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 绿色记忆.

Linux系统中每个运行的进程，具有与之关联的文件描述符，通过这些描述符可以访问打开的文件或者设备。当一个进程打开时，一般会有三个已经打开的文件描述符：

下表是与文件访问有关的系统调用

size_t write( int fildes, const void *buf, size_t nbytes );

#include <unistd.h>
write( 1, "stdout", 6 );
write( 2, "stderr", 6 );

size_t read( int fildes, void *buf, size_t nbytes );

char buf[128];
int nread;
//阻塞的从标准输入中读取数据
nread = read( 0, buf, 16 );
write( 2, buf, nread );

#include <fcntl.h>
//严格的说， 在遵守POSIX规范的系统上，下面两个头文件不需要包含
#include <sys/types.h>
#include <sys/stat.h>
//oflags可以指定打开模式
//O_RDONLY   只读
//O_WRONLY   只写
//O_RDWR     读写
//oflags还可以按位或以下选项：
//O_APPEND   写入数据追加在文件结尾
//O_TRUNC    设置文件长度为0，丢弃已有内容
//O_CREAT    如果需要，根据mode中给出的模式创建文件
//O_EXCL     与O_CREAT联用，防止其它进程创建同一个文件
//           如果其它进程创建同一文件，该调用将失败
int open(const char *path, int oflags);
//mode在使用O_CREAT选项时有意义，代表文件的模式（权限）
//模式由S_开头的若干常量来表示，使用时按位或
// S_ISUID 04000 文件的 (set user-id on execution)位
// S_ISGID 02000 文件的 (set group-id on execution)位
// S_ISVTX 01000 文件的sticky 位
// S_IRUSR (S_IREAD) 00400 文件所有者具可读取权限
// S_IWUSR (S_IWRITE)00200 文件所有者具可写入权限
// S_IXUSR (S_IEXEC) 00100 文件所有者具可执行权限
// S_IRGRP 00040 用户组具可读取权限
// S_IWGRP 00020 用户组具可写入权限
// S_IXGRP 00010 用户组具可执行权限
// S_IROTH 00004 其他用户具可读取权限
// S_IWOTH 00002 其他用户具可写入权限
// S_IXOTH 00001 其他用户具可执行权限
int open(const char *path, int oflags, mode_t mode);

#include <unistd.h>
#include <sys/types.h>
//whence可以为：
// SEEK_SET: 表示偏移量为绝对位置
// SEEK_CUR: 表示偏移量是相对于当前位置的位置
// SEEK_END: 表示偏移量是相对于文件结尾的位置
off_t lseek( int fildes, off_t offset, int whence );

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
//该函数通过描述符定位文件
int fstat( int fildes, struct stat *buf );
//下面两个函数通过文件路径定位
int stat( const char *path, struct stat *buf );
//该函数与stat类似，但是如果文件是符号链接，它会
//返回符号链接本身的信息，而stat返回链接目标的信息
int lstat( const char *path, struct stat *buf );

#include <unistd.h>
//复制并返回新的文件描述符
int dup( int fildes );
//复制文件描述符为fildes2
int dup2( int fildes, int fildes2 );

标准I/O库（stdio）及其头文件stdio.h为底层I/O系统提供通用的对外接口，现在这个库已经是ANSI C标准库的一部分。标准I/O库提供多种复杂的函数用于格式化输出、扫描输入，还负责设备缓冲的处理。

在标准I/O库中，操控文件的方式与系统调用类似，其中与底层文件描述符对应的是流（Stream），被实现为指向结构体FILE的指针。

在程序启动时，stdin、stdout、stderr这三个文件已经打开。

标准I/O库关于文件读写API的使用，参考Linux I/O编程

相关系统调用或函数：

#include <sys/stat.h>
int chmod(const char *path, mode_t mode);

#include <sys/types.h>
#include <unistd.h>
int chown(const char *path, uid_t owner, gid_t group);
//支持数字格式的uid、gid，这些ID可以通过getuid、getgid获得

#include <unistd.h>
int unlink(const char *path);
int link(const char *path1, const char *path2);
int symlink(const char *path1, const char *path2);

//创建临时文件的技巧，创建后立即unlink
open(...);
unlink(...);
//该文件会在当前进程退出后自动清理删除

#include <sys/types.h>
#include <sys/stat.h>
int mkdir(const char *path, mode_t mode);

#include <unistd.h>
int rmdir(const char *path);

#include <unistd.h>
int chdir(const char *path);

#include <unistd.h>
char *getcwd(char *buf, size_t size);

虽然可以将目录作为普通文件一样打开读写，但是这种方式不具有可移植性。Linux下用于目录访问的标准库函数定义在dirent.h头中，这些函数使用结构体DIR作为目录操作的基础，DIR*被称为目录流。这些函数中常用的包括：

函数	说明
opendir	opendir打开一个目录并建立目录流，如果失败，返回NULL，在底层，目录流打开目录的文件描述符 #include <sys/types.h> #include <dirent.h> DIR *opendir(const char *name);
readdir	返回一个包含了下一个目录项信息的dirent指针，每次调用返回下一个，遇到目录结尾则返回NULL。如果在迭代期间，其他进程创建/删除了文件，那么readdir不能保证所有文件被列出。 dirent指针包含两个数据项： ino_t d_ino;/*文件Inode节点号*/char d_name[];/*文件的名字*/   #include <sys/types.h> #include <dirent.h> struct dirent *readdir(DIR *dirp);
telldir	返回当前目录流迭代的位置，可以供后续seekdir调用进行重置 #include <sys/types.h> #include <dirent.h> long int telldir(DIR *dirp);
seekdir	设置目录流指针的位置 #include <sys/types.h> #include <dirent.h> void seekdir(DIR *dirp, long int loc);
closedir	关闭目录流，并释放与之相关的资源 #include <sys/types.h> #include <dirent.h> int closedir(DIR *dirp);

很多文件I/O函数在失败后会设置外部变量errno的值，以提示失败的原因，程序必须在函数报告出错后立即检查errno，因为它可能被下一个函数调用覆盖。常见的错误代码包括：

错误代码	说明
EPERM	操作不允许
ENOENT	文件或目录不存在
EINTR	系统调用被中断
EIO	I/O错误
EBUSY	设备或资源忙
EEXIST	文件存在
EINVAL	无效参数
EMFILE	打开的文件过多
ENODEV	设备不存在
EISDIR	是一个目录
ENOTDIR	不是一个目录

下面两个函数用于错误代码的处理：

#include <string.h>
char *strerror(int errnum);

#include <stdio.h>
void perror(const char *s);

该系统调用允许对底层的文件描述符进行更加细致的控制：

#include <fcntl.h>
int fcntl(int fildes, int cmd);
int fcntl(int fildes, int cmd, long arg);

//cmd表示需要执行的动作：
//F_DUPFD 复制并返回一个新的文件描述符
//F_GETFD 返回fcntl.h中定义的文件描述符标记
//F_SETFD 设置文件描述符标记
//F_GETFL 获取文件状态标记、访问模式

内存映射。该函数用于创建一段供多个程序共享的内存，其中一个程序对其的修改，另外一个程序会立即看到。

该函数创建了一个指向了一段内存区域的指针，该内存区域与文件描述符指向的文件的内容关联：

#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);
//addr 起始内存地址，如果设置为0，则自动分配
//len 共享内存的长度
//prot设置共享内存的访问权限，以下位或：
//PROT_READ 该内存段可读
//PROT_WRITE 该内存段可写
//PROT_EXEC 该内存段可执行
//PROT_NONE 该内存段不能被访问
//flags控制程序对内存段的改变造成的影响：
//MAP_PRIVATE 内存段是私有的，修改是本地的，仅对当前进程有效
//MAP_SHARED 对内存段的修改被保留到磁盘
//MAP_FIXED 该段必须位于addr指定的地址
//fildes 共享内存关联的文件描述符
//off 共享内存访问文件内容的偏移值

使用msync函数可以把内存段中的部分或者全部写回到被映射的文件中，或者从文件中读出：

#include <sys/mman.h>
int msync(void *addr, size_t len, int flags);
//addr 起始地址
//len 长度
//flags 标记位：
//MS_ASYNC 执行异步写
//MS_SYNC 执行同步写
//MS_INVALIDATE 把数据读回到内存段

使用munmap函数可以释放内存段：

#include <sys/mman.h>
int munmap(void *addr, size_t len);

该系统调用在Linux下不仅仅可以用于网络I/O，普通文件I/O也被支持：

#include <sys/types.h>
#include <sys/time.h>
#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    char buffer[128];
    int result, nread;
    fd_set inputs, testfds;
    struct timeval timeout;
    FD_ZERO( &inputs ); //初始化为空白文件描述符集
    FD_SET( 0, &inputs ); //设置标准输入
    while ( 1 )
    {
        testfds = inputs;
        timeout.tv_sec = 2;
        timeout.tv_usec = 500000;
        //等待标准输入上具有数据可读，超时2.5秒
        result = select( FD_SETSIZE, &testfds, ( fd_set * ) NULL, ( fd_set * ) NULL, &timeout );
        switch ( result )
        {
            case 0 :
                printf( "超时\n" );
                break;
            case -1 :
                perror( "出错" );
                exit( 1 );
            default :
                if ( FD_ISSET( 0, &testfds ) )
                {
                    //标准输入已经就绪，可以读取
                }
                break;
        }
    }
}

The post Linux IO编程 appeared first on 绿色记忆.

EADDRINUSE

Berkeley sockets（BSD sockets，来自BSD 4.2，1983），是一套用于操控因特网套接字、UNIX域套接字的接口标准，是进程间通信的一种方式。

POSIX sockets与Berkeley sockets的差别很小。大部分的现代操作系统实现了Berkeley sockets接口，甚至包括Microsoft的Winsock。

一个套接字（连接）由五元组来标识：

<protocol>, <src addr>, <src port>, <dest addr>, <dest port>

其中：

1. protocol在创建

   socket()

   时设置
2. src addr / src port 在

   bind()

   时设置
3. dest addr / dest port在

   connect()

   时设置

虽然UDP不需要connect()，但是dest addr / dest port会在第一次发送数据数据时由系统隐式设置。

这套API主要包含了以下头文件：

包含的主要函数有：

/**
 * 创建一个通信端点（endpoint）并返回套接字的文件描述符，如果出错返回-1
 * domain 
 *   指定协议族：AF_INET、AF_INET6、AF_UNIX
 * type 
 *   套接字类型：SOCK_STREAM、SOCK_DGRAM、SOCK_SEQPACKET、SOCK_RAW 
 * protocol 
 *   传输协议：IPPROTO_TCP、IPPROTO_SCTP、IPPROTO_UDP、IPPROTO_DCCP
 *   这些协议定义在netinet/in.h，如果指定0，则根据domain、type推导默认值
 */
int socket(int domain, int type, int protocol);

/**
 * 为套接字分配地址，成功返回0否则返回-1
 * sockfd
 *   被分配地址的套接字的描述符
 * my_addr
 *   代表地址的sockaddr结构的指针
 * addrlen
 *   指定sockaddr结构的长度
 */
int bind(int sockfd, const struct sockaddr *my_addr, socklen_t addrlen);

/**
 * 仅用于面向流（面向连接）的套接字服务端
 * sockfd
 *   监听的套接字描述符
 * backlog
 *   排队入站请求数量，一旦请求被接受即移出队列
 *   超过队列限制的请求被直接拒绝
 */
int listen(int sockfd, int backlog);

/**
 * 该系统调用通过自己指定的套接字，连接到服务器端套接字
 * 对于无连接的套接字类型，该调用不建立连接，只是用于说明数据报的默认目标
 * sockfd
 *   本地套接字描述符
 * serv_addr
 *   远程套接字监听地址
 * addrlen
 *   远程套接字地址的长度  
 */
int connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen);

/**
 * 为连接请求创建一个新的套接字，并移出队列
 * sockfd
 *   监听套接字的描述符
 * cliaddr
 *   用于接收客户端地址信息的结构
 * addrlen
 *   sockaddr类型的长度
 */
int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

/**
 * 通过DNS系统或者/etc/hosts来查找主机名对应的Internet地址信息
 * 如果调用成功返回代表因特网地址的结构hostent，否则返回NULL指针
 * 出错时通过h_errno可以检查具体原因
 * name
 *   主机名，例如gmem.cc
 */
struct hostent *gethostbyname(const char *name);

