Linux系统编程-Linux Unix技术丛书 pdf下载

Linux是世界上流行的开源操作系统。Linux系统编程技术将使你能够使用自己的系统程序扩展Linux操作 系统，并与系统上的其他程序进行通信。 

本书探讨了Linux文件系统及其基本命令、内置手册页、GNU编译器集合（GCC）和Linux系统调用；讲述了如何处理程序中的错误，以及如何捕获错误并打印错误相关信息；介绍了在系统上读写文件的多种方法，包括使用流和文件描述符。随着学习的不断深入，你将深入研究创建进程、创建僵尸进程和守护进程，并学习使用systemd处理守护进程的方法；了解如何创建共享库，并探索不同类型的进程间通信（IPC）；还将学习如何使用POSIX线程编写程序，以及如何使用GNU调试器（GDB）和Valgrind调试程序。 

学完本书，你将能够在Linux系统中开发自己的系统程序，包括守护进程、工具、客户端和过滤器。 

通过阅读本书，你将： 

◎ 了解如何使用各种系统调用为Linux系统编写程序。 

◎ 深入研究POSIX函数的工作原理。 

◎ 理解并学会使用信号、管道、IPC和流程管理等关键概念。 

◎ 了解如何集成程序与Linux系统。 

◎ 探索高级主题，例如，文件系统操作、创建共享库和调试程序。 

◎ 全面了解如何使用Valgrind调试程序。

第1章　获取必要的工具并编写

第一个Linux程序　1

1.1　技术要求　1

1.2　安装GCC和GNU Make　2

1.2.1　准备工作　3

1.2.2　实践步骤　3

1.2.3　它是如何工作的　4

1.3　安装GDB和Valgrind　5

1.3.1　准备工作　5

1.3.2　实践步骤　5

1.3.3　它是如何工作的　6

1.4　在Linux中编写一个简单的

C程序　7

1.4.1　准备工作　7

1.4.2　实践步骤　7

1.4.3　它是如何工作的　8

1.4.4　更多　9

1.5　编写一个解析命令行选项

的程序　10

1.5.1　准备工作　10

1.5.2　实践步骤　10

1.5.3　它是如何工作的　12

1.6　在内置手册页中查找信息　13

1.6.1　准备工作　13

1.6.2　实践步骤　14

1.6.3　它是如何工作的　14

1.6.4　更多　15

1.7　搜索手册以获取信息　15

1.7.1　准备工作　15

1.7.2　实践步骤　15

1.7.3　它是如何工作的　15

1.7.4　更多　16

第2章　使你的程序易于脚本化　17

2.1　技术要求　18

2.2　返回值以及如何读取它们　18

2.2.1　准备工作　18

2.2.2　实践步骤　18

2.2.3　它是如何工作的　20

2.2.4　更多　21

2.2.5　参考　21

2.3　使用有意义的返回值退出程序　21

2.3.1　准备工作　21

2.3.2　实践步骤　21

2.3.3　它是如何工作的　24

2.3.4　更多　25

2.4　重定向标准输入、标准输出

和标准错误　25

2.4.1　准备工作　25

2.4.2　实践步骤　25

2.4.3　它是如何工作的　27

2.4.4　更多　28

2.5　使用管道连接程序　28

2.5.1　准备工作　28

2.5.2　实践步骤　28

2.5.3　它是如何工作的　29

2.5.4　更多　30

2.5.5　参考　30

2.6　写入标准输出和标准错误　30

2.6.1　实践步骤　30

2.6.2　它是如何工作的　32

2.6.3　更多　32

2.7　从标准输入读取　33

2.7.1　准备工作　33

2.7.2　实践步骤　33

2.7.3　它是如何工作的　34

2.7.4　更多　35

2.8　编写一个管道友好的程序　36

2.8.1　准备工作　36

2.8.2　实践步骤　36

2.8.3　它是如何工作的　38

2.8.4　更多　39

2.9　将结果重定向到文件　39

2.9.1　准备工作　40

2.9.2　实践步骤　40

2.9.3　它是如何工作的　43

