File operations in C extend far beyond simple reading and writing. From low-level system calls to advanced buffering techniques, from file locking to asynchronous I/O, mastering advanced file operations is essential for building robust, high-performance systems. This comprehensive guide explores the sophisticated techniques that separate professional systems programmers from beginners.
Understanding the File I/O Stack
┌─────────────────────────────────────┐ │ User Application │ ├─────────────────────────────────────┤ │ Standard C Library (stdio) │ ← fopen(), fread(), fprintf() ├─────────────────────────────────────┤ │ System Call Layer │ ← open(), read(), write() ├─────────────────────────────────────┤ │ Virtual File System │ ├─────────────────────────────────────┤ │ Filesystem Driver │ ← ext4, XFS, etc. ├─────────────────────────────────────┤ │ Block Layer │ ├─────────────────────────────────────┤ │ Device Driver │ └─────────────────────────────────────┘
Low-Level File I/O (POSIX System Calls)
1. Basic System Calls
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
int main() {
// Open file
int fd = open("test.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
if (fd == -1) {
perror("open");
return 1;
}
// Write data
const char *data = "Hello, Advanced File Operations!\n";
ssize_t bytes_written = write(fd, data, strlen(data));
if (bytes_written == -1) {
perror("write");
close(fd);
return 1;
}
// Seek to beginning
off_t new_pos = lseek(fd, 0, SEEK_SET);
if (new_pos == -1) {
perror("lseek");
close(fd);
return 1;
}
// Read data
char buffer[256];
ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
if (bytes_read == -1) {
perror("read");
close(fd);
return 1;
}
buffer[bytes_read] = '\0';
printf("Read: %s", buffer);
// Close file
close(fd);
return 0;
}
2. Advanced open() Flags
void demonstrate_open_flags() {
// O_CLOEXEC: Close on exec
int fd1 = open("file1.txt", O_RDONLY | O_CLOEXEC);
// O_DIRECT: Bypass page cache (direct I/O)
int fd2 = open("file2.txt", O_RDWR | O_DIRECT | O_SYNC);
// O_NOATIME: Don't update access time
int fd3 = open("file3.txt", O_RDONLY | O_NOATIME);
// O_SYNC: Synchronous writes
int fd4 = open("file4.txt", O_WRONLY | O_CREAT | O_SYNC, 0644);
// O_DSYNC: Synchronous data writes (metadata may be async)
int fd5 = open("file5.txt", O_WRONLY | O_DSYNC);
// O_DIRECTORY: Fail if not a directory
int fd6 = open("mydir", O_RDONLY | O_DIRECTORY);
// O_NOFOLLOW: Don't follow symlinks
int fd7 = open("symlink.txt", O_RDONLY | O_NOFOLLOW);
close(fd1);
close(fd2);
close(fd3);
close(fd4);
close(fd5);
close(fd6);
close(fd7);
}
Advanced File Descriptor Operations
1. File Descriptor Duplication
#include <unistd.h>
#include <fcntl.h>
void demonstrate_fd_duplication() {
int fd = open("data.txt", O_RDWR);
// dup() - create copy of file descriptor
int fd_copy = dup(fd);
// dup2() - duplicate to specific descriptor
int new_fd = dup2(fd, 100); // Create copy at fd 100
// Both descriptors share the same file offset and flags
write(fd, "Through original", 16);
write(fd_copy, "Through copy", 12);
// Close copies
close(fd_copy);
close(fd);
}
// Redirect stdout to a file
void redirect_stdout(const char *filename) {
int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1) return;
// Save original stdout
int saved_stdout = dup(STDOUT_FILENO);
// Redirect stdout to file
dup2(fd, STDOUT_FILENO);
// Now all printf will go to the file
printf("This goes to the file!\n");
fflush(stdout);
// Restore stdout
dup2(saved_stdout, STDOUT_FILENO);
// Clean up
close(fd);
close(saved_stdout);
}
2. File Descriptor Flags and Status
#include <fcntl.h>
void demonstrate_fcntl_operations(int fd) {
// Get file descriptor flags
int flags = fcntl(fd, F_GETFD);
if (flags == -1) {
perror("fcntl F_GETFD");
return;
}
// Set FD_CLOEXEC flag
flags |= FD_CLOEXEC;
if (fcntl(fd, F_SETFD, flags) == -1) {
perror("fcntl F_SETFD");
return;
}
// Get file status flags
int status = fcntl(fd, F_GETFL);
if (status == -1) {
perror("fcntl F_GETFL");
return;
}
// Add O_APPEND flag
status |= O_APPEND;
if (fcntl(fd, F_SETFL, status) == -1) {
perror("fcntl F_SETFL");
return;
}
// Check if file is non-blocking
if (status & O_NONBLOCK) {
printf("File is in non-blocking mode\n");
}
// Get file owner (for signals)
int owner = fcntl(fd, F_GETOWN);
printf("File owner: %d\n", owner);
// Set file owner
fcntl(fd, F_SETOWN, getpid());
}
Advanced Buffer Management
1. Setting Buffer Sizes
#include <stdio.h>
void demonstrate_buffer_management() {
FILE *fp = fopen("large_file.bin", "wb");
if (!fp) return;
// Set custom buffer size (must be called before any I/O)
char *buffer = malloc(65536); // 64KB buffer
setvbuf(fp, buffer, _IOFBF, 65536);
// Write data (will use custom buffer)
for (int i = 0; i < 1000000; i++) {
fprintf(fp, "%d\n", i);
}
// Flush buffer
fflush(fp);
fclose(fp);
free(buffer);
}
// Line buffering for interactive programs
void setup_line_buffering() {
// Make stdout line-buffered
setvbuf(stdout, NULL, _IOLBF, 0);
// Make stderr unbuffered (immediate output)
setvbuf(stderr, NULL, _IONBF, 0);
printf("This will appear immediately\n");
fprintf(stderr, "This appears immediately too\n");
}
2. Direct I/O (Bypassing Page Cache)
#include <sys/stat.h>
// Must be aligned to block size for O_DIRECT
void* aligned_alloc_for_direct_io(size_t size) {
long page_size = sysconf(_SC_PAGESIZE);
void *ptr;
posix_memalign(&ptr, page_size, size);
return ptr;
}
void direct_io_write(const char *filename, const void *data, size_t size) {
int fd = open(filename, O_WRONLY | O_CREAT | O_DIRECT | O_SYNC, 0644);
if (fd == -1) {
perror("open with O_DIRECT");
return;
}
// Must use aligned buffer
void *aligned = aligned_alloc_for_direct_io(size);
memcpy(aligned, data, size);
ssize_t written = write(fd, aligned, size);
if (written == -1) {
perror("write (O_DIRECT)");
}
free(aligned);
close(fd);
}
File Locking and Synchronization
1. Record Locking (fcntl)
#include <fcntl.h>
// Exclusive lock
int lock_file_exclusive(int fd, off_t start, off_t len) {
struct flock fl = {
.l_type = F_WRLCK, // Exclusive lock
.l_whence = SEEK_SET,
.l_start = start,
.l_len = len,
.l_pid = 0
};
return fcntl(fd, F_SETLKW, &fl); // Blocking lock
}
// Shared lock (read lock)
int lock_file_shared(int fd, off_t start, off_t len) {
struct flock fl = {
.l_type = F_RDLCK, // Shared lock
.l_whence = SEEK_SET,
.l_start = start,
.l_len = len,
.l_pid = 0
};
return fcntl(fd, F_SETLKW, &fl);
}
// Try lock (non-blocking)
int try_lock_file(int fd, off_t start, off_t len) {
struct flock fl = {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
.l_start = start,
.l_len = len,
.l_pid = 0
};
if (fcntl(fd, F_SETLK, &fl) == -1) {
if (errno == EACCES || errno == EAGAIN) {
return 0; // Lock is held by another process
}
return -1; // Other error
}
return 1; // Lock acquired
}
// Unlock file
int unlock_file(int fd, off_t start, off_t len) {
struct flock fl = {
.l_type = F_UNLCK,
.l_whence = SEEK_SET,
.l_start = start,
.l_len = len,
.l_pid = 0
};
return fcntl(fd, F_SETLK, &fl);
}
// Complete example: Database record locking
typedef struct {
int id;
char name[50];
double balance;
} Account;
int update_account(const char *filename, int account_id, double new_balance) {
int fd = open(filename, O_RDWR);
if (fd == -1) return -1;
off_t offset = account_id * sizeof(Account);
// Lock the specific record
struct flock fl = {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
.l_start = offset,
.l_len = sizeof(Account),
.l_pid = 0
};
if (fcntl(fd, F_SETLKW, &fl) == -1) {
close(fd);
return -1;
}
// Read, modify, write
Account acc;
lseek(fd, offset, SEEK_SET);
if (read(fd, &acc, sizeof(Account)) != sizeof(Account)) {
unlock_file(fd, offset, sizeof(Account));
close(fd);
return -1;
}
acc.balance = new_balance;
lseek(fd, offset, SEEK_SET);
write(fd, &acc, sizeof(Account));
// Unlock
unlock_file(fd, offset, sizeof(Account));
close(fd);
return 0;
}
2. Advisory vs Mandatory Locking
void setup_mandatory_locking(const char *filename) {
struct stat st;
stat(filename, &st);
// Set setgid bit to enable mandatory locking
chmod(filename, st.st_mode | S_ISGID);
// Remove group execute permission
chmod(filename, st.st_mode & ~S_IXGRP);
}
Scatter-Gather I/O (readv/writev)
#include <sys/uio.h>
void scatter_gather_example() {
int fd = open("data.txt", O_RDWR | O_CREAT, 0644);
if (fd == -1) return;
// Prepare multiple buffers for writing
struct iovec iov[3];
char *part1 = "Hello, ";
char *part2 = "scatter-gather ";
char *part3 = "I/O!\n";
iov[0].iov_base = part1;
iov[0].iov_len = strlen(part1);
iov[1].iov_base = part2;
iov[1].iov_len = strlen(part2);
iov[2].iov_base = part3;
iov[2].iov_len = strlen(part3);
// Write all buffers in one system call
ssize_t written = writev(fd, iov, 3);
printf("Wrote %zd bytes\n", written);
// Read scattered data
lseek(fd, 0, SEEK_SET);
char buffer1[10], buffer2[20], buffer3[10];
struct iovec read_iov[3];
read_iov[0].iov_base = buffer1;
read_iov[0].iov_len = sizeof(buffer1);
read_iov[1].iov_base = buffer2;
read_iov[1].iov_len = sizeof(buffer2);
read_iov[2].iov_base = buffer3;
read_iov[2].iov_len = sizeof(buffer3);
ssize_t read_bytes = readv(fd, read_iov, 3);
printf("Read %zd bytes\n", read_bytes);
printf("Buffer1: %.*s\n", (int)read_iov[0].iov_len, buffer1);
printf("Buffer2: %.*s\n", (int)read_iov[1].iov_len, buffer2);
printf("Buffer3: %.*s\n", (int)read_iov[2].iov_len, buffer3);
close(fd);
}
Asynchronous I/O (AIO)
1. POSIX AIO Basics
#include <aio.h>
#include <signal.h>
#define AIO_BUFFER_SIZE 4096
typedef struct {
int fd;
char buffer[AIO_BUFFER_SIZE];
struct aiocb aio_cb;
} AsyncIOContext;
void aio_completion_handler(sigval_t sigval) {
AsyncIOContext *ctx = (AsyncIOContext*)sigval.sival_ptr;
// Get completion status
int ret = aio_error(&ctx->aio_cb);
if (ret == 0) {
ssize_t bytes = aio_return(&ctx->aio_cb);
printf("AIO completed: %zd bytes\n", bytes);
printf("Data: %.*s\n", (int)bytes, ctx->buffer);
} else {
printf("AIO error: %d\n", ret);
}
close(ctx->fd);
free(ctx);
}
void async_read_example(const char *filename) {
int fd = open(filename, O_RDONLY);
if (fd == -1) return;
AsyncIOContext *ctx = malloc(sizeof(AsyncIOContext));
ctx->fd = fd;
// Setup AIO control block
memset(&ctx->aio_cb, 0, sizeof(struct aiocb));
ctx->aio_cb.aio_fildes = fd;
ctx->aio_cb.aio_buf = ctx->buffer;
ctx->aio_cb.aio_nbytes = AIO_BUFFER_SIZE;
ctx->aio_cb.aio_offset = 0;
// Setup notification (signal or callback)
ctx->aio_cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
ctx->aio_cb.aio_sigevent.sigev_notify_function = aio_completion_handler;
ctx->aio_cb.aio_sigevent.sigev_value.sival_ptr = ctx;
// Start asynchronous read
if (aio_read(&ctx->aio_cb) == -1) {
perror("aio_read");
free(ctx);
close(fd);
return;
}
printf("Async read initiated. Continuing with other work...\n");
// Continue with other work while I/O happens
for (int i = 0; i < 5; i++) {
printf("Doing other work... %d\n", i);
sleep(1);
}
}
2. Multiple AIO Operations
#define MAX_AIO_REQUESTS 10
void wait_for_aio_completion(struct aiocb *cb_list[], int count) {
int ret;
int complete = 0;
while (complete < count) {
ret = aio_suspend((const struct aiocb **)cb_list, count, NULL);
if (ret == -1) {
perror("aio_suspend");
break;
}
complete = 0;
for (int i = 0; i < count; i++) {
if (aio_error(cb_list[i]) != EINPROGRESS) {
complete++;
}
}
}
}
void multiple_async_reads(const char **filenames, int count) {
struct aiocb *cb_list[MAX_AIO_REQUESTS];
int fds[MAX_AIO_REQUESTS];
char *buffers[MAX_AIO_REQUESTS];
for (int i = 0; i < count; i++) {
fds[i] = open(filenames[i], O_RDONLY);
if (fds[i] == -1) continue;
buffers[i] = malloc(4096);
cb_list[i] = malloc(sizeof(struct aiocb));
memset(cb_list[i], 0, sizeof(struct aiocb));
cb_list[i]->aio_fildes = fds[i];
cb_list[i]->aio_buf = buffers[i];
cb_list[i]->aio_nbytes = 4096;
cb_list[i]->aio_offset = 0;
if (aio_read(cb_list[i]) == -1) {
perror("aio_read");
}
}
// Wait for all reads to complete
wait_for_aio_completion(cb_list, count);
// Process results
for (int i = 0; i < count; i++) {
if (cb_list[i]) {
ssize_t bytes = aio_return(cb_list[i]);
printf("File %s: %zd bytes\n", filenames[i], bytes);
free(buffers[i]);
close(fds[i]);
free(cb_list[i]);
}
}
}
Memory-Mapped I/O (Extended)
#include <sys/mman.h>
typedef struct {
void *data;
size_t size;
int fd;
} MappedFile;
MappedFile* map_file_readonly(const char *filename) {
int fd = open(filename, O_RDONLY);
if (fd == -1) return NULL;
struct stat st;
if (fstat(fd, &st) == -1) {
close(fd);
return NULL;
}
void *data = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (data == MAP_FAILED) {
close(fd);
return NULL;
}
MappedFile *mf = malloc(sizeof(MappedFile));
mf->data = data;
mf->size = st.st_size;
mf->fd = fd;
return mf;
}
void unmap_file(MappedFile *mf) {
if (mf) {
munmap(mf->data, mf->size);
close(mf->fd);
free(mf);
}
}
// Create a growable memory-mapped file
typedef struct {
void *data;
size_t size;
size_t capacity;
int fd;
const char *filename;
} GrowableMappedFile;
GrowableMappedFile* create_growable_mapped_file(const char *filename, size_t initial_size) {
int fd = open(filename, O_RDWR | O_CREAT, 0644);
if (fd == -1) return NULL;
// Set initial size
ftruncate(fd, initial_size);
void *data = mmap(NULL, initial_size, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
close(fd);
return NULL;
}
GrowableMappedFile *gmf = malloc(sizeof(GrowableMappedFile));
gmf->data = data;
gmf->size = initial_size;
gmf->capacity = initial_size;
gmf->fd = fd;
gmf->filename = strdup(filename);
return gmf;
}
int grow_mapped_file(GrowableMappedFile *gmf, size_t new_size) {
if (new_size <= gmf->capacity) {
gmf->size = new_size;
return 0;
}
// Remap to larger size
ftruncate(gmf->fd, new_size);
void *new_data = mremap(gmf->data, gmf->capacity, new_size, MREMAP_MAYMOVE);
if (new_data == MAP_FAILED) {
return -1;
}
gmf->data = new_data;
gmf->capacity = new_size;
gmf->size = new_size;
return 0;
}
void destroy_growable_mapped_file(GrowableMappedFile *gmf) {
if (gmf) {
munmap(gmf->data, gmf->capacity);
close(gmf->fd);
free((void*)gmf->filename);
free(gmf);
}
}
Sparse Files
#include <sys/stat.h>
void create_sparse_file(const char *filename, off_t size) {
int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1) return;
// Write at the end to create a hole
lseek(fd, size - 1, SEEK_SET);
write(fd, "", 1);
close(fd);
// Check if file is sparse
struct stat st;
stat(filename, &st);
printf("File size: %ld, Blocks used: %ld\n", st.st_size, st.st_blocks);
}
void find_holes(const char *filename) {
int fd = open(filename, O_RDONLY);
if (fd == -1) return;
off_t offset = 0;
off_t hole_start, data_start;
while (1) {
// Find next data extent
hole_start = lseek(fd, offset, SEEK_HOLE);
if (hole_start == -1) break;
// Find end of data
data_start = lseek(fd, hole_start, SEEK_DATA);
if (data_start == -1) {
printf("Hole from %ld to end\n", hole_start);
break;
}
printf("Data from %ld to %ld\n", hole_start, data_start);
offset = data_start;
}
close(fd);
}
File Change Notification (inotify)
#include <sys/inotify.h>
#include <limits.h>
void watch_directory(const char *path) {
int fd = inotify_init1(IN_NONBLOCK);
if (fd == -1) {
perror("inotify_init");
return;
}
int wd = inotify_add_watch(fd, path,
IN_CREATE | IN_DELETE | IN_MODIFY | IN_MOVED_FROM | IN_MOVED_TO);
if (wd == -1) {
perror("inotify_add_watch");
close(fd);
return;
}
printf("Watching: %s\n", path);
char buffer[4096];
struct inotify_event *event;
while (1) {
ssize_t len = read(fd, buffer, sizeof(buffer));
if (len == -1 && errno == EAGAIN) {
usleep(100000);
continue;
}
for (char *ptr = buffer; ptr < buffer + len;
ptr += sizeof(struct inotify_event) + event->len) {
event = (struct inotify_event*)ptr;
if (event->mask & IN_CREATE)
printf("Created: %s\n", event->name);
if (event->mask & IN_DELETE)
printf("Deleted: %s\n", event->name);
if (event->mask & IN_MODIFY)
printf("Modified: %s\n", event->name);
if (event->mask & IN_MOVED_FROM)
printf("Moved from: %s\n", event->name);
if (event->mask & IN_MOVED_TO)
printf("Moved to: %s\n", event->name);
}
}
inotify_rm_watch(fd, wd);
close(fd);
}
Advanced File Descriptor Operations (splice, sendfile)
#include <fcntl.h>
// Zero-copy file copy using sendfile
int zero_copy_copy(const char *src, const char *dst) {
int src_fd = open(src, O_RDONLY);
if (src_fd == -1) return -1;
int dst_fd = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (dst_fd == -1) {
close(src_fd);
return -1;
}
struct stat st;
fstat(src_fd, &st);
off_t offset = 0;
ssize_t bytes_copied = sendfile(dst_fd, src_fd, &offset, st.st_size);
close(src_fd);
close(dst_fd);
return bytes_copied;
}
// Pipe data between file descriptors
void pipe_between_fds(int in_fd, int out_fd, size_t count) {
int pipefd[2];
pipe(pipefd);
splice(in_fd, NULL, pipefd[1], NULL, count, SPLICE_F_MOVE);
splice(pipefd[0], NULL, out_fd, NULL, count, SPLICE_F_MOVE);
close(pipefd[0]);
close(pipefd[1]);
}
File Descriptor Limits and Resource Control
#include <sys/resource.h>
void check_and_set_fd_limits() {
struct rlimit rl;
// Get current limits
if (getrlimit(RLIMIT_NOFILE, &rl) == 0) {
printf("Soft limit: %ld, Hard limit: %ld\n", rl.rlim_cur, rl.rlim_max);
}
// Increase soft limit
rl.rlim_cur = 65536;
if (setrlimit(RLIMIT_NOFILE, &rl) == -1) {
perror("setrlimit");
}
// Get number of open file descriptors
int max_fd = sysconf(_SC_OPEN_MAX);
printf("Maximum open files: %d\n", max_fd);
}
// Safe FD closing utility
void close_all_fds_except(int *except_fds, int except_count) {
int max_fd = sysconf(_SC_OPEN_MAX);
for (int fd = 3; fd < max_fd; fd++) { // Skip stdin, stdout, stderr
int keep = 0;
for (int i = 0; i < except_count; i++) {
if (fd == except_fds[i]) {
keep = 1;
break;
}
}
if (!keep) {
close(fd);
}
}
}
Complete Example: High-Performance Logging System
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <time.h>
#include <sys/mman.h>
typedef struct {
int fd;
char *buffer;
size_t buffer_size;
size_t buffer_pos;
pthread_mutex_t mutex;
volatile int running;
pthread_t flush_thread;
const char *filename;
} AsyncLogger;
AsyncLogger* logger_create(const char *filename, size_t buffer_size) {
AsyncLogger *logger = malloc(sizeof(AsyncLogger));
logger->filename = strdup(filename);
logger->fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0644);
if (logger->fd == -1) {
free(logger);
return NULL;
}
logger->buffer_size = buffer_size;
logger->buffer = malloc(buffer_size);
logger->buffer_pos = 0;
logger->running = 1;
pthread_mutex_init(&logger->mutex, NULL);
return logger;
}
void logger_flush(AsyncLogger *logger) {
pthread_mutex_lock(&logger->mutex);
if (logger->buffer_pos > 0) {
write(logger->fd, logger->buffer, logger->buffer_pos);
logger->buffer_pos = 0;
}
pthread_mutex_unlock(&logger->mutex);
}
void* logger_flush_thread(void *arg) {
AsyncLogger *logger = (AsyncLogger*)arg;
while (logger->running) {
sleep(1); // Flush every second
logger_flush(logger);
}
// Final flush
logger_flush(logger);
return NULL;
}
void logger_log(AsyncLogger *logger, const char *format, ...) {
pthread_mutex_lock(&logger->mutex);
// Format message
va_list args;
va_start(args, format);
int needed = vsnprintf(NULL, 0, format, args);
va_end(args);
va_start(args, format);
if (logger->buffer_pos + needed + 1 >= logger->buffer_size) {
// Buffer full, flush first
write(logger->fd, logger->buffer, logger->buffer_pos);
logger->buffer_pos = 0;
}
logger->buffer_pos += vsnprintf(logger->buffer + logger->buffer_pos,
logger->buffer_size - logger->buffer_pos,
format, args);
va_end(args);
// Add newline if not present
if (logger->buffer[logger->buffer_pos - 1] != '\n') {
logger->buffer[logger->buffer_pos++] = '\n';
}
pthread_mutex_unlock(&logger->mutex);
}
void logger_destroy(AsyncLogger *logger) {
logger->running = 0;
pthread_join(logger->flush_thread, NULL);
logger_flush(logger);
close(logger->fd);
free(logger->buffer);
free((void*)logger->filename);
pthread_mutex_destroy(&logger->mutex);
free(logger);
}
Best Practices Summary
- Always check return values: System calls can fail
- Use O_CLOEXEC: Prevent file descriptor leaks across exec()
- Set appropriate buffer sizes: Balance memory vs performance
- Use fsync/fdatasync: Ensure data durability when needed
- Handle EINTR: Restart system calls if interrupted
- Use O_DIRECT with caution: Requires aligned buffers
- Implement proper locking: For concurrent access
- Close file descriptors: Prevent resource leaks
- Use sendfile/splice: For zero-copy operations
- Monitor file descriptor limits: Prevent resource exhaustion
Conclusion
Advanced file operations in C provide the foundation for building high-performance, reliable systems. By mastering low-level system calls, buffering strategies, asynchronous I/O, and synchronization techniques, you can create applications that efficiently handle large volumes of data while maintaining data integrity and system responsiveness.
The techniques covered in this guide—from direct I/O and memory mapping to asynchronous operations and file change monitoring—represent the essential toolkit for systems programmers working with files at scale. Understanding when and how to apply these advanced features separates robust production systems from basic prototypes.