POSIX Interface: The Portable Operating System Standard

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>
 
/**
 * fork() - Create a new process by duplicating the calling process.
 * 
 * Returns:
 *   - To parent: PID of child (positive integer)
 *   - To child: 0
 *   - On failure: -1 (only to parent, child not created)
 * 
 * Key semantics:
 *   - Child inherits copies of parent's memory, file descriptors, etc.
 *   - File descriptors share underlying file descriptions (seek position)
 *   - Child gets its own unique PID and PPID
 *   - Child's resource utilizations reset to zero
 */
void demonstrate_fork(void) {
    printf("Parent PID: %d\n", getpid());
    
    pid_t pid = fork();
    
    if (pid < 0) {
        /* fork() failed - handle error */
        fprintf(stderr, "fork failed: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) {
        /* Child process */
        printf("Child: My PID is %d, parent is %d\n", 
               getpid(), getppid());
        /* Child does its work here */
        _exit(EXIT_SUCCESS);  /* Use _exit(), not exit() in child */
    }
    
    /* Parent process continues here */
    printf("Parent: Created child with PID %d\n", pid);
    
    /* Wait for child to complete */
    int status;
    pid_t waited = waitpid(pid, &status, 0);
    
    if (waited == -1) {
        perror("waitpid");
        exit(EXIT_FAILURE);
    }
    
    if (WIFEXITED(status)) {
        printf("Child exited with status %d\n", WEXITSTATUS(status));
    } else if (WIFSIGNALED(status)) {
        printf("Child killed by signal %d\n", WTERMSIG(status));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
 
/**
 * The fork-exec pattern: the Unix way to run external programs.
 * 
 * This pattern is fundamental:
 * 1. Fork to create a child process
 * 2. In child: exec to replace with desired program
 * 3. In parent: wait for child completion
 */
int run_command(const char *program, char *const argv[]) {
    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork");
        return -1;
    }
    
    if (pid == 0) {
        /* Child: execute the program */
        execvp(program, argv);
        /* If we get here, exec failed */
        perror("execvp");
        _exit(127);  /* Convention: 127 = command not found */
    }
    
    /* Parent: wait for child */
    int status;
    if (waitpid(pid, &status, 0) == -1) {
        perror("waitpid");
        return -1;
    }
    
    if (WIFEXITED(status)) {
        return WEXITSTATUS(status);
    }
    
    return -1;  /* Child terminated abnormally */
}
 
/* Usage example */
void example_run_ls(void) {
    char *argv[] = {"ls", "-la", "/tmp", NULL};
    int result = run_command("ls", argv);
    printf("ls exited with status: %d\n", result);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <errno.h>
 
/**
 * open() - Open or optionally create a file.
 * 
 * Parameters:
 *   path:  pathname of file to open
 *   oflag: O_RDONLY, O_WRONLY, O_RDWR (exactly one required)
 *          plus optional flags: O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_NONBLOCK
 *   mode:  permissions if O_CREAT (modified by umask)
 * 
 * Returns: file descriptor on success, -1 on error
 * 
 * Critical semantics:
 *   - Returns lowest available file descriptor
 *   - Atomically creates file if O_CREAT | O_EXCL
 *   - O_APPEND makes all writes atomic at end of file
 */
int open_file_examples(void) {
    int fd;
    
    /* Open existing file for reading */
    fd = open("/etc/passwd", O_RDONLY);
    if (fd == -1) {
        perror("open /etc/passwd");
        return -1;
    }
    close(fd);
    
    /* Create new file (fail if exists) - secure pattern */
    fd = open("/tmp/newfile.txt", 
              O_WRONLY | O_CREAT | O_EXCL,
              S_IRUSR | S_IWUSR);  /* 0600 - owner r/w only */
    if (fd == -1) {
        if (errno == EEXIST) {
            printf("File already exists\n");
        } else {
            perror("open new file");
        }
        return -1;
    }
    close(fd);
    
    /* Open for append - atomic writes at end */
    fd = open("/tmp/logfile.txt", 
              O_WRONLY | O_CREAT | O_APPEND,
              S_IRUSR | S_IWUSR | S_IRGRP);  /* 0640 */
    if (fd == -1) {
        perror("open logfile");
        return -1;
    }
    
    return fd;  /* Return for further operations */
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
 
/**
 * CRITICAL: read() and write() may return fewer bytes than requested.
 * 
 * This is NOT an error condition. It happens when:
 *   - Reading: less data available (end of file, pipe, socket)
 *   - Writing: resource limits, non-blocking I/O, signals
 * 
 * Correct code MUST handle partial reads/writes.
 */
 
/* Robust read: keep trying until we get all requested bytes */
ssize_t read_all(int fd, void *buf, size_t count) {
    char *ptr = buf;
    size_t remaining = count;
    
    while (remaining > 0) {
        ssize_t n = read(fd, ptr, remaining);
        
        if (n < 0) {
            if (errno == EINTR) {
                continue;  /* Interrupted by signal, retry */
            }
            return -1;  /* Actual error */
        }
        
        if (n == 0) {
            break;  /* End of file */
        }
        
        ptr += n;
        remaining -= n;
    }
    
    return count - remaining;  /* Total bytes read */
}
 
/* Robust write: keep trying until all bytes written */
ssize_t write_all(int fd, const void *buf, size_t count) {
    const char *ptr = buf;
    size_t remaining = count;
    
    while (remaining > 0) {
        ssize_t n = write(fd, ptr, remaining);
        
        if (n < 0) {
            if (errno == EINTR) {
                continue;  /* Interrupted by signal, retry */
            }
            return -1;  /* Actual error */
        }
        
        /* write() returning 0 is unusual but not impossible */
        ptr += n;
        remaining -= n;
    }
    
    return count;  /* All bytes written */
}
 
/* File copy example using robust I/O */
int copy_file(const char *src, const char *dst) {
    int src_fd = open(src, O_RDONLY);
    if (src_fd == -1) {
        perror("open source");
        return -1;
    }
    
    int dst_fd = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (dst_fd == -1) {
        perror("open destination");
        close(src_fd);
        return -1;
    }
    
    char buffer[4096];
    ssize_t bytes_read;
    
    while ((bytes_read = read(src_fd, buffer, sizeof(buffer))) > 0) {
        if (write_all(dst_fd, buffer, bytes_read) < 0) {
            perror("write");
            close(src_fd);
            close(dst_fd);
            return -1;
        }
    }
    
    if (bytes_read < 0) {
        perror("read");
        close(src_fd);
        close(dst_fd);
        return -1;
    }
    
    close(src_fd);
    close(dst_fd);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
 
/**
 * lseek() - Reposition read/write file offset.
 * 
 * Parameters:
 *   fd:     file descriptor
 *   offset: offset to seek to (can be negative)
 *   whence: SEEK_SET (from start), SEEK_CUR (from current), SEEK_END (from end)
 * 
 * Returns: resulting offset from start of file, or -1 on error
 */
void lseek_examples(int fd) {
    off_t pos;
    
    /* Go to start of file */
    pos = lseek(fd, 0, SEEK_SET);
    
    /* Go to end of file */
    pos = lseek(fd, 0, SEEK_END);
    printf("File size: %lld bytes\n", (long long)pos);
    
    /* Move forward 100 bytes from current position */
    pos = lseek(fd, 100, SEEK_CUR);
    
    /* Move backward 50 bytes from current position */
    pos = lseek(fd, -50, SEEK_CUR);
    
    /* Create a sparse file (hole) - data between positions is zero */
    lseek(fd, 1000000, SEEK_SET);
    write(fd, "x", 1);  /* File appears 1MB but uses minimal disk space */
}
 
/**
 * dup2() - Duplicate file descriptor to specific number.
 * 
 * This is how shells implement I/O redirection:
 *   cmd > file  becomes  dup2(file_fd, STDOUT_FILENO)
 */
void redirect_stdout_to_file(const char *filename) {
    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open");
        return;
    }
    
    /* Make stdout refer to the file */
    if (dup2(fd, STDOUT_FILENO) == -1) {
        perror("dup2");
        close(fd);
        return;
    }
    
    close(fd);  /* Original fd no longer needed */
    
    /* Now printf goes to the file */
    printf("This goes to %s\n", filename);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
 
/**
 * Directory traversal with opendir/readdir/closedir
 * 
 * These functions provide portable directory reading.
 * The struct dirent contains at minimum:
 *   - d_name: null-terminated filename
 *   - d_ino: inode number (may not be meaningful on all systems)
 */
void list_directory(const char *path) {
    DIR *dir = opendir(path);
    if (dir == NULL) {
        perror("opendir");
        return;
    }
    
    struct dirent *entry;
    
    /* readdir returns NULL on end-of-directory OR error */
    /* Distinguish by checking errno */
    errno = 0;
    while ((entry = readdir(dir)) != NULL) {
        /* Skip . and .. */
        if (strcmp(entry->d_name, ".") == 0 ||
            strcmp(entry->d_name, "..") == 0) {
            continue;
        }
        
        printf("%s\n", entry->d_name);
    }
    
    if (errno != 0) {
        perror("readdir");
    }
    
    closedir(dir);
}
 
/**
 * Get file metadata with stat/lstat/fstat
 * 
 * struct stat contains:
 *   st_mode:  file type and permissions
 *   st_ino:   inode number
 *   st_dev:   device ID
 *   st_nlink: number of hard links
 *   st_uid:   owner user ID
 *   st_gid:   owner group ID
 *   st_size:  file size in bytes
 *   st_atime: last access time
 *   st_mtime: last modification time
 *   st_ctime: last status change time
 */
void print_file_info(const char *path) {
    struct stat sb;
    
    /* lstat doesn't follow symlinks; stat does */
    if (lstat(path, &sb) == -1) {
        perror("lstat");
        return;
    }
    
    printf("%s:\n", path);
    printf("  Size: %lld bytes\n", (long long)sb.st_size);
    printf("  Inode: %llu\n", (unsigned long long)sb.st_ino);
    printf("  Links: %lu\n", (unsigned long)sb.st_nlink);
    printf("  Permissions: %o\n", sb.st_mode & 07777);
    
    /* Check file type */
    printf("  Type: ");
    if (S_ISREG(sb.st_mode)) printf("regular file\n");
    else if (S_ISDIR(sb.st_mode)) printf("directory\n");
    else if (S_ISLNK(sb.st_mode)) printf("symbolic link\n");
    else if (S_ISFIFO(sb.st_mode)) printf("FIFO/pipe\n");
    else if (S_ISSOCK(sb.st_mode)) printf("socket\n");
    else if (S_ISCHR(sb.st_mode)) printf("character device\n");
    else if (S_ISBLK(sb.st_mode)) printf("block device\n");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
 
/**
 * Secure file creation pattern using link/unlink.
 * 
 * This pattern ensures atomic replacement:
 * 1. Create new file with temporary name
 * 2. Write complete content
 * 3. Sync to disk
 * 4. Rename temp file to target (atomic)
 * 
 * If crash occurs, either old version or new version exists,
 * never a partial file.
 */
int atomic_file_update(const char *target, const char *content) {
    char tempfile[256];
    snprintf(tempfile, sizeof(tempfile), "%s.tmp.%d", target, getpid());
    
    /* Create temporary file */
    int fd = open(tempfile, O_WRONLY | O_CREAT | O_EXCL, 0644);
    if (fd == -1) {
        perror("open tempfile");
        return -1;
    }
    
    /* Write content */
    size_t len = strlen(content);
    if (write(fd, content, len) != (ssize_t)len) {
        perror("write");
        close(fd);
        unlink(tempfile);
        return -1;
    }
    
    /* Sync to disk before rename */
    if (fsync(fd) == -1) {
        perror("fsync");
        close(fd);
        unlink(tempfile);
        return -1;
    }
    
    close(fd);
    
    /* Atomic rename */
    if (rename(tempfile, target) == -1) {
        perror("rename");
        unlink(tempfile);
        return -1;
    }
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
 
/* Volatile sig_atomic_t for signal-handler communication */
volatile sig_atomic_t shutdown_requested = 0;
 
/**
 * Signal handler function.
 * 
 * CRITICAL: Signal handlers must be async-signal-safe.
 * Most library functions are NOT safe to call from handlers.
 * 
 * Safe operations:
 *   - Setting volatile sig_atomic_t variables
 *   - Calling async-signal-safe functions (write, _exit, etc.)
 * 
 * UNSAFE (do NOT call from signal handlers):
 *   - printf, malloc, free, most standard library functions
 */
void signal_handler(int signum) {
    /* Set flag - main loop will check and handle */
    shutdown_requested = 1;
    
    /* If you must log, use write() not printf() */
    const char msg[] = "Shutdown signal received\n";
    write(STDERR_FILENO, msg, sizeof(msg) - 1);
}
 
/**
 * sigaction() - The POSIX way to install signal handlers.
 * 
 * Always use sigaction(), never signal().
 * signal() has undefined behavior for many details.
 */
void setup_signal_handlers(void) {
    struct sigaction sa;
    
    /* Clear the structure */
    memset(&sa, 0, sizeof(sa));
    
    /* Set handler function */
    sa.sa_handler = signal_handler;
    
    /* Block other signals during handler execution */
    sigfillset(&sa.sa_mask);
    
    /* Flags: SA_RESTART makes interrupted syscalls retry */
    sa.sa_flags = SA_RESTART;
    
    /* Install handler for SIGINT (Ctrl+C) */
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction SIGINT");
        exit(EXIT_FAILURE);
    }
    
    /* Install handler for SIGTERM */
    if (sigaction(SIGTERM, &sa, NULL) == -1) {
        perror("sigaction SIGTERM");
        exit(EXIT_FAILURE);
    }
}
 
/**
 * Main loop checking for shutdown.
 */
int main(void) {
    setup_signal_handlers();
    
    printf("Running... Press Ctrl+C to stop\n");
    
    while (!shutdown_requested) {
        /* Do work */
        sleep(1);
        printf(".");
        fflush(stdout);
    }
    
    printf("\nShutting down gracefully...\n");
    /* Cleanup code here */
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
 
/**
 * pipe() - Create an anonymous pipe.
 * 
 * Creates a unidirectional data channel:
 *   pipefd[0]: read end
 *   pipefd[1]: write end
 * 
 * Data written to pipefd[1] can be read from pipefd[0].
 * Pipe has limited buffer size (typically 64KB on Linux).
 */
void pipe_example(void) {
    int pipefd[2];
    char buffer[256];
    
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) {
        /* Child: read from pipe */
        close(pipefd[1]);  /* Close unused write end */
        
        ssize_t n = read(pipefd[0], buffer, sizeof(buffer) - 1);
        if (n > 0) {
            buffer[n] = '\0';
            printf("Child received: %s\n", buffer);
        }
        
        close(pipefd[0]);
        _exit(EXIT_SUCCESS);
    } else {
        /* Parent: write to pipe */
        close(pipefd[0]);  /* Close unused read end */
        
        const char *msg = "Hello from parent!";
        write(pipefd[1], msg, strlen(msg));
        
        close(pipefd[1]);  /* Signals EOF to reader */
        wait(NULL);
    }
}
 
/**
 * Implementing shell pipelines: cmd1 | cmd2
 * 
 * This is how "ls -l | grep foo" works.
 */
void shell_pipeline_example(void) {
    int pipefd[2];
    
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    
    /* First child: runs "ls -l", stdout to pipe */
    pid_t pid1 = fork();
    if (pid1 == 0) {
        close(pipefd[0]);  /* Close read end */
        dup2(pipefd[1], STDOUT_FILENO);  /* stdout -> pipe write */
        close(pipefd[1]);
        
        execlp("ls", "ls", "-l", NULL);
        perror("execlp ls");
        _exit(127);
    }
    
    /* Second child: runs "grep foo", stdin from pipe */
    pid_t pid2 = fork();
    if (pid2 == 0) {
        close(pipefd[1]);  /* Close write end */
        dup2(pipefd[0], STDIN_FILENO);  /* stdin <- pipe read */
        close(pipefd[0]);
        
        execlp("grep", "grep", "txt", NULL);
        perror("execlp grep");
        _exit(127);
    }
    
    /* Parent: close pipe and wait */
    close(pipefd[0]);
    close(pipefd[1]);
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
 
#define SHM_NAME "/my_shared_mem"
#define SHM_SIZE 4096
 
/**
 * POSIX shared memory with shm_open/mmap.
 * 
 * Steps:
 * 1. shm_open() - create/open shared memory object
 * 2. ftruncate() - set size
 * 3. mmap() - map into address space
 * 4. Use the memory
 * 5. munmap() - unmap
 * 6. shm_unlink() - remove shared memory object
 */
 
/* Writer process */
void shared_memory_writer(void) {
    /* Create shared memory object */
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    if (fd == -1) {
        perror("shm_open");
        exit(EXIT_FAILURE);
    }
    
    /* Set size */
    if (ftruncate(fd, SHM_SIZE) == -1) {
        perror("ftruncate");
        exit(EXIT_FAILURE);
    }
    
    /* Map into address space */
    void *addr = mmap(NULL, SHM_SIZE, 
                      PROT_READ | PROT_WRITE,
                      MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
    
    close(fd);  /* fd no longer needed after mmap */
    
    /* Write data */
    const char *message = "Hello from shared memory!";
    memcpy(addr, message, strlen(message) + 1);
    printf("Writer: wrote message\n");
    
    /* In real code, use semaphores for synchronization */
    sleep(5);  /* Keep memory available */
    
    /* Cleanup */
    munmap(addr, SHM_SIZE);
    shm_unlink(SHM_NAME);
}
 
/* Reader process */
void shared_memory_reader(void) {
    /* Open existing shared memory */
    int fd = shm_open(SHM_NAME, O_RDONLY, 0666);
    if (fd == -1) {
        perror("shm_open");
        exit(EXIT_FAILURE);
    }
    
    /* Map read-only */
    void *addr = mmap(NULL, SHM_SIZE,
                      PROT_READ,
                      MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
    
    close(fd);
    
    /* Read data */
    printf("Reader: %s\n", (char *)addr);
    
    munmap(addr, SHM_SIZE);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
 
/**
 * Thread function signature: void *(*start_routine)(void *)
 * 
 * Takes void* argument, returns void* result.
 * Return value or pthread_exit() argument passed to pthread_join().
 */
void *thread_function(void *arg) {
    int thread_num = *(int *)arg;
    
    printf("Thread %d: starting\n", thread_num);
    sleep(1);  /* Simulate work */
    printf("Thread %d: finishing\n", thread_num);
    
    /* Return value accessible via pthread_join */
    int *result = malloc(sizeof(int));
    *result = thread_num * 10;
    return result;
}
 
int main(void) {
    pthread_t threads[4];
    int thread_args[4];
    
    /* Create threads */
    for (int i = 0; i < 4; i++) {
        thread_args[i] = i;
        
        int rc = pthread_create(&threads[i], NULL, 
                               thread_function, &thread_args[i]);
        if (rc != 0) {
            fprintf(stderr, "pthread_create failed: %d\n", rc);
            exit(EXIT_FAILURE);
        }
    }
    
    /* Wait for all threads and collect results */
    for (int i = 0; i < 4; i++) {
        void *result;
        int rc = pthread_join(threads[i], &result);
        
        if (rc != 0) {
            fprintf(stderr, "pthread_join failed: %d\n", rc);
        } else {
            printf("Thread %d returned: %d\n", i, *(int *)result);
            free(result);  /* Clean up thread-allocated memory */
        }
    }
    
    printf("All threads completed\n");
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <pthread.h>
 
/* Shared data protected by mutex */
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
void *increment_counter(void *arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&mutex);
        counter++;  /* Protected access */
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
 
int main(void) {
    pthread_t t1, t2;
    
    pthread_create(&t1, NULL, increment_counter, NULL);
    pthread_create(&t2, NULL, increment_counter, NULL);
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    
    printf("Final counter value: %d\n", counter);
    /* Should be 200000; without mutex would be less due to races */
    
    pthread_mutex_destroy(&mutex);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
 
/**
 * time() - Simple seconds since epoch
 */
void simple_time_example(void) {
    time_t now = time(NULL);
    printf("Seconds since epoch: %ld\n", (long)now);
    
    /* Convert to local time */
    struct tm *local = localtime(&now);
    printf("Local time: %04d-%02d-%02d %02d:%02d:%02d\n",
           local->tm_year + 1900, local->tm_mon + 1, local->tm_mday,
           local->tm_hour, local->tm_min, local->tm_sec);
    
    /* Format as string */
    char buffer[64];
    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S %Z", local);
    printf("Formatted: %s\n", buffer);
}
 
/**
 * clock_gettime() - High-resolution time with multiple clocks
 * 
 * Clock types:
 *   CLOCK_REALTIME  - Wall clock (can be adjusted)
 *   CLOCK_MONOTONIC - Steady clock (for measuring intervals)
 *   CLOCK_PROCESS_CPUTIME_ID - CPU time for process
 *   CLOCK_THREAD_CPUTIME_ID  - CPU time for thread
 */
void high_resolution_time_example(void) {
    struct timespec ts;
    
    /* Get real time (wall clock) */
    clock_gettime(CLOCK_REALTIME, &ts);
    printf("Real time: %ld.%09ld seconds\n", 
           (long)ts.tv_sec, ts.tv_nsec);
    
    /* Measure elapsed time with monotonic clock */
    struct timespec start, end;
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    /* Work to measure */
    volatile int sum = 0;
    for (int i = 0; i < 1000000; i++) sum += i;
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    
    /* Calculate elapsed time */
    long elapsed_ns = (end.tv_sec - start.tv_sec) * 1000000000L
                    + (end.tv_nsec - start.tv_nsec);
    printf("Elapsed: %ld ns (%.3f ms)\n", 
           elapsed_ns, elapsed_ns / 1000000.0);
}
 
/**
 * nanosleep() - High-resolution sleep
 */
void precise_sleep(long milliseconds) {
    struct timespec req, rem;
    
    req.tv_sec = milliseconds / 1000;
    req.tv_nsec = (milliseconds % 1000) * 1000000;
    
    /* nanosleep may be interrupted by signals */
    while (nanosleep(&req, &rem) == -1) {
        req = rem;  /* Sleep remaining time */
    }
}