2.9.4　更多　44

2.10　读取环境变量　44

2.10.1　准备工作　44

2.10.2　实践步骤　45

2.10.3　它是如何工作的　46

2.10.4　更多　47

第3章　深入探索Linux中的C语言　48

3.1　技术要求　49

3.2　使用GNU编译器套件

链接库　49

3.2.1　准备工作　49

3.2.2　实践步骤　49

3.2.3　它是如何工作的　52

3.2.4　更多　53

3.3　切换C标准　54

3.3.1　准备工作　54

3.3.2　实践步骤　54

3.3.3　它是如何工作的　56

3.3.4　更多　57

3.4　使用系统调用　57

3.4.1　准备工作　58

3.4.2　实践步骤　58

3.4.3　它是如何工作的　60

3.4.4　更多　61

3.5　获取Linux和类UNIX头

文件信息　61

3.5.1　准备工作　61

3.5.2　实践步骤　62

3.5.3　它是如何工作的　63

3.5.4　更多　63

3.6　定义功能测试宏　63

3.6.1　准备工作　64

3.6.2　实践步骤　64

3.6.3　它是如何工作的　67

3.6.4　更多　68

3.7　编译过程的4个步骤　68

3.7.1　准备工作　68

3.7.2　实践步骤　68

3.7.3　它是如何工作的　71

3.8　使用Make编译　72

3.8.1　准备工作　72

3.8.2　实践步骤　73

3.8.3　它是如何工作的　74

3.9　使用GCC选项编写一个

通用的Makefile　74

3.9.1　准备工作　74

3.9.2　实践步骤　75

3.9.3　它是如何工作的　75

3.9.4　更多　75

3.10　编写一个简单的Make file　76

　3.10.1　准备工作　76

　3.10.2　实践步骤　76

　3.10.3　它是如何工作的　77

3.11　编写一个更高级的Makefile　77

　3.11.1　准备工作　78

　3.11.2　实践步骤　78

　3.11.3　它是如何工作的　82

第4章　处理程序中的错误　84

4.1　技术要求　85

4.2　为什么错误处理在系统编程

中很重要　85

4.2.1　准备工作　85

4.2.2　实践步骤　85

4.2.3　它是如何工作的　87

4.3　处理常见的错误　87

4.3.1　准备工作　87

4.3.2　实践步骤　88

4.3.3　它是如何工作的　90

4.4　错误处理和errno　90

4.4.1　准备工作　91

4.4.2　实践步骤　91

4.4.3　它是如何工作的　92

4.5　处理更多errno宏　93

4.5.1　准备工作　93

4.5.2　实践步骤　93

4.5.3　它是如何工作的　94

4.5.4　更多　94

4.6　使用errno和strerror()　94

4.6.1　准备工作　95

4.6.2　实践步骤　95

4.6.3　更多　96

4.7　使用errno和perror()　96

4.7.1　准备工作　96

4.7.2　实践步骤　96

4.7.3　更多　98

4.8　返回错误值　98

4.8.1　准备工作　98

4.8.2　实践步骤　98

4.8.3　它是如何工作的　99

4.8.4　更多　99

第5章　使用文件I/O和文件

系统操作　100

5.1　技术要求　101

5.2　读取索引节点信息并学习

文件系统　101

5.2.1　准备工作　101

5.2.2　实践步骤　101

5.2.3　它是如何工作的　103

5.3　创建软链接和硬链接　104

5.3.1　准备工作　104

5.3.2　实践步骤　104

5.3.3　它是如何工作的　107

5.3.4　更多　108

5.4　创建文件并更新时间戳　108

5.4.1　准备工作　108

5.4.2　实践步骤　108

5.4.3　它是如何工作的　110

5.4.4　更多　110

5.5　删除文件　111

5.5.1　准备工作　111

5.5.2　实践步骤　111

5.5.3　它是如何工作的　112

5.6　获得访问权限和所有权　112

5.6.1　准备工作　112

5.6.2　实践步骤　112

5.6.3　它是如何工作的　114

