C语言中fcntl文件锁未按预期工作的技术咨询

Hey there! Let's figure out why your fcntl() file locking isn't playing nice with your multi-process setup for modifying original.txt. I’ve tackled similar head-scratchers before, so let’s break this down step by step.

1. You’re Using the Wrong Lock Type or Scope #

fcntl()’s record locking is powerful, but it’s easy to misconfigure:

• Shared vs. Exclusive Locks: If you’re using F_RDLCK (shared read lock) instead of F_WRLCK (exclusive write lock), multiple processes can still write to the file at the same time. Always use an exclusive lock when modifying file content.
• Lock Duration: Make sure you hold the lock for the entire duration of your file operation—from opening the file, modifying its content, to closing it. If you unlock too early (like right after opening), processes will still clash.

2. File Opening Mistakes Are Breaking the Lock Context #

The way you open the file matters a lot for locking to work:

• Avoid O_TRUNC on Open: Using O_TRUNC to truncate the file when opening can invalidate the lock before you even start modifying. Instead, open with O_RDWR (read-write mode) and truncate only after you’ve locked the file and read its content.
• Lock After Opening: Locks are tied to file descriptors, so always open the file first, then apply the lock. Locking before opening does nothing—each process gets its own file descriptor, so the lock won’t carry over.

3. You’re Not Handling Lock Wait/Errors Correctly #

When calling fcntl(), if you use F_SETLK, it will immediately return an error (EAGAIN/EACCES) if the lock is held by another process. If your code doesn’t check this return value, it’ll just skip locking and proceed to modify the file—leading to race conditions.

• Use F_SETLKW (the "W" stands for wait) instead: This makes the process block until the lock is available, ensuring only one process modifies the file at a time.
• Always check the return code of fcntl()—don’t assume the lock succeeded!

4. Working Example Code (C Language) #

Here’s a simplified implementation that fixes these issues. Each process can call this to delete its target line safely:

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define TARGET_FILE "original.txt"

// Acquire exclusive write lock on the file
int acquire_exclusive_lock(int fd) {
    struct flock lock;
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0; // Lock entire file
    lock.l_pid = getpid();

    // Wait until lock is available
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        perror("Failed to acquire lock");
        return -1;
    }
    return 0;
}

// Release the lock
int release_lock(int fd) {
    struct flock lock;
    lock.l_type = F_UNLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;
    lock.l_pid = getpid();

    if (fcntl(fd, F_UNLCK, &lock) == -1) {
        perror("Failed to release lock");
        return -1;
    }
    return 0;
}

// Delete specified line from the file
void delete_target_line(const char *target_line) {
    // Open file in read-write mode
    int fd = open(TARGET_FILE, O_RDWR);
    if (fd == -1) {
        perror("Failed to open file");
        return;
    }

    // Lock before doing any modifications
    if (acquire_exclusive_lock(fd) == -1) {
        close(fd);
        return;
    }

    // Read entire file content into buffer
    char file_buffer[1024];
    ssize_t bytes_read = read(fd, file_buffer, sizeof(file_buffer) - 1);
    if (bytes_read == -1) {
        perror("Failed to read file");
        goto cleanup;
    }
    file_buffer[bytes_read] = '\0';

    // Build new content excluding the target line
    char *new_content = malloc(bytes_read + 1);
    if (!new_content) {
        perror("Failed to allocate memory");
        goto cleanup;
    }
    new_content[0] = '\0';

    char *current_line = strtok(file_buffer, "\n");
    while (current_line != NULL) {
        if (strcmp(current_line, target_line) != 0) {
            strcat(new_content, current_line);
            strcat(new_content, "\n");
        }
        current_line = strtok(NULL, "\n");
    }

    // Rewind file, truncate, and write new content
    lseek(fd, 0, SEEK_SET);
    if (ftruncate(fd, 0) == -1) {
        perror("Failed to truncate file");
        free(new_content);
        goto cleanup;
    }

    ssize_t bytes_written = write(fd, new_content, strlen(new_content));
    if (bytes_written == -1) {
        perror("Failed to write new content");
    }

    free(new_content);
cleanup:
    release_lock(fd);
    close(fd);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <line-to-delete>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    delete_target_line(argv[1]);
    return EXIT_SUCCESS;
}

5. Extra Tips to Avoid Lock Issues #

• Lock is tied to file descriptors: If you fork a process, the child inherits the file descriptor and the lock. But the lock only releases when all file descriptors pointing to the file are closed in all processes.
• NFS Caveats: fcntl() locks work on local filesystems, but they’re not reliable on network filesystems like NFS. If you’re using NFS, you’ll need a different locking mechanism.
• Test Concurrent Scenarios: Spin up multiple processes at once (e.g., for i in {1..3}; do ./delete_process "show core status" & done) to verify that the lock prevents race conditions.

内容的提问来源于stack exchange，提问作者vivek