Embedded Linux: File Sharing

1. Multi-threading Large Files: File sharing can be used to enable multiple threads to operate on the same large file simultaneously. By creating multiple different file descriptors, each thread can read or write to the file in parallel, reducing file read/write times and improving overall efficiency.

2. Increased Concurrency: File sharing provides a mechanism that allows multiple processes or threads to concurrently access the same file. This is beneficial for applications that frequently access files, enabling better utilization of system resources, and improving concurrency and responsiveness.

3. File Descriptor Duplication: By calling the open function multiple times or using the dup() and dup2() functions, multiple different file descriptors can be created that point to the same file. This provides independent file access channels for multiple concurrent operations, ensuring they do not interfere with each other.

4. Cooperative Operations: File sharing also involves mechanisms like file locking to ensure that operations on the file are conducted cooperatively during concurrent access. This helps avoid data inconsistencies and conflicts, improving program stability.

#include
#include
#include
int main(void) {
    // Open the same file to get file descriptors
    int fd1 = open("example.txt", O_RDONLY);
    int fd2 = open("example.txt", O_RDONLY);
    if (fd1 == -1 || fd2 == -1) {
        perror("Error opening file");
        return 1;
    }
    // Read file content
    char buffer1[100];
    char buffer2[100];
    ssize_t bytesRead1 = read(fd1, buffer1, sizeof(buffer1));
    ssize_t bytesRead2 = read(fd2, buffer2, sizeof(buffer2));
    // Output the read content
    printf("Content read from fd1: %.*s\n", (int)bytesRead1, buffer1);
    printf("Content read from fd2: %.*s\n", (int)bytesRead2, buffer2);
    // Close file descriptors
    close(fd1);
    close(fd2);
    return 0;
}

#include
#include
#include
#include
int main() {
    // File path
    const char *file_path = "example.txt";
    // Open the file in the first process
    int fd1 = open(file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd1 == -1) {
        perror("Error opening file in process 1");
        exit(EXIT_FAILURE);
    }
    // Write content to the file
    const char *content1 = "Hello from process 1\n";
    write(fd1, content1, strlen(content1));
    // Close file descriptor
    close(fd1);
    // Open the file in the second process
    int fd2 = open(file_path, O_WRONLY | O_APPEND);
    if (fd2 == -1) {
        perror("Error opening file in process 2");
        exit(EXIT_FAILURE);
    }
    // Write content to the file
    const char *content2 = "Hello from process 2\n";
    write(fd2, content2, strlen(content2));
    // Close file descriptor
    close(fd2);
    return 0;
}

#include
#include
#include
#include
int main() {
    // File path
    const char *file_path = "example.txt";
    // Open the file
    int fd1 = open(file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd1 == -1) {
        perror("Error opening file");
        exit(EXIT_FAILURE);
    }
    // Write content to the file
    const char *content = "Hello from process\n";
    write(fd1, content, strlen(content));
    // Duplicate file descriptor
    int fd2 = dup(fd1);
    if (fd2 == -1) {
        perror("Error duplicating file descriptor");
        close(fd1);
        exit(EXIT_FAILURE);
    }
    // Use original file descriptor to write content
    const char *content1 = "Original file descriptor\n";
    write(fd1, content1, strlen(content1));
    // Use duplicated file descriptor to write content
    const char *content2 = "Duplicated file descriptor\n";
    write(fd2, content2, strlen(content2));
    // Close file descriptors
    close(fd1);
    close(fd2);
    return 0;
}