5.7　设置访问权限和所有权　117

5.7.1　准备工作　117

5.7.2　实践步骤　117

5.7.3　它是如何工作的　121

5.7.4　更多　122

5.8　使用文件描述符写入文件　122

5.8.1　准备工作　122

5.8.2　实践步骤　123

5.8.3　它是如何工作的　124

5.8.4　更多　124

5.9　使用文件描述符读取文件　125

5.9.1　准备工作　125

5.9.2　实践步骤　125

5.9.3　它是如何工作的　127

5.9.4　更多　127

5.10　使用流写入文件　127

　5.10.1　准备工作　128

　5.10.2　实践步骤　128

　5.10.3　它是如何工作的　129

　5.10.4　参考　129

5.11　使用流读取文件　130

　5.11.1　准备工作　130

　5.11.2　实践步骤　130

　5.11.3　它是如何工作的　131

　5.11.4　更多　131

5.12　使用流读写二进制数据　131

　5.12.1　准备工作　132

　5.12.2　实践步骤　132

　5.12.3　它是如何工作的　133

　5.12.4　更多　134

5.13　使用lseek()在文件中移动　134

　5.13.1　准备工作　134

　5.13.2　实践步骤　134

　5.13.3　它是如何工作的　136

5.14　使用fseek()在文件中移动　137

　5.14.1　准备工作　137

　5.14.2　实践步骤　137

　5.14.3　它是如何工作的　138

　5.14.4　更多　138

第6章　创建进程和使用作业控制　139

6.1　技术要求　140

6.2　探索如何创建进程　140

6.2.1　准备工作　140

6.2.2　实践步骤　140

6.2.3　它是如何工作的　142

6.2.4　更多　142

6.3　在Bash中使用作业控制　142

6.3.1　准备工作　143

6.3.2　实践步骤　143

6.3.3　它是如何工作的　144

6.4　使用信号控制和终止进程　144

6.4.1　准备工作　144

6.4.2　实践步骤　145

6.4.3　它是如何工作的　147

6.4.4　参考　148

6.5　在进程中使用execl()替换

运行的程序　148

6.5.1　准备工作　149

6.5.2　实践步骤　149

6.5.3　它是如何工作的　150

6.5.4　参考　150

6.6　创建新进程　150

6.6.1　准备工作　150

6.6.2　实践步骤　150

6.6.3　它是如何工作的　151

6.6.4　更多　152

6.7　在创建的进程中执行新程序　152

6.7.1　准备工作　152

6.7.2　实践步骤　152

6.7.3　它是如何工作的　154

6.8　使用system()启动一个新进程　154

6.8.1　准备工作　155

6.8.2　实践步骤　155

6.8.3　它是如何工作的　156

6.9　创建僵尸进程　156

6.9.1　准备工作　156

6.9.2　实践步骤　156

6.9.3　它是如何工作的　159

6.9.4　更多　159

6.10　了解孤儿进程　159

6.10.1　准备工作　159

6.10.2　实践步骤　160

6.10.3　它是如何工作的　161

6.10.4　参考　162

6.11　创建守护进程　162

6.11.1　准备工作　162

6.11.2　实践步骤　162

6.11.3　它是如何工作的　165

6.11.4　更多　166

6.12　实现信号处理程序　166

6.12.1　准备工作　167

6.12.2　实践步骤　167

6.12.3　它是如何工作的　170

6.12.4　更多　170

第7章　使用systemd处理守护进程　171

7.1　技术要求　171

7.2　了解systemd　172

7.2.1　准备工作　172

7.2.2　实践步骤　172

7.2.3　它是如何工作的　172

7.2.4　更多　173

7.2.5　参考　173

7.3　为守护进程编写单元文件　173

7.3.1　准备工作　173

7.3.2　实践步骤　174

7.3.3　它是如何工作的　175

7.3.4　更多　175

7.3.5　参考　175

7.4　启用和禁用服务，以及启动和

停止服务　176

7.4.1　准备工作　176

7.4.2　实践步骤　176

7.4.3　它是如何工作的　178

