knative项目提供了信号处理的封装。

import "github.com/knative/pkg/signals"

// 创建默认的信号处理器
stopCh := signals.SetupSignalHandler()


// goroutine应该等待此通道可读，然后清理并退出
go func(stopCh <-chan struct{}){
    <-stopCh
}(stopCh)

The post Go语言系统编程 appeared first on 绿色记忆.

git clone https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git

 根据需要，切换分支。

apt install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc flex libelf-dev bison

cd linux-stable

# 使用当前系统内核配置
cp -v /boot/config-$(uname -r) .config

# 使用图形化界面进行配置
make menuconfig

# 使用字符界面配置
make config

# 在现有的内核设置文件基础上建立一个新的设置文件，只会向用户提供有关新内核特性的问题，
# 在新内核升级的过程 中，make oldconfig非常有用
make oldconfig

# 自动的尽量选择 y 选项
make allyesconfig

# 自动的尽量选择 m 选项
make allmodconfig

你也可以手工直接编辑.config文件。每个选项都可以设置以下值之一：

# 编译
make -j 8

# 编译bzImage
make bzImage

# 安装内核模块到系统
sudo make modules_install
# 安装内核到系统
sudo make install  

更新initramfs，指向最新的内核： 

sudo update-initramfs -c -k 4.15.0

更新GRUB BootLoader：

sudo update-grub

重启后就可以使用新内核了。 

设置内核选项：

make O=build/ defconfig

make O=build/ menuconfig

# Processor type and features ---->
#     [ ]   Randomize the address of the kernel image (KASLR) 

# Kernel hacking  --->
#     [*] Kernel debugging
#     Compile-time checks and compiler options  --->
#         [*] Compile the kernel with debug info
#         [*]   Provide GDB scripts for kernel debugging

然后按正常流程构建。

内核项目本身是基于make的，我们需要将其转换为CMake项目。

首先，安装scan-build

sudo -H pip install scan-build
# 或者
sudo apt install bear

这是一个构建拦截工具（build interceptor） ，它能够拦截make的构建过程，并生成一个

compile_commands.json

拦截构建过程：

cd linux-stable
intercept-build make -j8
# 或者
bear make -j8

# 拦截其它目标
bear make tools/all
bear make bzImage

从compile_commands.json生成CMakeList.txt文件：

cd ..
git clone https://github.com/habemus-papadum/kernel-grok.git
cd linux-stable
../kernel-grok/generate_cmake

如果报头文件找不到的错误，在CMakeList.txt中增加：

set(CMAKE_C_COMPILER "gcc")
include_directories(".")
include_directories("./include")

首先配置并编译好内核，然后在源码目录下执行：

git clone https://github.com/amezin/vscode-linux-kernel.git .vscode

# 生成compile_commands.json
python .vscode/generate_compdb.py
# 如果不是编译的x64内核，则修改c_cpp_properties.json的intelliSenseMode。可选值：
# gcc-x86    gcc-x64    gcc-arm    gcc-arm64

The post Linux内核编程知识集锦 appeared first on 绿色记忆.

当从一个进程连接数据流到另外一个进程时，使用术语“管道”。通常是把一个进程的输出通过管道连接到另外一个进程的输入。Shell命令通过管道字符可以实现命令的连接：

cmd1 | cmd2

#cmd1的标准输入来自终端键盘
#cmd1的标准输出传递给cmd2，作为它的标准输入
#cmd2的标准输出连接到终端屏幕

Linux提供了类似的API，允许通过编程的方式，利用管道在两个程序之间传递数据。在两个程序之间进行数据传递的最简单方式是使用popen/pclose函数：

#include <stdio.h>
/**
 * 允许将另外一个程序作为新进程启动，并可以传递数据或者接收数据
 * @param command 需要运行的程序和参数
 * @param open_mode 打开模式，必须是r或者w
 *     如果是r，被调用程序的输出可以被当前程序使用，通过返回的文件指针进行fread读取
 *     如果是w，当前程序可以通过fwrite向被调用程序发送数据，后者可以在stdin上读取这些数据
 */
FILE *popen( const char *command, const char *open_mode );
/**
 * 关闭文件指针，该函数只有在新进程结束后才会返回，否则会一直阻塞
 */
int pclose( FILE *stream_to_close );

下面是一个简单的示例，执行uname命令并获取其输出：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
    char buffer[BUFSIZ + 1];
    int chars_read;
    memset( buffer, 0, sizeof ( buffer ) );
    FILE *read_fp = popen( "uname -a", "r" ); //创建新进程并读取其标准输出
    if ( read_fp != NULL )
    {
        //像读取文件一样，将新进程的标准输出读取到缓冲区
        chars_read = fread( buffer, sizeof(char), BUFSIZ, read_fp );
        if ( chars_read > 0 )
        {
            printf( "Output: %s\n", buffer );
        }
        pclose( read_fp );
        exit( EXIT_SUCCESS );
    }
    exit( EXIT_FAILURE );
}

在底层，Linux提供了pipe函数，通过该函数可以在两个进程之间传递数据，不需要启动Shell，该函数提供了对读写数据的更多控制：

#include <unistd.h>
/**
 * 创建一个管道，该函数对入参数组填上两个新的文件描述符，然后返回0
 * 返回的两个文件描述符通过一种特殊的方式连接：依据FIFO原则，写入
 * file_descriptor[1]的数据，都可以从file_descriptor[0]中读取回来
 *
 * @param file_descriptor 长度为2的文件描述符数组
 * @return 如果成功返回0否则返回-1并设置errno：
 *     EMFILE：进程使用的文件描述符过多
 *     ENFILE：系统的文件表已满
 *     EFAULT：文件描述符无效
 */
int pipe( int file_descriptor[2] );

初看，pipe函数没有什么价值，但由于fork调用创建新进程时，默认原先打开的文件描述符仍然保持打开状态，因此，管道可以被父子进程共享，从而用来在其间进行数据传递，下面是pipe在父子进程之间使用的例子：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
    int data_processed;
    int file_pipes[2];
    const char some_data[] = "MSG";
    char buffer[BUFSIZ + 1];
    pid_t fork_result;
    memset( buffer, '\0', sizeof ( buffer ) );
    if ( pipe( file_pipes ) == 0 ) //创建一个共享的管道
    {
        fork_result = fork(); //创建子进程
        if ( fork_result == -1 ) exit( EXIT_FAILURE );
        if ( fork_result == 0 )
        {
            //这里是子进程，从文件描述符0中读取数据
            data_processed = read( file_pipes[0], buffer, BUFSIZ );
            printf( "Read %d bytes: %s\n", data_processed, buffer );
            exit( EXIT_SUCCESS );
        }
        else
        {
            //这里是父进程，向文件描述符1中写入数据
            data_processed = write( file_pipes[1], some_data, strlen( some_data ) );
            printf( "Wrote %d bytes\n", data_processed );
        }
    }
    exit( EXIT_SUCCESS );
}

上面的例子中，父子进程运行的是相同的程序，如果两个进程是完全不同的程序呢？通过exec()调用后，只需要将文件描述符传递给新进程就可以继续使用管道了，因为文件描述符本质上只是一个数字而已：

//将管道文件描述符保存到字符串中
sprintf(buffer, "%d", file_pipes[0]);
//传递给子进程
execl("command", buffer, (char *)0);
//读取参数为文件描述符
sscanf(argv[0], "%d", &file_descriptor);
//从文件描述符中读取数据
data_processed = read( file_descriptor, buffer, BUFSIZ );

关于管道的使用，应当注意：

1. 对于已经关闭写端的管道，对其指向read()调用不会阻塞，而会立即返回0。这与读取无效文件描述符不同，后者会返回-1
2. 如果通过fork()调用使用管道，就会存在两个不同的文件描述符可以用来向管道写数据，一个在父进程中，一个在子进程中。只有在父子文件中均把针对管道的写描述符关闭，管道才认为是关闭的，对其进行read才会立即返回

通过管道连接两个进程，具有更加简洁的方法：

if ( fork_result == ( pid_t ) 0 ) // 子进程
{
    close( 0 ); //关闭标准输入
    //复制管道读，根据dup的特点，它将复制为最小数值的文件描述符，即作为标准输入
    dup( file_pipes[0] );
    //关闭管道中两个文件描述符
    close( file_pipes[0] );
    close( file_pipes[1] );
    execlp( "od", "od", "-c", ( char * ) 0 );
}

要在两个不相关（不具备共同祖先）的进程之间传递数据，可以使用命名管道（Named pipe），命名管道又被称为FIFO文件。命名管道是一种特殊类型的文件，在文件系统中以文件名的形式存在，其行为却与前一节所述的管道类似。可以通过Shell命令

mknode

mkfifo

mkfifo /tmp/my_fifo
#尝试读取这个空白的命名管道
cat < /tmp/my_fifo  #阻塞

#在另外一个终端尝试写入这个空白的命名管道
echo "Hello World" > /tmp/my_fifo 
#第一个终端读取到内容并输出在屏幕上

在程序中，可以使用以下两个调用：

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo( const char *filename, mode_t mode );
int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t) 0);

//创建命名管道的例子：
int main()
{
    int res = mkfifo( "/tmp/my_fifo", 0777 ); //尝试创建777权限的文件，当然需要受到用户掩码umask的制约
    if ( res == 0 ) exit( EXIT_SUCCESS );
}

通过open命令访问FIFO文件时，需要注意一个限制：不能以

O_RDWR

O_NONBLOCK

//调用一直阻塞，除非另外一个进程以写方式打开同一命名管道
open( const char *path, O_RDONLY );
//即使没有其它进程以写模式打开同一命名管道，调用也会成功并立即返回
open(const char *path, O_RDONLY | O_NONBLOCK);
//调用一直阻塞，除非另外一个进程以读方式打开同一命名管道
open( const char *path, O_WRONLY );
//调用会立即返回，但是如果没有另外一个进程以读模式打开命名管道，调用将返回-1，并且FIFO也不会被打开
open(const char *path, O_WRONLY | O_NONBLOCK);

与线程之间通信的信号量类似，Linux还提供了更通用的，可以在不同进程之间进行通信的信号量机制，这些信号量接口都是针对成组的通用信号量进行操作，而不是针对一个二进制信号量。

