curl 各阶段耗时

Jun 11, 2022

curl -X GET -w “\ntime_namelookup:%{time_namelookup}\ntime_connect: %{time_connect}\ntime_starttransfer: %{time_starttransfer}\ntime_total: %{time_total}\n” xxxx

阅读全文

指针的最后三位永远是0

May 27, 2022

深入理解nginx中，第9章中有一句：利用指针的最后一位一定是0的特性。能解释一下这个特性？

阅读全文

非阻塞套接字

May 26, 2022

在阻塞和非阻塞两种模式下执行I/O操作。在阻塞模式下，在I/O操作完成前，执行的操作函数一直等候而不会立即返回，该函数所在的线程会阻塞在这里。相反，在非阻塞模式下，套接字函数会立即返回，而不管I/O是否完成，该函数所在的线程会继续运行。

阅读全文

vimmap

Apr 9, 2022

在vim配置文件中经常会看到map、nmap、imap、vmap、vnoremap、nunmap、nmapclear等，都是什么意思呢？

阅读全文

process

Apr 4, 2022

http://www.howtoip.com/how-to-use-the-mac-terminals-hidden-task-manager-to-see-background-processes/

vi /etc/ld.so.preload

删除相关内容 [root@redis02 ~]# echo $LD_PRELOAD 结果为空清理完成后，top已经可以看到之前隐藏进程

阅读全文

nsenter

Mar 26, 2022

nsenter也可以进入mnt, uts, ipc, pid, user命令空间，以及指定根目录和工作目录。

阅读全文

ifconfig

$ apt-get install net-tools

ip

$ apt-get install iproute2

ping

$ apt-get install iputils-ping

阅读全文

completion bash自动补全

Mar 26, 2022

要让可编程命令补全功能在你的终端起作用，你只需要如下执行/etc/bash_completion即可：

阅读全文

Bus error 10

May 30, 2020

Bus error: 10 ulimit -c ulimited

Bus error: 10 (core dumped)

$lldb /cores/core.14533 (lldb) target create “/cores/core.14533” warning: (x86_64) /cores/core.14533 load command 108 LC_SEGMENT_64 has a fileoff + filesize (0x28a0e000) that extends beyond the end of the file (0x28a0d000), the segment will be truncated to match warning: (x86_64) /cores/core.14533 load command 109 LC_SEGMENT_64 has a fileoff (0x28a0e000) that extends beyond the end of the file (0x28a0d000), ignoring this section Current executable set to ‘/cores/core.14533’ (x86_64). (lldb) bt error: invalid process https://stackoverflow.com/questions/212466/what-is-a-bus-error

阅读全文

make

May 29, 2020

config/configure/Configure、make 、make test/make check、sudo make install 的作用

阅读全文

文件句柄泄漏

May 29, 2020

问题出现的表象：

所有客户端都无法登陆服务器，正常游戏的玩家退出后重新登陆也失败.
查看日志，出现大量socket加入队列失败的情况。

什么是 IO 多路复用一句话解释：单线程或单进程同时监测若干个文件描述符是否可以执行 IO 操作的能力。
解决什么问题说在前头应用程序通常需要处理来自多条事件流中的事件，比如我现在用的电脑，需要同时处理键盘鼠标的输入、中断信号等等事件，再比如 web 服务器如 nginx，需要同时处理来来自 N 个客户端的事件。

阅读全文

abi

Feb 6, 2020

每个操作系统都会为运行在该系统下的应用程序提供应用程序二进制接口（Application Binary Interface，ABI）。ABI包含了应用程序在这个系统下运行时必须遵守的编程约定。ABI总是包含一系列的系统调用和使用这些系统调用的方法，以及关于程序可以使用的内存地址和使用机器寄存器的规定。从一个应用程序的角度看，ABI既是系统架构的一部分也是硬件体系结构的重点，因此只要违反二者之一的条件约束就会导致程序出现严重错误。在很多情况下，链接器为了遵守ABI的约定需要做一些重要的工作。例如，ABI要求每个应用程序包含一个程序中各例程使用的静态数据的所有地址表，链接器通过收集所有链接到程序中的模块的地址信息来创建地址表。ABI经常影响链接器的是对标准过程调用的定义 ABI（Application Binary Interface）：应用程序二进制接口，描述了应用程序和操作系统之间，一个应用和它的库之间，或者应用的组成部分之间的低接口。ABI涵盖了各种细节，如：数据类型的大小、布局和对齐；调用约定（控制着函数的参数如何传送以及如何接受返回值），例如，是所有的参数都通过栈传递，还是部分参数通过寄存器传递；哪个寄存器用于哪个函数参数；通过栈传递的第一个函数参数是最先push到栈上还是最后；系统调用的编码和一个应用如何向操作系统进行系统调用；以及在一个完整的操作系统ABI中，目标文件的二进制格式、程序库等等。与应用程序接口区别编辑应用程序接口（Application Programming Interface，API），又称为应用编程接口，就是软件系统不同组成部分衔接的约定。由于近年来软件的规模日益庞大，常常需要把复杂的系统划分成小的组成部分，编程接口的设计十分重要。程序设计的实践中，编程接口的设计首先要使软件系统的职责得到合理划分。良好的接口设计可以降低系统各部分的相互依赖，提高组成单元的内聚性，降低组成单元间的耦合程度，从而提高系统的维护性和扩展性。 ABI不同于API ，API定义了源代码和库之间的接口，因此同样的代码可以在支持这个API的任何系统中编译，然而ABI允许编译好的目标代码在使用兼容ABI的系统中无需改动就能运行。 ABI掩盖了各种细节，例如:调用约定控制着函数的参数如何传送以及如何接受返回值；系统调用的编码和一个应用如何向操作系统进行系统调用；以及在一个完整的操作系统ABI中，对象文件的二进制格式、程序库等等。一个完整的ABI，像 Intel二进制兼容标准 (iBCS) ，允许支持它的操作系统上的程序不经修改在其他支持此ABI的操作系统上运行。其他的 ABI 标准化细节包括C++ name decoration和同一个平台上的编译器之间的调用约定，但是不包括跨平台的兼容性。在Unix的操作系统中，存在很多运行在同一件平台上互相相关但是不兼容的操作系统（尤其是80386兼容系统）。有一些努力尝试标准化A I，以减少销售商将程序移植到其他系统时所需的工作。然而，还没有很成功的例子，虽然LSB正在为Linux做这方面的努力。它描述了应用程序与OS之间的底层接口。ABI涉及了程序的各个方面，比如：目标文件格式、数据类型、数据对齐、函数调用约定以及函数如何传递参数、如何返回值、系统调用号、如何实现系统调用等。一套完整的ABI（比如：Intel Binary Compatibility Standard (iBCS)），可以让程序在所有支持该ABI的系统上运行，而无需对程序进行修改。

ABI 解决什么问题

    参考文献：1） 《Unix网络编程》
    2）  http://book.51cto.com/art/200912/168560.htm

最近学习了使用Unix域套接字在进程间传递文件描述符，仿照参考资料，自己也写了简单的程序来实践这种技术。

其他不多说了，具体理论知识参见参考资料，开始我自己的程序介绍（在OpenSolaris 2009.06平台上测试）：

1 程序作用说明：父进程，子进程以及另外一个进程向同一个文件的文件描述符向这个文件中写内容。具体如下： 1）父进程指定要打开的文件名，打开权限，打开模式； 2）fork一个子进程； 3）子进程调用execl函数来执行程序openfile：该新程序取得指定文件的文件描述符；向指定文件中写入“openfileprog write test”；向父进程返回该文件描述符； 4）父进程收到该文件描述符后，向文件中写“paraent process write ppp”； 5）父进程作为server端建立域socket等待客户端进程连接； 6）客户端进程连接父进程； 7）父进程向该客户端进程返回从子进程得到的文件描述符； 8）客户端进程收到该文件描述符后使用它在文件中写“this is client process ccc”；

其中父子进程传递文件描述符通过建立的一对套接字管道，父进程和客户端进程传递文件描述符通过Unix域套接字。

2 具体代码说明：

1）首先看openfile程序，这时子进程通过调用execl执行的。调用方法如下： execl(“./openfileprog”, “openfileprog”, permit, mode, argsockfd, (char *)NULL); 其中参数1： openfile程序路径；参数2： openfile程序名；参数3：待打开文件的权限；参数4：待打开文件模式；参数5：父进程建立的一对套接字管道的其中之一；

作为openfile程序，主要按照execl传的参数，打开指定文件，取得文件描述符；向该文件中写入内容；然后调用func_send_fd函数通过argsockfd把取得的文件描述符传给父进程。该程序代码如下：

int main(int argc, char argv[]) / openfileprog / { int i, fd, ret; ssize_t size; size_t buflen; char data[10]; char buf[] = “openfileprog write test\n”; / 向文件中写入的内容 / / execl(“./openfileprog”, permit, mode, argsockfd, (char *)NULL); */ fd = -1; if((fd = open(“./file”, atoi(argv[1]), atoi(argv[2]))) < 0) { printf(“in openfileprog, open failed\n”); exit(-1); }

size = -1; buflen = sizeof(buf); if((size = write(fd, buf, buflen)) <= 0) { printf(“in openfileprog, write failed\n”); }

/* 把设定的data信息也传给父进程 */ ret = ‘a’; for(i = 0; i < sizeof(data); i++, ret++) { data[i] = ret; } data[sizeof(data) - 1] = ‘\0’;

ret = -1; if(0 > (ret = func_send_fd(atoi(argv[3]), fd, data, 10))) { printf(“in openfileprog, func_send_fd failed\n”); }

close(fd);

return 0; }

func_send_fd函数负责把取得的文件描述符传出去：

int func_send_fd(int send_sock, int send_fd, void *data, int bytes) { struct msghdr msghead; struct iovec passdata[1]; int ret;

/* 填充msghead结构 */ msghead.msg_accrights = (caddr_t)&send_fd; msghead.msg_accrightslen = sizeof(send_fd);

msghead.msg_name = NULL; msghead.msg_namelen = 0; passdata[0].iov_base = data; passdata[0].iov_len = bytes;

msghead.msg_iov = passdata; msghead.msg_iovlen = 1;

/* 发送信息 */ if(0 > (ret = sendmsg(send_sock, &msghead, 0))) { printf(“in func_send, send_fd is %d, sendsock is %d, sendmsg failed,errno is %d\n”, send_fd,send_sock,errno); return -1; }

return ret; }

在上述两个函数之前，加上以下必要头文件和宏：

#include #include #include #include #include #include #include #define SLEEPTIME 3 #define ARGLEN 20

以上作为一个c文件。

2）然后看父进程代码

下面是父进程程序：