/**
 * 类似于上面的函数，通过地址来查询
 * addr
 *   in_addr类型的指针，代表了主机的地址
 * len
 *   上面地址的长度
 * type
 *   地址族类型，例如AF_INET
 */
struct hostent *gethostbyaddr(const void *addr, int len, int type);

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define DEFAULT_PORT 1918

const char* ip2txt( struct sockaddr_in addr, char* buf );

int main( void )
{
    int sock_desc, client_sock, read_size;
    struct sockaddr_in server, client;
    socklen_t socklen = sizeof ( server );
    char client_message[2000], ipv4_buf[INET_ADDRSTRLEN];
    struct timeval timeout;
    timeout.tv_sec = 3;
    timeout.tv_usec = 0;

    setvbuf( stdout, NULL, _IONBF, 0 );

    //创建套接字，返回一个描述符
    sock_desc = socket( AF_INET, SOCK_STREAM, 0 );
    if ( sock_desc == -1 )
    {
        puts( "Failed to create socket" );
        return 1;
    }
    //监听套接字结构
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons( DEFAULT_PORT );
    //绑定本地监听地址到描述符
    if ( bind( sock_desc, ( struct sockaddr * ) &server, socklen ) < 0 )
    {
        puts( "Binding failed" );
        return 1;
    }
    else
    {
        printf( "Binding to local socket address: %s:%d\n", ip2txt( server, ipv4_buf ), DEFAULT_PORT );
    }
    //开始监听，等待队列容量10
    listen( sock_desc, 10 );
    for ( ;; )
    {
        //接收一个客户端连接，返回代表此套接字的描述符
        client_sock = accept( sock_desc, ( struct sockaddr * ) &client, &socklen );
        printf( "Connection from %s:%d accepted\n", ip2txt( client, ipv4_buf ), ntohs( client.sin_port ) );
        //设置读取超时，此方法用于Linux，Cygwin无效
        if ( setsockopt( client_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(struct timeval) ) == 0 )
        {
            printf( "recv() timeout set to %ds\n", ( int ) timeout.tv_sec );
        }
        //循环读取数据，该方法会立即返回
        while ( ( read_size = recv( client_sock, client_message, sizeof ( client_message ), 0 ) ) > 0 )
        {
            //把数据原样写给客户端
            printf( "Received message: %s\n", client_message );
            write( client_sock, client_message, strlen( client_message ) );
        }

        //如果超时后仍然读取不到数据、或者出现其他错误，会返回-1
        puts( "Error recv()." );
    }
    return 0;
}

const char* ip2txt( struct sockaddr_in addr, char* buf )
{
    //该函数用来将网络字节序的整数转换为点号分隔的IP地址格式
    return inet_ntop( AF_INET, &addr.sin_addr, buf, INET_ADDRSTRLEN );
}

客户端代码示例：

void client()
{
    int client_sock_desc;
    struct sockaddr_in server;
    char client_message[2000], server_message[2000];
    client_sock_desc = socket( AF_INET, SOCK_STREAM, 0 );
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr( "192.168.0.90" );
    server.sin_port = htons( DEFAULT_PORT );
    socklen_t socklen = sizeof ( server );
    //连接到服务器端
    if ( connect( client_sock_desc, ( struct sockaddr* ) &server, socklen ) < 0 )
    {
        printf( "Connect failed.\n" );
        return;
    }
    while ( 1 )
    {
        printf( "Enter message: \n" );
        scanf( "%s", client_message );
        //发送消息
        if ( send( client_sock_desc, client_message, strlen( client_message ), 0 ) < 0 )
        {
            printf( "Send failed.\n" );
            return;
        }
        //接收回应
        if ( recv( client_sock_desc, server_message, sizeof ( server_message ), 0 ) < 0 )
        {
            printf( "Recv failed.\n" );
            return;
        }
        printf( "Message from server:%s\n", server_message );
    }
}

一般情况下，对于网络服务器不适用“多进程”方式处理，因为网络服务器通常需要很多内存资源，fork()却会复制这些资源。这里只是做一个简单示例：

bind( server_sockfd, ( struct sockaddr * ) &server_address, server_len );
listen( server_sockfd, 5 );
signal( SIGCHLD, SIG_IGN ); //忽略子进程的退出
while ( 1 )
{
    client_len = sizeof ( client_address );
    //接受一个连接请求
    client_sockfd = accept( server_sockfd, ( struct sockaddr * ) &client_address, &client_len );
    //创建子进程处理请求
    if ( fork() == 0 )
    {
        //如果是子进程，读取消息并处理
        //注意子进程继承父进程打开的文件描述符
        read( client_sockfd, &ch, 1 );
        write( client_sockfd, &ch, 1 );
        close( client_sockfd );
        exit( 0 );
    }
    else
    {
        //如果是父进程，只需要关闭描述符
        close( client_sockfd );
    }
}

select系统调用允许同时在多个底层文件描述符上等待输入的到达或输出的完成，避免在单个输入输出上的忙等待。下面是相关的函数说明：

#include <sys/types.h>
#include <sys/time.h>
//下面这组宏用于对文件描述符集合进行操作
void FD_ZERO( fd_set *fdset );//将文件描述符集初始化为空集合
int FD_ISSET( int fd, fd_set *fdset ); //判断文件描述符fd是否存在于fdset中
void FD_CLR( int fd, fd_set *fdset ); //清除一个文件描述符
void FD_SET( int fd, fd_set *fdset ); //设置一个文件描述符
/**
 * 测试文件描述符集中是否至少有一个文件描述符已经处于可读、可写、错误状态。
 * 该函数在以下情况下返回：
 * 1、readfds具有可读、writefds具有可写、errorfds存在描述符遇到错误条件
 * 2、如果上述三个情况都没有发生，该调用在timeout后返回
 * 当返回时，描述符集合被修改为指示哪些描述符可读、可写或者处于错误状态
 * 
 * @param nfds 需要测试的文件描述符数量，从0到nfds-1
 * 下面三个参数都可以被设置为空指针，表示不进行相应的测试
 * @param readfds  读文件描述符
 * @param writefds 写文件描述符
 * @param errorfds 错误文件描述符
 * @param timeout 超时时间，如果是空指针将一直阻塞
 * @return 状态无变化的描述符总数，失败时返回-1并设置errno：
 *         EBADF 无效文件描述符
 *         EINTR 因中断而返回
 *         EINVAL ndfs或者timeout取值错误
 */
int select( int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout );
struct timeval
{
    time_t tv_sec; /* 毫秒 */
    long tv_usec; /* 微秒 */
};

下面是一段示例代码，通过单进程服务多个客户端，并将请求值加1返回给客户端：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>

#define DEFAULT_PORT 1918

int main()
{
    int server_sockfd, client_sockfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
    int result;
    fd_set readfds, testfds;
    //创建客户端TCP套接字
    server_sockfd = socket( AF_INET, SOCK_STREAM, 0 );
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl( INADDR_ANY );
    server_address.sin_port = htons( DEFAULT_PORT );
    server_len = sizeof ( server_address );
    //绑定套接字描述符到本地地址
    bind( server_sockfd, ( struct sockaddr * ) &server_address, server_len );
    //在套接字描述符上监听
    listen( server_sockfd, 5 );
    FD_ZERO( &readfds );
    FD_SET( server_sockfd, &readfds ); //将监听描述符添加到集合中
    while ( 1 )
    {
        char ch;
        int fd;
        int nread;
        testfds = readfds;
        //一直等待，直到输入（连接请求）到达
        result = select( FD_SETSIZE, &testfds, ( fd_set * ) 0, ( fd_set * ) 0, ( struct timeval * ) 0 );
        for ( fd = 0; fd < FD_SETSIZE; fd++ )
        {
            //遍历所有就绪的可读描述符
            if ( FD_ISSET( fd, &testfds ) )
            {
                if ( fd == server_sockfd )
                {
                    //这是一个服务器监听套接字
                    //服务器端套接字就绪，说明有连接请求
                    client_len = sizeof ( client_address );
                    //生成客户套接字，并加入到读套接字集中
                    client_sockfd = accept( server_sockfd, ( struct sockaddr * ) &client_address, &client_len );
                    FD_SET( client_sockfd, &readfds );
                }
                else
                {
                    //这是一个客户套接字
                    ioctl( fd, FIONREAD, &nread ); //得到可读数据字节数
                    if ( nread == 0 )
                    {
                        close( fd );
                        FD_CLR( fd, &readfds ); //从读集合中移除该客户端
                    }
                    else
                    {
                        read( fd, &ch, 1 ); //读取一个字节
                        ch++;
                        write( fd, &ch, 1 ); //写回一个字节
                    }
                }
            }
        }
    }
}

sockfd = socket( AF_INET, SOCK_DGRAM, 0 );
address.sin_family = AF_INET;
address.sin_port = servinfo->s_port;
address.sin_addr = *( struct in_addr * ) *hostinfo->h_addr_list;
len = sizeof(address);
//向address发送一个数据报
sendto( sockfd, buffer, 1, 0, ( struct sockaddr * ) &address, len );
//从address接收数据报
recvfrom( sockfd, buffer, sizeof(buffer), 0, ( struct sockaddr * ) &address, &len );

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include 
#include 
#include 
#include 
#include 
#include <sys/types.h>
#include  

int main(int argc, char *argv[])
{
    int listenfd = 0, connfd = 0;
    struct sockaddr_in serv_addr; 

    char sendBuff[1025];
    time_t ticks; 
    // 下面的调用在内核中创建一个未命名套接字，返回一个整数 —— 套接字描述符
    // AF_INET 地址族，对于IPv4使用AF_INET
    // SOCK_STREAM 传输层协议类型，流式表示需要确认机制
    // 0 让内核决定默认协议，AF_INET + SOCK_STREAM -> TCP
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    memset(&serv_addr, '0', sizeof(serv_addr));
    memset(sendBuff, '0', sizeof(sendBuff)); 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(5000); 
    // 将serv_addr所指定的细节信息，绑定到listenfd。bind调用时可选的，如果不调用，内核可以随机选取监听端口
    bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 

    // 在此套接字上监听新连接请求，最多10个排队
    listen(listenfd, 10); 

    while(1)
    {
        // accept导致当前线程休眠，当有新的客户端请求进入，并且完成3次握手后，线程醒来
        // 获得代表客户端套接字的套接字描述符
        connfd = accept(listenfd, (struct sockaddr*)NULL, NULL); 

        ticks = time(NULL);
        snprintf(sendBuff, sizeof(sendBuff), "%.24s\r\n", ctime(&ticks));
        // 可以向套接字描述符中写数据
        write(connfd, sendBuff, strlen(sendBuff)); 
        // 关闭描述符
        close(connfd);
        sleep(1);
     }
}

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include 
#include 
#include 
#include 
#include 
#include 
#include <arpa/inet.h> 

int main(int argc, char *argv[])
{
    int sockfd = 0, n = 0;
    char recvBuff[1024];
    struct sockaddr_in serv_addr; 

    if(argc != 2)
    {
        printf("\n Usage: %s  \n",argv[0]);
        return 1;
    } 

    memset(recvBuff, '0',sizeof(recvBuff));
    // 创建一个套接字，客户端服务器没有区别
    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("\n Error : Could not create socket \n");
        return 1;
    } 

    memset(&serv_addr, '0', sizeof(serv_addr)); 

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(5000); 

    if(inet_pton(AF_INET, argv[1], &serv_addr.sin_addr)<=0)
    {
        printf("\n inet_pton error occured\n");
        return 1;
    } 

    // 客户端套接字一般都不需要绑定，由内核自由分配一个端口就足够了

    // 尝试连接到远程套接字（IP+端口）
    if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
       printf("\n Error : Connect Failed \n");
       return 1;
    } 
    // 读取套接字，就像读取一个普通文件一样
    while ( (n = read(sockfd, recvBuff, sizeof(recvBuff)-1)) > 0)
    {
        recvBuff[n] = 0;
        if(fputs(recvBuff, stdout) == EOF)
        {
            printf("\n Error : Fputs error\n");
        }
    } 

    if(n < 0)
    {
        printf("\n Read error \n");
    } 

    return 0;
}

应用程序周期性的调用read来检查I/O状态，以完成数据的读取，性能最差。

维护一个最长1024的数组，保存文件描述符的状态，一次select可以遍历很多文件描述符。

int select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

