Linux System Programming - A programmers/Practical Approach

Explore how Linux uses user mode and kernel mode to protect hardware resources, with system calls and library calls enabling transitions from user space to kernel space.

Explore Linux file concepts, including ownership, permission bits (read, write, execute), and file types from files to links, and learn to view and change permissions with ls -l and chmod.

Open system call returns a file descriptor and uses default descriptors for standard input, output, and error. Use O_RDONLY, O_WRONLY, O_RDWR, and O_CREAT with mode.

Discover how the read() system call reads bytes into a user-space buffer from a file descriptor obtained via open(), including end-of-file and error handling, with examples.

Explain how the write() system call writes data from a user-space buffer to a file, using a file descriptor obtained from open(), a buffer pointer, and a count.

Shows how to use the lseek system call to move the file offset for read/write operations, with absolute, relative, and end-of-file seeks, and open, read, write and close.

Explore race conditions and atomicity in Linux file I/O, driven by multiprocessing and multithreading. Observe log.txt race scenarios under scheduling, blocking vs non blocking I/O, open calls.

Explore atomicity in Linux system calls, where kernel guarantees a single atomic operation from start to finish, returning pass or fail and preventing race around condition in the critical section.

Explore how the Linux kernel uses preemptive scheduling to allocate cpu time slices among processes, contrasting it with non preemptive behavior in kernel mode before version 2.6.

Explore how the file descriptor table links to the open file table and inode, detailing file offsets, flags, and pointers to data blocks, including single, double, and triple indirection.

See how the per-process file descriptor table, the open file table, and the inode table coordinate opening log.txt in read-write mode, with create, seek, and write updating the file offset.

Demonstrate how dup and dup2 duplicate file descriptors, returning newfd, and redirect output to files such as newFile.log and newfile2.log, by illustrating open, unistd.h, and per-process file descriptor tables.

Explore the program versus process concept, examine process memory layout and sections, and learn process id, parent process id, and how preprocessing, compiling, assembling, linking, and loading form an executable.

Explore Linux process IDs and parent process IDs by using getpid and getppid, observing how the shell forks child processes, and using ps -ef to reveal pid and ppid relationships.

Examine the basic process memory layout, including the text segment with program code, data (initialized and BSS), stack, and heap, and how stack frames store locals for dynamic allocation.

Explore how a C program's memory partitions into text segment, initialized data segment, uninitialized data segment, stack, and heap, with static variables and malloc illustrating each segment.

Understand virtual memory, how Linux multiprocess systems provide each process with more addressing space than physical RAM, and how private memory protects data across processes.

Explore how virtual memory manages process memory, page frames, page tables, and swap between RAM and disk, and illustrate page faults in Linux.

Learn how command line arguments work in a process with argc and argv, print strings, and convert ASCII inputs to integers for add or subtract operations.

Explore the environment of a process, where environment variables are name-value pairs accessible across functions via environ and get env, with examples of setting new variables.

Explore memory allocations in Linux system programming, including malloc, calloc, realloc, and the break and s break system calls. See how the heap grows with dynamic memory.

Understand memory in Linux with malloc, calloc, realloc, and free; free returns blocks to free list without lowering program break, while alloc A allocates on stack and risks overflow.

Explain how the fork system call creates a child process, duplicating the parent’s memory and creating separate virtual memory for text, data, and stack via copy-on-write.

Explore how orphan and zombie processes form during forking, and how a sleeping child affects scheduling. Learn how reparenting to init and wait calls remove zombies from the process table.

Learn how the exec system call replaces a running program by loading a new program into memory, discarding the old one, and starting execution from main using argv and envp.

Demonstrates a lexical exec call where p1 runs p2 by replacing its own process image, preserving the same process id, and passing argv0, argv1, argv2 as arguments.

Explore how the execve system call replaces a running program with another, passing argv and envp, and inspect the new program’s arguments and environment.

Combine fork and exec to create a child process and replace its memory with a new program, while the parent waits and collects the child's exit status.