int main(int argc, char *argv) { int status,sockfd[2]; char permit[ARGLEN]; char mode[ARGLEN]; char argsockfd[ARGLEN]; int recvfd; char data[20]; int bytes; int ret,i; ssize_t size; int buflen; pid_t pid,chldpid;

/* 以下几行是使用域套接字必要变量 */ int fdsock, fdaccept; struct sockaddr_un addr_server;
int len;
const char path[] = “/export/home/temp/test/other_prog/fengxianzhong”;

/* 以下是父进程写入文件的内容 */
char buf[] = “paraent process write ppp\n”;

/* 父进程同时向处理向client发送的数据 */ char datasend[] = “send by myopen\n”;

memset(permit, ‘\0’, sizeof(permit)); memset(mode, ‘\0’, sizeof(mode)); memset(argsockfd, ‘\0’, sizeof(argsockfd)); memset(data, ‘\0’, sizeof(data));

printf(“now it is parent process,now will fork a child process\n”); sleep(SLEEPTIME);

/* 设置文件权限和打开模式 */ snprintf(permit, sizeof(permit), “%d”,PERMIT); snprintf(mode, sizeof(mode), “%d”,MODE); // printf(“in myopen %s, %s\n”, permit, mode);

/* 建立和子进程通信的socket套接字管道 */ ret = socketpair(AF_UNIX,SOCK_STREAM,0,sockfd); if(0 > ret) { printf(“socketpair failed,errno is %d \n”,errno); }

/* fork 子进程 / if(0 == (chldpid = fork())) / child process */ { printf(“now it is child process, sendsock is %d\n”,sockfd[1]); close(sockfd[0]); snprintf(argsockfd, sizeof(argsockfd), “%d”, sockfd[1]);

/* 子进程中执行新程序openfile */ execl(“./openfileprog”, “openfileprog”, permit, mode, argsockfd, (char *)NULL); printf(“execl failed, perimit is %s, mode is %s\n”,permit, mode); exit(-1); }

/* paraent process start to write the file opened by child process */

printf(“now it is parent process\n”); close(sockfd[1]); bytes = sizeof(data);

/* 等待子进程结束 / pid = wait(&status); if((status = WEXITSTATUS(status)) == 0) / child process terminate */ { printf(“child %d process terminate,now parent will write file …\n”,pid); }

/* 从子进程取得文件描述符 / recvfd = -1; // printf(“recv sock is %d\n”, sockfd[0]); ret = func_recv_fd(sockfd[0], &recvfd, data, bytes); if(ret < 0) { printf(“paraent recv failed\n”); } / else { printf(“fd %d paraent recv %d bytes data is %s\n”, recvfd,strlen(data),data); } */

/* 向文件写入数据 */ size = -1; buflen = sizeof(buf);

if((size = write(recvfd, buf, buflen)) <= 0) { printf(“in openfileprog, write failed\n”); }

/* 父进程作为server建立域套接字，等待client连接 */ printf(“parent write over! Accept other process ……\n”);

fdsock = socket(AF_UNIX, SOCK_STREAM, 0); if(-1 == fdsock) { printf(“myopen creat socket error!errno is %d\n”, errno); }

unlink(path);

memset(&addr_server, 0, sizeof(addr_server)); addr_server.sun_family = AF_UNIX; strcpy(addr_server.sun_path, path); len = sizeof(struct sockaddr_un);

ret = bind(fdsock, (struct sockaddr*)&addr_server, len); if(-1 == ret) { printf(“in myopen bind error, errorno is %d\n”,errno); close(fdsock); unlink(path); }

ret = listen(fdsock,1); if(-1 == ret) { printf(“in myopen listen error, errorno is %d\n”,errno); close(fdsock); unlink(path); }

fdaccept = accept(fdsock, (struct sockaddr*)&addr_server, &len); if(-1 == ret) { printf(“in myopen accept error, errorno is %d\n”,errno); close(fdsock); unlink(path); }

/* 向已经连接的client传递该文件描述符 */ ret = func_send_fd(fdaccept, recvfd, datasend, sizeof(datasend)); if(0 > ret) { printf(“in myopen, func_send_fd failed\n”); }

printf(“send fd over! Will sleep 10s \n”);

sleep(10);

exit(0);

}

func_recv_fd函数负责从子进程接受文件描述符：

int func_recv_fd(int recv_sock, int *recvfd, void *data, int bytes) { struct msghdr msghead; struct iovec passdata[1]; int ret; int temp; int newfd;

struct cmsghdr *msgptr1;

struct cmsghdr *msgptr = NULL;

memset(&msghead, 0, sizeof(msghead));

/* 同func_send_fd ，填充所需要的结构 */ msghead.msg_accrights = (caddr_t)&newfd; msghead.msg_accrightslen = sizeof(recvfd);

msghead.msg_name = NULL; msghead.msg_namelen = 0; passdata[0].iov_base = data; passdata[0].iov_len = bytes;

msghead.msg_iov = passdata; msghead.msg_iovlen = 1;

/* 接收信息（文件描述符）*/ if(0 > (ret = recvmsg(recv_sock, &msghead, 0))) { printf(“in func_recv_fd, recvmsg failed\n”); return -1; }

if(msghead.msg_accrightslen == sizeof(recvfd)) { recvfd = newfd; / 文件描述符 */ }

return ret; }

其中父进程向client进程发送文件描述符也使用了func_send_fd函数，该函数在此c文件中重新写了一遍；其实没有必要这样重复。我们可以把它作为一个库来使用；不过这里暂且这样使用。函数代码参考上面所写的。

在这个c文件中还要加入以下头文件和宏定义：

Dec 12, 2019

网关即Gateway，它是连接基于不同通信协议的网络的设备，使文件可以在这些网络之间传输。网关除传输信息外，还将这些信息转化为接收网络所用协议认可的形式。它同路由器有密切关系。

阅读全文

ip netns

Dec 10, 2019

ip netns 命令用来管理 network namespace。它可以创建命名的 network namespace，然后通过名字来引用 network namespace，所以使用起来很方便。

阅读全文

netfilter iptables

Dec 10, 2019

https://www.netfilter.org/ https://arthurchiao.github.io/blog/deep-dive-into-iptables-and-netfilter-arch-zh/ https://www.digitalocean.com/community/tutorials/a-deep-dive-into-iptables-and-netfilter-architecture

https://arthurchiao.github.io/blog/nat-zh/

防火墙是保护服务器和基础设施安全的重要工具。在 Linux 生态系统中，iptables 是使 用很广泛的防火墙工具之一，它基于内核的包过滤框架（packet filtering framework） netfilter。如果管理员或用户不了解这些系统的架构，那可能就无法创建出可靠的防火 墙策略，一方面是因为 iptables 的语法颇有挑战性，另外一方面是 netfilter 框架内部 相互交织而变得错综复杂。

阅读全文

tcp

Dec 9, 2019

作者：灵剑链接：https://www.zhihu.com/question/51438786/answer/125920692 来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

阅读全文

resolv.conf

Dec 8, 2019

resolv.conf配置DNS客户，它包含了主机的域名搜索顺序和DNS服务器的地址，每一行应包含一个关键字和一个或多个的由空格隔开的参数。 cat /etc/resolv.conf

Nov 10, 2019

Oct 22, 2019

命令行界面 (CLI) = 使用文本命令进行交互的用户界面终端 (Terminal) = TTY = 文本输入/输出环境控制台 (Console) = 一种特殊的终端 Shell = 命令行解释器，执行用户输入的命令并返回结果

什么是命令行界面？命令行界面，通俗来讲，就是你看过的那种满屏幕都是字符的界面。
终端 —— 人与机器交互的接口 2.2. 控制台 (Console) 是什么？在历史上，终端是连接到计算机上的一种带输入输出功能的外设。但是有一个终端与众不同，它与计算机主机是一体的，是计算机的一个组成部分。这个特殊的终端就叫做控制台(Console)。

阅读全文

CentOS

Sep 21, 2019

CentOS（Community Enterprise Operating System，中文意思是社区企业操作系统）是Linux发行版之一，它是来自于Red Hat Enterprise Linux依照开放源代码规定释出的源代码所编译而成。由于出自同样的源代码，因此有些要求高度稳定性的服务器以CentOS替代商业版的Red Hat Enterprise Linux使用。两者的不同，在于CentOS完全开源。 CentOS 是RHEL（Red Hat Enterprise Linux）源代码再编译的产物，而且在RHEL的基础上修正了不少已知的 Bug ，相对于其他 Linux 发行版，其稳定性值得信赖。 CentOS在2014初，宣布加入Red Hat。 CentOS 加入红帽后不变的是：

CentOS 继续不收费
保持赞助内容驱动的网络中心不变
Bug、Issue 和紧急事件处理策略不变
Red Hat Enterprise Linux 和 CentOS 防火墙也依然存在

阅读全文

system call table

Sep 18, 2019