select 函数监视的文件描述符分 3 类，分别是 writefds、readfds 和 exceptfds。调用后 select 函数会阻塞，直到有描述符就绪（有数据 可读、可写、或者有 except），或者超时（timeout 指定等待时间，如果立即返回设为 null 即可）。当 select 函数返回后，通过遍历 fd_set，来找到就绪的描述符。
select 目前几乎在所有的平台上支持，其良好跨平台支持是它的一大优点。select 的一个缺点在于单个进程（Apache使用多进程方式解决此问题，尽管Linux进程很轻量，也是有代价的。而且进程间数据同步远比不上线程间同步的高效）能够监视的文件描述符的数量存在最大限制，在 Linux 上一般为 1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但是这样也会造成效率的降低。

类似于select，但是使用链表解决1024数组长度限制。

int poll (struct pollfd *fds, unsigned int nfds, int timeout);
struct pollfd {
    int fd; /* file descriptor */
    short events; /* requested events to watch */
    short revents; /* returned events witnessed */
};

pollfd 结构包含了要监视的 event 和发生的 event，不再使用 select参数-值传递的方式。同时，pollfd 并没有最大数量限制（但是数量过大后性能也是会下降）。和 select 函数一样，poll 返回后，需要轮询 pollfd 来获取就绪的描述符。
从上面看，select 和 poll 都需要在返回后，通过遍历文件描述符来获取已经就绪的 socket。事实上，同时连接的大量客户端在同一时刻可能只有很少的处于就绪状态，因此随着监视的描述符数量的增长，其效率也会线性下降。

效率最高，调用epoll后，如果没有发现可用的I/O事件，调用线程将会自动休眠，直到有事件发生后，内核将其唤醒。

// 创建 epoll 文件描述符，参数 size 并不是限制了 epoll 所能监听的描述符最大个数，只是对内核初始分配内部数据结构的一个建议
int epoll_create(int size)；
// 对指定描述符 fd 执行 op 操作控制，event 是与 fd 关联的监听事件
// op有三种：添加 EPOLL_CTL_ADD，删除 EPOLL_CTL_DEL，修改 EPOLL_CTL_MOD
//          分别添加、删除和修改对 fd 的监听事件
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；

typedef union epoll_data {
    void *ptr;
    int fd;
    __uint32_t u32;
    __uint64_t u64;
} epoll_data_t;

struct epoll_event {
    __uint32_t events;      /* Epoll events */
    epoll_data_t data;      /* User data variable */
};
//  等待 epfd 上的 IO 事件，最多返回 maxevents 个事件
int epoll_wait(int epfd, struct epoll_event * events,  int maxevents, int timeout);

在 select/poll 中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而 epoll 事先通过 epoll_ctl() 来注册一个文件描述符，一旦某个文件描述符就绪时，内核会采用类似 callback 的回调机制，迅速激活这个文件描述符，当进程调用 epoll_wait 时便得到通知

epoll 的优点主要是一下几个方面：

1. 监视的描述符数量不受限制，它所支持的 fd 上限是最大可以打开文件的数目，这个数字一般远大于 2048, 举个例子, 在 1GB 内存的机器上大约是 10 万左右，具体数目可以

   cat /proc/sys/fs/file-max

   察看, 一般来说这个数目和系统内存关系很大
2. IO 的效率不会随着监视 fd 的数量的增长而下降。epoll 不同于 select 和 poll 轮询的方式，而是通过每个 fd 定义的回调函数来实现的。只有就绪的 fd 才会执行回调函数
3. 支持水平触发和边沿触发两种模式：
   1. 水平触发模式，文件描述符状态发生变化后，如果没有采取行动，它将后面反复通知，这种情况下编程相对简单，libevent 等开源库很多都是使用的这种模式
   2. 边沿触发模式，只告诉进程哪些文件描述符刚刚变为就绪状态，只说一遍，如果没有采取行动，那么它将不会再次告知。理论上边缘触发的性能要更高一些，但是代码实现相当复杂（Nginx 使用的边缘触发）
4. mmap 加速内核与用户空间的信息传递。epoll 是通过内核与用户空间 mmap 同一块内存，避免了无谓的内存拷贝

The post Linux网络编程 appeared first on 绿色记忆.

参考：

1. Linux网络编程
2. Linux编程知识集锦
3. Linux知识集锦

网络接口绑定（Network Interface Bonding）是Linux下的一项技术，它能够将多块物理网卡绑定为单一的逻辑网卡，从而实现：

1. 带宽增加
2. 提供容错能力，防止一根网线损坏的情况

也叫Teaming、 Link Aggregation Groups（LAG）。

你需要先安装bonding内核模块，并且用modprobe查看bonding驱动是否被加载：

sudo modprobe bonding
lsmod | grep bond

你需要先安装两块物理NIC，然后使用下面的命令将它们bond为新的逻辑接口： 

sudo ip link add bond0 type bond mode 802.3ad
sudo ip link set eth0 master bond0
sudo ip link set eth1 master bond0

或者永久化的配置：

auto bond0
iface bond0 inet static
	address 192.168.1.150
	netmask 255.255.255.0	
	gateway 192.168.1.1
	dns-nameservers 192.168.1.1 8.8.8.8
	dns-search domain.local
		slaves eth0 eth1
		bond_mode 0
		bond-miimon 100
		bond_downdelay 200
		bound_updelay 200

参考：TCP/IP协议栈学习笔记

网络地址转换也称为网络掩蔽或者IP掩蔽（Masquerading），是一种在IP封包通过路由器或防火墙时重写源IP地址或目的IP地址的技术。该技术普遍用于只有一个公有IP的局域网中，允许局域网中多台主机与公网上的主机进行通信。NAT 功能通常被集成到路由器、防火墙、ISDN路由器或者单独的NAT设备中。

一个典型的局域网会使用一个专用网络来指定子网，最常用的是192.168.x.x，这个局域网中包含一个路由器，它占用一个IP地址（例如192.168.0.1）。路由器同时通过一个ISP提供的公有IP地址连接到因特网上。

当局域网上的主机需要和公网主机通信时，其发送IP封包，路由器将IP封包的源地址从专有地址192.168.0.x转换为公有地址（例如106.185.46.7），路由记住专有地址[:端口]与公有地址[:端口]的映射关系，当公网主机的IP封包到达时，利用此映射关系改写目的地址，进而转发给局域网主机。

上述的源地址、目的地址改写的过程即为NAT。

NAT的优势：

1. 在IPv4短缺的情况下，可以使多台主机共享一个IP地址接入因特网
2. 隐藏内网计算机，避免受到来自外部网络的攻击

NAT的缺点：

1. 某些协议无法正常工作，例如主动模式的FTP。这些协议需要引入应用层网关（Application Layer Gateway，ALG）才能正常工作

亦可简称NAT或者静态NAT，仅支持地址转换，不支持端口映射。需要每一个连接对应一个公网IP地址，因此需要维护一个公网IP地址池。某些宽带路由器使用这种方式去指定一台局域网主机去接受所有外部连接，并称该机器为DMZ主机（并不是真正意义上的，因为DMZ主机必须与内网隔离）。

NAPT，该方式支持端口映射，允许多台内网主机共享一个公网IP地址，其包括两类转换功能：

1. 源地址转换：发起连接的内网计算机的IP地址将会被重写，使得内网主机发出的数据包能够到达外网主机
2. 目的地址转换：被连接内网计算机的IP地址将被重写，使得外网主机发出的数据包能够到达内网主机

这两种转换一般会一起使用，以支持双向通信。

NAPT需要维护一个NAT表，来基于内网IP/端口与公网IP/端口的对应关系，例如：

 STUN标准将NAPT分为以下几个子类型：

NAT-T技术主要解决两台同时处于NAT设备后面的局域网主机建立网络连接的问题。

两台都处于NAT后面的主机，无法知道对方映射的公网地址/端口，因此，一般的NAT-T技术都需要一个公共服务器作为媒介：要么在建立连接的时候需要用到该服务器，要么所有的数据都通过此公共服务器中继。

假设：

1. 位于NAT后的主机A（局域网IP：192.168.0.89，公网IP：106.185.46.7）
2. 主机B（局域网IP：192.168.1.90，公网IP：106.185.46.10），以公网服务器S（106.185.46.1）为媒介（所谓STUN服务器），进行NAT-T的过程可能如下（A与B是对称的）：
3. A连接S，获得映射地址（192.168.0.89:35330  =>106.185.46.7:2250），将此地址信息告知S
4. B连接S，获得映射地址（192.168.1.90:35330 =>106.185.46.10:3210），将此地址信息告知S
5. A和B分别获取对方的两个地址
6. A尝试连接B
   1. 如果B是完全圆锥型NAT，那么不论A是圆锥型、对称NAT，连接都立刻建立
   2. 如果B是地址或端口受限NAT，由于A之前从未与B通信过，因此无法建立连接
      1. 如果A是地址或端口受限NAT，与B的连接无法建立，但是A尝试发包到B的记录已经被A侧NAT记录。只要该记录没有过期，B就可以反过来向A发送数据，该数据 A必然收到，随后A和B即可双向通信
      2. 如果A是对称型NAT，B利用从S得到的关于A的信息（假设为192.168.0.89:35330 =>106.185.46.7:2250 => 106.185.46.1:3387），尝试向106.185.46.7:2250发送信息，由于A的对称NAT的限制，此尝试必然失败。但是，此尝试在B侧留下了NAT记录。如果
         1. B是地址受限NAT，那么A可以再次向B发送数据，这一次B必然收到
         2. B是端口受限NAT，则无法通信
   3. B是对称NAT的情况下，如果A是对称NAT或者端口受限圆锥型NAT，则双方无法通信

网桥（Bridge）是一种（可以是软件虚拟的）设备，该设备有两个或者多个网络接口，分别连接到多个局域网（不同网段）中。网桥将它连接的某个局域网发送的数据帧，统一转发到其它网络接口对应的局域网中，从而将多个网络在数据链路层无缝连接起来，就好像是一个局域网一样。任何真实设备（例如eth0）和虚拟设备（例如tap0）都可链接到网桥。

网桥与路由器不同，后者允许多个网络在保持独立的情况下能够相互通信。网桥的行为更像是一台虚拟的交换机，它能够透明的工作，其它主机不需要知道其存在。

Vmware中的桥接，和一般意义上的桥接原理是一样的，它让虚拟机网卡连接到一个虚拟的以太网交换机，虚拟以太网交换机与宿主机器的以太网卡通过一个“虚拟网桥”相连。

当你将一个网络接口（例如eth0）添加到Linux虚拟网桥（例如br0）时，你需要把IP地址从eth0移除，并添加到br0，这样才能保证网络正常工作。

这是因为，网桥br0负责处理本机eth0的入站流量，它应该响应ARP请求——这样它才能把流量转发给网桥中的其它网络接口，因而它拥有eth0的IP就很合理了（把网桥的MAC和IP关联）。

默认情况下，Bridge不允许包从收到包的端口发出。例如，当Bridge从一个端口接收到广播报文后，它会将报文向其它端口全部发出，而不包括接收的那个端口。

你可以在端口级别打开Hairpin模式，这样，从该端口进入网桥的包，还可以从此端口出去。在NAT场景下，例如Docker的NAT网络，从容器访问它映射（80）到的主机端口（8080）时：

1. 容器访问hostip:8080
2. 请求到达网桥，来自端口A
3. 进入宿主机协议栈
4. DNAT转换为continerip:80
5. 协议包又要从A端口发出

为什么叫Hairpin，这是形象的描述流量的走向，就像最简单的U形发卡一样，封包经过网桥/路由处理后，从它来自的地方发回去。

当一张网卡被设置为混杂（Promicuous）模式，它就会接收网络上所有的数据帧，从而可以实现监听。

有多种方式可以检测处于混杂模式的网卡，假设现在怀疑硬件地址为38-83-45-09-0A-60、IP地址为192.168.1.5的网卡处于混杂模式，可以：

1. 伪造ICMP报文：ECHO_REQUEST，即ping命令使用的报文，将其IP首部的目的地址设置为192.168.1.5，以太网帧首部的目的地址设置为虚假的地址00-00-00-00-00-00。如果192.168.1.5是正常的网卡，它将会检测硬件地址，发现与自己的地址不同，因而忽略此帧；反之，如果192.168.1.5处于混杂模式，则它不会做硬件地址的比较，报文直接交由上层处理，导致回复ICMP报文
2. 以非广播方式在局域网内发送ARP请求，如果某个网卡回复之，则其可能处于混杂模式

