book

System Programming in Linux

Name: System Programming in Linux
Author: Stewart N. Weiss
ISBN: 9781718503564

by Stewart N. Weiss

October 2025

Intermediate to advanced

1048 pages

29h 35m

English

No Starch Press

Read now

Unlock full access

Cover Page
Title Page
Copyright Page
Dedication Page
About the Author
About the Technical Reviewer
BRIEF CONTENTS
CONTENTS IN DETAIL
ACKNOWLEDGMENTS
PREFACE

INTRODUCTION
What Will You Learn from This Book?How Will This Book Teach You?Using Open Source SoftwarePresenting Different PerspectivesUsing Example ProgramsWhat Should You Know to Understand This Book?The Role of C in This BookUtility ProgramsSystem RequirementsAbout UNIX, Unix, Linux, and MoreScope, Content, and OrganizationChapter OrganizationOnline MaterialsConventions and FormatTypographical ConventionsNotationExample Program Naming ConventionsDates and IdentitiesSuggestions and Corrections
1 CORE CONCEPTS
What Is System Programming?The Magic of Input and OutputThe Role of the C Library in I/OSystem ResourcesSystem Programs ExplainedFundamental Concepts of UnixThe Unix KernelShells and CommandsUsers and GroupsPrivileged and Nonprivileged InstructionsEnvironmentsFiles, Directories, and the Single Directory HierarchyProcessesThreadsOnline DocumentationUsing the Manual PagesThe PagerThe Structure of Man PagesSearching Through the Man PagesUnix History and StandardsThe Birth of UNIXEarly BranchesThe Free Software Foundation and GNUThe Rise of LinuxMany UnixesUnix and Related StandardsC StandardsSummaryExercises
2 FUNDAMENTALS OF SYSTEM PROGRAMMING
Object LibrariesSystem LibrariesStatic and Shared LibrariesThe Advantages of Shared LibrariesCommands to Query a Library’s ContentsCommands to Show the Libraries Linked to a ProgramThe C Standard LibrarySystem CallsWrapper FunctionsSystem Call ExecutionMultiple Paths to Kernel ServicesHandling Errors from System Calls and Library FunctionsSystem Call ErrorsErrors from Library FunctionsPortabilityFeature Test MacrosOther Portability IssuesSystem LimitsInternationalizationProcessing the Command Line and EnvironmentExtracting Command Line ArgumentsAccessing the EnvironmentReporting Usage ErrorsExtracting the Program NameExtracting Command Line OptionsExtracting Numbers from StringsSummaryExercises
3 TIME, DATES, AND LOCALES
Learning System ProgrammingOrganization of Common CodeFunctions for Extracting NumbersCommon Error-Handling FunctionsFile OrganizationPlanning Our First System ProgramDesigning the First Version of spl_dateAbout Calendar Time in UnixBroken-Down TimeCalendar Time System CallsTime Conversion FunctionsDesigning a Second Version of spl_dateDesigning a Third Version of spl_dateThe User InterfaceProgram LogicWorking with LocalesLocale CategoriesAbout Time ZonesThe Command-Level Interface to LocalesThe Structure of LocalesThe Programming Interface to LocalesAn Internationalized Version of the spl_date ProgramOther Ways to Internationalize ProgramsLocale ObjectsSummaryExercises
4 BASIC CONCEPTS OF FILE I/O
High-Level vs. Low-Level File I/OUniversal I/OFile Permissions RevisitedApplying the UmaskSetting and Getting UmasksPropagating UmasksA Process’s User IDsThe setuid BitInput/Output MechanicsStandard File DescriptorsThe Kernel I/O InterfaceOpening FilesClosing FilesReading from FilesWriting to FilesWriting a copy CommandDesign of the copy ProgramImplementation of the copy ProgramTesting of the copy ProgramThe Universality of the copy ProgramTiming ProgramsBuffering and Running TimeSummaryExercises
5 FILE I/O AND LOGIN ACCOUNTING
Controlling the Position of I/O OperationsThe lseek() System CallFile HolesDisplaying Last Login InformationThe lastlog CommandThe lastlog FileThe lastlog StructureUsernames, User IDs, and the passwd FileThe Password DatabaseAccessing All User EntriesDeveloping a lastlog ProgramDesign ConsiderationsProgram LogicWriting the ProgramDeveloping a last CommandLogin RecordsThe utmp StructureThe utmpx APILogins, Logouts, and the utmp and wtmp FilesA Program to Show the utmp and wtmp FilesAnalysis of the wtmp FileDesigning the spl_last ProgramUser Space Buffering of InputSummaryExercises
6 OVERVIEW OF FILESYSTEMS AND FILES
Disks and Disk PartitionsDisk GeometryDisk Device DriversDisk PartitioningMany, Many FilesystemsFilesystems Supported by LinuxThe Ext FilesystemsFilesystem StructurePartition LayoutBlock Group LayoutPerformance ConsiderationsThe Kernel’s Filesystem InterfaceCreating a New FileWriting Data to a FileThe Virtual FilesystemExploring the Filesystem APIThe stat CommandThe stat() System CallThe stat StructureThe File ModeThe setgid BitThe sticky BitAn Example lstat ProgramThe statx() System CallThe statx Data StructureCalling statx()Writing an spl_stat CommandDesigning the main() FunctionDesigning the print_statx() FunctionWriting the Auxiliary FunctionsDesigning an Enhanced spl_stat CommandWriting an spl_statfs CommandThe statfs() System CallThe statvfs() Library FunctionA Hybrid SolutionTesting spl_statfsSummaryExercises
7 THE DIRECTORY HIERARCHY
Directory StructureProcessing DirectoriesThe readdir() Library FunctionThe dirent StructureDirectory StreamsThe opendir() Library FunctionThe closedir() Library FunctionA Simple ls ProgramOther Functions in the Directory APIThe telldir() and seekdir() Library FunctionsThe scandir() Library FunctionProcessing the Directory HierarchyMounting File SystemsAn Example of Filesystem MountingCommands for Finding Mount PointsDuplicate Inode NumbersTree WalksA Recursive Tree Walk Using readdir()A Recursive Tree Walk Using scandir()The nftw() Tree Walk FunctionWriting a du CommandThe fts Tree Traversal FunctionsThe pwd CommandAn Exercise in Constructing a Directory TreeA Strategy for Implementing the pwd CommandSummaryExercises
8 INTRODUCTION TO SIGNALS
The Role of SignalsA Signal Delivery ExampleSources of SignalsSignal ConceptsThe Lifetime of a SignalSignal TypesBasic Signal HandlingThe signal() System CallThe System V signal() SemanticsSending SignalsBlocking SignalsSignal SetsThe sigprocmask() FunctionThe sigaction() System CallThe sigaction StructureSignal Information Passed to the HandlerEffect of sa_flags on Signal Handler ExecutionGuidance on Designing Signal HandlersSummaryExercises
9 TIMERS AND SLEEP FUNCTIONS
Keeping Track of TimeAlarm Clocks and TimersSleep Functions and TimersTime, Clocks, and TimingOverviewHardware Clocks and Hardware TimersThe System ClockHigh-Resolution Sleep FunctionsThe nanosleep() System CallThe clock_nanosleep() System CallSoftware TimersThe alarm() System CallA Progress Bar Based on AlarmsInterval TimersOverviewPOSIX TimersA POSIX Timer-Based Progress BarResource MonitorsReal-Time Signals and Multiple TimersSummaryExercises
10 PROCESS FUNDAMENTALS
Processes RevisitedThe Process TreeProcess GroupsSessionsForeground and Background Processes and Process GroupsProgram FilesThe Contents of an Executable FileThe Executable and Linking FormatThe Virtual Memory Layout of a ProcessThe Text SegmentThe Initialized Data SegmentThe Uninitialized Data SegmentThe HeapThe Stack SegmentA Program That Displays Virtual Memory LocationsThe Kernel’s Process RepresentationProcess MetadataOverview of the Process DescriptorThe proc PseudofilesystemNumbered DirectoriesThe Magic of /procUseful Per-Process FilesAn ancestors CommandA Simple ps CommandSummaryExercises
11 PROCESS CREATION AND TERMINATION
The Lifetime of a ProcessCreating ProcessesThe Basics of fork()The Child’s Memory ImageThe Child’s Process DescriptorSharing of Open FilesPotential Race ConditionsProcess Synchronization with SignalsOther Functions That Create ProcessesTerminating ProcessesExecuting ProgramsThe execve() System CallThe exec() Library FunctionsWaiting for ChildrenThe wait() and waitpid() System CallsThe waitid() System CallThe SIGCHLD Signal and Asynchronous WaitingPutting It All Together: A Simple ShellThe system() Library FunctionSummaryExercises
12 INTRODUCTION TO INTERPROCESS COMMUNICATION
Why Do We Need IPC?An Overview of Interprocess CommunicationShared Memory MethodsData Transfer MethodsTwo Different APIsSummary of the Common IPC FacilitiesPOSIX Shared MemoryOverviewThe Shared Memory APIA Shared Memory Example ProgramPointer Pitfalls in Shared MemoryRace ConditionsSemaphoresOverviewSystem V SemaphoresPOSIX SemaphoresA Shared Memory Producer Consumer ProgramPOSIX Message QueuesA Simple Message Queue ExampleMessage Queues and Asynchronous NotificationA Program Receiving Asynchronous NotificationsSummaryExercises
13 PIPES AND FIFOS
An Overview of PipesPipe BasicsUnnamed PipesThe Behavior of Read Operations on PipesThe Behavior of Write Operations on PipesA Producer-Consumer ExampleA Shell Pipe SimulationBest Practices Regarding PipesThe popen() and pclose() Library FunctionsFIFOsCreating Named Pipes in the ShellCreating FIFOsOpening FIFOsPutting It All Together: A Simple FIFO-Based Server-Like ProgramSummaryExercises
14 CLIENT-SERVER APPLICATIONS AND DAEMONS
Introduction to Client-Server ApplicationsSystem Logging FacilitiesDaemonsOverviewConverting Processes into DaemonsAn Iterative ServerOverview of the ApplicationThe spl_calc Common Header FileThe spl_calc Client ProgramThe spl_calc Server ProgramA Concurrent ServerThe Concurrent Server ClientThe Concurrent ServerSummaryExercises
15 INTRODUCTION TO THREADS
BackgroundThreads and ProcessesSupport in the KernelPros and Cons of MultithreadingShared Resources and AttributesProgram Design Considerations with ThreadsOverview of the Pthreads LibraryThread ManagementCreating a ThreadExiting a ThreadJoining a ThreadPassing Data to ThreadsIdentifying ThreadsDetaching ThreadsCanceling a ThreadSetting Thread Stack SizeSignals and ThreadsThread-Directed SignalsProcess-Directed SignalsSignal Masks and DispositionsA Multithreaded Concurrent ServerSummaryExercises
16 THREAD SYNCHRONIZATION
Correctness and Performance ConsiderationsMutexesDeclaring and Initializing a MutexLocking and Unlocking a MutexDestroying a MutexA Program Using a Normal MutexOther Types of MutexesCondition VariablesWhy Do We Need Condition Variables?The Typical Steps for Using Condition VariablesDeclaring and Initializing a Condition VariableWaiting on a Condition VariableSignaling a Condition VariableDestroying a Condition VariableCondition AttributesA Multithreaded Multiple Producer, Multiple Consumer ProgramBarrier SynchronizationPthreads BarriersA Program Using Barrier SynchronizationRead-Write LocksRead-Write Lock API OverviewUse and Semantics of Read-Write LocksFurther Details About Pthreads Read-Write LocksRead-Write Lock ExampleSummaryExercises
17 ALTERNATIVE METHODS OF I/O
Nonblocking I/OEnabling Nonblocking I/OA Program to Demonstrate Nonblocking InputSignal-Driven I/OOverviewProcedure for Enabling Signal-Driven I/OEvents Causing Signal GenerationReal-Time Signals and Signal-Driven I/OA Program Using Signal-Driven I/OPOSIX Asynchronous I/OOverviewThe AIO APIPerformance Benefits of Asynchronous I/O with Disk FilesAn AIO-Based Implementation of spl_cp1.cMultiplexed I/OOverviewThe select() System CallAn Example ProgramSummaryExercises
18 TERMINALS AND TERMINAL I/O
About Interactive ProgramsAn Overview of TerminalsAn ExperimentAn ExplanationTerminal DriversTerminal Driver StructureThe Terminal Driver as Seen from the ShellCategories of Terminal AttributesThe Terminal Driver APITerminal SwitchesTerminal Special CharactersTerminal Attribute ModificationWriting an spl_stty CommandProgram Data StructuresThe main() Function of spl_sttyFunctions That Display AttributesFunctions That Set AttributesThe ioctl() System CallThe Form of an ioctl() CallSummaryExercises
19 INTERACTIVE PROGRAMMING AND THE NCURSES LIBRARY
Canonical and Noncanonical ModesCanonical ModeOverview of Noncanonical ModesThe MIN and TIME ParametersAn Interactive Program in Noncanonical ModeProgram Features and IssuesTerminal Control FunctionsGlobal Constants, Types, and VariablesSupport FunctionsThe sprite.c main() FunctionCurses and the ncurses LibraryHistory, Standards, and NamesTerminologyCompiling, Building, and Running Curses ProgramsCurses BasicsThe Curses APIA Program with Tiled WindowsA Curses Version of sprite.cThe top ProgramRequirements of a Simplified top CommandDesign ConsiderationsInput Mode and the CursorScreen ManagementData StructuresSorting FunctionsAcquiring and Storing the DataAcquiring Summary DataAcquiring Per-Process DataThe main() FunctionConcluding ThoughtsSummaryExercises
A CREATING LIBRARIES
About LibrariesStatic vs. Shared Libraries in UnixIdentifying LibrariesCreating a Static LibraryUsing (Linking to) a Static LibraryCreating a Shared LibraryShared Library NamesSteps to Create the LibraryUsing a Shared Library
B UNICODE AND UTF-8
BackgroundTerminologyUnicodeUTF-8Conversion Example 1Conversion Example 2
C DATE AND TIME FORMAT SPECIFIERS
BIBLIOGRAPHY
INDEX

Content preview from System Programming in Linux

6OVERVIEW OF FILESYSTEMS AND FILES

Chapter opening image from the book’s cover; shows a sunflower.

In Chapter 1, we introduced the basic concepts of files, directories, and filesystems. The online chapter, “Working in the Command Line Interface,” describes the user-level interface to the filesystem, namely the basic commands for working with files and directories. Here, we dig a little deeper into the hardware and software layers on which this interface is built.

We begin by examining the physical layer that underlies a typical disk-based filesystem. After that, we discuss the different types of filesystems supported by Linux, as well as the Linux virtual file system (VFS). We then describe the various ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0642572230128Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

System Programming in Linux

by Stewart N. Weiss

6OVERVIEW OF FILESYSTEMS AND FILES

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.