系统调用号函数名入口点源代码 0 read sys_read fs/read_write.c 1 write sys_write fs/read_write.c 2 open sys_open fs/open.c 3 close sys_close fs/open.c 4 stat sys_newstat fs/stat.c 5 fstat sys_newfstat fs/stat.c 6 lstat sys_newlstat fs/stat.c 7 poll sys_poll fs/select.c 8 lseek sys_lseek fs/read_write.c 9 mmap sys_mmap arch/x86/kernel/sys_x86_64.c 10 mprotect sys_mprotect mm/mprotect.c 11 munmap sys_munmap mm/mmap.c 12 brk sys_brk mm/mmap.c 13 rt_sigaction sys_rt_sigaction kernel/signal.c 14 rt_sigprocmask sys_rt_sigprocmask kernel/signal.c 15 rt_sigreturn stub_rt_sigreturn arch/x86/kernel/signal.c 16 ioctl sys_ioctl fs/ioctl.c 17 pread64 sys_pread64 fs/read_write.c 18 pwrite64 sys_pwrite64 fs/read_write.c 19 readv sys_readv fs/read_write.c 20 writev sys_writev fs/read_write.c 21 access sys_access fs/open.c 22 pipe sys_pipe fs/pipe.c 23 select sys_select fs/select.c 24 sched_yield sys_sched_yield kernel/sched/core.c 25 mremap sys_mremap mm/mmap.c 26 msync sys_msync mm/msync.c 27 mincore sys_mincore mm/mincore.c 28 madvise sys_madvise mm/madvise.c 29 shmget sys_shmget ipc/shm.c 30 shmat sys_shmat ipc/shm.c 31 shmctl sys_shmctl ipc/shm.c 32 dup sys_dup fs/file.c 33 dup2 sys_dup2 fs/file.c 34 pause sys_pause kernel/signal.c 35 nanosleep sys_nanosleep kernel/hrtimer.c 36 getitimer sys_getitimer kernel/itimer.c 37 alarm sys_alarm kernel/timer.c 38 setitimer sys_setitimer kernel/itimer.c 39 getpid sys_getpid kernel/sys.c 40 sendfile sys_sendfile64 fs/read_write.c 41 socket sys_socket net/socket.c 42 connect sys_connect net/socket.c 43 accept sys_accept net/socket.c 44 sendto sys_sendto net/socket.c 45 recvfrom sys_recvfrom net/socket.c 46 sendmsg sys_sendmsg net/socket.c 47 recvmsg sys_recvmsg net/socket.c 48 shutdown sys_shutdown net/socket.c 49 bind sys_bind net/socket.c 50 listen sys_listen net/socket.c 51 getsockname sys_getsockname net/socket.c 52 getpeername sys_getpeername net/socket.c 53 socketpair sys_socketpair net/socket.c 54 setsockopt sys_setsockopt net/socket.c 55 getsockopt sys_getsockopt net/socket.c 56 clone stub_clone kernel/fork.c 57 fork stub_fork kernel/fork.c 58 vfork stub_vfork kernel/fork.c 59 execve stub_execve fs/exec.c 60 exit sys_exit kernel/exit.c 61 wait4 sys_wait4 kernel/exit.c 62 kill sys_kill kernel/signal.c 63 uname sys_newuname kernel/sys.c 64 semget sys_semget ipc/sem.c 65 semop sys_semop ipc/sem.c 66 semctl sys_semctl ipc/sem.c 67 shmdt sys_shmdt ipc/shm.c 68 msgget sys_msgget ipc/msg.c 69 msgsnd sys_msgsnd ipc/msg.c 70 msgrcv sys_msgrcv ipc/msg.c 71 msgctl sys_msgctl ipc/msg.c 72 fcntl sys_fcntl fs/fcntl.c 73 flock sys_flock fs/locks.c 74 fsync sys_fsync fs/sync.c 75 fdatasync sys_fdatasync fs/sync.c 76 truncate sys_truncate fs/open.c 77 ftruncate sys_ftruncate fs/open.c 78 getdents sys_getdents fs/readdir.c 79 getcwd sys_getcwd fs/dcache.c 80 chdir sys_chdir fs/open.c 81 fchdir sys_fchdir fs/open.c 82 rename sys_rename fs/namei.c 83 mkdir sys_mkdir fs/namei.c 84 rmdir sys_rmdir fs/namei.c 85 creat sys_creat fs/open.c 86 link sys_link fs/namei.c 87 unlink sys_unlink fs/namei.c 88 symlink sys_symlink fs/namei.c 89 readlink sys_readlink fs/stat.c 90 chmod sys_chmod fs/open.c 91 fchmod sys_fchmod fs/open.c 92 chown sys_chown fs/open.c 93 fchown sys_fchown fs/open.c 94 lchown sys_lchown fs/open.c 95 umask sys_umask kernel/sys.c 96 gettimeofday sys_gettimeofday kernel/time.c 97 getrlimit sys_getrlimit kernel/sys.c 98 getrusage sys_getrusage kernel/sys.c 99 sysinfo sys_sysinfo kernel/sys.c 100 times sys_times kernel/sys.c 101 ptrace sys_ptrace kernel/ptrace.c 102 getuid sys_getuid kernel/sys.c 103 syslog sys_syslog kernel/printk/printk.c 104 getgid sys_getgid kernel/sys.c 105 setuid sys_setuid kernel/sys.c 106 setgid sys_setgid kernel/sys.c 107 geteuid sys_geteuid kernel/sys.c 108 getegid sys_getegid kernel/sys.c 109 setpgid sys_setpgid kernel/sys.c 110 getppid sys_getppid kernel/sys.c 111 getpgrp sys_getpgrp kernel/sys.c 112 setsid sys_setsid kernel/sys.c 113 setreuid sys_setreuid kernel/sys.c 114 setregid sys_setregid kernel/sys.c 115 getgroups sys_getgroups kernel/groups.c 116 setgroups sys_setgroups kernel/groups.c 117 setresuid sys_setresuid kernel/sys.c 118 getresuid sys_getresuid kernel/sys.c 119 setresgid sys_setresgid kernel/sys.c 120 getresgid sys_getresgid kernel/sys.c 121 getpgid sys_getpgid kernel/sys.c 122 setfsuid sys_setfsuid kernel/sys.c 123 setfsgid sys_setfsgid kernel/sys.c 124 getsid sys_getsid kernel/sys.c 125 capget sys_capget kernel/capability.c 126 capset sys_capset kernel/capability.c 127 rt_sigpending sys_rt_sigpending kernel/signal.c 128 rt_sigtimedwait sys_rt_sigtimedwait kernel/signal.c 129 rt_sigqueueinfo sys_rt_sigqueueinfo kernel/signal.c 130 rt_sigsuspend sys_rt_sigsuspend kernel/signal.c 131 sigaltstack sys_sigaltstack kernel/signal.c 132 utime sys_utime fs/utimes.c 133 mknod sys_mknod fs/namei.c 134 uselib fs/exec.c 135 personality sys_personality kernel/exec_domain.c 136 ustat sys_ustat fs/statfs.c 137 statfs sys_statfs fs/statfs.c 138 fstatfs sys_fstatfs fs/statfs.c 139 sysfs sys_sysfs fs/filesystems.c 140 getpriority sys_getpriority kernel/sys.c 141 setpriority sys_setpriority kernel/sys.c 142 sched_setparam sys_sched_setparam kernel/sched/core.c 143 sched_getparam sys_sched_getparam kernel/sched/core.c 144 sched_setscheduler sys_sched_setscheduler kernel/sched/core.c 145 sched_getscheduler sys_sched_getscheduler kernel/sched/core.c 146 sched_get_priority_max sys_sched_get_priority_max kernel/sched/core.c 147 sched_get_priority_min sys_sched_get_priority_min kernel/sched/core.c 148 sched_rr_get_interval sys_sched_rr_get_interval kernel/sched/core.c 149 mlock sys_mlock mm/mlock.c 150 munlock sys_munlock mm/mlock.c 151 mlockall sys_mlockall mm/mlock.c 152 munlockall sys_munlockall mm/mlock.c 153 vhangup sys_vhangup fs/open.c 154 modify_ldt sys_modify_ldt arch/x86/um/ldt.c 155 pivot_root sys_pivot_root fs/namespace.c 156 _sysctl sys_sysctl kernel/sysctl_binary.c 157 prctl sys_prctl kernel/sys.c 158 arch_prctl sys_arch_prctl arch/x86/um/syscalls_64.c 159 adjtimex sys_adjtimex kernel/time.c 160 setrlimit sys_setrlimit kernel/sys.c 161 chroot sys_chroot fs/open.c 162 sync sys_sync fs/sync.c 163 acct sys_acct kernel/acct.c 164 settimeofday sys_settimeofday kernel/time.c 165 mount sys_mount fs/namespace.c 166 umount2 sys_umount fs/namespace.c 167 swapon sys_swapon mm/swapfile.c 168 swapoff sys_swapoff mm/swapfile.c 169 reboot sys_reboot kernel/reboot.c 170 sethostname sys_sethostname kernel/sys.c 171 setdomainname sys_setdomainname kernel/sys.c 172 iopl stub_iopl arch/x86/kernel/ioport.c 173 ioperm sys_ioperm arch/x86/kernel/ioport.c 174 create_module NOT IMPLEMENTED 175 init_module sys_init_module kernel/module.c 176 delete_module sys_delete_module kernel/module.c 177 get_kernel_syms NOT IMPLEMENTED 178 query_module NOT IMPLEMENTED 179 quotactl sys_quotactl fs/quota/quota.c 180 nfsservctl NOT IMPLEMENTED 181 getpmsg NOT IMPLEMENTED 182 putpmsg NOT IMPLEMENTED 183 afs_syscall NOT IMPLEMENTED 184 tuxcall NOT IMPLEMENTED 185 security NOT IMPLEMENTED 186 gettid sys_gettid kernel/sys.c 187 readahead sys_readahead mm/readahead.c 188 setxattr sys_setxattr fs/xattr.c 189 lsetxattr sys_lsetxattr fs/xattr.c 190 fsetxattr sys_fsetxattr fs/xattr.c 191 getxattr sys_getxattr fs/xattr.c 192 lgetxattr sys_lgetxattr fs/xattr.c 193 fgetxattr sys_fgetxattr fs/xattr.c 194 listxattr sys_listxattr fs/xattr.c 195 llistxattr sys_llistxattr fs/xattr.c 196 flistxattr sys_flistxattr fs/xattr.c 197 removexattr sys_removexattr fs/xattr.c 198 lremovexattr sys_lremovexattr fs/xattr.c 199 fremovexattr sys_fremovexattr fs/xattr.c 200 tkill sys_tkill kernel/signal.c 201 time sys_time kernel/time.c 202 futex sys_futex kernel/futex.c 203 sched_setaffinity sys_sched_setaffinity kernel/sched/core.c 204 sched_getaffinity sys_sched_getaffinity kernel/sched/core.c 205 set_thread_area arch/x86/kernel/tls.c 206 io_setup sys_io_setup fs/aio.c 207 io_destroy sys_io_destroy fs/aio.c 208 io_getevents sys_io_getevents fs/aio.c 209 io_submit sys_io_submit fs/aio.c 210 io_cancel sys_io_cancel fs/aio.c 211 get_thread_area arch/x86/kernel/tls.c 212 lookup_dcookie sys_lookup_dcookie fs/dcookies.c 213 epoll_create sys_epoll_create fs/eventpoll.c 214 epoll_ctl_old NOT IMPLEMENTED 215 epoll_wait_old NOT IMPLEMENTED 216 remap_file_pages sys_remap_file_pages mm/fremap.c 217 getdents64 sys_getdents64 fs/readdir.c 218 set_tid_address sys_set_tid_address kernel/fork.c 219 restart_syscall sys_restart_syscall kernel/signal.c 220 semtimedop sys_semtimedop ipc/sem.c 221 fadvise64 sys_fadvise64 mm/fadvise.c 222 timer_create sys_timer_create kernel/posix-timers.c 223 timer_settime sys_timer_settime kernel/posix-timers.c 224 timer_gettime sys_timer_gettime kernel/posix-timers.c 225 timer_getoverrun sys_timer_getoverrun kernel/posix-timers.c 226 timer_delete sys_timer_delete kernel/posix-timers.c 227 clock_settime sys_clock_settime kernel/posix-timers.c 228 clock_gettime sys_clock_gettime kernel/posix-timers.c 229 clock_getres sys_clock_getres kernel/posix-timers.c 230 clock_nanosleep sys_clock_nanosleep kernel/posix-timers.c 231 exit_group sys_exit_group kernel/exit.c 232 epoll_wait sys_epoll_wait fs/eventpoll.c 233 epoll_ctl sys_epoll_ctl fs/eventpoll.c 234 tgkill sys_tgkill kernel/signal.c 235 utimes sys_utimes fs/utimes.c 236 vserver NOT IMPLEMENTED 237 mbind sys_mbind mm/mempolicy.c 238 set_mempolicy sys_set_mempolicy mm/mempolicy.c 239 get_mempolicy sys_get_mempolicy mm/mempolicy.c 240 mq_open sys_mq_open ipc/mqueue.c 241 mq_unlink sys_mq_unlink ipc/mqueue.c 242 mq_timedsend sys_mq_timedsend ipc/mqueue.c 243 mq_timedreceive sys_mq_timedreceive ipc/mqueue.c 244 mq_notify sys_mq_notify ipc/mqueue.c 245 mq_getsetattr sys_mq_getsetattr ipc/mqueue.c 246 kexec_load sys_kexec_load kernel/kexec.c 247 waitid sys_waitid kernel/exit.c 248 add_key sys_add_key security/keys/keyctl.c 249 request_key sys_request_key security/keys/keyctl.c 250 keyctl sys_keyctl security/keys/keyctl.c 251 ioprio_set sys_ioprio_set fs/ioprio.c 252 ioprio_get sys_ioprio_get fs/ioprio.c 253 inotify_init sys_inotify_init fs/notify/inotify/inotify_user.c 254 inotify_add_watch sys_inotify_add_watch fs/notify/inotify/inotify_user.c 255 inotify_rm_watch sys_inotify_rm_watch fs/notify/inotify/inotify_user.c 256 migrate_pages sys_migrate_pages mm/mempolicy.c 257 openat sys_openat fs/open.c 258 mkdirat sys_mkdirat fs/namei.c 259 mknodat sys_mknodat fs/namei.c 260 fchownat sys_fchownat fs/open.c 261 futimesat sys_futimesat fs/utimes.c 262 newfstatat sys_newfstatat fs/stat.c 263 unlinkat sys_unlinkat fs/namei.c 264 renameat sys_renameat fs/namei.c 265 linkat sys_linkat fs/namei.c 266 symlinkat sys_symlinkat fs/namei.c 267 readlinkat sys_readlinkat fs/stat.c 268 fchmodat sys_fchmodat fs/open.c 269 faccessat sys_faccessat fs/open.c 270 pselect6 sys_pselect6 fs/select.c 271 ppoll sys_ppoll fs/select.c 272 unshare sys_unshare kernel/fork.c 273 set_robust_list sys_set_robust_list kernel/futex.c 274 get_robust_list sys_get_robust_list kernel/futex.c 275 splice sys_splice fs/splice.c 276 tee sys_tee fs/splice.c 277 sync_file_range sys_sync_file_range fs/sync.c 278 vmsplice sys_vmsplice fs/splice.c 279 move_pages sys_move_pages mm/migrate.c 280 utimensat sys_utimensat fs/utimes.c 281 epoll_pwait sys_epoll_pwait fs/eventpoll.c 282 signalfd sys_signalfd fs/signalfd.c 283 timerfd_create sys_timerfd_create fs/timerfd.c 284 eventfd sys_eventfd fs/eventfd.c 285 fallocate sys_fallocate fs/open.c 286 timerfd_settime sys_timerfd_settime fs/timerfd.c 287 timerfd_gettime sys_timerfd_gettime fs/timerfd.c 288 accept4 sys_accept4 net/socket.c 289 signalfd4 sys_signalfd4 fs/signalfd.c 290 eventfd2 sys_eventfd2 fs/eventfd.c 291 epoll_create1 sys_epoll_create1 fs/eventpoll.c 292 dup3 sys_dup3 fs/file.c 293 pipe2 sys_pipe2 fs/pipe.c 294 inotify_init1 sys_inotify_init1 fs/notify/inotify/inotify_user.c 295 preadv sys_preadv fs/read_write.c 296 pwritev sys_pwritev fs/read_write.c 297 rt_tgsigqueueinfo sys_rt_tgsigqueueinfo kernel/signal.c 298 perf_event_open sys_perf_event_open kernel/events/core.c 299 recvmmsg sys_recvmmsg net/socket.c 300 fanotify_init sys_fanotify_init fs/notify/fanotify/fanotify_user.c 301 fanotify_mark sys_fanotify_mark fs/notify/fanotify/fanotify_user.c 302 prlimit64 sys_prlimit64 kernel/sys.c 303 name_to_handle_at sys_name_to_handle_at fs/fhandle.c 304 open_by_handle_at sys_open_by_handle_at fs/fhandle.c 305 clock_adjtime sys_clock_adjtime kernel/posix-timers.c 306 syncfs sys_syncfs fs/sync.c 307 sendmmsg sys_sendmmsg net/socket.c 308 setns sys_setns kernel/nsproxy.c 309 getcpu sys_getcpu kernel/sys.c 310 process_vm_readv sys_process_vm_readv mm/process_vm_access.c 311 process_vm_writev sys_process_vm_writev mm/process_vm_access.c 312 kcmp sys_kcmp kernel/kcmp.c 313 finit_module sys_finit_module kernel/module.c 在linux 查看32位的系统调用号 cat /usr/include/asm/unistd_32.h