首先要保证局域网的安全，因此这种监听只能出现在局域网内，因此必须有以太局域网主机被攻破。

另外数据加密也是比较好的手段，如果监听到的报文是加密的，没有什么用。

使用交换机也是一种常见的方式，交换机工作在数据链路层，与工作在物理层的HUB不同。交换机通常会维护一个ARP数据库，记录每个交换机端口绑定的MAC地址，当报文到达交换机时，它只会将其从匹配的端口发送出去。交换机只在两种情况下广播报文：

1. 以太网帧的目的地址在本地ARP数据库中不存在
2. 报文本身就是广播的

交换机可以在很大程度上解决监听问题，但是不能防止ARP欺骗。

所谓隧道（Tunneling），是指使用一种网络协议，并将另外一个网络协议封装在其载荷（或称负载，Payload）部分的技术。前者叫做隧道协议，后者叫做负载协议。使用隧道技术的目的一般是：

1. 在不兼容的网络上传送网络协议数据报
2. 在不安全的网络上提供安全性保证
3. 规避防火墙，被防火墙阻挡的协议可以封装在不被阻挡的协议中，例如HTTP

通常，隧道协议往往位于负载协议的高层（例如PPTP，即点对点隧道协议，可以通过TCP来封装PPP，前者工作在传输层，而PPP是链路层协议），或者与负载协议处于同一层。

Linux L3的隧道技术，主要基于TUN设备实现。

常见的隧道协议包括：

在传统TCP/IP术语中，网络设备只分为网关、主机（亦称终端系统）两种，前者能够在网络间传递数据报。网关的数据处理一般只到达第三层（IP层）。网关与路由器在传统TCP/IP术语中往往是一个概念。

现代网络术语中，网关与路由器不同，网关能够在不同协议之间移动数据；而路由器则是在不同网络之间移动数据。例如，语音网关可以连接公共交换电话网（PSTN）与以太网，实现网络电话。

多播（MultiCast）也称为组播，包括链路层、网络层、应用层等多播技术。多播通常指IP多播（网络层）。

由于在IPv4网络中，多播包可能不被路由，因此你只能在局域网中使用多播技术。DVMRP、MOSPF 之类的技术解决此问题，但是你需要能够对客户端 - 服务器之间所有路由器进行配置，或者创建隧道。IPv6网络是强制支持IP多播的。

网络虚拟化是一个很大的技术方向，可以包括硬件、软件或者相结合的实现方式。

Linux内核支持的网络虚拟化，主要包括两个方面：

1. 软交换机：Linux Bridge, OpenVSwitch
2. 虚拟网络适配器：tun、tap、veth等

VLAN（Virtual Local Area Network）是广泛应用的网络虚拟化（在一套物理网络设备上虚拟出多个二层网络）技术，它直接在Ethernet帧的头部加上4个字节的VLAN Tag，此Tag用于标识不同的二层网络。VLAN已经在大部分的网络设备和操作系统中得到了支持，它处理起来也比较简单，在读取Ethernet数据的时候，只需要根据EtherType相应的偏移4个字节就行。利用VLAN可以：

1. 将主机进行分组，即使主机不是连接到同一交换机上
2. 可以对连接到相同交换机/网桥上的主机/客户机进行隔离，划分到不同子网。这样一个交换机就可以表现的像是多个独立交换机一样

VLAN ID的范围是1 - 4095，对于规模较大的IT组织，需要谨慎规划子网，否则VLAN ID可能不够用。

假设你的IT环境下有一个物理交换机，连接着一系列物理主机，现在需要划分为三个独立网络。管理员配置交换机端口，将它们的VLAN ID分别设置为10 11 12，不同网络的主机分别连接到对应的端口。这种仅仅配置针对单个VLAND的端口，叫做access port。

随着规模的增大，一个交换机不够用了，管理员又引入一个交换机。这样，两个交换机必须都有一个端口，它允许任何以太网帧通过，而不管帧的VLAN ID，否则就无法联通了。这种不过滤VLAN ID的端口叫做trunk port。

在虚拟化环境下，交换机的所有端口都会配置为trunk port。这样，每个端口（也就是主机）上都可以运行不同虚拟网络的VM。

VXLAN（Virtual eXtensible Local Area Network）是目前最热门的网络虚拟化/Overlay/虚拟隧道技术之一，VXLAN协议将Ethernet帧封装在底层网络（Underlay）的三层报文（UDP）内，再加上8个字节的VXLAN header，用来标识不同的二层网络：

VXLAN数据是经过VTEP（VXLAN Tunnel EndPoint）封装和解封装的，相应的VXLAN数据的外层UDP封包的IP（源、目的）地址就是VTEP（本机、对方）的IP地址，端口就是VTEP设备的端口（默认4789）。最外层的MAC地址用来实现VTEP之间的数据传递。每个物理节点上的所有虚拟机可以共享VTEP。VTEP可以由软件（例如OVS）或硬件实现。

VXLAN因为提出的较晚，在设备上的支持率不如VLAN，而且，VXLAN数据的封装解封装，要比VLAN复杂的多。但是它具有以下优势：

1. VLAN ID数量限制：8个字节的VXLAN Header。其中的24bit用来标识（VNI，VXLAN Network Identifier）不同的二层网络，这样总共可以标识1600多万个不同的二层网络
2. TOR交换机MAC地址表限制：在网络虚拟化之前，TOR交换机的一个端口连接一个物理主机对应一个MAC地址，但现在交换机的一个端口虽然还是连接一个物理主机但是可能进而连接几十个甚至上百个虚拟机和相应数量的MAC地址，MAC地址表记录在交换机的内存中，而交换机的内存是有限的。如果使用VXLAN，虚拟机的以太网帧被VTEP封装在UDP里面，一个VTEP可以被一个物理主机上的所有虚拟机共用
3. 灵活的虚机部署：采用VLAN网络的虚拟环境，不存在Overlay网络。虚拟机的网络数据，被打上VLAN Tag之后，直接在物理网络上传输，与物理网络上的VLAN是融合在一起的。这种实现机制的好处是：虚拟机能直接访问到物理网络的设备。而坏处是，无法突破物理网络的限制，通常不同的VLAN网络，会被分配不同的IP地址段，通过路由器或者其他的三层设备连接在一起，不同VLAN的虚拟机不能方便的进行L2通信。使用VXLAN后，由于基于UDP进行封装，因此可以在L2或L3网络上构建L2网络，这是一个独立于物理网络的Overlay network

和普通隧道（例如ipip）不同，VXLAN是一对多的，而不是1：1的隧道协议。VXLAN设备可以像网桥那样，动态添加对端IP地址。严格来说，VXLAN模型中并没有隧道的物理实体。

配置和管理VXLAN，需要内核版本3.7以上的iproute2包，ip命令即此包的用户空间工具。

VXLAN报文的转发过程如下：

1. 原始报文经过源主机上的VTEP设备，被Linux内核添加VXLAN包头、外层UDP头，发送出去
2. 对端VTEP设备接收到VXLAN报文，移除UDP头，然后根据VXLAN头决定发给哪个虚拟机

在通信之前，需要回答以下三个问题：

1. 哪些VTEP需要加到同一VNI组
2. 源虚拟机如何知道目的虚拟机的MAC地址
3. 如何知道目的虚拟机在哪个节点

问题1，通常由管理员进行配置。问题2/3本质上是一个问题 —— VXLAN通信双方如何感知彼此：

1. 内层报文，双方IP地址可以认为是已知
2. 内层报文，对方MAC地址，需要实现一种ARP机制
3. VXLAN头，只需要知道VNI，通常直接配置在VTEP上 —— 要么提前规划，要么根据内层报文自动生成
4. UDP头，需要知道源、目的地址/端口。源地址端口自动获取，目的端口一般默认4789，目的IP地址亦即目标主机的VTEP地址，可以通过两种方式得到：
   1. 组播：同一个VXLAN网络的VTEP加入到同一组播网络中，通过组播同步信息
   2. 控制中心：集中式保存需要的信息

这种配置下，两台机器构成一个VXLAN网络，每个机器上配置一个VTEP，VTEP之间通过它们的IP地址进行通信。

首先，需要添加VXLAN类型的接口：

# 接口类型  VNI  对端端口
ip link add vxlan0 type vxlan id 1 dstport 4789 
  # 对端Underlay地址  本地Underlay地址   物理网络接口
  remote 192.168.1.3 local 192.168.1.2 dev ens33

为VTEP分配IP地址并启用之：

# 自动添加路由 172.17.1.0      0.0.0.0         255.255.255.0   U     0      0        0 vxlan0
ip addr add 172.17.1.2/24 dev vxlan0
ip link set vxlan0 up

此时你可以看到如下FDB（Forwarding information base，也叫MAC表）表项： 

bridge fdb
00:00:00:00:00:00 dev vxlan0 dst 192.168.1.3 via ens33 self permanent

该项的含义是， 默认的VTEP对端地址为192.168.1.3。原始报文经过vxlan0接口后，内核会为其添加VXLAN头部，外部封装的UDP包的目的IP地址会被设置为192.168.1.3。

在对端，你需要进行对应的配置，VNI必须保持一致。 

该模式需要Underlay网络支持组播。首先创建VTEP：

# VNI                    # 使用ens33上的多播组239.1.1.1进行信息交换
ip link add vxlan0 type vxlan id 1  local 192.168.1.2  group 239.1.1.1 dev ens33 dstport 4789

和点对点模式类似的，你需要为VTEP配置IP地址并且启用之。此时，你可以看到如下FDB表项：

00:00:00:00:00:00 dev vxlan0 dst 239.1.1.1 via ens33 self permanent

和点对点模式不同的是，dst字段的值设置为组播地址，而非对端Underlay IP地址。这个条目会导致默认情况下UDP头的目的地址被设置为组播地址239.1.1.1。

在所有参与到VXLAN的节点上，你需要进行对应的配置，VNI必须保持一致。

该模式下VTEP之间通信过程如下：

1. 主机1通过vxlan0发起ping 172.17.1.3报文到主机2的vxlan0
2. 主机1内核发现目的地址和源地址在同一二层网络中，需要获取对方MAC地址，但是本地没有缓存，因此发送ARP查询请求
3. ARP报文源MAC地址为主机1的vxlan0的MAC地址，目的地址为广播地址255.255.255.255
4. 内核将ARP报文封装到UDP中，设置VXLAN头。由于VTEP配置了多播组，同时不知道目标VTEP在哪台主机上，因此会从239.1.1.1发送组播报文
5. 多播组中所有主机都会收到UDP报文，并根据VXLAN头发送给对应的VTEP
6. VTEP去掉VXLAN头，得到ARP请求报文，并将源VTEP的MAC地址+源主机IP地址信息记录到FDB表中
7. 主机2发现ARP请求是针对自己的，因此生成ARP应答，并且单播（因为已经知道主机1的IP-MAC对应关系）给主机1的VTEP
8. ARP应答通过底层网络发送给主机1，解析后发送给vxlan0，VTEP解析ARP报文并更新VTEP缓存，同时根据报文学习得到目的VTEP所在的主机地址，添加到自己的FDB表

实际情况下，每个主机都可能有几十甚至上百个虚拟机/容器，需要加入到同一个VLAN中，而每个VLAN在一台主机上仅仅有一个VTEP。

一个简单的解决办法是桥接。对于容器场景，可以用VETH Pair将容器连接到网桥，然后将VTEP也连接到网桥。VTEP通过物理网络相互联系。

由于某些网络设备不支持多播，而且多播导致的不必要流量，在生产环境下VXLAN多播模式用的很少。

生产环境主要使用分布式控制中心架构，在每个VTEP节点部署Agent，Agent联系控制中心，获取通信所需要的信息（FDB+ARP）。

L2设备，一种虚拟的网桥（Bridge），它是：

1. 一种网络设备，因此可以配置IP地址、MAC地址
2. 虚拟交换机，具有和物理交换机类似的能力

普通网络设备只有两个Port，一端的数据会从另外一端出去。例如物理网卡，会从外部接收数据，发往内核协议栈，或者从内核协议栈接收数据发送到外部。

Bridge则不同，它具有多个Port，数据可以从任何端口进来，至于从哪个端口出去，原理类似于物理交换机 —— 要看MAC地址。

Bridge被广泛用于KVM/QEMU、容器技术。

下面的命令创建并启用一个网桥：

ip link add name br0 type bridge
ip link set br0 up

# 或者使用brctl命令
brctl addbr br0