#include <sys/sem.h>
/**
 * 创建一个新的信号量，或者获取一个已经存在的信号量
 * @param key  一个整数，不相关的进程可以通过同一key来访问同一信号量
 *             特殊值IPC_PRIVATE表示创建一个只有当前进程才能看见的信号量
 * @param num_sems 需要的信号量的数目，一般为1
 * @param sem_flags 位或标记。低9位类似于文件权限；IPC_CREAT表示创建一个新的信号量；
 *                  IPC_EXCL | IPC_CREAT 表示确保获得一个新的、唯一的信号量，如果
 *                  信号量已经存在，会返回错误
 * @return 成功返回正整数，表示信号量的唯一标识（sem_id）；失败返回-1
 */
int semget( key_t key, int num_sems, int sem_flags );
/**
 * 用于改变信号量的值，这是一个原子操作
 * @param sem_id 信号量的唯一标识
 * @param sem_ops 指向一个结构的指针
 * @param num_sem_ops
 *
 */
struct sembuf
{
    short sem_num; //信号量的数量，除非需要使用一组信号量，否则取值0
    short sem_op;  //信号量在一次操作中需要改变的值，可以使用非1值来改变信号量
                   //通常只会用到两个值：-1表示P操作，表示等待信号量可用；+1表示V操作，表示发送信号量可用的信息
    short sem_flg; //通常设置为SEM_UNDO，它使得操作系统跟踪该信号量的修改情况
                   //如果进程没有释放持有的信号量就终止，操作系统会代为释放
};
int semop( int sem_id, struct sembuf *sem_ops, size_t num_sem_ops );
/**
 * 直接控制信号量信息
 * @param sem_id 信号量的唯一标识
 * @param sem_num 信号量的数量，除非需要使用一组信号量，否则取值0
 * @param command 需要指向的操作
 * @param semun 提供命令参数的联合体
 */
union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};
int semctl( int sem_id, int sem_num, int command, union semun semun );

共享内存允许不相关的进程访问同一块逻辑内存。这是一种在进程之间传递数据的非常有效的方式，大部分实现都把共享内存安排为同一段物理内存。共享内存是进程地址空间中的一个特殊的范围。共享内存没有通过同步机制，因此需要使用其它同步机制来对共享内存的访问进行同步。

与共享内存相关的函数有：

#include <cygwin/types.h>
#include <stddef.h>

//#include <sys/shm.h>

/**
 * 创建共享内存
 * @param key 共享内存段的命名，特殊键IPC_PRIVATE表示创建进程私有的共享内存
 * @param size 共享内存的容量
 * @param shmflg 位或，包含9个代表访问权限的位，IPC_CREAT用于创建一个新的共享内存
 *               给此函数传递已经存在的key并不是错误，此时的IPC_CREAT会被忽略
 *
 * @return 如果成功，返回一个正整数，作为共享内存的标识符；否则返回-1
 */
int shmget( key_t key, size_t size, int shmflg );
/**
 * 第一次创建共享内存段时，它不能被任何进程访问。要启用对共享内存的访问，必须
 * 将其连接到一个进程的地址空间中，这通过shmat函数完成
 * @param shm_id 共享内存标识符
 * @param shm_addr 连接到当前进程的地址位置，通常设置为空指针，表示让系统选择，否则硬件依赖性太高
 * @param shmflg 标记位：SHM_RND与shm_addr联用，来控制连接地址；SHM_RDONLY 是共享内存对当前进程只读
 *
 * @return 如果成功，返回指向共享内存第一个字节的指针；否则返回-1
 */
void *shmat( int shm_id, const void *shm_addr, int shmflg );
/**
 * 将共享内存段从当前进程分离，该函数不会删除共享内存，只是使当前进程不再能访问它
 * @param shm_addr shmat的返回值
 */
int shmdt( const void *shm_addr );
/**
 * 控制共享内存
 * @param shm_id 共享内存标识符
 * @param cmd 采取的动作：
 *            IPC_STAT 将shmid_ds中的数据设置为共享内存的当前关联值
 *            IPC_SET 如果有足够权限，则把shmid_ds中的值设置到共享内存
 *            IPC_RMID 删除共享内存段
 * @param buf 指针，指向共享内存模式和访问权限的结构
 */
struct shmid_ds
{
    uid_t uid;
    uid_t gid;
    mode_t mode;
};
int shmctl( int shm_id, int cmd, struct shmid_ds *buf );

消息队列类似于命名管道，但是不具有打开、关闭管道以及阻塞通信方面的复杂性。消息队列提供了一种从一个进程向另外一个进程发送数据块的机制，每个数据块被认为含有一个类型。下面是消息队列相关API：

MSGMAX
//单个消息的最大字节数
MSGMNB
//队列最大深度

#include <sys/msg.h>
/**
 * 创建和访问一个消息队列
 * @param key 队列的名字，IPC_PRIVATE用于创建私有队列
 * @param msgflg 标记位，包含9个权限位，IPC_CREAT必须与这些位或才能创建新的队列
 * @return 如果成功返回消息队列的标识符，否则返回-1
 */
int msgget( key_t key, int msgflg );
/**
 * 把消息放入到队列中
 * @param msqid 消息队列标识符
 * @param msg_ptr 待发送消息的指针，目标应当是一个结构，且第一个成员变量是long型，用于表示消息类型
 * @param msg_sz msg_ptr指向的消息的长度，不包括long型的消息类型的长度
 * @param msgflg 控制当队列满或者队列消息到达系统范围限制时的行为，位或
 *               IPC_NOWAIT：立即返回-1，不发送消息；如果该标记被清除，则发送进程挂起直到队列有空闲
 */
int msgsnd( int msqid, const void *msg_ptr, size_t msg_sz, int msgflg );
/**
 * 从队列里接收一个消息
 * @param msqid 消息队列标识符
 * @param msg_ptr 准备接收消息的指针
 * @param msg_sz msg_ptr指向消息的长度，不包括long型消息类型的长度
 * @param msgtype 消息类型，用于实现简单的优先级机制：如果小于0获取消息类型小于等于其绝对值的第一个消息
 *                如果为0获取第一个消息；如果大于0获取对应类型的第一个消息
 * @param msgflg 控制当队列为空时的行为，位或。IPC_NOWAIT类似msgsnd
 */
int msgrcv( int msqid, void *msg_ptr, size_t msg_sz, long int msgtype, int msgflg );
/**
 * 控制消息队列
 * @param msqid 消息队列标识符
 * @param cmd 命令。IPC_STAT，将消息队列关联值设置到buf；IPC_SET，将buf中的值设置到消息队列
 *            IPC_RMID，删除消息队列
 * @param buf 存放命令参数
 */
struct msqid_ds
{
    uid_t uid;
    uid_t gid;
    mode_t mode;
};
int msgctl( int msqid, int cmd, struct msqid_ds *buf );

The post Linux进程间通信 appeared first on 绿色记忆.

进程和信号是Linux操作环境的基础部分，控制着Linux和其它类UNIX系统的几乎所有活动。

UNIX标准对进程的定义：其中运行着一个或者多个线程的地址空间，以及这些线程需要的系统资源。Linux系统的进程是非常轻量级的。

每个Linux进程包含以下部分：

1. PID：进程的唯一表示，是范围从2~32768的正整数，数字回绕一圈后，重新从2开始计数（数字1被系统第一个进程init占用）
2. 程序代码：以自动方式加载到内存，正常情况下Linux进程不能对用来存放程序代码的内存区域进行写操作，因而可以被多个进程安全的共享
3. 函数库：系统函数库也可以被共享，不管多少进程调用printf，内存中只需要它的一份副本即可，这种做法类似于微软的DLL机制但更为复杂
4. 进程数据：存放进程的全局变量
5. 栈空间：进程有属于自己的栈空间，用于保存函数中的局部变量、控制函数的调用和返回
6. 环境空间：包含专为该进程建立的环境变量
7. 程序计数器：记录进程执行到的位置，即在执行线程中的位置。进程可以包含多个执行线程

Linux系统使用一个被称为进程表的结构来存放当前加载到内存的所有进程的信息。这些信息包括：进程ID、进程状态、进程命令字符串以及其它一些ps命令输出的信息。操作系统通过PID对进程进行管理，早起的UNIX系统只能同时运行256个进程。

注意：这些状态也适用于线程。进程中的线程通常处于不同的状态。

通过ps的STAT列，可以查看进程的状态，其代码如下表：

一般而言，每个Linux进程都是由另外一个被称为父进程的进程所启动的，前者相对的被称为子进程。在Linux系统启动时，它运行一个PID为1的init进程，可以把该进程看做操作系统的进程管理器，它是所有进程的祖先进程。

启动进程并等待其结束，是Linux中最基本的进程管理任务。应用程序可以通过fork、exec、wait等系统调用完成这些任务。

每个进程被分配以非常短暂的时间片，在时间片范围内进程代码被CPU执行，由于CPU非常快、时间片又非常短，你会感觉到多个程序同时运行的假象。Linux内核使用进程调度器来决定下一个时间片应该分配给哪个进程，其判断的依据是进程的优先级，优先级高的进程获得的时间片更多。在Linux中进程的运行时间不可能超过分配给它的时间片，Linux使用的是抢占式处理，因此进程的挂起、继续运行不需要彼此之间的协作。

进程调用

exit()

父进程可能先于子进程死亡，这种情况下，init进程可以成为子进程的养父。

子进程在死亡后，将处于僵尸状态。这种状态的进程不能被调度，并占据少量的系统资源，以保证其父进程可以访问其退出码等信息。父进程负责完全的释放子进程。

进程包含：虚拟地址空间、打开的系统对象的描述符、安全上下文、进程标识符、环境变量、最小-最大工作集大小，以及最少一个线程 —— 主线程。

线程是进程内部的一个可调度的实体（执行路径），进程内的所有线程共享地址空间、打开的描述符。每个线程维护自己的exception handlers、调度优先级、线程本地存储、线程标识符、线程上下文结构。线程可以具有自己的安全上下文。