阅读全文

函数调用帧栈

Sep 18, 2019

区域作用栈区（stack）由编译器自动分配和释放，存放函数的参数值，局部变量的值等。操作方式类似与数据结构中的栈堆区（heap）一般由程序员分配和释放，若程序员不释放，程序结束时可能由操作系统回收。与数据结构中的堆是两码事，分配方式类似于链表静态区（static）全局变量和静态变量存放于此文字常量区常量字符串放在此，程序结束后由系统释放程序代码区存放函数体的二进制代码栈帧就是一个函数执行的环境。实际上，栈帧可以简单理解为：栈帧就是存储在用户栈上的（当然内核栈同样适用）每一次函数调用涉及的相关信息的记录单元。栈是从高地址向低地址延伸的。每个函数的每次调用，都有它自己独立的一个栈帧，这个栈帧中维持着所需要的各种信息。寄存器ebp指向当前的栈帧的底部（高地址），寄存器esp指向当前的栈帧的顶部（地址地）。

阅读全文

C语言的异常机制 setjump longjump函数

Sep 18, 2019

与刺激的abort()和exit()相比,goto语句看起来是处理异常的更可行方案。不幸的是，goto是本地的：它只能跳到所在函数内部的标号上，而不能将控制权转移到所在程序的任意地点（当然，除非你的所有代码都在main体中）。为了解决这个限制，C函数库提供了setjmp()和longjmp()函数，它们分别承担非局部标号和goto作用。头文件申明了这些函数及同时所需的jmp_buf数据类型。原理非常简单： 1.setjmp(j)设置“jump”点，用正确的程序上下文填充jmp_buf对象j。这个上下文包括程序存放位置、栈和框架指针，其它重要的寄存器和内存数据。当初始化完jump的上下文，setjmp()返回0值。

以后调用longjmp(j,r)的效果就是一个非局部的goto或“长跳转”到由j描述的上下文处（也就是到那原来设置j的setjmp()处）。当作为长跳转的目标而被调用时，setjmp()返回r或1（如果r设为0的话）。（记住，setjmp()不能在这种情况时返回0。）

vxworks是怎么把这个pty设备建立起来的呢, 这个可以从帮助文件中找到:
1. 先调用ptyDrv( ) 初始化驱动
2. 调用ptyDevCreate( ) 来创建pty设备, 当然也可以用ptyDevRemove( )来移除一个已经创建过的pty设备.
    在调用ptyDevCreate( )的时候, 举例来说, ptyDevCreate ("/pty/0.", 512, 512); 那么就会生成一个pty Master, 自动命名为"/pty0.M", 并且生成一个pty Slave, 自动命名为"/pty0.S". 然后Master和Slave就可以通过open()函数打开啦! 比如说 open ("/pty0.M", O_RDWR, 0), 就可以得到master的fd了, slave同样.户端的具体实现:

nginx配置大致如下： upstream webserver { server unix:/var/3w/9101.sock server unix:/var/3w/9102.sock server unix:/var/3w/9103.sock server unix:/var/3w/9104.sock }

多个server 进程，共同对应一个unix socket file，前面走nginx代理启动配置大致如下： python webserver –app_sockfile=/var/3w/webserver.sock python webserver –app_sockfile=/var/3w/webserver.sock python webserver –app_sockfile=/var/3w/webserver.sock python webserver –app_sockfile=/var/3w/webserver.sock nginx配置大致如下： upstream webserver { server unix:/var/3w/webserver.sock } reuseaddr是用来去掉2MSL的，MSL请看tcp协议，简单来讲，当某个绑定了套接字127.0.0.1:8080的进程stop后，假如没有使用reuseaddr，该进程不能立刻重新运行，反之，则可以立刻running。 reuseport，也是setsockopt来设置套接字属性的

阅读全文

多个进程绑定相同端口的实现分析[Google Patch]

May 28, 2019

Google REUSEPORT 新特性，支持多个进程或者线程绑定到相同的 IP 和端口，以提高 server 的性能。

设计思路该特性实现了 IPv4/IPv6 下 TCP/UDP 协议的支持，已经集成到 kernel 3.9 中。

阅读全文

TCP_CORK tcp_push TCP_NODELAY 和 TCP_NOPUSH

May 26, 2019

用户层可通过setsockopt系统调用设置TCP套接口的TCP_CORK选项。开启时，内核将阻塞不完整的报文，当关闭此选项时，发送阻塞的报文。此处的不完整指的是应用层发送的数据长度不足一个MSS长度。使用场景是在调用sendfile发送文件内容之前，提前发送一个描述文件信息的头部数据段，并且阻塞住此头部数据，与之后的sendfile数据一同发送。或者用于优化吞吐性能。但是，TCP_CORK最多只能将数据阻塞200毫秒，如果超过此时间值，内核将自动发送阻塞的数据。

阅读全文

pid 文件作用

May 26, 2019

打开系统(Linux) 的 “/var/run/” 目录可以看到有很多已 “.pid” 为结尾的文件这些文件只有一行，它记录的是相应进程的 pid，即进程号。所以通过 pid 文件可以很方便的得到一个进程的 pid，然后做相应的操作，比如检测、关闭。重要的作用，那就是防止进程启动多个副本。通过文件锁，可以保证一时间内只有一个进程能持有这个文件的写权限，所以在程序启动的检测逻辑中加入获取pid 文件锁并写pid文件的逻辑就可以防止重复启动进程的多个副本了。 /var/run是干什么用的根据linux的文件系统分层结构标准（FHS）中的定义：

阅读全文

libevent

May 26, 2019

libevent是一个事件通知库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue、IOCP等系统调用管理事件机制。著名分布式缓存软件memcached也是基于libevent，而且libevent在使用上可以做到跨平台，而且根据libevent官方网站上公布的数据统计，似乎也有着非凡的性能。 libevent支持用户使用三种类型的事件，分别是网络IO、定时器、信号三种，最新版本在定时器的实现上使用了最小堆的数据结构，以达到高效查找、排序、删除定时器的目的，IO和信号的实现均使用了双向队列（用链表实现）。网络IO上，主要关注了一下linux上的epoll（因为目前的开发主要在linux平台），结果发现libevent的epoll居然用的EPOLLLT，水平触发的方式用起来比较方便，不容易出错，但是在效率上可能比EPOLLET要低一些。 libevent包括事件管理、缓存管理、DNS、HTTP、缓存事件几大部分。事件管理包括各种IO（socket）、定时器、信号等事件；缓存管理是指evbuffer功能；DNS是libevent提供的一个异步DNS查询功能；HTTP是libevent的一个轻量级http实现，包括服务器和客户端。libevent也支持ssl，这对于有安全需求的网络程序非常的重要，但是其支持不是很完善，比如http server的实现就不支持ssl。

阅读全文

backlog

May 24, 2019

TCP建立连接是要进行三次握手，但是否完成三次握手后，服务器就处理（accept）呢？

阅读全文

SYN-Cookie

May 23, 2019

预防半连接攻击，SYN-Cookie是一种有效的机制，它的基本原理非常简单，那就是“完成三次握手前不为任何一个连接分配任何资源 1.编码信息将一些本应该在本地保存的信息编码到返回给客户端的SYN-ACK的初始化序列号或者时间戳里面。握手尚未完成不分配任何资源(Linux即不分配request结构体)。 2.解码信息等到客户端的ACK最终到来的时候，再从ACK序列号里面解码出保存的信息。 3.建立连接利用第2步解码出来的信息建立一个TCP连接，此时因为握手已经完成，可以分配资源了。编码过程图示解码过程图示通过上面的编码解码过程中好像没有什么check/compare操作，一般而言，对于类似HASH或者摘要的算法，都需要对信息进行比对，比如对一段信息生产一个摘要，为了确保该信息没有被篡改，需要再次使用相同的算法生成摘要，如果两段摘要的值不同，说明信息被篡改了！对于上面的算法，在生产Cookie的时候，我们注意到使用hash算法对元组生产了一个值，但是对于解码的过程，它并没有再次计算这个值与原始携带的值做比对，这样合理吗？这事实上是Linux的一个hack！Linux将一段data做了限定，比如它的值严格在0-7之间，将这个data一同参与运算，而不是仅仅将其编码到固定的某几个bit，算法寄希望于：如果数据是伪造的或者被篡改了，那么解码出来的data的值仍然处在规定的严格区间里的可能性微乎其微！ 24比特数据的编码和解码的过程：

阅读全文

SO_REUSEADDR SO_REUSEPORT

May 23, 2019

每次kill掉该服务器进程并重新启动的时候，都会出现bind错误：error:98，Address already in use。然而再kill掉该进程，再次重新启动的时候，就bind成功了。端口正在被使用，并处于TCP中的TIME_WAIT状态。再过两分钟，我再执行命令netstat -an|grep 9877

阅读全文

lsof netstat

May 22, 2019

lsof命令只能以root的权限执行用法如下：

显示开启文件abc.txt的进程 lsof abc.txt
显示22端口现在被什么程序占用 lsof -i 22
显示abc进程现在正在打开的文件 lsof -c abc
显示归属gid的进程情况 lsof -g gid
显示指定目录下被进程开启的文件，不会遍历该目录下的所有子目录 lsof +d /usr/local/
显示指定目录下被进程开启的文件，会遍历该目录下得所有子目录 lsof +D /usr/local/
显示使用fd为4的进程 lsof -d 4
不进行域名解析，缺省会进行，比较慢 lsof -n
查看进程号为12的进程打开了哪些文件 lsof -p 12
让lsof重复执行，缺省15s刷新 lsof +|-r [t] -r, lsof会永远执行，直到被中断 +r, lsof会一直执行，直到没可显示的内容 Example：查看目前ftp连接的情况：lsof -i tcp@test.com:ftp -r
列出打开文件的大小，如果大小为0，则空 lsof -s
以UID，列出打开的文件 lsof -u username
显示符合条件的进程情况语法：lsof -i[46] [protocol][@hostname|hostaddr][:service|port] 46 – IPV4 or IPV6 protocol – TCP or UDP hostname – Internet host name hostaddr – IP地址 service – /etc/service中的service name（可多选） port – 端口号（可多选） Example： TCP:25 - TCP and port 25 @1.1.1.1 - IP 1.1.1.1 tcp@test.com - TCP protocol, ftp service netstat可以不在root权限下运行
查看进程占用的端口号 netstat -anp [root@nbatest ~]# netstat -anp | grep syslog //进程名 udp 0 0 0.0.0.0:514 0.0.0.0:* 31483/syslogd
netstat -anp [root@nbatest ~]# netstat -anp | grep 514 //port口 udp 0 0 0.0.0.0:514 0.0.0.0:* 31483/syslogd

阅读全文

TCP序列号欺骗

May 9, 2019

为了确保端到端的可靠传输，TCP对所发送出的每个数据包都分配序列编号，当对方收到数据包后则向发送方进行确认，接收方利用序列号来确认数据包的先后顺序，并丢弃重复的数据包。TCP序列号在TCP数据包中占32位字节，有发送序列号SEQS和确认序列号SEQA两种，它们分别对应SYN和ACK两个标志。当SYN置1时，表示所发送的数据包的序列号为SEQS ；当ACK置1时，表示接收方准备接收的数据包的序列号为SEQA 。 ① Xser → Server：SYN（SEQS=ISNC）；使用User的IP作为源地址 ② Server → User ：SYN（SEQS=ISNS），ACK（SEQA=ISNC+1） ③ Xser → Server：ACK（SEQA=ISNS+1）；使用User的IP作为源地址在这里，Xser以User的身份向服务器发送初始序列号，并置SYN=1，请求与服务器建立连接；当服务器收到该请求后，向User返回应答序列号，如果此时User能正常工作，则认为这是一个非法数据包而终止连接，使攻击者的目的落空，否则，攻击者将继续以User的身份向服务器发送已推测出的确认序列号ISNS+1，并与服务器建立连接，进而可在服务器上行使User的权限，执行相应的操作。使用这种攻击需要具备两个基本条件：一是能推测出序列号ISNS的值；二是所冒充的可信任主机不能正常工作。其中，最关键的是要推测出由服务器返回的序列号ISNS的值。由服务器返回的这个值可能是个随机数，它通常与被信任主机和服务器间的RTT时间有关，必须经过多次采样和统计分析，才可能推测到这个值。通常，可重复多次与被攻击主机的某个端口（如SMTP）建立正常连接，然后断开，并记录每次连接所设定的ISN值。另外，还需要多次测试可信任主机与服务器间的RTT时间