刚创建的网桥，一端连接着网络协议栈，其余什么都没有连接，因此没有任何功能。

下面我们创建veth对：

ip link add veth0 type veth peer name veth1
ip addr add 1.2.3.101/24 dev veth0
ip addr add 1.2.3.102/24 dev veth1
ip link set veth0 up
ip link set veth1 up


# 接受源自本地IP的ARP包
echo 1 > /proc/sys/net/ipv4/conf/all/accept_local 
# 不进行源地址校验
echo 0 > /proc/sys/net/ipv4/conf/all/rp_filter 
echo 0 > /proc/sys/net/ipv4/conf/veth0/rp_filter 
echo 0 > /proc/sys/net/ipv4/conf/veth1/rp_filter


# 现在测试是可以通的
#         由于目的地址是本地地址，默认会走lo，因此用 -I 强制指定PING请求的源地址/源接口
ping -c 1 -I veth0 1.2.3.102

并且将其一端连接到网桥： 

ip link set dev veth0 master br0
# 或者使用brctl命令
brctl addif br0 veth0

使用下面的命令查看网桥上连接了哪些设备：

bridge link
# 9: veth0 state UP : <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 master br0 state forwarding priority 32 cost 2 

# 或者使用brctl命令
brctl show
# bridge name	bridge id		   STP enabled	interfaces
# br0		    8000.4a4c11893317	no		     veth0
# docker0		8000.02428b446c5b	no		
# virbr0		8000.deadbeef0000	no		     virbr0-nic

现在：

1. br0和veth0连接起来，双向通道
2. 协议栈和veth0是单向通道，协议栈可以发数据给veth0，veth0从外部接受的数据不能发送给协议栈
3. br0的MAC地址变成veth0的MAC地址 

相当于br0在veth0和协议栈之间做了拦截 —— 本来veth0发给协议栈的数据，全部转发给br0处理了。 

而且，veth0和veth1之间也不通了：

ping -c 1 -I veth0 1.2.3.102
# From 1.2.3.101 icmp_seq=1 Destination Host Unreachable

原因是什么呢？下面在veth1、veth0、br0上分别抓包：

tcpdump -n -i veth0
# tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
# listening on veth0, link-type EN10MB (Ethernet), capture size 65535 bytes
# 22:37:16.291125 ARP, Request who-has 1.2.3.102 tell 1.2.3.101, length 28
# 22:37:16.291165 ARP, Reply 1.2.3.102 is-at ce:97:9b:c2:d1:ee, length 28

tcpdump -n -i veth1
# tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
# listening on veth1, link-type EN10MB (Ethernet), capture size 65535 bytes
# 22:37:16.291140 ARP, Request who-has 1.2.3.102 tell 1.2.3.101, length 28
# 22:37:16.291163 ARP, Reply 1.2.3.102 is-at ce:97:9b:c2:d1:ee, length 28


tcpdump -n -i br0
# tcpdump: WARNING: br0: no IPv4 address assigned
# tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
# listening on br0, link-type EN10MB (Ethernet), capture size 65535 bytes
# 22:37:16.291165 ARP, Reply 1.2.3.102 is-at ce:97:9b:c2:d1:ee, length 28
# 22:37:17.289325 ARP, Reply 1.2.3.102 is-at ce:97:9b:c2:d1:ee, length 28

可以看到，veth0、veth1正常进行了ARP请求、响应，br0则仅仅监控到响应。但是veth0却不能将ARP应答发给协议栈，因此无法通信。 具体分析：

1. Ping命令发起ICMP请求，设置IP封包的源接口为veth0
2. 内核接受到上述封包，发送到目的地址1.2.3.102之前，发现没有ARP缓存，无法生成L2帧
3. 内核发送ARP请求，从veth0发出
4. veth1接口接收到ARP请求，并正常响应之
5. veth0接收到响应
6. veth0将响应通过交换机br0发送，而非内核
7. 内核没有接收到ARP响应，L2帧发送失败，Ping失败

下面，把veth0的IP地址转让给br0：

ip addr del 1.2.3.101/24 dev veth0
ip addr add 1.2.3.101/24 dev br0

现在，veth0没有IP地址了，因此协议栈在路由的时候，不会将数据包发送给veth0。这意味着，协议栈到veth0的单向通道也断了，veth0单纯变成了连接br0和veth1的网线。 

从br0 Ping veth1现在可以收到ICMP应答报文。报文流转路线：内核 - br0 - veth0 - veth1 - 内核 - veth1 - veth0 - br0 - 内核，但是却还不能联系到外部网络。另外，veth0仍然无法Ping通veth1，原因还是无法将ARP应答返回给内核。 

现在，再把物理网卡添加到网桥：

ip link set dev eth0 master br0

现在eth0也和veth0一样，接受到的封包直接转发给br0，而不发给协议栈，自己变为一根网线。eth0、veth0无法Ping通网关，而br0则通过eth0这根网线连接到网关，veth1也可以通过br0 ping通网关。

这时，eth0已经成为一根网线，它上面配置IP没有意义，反而会影响路由表：

ip addr del 192.169.1.105/24 dev eth0

eth0被删除后默认路由消失，重新添加默认路由后，可以从veth1连接外部网络。

对于虚拟机来说，通常通过tun/tap等网络设备，将虚拟机内的网卡连接到网桥，再由网桥转发给出去。

对于容器来说，每个则通常使用veth对。容器的网关被桥接到br0，且网关设置为br0。容器IP封包发到br0后，进入宿主机协议栈。宿主机需要配置IP转发功能，可以把容器IP封包转发出去。由于容器、宿主机物理网络通常不是一个网段，因此转发出去之前通常需要NAT。

混杂模式下，网卡会把所有接收到的流量交给协议栈处理，不管目的MAC地址是否匹配。

使用下面的命令，使网卡进入混杂模式：

ifconfig eth0 promisc

使用下面的命令则退出混杂模式：

ifconfig eth0 -promisc

需要注意的时，加入到网桥后，设备自动进入混杂模式。退出网桥后则自动退出混杂模式。另外加入网桥期间，设备无法退出混杂模式。  

通过网桥，可以协助处理虚拟化/命名空间下的基于多VLAN的网络虚拟化。

VLAN filtering是在3.8引入的特性，可以简化基于VLAN的网络虚拟化的配置复杂度。利用VLAN filtering，管理员不需要创建大量的VLAN、Bridge。使用一个网桥，你就能够控制所有VLAN。

这里我们看一个在虚拟化中广泛使用的网络拓扑：不同子网的虚拟机通过网桥，通过bond做负载均衡，最后连接到物理网卡。

没有VLAN filtering之前，拓扑图如下：

创建此拓扑的步骤：

1. 创建bond设备，作为两张物理网卡的master：
   

   ip link add bond0 type bond
   ip link set bond0 type bond miimon 100 mode balance-alb
   
   ip link set eth0 down
   ip link set eth0 master bond0
   
   ip link set eth1 down
   ip link set eth1 master bond0
   
   ip link set bond0 up 

2. 在bond0上创建VLAN子接口：
   

   ip link add link bond0 name bond0.2 type vlan id 2
   ip link set bond0.2 up
   
   ip link add link bond0 name bond0.3 type vlan id 3
   ip link set bond0.3 up

3. 将VLAN子接口分别连接到一个网桥：

   ip link add br0 type bridge
   ip link set bond0.2 master br0
   ip link set br0 up
   
   ip link add br1 type bridge
   ip link set bond0.3 master br1
   ip link set br1 up 

4. 将代表虚拟机的TAP设备也连接到网桥：

   ip link set guest_1_tap_0 master br0
   ip link set guest_2_tap_0 master br0
   
   ip link set guest_2_tap_1 master br1
   ip link set guest_3_tap_0 master br1 

如果使用了VLAN filtering，就不需要创建bond的VLAN子接口，也仅需要一个网桥：

创建此拓扑的步骤：

1.  创建bond设备：

   ip link add bond0 type bond
   ip link set bond0 type bond miimon 100 mode balance-alb
   ip link set eth0 down
   ip link set eth0 master bond0
   ip link set eth1 down
   ip link set eth1 master bond0
   ip link set bond0 up

2. 创建网桥，启用VLAN Filtering： 

   ip link add br0 type bridge
   ip link set br0 up
   ip link set br0 type bridge vlan_filtering 1
   
   ip link set bond0 master br0

3.  将TAP连接到网桥：

   ip link set guest_1_tap_0 master br0
   ip link set guest_2_tap_0 master br0
   
   ip link set guest_2_tap_1 master br0
   ip link set guest_3_tap_0 master br0

4. 为这些TAP接口、Bond接口设置VLAN filter：
   

   bridge vlan add dev guest_1_tap_0 vid 2 pvid untagged master
   bridge vlan add dev guest_2_tap_0 vid 2 pvid untagged master
   
   bridge vlan add dev guest_2_tap_1 vid 3 pvid untagged master
   bridge vlan add dev guest_3_tap_0 vid 3 pvid untagged master
   
   bridge vlan add dev bond0 vid 2 master
   bridge vlan add dev bond0 vid 3 master 

简单的理解：TUN/TAP就是针对用户空间程序而不是物理媒体的网络接口，这种网络接口的一端连接着网络协议栈，另一端连接着用户空间程序。不同于普通靠硬件板卡实现的设备，TUN/TAP全部用软件实现，并向运行于操作系统上的软件提供与硬件的网络设备完全相同的功能。

TUN/TAP为用户空间程序提供数据包的收发功能，它可以呈现为简单的点对点设备或者以太网设备，与物理设备不同的是，它从用户空间程序接收数据包而不是物理媒体；同样的，它将数据包发送给用户空间程序，而不是物理媒体。操作系统通过TUN/TAP设备发送的数据包，被分发给关联到这些设备的用户空间程序中。用户空间程序也可以将数据包发给TUN/TAP设备，后者把数据包注入到操作系统的网络栈之中，模拟为来自外部的数据。

要使用TUN驱动，必须打开/dev/net/tun文件，并发起相应的ioctl()调用，来向内核注册一个网络设备，这些网络设备可以通过ifconfig看到，名字为tunXXX或者tapXXX（依据调用时的选项）。当关闭文件描述符时，这些网络设备连同相应的路由会消失。用户程序写入/dev/net/tun文件的数据，会写到内核网络协议栈；用户程序从/dev/net/tun文件读取时，则拿到内核发送给tun设备的IP封包。

要使用TAP驱动，基本和TUN完全相同，区别有几点：

1. tun设备的/dev/tunX工作在L3，可以通过IP转发和物理网卡连通
2. tap设备的/dev/tapX工作在L2，可以和物理网卡进行桥接

TUN模拟了网络层（点对点）设备，操作第三层数据包比如IP数据封包。普通的网卡通过网线收发数据包，但是 TUN 设备通过一个文件收发数据包。所有对这个文件的写操作会通过 TUN 设备转换成一个数据包送给内核；当内核发送一个包给 TUN 设备时，通过读这个文件可以拿到数据包的内容：

TUN 设备的 /dev/tunX 文件收发的是 IP 层数据包，只能工作在 IP 层，无法与物理网卡做 bridge，但是可以通过三层交换（如 ip_forward）与物理网卡连通。

TUN的含义即隧道，实际上TUN的确和隧道技术有关系。tun/tap设备将协议栈的部分数据转发给用户空间程序，使之有处理数据包的机会，例如加密、压缩。VPN是最常见的应用场景。下面是基于TUN设备实现VPN的过程：

1. 本地应用构造一个数据包，发送给tun0所在网段（虚拟网络）的IP地址192.168.1.3
2. 数据包到达内核协议栈后，根据目的IP地址判断需要从tun0发出
3. tun0的一端连接着内核协议栈，另一端则连接着用户空间应用 —— VPN程序
4. VPN程序对数据包进行再次封装，源地址设置为eth0，目的地址设置为eth0所在网段的VPN对端物理机IP地址
5. 封装后数据包发送到协议栈，走eth0发送到VPN对端

Linux的L3隧道技术都是基于TUN设备，包括ipip、GRE、sit、ISATAP、VTI等。

TAP 等同于一个以太网设备，它操作第二层数据包如以太网数据帧。TAP的工作方式和TUN完全相同。

TAP 设备的 /dev/tapX 文件收发的是 MAC 层数据包，拥有 MAC 层功能，可以与物理网卡做 bridge，支持 MAC 层广播。

Libvirt创建的VM，会在宿主机上对应一个vnet*接口，这个接口桥接到网桥设备virbr*：

