awesome-repositories.com
المدونة
awesome-repositories.com

اكتشف أفضل مستودعات المصادر المفتوحة باستخدام بحث مدعوم بالذكاء الاصطناعي.

استكشفعمليات بحث منسقةبدائل مفتوحة المصدربرمجيات ذاتية الاستضافةالمدونةخريطة الموقع
المشروعحولكيفية ترتيب النتائجالصحافةخادم MCP
قانونيالخصوصيةالشروط
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
angrave avatar

angrave/SystemProgramming

0
View on GitHub↗
5,734 نجوم·771 تفرعات·7 مشاهداتgithub.com/angrave/SystemProgramming/wiki↗

SystemProgramming

This is an open-source, crowd-sourced wiki textbook that teaches Linux system programming in C. It covers the core operating system concepts of process management through the fork-exec-wait model, dynamic memory allocation using implicit free list heap allocators, inode-based file systems, inter-process communication via pipes and shared memory, POSIX threads with synchronization primitives, signal-based asynchronous notification, virtual memory with page table translation, and runtime diagnostics using Valgrind and GDB.

The textbook distinguishes itself by providing practical, implementation-focused coverage of concurrency and synchronization, including multiple mutual exclusion algorithms such as Dekker's, Peterson's, and spinlock implementations, along with deadlock detection and prevention strategies. It also offers detailed guides on building custom memory allocators, including explicit free list management, segregated heap allocation, and buddy system allocation, as well as tutorials on network client-server programming with TCP and UDP sockets using epoll for scalable I/O event handling.

The material addresses common C programming pitfalls related to memory safety, array sizing, macro usage, and pointer handling, and includes dedicated sections on debugging and sanitization using Valgrind, GDB, and ThreadSanitizer. The content is organized as a living reference that multiple authors contribute to and edit through a collaborative web platform.

Features

  • Process Management - Teaches creating, forking, executing, and waiting for child processes with zombie cleanup.
  • Open Source Textbooks - Serves as an open-source, crowd-sourced wiki textbook for Linux system programming in C.
  • Textbooks - Serves as the primary textbook for learning Linux system programming in C.
  • Shared Global Memory Access - Teaches that threads share global memory, a fundamental concept for understanding race conditions.

بحث بالذكاء الاصطناعي

استكشف المزيد من المستودعات الرائعة

صف ما تحتاجه بلغة بسيطة — وسيقوم الذكاء الاصطناعي بترتيب آلاف المشاريع مفتوحة المصدر المنسقة حسب الصلة.