7.5　为systemd创建现代守护进程　178

7.5.1　准备工作　178

7.5.2　实践步骤　179

7.5.3　它是如何工作的　180

7.5.4　参考　180

7.6　使新的守护进程成为systemd

服务　181

7.6.1　准备工作　181

7.6.2　实践步骤　181

7.6.3　它是如何工作的　182

7.7　查阅日志　182

7.7.1　准备工作　182

7.7.2　实践步骤　182

7.7.3　它是如何工作的　184

7.7.4　参考　184

第8章　创建共享库　185

8.1　技术要求　185

8.2　库及其重要性　186

8.2.1　准备工作　186

8.2.2　实践步骤　186

8.2.3　它是如何工作的　188

8.2.4　更多　188

8.3　创建静态库　188

8.3.1　准备工作　188

8.3.2　实践步骤　188

8.3.3　它是如何工作的　189

8.3.4　参考　190

8.4　使用静态库　190

8.4.1　准备工作　190

8.4.2　实践步骤　190

8.4.3　它是如何工作的　192

8.5　创建动态库　192

8.5.1　准备工作　192

8.5.2　实践步骤　192

8.5.3　它是如何工作的　193

8.5.4　更多　193

8.5.5　参考　194

8.6　在系统上安装动态库　194

8.6.1　准备工作　194

8.6.2　实践步骤　194

8.6.3　它是如何工作的　195

8.7　在程序中使用动态库　195

8.7.1　准备工作　196

8.7.2　实践步骤　196

8.7.3　它是如何工作的　196

8.7.4　更多　197

8.7.5　参考　197

8.8　编译静态链接程序　197

8.8.1　准备工作　197

8.8.2　实践步骤　197

8.8.3　它是如何工作的　199

第9章　终端I/O及改变终端行为　200

9.1　技术要求　201

9.2　查看终端信息　201

9.2.1　准备工作　201

9.2.2　实践步骤　 201

9.2.3　它是如何工作的　202

9.2.4　参考　203

9.3　使用stty改变终端的设置　203

9.3.1　准备工作　203

9.3.2　实践步骤　203

9.3.3　它是如何工作的　204

9.4　调查TTY和PTY设备，

并向它们写入数据　204

9.4.1　实践步骤　204

9.4.2　它是如何工作的　206

9.4.3　更多　206

9.4.4　参考　206

9.5　检查是否是TTY设备　206

9.5.1　准备工作　206

9.5.2　实践步骤　207

9.5.3　它是如何工作的　208

9.5.4　参考　208

9.6　创建一个PTY　208

9.6.1　准备工作　209

9.6.2　实践步骤　209

9.6.3　它是如何工作的　211

9.6.4　参考　211

9.7　关闭密码提示回显　211

9.7.1　准备工作　211

9.7.2　实践步骤　212

9.7.3　它是如何工作的　213

9.7.4　更多　213

9.8　读取终端的大小　214

9.8.1　准备工作　214

9.8.2　实践步骤　214

9.8.3　它是如何工作的　215

9.8.4　更多　215

9.8.5　参考　215

第10章　使用不同类型的IPC　216

10.1　技术要求　217

10.2　使用IPC信号—为守护

构建客户端　217

　10.2.1　准备工作　217

　10.2.2　实践步骤　217

　10.2.3　它是如何工作的　220

　10.2.4　参考　221

10.3　使用管道通信　221

　10.3.1　准备工作　221

　10.3.2　实践步骤　221

　10.3.3　它是如何工作的　222

　10.3.4　参考　223

10.4　FIFO—在shell中使用它　223

　10.4.1　准备工作　223

　10.4.2　实践步骤　223

　10.4.3　它是如何工作的　224

　10.4.4　更多　225

　10.4.5　参考　225

10.5　FIFO—构建发送者　225

　10.5.1　准备工作　225

　10.5.2　实践步骤　225

　10.5.3　它是如何工作的　228

　10.5.4　参考　228

10.6　FIFO—构建接收者　228

　10.6.1　准备工作　228