virbr0		8000.100000000000	no		virbr0-nic
							vnet0
							vnet1

这些vnet接口，就是TAP设备，它关联到一个进程，即运行qemu-kvm模拟器的那个进程。qemu-kvm写入到此接口的数据，在宿主机看来，就好像从vnet这个网卡接收到的封包似的。反之亦然，qemu-kvm从此接口读取的数据，会写入到虚拟机的eth0，在虚拟机看来，就好像是从网卡接收到封包似的。

也是虚拟的以太网设备，可以作为网络命名空间的隧道，让两个网络命名空间可以通信。VETH也能够作为独立网络设备使用。从效果上说，VETH就像是两个网络接口通过RJ45网线连接在一起似的。

VETH设备总是成对形式创建的：

# 创建一对veth，相互连接起来
ip link add veth0 type veth peer name veth1

# 查看veth对
ip link list
# 13: veth1@veth0: <BROADCAST,MULTICAST,M-DOWN> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
#     link/ether 72:a4:a7:eb:e8:db brd ff:ff:ff:ff:ff:ff
# 14: veth0@veth1: <BROADCAST,MULTICAST,M-DOWN> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
#     link/ether 46:ba:9b:5e:3a:27 brd ff:ff:ff:ff:ff:ff

从一端发送的数据，会立即在另一端接收到。任何一端Down掉或删除，则veth对的状态被破坏。

可以把veth放到其他网络命名空间：

# 创建一个新的网络命名空间
ip netns add test

# 移动veth1
ip link set veth1 netns test

移动了以后，从当前命名空间看到的，Peer的名字会变化：

# 默认命名空间看veth1变为if13，表示Peer是test命名空间序号为13的网络接口
ip link show veth0
# 14: veth0@if13: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
#     link/ether 46:ba:9b:5e:3a:27 brd ff:ff:ff:ff:ff:ff link-netnsid 3

# test命名空间看veth0变为if14，和上面的序号14匹配
ip netns exec test ip link show veth1
# 13: veth1@if14: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
#    link/ether 72:a4:a7:eb:e8:db brd ff:ff:ff:ff:ff:ff link-netnsid 0

在宿主机上，通过设置路由，可以让其他网络命名空间的流量通过veth对出站。 

VETH和TAP都是用来传递L2以太网帧的，TAP/TUN常用于用于加密、VPN、隧道、虚拟机，VETH常用于不同命名空间之间进行数据穿越。这有历史问题在里面。

下面是OpenStack创建了新的虚拟机vm0后的网络架构图：

关于虚拟机vm0的网络模型，说明如下：

1. 虚拟机中的eth0，连接到vnet0，vnet0是Linux网桥qbrXXX的TAP接口
2. Linux网桥qbrXXX连接到OVS网桥br-int，通过一对VETH qvbXXX - qv0XXX

可以看到，通过TAP将虚拟机连接到第一个网桥qbrXXX，而VETH对则将第一个网桥连接到第二个。为什么需要两根RJ45网线呢？用其中一个不行么？

主要原因是遗留技术的存在：

1. 当KVM产生一个虚拟机，它期望一个TAP接口连接到虚拟机的以太网端口（eth0），这样KVM就得到一个FD，它在其上读写以太网帧。也就是说TAP是去不掉的
2. 而VETH是相对新的技术，能够支持Linux Bridge、命名空间、Open vSwitch等技术

有时我们需要一块物理网卡绑定多个 IP 以及多个 MAC 地址，虽然绑定多个 IP 很容易（通过网卡别名，例如eth0:1），但是这些 IP 会共享物理网卡的 MAC 地址，可能无法满足我们的设计需求，所以有了 macvlan设备，其工作方式如下：

配合网络命名空间机制，可以在不需要建立Bridge的情况下，为虚拟机建立独立的网络栈：

MacVLAN接口可以看做是物理以太网接口的N个虚拟子接口（sub interface），每个子接口都具有区别于父接口（parent interface）的MAC地址，并且可以像普通网卡一样分配IP地址。这种虚拟网卡在逻辑上，和物理网卡具有对等的地位。

父接口可以是一个物理接口（例如eth0），可以是一个 802.1q 的子接口（例如eth0.10），也可以是 bonding 接口。

除了虚拟化之外，Keepalived也通过MacVLAN来使用虚拟Mac地址。

需要注意，使用MacVLAN的虚拟机/容器，和主机共享一个网段。如果虚拟机/容器需要和宿主机通信，需要额外创建一个子接口给宿主机使用

MacVLAN支持5种模式：

# 创建MacVLAN子接口，父接口为eth0，MAC地址默认自动分配，如需指定，可以 address 00:00:00:00:00:09
ip link add link eth0 name macv1 type macvlan mode bridge
ip link add link eth0 name macv2 type macvlan mode bridge

# if link可以看到新创建的两个子接口
5: macv1@eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1
    link/ether a6:6d:2c:6e:33:bf brd ff:ff:ff:ff:ff:ff
6: macv2@eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1
    link/ether 12:c9:36:fe:f8:6c brd ff:ff:ff:ff:ff:ff

# 移动到命名空间中
ip netns add net1
ip netns add net2
ip link set macv1 netns net1
ip link set macv2 netns net2

# 查看命名空间中的接口状态
ip netns exec net1 ip link
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
# 类似于VETH对的一端，移动到命名空间后，使用@if2指明父接口在宿主机网络命名空间的序号
5: macv1@if2: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1
    link/ether a6:6d:2c:6e:33:bf brd ff:ff:ff:ff:ff:ff link-netnsid 0

# 配置IP地址
ip netns exec net1 ip addr add dev macv1 10.0.0.200/16
ip netns exec net2 ip addr add dev macv2 10.0.0.201/16
ip netns exec net1 ip link set dev macv1 up
ip netns exec net2 ip link set dev macv2 up

# 通信
ip netns exec net1 ping 10.0.0.1    # OK
ip netns exec net1 ping 10.0.0.201  # OK
ip netns exec net1 ping 10.0.0.200  # 失败
ip net exec net1 ip link set lo up  # 原因是命名空间中lo默认DOWN，导致不能PING自己

# 对于网桥br0的端口eth0，从此端口收到的包，允许（可能经过某种处理后）从此端口再发回去
brctl hairpin br0 eth0 on
# or
ip link set dev eth0 hairpin on

位于两台机器上的MacVLAN虚拟网卡要实现通信，需要满足：

1. 两台机器的父接口都处于混杂模式
2. 两台主机的MacVLAN子网IP段不重叠

在MacVLAN的虚拟网络中，父接口仅仅相当于一个交换机。对于进出子MacVLAN接口的数据包，物理网卡仅仅转发而不处理，这导致使用本机MacVLAN网卡的IP无法和物理网卡的IP进行通信。

MacVLAN是将虚拟机、容器连接到物理网络的简单方法。但是它有以下缺点：

1. 每个虚拟接口都需要MAC地址，但是物理交换器支持的MAC地址数量会有限制，许多物理网卡支持的MAC地址数量也会有限制
2. IEEE 802.11（WiFi）不支持一个客户端有多个MAC地址
3. 在云上环境，VPC往往对入站报文的MAC地址进行校验，Linux Bridge面临同样的问题

面临这些缺点时，可以考虑使用IPVLAN。

类似于MacVLAN，都是在一个父接口下虚拟出多个子接口。不同之处是，IPVLAN的所有子接口MAC相同，仅仅IP不同。

IPVLAN从3.19开始支持，比较稳定的版本需要4.2+。Docker对老版本的支持存在缺陷。

某些DHCP服务器在分配IP地址时，以MAC地址作为机器的标识，这和IPVLAN无法协同工作。

IPVLAN支持L2、L3等模式，一个父接口同时只能在一种模式下工作。

IPVLAN无法从宿主机访问子接口的IP地址，也不能从子接口所在命名空间访问父接口的IP地址。你可以额外创建一对veth，配合路由，来解决这个问题。

这种模式下，和MacVLAN工作方式很类似。父接口作为交换机，转发子接口的数据。子接口直接加入父接口所在的二层网络。

实验：

ip link add link eth0 ipvlan1 type ipvlan mode l2
ip link add link eth0 ipvlan2 type ipvlan mode l2

ip net add net1
ip net add net2

ip link set ipvlan1 netns net1
ip link set ipvlan2 netns net2

ip net exec net1 ip link set ipvlan1 up
ip net exec net2 ip link set ipvlan2 up

ip net exec net1 ip addr add 10.0.10.1/16 dev ipvlan1
ip net exec net2 ip addr add 10.0.10.2/16 dev ipvlan2

ip net exec net1 route add default dev ipvlan1
ip net exec net2 route add default dev ipvlan2

ip net exec net1 ip link set ipvlan1 up
ip net exec net2 ip link set ipvlan2 up

ip net exec net1 ip link set lo up
ip net exec net2 ip link set lo up

这种模式下， 父接口类似于路由器。它在各个虚拟网络和主机网络之间进行不同网络报文的路由转发工作。 只要父接口相同，即使虚拟机/容器不在同一个网络，也可以互相ping通对方，因为ipvlan会在中间做报文的转发工作。 L3模式下的虚拟接口不会接收到多播或者广播的报文，所有的 ARP 过程或者其他多播报文都是在底层的父接口完成的。

外部网络不会理解IPVLAN虚拟出来的网络，因此如果外部路由器上不配置适当路由规则，IPVLAN的虚拟IP无法被外部访问。 

实验：

ip netns add net1
ip netns add net2

# 添加L3模式的IPVLAN子接口
ip link add link eth0 ipvlan1 type ipvlan mode l3
ip link add link eth0 ipvlan2 type ipvlan mode l3

# 可以发现子接口的MAC地址和父接口相同
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP mode DEFAULT group default qlen 1000
    link/ether 10:00:00:00:00:07 brd ff:ff:ff:ff:ff:ff
5: ipvlan1@eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 10:00:00:00:00:07 brd ff:ff:ff:ff:ff:ff
6: ipvlan2@eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/ether 10:00:00:00:00:07 brd ff:ff:ff:ff:ff:ff

# 移动到网络命名空间
ip link set ipvlan1 netns net1
ip link set ipvlan2 netns net2

注意，由于父子接口的MAC地址一样，因此不能通过DHCP分配IP地址，必须手工添加：

ip net exec net1 ip addr add 10.98.0.1/16 dev ipvlan1
ip net exec net1 ip link set dev ipvlan1 up
ip net exec net2 ip addr add 10.99.0.1/16 dev ipvlan2
ip net exec net2 ip link set dev ipvlan2 up

# 添加路由
ip net exec net1 route add default dev ipvlan1
ip net exec net2 route add default dev ipvlan2

ip net exec net1 ping 10.99.0.1  # OK

# 在宿主机的L2网络的其它主机上，必须有路由才能访问IPVLAN子接口
#                                        IPVLAN父接口IP
ip route add 10.98.0.0/16 dev virbr0 via 10.0.0.7
ip route add 10.99.0.0/16 dev virbr0 via 10.0.0.7

类似于L3模式，但是L3S模式下出入流量均经过宿主机网络命名空间的三层网络（L2/L3模式则不经过），会被宿主机的netfilter框架过滤。

这意味着L3S可以支持kube-proxy，但是，它又会引入以下问题：

1. 当K8S服务的客户端、Pod位于同一节点时，访问服务的应答报文会走ipvlan datapath，接收不到
2. 同样场景下，同一方向流量多次进出宿主机 conntrack，datapath复杂，和iptables/ipvs也存在兼容性问题

可以为容器额外引入VETH（另外一端放在宿主机），通过路由设置，让K8S服务的流量从VETH出站，解决Service无法访问的问题。

Macvtap是一个新式驱动，用于简化虚拟化网络桥接。它基于macvlan设备驱动，将macvlan和TAP的优点进行整合。它使用macvlan的方式来收发数据包，但是收到的数据包不会交给独立网络栈处理，而是交给/dev/tapX文件：

由于 macvlan是工作在 MAC 层的，所以 macvtap 也只能工作在 MAC 层，不会存在macvtun这样的设备。

一个macvtap端点（endpoint）是一个字符设备，它很大程度上遵循tun/tap ioctl接口，可以被KVM/QEMU或者其它支持tun/tap接口的hypervisors直接使用。macvtap端点扩展一个既有网络接口（底层设备，lower device），具有自己的MAC地址，位于与被扩展接口相同的网段。典型情况下，macvtap让宿主机、客户机一同出现在物理网络上。

