7a:Te2b,#include #include #include #include #include #include #include /** * Creates a FIFO with comprehensive error handling. * * This function demonstrates production-quality FIFO creation, * handling all common error cases appropriately. * * @param fifo_path Path for the new FIFO * @param mode Permission bits (e.g., 0666) * @return 0 on success, -1 on failure */ int create_fifo_robust(const char *fifo_path, mode_t mode) { // Attempt to create the FIFO if (mkfifo(fifo_path, mode) == 0) { printf("FIFO created successfully: %s ", fifo_path); return 0; } // Handle specific error cases switch (errno) { case EEXIST: // FIFO or file already exists at this path // Check if it's actually a FIFO we can use struct stat st; if (stat(fifo_path, &st) == 0 && S_ISFIFO(st.st_mode)) { printf("FIFO already exists, reusing: %s ", fifo_path); return 0; // Existing FIFO is acceptable } fprintf(stderr, "Error: Path exists but is not a FIFO: %s ", fifo_path); return -1; case ENOENT: // A directory component doesn't exist fprintf(stderr, "Error: Parent directory does not exist: %s ", fifo_path); return -1; case EACCES: // Permission denied on parent directory fprintf(stderr, "Error: Permission denied creating FIFO: %s ", fifo_path); return -1; case EROFS: // Filesystem is read-only fprintf(stderr, "Error: Filesystem is read-only: %s ", fifo_path); return -1; case ENOSPC: // No space left on device fprintf(stderr, "Error: No space left on device: %s ", fifo_path); return -1; case ENAMETOOLONG: // Pathname too long fprintf(stderr, "Error: Pathname too long: %s ", fifo_path); return -1; default: // Generic error handling fprintf(stderr, "Error creating FIFO '%s': %s ", fifo_path, strerror(errno)); return -1; } } /** * Demonstrates FIFO creation with cleanup registration. * Uses atexit() to ensure cleanup on normal program exit. */ static const char *cleanup_fifo_path = NULL; void cleanup_fifo(void) { if (cleanup_fifo_path != NULL) { unlink(cleanup_fifo_path); printf("Cleaned up FIFO: %s ", cleanup_fifo_path); } } int main(int argc, char *argv[]) { const char *fifo_path = "/tmp/example_fifo"; mode_t fifo_mode = 0666; // rw-rw-rw- (modified by umask) // Register cleanup handler cleanup_fifo_path = fifo_path; atexit(cleanup_fifo); // Create the FIFO if (create_fifo_robust(fifo_path, fifo_mode) != 0) { return EXIT_FAILURE; } // Verify creation by examining file type struct stat st; if (stat(fifo_path, &st) == 0) { printf("File type: %s ", S_ISFIFO(st.st_mode) ? "FIFO (named pipe)" : "Other"); printf("Permissions: %o ", st.st_mode & 0777); printf("Owner UID: %d ", st.st_uid); printf("Group GID: %d ", st.st_gid); } printf("FIFO ready for use. Press Enter to cleanup and exit... "); getchar(); return EXIT_SUCCESS; }7b:T701,#include #include #include #include #include #include #include /** * Creates a FIFO using mknod() directly. * This demonstrates the underlying system call that mkfifo() wraps. */ int create_fifo_with_mknod(const char *path, mode_t mode) { // S_IFIFO = 0010000 in octal (FIFO special file type) // We OR this with the permission bits to create the full mode mode_t full_mode = S_IFIFO | (mode & 0777); // dev parameter is ignored for FIFOs (no device backing) if (mknod(path, full_mode, 0) == -1) { fprintf(stderr, "mknod failed: %s ", strerror(errno)); return -1; } printf("FIFO created via mknod(): %s ", path); return 0; } /** * Compares mkfifo() and mknod() for FIFO creation. */ int main(void) { const char *path_mkfifo = "/tmp/fifo_via_mkfifo"; const char *path_mknod = "/tmp/fifo_via_mknod"; // Clean up any previous runs unlink(path_mkfifo); unlink(path_mknod); // Create using mkfifo() printf("Creating FIFO using mkfifo()... "); if (mkfifo(path_mkfifo, 0666) == -1) { perror("mkfifo"); } // Create using mknod() printf("Creating FIFO using mknod()... "); if (create_fifo_with_mknod(path_mknod, 0666) == -1) { perror("mknod"); } // Verify both are FIFOs struct stat st1, st2; stat(path_mkfifo, &st1); stat(path_mknod, &st2); printf(" Verification: "); printf("%s is FIFO: %s ", path_mkfifo, S_ISFIFO(st1.st_mode) ? "yes" : "no"); printf("%s is FIFO: %s ", path_mknod, S_ISFIFO(st2.st_mode) ? "yes" : "no"); // Cleanup unlink(path_mkfifo); unlink(path_mknod); return 0; }7c:Tea5,#include #include #include #include #include #include #include /** * Demonstrates various FIFO permission patterns for different use cases. */ void demonstrate_permission_patterns(void) { // Pattern 1: World-accessible FIFO (least secure) // Typical for simple examples, NOT for production printf("Pattern 1: World-accessible (0666) "); unlink("/tmp/fifo_world"); if (mkfifo("/tmp/fifo_world", 0666) == 0) { system("ls -l /tmp/fifo_world"); } // Pattern 2: Owner-only FIFO (most secure) // Good for single-user applications printf(" Pattern 2: Owner-only (0600) "); unlink("/tmp/fifo_private"); if (mkfifo("/tmp/fifo_private", 0600) == 0) { system("ls -l /tmp/fifo_private"); } // Pattern 3: Group-shared FIFO // Useful for service communication within same group printf(" Pattern 3: Group-shared (0660) "); unlink("/tmp/fifo_group"); if (mkfifo("/tmp/fifo_group", 0660) == 0) { system("ls -l /tmp/fifo_group"); } // Pattern 4: Write-only to others // Good for logging: others can write, only owner can read printf(" Pattern 4: Public write, owner read (0622) "); unlink("/tmp/fifo_logger"); if (mkfifo("/tmp/fifo_logger", 0622) == 0) { system("ls -l /tmp/fifo_logger"); } // Cleanup unlink("/tmp/fifo_world"); unlink("/tmp/fifo_private"); unlink("/tmp/fifo_group"); unlink("/tmp/fifo_logger"); } /** * Shows how umask affects FIFO permissions. */ void demonstrate_umask_effect(void) { printf(" === Umask Effects === "); // Get current umask mode_t old_umask = umask(0); umask(old_umask); // Restore printf("Current umask: %04o ", old_umask); // Create FIFO with current umask unlink("/tmp/fifo_umask_test"); mkfifo("/tmp/fifo_umask_test", 0666); struct stat st; stat("/tmp/fifo_umask_test", &st); printf("Requested: 0666, Actual: %04o ", st.st_mode & 0777); printf("Expected: %04o (0666 & ~umask) ", 0666 & ~old_umask); // Create with different umask umask(0077); // Very restrictive unlink("/tmp/fifo_umask_test2"); mkfifo("/tmp/fifo_umask_test2", 0666); stat("/tmp/fifo_umask_test2", &st); printf(" With umask 0077: "); printf("Requested: 0666, Actual: %04o ", st.st_mode & 0777); // Restore original umask umask(old_umask); // Cleanup unlink("/tmp/fifo_umask_test"); unlink("/tmp/fifo_umask_test2"); } /** * Changes FIFO ownership (requires appropriate privileges). */ void demonstrate_ownership_change(void) { printf(" === Ownership Changes === "); unlink("/tmp/fifo_chown"); if (mkfifo("/tmp/fifo_chown", 0666) != 0) { perror("mkfifo"); return; } struct stat st; stat("/tmp/fifo_chown", &st); printf("Original owner: UID=%d, GID=%d ", st.st_uid, st.st_gid); // Change group (may require group membership or root) // This example shows the API; actual effect depends on privileges if (chown("/tmp/fifo_chown", -1, getgid()) == 0) { stat("/tmp/fifo_chown", &st); printf("After chown: UID=%d, GID=%d ", st.st_uid, st.st_gid); } else { printf("chown: %s (this is normal for non-root) ", strerror(errno)); } // Change permissions chmod("/tmp/fifo_chown", 0640); stat("/tmp/fifo_chown", &st); printf("After chmod 0640: mode=%04o ", st.st_mode & 0777); unlink("/tmp/fifo_chown"); } int main(void) { demonstrate_permission_patterns(); demonstrate_umask_effect(); demonstrate_ownership_change(); return 0; }7d:Tcd4,#include #include #include #include #include #include #include #include /** * Creates a FIFO in a secure, application-specific directory. * This pattern is recommended for production applications. */ int create_application_fifo(const char *app_name, const char *fifo_name, char *fifo_path_out, size_t path_size) { char dir_path[256]; // Strategy 1: Use XDG_RUNTIME_DIR if available (modern Linux) const char *runtime_dir = getenv("XDG_RUNTIME_DIR"); if (runtime_dir != NULL) { snprintf(dir_path, sizeof(dir_path), "%s/%s", runtime_dir, app_name); } else { // Fallback: Create in /tmp with unique directory per user struct passwd *pw = getpwuid(getuid()); if (pw == NULL) { perror("getpwuid"); return -1; } snprintf(dir_path, sizeof(dir_path), "/tmp/%s-%s", app_name, pw->pw_name); } // Create the application directory if it doesn't exist if (mkdir(dir_path, 0700) == -1 && errno != EEXIST) { fprintf(stderr, "Failed to create directory %s: %s ", dir_path, strerror(errno)); return -1; } // Verify directory ownership (security check) struct stat st; if (stat(dir_path, &st) != 0 || st.st_uid != getuid()) { fprintf(stderr, "Security error: directory %s not owned by us ", dir_path); return -1; } // Build FIFO path snprintf(fifo_path_out, path_size, "%s/%s", dir_path, fifo_name); // Remove any existing FIFO (to handle stale FIFOs from crashed runs) unlink(fifo_path_out); // Create the FIFO with restrictive permissions if (mkfifo(fifo_path_out, 0600) == -1) { fprintf(stderr, "Failed to create FIFO %s: %s ", fifo_path_out, strerror(errno)); return -1; } printf("Created secure FIFO: %s ", fifo_path_out); return 0; } /** * Example usage: Multi-instance safe FIFO with PID suffix */ int create_instance_fifo(const char *base_name, char *fifo_path_out, size_t path_size) { // Include PID so multiple instances don't conflict snprintf(fifo_path_out, path_size, "/tmp/%s.%d.fifo", base_name, getpid()); unlink(fifo_path_out); if (mkfifo(fifo_path_out, 0600) == -1) { perror("mkfifo"); return -1; } printf("Created instance-specific FIFO: %s ", fifo_path_out); return 0; } int main(void) { char fifo_path[256]; printf("=== Production FIFO Placement === "); // Production pattern if (create_application_fifo("myapp", "control.fifo", fifo_path, sizeof(fifo_path)) == 0) { printf("Use this FIFO: %s ", fifo_path); unlink(fifo_path); // Cleanup demo } printf(" === Instance-Specific FIFO === "); // Multi-instance pattern if (create_instance_fifo("worker", fifo_path, sizeof(fifo_path)) == 0) { unlink(fifo_path); // Cleanup demo } return 0; }7e:Te69,#include #include #include #include #include #include #include // Global FIFO path for cleanup handlers static char g_fifo_path[256] = {0}; static volatile sig_atomic_t g_shutdown_requested = 0; /** * Signal handler for graceful shutdown. * Sets flag rather than doing cleanup directly (signal safety). */ void signal_handler(int signum) { g_shutdown_requested = 1; // Re-raise to get default behavior after cleanup signal(signum, SIG_DFL); } /** * atexit cleanup handler. * Called on normal exit() or return from main(). */ void cleanup_atexit(void) { if (g_fifo_path[0] != '\0') { if (unlink(g_fifo_path) == 0) { printf("Cleaned up FIFO (atexit): %s ", g_fifo_path); } } } /** * Perform cleanup from main loop when signal received. */ void perform_signal_cleanup(void) { if (g_fifo_path[0] != '\0') { if (unlink(g_fifo_path) == 0) { printf("Cleaned up FIFO (signal): %s ", g_fifo_path); } } } /** * Check if a stale FIFO exists and can be cleaned up. */ int cleanup_stale_fifo(const char *fifo_path, const char *pid_file_path) { struct stat st; // Check if FIFO exists if (stat(fifo_path, &st) != 0) { return 0; // Doesn't exist, nothing to clean } if (!S_ISFIFO(st.st_mode)) { fprintf(stderr, "Error: %s exists but is not a FIFO ", fifo_path); return -1; } // If we have a PID file, check if the process is still running if (pid_file_path != NULL) { FILE *pf = fopen(pid_file_path, "r"); if (pf != NULL) { int old_pid; if (fscanf(pf, "%d", &old_pid) == 1) { fclose(pf); // Check if process exists if (kill(old_pid, 0) == 0 || errno == EPERM) { // Process exists! Don't remove its FIFO fprintf(stderr, "Error: Another instance (PID %d) appears to be running ", old_pid); return -1; } } else { fclose(pf); } } } // Safe to remove stale FIFO if (unlink(fifo_path) == 0) { printf("Removed stale FIFO: %s ", fifo_path); } return 0; } /** * Complete FIFO setup with lifecycle management. */ int setup_fifo_with_lifecycle(const char *fifo_path) { // Copy path for cleanup handlers strncpy(g_fifo_path, fifo_path, sizeof(g_fifo_path) - 1); // Register atexit handler atexit(cleanup_atexit); // Register signal handlers struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = signal_handler; sigemptyset(&sa.sa_mask); sigaction(SIGTERM, &sa, NULL); sigaction(SIGINT, &sa, NULL); sigaction(SIGHUP, &sa, NULL); // Clean up any stale FIFO cleanup_stale_fifo(fifo_path, NULL); // Create the FIFO if (mkfifo(fifo_path, 0600) == -1) { perror("mkfifo"); return -1; } printf("FIFO created with lifecycle management: %s ", fifo_path); return 0; } int main(void) { const char *fifo_path = "/tmp/lifecycle_demo.fifo"; if (setup_fifo_with_lifecycle(fifo_path) != 0) { return EXIT_FAILURE; } printf(" FIFO is ready. Press Ctrl+C to demonstrate cleanup... "); // Main loop while (!g_shutdown_requested) { sleep(1); } // Signal was received, perform cleanup perform_signal_cleanup(); printf("Graceful shutdown complete. "); return EXIT_SUCCESS; }72:{"json":{"id":"seed_fdc1939854e932de2047275187982c58","slug":"named-pipes-fifos","category":"Operating Systems","topic":"Named Pipes (FIFOs)","title":"Named Pipes (FIFOs): Persistent Inter-Process Communication","description":"Master Named Pipes (FIFOs) for flexible inter-process communication. Learn FIFO creation, unrelated process communication, blocking semantics, limitations, and real-world use cases that leverage filesystem-based IPC.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_194adc33f833af9b752faff15e6f9cf2","title":"FIFO Creation: Building Named Pipes from the Ground Up","order":0,"content":[{"id":"opening-context","title":"From Anonymous Pipes to Named Pipes","content":[{"data":{"content":"In the previous module, we explored **anonymous pipes**—the fundamental IPC mechanism that allows parent and child processes to communicate through a unidirectional byte stream. While powerful for related processes, anonymous pipes have a critical limitation: they exist only in kernel memory, invisible to the filesystem, and **cannot be accessed by unrelated processes**.\n\n**Named Pipes**, also known as **FIFOs** (First-In, First-Out), solve this problem by creating a special file in the filesystem that multiple processes can open, regardless of their ancestry relationships. When you create a FIFO, you create a rendezvous point—a named channel that any process with appropriate permissions can use for communication.\n\nThis architectural shift from in-memory-only pipes to filesystem-visible pipes opens up entirely new patterns for process coordination, service communication, and system design."},"type":"text"},{"data":{"icon":"Target","title":"Learning Objectives","content":"By the end of this page, you will understand:\n\n• The fundamental difference between anonymous pipes and named pipes (FIFOs)\n• How to create FIFOs using both the `mkfifo` command and the `mkfifo()` system call\n• The kernel data structures and mechanisms underlying FIFO creation\n• Permission models and ownership semantics for FIFOs\n• Best practices for robust FIFO creation in production systems","variant":"info"},"type":"callout"}]},{"id":"understanding-named-pipes","title":"Understanding Named Pipes (FIFOs)","content":[{"data":{"content":"A **Named Pipe** (FIFO) is a special type of file that provides a communication channel between processes. Unlike regular files, data written to a FIFO does not persist on disk—it exists only in a kernel buffer until another process reads it. The name \"FIFO\" reflects its First-In, First-Out semantics: bytes are read in the same order they were written.\n\n**The key insight** is that a FIFO appears in the filesystem like any other file. It has a path, permissions, ownership, and can be listed with `ls`. But its behavior is fundamentally different from regular files:\n\n- **No persistent storage**: Data doesn't accumulate on disk\n- **Blocking I/O**: Reads and writes can block waiting for the other party\n- **Streaming semantics**: Data flows through, not stored then retrieved\n- **Process rendezvous**: Enables synchronization between unrelated processes"},"type":"text"},{"data":{"rows":[["Filesystem presence","None—exists only in kernel memory","Has a filesystem path (inode entry)"],["Creation mechanism","`pipe()` system call only","`mkfifo()` syscall or `mkfifo` command"],["Process relationship","Requires common ancestor (typically parent-child)","Any process with appropriate permissions"],["Persistence after creation","Destroyed when all file descriptors closed","File entry persists until explicitly deleted"],["Discovery mechanism","File descriptors inherited across fork()","Processes open the named path independently"],["Typical use case","Pipeline composition (shell `|`)","Client-server patterns, logging systems"],["Cleanup required","Automatic when processes exit","Explicit removal with `unlink()` or `rm`"]],"caption":"Anonymous Pipes vs Named Pipes (FIFOs)","headers":["Characteristic","Anonymous Pipe","Named Pipe (FIFO)"]},"type":"table"},{"data":{"icon":"Info","title":"The \"Special File\" Concept","content":"FIFOs belong to Unix's elegant abstraction of \"everything is a file.\" Along with devices (/dev/*), sockets, and symbolic links, FIFOs are **special files** that implement file operations (open, read, write, close) but with non-file-like behavior. When you `ls -l` a FIFO, you'll see 'p' as the first character of its permissions.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"mkfifo-command","title":"Creating FIFOs with the mkfifo Command","content":[{"data":{"content":"The simplest way to create a FIFO is using the `mkfifo` command from the shell. This is the standard utility for creating named pipes on Unix-like systems and is available on all POSIX-compliant operating systems.\n\n**Basic Syntax:**\n```bash\nmkfifo [OPTIONS] NAME...\n```\n\nThe command creates a FIFO with the specified name. If no mode (permissions) is specified, the default is `0666` (read/write for all), modified by the process's umask."},"type":"text"},{"data":{"fileName":"Creating and Inspecting FIFOs","languages":[{"code":"# Create a simple FIFO\nmkfifo my_pipe\n\n# Create a FIFO with explicit permissions (rw for owner only)\nmkfifo -m 600 secure_pipe\n\n# Create multiple FIFOs at once\nmkfifo pipe1 pipe2 pipe3\n\n# Create a FIFO in a specific directory\nmkfifo /tmp/my_application/request_pipe\n\n# Inspect the created FIFO\nls -l my_pipe\n# Output: prw-r--r-- 1 user group 0 Jan 16 10:30 my_pipe\n# ^ 'p' indicates this is a pipe (FIFO)\n\n# View file type using stat\nstat my_pipe\n# Output includes: File: my_pipe\n# Size: 0\n# Type: fifo\n\n# View file type using file command\nfile my_pipe\n# Output: my_pipe: fifo (named pipe)","label":"Shell Commands","value":"bash","language":"bash"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"**Understanding the `ls -l` output:**\n\nWhen you list a FIFO with `ls -l`, several fields reveal its nature:\n\n1. **Type indicator (`p`)**: The first character is 'p' for pipe—not 'd' (directory), '-' (regular file), or 'l' (symbolic link).\n\n2. **Permissions**: Standard Unix permissions apply. A process needs read permission to open for reading, write permission to open for writing.\n\n3. **Size (always 0)**: FIFOs report size as 0 because they don't store data—they're channels for data in transit.\n\n4. **Link count (typically 1)**: FIFOs can have hard links like regular files, though this is rarely useful.\n\n**Common Options:**"},"type":"text"},{"data":{"items":["**`-m, --mode=MODE`**: Set file permission bits to MODE, not `a=rw - umask`. MODE is specified in octal (like `600`) or symbolic (like `u=rw`) notation.","**`-Z`**: Set SELinux security context of each created FIFO to the default type.","**`--context[=CTX]`**: Set SELinux security context. If CTX is specified, use it; otherwise, use the default.","**`--help`**: Display help message and exit.","**`--version`**: Output version information and exit."],"title":{"icon":"ListIcon","text":"mkfifo Command Options","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"AlertCircle","title":"FIFO Creation Failure Conditions","content":"The `mkfifo` command will fail (return non-zero) if:\n\n• **Path already exists**: Unlike regular files, mkfifo won't overwrite existing files or FIFOs\n• **Permission denied**: No write permission on the parent directory\n• **Parent directory doesn't exist**: Must create parent directories first\n• **Filesystem doesn't support FIFOs**: Some filesystems (FAT, some network filesystems) don't support special files\n• **Disk quota exceeded**: If quotas are enforced on the filesystem","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"mkfifo-syscall","title":"Creating FIFOs Programmatically: The mkfifo() System Call","content":[{"data":{"content":"For applications that need to create FIFOs dynamically, the `mkfifo()` system call (actually a library function that wraps `mknod()`) provides programmatic FIFO creation.\n\n**Function Signature:**\n```c\n#include \n#include \n\nint mkfifo(const char *pathname, mode_t mode);\n```\n\n**Parameters:**\n- `pathname`: Path where the FIFO should be created\n- `mode`: Permission bits for the new FIFO (modified by umask)\n\n**Return Value:**\n- Returns `0` on success\n- Returns `-1` on failure, with `errno` set to indicate the error"},"type":"text"},{"data":{"fileName":"fifo_creation.c","languages":[{"code":"$7a","label":"C","value":"c","language":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"**Understanding the Code:**\n\nThis example demonstrates several important patterns:\n\n1. **Comprehensive error handling**: Each potential failure mode is handled specifically, providing meaningful error messages for debugging.\n\n2. **EEXIST handling**: A particularly common case—if the FIFO already exists and is usable, we treat this as success. This pattern enables idempotent service startup.\n\n3. **Cleanup registration**: Using `atexit()` ensures the FIFO is removed when the program exits normally. For robust cleanup, you'd also need signal handlers for abnormal termination.\n\n4. **Post-creation verification**: Using `stat()` with `S_ISFIFO()` macro confirms the created file is indeed a FIFO."},"type":"text"},{"data":{"icon":"Lightbulb","title":"The S_ISFIFO Macro","content":"The `S_ISFIFO(mode)` macro from `` tests whether a file's mode indicates it's a FIFO. Other useful macros include:\n\n• `S_ISREG(m)` — is it a regular file?\n• `S_ISDIR(m)` — is it a directory?\n• `S_ISCHR(m)` — is it a character device?\n• `S_ISBLK(m)` — is it a block device?\n• `S_ISLNK(m)` — is it a symbolic link?\n• `S_ISSOCK(m)` — is it a socket?","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"mknod-alternative","title":"The mknod() Alternative","content":[{"data":{"content":"The `mkfifo()` function is actually a convenience wrapper around the more general `mknod()` system call. Understanding `mknod()` provides deeper insight into how the kernel handles special file creation.\n\n**Function Signature:**\n```c\n#include \n#include \n#include \n#include \n\nint mknod(const char *pathname, mode_t mode, dev_t dev);\n```\n\n**Parameters:**\n- `pathname`: Path for the new special file\n- `mode`: Permission bits OR'ed with file type (e.g., `S_IFIFO | 0666`)\n- `dev`: Device number (ignored for FIFOs, used for device files)\n\n**How mkfifo() Uses mknod():**\n\nInternally, `mkfifo(path, mode)` is typically implemented as:\n```c\nmknod(path, (mode & ~S_IFMT) | S_IFIFO, 0)\n```\n\nThis masks off any file type bits in mode, OR's in `S_IFIFO` (the FIFO type indicator), and passes 0 for the device number."},"type":"text"},{"data":{"fileName":"mknod_fifo.c","languages":[{"code":"$7b","label":"C","value":"c","language":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"When to Use mknod() Directly","content":"While `mkfifo()` is preferred for creating FIFOs due to its clarity and portability, `mknod()` is occasionally used when:\n\n• Creating multiple types of special files in the same code path\n• Working with older systems where `mkfifo()` might not be available\n• Implementing low-level system utilities that need fine-grained control\n\nFor application code, always prefer `mkfifo()`—it's cleaner and more clearly expresses intent.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"kernel-internals","title":"Kernel Internals of FIFO Creation","content":[{"data":{"content":"Understanding what happens inside the kernel when a FIFO is created illuminates why FIFOs behave the way they do. When `mkfifo()` is called, a carefully orchestrated sequence of kernel operations occurs:\n\n**Step-by-Step FIFO Creation:**"},"type":"text"},{"data":{"type":"ordered","items":["**Path resolution**: The kernel's VFS (Virtual File System) layer parses the pathname, resolving any symbolic links and traversing directory entries to locate the parent directory.","**Permission check**: The kernel verifies that the calling process has write permission on the parent directory where the FIFO will be created.","**Inode allocation**: A new inode is allocated from the filesystem's inode pool. This inode will contain metadata about the FIFO (ownership, permissions, timestamps).","**File type setting**: The inode's mode field is set to indicate `S_IFIFO` (pipe/FIFO type), distinguishing it from regular files, directories, etc.","**Directory entry creation**: A new entry is added to the parent directory, mapping the FIFO's name to its inode number.","**No data block allocation**: Unlike regular files, no data blocks are allocated—FIFO data lives in kernel buffer memory, not on disk.","**Pipe infrastructure setup**: The kernel associates pipe-specific data structures with the inode for managing read/write operations."],"title":{"icon":"Zap","text":"Kernel FIFO Creation Sequence","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"height":"400px","mermaidSyntax":"flowchart TB\n subgraph UserSpace[\"User Space\"]\n App[\"Application calls mkfifo()\"]\n end\n \n subgraph Kernel[\"Kernel Space\"]\n VFS[\"VFS Layer: Path Resolution\"]\n Perm[\"Permission Check\"]\n Inode[\"Inode Allocation\"]\n DirEntry[\"Directory Entry Creation\"]\n PipeSetup[\"Pipe Infrastructure\"]\n end\n \n subgraph Filesystem[\"Filesystem\"]\n InodeTable[\"Inode Table\"]\n Directory[\"Parent Directory\"]\n end\n \n App --> VFS\n VFS --> Perm\n Perm --> Inode\n Inode --> InodeTable\n Inode --> DirEntry\n DirEntry --> Directory\n DirEntry --> PipeSetup\n PipeSetup --> Return[\"Return to User Space\"]\n"},"type":"mermaid-excalidraw"},{"data":{"content":"**The Pipe Inode Structure:**\n\nIn the Linux kernel, a FIFO's inode contains a pointer to a `pipe_inode_info` structure, which manages:\n\n- **Circular buffer**: A ring buffer (typically 16 pages = 64KB) for data in transit\n- **Reader/writer counts**: How many processes have the FIFO open for reading/writing\n- **Wait queues**: Blocked readers and writers waiting for data/space\n- **Synchronization primitives**: Spinlocks and mutexes for thread-safe operation\n\n**Key Insight:** The FIFO's filesystem presence (inode + directory entry) is merely a *naming mechanism*. The actual communication infrastructure is pure kernel memory, identical to anonymous pipes. This is why FIFO size is always reported as 0—there's no on-disk data."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Memory vs Disk: The Critical Distinction","content":"A common misconception is that FIFOs write data to disk. They don't. The filesystem entry is just a name and permissions—data flows through kernel memory buffers exactly as with anonymous pipes. This is why FIFOs are fast (no disk I/O for data) but volatile (data vanishes when readers disconnect or system reboots).","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"permissions-ownership","title":"Permissions and Ownership","content":[{"data":{"content":"FIFOs inherit the Unix permission model, but their permissions control access differently than regular files. Understanding these semantics is crucial for secure FIFO-based IPC.\n\n**Permission Semantics for FIFOs:**"},"type":"text"},{"data":{"rows":[["Read (r)","Process can open FIFO for reading"],["Write (w)","Process can open FIFO for writing"],["Execute (x)","No effect—FIFOs cannot be executed"]],"headers":["Permission","Effect on FIFO"]},"type":"table"},{"data":{"content":"**Ownership Semantics:**\n\n- **Owner (UID)**: Set to the effective UID of the creating process\n- **Group (GID)**: Set based on filesystem mounting options (typically parent directory's GID or process's effective GID)\n- **Modification**: Can be changed via `chown()` and `chmod()` with appropriate privileges"},"type":"text"},{"data":{"fileName":"fifo_permissions.c","languages":[{"code":"$7c","label":"C","value":"c","language":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"Security Considerations","content":"**Common Security Pitfalls:**\n\n• **World-writable FIFOs**: Allow any user to write data, potentially causing DoS or injection attacks\n• **Predictable names in /tmp**: Race conditions allow attackers to create symlinks before your FIFO (symlink attacks)\n• **Ignoring return values**: Not checking open() failures can lead to unexpected behavior\n\n**Mitigations:**\n• Use restrictive permissions (0600 or 0660)\n• Create FIFOs in application-specific directories with proper permissions\n• Use `mkdtemp()` for ephemeral FIFO directories\n• Validate opened file is actually a FIFO using `fstat()` + `S_ISFIFO()`","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"directory-placement","title":"Directory Placement Strategies","content":[{"data":{"content":"Where you create your FIFO significantly impacts security, reliability, and system integration. Different placements suit different use cases:\n\n**Common FIFO Locations:**"},"type":"text"},{"data":{"rows":[["`/tmp`","Temporary, ephemeral FIFOs","World-writable, always exists, no setup needed","Security risks, cluttered namespace, cleaned on reboot"],["`/var/run` or `/run`","System services, daemons","Standard location for runtime data, proper permissions","Requires root or proper group membership, cleaned on reboot"],["Application-specific directory","Production applications","Full control over permissions, organized namespace","Must create directory, ensure persistence across restarts"],["User home directory","User-level applications","User owns it, persistent, private by default","Path varies per user, may have quotas"],["`$XDG_RUNTIME_DIR`","Modern desktop applications","Per-user, secure, standard location for runtime files","Only available in desktop environments with systemd"]],"caption":"FIFO Placement Strategies","headers":["Location","Use Case","Pros","Cons"]},"type":"table"},{"data":{"fileName":"fifo_placement.c","languages":[{"code":"$7d","label":"C","value":"c","language":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Lightbulb","title":"Best Practice: Application-Specific Directories","content":"For production applications, always create FIFOs in dedicated, application-controlled directories:\n\n1. Create a directory like `/var/run/myapp/` (for system services) or `$XDG_RUNTIME_DIR/myapp/` (for user apps)\n2. Set restrictive permissions on the directory (0700 or 0750)\n3. Place FIFOs inside with appropriate permissions\n4. Verify directory ownership before creating FIFOs (defense against symlink attacks)\n\nThis pattern provides isolation, easy cleanup, and strong security.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"lifecycle-management","title":"Cleanup and Lifecycle Management","content":[{"data":{"content":"Unlike anonymous pipes that disappear when all file descriptors close, FIFOs persist in the filesystem until explicitly removed. Proper lifecycle management prevents accumulation of stale FIFOs.\n\n**Key Lifecycle Considerations:**"},"type":"text"},{"data":{"items":["**atexit() handlers**: Register cleanup functions for normal program termination—simple but doesn't handle crashes or SIGKILL","**Signal handlers**: Catch SIGTERM, SIGINT, SIGHUP to cleanup before abnormal exit—covers most graceful shutdown scenarios","**Startup cleanup**: Remove stale FIFOs on startup, assuming previous instance may have crashed—robust for single-instance apps","**PID files + FIFOs**: Pair with PID file; on startup, check if PID is live before removing FIFO—prevents accidental interference with running instance","**tmpfiles.d integration**: On systemd systems, declare FIFOs in `/etc/tmpfiles.d/` for automatic creation and cleanup by system"],"title":{"icon":"Target","text":"FIFO Lifecycle Management Strategies","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"fileName":"fifo_lifecycle.c","languages":[{"code":"$7e","label":"C","value":"c","language":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"systemd-tmpfiles for System Services","content":"For system services on Linux with systemd, you can declare FIFOs in `/etc/tmpfiles.d/myapp.conf`:\n\n```\np /run/myapp/control.fifo 0660 myuser mygroup -\n```\n\nThis creates the FIFO with proper ownership on boot, and integrates with systemd's lifecycle management. The FIFO is automatically recreated across reboots and cleaned up when the configuration is removed.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":8},{"id":"summary","title":"Summary: FIFO Creation Best Practices","content":[{"data":{"content":"Creating FIFOs correctly requires understanding both the mechanisms and the operational considerations. Let's consolidate the key principles:"},"type":"text"},{"data":{"type":"ordered","items":["**FIFOs provide named rendezvous points**: Unlike anonymous pipes, FIFOs exist in the filesystem, enabling communication between unrelated processes.","**Use `mkfifo()` for programmatic creation**: It's cleaner and more portable than `mknod()` for creating FIFOs.","**Handle EEXIST appropriately**: Often, reusing an existing FIFO is acceptable—check with `stat()` + `S_ISFIFO()`.","**Apply appropriate permissions**: Use 0600 for private FIFOs, 0660 for group-shared, avoid 0666 in production.","**Choose placement carefully**: Application-specific directories with proper security are preferred over `/tmp`.","**Implement cleanup strategies**: Use `atexit()`, signal handlers, and startup cleanup to prevent stale FIFOs.","**Data doesn't persist on disk**: FIFOs are in-memory channels with a filesystem name—data exists only until read."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that we understand how to create FIFOs, the next page explores their primary value proposition: enabling communication between **unrelated processes**. We'll examine the open semantics, synchronization patterns, and practical examples of FIFO-based IPC between independent programs."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the mechanics of FIFO creation—from shell commands to system calls to kernel internals. You can create production-quality FIFOs with appropriate permissions, secure placement, and proper lifecycle management. Next, we'll explore how FIFOs enable the powerful pattern of unrelated process communication.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":9}],"isLocked":false},{"id":"seed_128a5eb26a3d90ce23ac8d1b9472b4ca","title":"Unrelated Process Communication: The Power of Named Pipes","order":1,"content":null,"isLocked":true},{"id":"seed_008fe8a4dba4a5135079dfea8ecabb18","title":"Blocking Behavior: Mastering FIFO Synchronization Semantics","order":2,"content":null,"isLocked":true},{"id":"seed_7ba2c95616f465223e23800a29203d8f","title":"FIFO Limitations: Understanding the Boundaries","order":3,"content":null,"isLocked":true},{"id":"seed_6da86cde6e82e4cc17d7bdf3b8ae0bd6","title":"Use Cases: FIFOs in Real-World Systems","order":4,"content":null,"isLocked":true}]}}