# C++ Linux systemprogrammering

Nivå: advanced | Målgrupp: C++ programmerare | Förkunskaper: Stor vana att programmera i C++
https://www.ribomation.se/programmerings-kurser/cxx-linux-systems-programming/

Hur omvandlar man en signal till en exception? Hur skapar man en process och fyller den med ny programkod. Vilka olika
sätt att kommunicera mellan processer finns det? Hur fixar man memory-mapped I/O?
Dessa och en lång rad andra frågeställningar besvarar vi i denna mycket uppskattade kurs.

Hur omvandlar man en signal till en exception? Hur skapar man en process och fyller den med ny programkod. Vilka olika
sätt att kommunicera mellan processer finns det? Hur fixar man memory-mapped I/O?

Dessa och en lång rad andra frågeställningar besvarar vi i denna mycket uppskattade kurs.

- How the address space for a process is organized and why this is interesting
- How function calls are made and how you can use that insight
- How to track library calls and system calls, respectively
- The special file system `/ proc`
- Asynchronous I / O and memory mapped I / O
- Signal handling
- Process management with fork (), exec () and wait ()
- Communication with pipe & fifo
- POSIX message queues
- POSIX shared memory segments
- POSIX semaphores
- TCP stream sockets

### Application
Understanding the concept of a Linux application

#### The Process Concept
- What is a process and how it differs from a thread
- Process meta-data

#### Virtual Address Space Organization
- Virtual memory pages
- Address translation
- What happens during a page fault
- Memory areas and their functions

#### Compilation and Linking
- Overview of the various compilation steps
- Understanding the magic number
- Creating statically linked libraries
- Creating dynamically linked libraries
- Using programs to inspect compiled files such as `string`, `nm`, `objdump`, `ldd`

#### Understanding Function Calls
- The call stack
- The content of stack frames
- The details of a single function call
- Implementing variable number of function arguments
- Using `setjmp()` & `longjmp()`
- Understanding how `longjmp` is used when C++ throws an exception

#### Library and System Calls
- What is call to a library
- What is a system call
- How is the kernel code invoked during a system call
- Tracing library and system calls

#### Memory Management
- What is dynamic memory anyway
- The C APIs for using the heap
- Brief about how to implement heap management
- Estimating the current heap size
- Implementing a C++ allocator for use with containers
- Allocating memory blocks on the call stack
- Tracking memory leaks with valgrind
- The C++ APIs for using the heap

#### Creating Processes
- Copying a process with fork
- Special process IDs
- Terminating a process
- What are zombies and daemons
- Loading a new executable with exec
- Implementing class Process

### Input / Output
Different forms of performing I/O

#### File Systems
- What is a file system
- FS types
- File types
- Basic operations on files, from the kernel’s perspective
- I-nodes
- Directory files
- File descriptors
- Devices
- Mounting devices

#### The /proc file system
- What is the /proc FS
- Top-level info files
- Process-specific info files
- Reading /proc info files using C++

#### Regular I/O
- How to use the system API of `open()` & `close()`
- Opening modes
- Setting file permissions
- How to use the kernel API of read/write
- Changing the file read/write position
- Manipulating files in the file system
- Using C++ fstream for binary record-oriented files

#### Advanced I/O
- Manipulation of file descriptors
- Using memory mapped I/O
- Using non-blocking I/O
- Using non-deterministic I/O
- Implementing class MemoryMappedFile

### Inter-process Communication (IPC)
Different forms of interchanging data between processes.

#### Signals
- What are signals
- Sending signals from the shell and from program code
- Implementing signal handlers
- Registering signals and signal masks
- Implementing timeouts
- Creating interval timers
- Invoking `longjmp()` from a signal handler
- Implementing `class GlobalSignalHandler`
- How to translate a signal, such as `SEGV` (*segmentation fault*) into a C++ exception

#### Channels
- What is a channel
- Pipes
- Fifos
- Implementing class Fifo

#### Message Queues
- What is a message queue and how do it differ from a channel
- Overview of the API
- Usages
- Implementing class MessageQueue

#### Shared Memory
- What is shared memory
- Overview of the API
- Usages
- Implementing `class SharedMemory` and use it as a C++ allocator

#### Semaphores
- What is a semaphore
- Memory vs file-system based semaphores
- Overview of the API
- Usages
- Implementing class Semaphore
- Implementing class FileSystemSemaphore
- Implementing a message queue with semaphores for use in shared memory

#### TCP Sockets
- What is a TCP socket
- API overview
- Network byte order (NBO)
- Creating client sockets
- Creating server-side sockets
- Implementing class Socket
- Implementing class ServerSocket
- Implementing an iostreams compatible socket type