类似于macvlan，一个macvtap可以工作在以下三种模式之一。这些模式定义了连接到同一lower device的macvtap端点之间的通信方式：

亦称替代物（surrogate)，这类代理可以假扮Web服务器，接收发给 Web 服务器的真实请求，它可以向一个或者多个服务器索取内容，并返回给客户端，在客户端看来，好像反向代理就是真正的服务器。 反向代理有以下应用场景：

1. 反向代理可以缓存静态、动态内容，从而提高访问慢速Web服务器上公共内容时的性能，在此场景下反向代理被称为服务器加速器（Server accelerator）
2. 隐藏原始服务器的存在和特性
3. 为不支持SSL的服务器提供SSL支持
4. 负载均衡：分散入站请求到多个服务器上
5. 任何几个Web服务器需要通过同一IP地址访问的时候，可以将反向代理作为前置机

所谓透明代理，它透明在：

1. 对于客户端，发起连接时连接的服务端是真实的服务器而不是代理服务器
2. 对于服务器，收到的请求来自真实客户端而不是代理服务器

必须具有某种机制，在客户端毫无知觉的情况下，将它的请求劫持给代理服务器处理。同样的，真实服务器发回的响应也需要直接发给代理服务器，而不是客户端。

实现透明代理，需要多方面的配合。客户端（C）、代理（P）、服务器（S）的部署架构会很大程度上影响技术实现。主要关注点包括：

1. 网络路由：目的地是S的IP包路由给P处理。如果S和P部署在一起（例如用于Sidecar部署的Envoy），通过Linux本身的能力就能达成
2. IP_TRANSPARENT：P必须启用此套接字选项

当封包到达Linux内核时，它要么被路由，要么被丢弃，要么被Linux本地处理 —— 如果目的地址匹配本地地址的话。

什么是本地地址，是可以设置的，甚至你可以设置为0.0.0.0/0 —— 任何地址都是本地地址，但这样设置会导致系统无法连接到任何远程地址，因为所有地址都是本地地址了…应当发给本地进程处理。幸运的是，通过独立路由表，我们可以选择性的将一部分封包路由到本地：

# 对于任何目的端口是53的封包，设置标记
iptables -t mangle -I PREROUTING -p udp --dport 5301 -j MARK --set-mark 1

# 然后配置路由表，强制将其从lo网卡发出，而不管目的地址是什么
ip rule add fwmark 1 lookup 100
ip route add local 0.0.0.0/0 dev lo table 100 

注意，需要启用IP转发功能：

sysctl net.ipv4.conf.all.forwarding=1
sysctl net.ipv6.conf.all.forwarding=1

某些情况下反向路径过滤器（reverse path filter）可能会丢弃你拦截的封包，禁用之：

sysctl net.ipv4.conf.eth0.rp_filter=0

套接字选项IP_TRANSPARENT可以绑定不属于本机的IP地址，P需要启用此选项。此选项的作用：

1. 作为S的客户端时，此选项允许P使用不属于本机的IP地址作为源IP（也就是C的地址）发起连接
2. 作为C的服务器时，可以侦听（绑定到）不属于本机的IP地址（也就是S的地址）的连接请求。比如开启此IP_TRANSPARENT选项同时监听0.0.0.0.80，那么本机接收到的DST地址是192.168.0.189:80的TCP请求可被监听
3. 接受被TPROXY重定向的连接和封包

下面是一段基于simplesocket的代码，说明了IP_TRANSPARENT如何指定任意源地址的。注意需要CAP_NET_ADMIN权限才能运行：

# 基于TCP/IP协议族的UDP套接字 
Socket s(AF_INET, SOCK_DGRAM, 0);
# 套接字选项，IP_TRANSPARENT
SSetsockopt(s, IPPROTO_IP, IP_TRANSPARENT, 1);
# 使用的源地址
ComboAddress local("1.2.3.4", 5300);
# 使用的目的地址
ComboAddress remote("198.41.0.4", 53);
# 绑定到源地址，注意此地址不是本机地址 
SBind(s, local);
# 发送UDP包
SSendto(s, "hi!", remote);

使用tcpdump可以发现：

# tcpdump -n host 1.2.3.4
# 源地址不是本机
21:29:41.005856 IP 1.2.3.4.5300 > 198.41.0.4.53

Iptables支持一个特殊的目标TPROXY，它能够拦截流量，并将其转发给任意特定的本地IP地址，同时为封包设置标记：

# 修改针对25端口的TCP流量封包
iptables -t mangle -A PREROUTING -p tcp --dport 25 -j TPROXY
  # 设置0x1/0x1标记
  --tproxy-mark 0x1/0x1 
  # 转发给127.0.0.1:10025，但是不改变IP封包头的任何信息
  --on-port 10025      # 默认原始目的端口
  --on-ip 127.0.0.1    # 默认接收到流量的网卡地址

注意：

1. --tproxy-mark，它确保此封包通过正确的路由表发出。参考第一小节的路由，此封包  xxx:xxx:127.0.0.1:10025，将从lo网卡出网络栈
2. TPROXY和REDIRECT不同，后者本质上是DNAT，会改变IP封包头的目的地址

Iptables匹配扩展socket能够匹配和本地套接字相关的封包，它会进行Socket Hash查找，并且在以下条件下匹配：

1. 本地存在已经建立的套接字，匹配此封包
2. 如果本地存在非零监听套接字，并且地址端口匹配封包的地址端口

示例：

iptables -t mangle -A PREROUTING -p tcp -m socket -j DIVERT

iptables -t mangle -N DIVERT
iptables -t mangle -A DIVERT -j MARK --set-mark 1
iptables -t mangle -A DIVERT -j ACCEPT

# 配合路由表

使用IP_TRANSPARENT时：

1. 对于TCP连接，套接字的原始目的地址、端口可以通过getsockname()调用获得
2. 对于UDP连接，你必须设置套接字选项IP_RECVORIGDSTADDR：
   

   setsockopt (s, IPPROTO_IP, IP_RECVORIGDSTADDR, &n, sizeof(int));

   然后，调用recvmsg()方法：

   char orig_ip[32] = {0};
   int orig_port = 0;
   struct sockaddr_in *orig_addr;
   for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg,cmsg)) {
       if (cmsg->cmsg_level == SOL_IP && cmsg->cmsg_type == IP_ORIGDSTADDR) {
           orig_addr = (struct sockaddr_in *) CMSG_DATA(cmsg);
           transfer_sock_addr(orig_addr, orig_ip, 32, &orig_port);
           break;
       }
   }
   if (cmsg == NULL) {
       printf("IP_ORIGDSTADDR not enabled or small buffer or I/O error");
       return;
   } 

参考Istio学习笔记。

1. 需要通过Iptables来对封包进行标记。时用TPROXY目标可以在标记的同时，转发给指定IP:PORT，但却又不改包头
2. 需要为被标记的封包设置路由表，不管其目的地址是什么（0.0.0.0/0），总是发送到lo接口
3. lo接口接收到的封包，再次进入Iptables，这次不会走PREROUTING链
4. 对于TPROXY，已经明确指定了接收者进程的IP:PORT，直接由此进程处理封包，前提是IP_TRANSPARENT被设置好
5. SocketMatch的作用是识别本地相关的套接字并标记，它不是必须的，TPROXY也能够做标记工作

Loopback本来是通信学上的术语，和电信号、数字数据包的路由有关，将它们不做修改的路由给信号的发起者，主要用于测试通信基础设施。

在TCP/IP协议族的规范实现中，包含一个虚拟的网络接口，同一机器上的程序可以通过此虚拟接口进行网络通信，此接口完全是软件的，不会引起任何物理网卡的流量。程序发往lo接口的封包会简单的、立即发回网络栈，就好像是从网络上收到的一样。

如果路由将出口网卡设置为lo（不管目的地址是什么），则报文交由本地的应用程序处理，而不会真正路由出去。

在Linux中，dummy类型的网络接口类似于lo，区别在于，你可以创建多个dummy类型的网络接口。

此外，对于lo接口，内核会自动添加目的地址是CIDR的路由：

local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1

 而对于dummy接口则仅仅会添加针对其IP地址的路由。

Socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口，类似于TCP和UDP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。

UNIX Domain Socket是全双工的，API接口语义丰富，相比其它IPC机制有明显的优越性，目前已成为使用最广泛的IPC机制，比如X Window服务器和GUI程序之间就是通过UNIX Domain Socket通讯的。

使用UNIX Domain Socket的过程和网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address family指定为AF_UNIX，type可以选择SOCK_DGRAM或SOCK_STREAM，protocol参数仍然指定为0即可。

UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示：

struct sockaddr_un {
    sa_family_t     sun_family;             /*PF_UNIX或AF_UNIX */
    char    sun_path[UNIX_PATH_MAX];        /* 路径名 */
}; 

网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。

所谓抽象套接字命名空间（Abstract Socket Namespace）是Linux的特性，用于创建一个不去绑定到文件系统中文件的UDS，从而获得以下好处：

1. 不需要担心文件系统中的命名冲突
2. 当完成套接字使用后，不需要关注unlink文件路径名的问题 —— 到套接字关闭后，抽象名称会自动删除
3. 不需要在文件系统中创建对应路径，在chroot环境下可能有用，在没有缺陷操控特定文件系统路径时也有用

要创建抽象UDS套接字，需要指定sub_path的第一个字节为\0字符。在netstat lsof等命令的输出中，\0显示为@符号

现代以太网依赖于交换机进行帧的交换。它通常是具有多个端口的硬件盒子。如果目的地址对于交换机未知（它不知道关联到哪个端口），那么交换机会广播帧给所有端口。通过观察端口上的帧流量，交换机就能学习到端口-MAC对应关系，从而不再需要广播流量。交换机在FIB（forwarding information base，也叫forwarding table）中缓存对应关系。

交换机可以相互连接，从而构成更大的以太网。

Linux支持loopback设备，用于通过网络栈和主机自身进行通信。Linux能够和任何配置在本地网络接口上的IP进行通信，不管地址是不是在loopback设备上。

所有配置在本机网络接口的地址，即本地地址（Locally Hosted Addresses）。

这类地址来自和本机位于同一网段内的其它主机。这些主机通过交换机相互连接，地址本地可达（Locally Reachable Addresses）

所有其它地址，都必须依赖路由器（IP Routing Device）作为中介才能到达，并且，此路由器具有本地可达地址。

当封包从一个网络（经过路由器）到达另外一个网络，称为经过了一跳。跳的数量，即封包经过的中介路由器的数量。

对于一个路由路径，封包要经过的下一个网关（路由器），即下一跳。

任何在两个网络之间接受/转发封包的设备，都是路由器。路由器至少是dual-homed的 —— 每个接口接入到一个网络，网络接口通常是NIC。Linux主机经常扮演路由器的角色，NIC经常是VLAN接口之类的虚拟设备。

默认路由，即目的地是0/0的路由，是最一般的路由——如果找不到和封包目的地更匹配的路由，则自动使用默认路由。

对于连接到因特网的主机来说，默认路由通常是本地可达的路由器，此路由器也叫默认网关。

路由选择的基本原则是逐跳（hop-by-hop）进行，典型情况下以目的地址为选路的唯一标准。Linux作为路由器时，可能基于其它的封包特征进行选路，此所谓策略路由。

基于目的地址选路时，首先会查询路由缓存，然后查找主路由表。如果最近发送封包到了目的地址，则关于目的地址的路由会存在于缓存（本质上是一个hash表）中。如果最近没有发送封包到目的地，则需要查询路由表，匹配的原则是最长前缀匹配（longest prefix match） —— 也就是尽量选择精确的路由。最长前缀匹配能够针对大规模网络的路由规则，被更加精确的路由器（通常更靠近）或主机覆盖。

从2.2开始，Linux支持基于多路由表（multiple routing tables）和路由策略数据库（routing policy database，RPDB）的策略路由。

策略路由的依据，是封包的某些属性，例如源地址、ToS标记、fwmark（仅在内核中存在的、位于表示封包的数据结构中的字段）、接收封包接口名，等等。

启用策略路由的情况下，选路算法如下：

1. 首先，仍然是查询路由缓存
2. 基于优先级，来遍历RPDB。查找匹配的RPDB
3. 对于每个匹配RPDB条目，使用最长前缀原则匹配封包目的地址，遍历条目对应的路由表
4. 如果找到匹配路由，则终止迭代

伪代码：