序列号和确认号的简介及作用

阅读全文

Tcp Keepalive和HTTP Keep-alive

Apr 13, 2019

Tcp Keepalive的起源双方建立交互的连接，但是并不是一直存在数据交互，有些连接会在数据交互完毕后，主动释放连接，而有些不会，那么在长时间无数据交互的时间段内，交互双方都有可能出现掉电、死机、异常重启等各种意外，当这些意外发生之后，这些TCP连接并未来得及正常释放，那么，连接的另一方并不知道对端的情况，它会一直维护这个连接，长时间的积累会导致非常多的半打开连接，造成端系统资源的消耗和浪费，为了解决这个问题，在传输层可以利用TCP的保活报文来实现。

阅读全文

keepalive 连接池

Apr 13, 2019

1 连接种类一般连接主要分为长连接，短连接和http的keepalive连接。

阅读全文

发送接收缓冲区滑动窗口

Apr 13, 2019

发送窗口与接收窗口关系

阅读全文

inode 与文件块 block 对应关系

Apr 7, 2019

Linux文件访问流程 inode是文件的唯一标识，文件名和inode的对应关系存放在上一级目录的block中；inode里有指向文件block的指针和文件的属性，从而通过block获得文件数据。

阅读全文

socket 虚拟文件系统

Apr 6, 2019

在内核中，对socket实现了一种虚拟的文件系统（VFS）：socketfs。和其它一般文件系统不同，它不能被mount，没有挂载点，而是通过一个静态变量来引用： [ net/socket.c ] static struct vfsmount *sock_mnt __read_mostly; 在用户空间创建了一个socket后，返回值是一个文件描述符，下面分析一下创建socket时怎么和文件描述符联系的。在SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)最后调用sock_map_fd进行关联，其中返回的retval就是用户空间获取的文件描述符fd，sock就是调用sock_create创建成功的socket.

阅读全文

screen nohup session

Apr 6, 2019

nohup和&的缺点是，如果你要在一个shell会话里面执行多个命令和脚本，那么要每个命令和脚本都要加nohup和&非常麻烦，所以才有了screen和TMUX Screen 命令与 Tmux 命令另一种思路是使用 terminal multiplexer （终端复用器：在同一个终端里面，管理多个session），典型的就是 Screen 命令和 Tmux 命令。它们可以在当前 session 里面，新建另一个 session。这样的话，当前 session 一旦结束，不影响其他 session。而且，以后重新登录，还可以再连上早先新建的 session。 kill 调用的是 SIGTERM, 此信号可以被捕获和忽略。 kill -9 调用的是 SIGKILL, 杀掉进程，不能被捕获和忽略。 SIGHUP是在终端被断开时候调用，如果信号没有被处理，进程会终止。

阅读全文

fork cahe

Apr 6, 2019

题目：请问下面的程序一共输出多少个“-”？ `#include #include <sys/types.h> #include

int main(void) { int i; for(i=0; i<2; i++){ fork(); printf(“-“); }

wait(NULL); wait(NULL);

return 0; }` 如果你对fork()的机制比较熟悉的话，这个题并不难，输出应该是6个“-”，但是，实际上这个程序会很tricky地输出8个“-”。

阅读全文

文件锁

Apr 6, 2019

两种经常使用的文件锁：

阅读全文

fd 文件描述符

Apr 6, 2019

每一个文件描述符会与一个打开文件相对应，同时，不同的文件描述符也会指向同一个文件。相同的文件可以被不同的进程打开也可以在同一个进程中被多次打开。系统为每一个进程维护了一个文件描述符表，该表的值都是从0开始的，所以在不同的进程中你会看到相同的文件描述符，这种情况下相同文件描述符有可能指向同一个文件，也有可能指向不同的文件。具体情况要具体分析，要理解具体其概况如何，需要查看由内核维护的3个数据结构。 1.进程级的文件描述符表； 2.系统级的打开文件描述符表； 3.文件系统的i-node表。文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。在程序设计中，一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。在编写文件操作的或者网络通信的软件时，初学者一般可能会遇到“Too many open files”的问题。这主要是因为文件描述符是系统的一个重要资源，虽然说系统内存有多少就可以打开多少的文件描述符，但是在实际实现过程中内核是会做相应的处理的，一般最大打开文件数会是系统内存的10%（以KB来计算）（称之为系统级限制），查看系统级别的最大打开文件数可以使用sysctl -a | grep fs.file-max命令查看。与此同时，内核为了不让某一个进程消耗掉所有的文件资源，其也会对单个进程最大打开文件数做默认值处理（称之为用户级限制），默认值一般是1024，使用ulimit -n命令可以查看。在Web服务器中，通过更改系统默认值文件描述符的最大值来优化服务器是最常见的方式之一 ## 查看默认文件描述符的大小 [root@poe ~]# ulimit -n 1024 临时修改文件描述符的大小 [root@Gin scripts]# ulimit -SHn 65535 [root@Gin scripts]# ulimit -n 65535 永久修改文件描述符的大小： [root@Gin ~]# echo ‘* - nofile 65535’ »/etc/security/limits.conf [root@Gin ~]# tail -n1 /etc/security/limits.conf

- nofile 65535

阅读全文

pstack 原理

Mar 17, 2019

Mar 9, 2019

通配符适用的地方：shell命令行或者shell脚本中

阅读全文

awk 用法总结

Mar 3, 2019

1，awk 大小写敏感

awk命令格式和选项 2.1. awk的语法有两种形式 awk [options] ‘script’ var=value file(s)

时钟事件软件架构本系列文章的第一节中，我们曾经讨论了时钟源设备：clocksource，现在又来一个时钟事件设备：clock_event_device，它们有何区别？看名字，好像都是给系统提供时钟的设备，实际上，clocksource不能被编程，没有产生事件的能力，它主要被用于timekeeper来实现对真实时间进行精确的统计，而clock_event_device则是可编程的，它可以工作在周期触发或单次触发模式，系统可以对它进行编程，以确定下一次事件触发的时间，clock_event_device主要用于实现普通定时器和高精度定时器，同时也用于产生tick事件，供给进程调度子系统使用。时钟事件设备与通用时间框架中的其他模块的关系如下图所示：与clocksource一样，系统中可以存在多个clock_event_device，系统会根据它们的精度和能力，选择合适的clock_event_device对系统提供时钟事件服务。在smp系统中，为了减少处理器间的通信开销，基本上每个cpu都会具备一个属于自己的本地clock_event_device，独立地为该cpu提供时钟事件服务，smp中的每个cpu基于本地的clock_event_device，建立自己的tick_device，普通定时器和高精度定时器。在软件架构上看，clock_event_device被分为了两层，与硬件相关的被放在了machine层，而与硬件无关的通用代码则被集中到了通用时间框架层，这符合内核对软件的设计需求，平台的开发者只需实现平台相关的接口即可，无需关注复杂的上层时间框架。 tick_device是基于clock_event_device的进一步封装，用于代替原有的时钟滴答中断，给内核提供tick事件，以完成进程的调度和进程信息统计，负载平衡和时间更新等操作。 struct clock_event_device 时钟事件设备的核心数据结构是clock_event_device结构，它代表着一个时钟硬件设备，该设备就好像是一个具有事件触发能力（通常就是指中断）的clocksource，它不停地计数，当计数值达到预先编程设定的数值那一刻，会引发一个时钟事件中断，继而触发该设备的事件处理回调函数，以完成对时钟事件的处理。clock_event_device结构的定义如下：

阅读全文

时间轮算法

Jan 15, 2019

内核自身的正常运行也依赖于时钟系统。Linux 是一个典型的分时系统，CPU 时间被分成多个时间片，这是多任务实现的基础。Linux 内核依赖 tick，即时钟中断来进行分时。

阅读全文

Shell 脚本中调用另一个 Shell 脚本

Nov 28, 2018

fork: 如果脚本有执行权限的话，path/to/foo.sh。如果没有，sh path/to/foo.sh。 exec: exec path/to/foo.sh source: source path/to/foo.sh fork fork 是最普通的, 就是直接在脚本里面用 path/to/foo.sh 来调用 foo.sh 这个脚本，比如如果是 foo.sh 在当前目录下，就是 ./foo.sh。运行的时候 terminal 会新开一个子 Shell 执行脚本 foo.sh，子 Shell 执行的时候, 父 Shell 还在。子 Shell 执行完毕后返回父 Shell。子 Shell 从父 Shell 继承环境变量，但是子 Shell 中的环境变量不会带回父 Shell。

阅读全文

文件读取流程

Oct 21, 2018

使用df -aT命令，发现根目录/对应的文件系统为ext3 Ext3文件系统结构与Ext2相似。用工具格式化磁盘或分区时，会选择使用什么文件系统来格式化。若选用Ext2来格式化磁盘或分区，则磁盘或分区的大部分空间被格式化成了许多个Inode和block两个数据结构。block有3种大小选项1K，2K，4K，可在格式化之前选择。Inode的大小固定为128bytes。每个文件都仅会占用一个Inode，Inode主要用来记录文件相关属性，比如权限、文件大小、修改时间等。block用来记录文件的数据，一个Inode可以关联多个block，且Inode记录一个block号码需要4byte。如果文件非常大的话，则Inode无法直接记录文件所包含的所有block号码。所以Ext2采用12个直接、1个间接、1个双间接、和1个三间接记录区，共需60bytes。 12个直接记录区直接指向带有文件数据的block。1个间接记录区指向一个无真实文件数据的block，此block充当Inode的扩展记录区，此block直接指向带有数据的block。若此扩展block为1K，那么它可记录256个block号码。双间接和三间接类似。

Sep 13, 2018

<img src="https://xiazemin.github.io/MyBlog/img/kobject.jpeg"/> <!-- more --> 1. kobject

阅读全文

Jun 27, 2018

阅读全文

devfs sysfs

Jun 27, 2018

linux下有专门的文件系统用来对设备进行管理，devfs和sysfs就是其中两种。

阅读全文

Linux中pam模块

Jun 26, 2018

Linux-PAM(linux可插入认证模块)是一套共享库，使本地系统管理员可以随意选择程序的认证方式。换句话说，不用重新编译一个包含PAM功能的应用程序，就可以改变它使用的认证机制。这种方式下,就算升级本地认证机制,也不用修改程序. PAM使用配置/etc/pam.d/下的文件,来管理对程序的认证方式.应用程序调用相应的配置文件,从而调用本地的认证模块.模块放置在/lib/security下,以加载动态库的形式进，像我们使用su命令时,系统会提示你输入root用户的密码.这就是su命令通过调用PAM模块实现的。

阅读全文

issue 设置linux登录前后的欢迎信息

Jun 26, 2018

实现登录消息的功能，可以修改3个文件。

阅读全文

bash_profile等几个文件的执行过程

Jun 26, 2018