线程上下文中包括的数据项：寄存器数据、内核栈、线程环境块、位于进程地址空间的用户栈。

可以在程序内部启动另外一个程序，从而创建新的进程，可以通过库函数system()完成：

#include <stdlib.h>
/**
 * 运行指定的命令并等待其完成
 * @param cmd 需要执行的命令
 * @return 如果无法启动Shell返回127，其它错误返回-1，否则返回所执行命令的退出码
 */
int system( const char *cmd );

上述函数的重大缺点是必须等待子进程的完成，并且依赖于Shell，因此使用的不多。

exec系列函数用于把当前进程替换为一个新的进程（新进程执行结束后不会返回原进程）。 新的程序启动后，原有的程序就不再运行了：

#include <unistd.h>
char **environ; // 该全局变量可用来设置传递到新程序的环境变量

// ***p函数通过搜索PATH环境变量来查找新的可执行文件的路径，如果目标程序不在PATH中，则path参数应当使用绝对路径
// ***e函数支持通过envp数组指定环境变量

// 下面三个函数支持变长参数列表，此列表以一个空指针结束
int execl(const char *path, const char *arg0, ..., (char *)0);
int execlp(const char *file, const char *arg0, ..., (char *)0);
int execle(const char *path, const char *arg0, ..., (char *)0, char *const envp[]);

// 下面三个函数使用数组来表示参数列表
int execv( const char *path, char * const argv[] );
int execvp( const char *file, char * const argv[] );
int execve( const char *path, char * const argv[], char * const envp[] );

//举例：
char * const ps_argv[] = { "ps", "ax", 0 };
char * const ps_envp[] = { "PATH=/bin:/usr/bin", "TERM=console", 0 };
execl("/bin/ps", "ps", "ax", 0);
execlp("ps", "ps", "ax", 0);
execle("/bin/ps", "ps", "ax", 0, ps_envp);
execv("/bin/ps", ps_argv);
execvp("ps", ps_argv);
execve("/bin/ps", ps_argv, ps_envp);

一般情况下，exec函数是不会返回的，除非发生错误，此时返回-1并设置errno。

exec启动的新进程保留了原进程的许多特性，特别是，原进程打开的文件描述符仍然有效，除非这些描述符的close on exec flag标记位被设置。任何在原进程中打开的目录流都会在新进程中被关闭。

系统调用fork允许创建以当前进程为模板，复制出一个新的进程。fork调用会在进程表中创建一个新的表项，其中很多属性都和原进程相同，包括所执行的代码。但新进程具有自己的数据空间、环境、文件描述符。fork函数的原型如下：

#include <sys/types.h>
#include <unistd.h>
pid_t fork( void );

fork()函数很巧妙，其具有“两次返回”的效果，实质上对应了父子进程的不同执行路径。对于父进程，fork()返回子进程的ID；而对于子进程，fork()总是返回0。通过这一特点，可以判断当前执行的代码是父进程还是子进程：

pid_t new_pid;
new_pid = fork();
switch ( new_pid )
{
    case -1 :   /* 错误 */
        break;
    case 0 :    /* 子进程 */
        break;
    default :   /* 父进程 */
        break;
}

结合fork、exec函数，创建新进程的条件就完备了。

当fork启动一个子进程后，子进程就有了自己的生命周期，并将独立运行，有时候，需要知道子进程何时结束，可以在父进程中用wait系统调用：

#include <sys/types.h>
#include <sys/wait.h>
/**
 * 暂停父进程的执行，直到其子进程结束
 * @param stat_loc 存放状态信息，用于了解子进程的退出状态（即子进程main函数的返回值或者exit函数的退出码）
 *     WIFEXITED(stat_val)     如果子进程正常结束，则取值非0
 *     WEXITSTATUS(stat_val)   如果WIFEXITED非0，取值子进程的退出码
 *     WIFSIGNALED(stat_val)   如果子进程死于未捕获的信号，则取值非0
 *     WTERMSIG(stat_val)      如果WIFSIGNALED非0，取值目标信号的代码
 *     WIFSTOPPED(stat_val)    如果子进程意外终止，取值非0
 *     WSTOPSIG(stat_val)      如果WIFSTOPPED非0，返回信号代码
 *
 * @return 子进程的PID
 */
pid_t wait( int *stat_loc );

/**
 * 等到某个特定的子进程结束
 * @param pid 子进程的PID，如果指定为-1将返回任一子进程的信息
 * @param stat_loc 如果不是空指针，则用来存放状态信息
 * @param option 用于定制waitpid的行为
 */
pid_t waitpid( pid_t pid, int *stat_loc, int options );

/**
 * 检查某个子进程是否结束，立即返回
 * 
 * @return 如果目标子进程没有结束或者意外终止，返回0；否则返回子进程PID
 *         如果函数调用失败，返回-1并设置errno
 */
waitpid(child_pid, (int *) 0, WNOHANG);

使用fork创建的子进程终止时，其与父进程的关联还会保持，直到父进程也正常终止或者父进程调用wait才会结束。在此之前，虽然子进程已经无事可做，但是其在进程表中的项不会被删除，其退出码需要被保存，以备后续父进程的wait调用，这种进程被称为僵尸进程（Zombie，也称为死defunct进程）。

如果父进程异常终止，子进程自动把PID=1的进程（init）作为自己的父进程，这类僵尸进程会一直保存在进程表中直到init发现并释放它。

在Linux中，会话（Session）通常是指Shell会话，即会话的概念和Shell是分不开的。所谓Shell是用户访问Linux系统的接口，是用户与内核之间的桥梁。

在大部分的Linux发行版中，BASH是默认的Shell实现。每当你：

1. 本地打开Terminal窗口
2. 通过SSH远程登录

时，一个关联的新会话会被自动创建。不管本地还是远程登录，用户都会得到一个与终端（Terminal）相关联的（Shell）进程，该进程作为Session Leader，会话的ID就是该进程的PID。

你也可以编程式的创建新的会话，调用

pid_t setsid(void) 

当终端被挂断（Hangup），即：

1. 对于本地Terminal，窗口被关闭
2. 对于SSH终端，网络连接被断开

时，Session Leader会接收到SIGHUP信号而退出。在Session Leader退出前，它会向所有子进程也发送SIGHUP信号，通常会导致会话中所有进程都结束掉。要想让某个子进程超越Session的生命周期而存活，你可以：

1. 让Session Leader主动退出，一般来说就是在Shell里调用exit/logout等命令。默认情况（Shell选项huponexit=off）下，主动退出不会发送SIGHUP给子进程
2. 守护进程化：即所谓Double fork技巧，让Shell的子进程fork出孙子进程，在孙子进程中执行程序逻辑，而子进程立即退出（孙子进程变成孤儿进程）。由于Shell只会将SIGHUP发送给直接子进程，孙子进程就不会受到影响了
3. 使用

   setsid()

    系统调用，让某个子进程变成新的Session的Leader，自立门户

顾名思义，进程组（Process group）就是包含了1~N个进程的分组。进程组的主要作用是利于信号的分发——当信号发送给进程组时，其内部的所有进程都会接收到信号。

一个会话中可以包含1~N个进程组，进程组不允许跨会话迁移，进程没有资格创建属于其它会话的进程组，进程也不能加入属于其它会话的进程组。

一个Session有且只有一个终端，该终端称为控制终端（controlling terminal），改变Session关联的终端这一操作，只能由Session Leader完成。

终端的生命周期可能：

1. 与Session相同，这类终端是随着会话而创建的伪终端
2. 与系统相同，这类终端是随着系统启动的，init进程在会话结束后重启getty来监听该终端

软中断信号（简称信号，signal）用来通知进程发生了异步事件（通常是某种错误）。信号是进程之间（包括用户进程之间、用户进程与内核进程之间）进行通信的一种简单方式，信号不会给目标进程发送任何数据。

使用信号并挂起程序（例如pause调用）是Linux程序设计的一个重要部分，这意味着程序不需要总是在执行，在一个无限循环中检查某个事件是否发生，相反，它可以等待事件的发生。这种机制对于只有一个CPU的多任务环境非常重要，进程共享一个处理器，繁忙的循环会对系统性能造成极大的影响。

尽管用户可以通过命令手工发出信号，但是内核是主要的信号发出者。以下场景下会目标进程会收到信号：

1. 检测到一个可能出现的硬件故障，如电源故障
2. 程序出现异常行为，比如尝试访问进程外部内存空间、尝试写入只读内存区域
3. 用户从终端向目标程序发出某些指令（ctrl + z、ctrl + c等），终端进程会接收到对应信号
4. 进程的一个子进程终止时

在进程的进程表项（内核通过进程表对进程进行管理，每个进程在进程表中占有一项）中，有一个信号域，信号域的每一个slot对应一种信号，对于同一种信号，进程无法知道在处理前来过多少个。

内核通过设置进程的信号域对应slot，来给进程发送信号。

当内核将信号发送给正在睡眠的进程时：

1. 如果进程处于可中断的睡眠状态，则唤醒之
2. 如果进程处于不可中断的睡眠状态：则仅仅设置slot

进程在以下场景下检查自己是否收到信号：

1. 进程即将从内核态返回到用户态时：进程在内核态运行时，信号不起作用，直到其将要返回用户态时才进行处理，信号处理函数在进程上下文中进行
2. 进程即将进入或离开一个适当的低调度优先级睡眠状态时

进程接收到信号后，可以：

1. 忽略该信号
2. 捕获该信号：当前进程继续执行前，调用一个用户定义的函数。这种处理机制类似于中断处理程序
3. 让内核执行与该信号相关的默认动作，大部分信号的默认动作导致进程终止

根据POSIX标准，信号为进程而产生，但是仅仅其中一个线程可以接收信号并处理。至于哪个线程负责处理信号，取决于实现。

对于Linux：

1. 信号可以针对进程的整体而产生，例如kill命令产生的信号
2. 信号可以针对特定线程，例如SIGSEGV、SIGFPE信号，或者pthread_kill命令产生的信号
3. 对于针对进程整体的信号，任何没有被信号阻塞的线程都可以处理之。如果有多个这样的线程（has the signal unblocked），内核会随机的选择一个