# 首先查找路由缓存
if packet.routeCacheLookupKey in routeCache :
    route = routeCache[ packet.routeCacheLookupKey ]
else
    # 然后按优先级遍历RPDB，此数据库中是一条条规则
    for rule in rpdb :
        # 如果封包匹配RPDB规则
        if packet.rpdbLookupKey in rule :
            # 则遍历RPDB规则对应的路由表
            routeTable = rule[ lookupTable ]
            # 根据最长前缀原则来匹配路由表中的路由
            if packet.routeLookupKey in routeTable :
                route = route_table[ packet.routeLookup_key ]

使用策略路由时，单个路由表的使用逻辑保持不变。

路由缓存，又叫转发信息库（forwarding information base，FIB）。它是一个存放了最近使用的路由条目的哈希表，在查询路由表之前，会优先检查FIB。

FIB由内核独立于路由表维护，修改路由表可能不会立即反应到FIB，要避免此延迟，可以调用：

ip route flush cache

FIB清空后，新的封包，或者

ip route get

FIB提供基于多种方式的哈希查找，包括：dst（目的地址）、src（源地址）、tos（服务类型）、fwmark（内核封包标记）、iif（入站网络接口）。

FIB的缓存条目上，存储了以下属性：cwnd、advmss（建议最大段大小）、src（Preferred Local源地址）、mtu、rtt、age、users、used。

Linux 2.2 / 2.4支持多路由表，除了广泛使用的local / main表外，内核最多支持额外的252张路由表。联合多个路由表（主要基于目的地址）和RPDB（主要基于源地址），Linux内核实现了灵活的路由功能。

支持多重路由表的内核，使用0-255之间的整数来引用路由表。最基本的路由表是local（255）、main（252），路由表序号和名字的映射关系定义在

/etc/iproute2/rt_tables

下面的命令显示所有路由表的路由：

ip route show table all

下面的命令显示特定路由表中的路由：

ip route show table main
ip route show table 2005

这是一张由内核维护的特殊表，条目可以删除，但是需要注意风险。ip address和ifconfig命令会导致内核修改local表（通常也同时修改main表）。

local表的主要用途有两个：

1. 指定广播地址的规格，仅仅对于支持广播寻址的L2有用
2. 用于路由到本机IP地址

local表中可以出现的路由类型包括：local、nat、broadcast。这些路由类型不会出现在其它表，其它路由类型不会出现在local表。

如果某个网络接口具有多个IP地址，则每个IP地址都在local表中具有一个路由条目。这是在Linux下为网络接口添加IP地址的正常附加效果。

命令route操控的是该表，如果ip route不指定目标表，则默认操作main表。

路由表可以包含任意多个（除了local表，它由内核维护）条目。

条目的形式为：

ip route { add | del | change | append | replace } ROUTE

ROUTE := NODE_SPEC [ INFO_SPEC ]
  #            路由类型  匹配CIDR           路由表              路由协议           范围
  NODE_SPEC := [ TYPE ] PREFIX [ tos TOS ] [ table TABLE_ID ] [ proto RTPROTO ] [ scope SCOPE ] [ metric METRIC ]
    TYPE := [ unicast | local | broadcast | multicast | throw | unreachable | prohibit | blackhole | nat ]
    TABLE_ID := [ local| main | default | all | NUMBER ]
    RTPROTO := [ kernel | boot | static | NUMBER ]
    SCOPE := [ host | link | global | NUMBER ]

  INFO_SPEC := NH OPTIONS FLAGS [ nexthop NH ] ...
    #                     下一跳路由器地址             出口网卡名称    权重，在multipath路由中反应此路由的相对带宽或质量 
    NH := [ encap ENCAP ] [ via [ FAMILY ] ADDRESS ] [ dev STRING ] [ weight NUMBER ] NHFLAGS
      FAMILY := [ inet | inet6 | ipx | dnet | mpls | bridge | link ]
      NHFLAGS := [ onlink | pervasive ]
    OPTIONS := FLAGS [ mtu NUMBER ] [ advmss NUMBER ] [ as [ to ] ADDRESS ] rtt TIME ] [ rttvar TIME ] 
                     [ reordering NUMBER ] [ window NUMBER ] [ cwnd NUMBER ] [ ssthresh REALM ] [ realms REALM ] 
                     [ rto_min TIME ] [ initcwnd NUMBER ] [ initrwnd NUMBER ] [ features FEATURES ] [ quickack BOOL ] 
                     [ congctl NAME ] [ pref PREF ] [ expires TIME ]

路由类型可以分为一下几种：

ip route add unicast 192.168.0.0/24 via 192.168.100.5
ip route add default via 193.7.255.1
ip route add unicast default via 206.59.29.193
ip route add 10.40.0.0/16 via 10.72.75.254

ip route add table local broadcast 10.10.20.255 dev eth0 proto kernel scope link src 10.10.20.67 

ip route add 
  # 添加到local表    路由类型为local
  table local       local 
  # PREFIX，不带 / 为单一地址
  10.96.0.1 
  # 出口设备名称
  dev kube-ipvs0 
  # 内核自动添加的条目
  proto kernel 
  # 主机范围
  scope host 
  # 优先使用的源地址
  src 10.96.0.1

ip route add nat 193.7.255.184 via 172.16.82.184
ip route add nat 10.40.0.0/16 via 172.40.0.0

ip route add unreachable 192.168.14.0/26 

ip route add blackhole 64.65.64.0/18 

ip route add throw 10.79.0.0/16

所谓route scope，是一个“指示符”，用来说明到目标网络的“距离”。 

必须是定义在  /etc/iproute2/rt_scopes 中的名字或数字

RPDB控制内核遍历多张路由表的顺序。RPDB中的每个条目，具有一个优先级，优先级是0-32767之间的数字，越小优先级越高。下面是一个示例的路由策略：

ip rule list
9:      from all fwmark 0x200/0xf00 lookup 2004 
10:     from all fwmark 0xa00/0xf00 lookup 2005 
100:    from all lookup local 
32766:  from all lookup main 
32767:  from all lookup default

当封包达到后，假设没有路由缓存，内核会首先检查优先级为0的RPDB规则，如果匹配，则使用该规则指向的路由表，如果不匹配，则依次检查低优先级的规则。

RPDB中的规则类型有若干种，和路由类型对应：

# unicast 这是最常见的规则类型，也是默认的规则类型。会导致查找某个路由表
# 如果源地址是192.168.100.17则查找表5
ip rule add unicast from 192.168.100.17 table 5
# 如果源接口是eth7则查找表5
ip rule add unicast iif eth7 table 5
# 如果封包具有标记4则查找4
ip rule add unicast fwmark 4 table 4


# nat 用于正确实现无状态NAT，通常和nat类型的路由条目耦合在一起。这种条目
# 会导致内核重写出站封包的源地址
#  对于源地址是172.16.82.184的封包，将源地址改写为193.7.255.184
ip rule add nat 193.7.255.184 from 172.16.82.184
ip rule add nat 10.40.0.0 from 172.40.0.0/16


# unreachable 如果匹配，则立即应答 ICMP unreachable 给源地址
# 如果是来自eth2的、服务类型0xc0的封包
ip rule add unreachable iif eth2 tos 0xc0
ip rule add unreachable iif wan0 fwmark 5
ip rule add unreachable from 192.168.7.0/25


# prohibit 如果匹配，则立即应答 ICMP prohibit 给源地址
ip rule add prohibit from 209.10.26.51
ip rule add prohibit to 64.65.64.0/18
ip rule add prohibit fwmark 7


# blackhole 如果匹配，封包被静默的丢弃
ip rule add blackhole from 209.10.26.51
ip rule add blackhole from 172.19.40.0/24
ip rule add blackhole to 10.182.17.64/28

对于具有多重IP地址的主机来说，进行相互通信时必须选择正确的源IP地址。

出站封包的源地址选择的原则如下：

1. 如果应用程序已经在使用套接字，则源地址已经被选择过
2. 应用程序可以显式请求一个源地址，这个地址甚至可以不是本机地址。很多应用程序支持选取源地址，例如：
   

   nc -s $BINDADDR $DEST $PORT
   socat - TCP4:$REMOTEHOST:$REMOTEPORT,bind=$BINDADDR 

3. 内核进行选路操作，如果匹配路由存在src参数，则内核会利用该参数作为源地址
4. 如果没有src提示，则内核会根据目的地址，找到本机上第一个配置了与该地址在同一个网段、或者与该目的地址的路由下一跳地址在同一网段的IP地址的网络接口，并用此网络接口的IP地址作为源地址

Path MTU即（Path Maximum Transmission Unit），ICMP报文可以用于发现PMTU，它是整个路由路径中，最小的MTU。知道这个值以后，可以避免不必要的IP分片。

路由中任何一跳阻止ICMP报文，都会导致无法识别PMTU。

ICMP重定向是路由器提示发送者，具有更好路由路径的一种机制。配置静态路由可以防止不期望的ICMP重定向，尽管ICMP重定向不会导致危险，但是在良好管理的网络中是不应当发生的。

ECMP是一个逐跳的基于流的负载均衡策略，当路由器发现同一目的地址出现多个最优路径时，会更新路由表，为此目的地址添加多条规则，对应于多个下一跳。ECMP的路径选择策略有多种方法：

1. 哈希，例如根据源IP地址的哈希为流选择路径
2. 轮询，各个流在多条路径之间轮询传输
3. 基于路径权重，根据路径的权重分配流，权重大的路径分配的流数量更多

OSPF、ISIS、EIGRP、BGP等多种路由协议均支持ECMP。

ECMP是一种较为简单的负载均衡策略，其在实际使用中面临的问题也不容忽视：

1. 可能增加链路的拥塞：ECMP并没有拥塞感知的机制，只是将流分散到不同的路径上转发。对于已经产生拥塞的路径来说，很可能加剧路径的拥塞
2. 非对称网络使用效果不好

参考：重温iptables

参考基于tc的网络QoS管理

Offloading是Linux内核中一系列用于减轻CPU网络处理负担的技术。

随着技术的进步，网络接口的带宽越来越大。从早期的10Mbps发展到现在的10Gbps+，带宽增加了3个数量级。与此同时，网络中能够传递的单个封包的大小，受限于路径MTU。在简单的局域网环境下，可以使用Jumbo Frame将MTU提升到9KB，但是在复杂的因特网环境下，MTU一直都只能是1500左右。作为后果，带宽打满的情况下CPU单位时间需要处理的封包个数比早期多了3个数量级。现代处理器在处理1Gbps网络接口时，通常能够应对，不需要考虑Offloading。

尽管这些年CPU的性能也有很大的提升，包括频率升高和核心数增加，但是减少需要处理的封包数量对于提升性能仍然是很有价值的。每个封包都需要经过网络栈，处理过程相当复杂。

TCP Segmentation Offload，允许内核发送一个很大的封包，例如64KB，然后由（支持TSO的）网络适配器将封包分割为合适大小的TCP段传输。

TSO能够平均减少发送单个封包的开销达40倍，对于以发送为主的工作负载，例如下载服务器，足以让10Gbps网络全速工作。

Generic Segmentation Offload，更加一般的segmentation offloading机制，可以用于UDP协议。

即使在驱动层模拟GSO，也能提升性能。

在接收端进行Offloading的技术出现较晚，一方面早期的网络流量均是下行为主，另一方面接收端的处理难度要大的多。你无法控制什么时候接收封包，这是由对端控制的。

Large Receive Offload类似于GSO，它允许网络接口将接收到的封包进行合并，让操作系统看到的封包变少。即使在驱动层模拟LRO，也能提升性能。LRO被Linux中10Gbps网卡驱动广泛的支持。LRO仅仅支持TCP/IPv4。

LRO存在缺陷，它只是简单的将看到的封包都合并起来，如果包头中有差异这些差异会丢失。这些信息的丢失会导致问题：

1. 如果Linux主机作为路由器运行，那么它任何时候都不应该改变包头中的信息
2. 某些基于卫星网络的连接，依赖于特殊的头才能正常运作
3. Linux网桥无法工作，导致很多虚拟化场景无法使用LRO

Generic Receive Offload，解决了LRO的缺陷。GRO严格限制了封包合并的条件：

1. MAC地址必须相同
2. 仅允许很少一部分的TCP或IP头不同

这些限制让合并后的封包能够被无损的重新分段。GRO code可以用于重新分段。

GRO不限制于TCP协议。

The post Linux网络知识集锦 appeared first on 绿色记忆.