Start searching with AI
  • Implicit Free List Allocators - Provides detailed guides on implementing implicit free list heap allocators.
  • Heap Block Metadata Trackers - Stores block size and allocation status within the block itself, enabling navigation through the heap without external data structures.
  • File Descriptor Writing - Teaches writing raw byte streams to file descriptors as part of low-level I/O in system programming.
  • Process Lifecycle Identifiers - Assigns each running process a unique numeric identifier and tracks its parent, state, permissions, and open resources.
  • Formatted Stream Outputs - Covers printf-style formatted output to file streams, a fundamental C I/O technique taught in the textbook.
  • Concurrent Task Execution - Teaches concurrent task execution using POSIX threads across multiple CPU cores.
  • Child Exit Status Retrievals - Reads the lowest 8 bits of a child process's return value using wait macros to determine how it terminated.
  • Inode and Permission Managers - Teaches filesystem management including inode interpretation, permissions, and memory-mapped files.
  • String Buffer Formatting - Teaches snprintf-style safe string formatting into buffers, a key C programming practice.
  • Shell Command Execution - Covers invoking shell commands in subprocesses using the system call.
  • POSIX Thread Synchronization Primitives - Teaches POSIX thread synchronization using mutexes, semaphores, and condition variables.
  • Exec System Calls - Loads and runs a different program in the current process, discarding the original code and data.
  • C Language Fundamentals - Teaches core C language features including input/output, strings, structs, and common pitfalls.
  • Bidirectional Communication Pipes - Explains creating separate pipes for bidirectional communication between parent and child processes.
  • Shared Memory IPC - Teaches inter-process communication using pipes and shared memory.
  • Client-Server Implementations - Provides tutorials on building TCP and UDP client-server applications with sockets and epoll.
  • Condition Variable Synchronizations - Covers condition variable synchronization for blocking threads until a condition is signaled.
  • Broken Pipe Signal Handling - Teaches catching SIGPIPE signals when writing to a pipe with no active reader.
  • Deadlock Prevention and Avoidance - Teaches deadlock prevention and avoidance strategies, including resource allocation graphs and dining philosophers.
  • Mutex Unlock Guarantees - Teaches the fundamental rule of always unlocking mutexes to avoid deadlock.
  • Superblock and Inode Organizers - Teaches disk data organization using superblocks, inodes, and disk block structures.
  • Inode-Based Systems - Covers inode-based file system architecture with indirect block addressing.
  • Fork Return Value Distinctions - Checks the return value of fork to branch logic between the original parent and the newly created child process.
  • Inter-Process Shared Memory - Teaches shared memory as a key inter-process communication mechanism.
  • Process Schedulers - Teaches CPU scheduling algorithms that select which ready process to run next.
  • Dynamic Memory Allocation - Teaches dynamic heap memory allocation and deallocation using standard C library functions.
  • Custom Memory Allocators - Provides detailed guides on building custom heap allocators with explicit free lists and buddy systems.
  • Dynamic Heap Allocators - Teaches reserving contiguous heap memory blocks for dynamic use with malloc and related functions.
  • Zombie Process Reclamation - Teaches reaping terminated child processes to free kernel resources and prevent zombie accumulation.
  • Process Lifecycle Orchestrators - Teaches the complete fork-exec-wait process model including signal handling and zombie reclamation.
  • Process Isolation - Explains how private virtual address spaces prevent processes from accessing each other's memory.
  • Memory Isolation - Explains how page table translation isolates process memory, a fundamental OS concept in the textbook.
  • Pipe-Based Communication - Covers unidirectional byte stream communication between related processes using the pipe system call.
  • Cross-Thread Ownership Sharing - Explains how threads share heap, global variables, and program code within a single process.
  • Mutex-Based Resource Synchronizations - Teaches mutex-based resource synchronization for protecting shared data in multi-threaded environments.
  • Mutexes and Locks - Teaches mutex locking and unlocking as the core mechanism for protecting critical sections in concurrent programs.
  • Initialization and Destruction Patterns - Teaches mutex initialization and destruction as part of POSIX threading, a fundamental skill for concurrent programming.
  • Named Pipe Creation - Teaches creating named pipes (FIFOs) for communication between unrelated processes.
  • Null-Terminated String Buffers - Teaches storing text as contiguous bytes ending with a null character.
  • Page Table Mapping - Teaches organizing page mappings into hierarchical tables so only active address ranges consume physical memory.
  • Page Table Translators - Explains virtual memory translation through multi-level page tables.
  • Pipe Buffer Management - Teaches how kernel-level locking guarantees atomic writes smaller than the pipe buffer size.
  • Process Duplications - Covers the fork system call to create a new process with an isolated address space.
  • Process Image Replacements - Replace the current process image with a different program, allowing the child to run a separate executable.
  • Exec Signal State Preservations - Covers how signal state survives exec, a critical detail in the textbook's process lifecycle coverage.
  • Fork Signal Disposition Inheritances - Explains how signal dispositions are inherited across fork, a key concept in the textbook's process management coverage.
  • Signal Masking - Explains manipulating signal masks to block or defer signal delivery to threads.
  • Signal Handlers and Delivery - Covers signal-based asynchronous notification with per-thread masks and handlers.
  • Process Termination Signals - Teaches sending termination signals like SIGTERM, SIGINT, and SIGKILL to child processes.
  • Overlapping Memory Copies - Teaches using memmove to safely copy bytes between overlapping memory regions.
  • Stream Buffer Flushing - Covers forcing buffered output to be written immediately after reading from a pipe.
  • Verbatim String Outputs - Teaches printing raw strings and characters to stdout, a basic C output operation.
  • Concurrent Thread Execution - Teaches concurrent thread execution within a single process, a fundamental system programming concept.
  • Thread Joining Operations - Teaches the pthread_join operation for blocking until a thread completes and retrieving its return value.
  • Spurious Wakeup Guard Loops - Teaches the essential pattern of looping after condition variable wakeups to handle spurious wakeups.
  • Inode-Based File Accessors - Teaches reading and writing file content by following inode block pointers.
  • Runtime Memory Checkers - Teaches runtime diagnostics using Valgrind and GDB for memory error detection.
  • Heap String Duplication - Teaches allocating memory and creating a copy of a string on the heap.
  • Thread Creation and Join Operations - Teaches thread creation and join operations for starting concurrent execution paths and synchronizing their completion.
  • Process Forking - Teaches process creation via fork, duplicating the calling process for parallel execution.
  • Debugging Tools - Provides dedicated sections on debugging C programs with Valgrind, GDB, and ThreadSanitizer.
  • Null-Terminated String Copies - Teaches copying null-terminated strings into pre-allocated buffers, a fundamental C operation.
  • Memory and Concurrency Error Detection - Teaches memory error detection using Valgrind's Memcheck tool for catching leaks and invalid accesses.
  • File System Permissions - Teaches navigating directory structures, controlling file access, and using inodes.
  • Thread Synchronization Primitives - Teaches POSIX thread synchronization using mutexes, condition variables, and semaphores.
  • Condition Variable Signalings - Teaches how to signal condition variables to wake waiting threads, a core POSIX threading concept.
  • Thread Signal Mask Modifications - Teaches per-thread signal masking, a key concept in the textbook's POSIX threading coverage.
  • Concurrency Semaphores - Teaches concurrency semaphores for controlling access to a finite pool of resources and signaling between threads.
  • Condition Variable Semaphore Implementations - Teaches how to implement counting semaphores from condition variables, a key synchronization pattern.
  • Child Process Execution - Teaches spawning child processes via fork that duplicate the parent's execution context.
  • Process Completion Waiting - Teaches the wait system call to block the parent until a child process terminates.
  • Thread and Process Synchronization - Teaches mutex, semaphore, and condition variable usage for coordinating concurrent threads.
  • POSIX Thread Creation and Synchronization - Teaches launching POSIX threads and coordinating them with mutexes, semaphores, and condition variables.
  • Fork-Exec-Wait Sequences - Teaches the classic Unix fork-exec-wait pattern for process creation and management.
  • Semaphore Bounded Buffer Blockings - Teaches semaphore-based bounded buffer synchronization, a classic concurrency pattern in the textbook.
  • File Descriptor Stream Wrappers - Teaches wrapping pipe file descriptors into stream pointers for formatted input and output.
  • Formatted Input Parsing - Teaches scanf-style formatted input parsing from streams, a core C input technique.
  • Inter-Process Communication - Covers data transfer between processes using pipes, named pipes, and shared memory.
  • References - Covers process creation, signals, scheduling, and IPC as a core reference for Linux systems programming.
  • Thread-Safe Data Passing - Teaches thread-safe data passing by providing each thread with its own memory area to avoid race conditions.
  • Stack Data Passing to Threads - Teaches the pitfall of passing stack pointers to threads, a common C concurrency bug.
  • Free Block Placement Strategies - Teaches first-fit, best-fit, and worst-fit placement strategies for heap allocators.
  • Explicit Free List Allocators - Describes maintaining a doubly-linked list of free nodes for faster traversal without scanning allocated blocks.
  • Free Block Search Strategies - Covers first-fit, worst-fit, and insertion-order strategies for locating free memory blocks.
  • Linear Free Block Searches - Teaches scanning an implicit list from the start using a first-fit placement strategy.
  • Scheduler Performance Metrics - Teaches measuring turnaround, response, and wait times to evaluate CPU scheduling.
  • Memory-Mapped File Access - Covers mapping file contents directly into process memory for high-performance access.
  • Pipe Byte-by-Byte Reads - Explains the blocking behavior of reading one character at a time from a pipe.
  • Disk Synchronization - Describes forcing pending filesystem changes to disk for data durability.
  • Indirect Block Addressers - Teaches using indirect block addressing for large storage volumes.
  • Signal-Based - Covers sending SIGSTOP and SIGCONT signals to pause and resume process execution.
  • Debugging Tutorials - Provides a practical tutorial on using Valgrind, GDB, and ThreadSanitizer for debugging C programs.
  • System Call Navigators - Teaches directory navigation and manipulation using system calls like opendir, readdir, and chdir.
  • Thread Exit Operations - Documents thread termination semantics including return value passing in POSIX threads.
  • Turn-Based Coordination Patterns - Implements turn-based critical section coordination as a pedagogical example of mutual exclusion with limited concurrency.
  • Input Termination Newlines - Explains sending a newline through a pipe to terminate formatted input functions.
  • Runtime Assertions - Covers runtime assertions as a debugging technique to halt execution on failed conditions.
  • Peterson's Algorithm Implementations - Implements Peterson's algorithm for mutual exclusion between two threads using shared flags and a turn variable.
  • Dekker's Algorithm Implementations - Implements Dekker's algorithm for mutual exclusion between two threads using shared flags and a turn variable.
  • Network Programming Tutorials - Offers tutorials on building TCP and UDP client-server applications using sockets and epoll.
  • Buddy System Allocators - Describes the buddy system allocation strategy for splitting and coalescing memory blocks.
  • Process Count Limitations - Covers limiting the maximum number of user processes to prevent fork bomb attacks.
  • Atomic Exchange Synchronization - Implements atomic exchange synchronization as a hardware-level mutual exclusion technique for thread coordination.
  • Convoy Effect Mitigations - Explains scheduling techniques that prevent I/O-bound processes from being delayed by CPU-bound ones.
  • Copy-on-Write Memory Optimizations - Teaches copy-on-write memory optimization for sharing pages across forked processes.
  • Completely Fair Schedulers - Explains the Linux Completely Fair Scheduler as part of the process scheduling curriculum.
  • Resource Ordering Strategies - Teaches resource ordering strategies to prevent deadlock by assigning a global order to resources.
  • File Descriptor Sharing - Explains how open file descriptors are shared between parent and child after forking.
  • I/O Polling - Teaches monitoring multiple file descriptors for readiness using epoll and nonblocking I/O.
  • Heap Corruption Detection - Covers double-free prevention as part of heap corruption detection and safe memory practices.
  • Nonblocking Named Pipe Opens - Explains opening a named pipe without blocking using read-write mode and its trade-offs.
  • Block Pointer Indirection - Teaches using indirect blocks for large file addressing in filesystems.
  • Segregated Heap Allocators - Teaches segregated fits and buddy system allocation strategies for custom heap allocators.
  • Process Address Space Analysis - Explains how process memory is partitioned into stack, heap, data, and text segments.
  • Load Balancing Schedulers - Describes the Completely Fair Scheduler's red-black tree approach to distributing processes across cores.
  • C11 Atomic Operations for Mutual Exclusion - Teaches portable mutual exclusion using C11 atomic compare-and-exchange operations with memory ordering.
  • Memory Fragmentation Management - Teaches placement strategies like first-fit and best-fit to minimize unusable gaps in free memory.
  • Fine-Grained Mutex Assignments - Teaches the design pattern of using multiple mutexes for finer-grained synchronization.
  • Mutex Initialization Patterns - Teaches how to initialize mutexes statically and dynamically, a key POSIX threading detail.
  • Mutex Resource Cleanups - Covers the mutex destruction lifecycle, a detail in the textbook's POSIX threading coverage.
  • Page Fault Handlers - Teaches how the OS responds to page faults, a core virtual memory concept.
  • Page Permission Bit Configurations - Teaches setting page permission bits to enforce read-only, non-executable, or dirty page policies.
  • Virtual Address Translators - Teaches how the MMU translates virtual addresses to physical addresses via page tables.
  • Priority-Based Process Schedulers - Covers priority-based process selection using metrics like shortest job first or virtual runtime.
  • Process Preemption - Describes timer-interrupt-based preemption that forces a running process to yield the CPU.
  • Process Signal Management - Covers sending POSIX signals to manage and control process execution.
  • Exec Signal State Preservation - Explains which signal state persists and which is reset when a new program is executed.
  • Fork Signal State Inheritance - Documents how signal state is passed from parent to child during process forking.
  • Signal Disposition Configurations - Teaches how to set signal dispositions to ignore, catch, or use default behavior for signals.
  • Trylock Deadlock Avoidance - Explains trylock-based deadlock avoidance with non-blocking lock attempts and rollback.
  • Raw Memory Block Copies - Covers copying bytes between non-overlapping memory regions with memcpy.
  • Read-Only Page Sharing - Teaches how shared libraries are loaded once and mapped read-only into multiple processes.
  • System Memory Inspection - Teaches using GDB's examine command to inspect raw byte-level memory contents for debugging.
  • Graceful Interrupt Handlers - Demonstrates registering a SIGINT handler for graceful process termination.
  • Thread Cancellation - Teaches pthread_cancel for terminating threads, including its limitations regarding resource cleanup.
  • Spinlocks - Implements spinlocks using busy-waiting loops for mutual exclusion in critical sections.
  • Buffer Overflow Defenses - Covers protections against buffer overflows through safe library calls and correct size limits.
  • File and Folder Permissions - Teaches setting and checking file permissions for user, group, and others.
  • Octal Permission Decoding - Teaches how to decode octal permission values into user, group, and other access rights.
  • Octal Permission Assignments - Teaches setting file permissions using standard octal notation for user, group, and others.
  • Thread Signal Dispatchers - Explains how pending signals are delivered to any thread that does not have them blocked.
  • Dangling Pointer Preventers - Teaches setting pointers to null after freeing to avoid undefined behavior from dangling references.
  • Boundary Tag Coalescers - Teaches clearing allocation bits and coalescing adjacent free blocks using boundary tags.
  • Data Race Detectors - Teaches data race detection using ThreadSanitizer for concurrent C programs.
  • Memory Alignment Utilities - Teaches rounding up allocation sizes and offsetting pointers to meet architecture alignment requirements.
  • Threaded Forking Behaviors - Documents the unexpected single-thread behavior when forking from a multi-threaded process.
  • Bounded Buffer Synchronization - Teaches the producer-consumer pattern with semaphores for bounded buffer coordination.
  • Exact Substring Searches - Teaches locating the first occurrence of a substring within a string using standard C functions.
  • Event-Driven I/O - Teaches using epoll for scalable I/O event handling without busy-waiting.
  • Filesystem Journaling - Explains using a journal to record pending operations for crash recovery.
  • Process State Inspection - Teaches reading process metadata from the /proc filesystem for inspection.
  • Systems Programming - Practical systems programming assignments and lab materials.

    • سجل النجوم

    مخطط تاريخ النجوم لـ angrave/systemprogrammingمخطط تاريخ النجوم لـ angrave/systemprogramming

    الأسئلة الشائعة

    ما هي وظيفة angrave/systemprogramming؟

    This is an open-source, crowd-sourced wiki textbook that teaches Linux system programming in C. It covers the core operating system concepts of process management through the fork-exec-wait model, dynamic memory allocation using implicit free list heap allocators, inode-based file systems, inter-process communication via pipes and shared memory, POSIX threads with synchronization primitives, signal-based asynchronous notification, virtual memory with page table translation,…

    ما هي الميزات الرئيسية لـ angrave/systemprogramming؟

    الميزات الرئيسية لـ angrave/systemprogramming هي: Process Management, Open Source Textbooks, Textbooks, Shared Global Memory Access, Implicit Free List Allocators, Heap Block Metadata Trackers, File Descriptor Writing, Process Lifecycle Identifiers.

    ما هي البدائل مفتوحة المصدر لـ angrave/systemprogramming؟

    تشمل البدائل مفتوحة المصدر لـ angrave/systemprogramming: mit-pdos/xv6-public — xv6 is a Unix-like educational operating system designed for teaching kernel concepts. It is implemented as an… riba2534/tcp-ip-networknote — TCP-IP-NetworkNote is a comprehensive technical reference and guide for implementing network communication using TCP… microsoft/mimalloc — Mimalloc is a general purpose dynamic memory allocator for C and C++ designed to increase execution speed and reduce… sindresorhus/execa — Execa is a promise-based process execution library that serves as a wrapper for the Node.js child process module. It… c3lang/c3c — c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static… sysprog21/lkmpg — The Linux Kernel Module Programming Guide is an educational resource that teaches how to write, compile, and manage…

    بدائل مفتوحة المصدر لـ SystemProgramming

    مشاريع مفتوحة المصدر مشابهة، مرتبة حسب عدد الميزات المشتركة مع SystemProgramming.
    • mit-pdos/xv6-publicالصورة الرمزية لـ mit-pdos

      mit-pdos/xv6-public

      9,466عرض على GitHub↗

      xv6 is a Unix-like educational operating system designed for teaching kernel concepts. It is implemented as an instructional kernel for x86 and RISC-V architectures, featuring a virtual memory manager and support for symmetric multiprocessing. The system is designed to demonstrate core OS principles through a simplified re-implementation of Unix Version 6. It provides a controlled environment for studying system calls, trap handling, and process lifecycles. Its capability surface covers process management, including scheduling and context switching, and memory management via page tables for

      C
      عرض على GitHub↗9,466
    • riba2534/tcp-ip-networknoteالصورة الرمزية لـ riba2534

      riba2534/TCP-IP-NetworkNote

      2,505عرض على GitHub↗

      TCP-IP-NetworkNote is a comprehensive technical reference and guide for implementing network communication using TCP and UDP sockets in C and C++. It provides a detailed manual for using the POSIX socket API and covers the implementation of network protocols, synchronous and asynchronous I/O patterns, and concurrent programming models. The project is distinguished by its focus on cross-platform networking, offering a detailed comparison of socket implementation details and adaptation utilities between Linux and Windows Winsock environments. It specifically addresses the differences in header

      C
      عرض على GitHub↗2,505
    • microsoft/mimallocالصورة الرمزية لـ microsoft

      microsoft/mimalloc

      13,090عرض على GitHub↗

      Mimalloc is a general purpose dynamic memory allocator for C and C++ designed to increase execution speed and reduce fragmentation. It functions as a scalable heap manager that replaces standard library allocation functions to improve performance and memory efficiency across applications. The project distinguishes itself as both a heap security hardener and a memory corruption detector. It employs randomized allocation, encrypted free lists, and sampled guard pages to mitigate heap exploits and identify buffer overflows or use-after-free errors during runtime. The allocator provides capabili

      C
      عرض على GitHub↗13,090
    • c3lang/c3cالصورة الرمزية لـ c3lang

      c3lang/c3c

      5,147عرض على GitHub↗

      c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

      C3c3compilerlanguage
      عرض على GitHub↗5,147
    عرض جميع البدائل الـ 30 لـ SystemProgramming→