对于pthreads：每个线程具有独立的信号栈设置（signal stack settings），但是新线程总是从父线程拷贝此设置

shopt | grep huponexit

通过signal可以设置信号的处理函数：

#include <signal.h>
/**
 * 设置信号的处理函数
 * @param sig 信号
 * @param func 处理回调函数
 * @return 返回先前的信号处理函数的指针，如果未定义信号处理函数返回SIG_ERR并设置errno为正数
 *         如果给出一个无效的信号，或者尝试处理不可捕获、不可忽略的信号（例如SIGKILL），则将errno设置为EINVAL
 */
typedef void (*signal_handler_t )( int );
signal_handler_t signal( int sig, signal_handler_t );

//两个特殊的信号处理函数：
// SIG_IGN 忽略信号
// SIG_DFL 恢复此信号的默认处理行为

#include <unistd.h>
/**
 * 导致当前进程暂停执行，直到接收到一个信号
 * 当暂停被一个信号中断时，返回-1并且设置errno为EINTR
 */
int pause( void );

信号处理函数中调用某些函数是不安全的，例如printf，最好是在信号处理函数中设置一个标记，然后在主程序中检查标记再调用某些函数。下面是信号处理函数的例子：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch( int sig )
{
    printf( "OUCH! - I got signal %d\n", sig );
    //该信号处理函数恢复默认行为:停止程序
    signal( SIGINT, SIG_DFL );
}

int main()
{
    //进程启动后，设置信号的处理函数
    signal( SIGINT, ouch );
    while ( 1 )
    {
        //此循环会不停执行，除非接收到信号
        printf( "Hello World!\n" );
        sleep( 1 );
    }
}

X/Open和UNIX规范推荐了更加健壮的信号编程接口：

#include <signal.h>
/**
 * 指定接收到sig信号后采取的动作
 * @param sig 处理的信号
 * @param act 需要指向的动作
 * @param oact 如果不为空，此函数调用前sig信号的处理动作被转储到该指针
 * @return 如果成功，返回0，失败返回-1，如果给出的信号无效或者对不允许忽略或者
 *         捕获的信号进行忽略或者捕获，则设置errno=EINVAL
 */
int sigaction( int sig, const struct sigaction *act, struct sigaction *oact );
typedef  void (*sa_handler_t)( int );
struct sigaction
{
    sa_handler_t sa_handler; //信号处理函数，包括SIG_DFL、SIG_IGN
    //一个信号集，在sa_handler被调用之前，此信号集中的信号不会传递给进程，
    //可以防止信号处理函数尚未执行完毕就接收到新信号并重入信号处理函数的情况
    //信号处理函数在指向过程中，可能被新的信号中断而再次调用，这不仅仅是递归调用
    //的问题，更牵涉到可重入（安全的进入和再次指向）的问题
    sigset_t sa_mask;
    //标记位：
    //SA_RESETHAND 表示处理函数调用后（入口第一句后），即重置默认处理函数（SIG_DFL）
    //SA_NOCLDSTOP 子进程停止后不产生SIGCHLD信号
    //SA_RESTART   重启可中断函数而不是给出EINTR错误。许多系统调用是可中断的，也就是
    //             说接收到信号后系统调用会返回一个错误并设置errno=EINTR
    //             以表示该调用因为信号而返回。设置该标记后，调用将重启而不是被信号中断
    //SA_NODEFER   捕获到信号时不将其加入到信号屏蔽掩码中。通常的做法：为防止同一信号不
    //             断到达，新接收到的信号会被加入到掩码中，直到处理函数指向完毕
    int sa_flags;
};

//向信号集中增加一个信号
int sigaddset( sigset_t *set, int signo );
//创建空白信号集
int sigemptyset( sigset_t *set );
//创建包含所有已定义信号的信号集
int sigfillset( sigset_t *set );
//从信号集中删除指定的信号
int sigdelset( sigset_t *set, int signo );
//判断信号是否为信号集的成员，如果是返回1否则返回0，如果给定的信号无效返回-1并设置EINVAL
int sigismember( sigset_t *set, int signo );
/**
 * 根据how指定的方式修改进程的信号屏蔽掩码
 * @param how
 *        SIG_BLOCK    将set加入到进程的掩码
 *        SIG_SETMASK  将进程的掩码设置为set
 *        SIG_UNBLOCK  从进程的掩码中删除set
 * @param set 新的信号屏蔽掩码，如果设置为空，仅仅是把当前信号屏蔽掩码保存到oset
 * @param oset 原先的信号屏蔽掩码
 * @return 如果成功返回0；如果how无效返回-1并设置errno=EINVAL
 *
 */
int sigprocmask( int how, const sigset_t *set, sigset_t *oset );

/**
 * 如果一个信号被进程阻塞，就不会传递给进程而停留在待处理状态。
 * 该函数可以查看阻塞的信号中那些处于待处理状态
 */
int sigpending( sigset_t *set );

/**
 * 挂起进程自己，等待信号集中某个信号到达
 * 如果接收到的信号终止了程序，该调用不会返回；否则返回-1并设置errno=EINTR
 */
int sigsuspend( const sigset_t *sigmask );

下面是对前一个信号处理例子的改写：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
void ouch( int sig )
{
    printf( "OUCH! - I got signal %d\n", sig );
}
int main()
{
    struct sigaction act;
    act.sa_handler = ouch; //设置信号处理函数
    sigemptyset( &act.sa_mask ); //创建空的信号屏蔽掩码
    act.sa_flags = SA_RESETHAND;
    sigaction( SIGINT, &act, 0 );
    while ( 1 )
    {
        printf( "Hello World!\n" );
        sleep( 1 );
    }
}

信号处理函数中会遇到可重入问题，下表列出可以被信号处理函数安全调用的函数，他们本身是可重入、或者本身不会再生成信号：

进程可以调用kill函数来向包括其自身在内的进程发送一个信号。如果进程没有发送目标信号的权限，对kill的调用就会失败，失败的常见原因是目标进程是由另外一个用户所拥有。下面的函数可以用来发送信号：

#include <sys/types.h>
#include <signal.h>
/**
 * 将信号发送给指定进程，如果成功返回0，失败返回-1并设置errno，errno可以为以下值：
 * EINVAL  给定的信号无效
 * EPERM   发送进程的权限不够，一般只能发送给同一用户的进程，超级用户可以发送信号给所有进程
 * ESRCH   目标进程不存在
 *
 */
int kill( pid_t pid, int sig );

#include <unistd.h>
/**
 * 在延迟seconds秒以后，发送一个SIGALRM信号
 * 每个进程只能有一个闹钟，因此后续的调用将导致重新计时并返回上一次闹钟设置的剩余秒数
 * 如果seconds设置为0则取消闹钟请求
 */
unsigned int alarm( unsigned int seconds );

The post Linux信号、进程和会话 appeared first on 绿色记忆.

共享库（Shared libraries），在程序执行起始时被自动加载（而非执行过程中随时动态加载）。在链接阶段，必须有共享库才能链接。

使用共享库时，运行时加载的库，应当与链接时期望的库的“版本”一致，即功能上没有不兼容的变化。二进制文件（库、可执行文件）本身知道其依赖的共享库的版本。

如何识别这种变化并没有一致的规范，某些UNIX系统通过soname来版本化共享库，所谓soname就是在共享库名称后附加可选的数字后缀，例如libx.so.1。仅当共享库的接口发生不兼容变化时soname才改变，如果libx从1.0到1.9维持了一致性的接口，它们的soname应该一致。注意soname和文件名不是一回事，1.3版本的libx的文件名可能叫libx.so.1.3，但是它的soname可能是libx.so.1。

通过soname，可以很容易的允许不同版本的共享库存在于同一个系统中（相比Windows的DLL地狱）。不带后缀的example.so常常是指向最新版本的符号链接。不带后缀的so用于链接器，因为gcc不知道去寻找有后缀版本，例如-lpthread只能让gcc去寻找libpthread.so。

soname可以具有主次版本号区分，使用额外的点号分隔。例如：

libFOO.so.MAJOR.MINOR.BUGFIX

当安装libx库到系统时，可以建立符号链接

libx.so -> libx.so.1

libx.so -> libx.so.2

另一方面，这种符号链接用法可以扩展为，将某个soname链接到特定文件，例如

libx.so.1 -> libx.so.1.3

libx.so.1 -> libx.so.1.3.2

动态加载库（Dynamically loaded libraries），类似于Windows的DLL，运行期间，使用到的时候进行加载。编译链接都不需要目标库文件。

DLL中包含两类函数：导出（exported）函数、内部（internal）函数，只有导出函数可以被外部模块使用。SO中的所有函数均可以被外部使用，不需要特殊的export语句导出函数（在大部分UNIX系统中，默认所有符号被导出）。

静态库（Static libraries），简单的把一些obj文件打包为.a归档文件。优势是执行速度通常更快，而且是静态链接，因此不会出现找不到库、版本错误导致无法执行的情况。缺点是难以维护，库出现BUG则所有依赖都得重现链接

有时，如果依赖库声明的顺序不正确会导致：undefined reference错误。对于静态链接库libA，如果它依赖于链接库libB，那么，在Linker的参数列表中，libA必须在libB前面出现。动态链接库则无此顺序要求。

属于C编程语言的一部分，它是一个规范（Specification），它定义了若干函数，以及这些函数应该具有什么样的行为。

C标准库的更多内容参考C语言学习笔记。主要头文件包括assert.h ctype.h errno.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h wchar.h time.h

某种程度上是C标准库的超集 dlopen, fork等函数由POSIX库定义。

GNU的glibc库是C标准库、POSIX C库的超集，在Linux下通常作为共享对象位于/lib/x86_64-linux-gnu/libc.so...

glibc使用C语言的GCC方言编写，是Linux系统的基石。glibc简化了你和系统调用的交互（进行了函数封装）。不使用glibc的情况下，你可以直接写汇编代码来执行系统调用。如果仅仅需要使用C标准库的函数，可以使用musl-libc或者dietlibc等。 

libanl libc libc_nonshared libcrypt libdl libg libmvec libpthread libresolv librt libutil等都来自glibc库。