　10.6.2　实践步骤　229

　10.6.3　它是如何工作的　229

　10.6.4　参考　230

10.7　消息队列—构建发送者　230

　10.7.1　准备工作　230

　10.7.2　实践步骤　230

　10.7.3　它是如何工作的　231

　10.7.4　参考　232

10.8　消息队列—构建接收者　232

　10.8.1　准备工作　232

　10.8.2　实践步骤　232

　10.8.3　它是如何工作的　234

　10.8.4　参考　235

10.9　在父子进程间使用共享

内存通信　235

　10.9.1　准备工作　235

　10.9.2　实践步骤　235

　10.9.3　它是如何工作的　237

　10.9.4　参考　238

10.10　在不相关的进程中使用

共享内存　238

　10.10.1　准备工作　238

　10.10.2　实践步骤　238

　10.10.3　它是如何工作的　242

　10.10.4　参考　242

10.11　UNIX套接字编程—构建

发送者　242

　10.11.1　准备工作　242

　10.11.2　实践步骤　242

　10.11.3　它是如何工作的　246

　10.11.4　参考　246

10.12　UNIX套接字编程—构建

接收者　246

　10.12.1　准备工作　247

　10.12.2　实践步骤　247

　10.12.3　它是如何工作的　249

　10.12.4　参考　249

第11章　在程序中使用线程　250

11.1　技术要求　250

11.2　编写第一个线程化程序　251

　11.2.1　准备工作　251

　11.2.2　实践步骤　251

　11.2.3　它是如何工作的　254

　11.2.4　更多　255

　11.2.5　参考　255

11.3　从线程中读取返回值　256

　11.3.1　准备工作　256

　11.3.2　实践步骤　256

　11.3.3　它是如何工作的　259

11.4　触发竞态条件　259

　11.4.1　准备工作　259

　11.4.2　实践步骤　259

　11.4.3　它是如何工作的　261

11.5　使用互斥锁来防止竞态条件　262

　11.5.1　准备工作　262

　11.5.2　实践步骤　262

　11.5.3　它是如何工作的　264

　11.5.4　参考　265

11.6　更有效的互斥锁编程　265

　11.6.1　准备工作　265

　11.6.2　实践步骤　266

　11.6.3　它是如何工作的　266

11.7　使用条件变量　267

　11.7.1　准备工作　267

　11.7.2　实践步骤　267

　11.7.3　它是如何工作的　271

　11.7.4　参考　271

第12章　调试程序　272

12.1　技术要求　272

12.2　开始GDB　273

　12.2.1　准备工作　273

　12.2.2　实践步骤　273

　12.2.3　它是如何工作的　276

　12.2.4　更多　276

12.3　使用GDB进入函数内部　277

　12.3.1　准备工作　277

　12.3.2　实践步骤　277

　12.3.3　它是如何工作的　279

12.4　使用GDB观察内存　279

　12.4.1　准备工作　280

　12.4.2　实践步骤　280

　12.4.3　它是如何工作的　281

　12.4.4　更多　281

　12.4.5　参考　281

12.5　在运行期间修改变量　281

　12.5.1　准备工作　281

　12.5.2　实践步骤　282

　12.5.3　它是如何工作的　283

12.6　在新创建的程序中使用GDB　283

　12.6.1　准备工作　283

　12.6.2　实践步骤　283

　12.6.3　它是如何工作的　286

　12.6.4　更多　286

12.7　在多线程中调试程序　287

　12.7.1　准备工作　287

　12.7.2　实践步骤　287

　12.7.3　它是如何工作的　289

　12.7.4　更多　289

　12.7.5　参考　289

12.8　使用Valgrind找到一个简单

的内存泄漏　289

　12.8.1　准备工作　290

　12.8.2　实践步骤　290

　12.8.3　它是如何工作的　291

　12.8.4　参考　292

12.9　使用Valgrind找到缓冲区溢出　292

　12.9.1　准备工作　292

　12.9.2　实践步骤　292

　12.9.3　它是如何工作的　293

　12.9.4　更多　293