COMP2017 - Systems Programming in C Flashcards

Question 1

Pointer Arithmetic with Typed Pointers

Accepted Answer

Adding $n$ to a pointer increments its memory address by $n 	imes 	ext{sizeof}(*ptr)$ bytes. For example, if `int *p` points to address `0x1000` (assuming 4-byte `int`), `p + 1` yields `0x1004`, whereas for a `char *p`, `p + 1` yields `0x1001`.

Question 2

malloc() vs. calloc()

Accepted Answer

- `malloc(size_t size)`: Allocates `size` bytes of uninitialized memory containing garbage values.
- `calloc(size_t num, size_t size)`: Allocates memory for `num` objects of `size` bytes each and initializes all bits to `0`.

Question 3

Struct Padding and Data Alignment

Accepted Answer

Compilers insert unallocated byte gaps (padding) inside structs so fields align with processor memory boundaries (typically multiples of member size). Consequently, `sizeof(struct)` is often greater than the sum of the individual sizes of its members.

Question 4

Process Creation with fork()

Accepted Answer

`fork()` duplicates the calling process to create a child process. It returns:
- `0` inside the child process.
- The child's Process ID (PID) inside the parent process.
- `-1` on error.

Question 5

Zombie vs. Orphan Processes

Accepted Answer

- **Zombie Process**: A child process that has finished execution but whose parent has not yet read its exit status via `wait()`/`waitpid()`.
- **Orphan Process**: A running child whose parent process has died; it is automatically adopted by `init` (PID 1).

Question 6

The exec() Family of System Calls

Accepted Answer

Replaces the current process execution image (code, heap, stack, data) with a new program image. On success, `exec()` does not return because the calling code image no longer exists; the PID remains unchanged.

Question 7

Inter-Process Communication with pipe()

Accepted Answer

`int pipe(int pipefd[2])` creates a unidirectional data channel stored in the kernel.
- `pipefd[0]`: Open for reading.
- `pipefd[1]`: Open for writing.
Data written to `pipefd[1]` is buffered until read from `pipefd[0]`.

Question 8

Standard File Descriptors

Accepted Answer

By default, every POSIX process opens three standard file descriptors:
- `0`: Standard Input (`STDIN_FILENO` / `stdin`)
- `1`: Standard Output (`STDOUT_FILENO` / `stdout`)
- `2`: Standard Error (`STDERR_FILENO` / `stderr`)

Question 9

I/O Redirection using dup2()

Accepted Answer

`dup2(int oldfd, int newfd)` duplicates `oldfd` to `newfd`. If `newfd` was open, it is silently closed first. For example, `dup2(file_fd, STDOUT_FILENO)` redirects standard output to a file.

Question 10

Bitwise Manipulation Idioms

Accepted Answer

Common bitwise operations on bit index $k$: - **Set bit**: `x |= (1U << k)` - **Clear bit**: `x &= ~(1U << k)` - **Toggle bit**: `x ^= (1U << k)` - **Check bit**: `(x >> k) & 1`

Question 11

Dangling Pointers and Safe free()

Accepted Answer

A dangling pointer stores the address of memory that has already been deallocated using `free()`. Dereferencing it causes Undefined Behavior. Prevention pattern: Set pointers to `NULL` immediately after freeing (`free(ptr); ptr = NULL;`).

Question 12

Generic Pointers (void *)

Accepted Answer

A `void *` can hold the address of any data type without explicit casting. Limitations in standard C:
- Cannot be directly dereferenced.
- Cannot perform pointer arithmetic without first casting to a concrete data pointer type.

Question 13

pthread_create() Signature and Arguments

Accepted Answer

Creates a execution thread: `int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);`.
Returns `0` on success, or an error number on failure.

Question 14

Race Conditions and Mutexes

Accepted Answer

A **race condition** occurs when multiple threads access shared memory concurrently and at least one access is a write. A `pthread_mutex_t` enforces mutual exclusion via `pthread_mutex_lock()` and `pthread_mutex_unlock()` around critical sections.

Question 15

pthread_join() vs. pthread_detach()

Accepted Answer

- `pthread_join(thread, &retval)`: Blocks the caller until target `thread` terminates and reclaims its resources (like `waitpid()`).
- `pthread_detach(thread)`: Marks thread as detached, releasing resources automatically upon termination without requiring a join.

Question 16

The volatile Qualifier

Accepted Answer

Informs the compiler that a variable's value can be modified unexpectedly by external hardware or concurrent code (e.g., signal handlers, memory-mapped I/O registers). Prevents the compiler from optimizing away reads/writes or caching values in CPU registers.

Question 17

Function Pointer Declaration Syntax

Accepted Answer

Syntax: `return_type (*func_ptr_name)(param1_type, param2_type);`.
Example for a comparison callback: `int (*cmp)(const void *, const void *);`.

Question 18

Memory Leaks and Valgrind

Accepted Answer

A **memory leak** occurs when dynamic memory allocated on the heap is no longer reachable by the program but was never freed. **Valgrind** (`valgrind --leak-check=full ./prog`) is a dynamic analysis tool used to detect unfreed memory allocations and illegal accesses.

Question 19

POSIX Signal Handling Safety

Accepted Answer

Signals are asynchronous OS notifications. Handlers registered via `sigaction()` must only invoke **async-signal-safe** functions. Non-reentrant functions like `printf()`, `malloc()`, or `free()` must be avoided within signal handlers.

Question 20

System Calls vs. C Library Functions

Accepted Answer

- **System Calls** (`read`, `write`, `open`): Direct kernel interfaces causing context switches from user to kernel mode.
- **Library Functions** (`printf`, `fread`, `fopen`): Higher-level user-space functions, often wrapping system calls with user-space buffering.

COMP2017 - Systems Programming in C

Cards in this deck

Related Flashcard Sets

JLPT N4 - Grammar Patterns & Kanji

German B1 - Intermediate Grammar & Vocabulary

Kubernetes Fundamentals & Orchestration

CFA Level I - Ethical and Professional Standards