操作系统内核仅仅是Linux的一小部分，而大部分应用程序由Linux社区开发。Linux社区支持自由软件的概念，遵从GNU（GNU's not UNIX）通用许可证（GPL）。

GNU项目由Richard Stallman创立，目的是创建一个与UNIX系统兼容，但不受UNIX名字、源代码私有权限制的OS和开发环境。下面列出一些著名的GNU软件：

除上表以外，还有大量软件，例如电子表格、源代码管理工具、编译器、因特网工具、桌面环境（GNOME、KDE），都是在GPL条款下发布的。由于GNU软件的重要贡献，现在很多人把Linux称为GNU/Linux。

关于GNU的软件的更多内容：

1. GCC / GDB：将在本文后续内容中详细介绍
2. Make可以参考：GNU Make学习笔记
3. Autotools可以参考：Autotools学习笔记

GCC是GNU项目的C/C++编译器。

当调用gcc时，正常是执行从预处理、汇编、编译、链接的整个过程，通过某些选项可以在某个步骤中断此处理过程。例如：

-c

以

-f

-W

C++程序可以使用g++命令来编译。g++是gcc的一个前端应用

ldd

/etc/ld.so.conf

pkg-config

.pc

cd ~/CPP/lib/gcc/7.2/src
contrib/download_prerequisites
mkdir build && cd build
../configure -v --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu 
                --prefix=/home/alex/CPP/lib/gcc/7.2.0 
                --enable-languages=c,c++ --disable-multilib 
                --program-suffix=-7.1   # 程序名字后缀

# 构建
make -j 8
# 安装
make install 

# 下面列出最常用的选项，g++基本上接受与gcc同样的选项
gcc [-c|-S|-E] [-std=standard]
    [-g] [-pg] [-Olevel]
    [-Wwarn...] [-Wpedantic]
    [-Idir...] [-Ldir...]
    [-Dmacro[=defn]...] [-Umacro]
    [-foption...] [-mmachine-option...]
    [-o outfile] [@file] infile...

-std=c90

 -std=c++98

/usr/include

/lib /usr/lib

/usr/local/lib

-lm

ldd cstudy
	linux-vdso.so.1 =>  (0x00007fff56be3000)
    # 使用非标准的libc
	libc.so.6 => /home/alex/.local/lib/libc.so.6 (0x00007ffa34fee000)
	/home/alex/.local/lib/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007ffa353a3000)

# 使用自定义的glibc
-Wl,-rpath=/home/alex/.local/lib 
-Wl,--dynamic-linker=/home/alex/.local/lib/ld-linux-x86-64.so.2 

# 不指定选项，将预处理、汇编链接形成可执行文件，默认输出a.out
gcc hello.c
# 指定输出文件的名称
gcc hello.c -o hello
# 得到预处理输出文件
gcc -E hello.c -o hello.i
# 将预处理输出文件编译为汇编文件hello.s
gcc -S hello.i
# 将汇编文件编译为目标文件hello.o
gcc -c hello.s
# 不指定选项进行链接，生成可执行文件
gcc hello.o -o hello

# 多个文件一起编译，形成可执行文件
gcc hellolib.c hello.c -o hello
# 亦可逐个编译，然后链接，这样可以只编译部分文件
gcc -c hellolib.c
gcc -c hello.c
gcc hellolib.o hello.o -o hello

# 编译出共享库
gcc -shared hellolib.c -o libhello.so

# 强制使用静态hi库来链接
gcc hello.o -static -lhi -o hello

显示已经安装的软件包的元数据信息，该工具可以用于：

1. 检查库的版本号。如果所需要的库的版本不满足要求，它会打印出错误信息，避免链接错误版本的库文件
2. 获得编译预处理参数，如宏定义，头文件的位置
3. 获得链接参数，如库及依赖的其它库的位置，文件名及其它一些链接参数
4. 自动加入所依赖的其它库的设置

要使用pkg-config命令，目标库必须提供一个包含了元数据的.pc文件。对于大部分系统，这些.pc文件存放在：

1. /usr/lib/pkgconfig
2. /usr/share/pkgconfig
3. /usr/local/lib/pkgconfig
4. /usr/local/share/pkgconfig

但是可以通过环境变量

PKG_CONFIG_PATH

下面是一个例子：

# This is a comment
prefix=/home/hp/unst # this defines a variable
exec_prefix=${prefix} # defining another variable in terms of the first
libdir=${exec_prefix}/lib
includedir=${prefix}/include

Name: GObject # human-readable name
Description: Object/type system for GLib # human-readable description
Version: 1.3.1
URL: http://www.gtk.org
Requires: glib-2.0 = 1.3.1
Conflicts: foobar <= 4.5
Libs: -L${libdir} -lgobject-1.3
Libs.private: -lm
Cflags: -I${includedir}/glib-2.0 -I${libdir}/glib/include

pkg-config 
　[--modversion] [--help] [--print-errors] 
　[--silence-errors] [--cflags] [--libs] 
　[--libs-only-L] [--libs-only-l] [--cflags-only-I] 
　[--variable=VARIABLENAME] [--define-variable=VARIABLENAME=VARIABLEVALUE] 
　[--print-variables] [--uninstalled] [--exists] [--atleast-version=VERSION] 
　[--exact-version=VERSION] [--max-version=VERSION] [--list-all] [LIBRARIES...]
　[--print-provides] [--print-requires] [--print-requires-private] [LIBRARIES...]

# 打印glib-2.0库的prefix变量
# 检查是否存在大于1.3.4版本的glib-2.0库、以及大于1.8.3的libxml库
pkg-config --variable=prefix glib-2.0 
pkg-config --exists 'glib-2.0 >= 1.3.4 libxml = 1.8.3' 

配置动态连接器的运行时绑定，修改额外的链接库位置后，需要调用该命令使之生效

该命令为参数中提供的路径下找到的共享库，在：

1. /etc/ld.so.conf（动态库的额外搜索位置）
2. 受信目录（/lib /usr/lib）

中创建必要的链接、缓存。修改文件/etc/ld.so.conf后应当调用ldconfig。运行时连接器ld.so、ld-linux.so会使用这些缓存

ldconfig通过检查库的文件名和头，来判断那些版本（的库）需要更新其软链接。

ldconfig [ -nNvXV ] [ -f conf ] [ -C cache ] [ -r root ] directory ...
ldconfig -l [ -v ] library ...
ldconfig -p

-v 打印当前版本号，正在处理的目录、创建的链接
-n 仅仅处理命令行指定的目录。不处理/etc/ld.so.conf中列出的目录，以及受信目录（/lib、/usr/lib）
-N 不重建缓存
-X 不更新软链接
-f 使用其它文件而非/etc/ld.so.conf
-C 使用其它缓存而非/etc/ld.so.cache 

打印指定的程序、共享库，所依赖的共享库列表

ldd [OPTION]... FILE...

-u 打印没有使用的直接依赖
-d 进行重定位，报告所有缺失的对象
-r 同时对数据对象和函数进行重定位，报告缺失的对象或函数

显示一个或多个目标文件（object files）的信息

objdump [options] objfile...

-a 如果某个目标文件是归档文件（静态库），显示归档的头信息
-f 显示目标文件一般性的头
-p 显示特定目标文件格式的私有头
-h 显示目标文件section header的基本信息
-x 显示所有可用的头信息，包括符号表、relocation entries
-d 执行反汇编，仅针对可能存在代码的section
-D 对所有section执行反汇编
-S 显示混合着汇编的源码，隐含-d
-g 显示Debug信息
-e 显示Debug信息，输出格式与ctags工具兼容
-C  解码（demangle）低级的符号名称为用户可读名称，让C++函数名可读

# 显示共享库的soname
objdump -p /usr/lib/mysql/plugin/auth.so | grep SONAME

# 查找符号
objdump -x /home/alex/.local/lib/libc.so.6 | grep getaddrinfo

显示ELF文件的信息。ELF是UNIX系统实验室（USL）作为应用程序二进制接口（Application Binary Interface，ABI）而开发和发布的，也是Linux的主要可执行文件格式。

# readelf -h /home/alex/.local/lib/libc.so.6
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 03 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  # 可以看到操作系统信息
  OS/ABI:                            UNIX - GNU
  ABI Version:                       0
  Type:                              DYN (Shared object file)
  # 可以看到体系结构信息
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  # 程序入口点地址
  Entry point address:               0x21d10
  Start of program headers:          64 (bytes into file)
  Start of section headers:          12004816 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         10
  Size of section headers:           64 (bytes)
  Number of section headers:         82
  Section header string table index: 79 

# 查看调试文件信息
readelf -S /lib/x86_64-linux-gnu/libc-2.23.so | grep -E 'debug|.build'
  [ 1] .note.gnu.build-i NOTE             0000000000000270  00000270
  [70] .gnu_debuglink    PROGBITS         0000000000000000  001c6dd1

可以将可执行文件中的调试信息抽取出来：

objcopy --only-keep-debug foo foo.debug
strip -g foo 

GNU的调试器，可以：

1. 启动应用程序，并指定任何参数
2. 在特定情况下，让应用程序暂停执行
3. 暂停指向后，检查应用程序的状态
4. 改变应用程序状态

编译器有时候不去记录源文件所被编译时的实际目录，而仅仅记录源文件的名称或相对路径。即使记录了，在你调试的时候，编译目录可能已经删除，这就让gdb面临如何将符号表中的源文件路径映射到Debugger机器的源文件的问题

gdb使用一系列目录，从中搜索源文件，此所谓source path。每次gdb需要源文件时，逐个搜索这些目录，直到找到一个名称匹配的文件

例如，假设可执行文件符号表中引用/usr/src/foo-1.0/lib/foo.c，而Debugger的source path设定为 /mnt/cross，则文件的（在Debugger上）搜索顺序为：

1. 按符号表字面值搜索：/usr/src/foo-1.0/lib/foo.c
2. 添加source path作为前缀：/mnt/cross/usr/src/foo-1.0/lib/foo.c
3. 添加source path作为前缀，剥离符号表的目录部分：/mnt/cross/foo.c

符号表引用的相对路径../lib/foo.c类似，分别搜索 ../lib/foo.c、/mnt/cross/../lib/foo.c、/mnt/cross/foo.c

