Book Image

Linux System Programming Techniques

By : Jack-Benny Persson

5 (1)

Book Image

Linux System Programming Techniques

5 (1)

By: Jack-Benny Persson

Overview of this book

Linux is the world's most popular open source operating system (OS). Linux System Programming Techniques will enable you to extend the Linux OS with your own system programs and communicate with other programs on the system. The book begins by exploring the Linux filesystem, its basic commands, built-in manual pages, the GNU compiler collection (GCC), and Linux system calls. You'll then discover how to handle errors in your programs and will learn to catch errors and print relevant information about them. The book takes you through multiple recipes on how to read and write files on the system, using both streams and file descriptors. As you advance, you'll delve into forking, creating zombie processes, and daemons, along with recipes on how to handle daemons using systemd. After this, you'll find out how to create shared libraries and start exploring different types of interprocess communication (IPC). In the later chapters, recipes on how to write programs using POSIX threads and how to debug your programs using the GNU debugger (GDB) and Valgrind will also be covered. By the end of this Linux book, you will be able to develop your own system programs for Linux, including daemons, tools, clients, and filters.

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the color images

Conventions used

Chapter 1: Getting the Necessary Tools and Writing Our First Linux Programs

Chapter 1: Getting the Necessary Tools and Writing Our First Linux Programs

Technical requirements

Installing GCC and GNU Make

Installing GDB and Valgrind

Writing a simple C program for Linux

Writing a program that parses command-line options

Looking up information in the built-in manual page

Searching the manual for information

Free Chapter

Chapter 2: Making Your Programs Easy to Script

Chapter 2: Making Your Programs Easy to Script

Technical requirements

Return values and how to read them

Exiting a program with a relevant return value

Redirecting stdin, stdout, and stderr

Connecting programs using pipes

Writing to stdout and stderr

Reading from stdin

Writing a pipe-friendly program

Redirecting the result to a file

Reading environment variables

Chapter 3: Diving Deep into C in Linux

Chapter 3: Diving Deep into C in Linux

Technical requirements

Linking against libraries using GCC

Changing C standards

Using system calls – and when not to use them

Getting information about Linux- and Unix-specific header files

Defining feature test macros

Looking at the four stages of compilation

Compiling with Make

Writing a generic Makefile with GCC options

Writing a simple Makefile

Writing a more advanced Makefile

Chapter 4: Handling Errors in Your Programs

Chapter 4: Handling Errors in Your Programs

Technical requirements

Why error handling is important in system programming

Handling some common errors

Error handling and errno

Handling more errno macros

Using errno with strerror()

Using errno with perror()

Returning an error value

Chapter 5: Working with File I/O and Filesystem Operations

Chapter 5: Working with File I/O and Filesystem Operations

Technical requirements

Reading inode information and learning the filesystem

Creating soft links and hard links

Creating files and updating the timestamp

Getting access rights and ownership

Setting access rights and ownership

Writing to files with file descriptors

Reading from files with file descriptors

Writing to files with streams

Reading from files with streams

Reading and writing binary data with streams

Moving around inside a file with lseek()

Moving around inside a file with fseek()

Chapter 6: Spawning Processes and Using Job Control

Chapter 6: Spawning Processes and Using Job Control

Technical requirements

Exploring how processes are created

Using job control in Bash

Controlling and terminating processes using signals

Replacing the program in a process with execl()

Forking a process

Executing a new program in a forked process

Starting a new process with system()

Creating a zombie process

Learning about what orphans are

Creating a daemon

Implementing a signal handler

Chapter 7: Using systemd to Handle Your Daemons

Chapter 7: Using systemd to Handle Your Daemons

Technical requirements

Getting to know systemd

Writing a unit file for a daemon

Enabling and disabling a service – and starting and stopping it

Creating a more modern daemon for systemd

Making the new daemon a systemd service

Reading the journal

Chapter 8: Creating Shared Libraries

Chapter 8: Creating Shared Libraries

Technical requirements

The what and why of libraries

Creating a static library

Using a static library

Creating a dynamic library

Installing the dynamic library on the system

Using the dynamic library in a program

Compiling a statically linked program

Chapter 9: Terminal I/O and Changing Terminal Behavior

Chapter 9: Terminal I/O and Changing Terminal Behavior

Technical requirements

Viewing terminal information

Changing terminal settings with stty

Investigating TTYs and PTYs and writing to them

Checking if it's a TTY

Disabling echo for password prompts

Reading the terminal size

Chapter 10: Using Different Kinds of IPC

Chapter 10: Using Different Kinds of IPC

Technical requirements

Using signals for IPC – building a client for the daemon

Communicating with a pipe

FIFO – using it in the shell

FIFO – building the sender

FIFO – building the receiver

Message queues – creating the sender

Message queues – creating the receiver

Communicating between child and parent with shared memory

Using shared memory between unrelated processes

Unix socket – creating the server

Unix socket – creating the client

Chapter 11: Using Threads in Your Programs

Chapter 11: Using Threads in Your Programs

Technical requirements

Writing your first threaded program

Reading return values from threads

Causing a race condition

Avoiding race conditions with mutexes

Making the mutex program more efficient

Using condition variables

Chapter 12: Debugging Your Programs

Chapter 12: Debugging Your Programs

Technical requirements

Stepping inside a function with GDB

Investigating memory with GDB

Modifying variables during runtime

Using GDB on a program that forks

Debugging programs with multiple threads

Finding a simple memory leak with Valgrind

Finding buffer overflows with Valgrind

Other Books You May Enjoy

Other Books You May Enjoy

Packt is searching for authors like you

Leave a review - let other readers know what you think

Customer Reviews

5 (1)

5 star

100%

4 star

0

3 star

0

2 star

0

1 star

0

Other Books You May Enjoy

If you enjoyed this book, you may be interested in these other books by Packt:

Mastering Linux Device Driver Development

John Madieu

ISBN: 978-1-78934-204-8

Explore and adopt Linux kernel helpers for locking, work deferral, and interrupt management
Understand the Regmap subsystem to manage memory accesses and work with the IRQ subsystem
Get to grips with the PCI subsystem and write reliable drivers for PCI devices
Write full multimedia device drivers using ALSA SoC and the V4L2 framework

Linux Kernel Programming

Kaiwan N Billimoria

ISBN: 978-1-78995-343-5

Write high-quality modular kernel code (LKM framework) for 5.x kernels
Configure and build a kernel from source
Explore the Linux kernel architecture
Get to grips with key internals regarding memory management within the kernel
Understand and work with various dynamic kernel memory alloc/dealloc APIs
Discover key internals aspects...