利用~/.bash_profile: 每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该文件仅仅执行一次可以实现登录公告 $~/.bash_profile if [ -f ～/.greeting ]; then . ～/.greeting; fi $vi ～/.greeting echo -e “^[[1m^[[4;37;32m公告:^[[0m”

在登录Linux时要执行文件的过程如下：

struct napi_struct {
/* The poll_list must only be managed by the entity which changes the * state of the NAPI_STATE_SCHED bit. This means whoever atomically * sets that bit can add this napi_struct to the per-cpu poll_list, and * whoever clears that bit can remove from the list right before clearing the bit. /
struct list_head poll_list; / 用于加入处于轮询状态的设备队列 /
unsigned long state; / 设备的状态 /
int weight; / 每次处理的最大数量，非NAPI默认为64 /
int (poll) (struct napi_struct , int); / 此设备的轮询方法，非NAPI为process_backlog() /
#ifdef CONFIG_NETPOLL
…
#endif
unsigned int gro_count;
struct net_device *dev;
struct list_head dev_list;
struct sk_buff *gro_list;
struct sk_buff *skb;
};
(2) 初始化初始napi_struct实例。 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
int (poll) (struct napi_struct , int), int weight)
{
INIT_LIST_HEAD(&napi->poll_list);
napi->gro_count = 0;
napi->gro_list = NULL;
napi->skb = NULL;
napi->poll = poll; / 设备的poll函数 /
napi->weight = weight; / 设备每次poll能处理的数据包个数上限 */

list_add(&napi->dev_list, &dev->napi_list); /* 加入设备的napi_list */  
napi->dev = dev; /* 所属设备 */     #ifdef CONFIG_NETPOLL  
spin_lock_init(&napi->poll_lock);  
napi->poll_owner = -1;    #endif  
set_bit(NAPI_STATE_SCHED, &napi->state); /* 设置NAPI标志位 */   }   (3) 调度 在网卡驱动的中断处理函数中调用napi_schedule()来使用NAPI。 /**   * napi_schedule - schedule NAPI poll   * @n: napi context   * Schedule NAPI poll routine to be called if it is not already running.   */    static inline void napi_schedule(struct napi_struct *n)   {  
/* 判断是否可以调度NAPI */  
if (napi_schedule_prep(n))  
    __napi_schedule(n);   }   判断NAPI是否可以调度。如果NAPI没有被禁止，且不存在已被调度的NAPI， 则允许调度NAPI，因为同一时刻只允许有一个NAPI poll instance。 /**   * napi_schedule_prep - check if napi can be scheduled   * @n: napi context   * Test if NAPI routine is already running, and if not mark it as running.   * This is used as a condition variable insure only one NAPI poll instance runs.   * We also make sure there is no pending NAPI disable.   */  

static inline int napi_schedule_prep(struct napi_struct *n)
{
return !napi_disable_pending(n) && !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
}

Apr 22, 2018

expect是一个自动交互功能的工具。expect是开了一个子进程，通过spawn来执行shell脚本，监测到脚本的返回结果，通过expect判断要进行的交互输入内容（send） 1.安装expect 需要先安装tcl：apt-get install tcl apt-get install expect 2.expect使用 2.1一个简单的输入密码操作

1
2
3
4
5
6
7
 #！/usr/bin/expect
set timeout 100
set password "123456"
spawn sudo rm -rf zzlogic
expect "root123456"
send "$password\n"
interact

 目前支持I/O多路复用的系统调用有 select，pselect，poll，epoll，I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，pselect，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。
 与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

一、使用场景 IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：　　1）当客户处理多个描述符时（一般是交互式输入和网络套接口），必须使用I/O复用。　　2）当一个客户同时处理多个套接口时，这种情况是可能的，但很少出现。　　3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。　　4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。　　5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。

二、select、poll、epoll简介　　epoll跟select都能提供多路I/O复用的解决方案。在现在的Linux内核里有都能够支持，其中epoll是Linux所特有，而select则应该是POSIX所规定，一般操作系统均有实现。 1、select 基本原理：select 函数监视的文件描述符分3类，分别是writefds、readfds、和exceptfds。调用后select函数会阻塞，直到有描述符就绪（有数据可读、可写、或者有except），或者超时（timeout指定等待时间，如果立即返回设为null即可），函数返回。当select函数返回后，可以通过遍历fdset，来找到就绪的描述符。

基本流程，如图所示：

　　select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点。select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但是这样也会造成效率的降低。

select本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。这样所带来的缺点是： 1、select最大的缺陷就是单个进程所打开的FD是有一定限制的，它由FD_SETSIZE设置，默认值是1024。　　一般来说这个数目和系统内存关系很大，具体数目可以cat /proc/sys/fs/file-max察看。32位机默认是1024个。64位机默认是2048. 2、对socket进行扫描时是线性扫描，即采用轮询的方法，效率较低。　　当套接字比较多的时候，每次select()都要通过遍历FD_SETSIZE个Socket来完成调度，不管哪个Socket是活跃的，都遍历一遍。这会浪费很多CPU时间。如果能给套接字注册某个回调函数，当他们活跃时，自动完成相关操作，那就避免了轮询，这正是epoll与kqueue做的。 3、需要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时复制开销大。

2、poll 基本原理：poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态，如果设备就绪则在设备等待队列中加入一项并继续遍历，如果遍历完所有fd后没有发现就绪设备，则挂起当前进程，直到设备就绪或者主动超时，被唤醒后它又要再次遍历fd。这个过程经历了多次无谓的遍历。

它没有最大连接数的限制，原因是它是基于链表来存储的，但是同样有一个缺点： 1）大量的fd的数组被整体复制于用户态和内核地址空间之间，而不管这样的复制是不是有意义。 2）poll还有一个特点是“水平触发”，如果报告了fd后，没有被处理，那么下次poll时会再次报告该fd。

注意：从上面看，select和poll都需要在返回后，通过遍历文件描述符来获取已经就绪的socket。事实上，同时连接的大量客户端在一时刻可能只有很少的处于就绪状态，因此随着监视的描述符数量的增长，其效率也会线性下降。

3、epoll 　　epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

基本原理：epoll支持水平触发和边缘触发，最大的特点在于边缘触发，它只告诉进程哪些fd刚刚变为就绪态，并且只会通知一次。还有一个特点是，epoll使用“事件”的就绪通知方式，通过epoll_ctl注册fd，一旦该fd就绪，内核就会采用类似callback的回调机制来激活该fd，epoll_wait便可以收到通知。

epoll的优点： 1、没有最大并发连接的限制，能打开的FD的上限远大于1024（1G的内存上能监听约10万个端口）。 2、效率提升，不是轮询的方式，不会随着FD数目的增加效率下降。　　只有活跃可用的FD才会调用callback函数；即Epoll最大的优点就在于它只管你“活跃”的连接，而跟连接总数无关，因此在实际的网络环境中，Epoll的效率就会远远高于select和poll。 3、内存拷贝，利用mmap()文件映射内存加速与内核空间的消息传递；即epoll使用mmap减少复制开销。

epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下： LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。 ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。 1、LT模式　　LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的。 2、ET模式　　ET(edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once)。　　ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。 3、在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。(此处去掉了遍历文件描述符，而是通过监听回调的的机制。这正是epoll的魅力所在。) 注意：如果没有大量的idle-connection或者dead-connection，epoll的效率并不会比select/poll高很多，但是当遇到大量的idle-connection，就会发现epoll的效率大大高于select/poll。

三、select、poll、epoll区别 1、支持一个进程所能打开的最大连接数 2、FD剧增后带来的IO效率问题 3、消息传递方式

综上，在选择select，poll，epoll时要根据具体的使用场合以及这三种方式的自身特点： 1、表面上看epoll的性能最好，但是在连接数少并且连接都十分活跃的情况下，select和poll的性能可能比epoll好，毕竟epoll的通知机制需要很多函数回调。 2、select低效是因为每次它都需要轮询。但低效也是相对的，视情况而定，也可通过良好的设计改善。

阅读全文

ID为0和ID为1的进程

Dec 22, 2017

ID为0的进程通常是调度进程，常常被称为交换进程（swapper）。该进程是内核的一部分，它并不执行任何磁盘上的程序，因此也被称为系统进程。 ID为1的进程，通常是init进程，在自举过程结束时由内核调用。该进程的程序文件，在UNIX早起版本中是/etc/init，在较新的版本中是/sbin/init。该进程负责在自举内核后启动一个UNIX系统。init通常读与系统有关的初始化文件（/etc/rc*文件或/etc/inittab文件，以及/etc/init.d中的文件），并将系统引导到一个状态。init 进程绝不会终止，它是一个普通的用户进程（与交换进程不同，它不是内核的系统进程）但是它以超级用户特权运行。 ——摘自APUE 父进程ID为0的进程通常是内核进程，它们作为系统自举过程的一部分而启动，但init进程是个例外，它的父进程是0，但是它是用户进程。

阅读全文

Shell脚本经典之Fork炸弹

Dec 22, 2017

众所周知，bash是一款极其强大的shell，提供了强大的交互与编程功能。这样的一款shell中自然不会缺少“函数”这个元素来帮助程序进行模块化的高效开发与管理。于是产生了由于其特殊的特性，bash拥有了fork炸弹。Jaromil在2002年设计了最为精简的一个fork炸弹的实现。

阅读全文

fork

Dec 22, 2017

一、fork入门知识一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。我们来看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/* 
*  fork_test.c 
*  version 1 
*/  
#include <unistd.h>  
#include <stdio.h>   
int main ()   
{   
pid_t fpid; //fpid表示fork函数返回的值  
int count=0;  
fpid=fork();   
if (fpid < 0)   
printf("error in fork!");   
else if (fpid == 0) {  
printf("i am the child process, my process id is %d/n",getpid());   
printf("我是爹的儿子/n");//对某些人来说中文看着更直白。  
count++;  
}  
else {  
printf("i am the parent process, my process id is %d/n",getpid());   
printf("我是孩子他爹/n");  
count++;  
}  
printf("统计结果是: %d/n",count);  
return 0;  
}

运行结果是： i am the child process, my process id is 5574 我是爹的儿子统计结果是: 1 i am the parent process, my process id is 5573 我是孩子他爹统计结果是: 1 在语句fpid=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的几乎完全相同，将要执行的下一条语句都是if(fpid<0)…… 为什么两个进程的fpid不同呢，这与fork函数的特性有关。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值： 1）在父进程中，fork返回新创建子进程的进程ID； 2）在子进程中，fork返回0； 3）如果出现错误，fork返回一个负值；在fork函数执行完毕后，如果创建新进程成功，则出现两个进程，一个是子进程，一个是父进程。在子进程中，fork函数返回0，在父进程中，fork返回新创建子进程的进程ID。我们可以通过fork返回的值来判断当前进程是子进程还是父进程。引用一位网友的话来解释fpid的值为什么在父子进程中不同。“其实就相当于链表，进程形成了链表，父进程的fpid(p 意味point)指向子进程的进程id, 因为子进程没有子进程，所以其fpid为0. fork出错可能有两种原因： 1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。 2）系统内存不足，这时errno的值被设置为ENOMEM。创建新进程成功后，系统中出现两个基本完全相同的进程，这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略。每个进程都有一个独特（互不相同）的进程标识符（process ID），可以通过getpid（）函数获得，还有一个记录父进程pid的变量，可以通过getppid（）函数获得变量的值。 fork执行完毕后，出现两个进程，有人说两个进程的内容完全一样啊，怎么打印的结果不一样啊，那是因为判断条件的原因，上面列举的只是进程的代码和指令，还有变量啊。执行完fork后，进程1的变量为count=0，fpid！=0（父进程）。进程2的变量为count=0，fpid=0（子进程），这两个进程的变量都是独立的，存在不同的地址中，不是共用的，这点要注意。可以说，我们就是通过fpid来识别和操作父子进程的。还有人可能疑惑为什么不是从#include处开始复制代码的，这是因为fork是把进程当前的情况拷贝一份，执行fork时，进程已经执行完了int count=0;fork只拷贝下一个要执行的代码到新的进程。二、fork进阶知识先看一份代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* 
*  fork_test.c 
*  version 2 
*/  
#include <unistd.h>  
#include <stdio.h>  
int main(void)  
{  
int i=0;  
printf("i son/pa ppid pid  fpid/n");  
//ppid指当前进程的父进程pid  
//pid指当前进程的pid,  
//fpid指fork返回给当前进程的值  
for(i=0;i<2;i++){  
pid_t fpid=fork();  
if(fpid==0)  
printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
else  
printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
}  
return 0;  
}

运行结果是： i son/pa ppid pid fpid 0 parent 2043 3224 3225 0 child 3224 3225 0 1 parent 2043 3224 3226 1 parent 3224 3225 3227 1 child 1 3227 0 1 child 1 3226 0 这份代码比较有意思，我们来认真分析一下：第一步：在父进程中，指令执行到for循环中，i=0，接着执行fork，fork执行完后，系统中出现两个进程，分别是p3224和p3225（后面我都用pxxxx表示进程id为xxxx的进程）。可以看到父进程p3224的父进程是p2043，子进程p3225的父进程正好是p3224。我们用一个链表来表示这个关系： p2043->p3224->p3225 第一次fork后，p3224（父进程）的变量为i=0，fpid=3225（fork函数在父进程中返向子进程id），代码内容为：

1
2
3
4
5
6
7
8
for(i=0;i<2;i++){  
pid_t fpid=fork();//执行完毕，i=0，fpid=3225  
if(fpid==0)  
printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
else  
printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
}  
return 0;

p3225（子进程）的变量为i=0，fpid=0（fork函数在子进程中返回0），代码内容为：

1
2
3
4
5
6
7
8
for(i=0;i<2;i++){  
pid_t fpid=fork();//执行完毕，i=0，fpid=0  
if(fpid==0)  
printf("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
else  
printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
}  
return 0;

所以打印出结果： 0 parent 2043 3224 3225 0 child 3224 3225 0 第二步：假设父进程p3224先执行，当进入下一个循环时，i=1，接着执行fork，系统中又新增一个进程p3226，对于此时的父进程，p2043->p3224（当前进程）->p3226（被创建的子进程）。对于子进程p3225，执行完第一次循环后，i=1，接着执行fork，系统中新增一个进程p3227，对于此进程，p3224->p3225（当前进程）->p3227（被创建的子进程）。从输出可以看到p3225原来是p3224的子进程，现在变成p3227的父进程。父子是相对的，这个大家应该容易理解。只要当前进程执行了fork，该进程就变成了父进程了，就打印出了parent。所以打印出结果是： 1 parent 2043 3224 3226 1 parent 3224 3225 3227 第三步：第二步创建了两个进程p3226，p3227，这两个进程执行完printf函数后就结束了，因为这两个进程无法进入第三次循环，无法fork，该执行return 0;了，其他进程也是如此。以下是p3226，p3227打印出的结果： 1 child 1 3227 0 1 child 1 3226 0 细心的读者可能注意到p3226，p3227的父进程难道不该是p3224和p3225吗，怎么会是1呢？这里得讲到进程的创建和死亡的过程，在p3224和p3225执行完第二个循环后，main函数就该退出了，也即进程该死亡了，因为它已经做完所有事情了。p3224和p3225死亡后，p3226，p3227就没有父进程了，这在操作系统是不被允许的，所以p3226，p3227的父进程就被置为p1了，p1是永远不会死亡的，至于为什么，这里先不介绍，留到“三、fork高阶知识”讲。总结一下，这个程序执行的流程如下：这个程序最终产生了3个子进程，执行过6次printf（）函数。我们再来看一份代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* 
*  fork_test.c 
*  version 3 
*/  
#include <unistd.h>  
#include <stdio.h>  
int main(void)  
{  
int i=0;  
for(i=0;i<3;i++){  
pid_t fpid=fork();  
if(fpid==0)  
printf("son/n");  
else  
printf("father/n");  
}  
return 0;  }

它的执行结果是： father son father father father father son son father son son son father son 这里就不做详细解释了，只做一个大概的分析。 for i=0 1 2 father father father son son father son son father father son son father son 其中每一行分别代表一个进程的运行打印结果。总结一下规律，对于这种N次循环的情况，执行printf函数的次数为2（1+2+4+……+2N-1）次，创建的子进程数为1+2+4+……+2N-1个。(感谢gao_jiawei网友指出的错误，原本我的结论是“执行printf函数的次数为2（1+2+4+……+2N）次，创建的子进程数为1+2+4+……+2N ”，这是错的) 网上有人说N次循环产生2*（1+2+4+……+2N）个进程，这个说法是不对的，希望大家需要注意。数学推理见http://202.117.3.13/wordpress/?p=81（该博文的最后）。同时，大家如果想测一下一个程序中到底创建了几个子进程，最好的方法就是调用printf函数打印该进程的pid，也即调用printf(“%d/n”,getpid());或者通过printf(“+/n”);来判断产生了几个进程。有人想通过调用printf(“+”);来统计创建了几个进程，这是不妥当的。具体原因我来分析。老规矩，大家看一下下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* 
*  fork_test.c 
*  version 4
*/  
#include <unistd.h>  
#include <stdio.h>  
int main() {  
pid_t fpid;//fpid表示fork函数返回的值  
//printf("fork!");  
printf("fork!/n");  
fpid = fork();  
if (fpid < 0)  
printf("error in fork!");  
else if (fpid == 0)  
printf("I am the child process, my process id is %d/n", getpid());  
else  
printf("I am the parent process, my process id is %d/n", getpid());  
return 0;  
}

执行结果如下： fork! I am the parent process, my process id is 3361 I am the child process, my process id is 3362 如果把语句printf(“fork!/n”);注释掉，执行printf(“fork!”); 则新的程序的执行结果是： fork!I am the parent process, my process id is 3298 fork!I am the child process, my process id is 3299 程序的唯一的区别就在于一个/n回车符号，为什么结果会相差这么大呢？这就跟printf的缓冲机制有关了，printf某些内容时，操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上。但是,只要看到有/n 则会立即刷新stdout,因此就马上能够打印了。运行了printf(“fork!”)后,“fork!”仅仅被放到了缓冲里,程序运行到fork时缓冲里面的“fork!” 被子进程复制过去了。因此在子进程度stdout缓冲里面就也有了fork! 。所以,你最终看到的会是fork! 被printf了2次！！！！而运行printf(“fork! /n”)后,“fork!”被立即打印到了屏幕上,之后fork到的子进程里的stdout缓冲里不会有fork! 内容。因此你看到的结果会是fork! 被printf了1次！！！！所以说printf(“+”);不能正确地反应进程的数量。大家看了这么多可能有点疲倦吧，不过我还得贴最后一份代码来进一步分析fork函数。

1
2
3
4
5
6
7
8
9
10
 
#include <stdio.h>  
#include <unistd.h>  
int main(int argc, char* argv[])  
{  
fork();  
fork() && fork() || fork();  
fork();  
return 0;  
}

问题是不算main这个进程自身，程序到底创建了多少个进程。为了解答这个问题，我们先做一下弊，先用程序验证一下，到此有多少个进程。 [c-sharp] view plain copy #include int main(int argc, char* argv[]) { fork(); fork() && fork() || fork(); fork(); printf("+/n"); } 答案是总共20个进程，除去main进程，还有19个进程。我们再来仔细分析一下，为什么是还有19个进程。第一个fork和最后一个fork肯定是会执行的。主要在中间3个fork上，可以画一个图进行描述。这里就需要注意&&和||运算符。 A&&B，如果A=0，就没有必要继续执行&&B了；A非0，就需要继续执行&&B。 A||B，如果A非0，就没有必要继续执行||B了，A=0，就需要继续执行||B。 fork()对于父进程和子进程的返回值是不同的，按照上面的A&&B和A||B的分支进行画图，可以得出5个分支。加上前面的fork和最后的fork，总共4*5=20个进程，除去main主进程，就是19个进程了。一、fork()函数在操作系统的基本概念中进程是程序的一次执行，且是拥有资源的最小单位和调度单位（在引入线程的操作系统中，线程是最小的调度单位）。在Linux系统中创建进程有两种方式：一是由操作系统创建，二是由父进程创建进程（通常为子进程）。系统调用函数fork()是创建一个新进程的唯一方式，当然vfork()也可以创建进程，但是实际上其还是调用了fork()函数。fork()函数是Linux系统中一个比较特殊的函数，其一次调用会有两个返回值，下面是fork()函数的声明： #include // On success, The PID of the process is returned in the parent, and 0 is returned in the child. On failure, // -1 is returned in the parent, no child process is created, and errno is set appropriately. pid_t fork (void);当程序调用fork()函数并返回成功之后，程序就将变成两个进程，调用fork()者为父进程，后来生成者为子进程。这两个进程将执行相同的程序文本，但却各自拥有不同的栈段、数据段以及堆栈拷贝。子进程的栈、数据以及栈段开始时是父进程内存相应各部分的完全拷贝，因此它们互不影响。从性能方面考虑，父进程到子进程的数据拷贝并不是创建时就拷贝了的，而是采用了写时拷贝（copy-on -write）技术来处理。调用fork()之后，父进程与子进程的执行顺序是我们无法确定的（即调度进程使用CPU），意识到这一点极为重要，因为在一些设计不好的程序中会导致资源竞争，从而出现不可预知的问题。下图为写时拷贝技术处理前后的示意图：在Linux系统中，常常存在许多对文件的操作，fork()的执行将会对文件操作带来一些小麻烦。由于子进程会将父进程的大多数数据拷贝一份，这样在文件操作中就意味着子进程会获得父进程所有文件描述符的副本，这些副本的创建方式类似于dup()函数调用，因此父、子进程中对应的文件描述符均指向相同的打开的文件句柄，而且打开的文件句柄包含着当前文件的偏移量以及文件状态标志，所以在父子进程中处理文件时要考虑这种情况，以避免文件内容出现混乱或者别的问题。下图为执行fork()调用后文件描述符的相关处理及其变化：二、线程与进程类似，线程（thread）是允许应用程序并发执行多个任务的一种机制。一个进程中可以包含多个线程，同一个程序中的所有线程均会独立执行，且共享同一份全局内存区域，其中包括初始化数据段（initialized data），未初始化数据段（uninitialized data），以及堆内存段（heap segment）。在多处理器环境下，多个线程可以同时执行，如果线程数超过了CPU的个数，那么每个线程的执行顺序将是无法确定的，因此对于一些全局共享数据据需要使用同步机制来确保其的正确性。在系统中，线程也是稀缺资源，一个进程能同时创建多少个线程这取决于地址空间的大小和内核参数，一台机器可以同时并发运行多少个线程也受限于CPU的数目。在进行程序设计时，我们应该精心规划线程的个数，特别是根据机器CPU的数目来设置工作线程的数目，并为关键任务保留足够的计算资源。如果你设计的程序在背地里启动了额外的线程来执行任务，那这也属于资源规划漏算的情况，从而影响关键任务的执行，最终导致无法达到预期的性能。很多程序中都存在全局对象，这些全局对象的初始化工作都是在进入main()函数之前进行的，为了能保证全局对象的安全初始化（按顺序的），因此在程序进入main()函数之前应该避免线程的创建，从而杜绝未知错误的发生。三、fork()与多线程在程序中fork()与多线程的协作性很差，这是POSIX系列操作系统的历史包袱。因为长期以来程序都是单线程的，fork()运转正常。当20世纪90年代初期引入线程之后，fork()的适用范围就大为缩小了。在多线程执行的情况下调用fork()函数，仅会将发起调用的线程复制到子进程中。（子进程中该线程的ID与父进程中发起fork()调用的线程ID是一样的，因此，线程ID相同的情况有时我们需要做特殊的处理。）也就是说不能同时创建出于父进程一样多线程的子进程。其他线程均在子进程中立即停止并消失，并且不会为这些线程调用清理函数以及针对线程局部存储变量的析构函数。这将导致下列一些问题:

虽然只将发起fork()调用的线程复制到子进程中，但全局变量的状态以及所有的pthreads对象（如互斥量、条件变量等）都会在子进程中得以保留，这就造成一个危险的局面。例如：一个线程在fork()被调用前锁定了某个互斥量，且对某个全局变量的更新也做到了一半，此时fork()被调用，所有数据及状态被拷贝到子进程中，那么子进程中对该互斥量就无法解锁（因为其并非该互斥量的属主），如果再试图锁定该互斥量就会导致死锁，这是多线程编程中最不愿意看到的情况。同时，全局变量的状态也可能处于不一致的状态，因为对其更新的操作只做到了一半对应的线程就消失了。fork()函数被调用之后，子进程就相当于处于signal handler之中，此时就不能调用线程安全的函数（用锁机制实现安全的函数），除非函数是可重入的，而只能调用异步信号安全（async-signal-safe）的函数。fork()之后，子进程不能调用： malloc(3)。因为malloc()在访问全局状态时会加锁。任何可能分配或释放内存的函数，包括new、map::insert()、snprintf() …… 任何pthreads函数。你不能用pthread_cond_signal()去通知父进程，只能通过读写pipe(2)来同步。 printf()系列函数，因为其他线程可能恰好持有stdout/stderr的锁。除了man 7 signal中明确列出的“signal安全”函数之外的任何函数。
因为并未执行清理函数和针对线程局部存储数据的析构函数，所以多线程情况下可能会导致子进程的内存泄露。另外，子进程中的线程可能无法访问（父进程中）由其他线程所创建的线程局部存储变量，因为（子进程）没有任何相应的引用指针。由于这些问题，推荐在多线程程序中调用fork()的唯一情况是：其后立即调用exec()函数执行另一个程序，彻底隔断子进程与父进程的关系。由新的进程覆盖掉原有的内存，使得子进程中的所有pthreads对象消失。对于那些必须执行fork()，而其后又无exec()紧随其后的程序来说，pthreads API提供了一种机制：fork()处理函数。利用函数pthread_atfork()来创建fork()处理函数。当一个多线程程序 fork(2) 之后 fork(2) 程序创建了当前进程的副本，包括所有的内存页，还有打开文件的句柄等。所有这些工作对于一个 UNIX 程序员来说，都不陌生。子进程和父进程之间一个非常重要的区别是，子进程只有一个线程。一个程序员也许不希望复制包括所有线程在内的整个进程，而且，这也容易出问题。想想：所有的线程都因为一个系统调用（这里指的是 fork(2)）而被暂停（Suspended）。所以，fork(2) 仅仅会复制调用它的那个线程。那么（当前的实现方式）会遇到什么问题呢？关键部分，互斥锁（mutex）这种做法一个潜在的问题是，当 fork(2) 被调用的时候，某些线程可以正在执行关键部分的代码，在互斥锁的保护下对数据进行非原子操作。在子进程里，这些线程消失了，只留下一些修改到一半却没有可能“修正”的数据，不可能去确定 “其他线程正在做什么”和“怎么做可以保持数据一致”。此外，那些（复制过来的互斥锁）的状态是未定义，他们也许不能用（unusable），除非子进程调用 pthread_mutex_init() 去重置他们的状态为一个可用的值。它（ pthread_mutex_init() ）的实现取决于互斥锁在 fork(2) 执行之后的具体行为。在我的 Linux 机器上，被锁定（locked）的互斥锁的状态（重置之后）在子进程中仍是（locked）。库函数上面关于互斥锁和关键代码的问题，又引出了另一个潜在的问题。理论上，写一些在多线程上运行并且在调用 fork(2) 之后不会出错的代码，是可行的。但是，实践中，却有一个问题──库函数。你不能确认你正在用的库函数不会使用到全局数据。即使它（用到的库函数）是线程安全的，它也可能是通过在内部使用互斥锁来达到目的。你永远无法确认。即使系统的线程安全的库函数，也可能使用了互斥锁。一个潜在的例子是，malloc() 函数，至少在我的多线程程序里，内部使用了锁。所以，在其他线程调用 malloc() 的时候调用 fork(2) 是不安全的！一般来说，我们应该怎么做呢？在一个多线程程序调用 fork(2) 之后，你只应该调用异步安全（async-safe）的函数（在signal(7) http://www.kernel.org/doc/man-pages/online/pages/man7/signal.7.html 列出）。这个列表与你在一个消息回调函数（signal hanlder）里面可以调用的函数的列表是相似的，而原因也相似：在两种情况下，在调用一个函数时，线程会被终止（原文为带引号的interrupted，由于该线程在新的子进程里已经不存在，所以翻译为终止）。这里是几个在我的系统里，使用类内部锁的函数，仅仅是想让你知道，几乎没有东西是安全的：* malloc()* stdio的函数，比如printf() - 这是标准要求的* syslog()execve() 和文件句柄似乎使用 execve(2) 来启动一个需要调用fork(2)的多线程程序，是你唯一明智的选择。但即使这样做，也还有一点不足。当调用execve(2) 时，需要注意的是，打开的文件句柄还将维持打开的状态（在新的子进程中 —— 译者Xorcerer），可以继续被读取和写入数据。你在调用 execve(2) 之前打开了一个你不希望在新的子进程里被使用的文件，问题就出现了。这甚至会产生安全方便的问题。对此，有一个解决方案，你必须使用 fcntl(2) 来对每一个打开的文件句柄设施 FD_CLOEXEC 标记，这样，它们会在新的进程中被自动关闭。不幸的是，在多线程程序里，这没那么简单。当我们使用 fcntl(2) 去设置 FD_CLOEXEC 时，会有一个间隙： fd = open (“file”, O_RDWR | O_CREAT | O_TRUNC,0600); if(fd <0){
perror (“open()”); return0;
} fcntl (fd, F_SETFD, FD_CLOEXEC);
如果另一个线程正好在当前线程执行 open(2) 之后 fcntl(2) 之前调用 fork(2) 和 execve(2) ，那么得到的新进程将获得这个文件句柄的副本。这不是我们想要的。一个解决方案已经随着新标准（如：POSIX.1-2008）和新的 Linux 内核（2.6.23以及之后的版本）到来了。我们现在可以在 open(2) 使用 O_CLOEXEC 标记，所以，“开打文件与设置 FD_CLOEXEC” 已经成为了一个原子操作。除了使用 open(2) 之外，还有其他的创建文件句柄的方法：使用 dup(2) 复制它们，使用 socket(2) 创建socket，等。所有这些函数现在都有一个相似的标记如O_CLOEXEC或者其他更新的版本（其中某些函数，如dup2(2)没有一个用于标记位的参数，所以dup3(2)为此产生了）。值得提到的一点是同样的东西在单线程程序里也可能发生，如果它在同一个消息处理函数（singal handler）中使用 fork(2) 和 execve(2) 。这个操作是完全合法的，因为这两个函数是异步安全并且允许在消息处理函数中被调用，但是问题是这个程序也许会在调用 open(2) 和 fcntl(2) 之间时，被中断。想知道更多关于设置 FD_CLOEXEC 新API的信息，请参考《Ulrich Drepper’s blog: Secure File Descriptor Handling》。一个有用的系统函数：pthread_atfork() 其中一个尝试解决多线程程序中使用 fork(2) 的问题的函数是 pthread_atfork()。它拥有如下原型： int pthread_atfork(void (prepare)(void), void (parent)(void), void (*child)(void)); 它允许指定在 fork 被调用时的处理函数：prepare 新进程产生之前被调用。 parent 新进程产生之后在父进程被调用。 child 新进程产生之后，在子进程被调用。调用的目的是在 fork(2) 被调用时，处理多线程程序的关键部分（本文开始部分提及）。一个常见的场景时在 prepare 处理函数中加锁，在 parent 处理函数解锁和在 child 处理函数重新初始化锁。

阅读全文

vfs

Dec 7, 2017

在Linux中，文件系统主要分为下面3种：（1）基于磁盘的文件系统（Disk-based Filesystem) 是在非易失介质上存储文件的经典方法，用以在多次会话之间保持文件的内容。如Ext2/3/4， Reiserfs, FAT等。（2）虚拟文件系统（Virtual Filesystem）在内核中生成，是一种用户应用程序与内核通信的方法。如proc，它不许要在任何类的硬件设备上分配存储空间，所有的信息都是动态在内存中开辟和存储。（3）网络文件系统（Network Filesystem）是基于磁盘的文件系统和虚拟文件系统之间的折中。这种文件系统允许访问另一台计算机上的数据，该计算机通过网络连接到本地计算机。在这种情况下，数据实际上存储在一个不同系统的硬件设备上。由于VFS抽象层的存在，用户空间进程不会看到本地文件系统与网络文件系统之间的区别。

VFS的模型与结构 VFS不仅为文件系统提供了方法和抽象，还支持文件系统中对象（或文件）的统一视图。并非每一种文件系统都支持VFS中的所有抽象，如FAT，因为其设计没有考虑到此类对象。定义一个最小的通用模型，来支持内核中所有文件系统都实现的那些功能，这是不实际的。因为这样会损失许多本质性的功能特性，或者导致这些特性只能通过特定文件系统的路径访问。 VFS的方案完全相反：提供一种结构模型，包含了一个强大文件系统所具备的所有组件。但该模型只存在于虚拟中，必须使用各种对象和函数指针与每种文件系统适配。所有文件系统的实现都必须提供与VFS定义的结构配合的例程，以弥合两种视图之间的差异。 VFS是由基于经典文件系统的结构衍化而来，所以VFS与Ext类文件系统类似，从而在处理Ext类文件系统的时候，Ext和VFS之间的转换，几乎不会损失时间。

阅读全文

脚本输出带颜色文字

Sep 14, 2017

文本终端的颜色可以使用“ANSI非常规字符序列”来生成。举例：　　　　echo -e “\033[44;37;5m ME \033[0m COOL” 　　　　以上命令设置作用如下：背景色为蓝色，前景色为白色，字体闪烁，输出字符“ME”，然后重新设置屏幕到缺省设置，输出字符 “COOL”。“e”是命令 echo 的一个可选项，它用于激活特殊字符的解析器。“\033”引导非常规字符序列。“m”意味着设置属性然后结束非常规字符序列，这个例子里真正有效的字符是 “44;37;5” 和“0”。修改“44;37;5”可以生成不同颜色的组合，数值和编码的前后顺序没有关系。可以选择的编码如下所示：编码颜色/动作 0 重新设置属性到缺省设置 1 设置粗体 2 设置一半亮度（模拟彩色显示器的颜色） 4 设置下划线（模拟彩色显示器的颜色） 5 设置闪烁 7 设置反向图象 22 设置一般密度 24 关闭下划线 25 关闭闪烁 27 关闭反向图象 30 设置黑色前景 31 设置红色前景 32 设置绿色前景 33 设置棕色前景 34 设置蓝色前景 35 设置紫色前景 36 设置青色前景 37 设置白色前景 38 在缺省的前景颜色上设置下划线 39 在缺省的前景颜色上关闭下划线 40 设置黑色背景 41 设置红色背景 42 设置绿色背景 43 设置棕色背景 44 设置蓝色背景 45 设置紫色背景 46 设置青色背景 47 设置白色背景 49 设置缺省黑色背景　例如：在编译脚本文件时，对服务启动完成后的OK字符串设置成绿色除了echo还有printf也可以显示颜色，这里就不多说了，用法一样的。那么开始用php调用吧。

阅读全文

linux

curl 各阶段耗时

指针的最后三位永远是0

非阻塞套接字

vimmap

process

vi /etc/ld.so.preload

nsenter

net-tools

ifconfig

ip

ping

completion bash自动补全

route 路由表

rcfile

netns mac

iproute2mac IProute2

Makefile 增量编译

shell =~

nf_conntrack

Cockpit

echo 生成 md5多换行符

bash

dnsutils bind-tools

ulimit

nginx惊群问题

htop

iptables自定义链

dns

Shell去除空格和空行的方法

route print netstat nr

pfctl

Cgroup

局部变量及local命令

查看Linux系统架构类型的5条常用命令

http_proxy

env 环境变量存哪里

The Linux Programming Interface

硬链接软连接

ip 伪造

wget apt-get yum rpm 区别

iTerm2保持ssh连接不断开

wss RSS/VSS/USS/PSS

shell 生成 UUID

iptables 实现负载均衡

tso

tgw LVS

jp2a Textaizer 用ASCII字符拼成图案

dd

bin目录区别

SIP

split

Mac使用Launchd命令行lauchctl

Bash中如何判断一个命令是否存在

iptables 限制连接数

chisel lldb

set

解决 ln -s 软链接产生的Too many levels of symbolic links错误

libfaketime

ld_preload

grep 正则表达式

cURL与wget的区别

expand_aliases Bash非交互模式下alias不能使用

log

inode

文件IO 文件位置偏移量

CodeViz

cmake

tcpdump

shell 常用命令

Curl命令的data data-ascii data-binary data-raw和data-urlencode选项

dsl

正则表达式 分组匹配

proto3

prometheus

让Linux终端中执行的程序在后台运行 从前台变到后台

Supervisor

zabbix 监控系统

proc 文件系统 系统监控

监控知识体系

正则表达式分组匹配

让Linux终端中执行的程序在后台运行从前台变到后台

proc 文件系统系统监控

core 文件调试追踪 Segmentation fault 11

Epoll的本质内部实现原理