在符号表中，程序源代码中的每个标识符都和它的声明或使用信息绑定在一起，比如其数据类型、作用域以及内存地址。

目标文件中通常会有一个包含了所有外部可见标识符的符号表。在链接不同的目标文件时，链接器会使用这些文件中的符号表来解析所有未解析的符号引用。

在调试阶段，需要通过符合表来解读各种信息。

对于Ubuntu来说，软件包的符号表独立分发。它们发布在 ddebs.ubuntu.com，命名为

<package>-dbgsym

<package>-dgb

1. dbgsym可以自动生成、自动上传到ddebs.ubuntu.com。维护成本低

GDB支持在独立文件中存放的符号信息，并且能够自动发现、加载。

GDB支持两种方式来指定调试信息文件：

1. 在可执行文件中，包含debug link，指定了独立调试文件的名称，debug link是可执行文件中名为.gnu_debuglink的特殊section。调试文件名称格式通常是executable-name.debug。debug link 还提供调试文件的CRC检查，用于验证调试文件、可执行文件来自同一次build
2. 在可执行文件中，包含build ID，在对应的调试文件中，此ID也存在。build ID是可执行文件中（通常）名为 .note.gnu.build-id的section

对于方式debug link方式，GDB依次在以下位置寻找调试文件：

1. 在可执行文件所在目录
2. 名为.debug的子目录
3. 全局debug目录

对于build ID方式，GDB会在全局debug目录的.build-id子目录中查找nn/nnnnnnnn.debug文件。前面的nn是build ID的最前面2个HEX字符，nnnnnnnn则是build ID的剩余部分。

举例来说，调试/usr/bin/ls的时候，如果debug link指定了 ls.debug，并且具有build ID是abcdef1234，并且全局debug目录包括/usr/lib/debug，那么以下位置用于寻找调试文件：

1. /usr/lib/debug/.build-id/ab/cdef1234.debug
2. /usr/bin/ls.debug
3. /usr/bin/.debug/ls.debug
4. /usr/lib/debug/usr/bin/ls.debug

全局debug目录取决于GDB的配置项 

--with-separate-debug-dir

你也可以使用交互式命令查看、设置全局dbug目录：

# 查看
(gdb) show debug-file-directory
# 设置，path separator分隔
(gdb) set debug-file-directory directories  

找到调试文件，是设置断点的前提条件。运行到断点之后，你可能遇到：res_send.c: No such file or directory. 这样的错误，这是因为没有找到源码。可以用下面的命令来设置源码路径：

(gdb) directory /glibc-2.27/resolv
# 指定多个源码路径
(gdb) directory /glibc:$cdir:$cwd

gdb [-help] [-nh] [-nx] [-q] [-batch] [-cd=dir] [-f] [-b bps]
    [-tty=dev] [-s symfile] [-e prog] [-se prog] [-c core] [-p procID]
    [-x cmds] [-d dir] [prog|prog procID|prog core]

# 连接到指定的进程以调试
gdb -p 1234

# 调试应用程序
gdb /path/to/program

# 连接到gdbserver
target remote localhost:2345

# 在主函数执行前暂停
b main

# 在main.cpp的55行设置断点
break main.cpp:55

# 在指定的内存地址上设置断点
b *0x08048375

# 在main函数的第7个指令上设置断点
b *main+7 


# 指定源文件绝对路径
break  /tmp/KeyDB/src/replication.cpp:2302

# 函数断点，在执行函数前暂停程序
break funcname

# 在当前文件的第N行设置断点
b N
# 在当前行后面的第N行设置断点
b +N

# 条件断点
break line-number if condition
break main.cpp:55 if x > 1

# 线程断点
# 使用info threads获得线程编号
break line thread thread-number


# 列出所有断点
info break

# 根据序号删除断点
del breakpointnumber

# 禁用/启用断点
dis breakpointnumber
en  breakpointnumber

# 忽略断点，知道经过它X次
ignore breakpointnumber x

# 清除（当前暂停在的）断点
clear

c N

until line-number

s N

# 解决CLion中，由于源码路径不正确导致显示汇编的问题
where
# #30 0x00000000010ad0b0 in event_persist_closure (ev=<optimized out>, base=0x32fc000) at ../event.c:1580
# #31 event_process_active_single_queue (base=base@entry=0x32fc000, activeq=0x32260b0, max_to_process=max_to_process@entry=2147483647, endtime=endtime@entry=0x0) at ../event.c:1639
# 这里的libevent的源码映射失败，构建时，源码位于工作目录的上级目录
# #32 0x00000000010ada67 in event_process_active (base=0x32fc000) at ../event.c:1738
# #33 event_base_loop (base=0x32fc000, flags=0) at ../event.c:1961
# #34 0x0000000000a5067c in Envoy::Event::DispatcherImpl::run (this=0x322b3f0, type=Envoy::Event::Dispatcher::RunType::Block) at source/common/event/dispatcher_impl.cc:165
# #35 0x00000000009d74c5 in Envoy::Server::InstanceImpl::run (this=0x32bb200) at source/server/server.cc:466
# #36 0x0000000000425baa in Envoy::MainCommonBase::run (this=0x32ba8b0) at source/exe/main_common.cc:103
# #37 0x000000000040cd68 in Envoy::MainCommon::run (this=0x32ba480) at bazel-out/k8-dbg/bin/source/exe/_virtual_includes/envoy_main_common_lib/exe/main_common.h:86
# #38 0x000000000040a4bf in main (argc=19, argv=0x7ffe63314218) at source/exe/main.cc:37
# #39 0x00007f7407aaff45 in __libc_start_main (main=0x40a44e <main(int, char**)>, argc=19, argv=0x7ffe63314218, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7ffe63314208) at libc-start.c:287
# #40 0x0000000000409e45 in _start ()
# libevent的源码目录是：/home/alex/CPP/lib/libevent/2.1.8-stable
# 而当前的工作目录是：/home/alex/CPP/projects/clion/envoy
# 将libevent源码添加到源码搜索路径
directory /home/alex/CPP/lib/libevent/2.1.8-stable

# 得到eax寄存器的值，通常是函数调用返回值
i r eax 

set varname=varvalue

# 设置寄存器rdx的值
set $rdx = 10000

print varname

help commandname

watch x > 1

# 向前跑30行
advance +30

# 从指定的本地目录来寻找库
set sysroot [Directory]

# 从指定的远程目录寻找库，一般设置为 /
set sysroot remote:/
set sysroot remote:[Remote directory]
set solib-absolute-prefix [Directory]
show sysroot

$cdir

$cwd

disassemble main

x/8i main

这是一个控制程序，允许你通过Remote GDB连接到应用程序。要在目标系统中运行gdbserver，你需要应用程序的二进制文件，但是不一定需要符号表。

gdbserver [OPTIONS] COMM PROG [ARGS ...]
gdbserver [OPTIONS] --attach COMM PID
gdbserver [OPTIONS] --multi COMM

其中：

1. COMM：要么是一个TTY设备（串口调试），要么是HOST:PORT（用于监听GDB客户端连接），还可以指定 - 或者 stdio，表示使用gdbserver的标准输入/输出
2. PROG  ARGS：被调试的可执行文件的路径和参数
3. PID：需要附着到的进程的PID

# 附着到正在运行的程序，在2345端口上等待客户端连接
gdbserver --attach 0.0.0.0:2345 449

这是GDB自带的前端，使用

gdb -tui

Emacs编辑器提供的功能。按

M-x

输入命令

gdb-many-windows

输入命令

gdb-display-disassembly-buffer

如果不习惯Emacs的快捷键，可以使用cgdb，它更加简洁，vim用户友好。

默认情况下，cgdb将控制台分为两个窗口：

1. 源码窗口：使用vim风格命令，输入:quit可以退出
2. GDB窗口：使用GDB命令，输入quit或者C-d退出

可用窗口列表：

ESC            进入命令模式
  i              进入GDB模式（输入焦点变为GDB窗口）
  s              进入GDB模式，支持滚动
  C-t            为被调试程序打开新的TTY窗口
  C-w            切换水平/垂直布局
  num            k或者num up-arrow 光标向上移动num行
  num j          或者 num down-arrow 光标向下移动num行
  h              或者left-arrow 向左移动光标
  l              或者 right-arrow 向右移动光标
  C-b            或者 page up 向上翻页
  C-u            向上翻半页
  C-f            或者 page down 向下翻页
  C-d            向下翻半页
  m[a-zA-Z]      设置标记
  '[a-zA-Z]      跳转到标记
  ''             跳转到上一个位置
  '.             跳转到正在执行的行
  /              从当前光标处开始搜索
  ?              从当前光标处反向搜索
  n              前向下一个匹配
  N              反向下一个匹配
  o              打开文件对话框
  spacebar       在当前行设置断点
  t              在当前行设置一次性断点
  F5             发送run命令给GDB
  F6             发送continue命令给GDB
  F7             发送finish命令给GDB
  F8             发送next命令给GDB
  F10            发送step命令给GDB

:set asr           自动加载修改后的源文件

:set color         是否在可能的时候用彩色显示，默认no
:set dwc           是否在调试窗口中使用彩色显示

:set dis           是否显示汇编，默认off，如果on，则显示混合的汇编、源码

:set ic            搜索时是否忽略大小写，默认off
:set hls           是否高亮显示所有匹配

:set showmarks     源码窗口中是否默认显示标记

:set ts=number     TAB显示为空格的数量，默认8

:set wso=style     窗口布局方向 horizontal  或者 vertical
:set hls

:map lhs rhs       新建或者覆盖原有的按键映射

~/.cgdb/cgdbrc

map <F2> ip<Space>argc<CR>

map <F9> :until<CR>

set ignorecase
set ts=4
set wso=vertical
set dis=on

map <F3>     isi<CR><ESC>
map <F4>     ini<CR><ESC>
map <F5>     :step<CR>
map <F6>     :next<CR>
map <F7>     :finish<CR>
map <F8>     :continue<CR>
map <F9>     :run<CR>
map <F10>    :until<CR>

<Esc>        escape key
<Up>         cursor up key
<Down>       cursor down key
<Left>       cursor left key
<Right>      cursor right key
<Home>       home key
<End>        end key
<PageUp>     page up key
<PageDown>   page down key
<Del>        delete key
<Insert>     insert key
<Nul>        zero
<Bs>         backspace key
<Tab>        tab key
<NL>         linefeed
<FF>         formfeed
<CR>         carriage return
<Space>      space
<Lt>         less-than
<Bslash>     backslash
<Bar>        vertical bar
<F1>         function keys 1 to 12
<C-...>      control keys
<S-...>      shift keys

o

q

*

ESC

i

Linux或者UNIX下C语言程序入口函数的标准声明方式如下：

int main(int argc, char *argv[]);
//argc 表示参数的个数，其中第一个参数是程序的名称
//argv 表示参数的数组
//多个参数使用空白符区分，如果单个参数中间有空白符，使用引号包围该参数

下面的代码说明如何读取程序参数：

#include <stdio.h>
#include <stdlib.h>
int main( int argc, char *argv[] )
{
    int arg;
    for ( arg = 0; arg < argc; arg++ )
    {
        if ( argv[arg][0] == '-' ) printf( "选项: %s\n", argv[arg] + 1 );
        else printf( "参数: %s\n", argv[arg] );
    }
    exit( 0 );
}

X/Open规范定义了命令行选项的标准格式，并提供了获取命令行选项的接口：getopt函数：

#include <unistd.h>
int getopt(int argc, char *const argv[], const char *optstring);
//optstring：字符列表，表示支持的选项，每个字符代表一个选项，:表示前面的选项需要一个值
//例如if:lr表示支持4个选项，其中f后面紧跟一个关联值
extern char *optarg;
//optind存放下一个待处理参数的索引
//如果遇到无法识别的选项，getopt返回一个?并将此选项保存到optopt中
//如果一个选项要求关联值，但是没有传递，则getopt返回一个?
extern int optind, opterr, optopt;

反复调用getopt，即可依次得到选项，示例如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main( int argc, char *argv[] )
{
    int opt;
    //直到返回值是-1，依次读取
    while ( ( opt = getopt( argc, argv, ":if:lr" ) ) != -1 )
    {
        switch ( opt )
        {
            case 'i' :
            case 'l' :
            case 'r' :
                printf( "option: %c\n", opt );
                break;
            case 'f' :
                printf( "filename: %s\n", optarg ); //读取参数值
                break;
            case ':' :
                printf( "option needs a value\n" );
                break;
            case '?' :
                printf( "unknown option: %c\n", optopt ); //读取未知参数名
                break;
        }
    }
    for ( ; optind < argc; optind++ )
        printf( "argument: %s\n", argv[optind] );
    exit( 0 );
}

GNU C函数库支持双横线开头的长参数，函数为getopt_long，有关联值的参数使用

--option=value

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#define _GNU_SOURCE
#include <getopt.h>
int main( int argc, char *argv[] )
{
    int opt;
    struct option longopts[] = {
            //此结构的定义如下：
            //name：长选项的名字，缩写亦可，只要不与其它选项混淆
            //has_arg：是否带参数，0表示不带；1表示必须有一个参数；2表示有一个可选参数
            //flag：设置为NULL，那么找到该选项时，getopt_long返回val中给定的值（对应的短选项）
            //      否则，getopt_long返回0并且将val的值写入flag指向的变量
            //val：getopt_long为该选项返回的值
            { "initialize", 0, NULL, 'i' },
            { "file", 1, NULL, 'f' },
            { "list", 0, NULL, 'l' },
            { "restart", 0, NULL, 'r' },
            { 0, 0, 0, 0 }
    };
    while ( ( opt = getopt_long( argc, argv, ":if:lr", longopts, NULL ) ) != -1 )
    {
        switch ( opt )
        {
            case 'i' :
                case 'l' :
                case 'r' :
                printf( "option: %c\n", opt );
                break;
            case 'f' :
                printf( "filename: %s\n", optarg );
                break;
            case ':' :
                printf( "option needs a value\n" );
                break;
            case '?' :
                printf( "unknown option: %c\n", optopt );
                break;
        }
    }
    for ( ; optind < argc; optind++ )
        printf( "argument: %s\n", argv[optind] );
    exit( 0 );
}

#include <stdlib.h>
//读取环境变量
char *getenv(const char *name);
//设置环境变量，以name=value形式的字符串作为参数
int putenv(const char *string);

除了上面两个方法外，可以通过environ变量直接访问环境变量：

#include <stdlib.h>
//字符串数组
extern char **environ;

示例如下：

#include <stdlib.h>
#include <stdio.h>
extern char **environ;
int main()
{
    char **env = environ;
    while ( *env )
    {
        printf( "%s\n", *env );
        env++;
    }
    exit( 0 );
}

 UNIX/Linux下的时间的表示，均是以格林尼治（GMT）时间1970-01-01 00:00:00为起点进行计时的，表示为从这一时间点流逝的时间。时间使用预定义类型：

time_t

#include <time.h>
//如果tloc不为NULL，那么返回值同时写入到该指针
time_t time( time_t *tloc );
//把结构还原为时间值
time_t mktime(struct tm *timeptr);

 difftime函数可以返回两个时间点之间的差值：

#include <time.h>
//返回time1 - time2
double difftime(time_t time1, time_t time2);

使用gmtime函数可以把time_t分解为一个结构：

#include <time.h>
struct tm *gmtime( const time_t timeval );
//结构成员包括：
//int tm_sec，秒0-61
//int tm_min，分0-59
//int tm_hour，时0-23
//int tm_mday，月份中的日期1-31
//int tm_mon，月份0-11
//int tm_year，年度，从1900开始算
//int tm_wday，星期几，0-6，周日为0
//int tm_yday，年份中的日期，0-365
//int tm_isdst，是否夏令时

以上函数处理的都是GMT标准时间，如果需要得到当地时间，可以使用：

#include <time.h>
struct tm *localtime(const time_t *timeval);

以人类易于阅读的方式输出日期，可以使用：

#include <time.h>
char *asctime( const struct tm *timeptr );
//输出格式为固定26字符：Sun Jun 9 12:34:56 2007\n\0
//下面这个函数等价于：asctime(localtime(timeval))
char *ctime( const time_t *timeval );

Linux提供了strftime函数，可以对日期格式进行细致的格式化：

#include <time.h>
size_t strftime( char *s, size_t maxsize, const char *format, struct tm *timeptr );
/**
 * 其中，format为格式化字符串，类似于printf：
 * %a 星期几的缩写
 * %A 星期几的全称
 * %b 月份的缩写
 * %B 月份的全称
 * %c 日期和时间
 * %d 月份中的日期01-31
 * %H 小时0-23
 * %I 12小时制中的小时01-12
 * %j 年份中的日期，001-366
 * %m 年份中的月份，01-12
 * %M 分钟，00-59
 * %p a.m表示上午，p.m.下午
 * %S 秒，00-61
 * %u 星期几，1-7，周一为1
 * %U 一年中的第几周，01-53（周日算第一天）
 * %V 一年中的第几周，01-53（周一算第一天）
 * %w 星期几，0-6，周日为9
 * %x 本地格式的日期
 * %X 本地格式的时间
 * %y 年份-1900
 * %Y 年份
 * %Z 时区名
 * %% 字符%
 */

#include <stdio.h>
//创建一个唯一的文件名，缓冲区至少L_tmpnam长
char *tmpnam( char *s );
//创建一个唯一的临时文件，以读写方式打开
FILE *tmpfile( void );

//来自UNIX的临时文件函数，字符串模板必须以XXXXXX结尾，这6个字符会被替换
#include <stdlib.h>
char *mktemp( char *template );
int mkstemp( char *template );

除了init之外，所有Linux进程均是由其它程序或者用户启动的。每个程序都是以某个用户的名义去运行的，用户的内部识别方式是UID。

一般情况下，启动程序的用户的UID，即是程序的有效UID；如果程序的SUID位被设置，那么程序的所有者将作为其有效UID，不论谁启动该程序。

UID的类型是

uid_t

sys/types.h

#include <sys/types.h>
#include <unistd.h>
//得到程序关联的UID，通常是启动程序的用户的ID
uid_t getuid( void );
//返回当前用户关联的登录名
char *getlogin( void );

#include <sys/types.h>
#include <pwd.h>
//获取用户信息的标准接口，出错时返回空指针并设置errno
struct passwd *getpwuid( uid_t uid );
struct passwd *getpwnam( const char *name );
/**
 * passwd结构成员：
 * char *pw_name 用户登录名
 * uid_t pw_uid UID号
 * gid_t pw_gid GID号
 * char *pw_dir 家目录
 * char *pw_gecos 用户全名
 * char *pw_shell 默认Shell
 */

uname命令可以获取主机的若干信息，例如主机名等。

#include <unistd.h>
//获取主机名，字符串被假设最少有namelen长，成功返回0否则返回-1
int gethostname( char *name, size_t namelen );

#include <sys/utsname.h>
//使用uname系统调用，可以获取更多的信息
int uname( struct utsname *name );
struct utsname
{
    char sysname[]; //操作系统名称
    char nodename[]; //主机名称
    char release[]; //操作系统的发布级别
    char version[]; //操作系统的版本号
    char machine[]; //硬件类型
};
//得到唯一的机器ID
#include <unistd.h>
long gethostid( void );

Linux系统文件一般被存放到专用的目录，例如/usr/adm或者/var/log目录。UNIX规范通过syslog函数为所有程序产生日志信息提供了统一接口：

#include <syslog.h>
//该函数向系统的日志设施（facility）发送一条日志消息
//priority：严重级别与实施值的位或
//LOG_EMERG   紧急情况，该信息可能广播给所有用户
//LOG_ALERT   高优先级故障，例如数据库崩溃，该信息可能EMAIL管理员
//LOG_CRIT    严重错误，例如硬件故障
//LOG_ERR     错误
//LOG_WARNING 警告
//LOG_NOTICE  需要注意的特殊情况
//LOG_INFO    一般信息
//LOG_DEBUG   调试信息，该信息可能被忽略，其它级别的一般均记录日志
//
//message：基于printf风格的消息模板，%m表示当前errno
//arguments：模板参数
void syslog( int priority, const char *message, arguments...);

//其它函数
//关闭openlog打开的文件描述符
void closelog( void );
//该函数用于改变日志的表示方式，该函数会打开一个文件描述符，通过它写日志，使用syslog前并不是必须调用该函数
//ident：添加在日志信息前面的前缀

//logopt：对后续syslog调用的行为进行配置，是以下四个值的位或：
//LOG_PID    在日志信息中包含进程标识符
//LOG_CONS   如果无法记录到文件，信息被发送到控制台
//LOG_ODELAY 第一次调用syslog时才打开日志设施
//LOG_NDELAY 立即打开日志设施

//facility：后续syslog调用的默认设施值
void openlog( const char *ident, int logopt, int facility );
//设置日志掩码，来控制日志的优先级，没有在此掩码中置位的优先级，在后续syslog调用中，全部被丢弃
int setlogmask( int maskpri );

syslog创建的日志包含消息头和消息体，消息体由设施值和时间导出，消息体由调用者提供。syslog使用示例如下：

#include <syslog.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    int logmask;
    openlog( "logmask", LOG_PID | LOG_CONS, LOG_USER );
    syslog( LOG_INFO, "informative message, pid = %d", getpid() );
    syslog( LOG_DEBUG, "debug message, should appear" );
    logmask = setlogmask( LOG_UPTO( LOG_NOTICE ) ); //设置日志掩码，改变优先级
    syslog( LOG_DEBUG, "debug message, should not appear" );
    exit( 0 );
}

Linux系统上运行的程序会受到资源限制的影响，这些限制包括硬件方面的物理性限制、系统策略的限制、具体实现的限制（例如整数的长度、文件名允许的最大字符数）。

头文件limits.h包含了一些操作系统方面限制的显式常量：

头文件sys/resource.h提供了资源操作方面的定义：

#include <sys/resource.h>
#include <sys/time.h>
/**
 * 获取优先级。默认的优先级是0，正数用于后台任务，负数使一个程序运行的更加频繁，获得更多CPU时间
 * 优先级的有效范围：-20 ~ +20
 * @param which 指明who参数的含义：PRIO_PROCESS 进程标识符；PRIO_PGRP 进程组；PRIO_USER 用户
 * @param who 标识符
 * @return 成功时返回优先级，失败返回-1并设置errno，因为-1本身是有效的优先级，所有调用函数前应当置errno为0
 */
int getpriority( int which, id_t who );
//设置优先级。普通用户只能降低优先级，不能提高
int setpriority( int which, id_t who, int priority );
/**
 * 获取资源限制
 * @param resource 资源类型，RLIMIT_开头的若干常量
 */
int getrlimit( int resource, struct rlimit *r_limit );
struct rlimit
{
    rlim_t rlim_cur;   //当前软限制，建议性的最好不要超过的限制，如果超过可能导致库函数返回错误
    rlim_t rlim_max;   //硬限制，如果被超越，系统可能发送信号终止程序
};
int setrlimit( int resource, const struct rlimit *r_limit );
/**
 * 将CPU时间信息写入到r_usage中
 * @param who RUSAGE_SELF 仅返回当前程序使用的信息；RUSAGE_CHILDREN 包括子进程的使用信息
 */
int getrusage( int who, struct rusage *r_usage );
struct rusage
{
    struct timeval ru_utime; //使用的用户时间（程序自身的指令消耗的时间）
    struct timeval ru_stime; //使用的系统时间（操作系统为程序执行所消耗的时间，包括I/O等系统调用、其它系统函数调用）
};

C标准库函数可以用来分配内存：

#include <stdlib.h>
//注意，所有这些内存分配函数，都不保证两次调用分配的内存是连续的，不能假设并进行连续寻址
/**
 * 分配指定大小的内存
 */
void *malloc( size_t size );
/**
 * 用于为数组分配内存，所分配的内存全部初始化为0
 * @param number_of_elements 数组元素个数
 * @param element_size 单个元素的大小
 * @return 指向第一个元素的指针
 */
void *calloc( size_t number_of_elements, size_t element_size );
/**
 * 扩大或者减小已分配内存块的长度，可能需要移动整个内存块的位置
 * 注意，一定要使用新的指针，而不是existing_memory的指针进行后续访问
 * 如果无法调整内存块的大小，该函数返回空指针
 */
void *realloc( void *existing_memory, size_t new_size );

当物理内存耗尽时，内存分配会启用交换空间（Swap space），交换空间与Windows的虚拟内存交换文件类似，但是没有需要代码处理的局部堆、全局堆、可丢弃内存段等内容——Linux内核会管理所有工作。

Linux实现了“按需换页的虚拟内存系统”，程序看到的内存全部是虚拟的，Linux将内存按页划分，通常每页4096字节。

Linux内存管理系统能保护系统的其它部分免受错误使用内存的程序的影响，每个程序只能看到属于自己的内存映像，尝试访问不属于自己的内存空间，会导致段错误（Segmentation fault）。

空指针操作：glibc可能允许某些空指针读操作，输出“(null)\0”；空指针写、直接空指针读都是禁止的，会导致程序终止。

动态分配的内存在使用完毕后，应当调用free，将内存归还系统：

#include <stdlib.h>
void free(void *ptr_to memory);

free函数接受的指针必须指向由malloc、calloc、realloc调用所分配的内存。 

下面的几个函数用于连接的初始化与关闭，以及读写数据：

/**
 * 首先，需要使用该函数初始化MySQL连接句柄
 * @param MYSQL* 使用既有的句柄，一般NULL
 */
MYSQL *mysql_init( MYSQL * );
/**
 * 再正式连接之前，可以调用该函数提供一些选项，每次调用只能设置一个选项
 * @param option_to_set 选项，支持：
 *     const unsigned int * MYSQL_OPT_CONNECT_TIMEOUT  连接超时时间
 *     NULL MYSQL_OPT_COMPRESS 启用网络流量压缩
 *     const char * MYSQL_INIT_COMMAND 连接成功后指向的命令
 *     
 * @return 成功后返回0
 */
int mysql_options( MYSQL *connection, enum option_to_set, const char *argument );
/**
 * 然后，提供参数进行连接
 * @return 如果无法连接，返回NULL，可以通过mysql_error函数获取细节
 */
MYSQL *mysql_real_connect(
        MYSQL *connection, //指向已经由mysql_init初始化的结构
        const char *server_host, //主机名或者IP地址
        const char *sql_user_name, //MySQL用户名，为空则使用当前Linux的登录ID
        const char *sql_password, //密码，为空则只能访问不需要密码的资源
        const char *db_name, //使用的MySQL数据库
        unsigned int port_number, //如果使用默认端口，传递0
        const char *unix_socket_name, //一般传递NULL
        unsigned int flags ); //位或标记
/**
 * 执行SQL语句
 * @return 如果成功返回0
 */
int mysql_query( MYSQL *connection, const char *query );
//检查语句影响的行数
my_ulonglong mysql_affected_rows( MYSQL *connection );
//逐行提取结果集
MYSQL_RES *mysql_use_result( MYSQL *connection );
/**
 * 返回全部结果集
 * @return 如果成功，返回结果集指针，否则返回NULL
 */
MYSQL_RES *mysql_store_result( MYSQL *connection );
//上述函数调用成功后，应当调用下面的函数来获取结果集的行数
my_ulonglong mysql_num_rows( MYSQL_RES *result );
//读取下一行数据，如果没有更多的数据返回NULL
MYSQL_ROW mysql_fetch_row( MYSQL_RES *result );
//读取某个字段
MYSQL_FIELD *mysql_fetch_field( MYSQL_RES *result );
//可以在结果集中跳转到指定的偏移量，如果指定为0，那么下一次fetch_row返回第一行
void mysql_data_seek( MYSQL_RES *result, my_ulonglong offset );
//获取当前游标在结果集中的偏移量
MYSQL_ROW_OFFSET mysql_row_tell( MYSQL_RES *result );
//根据偏移量移动游标，返回先前的偏移量
MYSQL_ROW_OFFSET mysql_row_seek( MYSQL_RES *result, MYSQL_ROW_OFFSET offset );
/**
 * 返回结果集中字段的个数
 */
unsigned int mysql_field_count( MYSQL *connection );
//释放结果集相关资源
void mysql_free_result( MYSQL_RES *result );

/**
 * 最后使用完毕后，需要关闭MySQL连接，该函数调用后，MySQL结构被释放，指针失效无法再次使用
 */
void mysql_close( MYSQL *connection );

/**
 * 获取错误代码
 */
unsigned int mysql_errno( MYSQL *connection );
/**
 * 获取错误文本，这些文本存放在MySQL内部静态空间
 */
char *mysql_error( MYSQL *connection );

示例代码：

setvbuf( stdout, NULL, _IONBF, 0 );
MYSQL* conn = mysql_init( NULL );
const unsigned int timeout = 5;
mysql_options( conn, MYSQL_OPT_CONNECT_TIMEOUT, ( char* ) &timeout );
if ( !mysql_real_connect( conn, "127.0.0.1", "root", "root", "test", 0, NULL, 0 ) )
{
    printf( "Failed to connect: %s\n", mysql_error( conn ) );
}
if ( !mysql_query( conn, "INSERT INTO T_CORP (CORP_NAME, CAPI) VALUES ('Gmem Inc.', 1000.20)" ) )
{
    printf( "Inserted %lu rows", ( unsigned long ) mysql_affected_rows( conn ) );
    mysql_query( conn, "SELECT LAST_INSERT_ID()" );
    MYSQL_RES *res_ptr = mysql_use_result( conn ); //使用结果集
    MYSQL_ROW sqlrow; //代表行的字符串数组
    while ( ( sqlrow = mysql_fetch_row( res_ptr ) ) ) //循环读取结果集
    {
        printf( ", Last Corp ID: %s", sqlrow[0] );
    }
    mysql_free_result( res_ptr ); //释放结果集
}
else
{
    printf( "Failed to execute SQL: %s\n", mysql_error( conn ) );
}
mysql_close( conn );

参考：Linux内核编程知识集锦

The post Linux编程知识集锦 appeared first on 绿色记忆.