the-linux-programming-interface

• 广义上来说,包括整个command-line解析器, GUI, 文件管理等等所有的软件
• 狭义上来说,就是管理和分配计算机资源(比如CPU, RAM, 设备等等)的系统

Linux kernel通常是在/boot/vmlinuz,是一个压缩过的可执行文件,其意义是
virtual memory Linux Zipped binary

• Bourne shell (sh): 最早的shell
• C shell (csh): 和sh不兼容, 仅提供了些新功能
• Korn shell (ksh): 引入了csh的新功能,并且和sh兼容!
• Bourne again shell (bash): GNU版本的Bourne shell, 最广泛应用,在很多系统中 sh其实就是bash的soft link

• File types: 也叫regular或者plain文件
• Directories and links:
  1. 文件夹其实就是link的一个集合.
  2. 所谓link其实就是文件名和"文件的位置"的组合. 一个"文件位置"可能有多个文件名
  3. "文件位置"也有可能是文件夹.
  4. 文件夹里面里面至少也有两个link: "."和".."
• Symbolic links:symbolic link是一种非常特殊的link:
  1. link里面的配置是"文件名" + "文件位置"
  2. symbolic link里面的配置是"文件名" + "文件位置" (而文件位置所在的硬盘空 间里面写了一个另外一个'文件名'), 这个后面的"文件名"就叫target
• device file
• pipe file
• socket file

• pipe
• socket
• FIFO

• source code: 人类可以理解的文本
• binary machine-language: 机器可以理解的格式

• 把program导入virtual memory
• 为program的变量分配内存空间
• 建立一系列的bookkeeping data structure来记录process的信息, 比如:
  1. process ID
  2. termination status
  3. user ID
  4. group ID

• file mapping: 就是把一个文件mapping到virtual address space
• anonymous mapping: 没有对应文件,只不过是创建内容为0的内存page而已

• static library:
  1. 早期的object library都是static的. 使用static library的program最终会把 static library里面的响应代码编译到自己的binary里面
  2. 每个process都存一份static library到自己的binary里面是非常浪费硬盘空间, 而且会浪费内存空间:特别是多个process都调用了同一份static library代码,它 们都会要求一份内存地址.那么内存里面就由多份一样的代码.
  3. 如果library function做了更改,那么所有想使用最新版本library的程序都要重 新编译.
• shared library:
  1. 和static library不同的是, shared library会在编译的时候在executable里面 标明位置,而不会拷贝这段代码
  2. 在runtime,只要有一份library的代码运行,那么用到它的process都可以share, 这儿是shared名字的来历.
  3. 这样一来library升级的时候,使用这些library的代码也不需要进行重新编译.

• signals: 声明某件事情出现
• pipes(对shell用户来说,就是'|') and FIFO: 用处就是在process直接传递data
• sockets: 可以跨机器,在process直接传递data
• file locking: 允许process锁住文件的一部分,防止其他process更改
• message queues: 在process之间交换数据
• semaphores: 是用来"同步"多个process操作的
• shared memory: 让多个process共享一块内存空间.当一个process更改这个内存空间 内容的时候,其他process也都能看到

• real time:在Unix-like系统中,就是计算从1970年1月1号开始的秒数.当然这个秒数 是根据你的时区不同而不同的.之所以选择这个时间,是因为这个是Unix系统诞生附近 的日子
• process time: 也叫CPU time,就是一个process从开始运行后使用的CPU时间,分成 两个部分:
  1. system CPU time: 就是kernel 为process工作的cpu时间
  2. user CPU time: 用户自己执行使用的cpu时间

• 创建新的process
• 访问IO
• 创建PIPE

• system call会更改processor的state, 从user mode => kernel mode, 这样一来CPU 才能访问protected kernel memory(就是读取这些地址的数据到processor里面)
• system call的数目固定,每个system call都被分配了一个数字
• 每个system call都有一系列为这次操作准备的argument

• application应用想调用system call,都是通过调用c语言写成的包裹system call的 所谓"wrapper function"
• 我们调用wrapper function的时候,是将argument通过stack压栈传入的,但是system call使用这些参赛的时候,是希望它们在相应的寄存器里面的.所以wrapper就负责将 参赛从stack拷贝到相应的寄存器.
• 对于kernel来说,system call的不同体现在它们的"ID",也就是system call number 不一样,而触发的方式一样.所以wrapper负责把system call number写入到%eax里面 然后"触发"system call
• 这个"触发"就是machine instruction(int 0x80, int是intrrupt的缩写,是一个机 器语言语句),这其实是一个软件中断(software interrupt), 中断分两种:
  1. 硬件中断(hardware interrupt)是一种在任意时刻都可能发生的事情,比如我们 从键盘输入数据给计算机. 计算机是无法判断这些中断是什么时候来的
  2. 软件中断(software interrupt)其实是计算机"自己发给自己"的中断. 其实就是 一种"逃避"的手段,比如上一条指令是中断的话,下一条指令就没法执行了,因为 遇到了中断,当前的环境处理不了.要"跳"到另外的地方去执行,这个"跳到其他地方" 其实就是system call想要的.因为代码再其他地方
• 在"跳到其他地方执行"的同时,也会进行如下操作.
  1. 将cpu从user mode转化成kernel mode
  2. 执行system trap vector里面0x80处的代码. (换个角度讲, Linux只不过选择了 x80作为system call的exception 入口地址, 其实完全可以写成int 0x90, 然后 初始化system trap vector的时候,在x90处布置相应的handler)
• 这个system trap vector是在机器初始化的时候被填满的, 在vector的第128(0x80) 的位置,填的正是system_call()的代码地址, system_call主要做的工作是:
  1. 将cpu当前寄存器的值都存入到kernel stack
  2. 检查system call number(也就是存到%eax里面的,区别不同system call的序列 号)是否合法
  3. 根据system call number的不同,查阅sys_call_table后调用相应的routine.然后 调用相应的routine.
  4. 把routine返回的返回值写入到stack,并且"恢复"刚才保存的所有的cpu原来的寄 存器值
  5. 通过和int相对应的机器语句iret, 返回wrapper function,同时cpu从kernel mode 变回user mode
• 通常来说,system call routine在出现错误的时候,会返回负数,比如-6. 而wrapper 作为c libray,只是会设置返回值为-1来表示失败(0表示成功),失败的原因则是把system call routine的负数取正,写入到errno里面.
• 上面的这一系列讨论,其实暗示了我们,system call其实在调用的时候,是有一定的 性能损耗的.比如调用1千万次的c语言函数返回integer需要0.11秒,而调用system call getppid()1千万次则需要2.2秒!

• 内部不调用system call(也就是system call wrapper)的,比如字符串相关函数
• 内部调用system call(也就是system call wrapper),但是比system call来的更易 于使用(more caller-friendly)比如malloc()和free()就比system call brk()好用

• fd = open(pathname, flags, mode): 打开(没有的情况下也有可能创建)一个文件
• numread = read(fd, buffer, count): 最多读取count数目的内容到buffer,真正读 取的数目写入numread
• numwritten = write(fd, buffer, count): 和读取相反的写入操作
• status = close(fd): 和打开相反的关闭操作.

• fd是文件描述符
• offset是从whence开始的距离
• whence有三种值:
  1. SEEK_SET: 从文件头开始
  2. SEEK_CUR: 从刚才的kernel记录的offset开始
  3. SEEK_END: 从文件末尾开始

• FIFO
• pipe
• socket
• terminal

• access mode
• status flag

• 这个file descriptor的 controlling flag
• 一个指向open file handler的指针

• current file offset(read(), write()会更新这个offset, 而lseek()可以设置任意的值)
• status flag:打开文件的时候设置的一些文件特性
• access mode: 可读,可写,还是即可读又可写
• signal-driven I/O的设置
• 一个指向i-node object的指针

• file type and permission
• 指向文件拥有的所有的lock的列表
• file 的一系列属性

• 在process A里面, descriptor 1和20都指向了同一个open file,这个可以通过调用 dup(), dup2(), fcntl()来实现
• 同样的process A里面的fd2和process B里面的fd2都指向了同一个open file handle 这种情况在fork的时候就会出现(还记得stdin stdout, stderr么)
• 再看process A的fd0和process B的fd3指向了不同的open file handle. 但是这两个 file handle指向了同一个i-node. 在不同进程中打开同一个文件,会出现上述情况.

• file descriptor自己的flag(比如close-on-exec flag是自己的)即便是fd被复制(通 过dup()等),但是更改其中一个fd的fd flag不会影响另外一个
• 但是open file的flag都是fd之间共享的,通过一个fd更改这些flag是会影响到其他 fd的,比如:
  • access mode (O_WRONLY)
  • status flag (O_SYNC)
  • offset (write(), read(), lseek()等可以更改)

• stdout fd1肯定是指向open file handle for output.txt的(因为`>`指定了这个文件)
• 我们使用dup2()命令把stderr fd2也指向open file handle for output.txt

  #include <unistd.h>
  dup2(1, 2);
  

• dup: 只能保证用"尽可能小"的fd
• dup2: 可以先关闭newfd已有open file handle,然后重新联系就是先close然后dup
• fcntl: 更灵活的dup,不能自己close

• 一个process里面的thread都是共享fd的,也就共享了open file里面的current file offset.
• 多个thread使用pread()或者pwrite()就可以不用担心相互打扰,而产生race condition 了(如果在两个thread里面使用lseek(),则肯定会出现race condition)

• 如果文件不能被马上打开,那么open()就返回error,而不是blocking在那里等待文件 相应.
• 一旦通过这次open()打开以后,这个open file handle就拥有了nonblocking属性,所 有在这个open file handle所指向的fd上做的其他IO操作,都是nonblocking的.

• device
• pipe
• FIFO
• socket

• 还记得xargs么,它能把管道前面计算的值放到最后

  vagrant@vagrant:~$ diff t1.txt t2.txt
  10a11
  > AGAIN
  vagrant@vagrant:~$ ls t2.txt | xargs diff t1.txt
  10a11
  > AGAIN
  

• 如果我们想比较的是diff t2.txt t1.txt 而不是diff t1.txt t2.txt怎么办呢,bash 有个特殊的符号叫做"-",代表standard output

  vagrant@vagrant:~$ cat t2.txt | diff  t1.txt -
  10a11
  > AGAIN
  vagrant@vagrant:~$ cat t2.txt | diff  - t1.txt
  11d10
  < AGAIN
  

• 但是"-"广泛的使用于bash命令行,有很多解释,很容易出现解析失误的情况,这个时候 /dev/fd/FD_NUM就起作用了(但是比起xargs还是有差距,xargs是逐个的把结果提供 给后面的命令)

  vagrant@vagrant:~$ cat t2.txt | diff  - t1.txt
  11d10
  < AGAIN
  vagrant@vagrant:~$ cat t2.txt | diff  /dev/fd/0 t1.txt
  11d10
  < AGAIN
  

• mkstemp的参数template是会更改的,所以要使用character array

  #include <stdlib.h>
  int mkstemp(char *template);
  /* Returns file descriptor on success, or –1 on error */
  

• tmpfile在打开文件的时候,设置了O_EXCL flag, 这个flag能够保证临时文件名不可 能存在, 也不会和'其他process同时创建的文件'重名.

• Binary format identification: 每个program都会采用一种meta格式,好让kernel "有章可循"的解析文件,常见的类型有:
  1. assembler output (如今不常用)
  2. Common Object File Format(如今不常用)
  3. Executable and Linking Format(ELF). (当下默认的标准)
• Machine-language instructions: 机器语言其实就是汇编,程序的逻辑都是这部分 控制
• Program entry-pint address: 说明了文件从"汇编语言"的何处开始运行
• Data: 用来初始化变量的数字,以及literal constant(比如字符串)
• Symbol and relocation tables: 标记function, variable的位置和名字.这些信息 对于debug非常有用
• Shared-library and dynamic-linking information:列出需要链接的"动态链接库" 和linker的地址
• Other information: 还有其他一些信息

A process is an abstract entity, defined by the kernel, to which
system resources are allocated in order to execute a program

• program code
• program code使用的variable
• 一系列表示process状态的kernel data,比如:
  1. virutal memory table
  2. table of open file descriptors
  3. signal delivery and handling
  4. process resource usage and limit
  5. current working directory

• 对于32bit系统来说,最大就是32768了,但是你可以选择一个较小的其他数目
• 对于64bit系统来说,最大是2**22(大概是4百万)

• text segment: 是保存着program里面的machine instruction. 这个segment是被标 记为read-only的,所以一个process不会不小心更改了"运行'自己的指令序列.因为 多个program可以多次运行成多个process,所以其实每个process里面的text segment 都是一样的,所以可以把一份program code的copy映射到多个process的virtual address space
• initialized data segment:保留着"代码中明确初始化了的"global 和 static的变 量,这个也是从program里面读取的.
• uninitialized data segment: 保留着"代码中没有明确初始化的"global 和 static 变量.这个不是从program里面读取的,program里面也没有.因为没有初始化,所以值都 是为0,从而program也不需要记录他们的值和位置.所以只有program在runtime变成 process的时候才真正分配"内存"给它们. 历史上这个区域叫做bss segment (block started by symbol)
• stack segment: stack是一种动态"生长"和"缩退"的segment. 每当为一个function "自动"分配虚拟内存的时候,其参数,local variable, 返回值也会"紧接着"分配虚拟 内存.当这个function调用完成后,这些内存又"自动"释放. stack segment是从"高 地址"向"低地址"生长的
• heap segment: 是在运行的时候,动态分配的内存. heap segment是从"低地址"向"高 地址生长"的,生长的终点就是stack segment的顶点.换句话说stack和heap是公用地 址的(相对生长),当然这个地址很大.

• 这些library function返回的pointer必须指向data或者bss的内存地址,因为只有这 两块地址是不跟随function消失而消失,同时也是可写的.
• 一个library function返回了'指向static分配的内存pointer'的话,就必然无法做到 reentrant(可重入). 因为static分配内存可能会被下一次的程序调用所覆盖

• spatial locality: program有很大可能访问"刚才访问的内存"附近的内存
• temporal locality: program有很大可能访问"刚才访问过的内存"

• virtual memory就是把program使用的内存分成一个一个的小块(叫做page),同时RAM 也会把自己分成和page大小相同的单位,叫做page frame
• 在运行的时候只有一小部分的page是真正放在page frame里面的
• 如果process用到了一个page,但是这个page不在page frame里面,那么会触发page fault 一旦出现page fault,kernel就会停止当前的process运行,待它把相应内存page放入 page frame以后,再继续运行刚才的process

• stack向下(低地址)生长的时候,到了一个自己原来从来没到过的低地址.(stack可能 先向下生长,然后回退)
• 通过system call brk(), sbrk(), malloc分配heap地址,并且把heap的最高地址program break提高到原来没到过的高地址(heap可能先向上生长,然后回退)
• System V shared memory合并和分离的时候
• 当使用mmap()和munmap()被调用的时候.

• process之间相互隔离,process和kernel之间相互隔离.因为不同的process的page table entry指向不同的物理内存就可以做到
• 有些时候,process还希望共享一些内存,这个时候,让不同的process的page table entry指向相同的物理内存,就做到了share内存.通常需要share的情况有如下:
  1. 多个process运行同一个program的时候,text segment可以share(而且是只读的)
  2. 多个process之间相互通过调用shmget()和mmap()system call分享内存进行通信 (其实也是Linux处理线程的方法)的时候.
• 内存的保护机制也变的容易,不同的process有不同的page table entry指向同一块 page fragment.可以在page table entry里面设置属性,那么对同一个RAM里面的内 容有些process可读,有些process可写就做到了.
• 编程人员和编译器链接器不必考虑program在内存中的物理映射了
• 因为只有一小部分program在内存里面,那么我们可以在内存中存更多的进程, 进程 使用内存的总量可以超过物理RAM大小.因为总有多个process在运行,计算机CPU的利 用率也就提高了.

• function arguments and local variable: 调用一个function的时候.都会有些参数 而且函数内部会有一些local variable(在c语言里面local variable也叫automatic variable,因为它是自动分配内存的),这些都会自动被分配到stack frame里面.当然 了这些参数和local变量会随着函数调用的完成而丢失
• call linkage information: 每个function都会使用一些CPU寄存器(比如program counter,指向下一条机器指令),每当一个function调用另外一个function的时候,当 前所有寄存器的值都要保存起来(到stack里面),因为被调用的function返回的时候, 我们能restore寄存器原来的值.比如我们前面main调用doCalc(),再调用square()的 例子,其stack如下

               +----------------+
               | Frame for      |
               |  main()        |
               +----------------+
               | Frame for      |
               |  doCalc()      |
  stack  --->  +----------------+
  pointer      | Frame for      |
               |  square()      |
               +-------+--------+
                       |
                       | Direction of
                       | stack growth
                       V
  

• 对于bash来说设置环境变量如下(移除是unset):

  $ export SHELL=/bin/bash
  

• c shell的设置方式如下(移除是unsetenv):

  setenv SHELL /bin/bash
  

• setjmp第一次返回返回值为0
• setjmp给longjmp触发返回,返回值为longjmp设置的val(此val设置0无效,会自动设置 为1,因为setjmp第一次就返回0)

• alloca()通常都是以inline code实现的
• alloca()的任务简单,只是更改stack pointer, 而malloc则要维护一个block free list

mtk:x:1000:100:Michael Kerrisk:/home/mtk:/bin/bash

• mtk: 也就是用户名,登录的时候,就是使用用户名,我们的ls加上参数-l就会显示某 个文件属于哪个用户名
• x: 也就是encrypted password:一般来说这里会有13个字符的加密密码,但是由于现 在多采用"shadow password",也就是把加密密码放到/etc/shadow里面去.所以这里 就使用一个x作为"占位符". 如果/etc/shadow对应的密码为空,那么这个x也是空,也 就意味着用户可以不使用密码登录
• 1000:第一个1000是用户的UID,如果这个数字为0的话,那么意味着是超级用户(通常 是root). Linux2.2以前UID是使用了16位存储,所以最多用户为65535,Linux2.6开始 使用32位存储,则最大用户数则多的多了
• 1000:第二个1000是用户的GID,这个Group是用户序列的"第一个"group,也叫primary group
• Michael Kerrisk: 这个域叫comment,其实就是对username的description
• /home/mtk:这个是home文件夹,登录以后,这个域就变成HOME环境变量
• /bin/bash:这个是默认的shell,登录以后,这个域变成SHELL环境变量

       因为基本上所有的用户都有权限读取/etc/passwd,权限较低的用户可
       以读取/etc/passwd里面权限较高用户的encrypted password,然后采
       取"撞库"的方法猜测高权限用户的密码

root:$6$5/5YIHUd$vYsjnBgYda/v8BaFlzTnM9CmGxEbgTvuZmiz0whhIY8/
GGndpB7W8Dar0/30MLL3IGGrjpXrzohGltJMOFVV//:16554:0:99999:7:::

• /etc/passwd里面存储的,是以用户为index,会列出用户的primary group

  vagrant@vagrant:~$ cat /etc/passwd
  root:x:0:0:root:/root:/bin/bash
  vagrant:x:1000:1000:vagrant,,,:/home/vagrant:/bin/bash
  

• /etc/group里面存储的是以group为index. 会列出组的所有成员(当然在/etc/passwd 里面列举过的就不再列举了,比如`vagrant:x:1000:`这一行后面就没有其他用户.

  vagrant@vagrant:~$ cat /etc/group
  adm:x:4:syslog,vagrant
  cdrom:x:24:vagrant,hfeng
  sudo:x:27:vagrant
  dip:x:30:vagrant
  plugdev:x:46:vagrant
  vagrant:x:1000:
  lpadmin:x:117:vagrant
  sambashare:x:118:vagrant
  docker:x:998:vagrant,hfeng
  

• docker:是groupname
• x:原来是密码,现在存在/etc/gshadow
• 998:就是GID,一般来说,GID为0 group root的ID
• vagrant,hfeng: 剩下的就是username 列表了.

mtk:x:1000:100:Michael Kerrisk:/home/mtk:/bin/bash

• effective user ID
• effective group ID
• supplementry group ID

• 调用system call, 这个可以在process启动以后用来改变自己的effective user & group ID

  int setuid(uid_t uid);
  int setgid(gid_t gid);
  

• 使用set-user-ID和set-group-ID,这个是要在process启动之前就得设置

• passwd, 我们的普通用户也需要更改密码, 但是改密码是root级别的权限
• su, 我们普通用户要临时切换到其他用户shell, 但是切换用户是root级别的权限

       把effective User ID和effective Group ID的值都复制一遍存下来.

• real UID&GID
• saved UID&GID

• setfsuid()
• setfsgid()

• User CPU time: 在user mode流逝的时间
• System CPU time: 在kernel mode流逝的时间

• user就是user cpu time.
• sys就是system cpu time.
• real是指从开始到结束用了多少时间,就是我们这一章最开始讲的real time.而user+sys 的时间其实有可能超过real, 因为会有多个线程同时运行,cpu时间用的多于real time

• _POSIX_MQ_PRIO_MAX(值为32): SUSv3设置队列的级别最多为32个. 但是Linux认为 这个需要多一点,所以设置了自己的MA_PRIO_MAX为32768
• _POSIX_NAME_MAX(值为14): Linux当然定义了一个更长的文件名长度

• 系统有多少的process在运行
• 一共process打开了多少文件
• 有哪些文件被锁,用的锁是哪些
• 系统使用了哪些socket

• read(): 从kernel buffer cache读取到user-space buffer
• write(): 把user-space buffer写入到kernel buffer cache

• 减少了一次disk操作
• 并且read(), write()返回速度明显提升.

• 在2.2版本以前存在这buffer cache和page cache两个概念.page cache我们说过用 来"映射"process使用的virtual memory的.buffer cache是用来加速IO操作,提升IO 效率的
• 从2.4版本开始, buffer cache不存在了.转而是page cache 起两种作用:即用来"映 射"virtual memory,又用来加速IO

• BUF_SIZE为1, 那么拷贝1千万bytes就需要调用1千万次system call read&write
• BUF_SIZE为1000, 那么拷贝1千万bytes只需要1万次system call read&write

• 虽然有buffer cache的存在,kernel可以把1千万bytes暂存起来统一进行一次disk操 作
• 但是system call也是非常耗费系统资源的操作,所以我们BUF_SIZE要"尽可能的大" 到system call所用时间比起"搬运1千万bytes到磁盘的操作"已经可以忽略的程度.

       对于stdio来说,它会自己创造一个buffer,等这个buffer满了以后,才去调用read&write system call

• 参数buf:
  1. 这个参数可以是NULL, 如果是NULL的话, stdio library会使用automatic的内存 (也就是stack上面的内存)创建一个buffer,大小可以由参数size指定,也可以忽略 size. SUSv3就是直接忽略size的
  2. 如果这个参数不为NULL,那么这个参数指向的内存必须是static的,或者是dynamic 的地址(也就是heap上的), 因为stdio要使用这个地址,所以其地址必须明确(automatic 内存可能在函数退出的时候被压出栈). 这段内存的开始地址为buf,长度为size 单位为bytes
• 参数mode:buf确定了以后,并不是每次都把buffer"用尽", 需要看mode是什么:
  1. _IONBF: 如果是这个参数,那么buffer不会被使用.每一个stdio library call 之 后就立刻调用read&write() system call(当然了kernel还是会使用buffer cache 进行一下等待的, 这里讨论的是stdio的二次缓冲buffer), stderr就是使用这种 方式,所以可以尽可能快的打印错误
  2. _IOLBF: 要么是stdio的buffer满了,要么是遇到了换行,两者满足其一就会返回.
  3. _IOFBF: 只有stdio的buffer满了,才会调用read&write system call

• character device: 以一个character为单位来处理, terminal和键盘是常见的character device
• block device: 以block为单位(通常位512 byte)来处理, disk和tape是常见的block device

• major用来确定device file类型
• minor用来确定specific device

• file system: 保持regular file, directory的常见"文件"系统
• data area: 数据库会使用的,保持raw-mode的设备
• swap area: kernel 管理memory的时候,会用到.

• ext2
• Unix文件系统,Minix, SystemV, BSD file system
• Microsofts' FAT, FAT32, NTFS
• ISO 9660 CD-ROM file system
• Apple Macintosh's HFS
• 一系列的journaling files system: 包括ext3, ext4, JFS, XFS, Btrfs

         +------------------+-----------------------------+---------------+
 Disk    | partition        |       partition             | partition     |
         |                  +                             |               |
         +------------------/-----------------------------\---------------+
                           /                               \
                          /                                 \
                         /                                   \
                        /                                     \
                       /                                       \
                      /                                         \
                     /                                           \
                    /                                             \
                   +-----+-----+------+----------------------------+
                   |boot |super|i-node|      data blocks           |
File System        |block|block|table |                            |
                   +-----+-----+------+----------------------------+

• boot block: 这永远都会是file system的第一个block. boot block是不会被file system所使用的.但是它却包含了如何启动操作系统的信息.虽然操作系统只需要一个 boot block.但是所有的file system都保留了一个boot block(大部分都没有使用)
• superblock: 是单独的一个block, 紧接着boot block, 包含了如下的数据:
  1. i-node table的大小
  2. 每一个logical block的大小
  3. 有多少的logical block
• i-node table: 每一个文件或者文件夹又在i-node里面对应了一个entry
• data blocks: 大部分的file system就是data blocks,用来存储文件和文件夹.

• file type: regular file, directory, symbolic link, character device
• Owner for the file
• Group for the file
• Access permissions for owner, group, and other. 需要注意的是root通常被认 为是拥有一切的权限.所以一个不能运行的hello.c在root看来也是rwx的,只不过在 执行的时候,会出现command not found错误而已.

  vagrant@ tmp $ ls -al hello.c
  -rw-rw-r-- 1 vagrant vagrant 167 Aug 16 19:39 hello.c
  vagrant@ tmp $ ./hello.c
  bash: ./hello.c: Permission denied
  vagrant@ tmp $ sudo ./hello.c
  sudo: ./hello.c: command not found
  

• 三个时间戳
  1. time of last access to the file (ls -lu: 打开文件的操作,不一定要改动)
  2. time of last modification of the file(ls -l: 上次改动文件的操作的时间)
  3. time of last status change(ls -lc: 上次改动i-node的时间: 改动文件内容 "一定"改动i-node.但是改动i-node"不一定"改动文件内容)
• 指向文件的hard link的数目
• 文件以byte记的大小
• "真实"所分配的block的数目.(block的大小为512byte), 这个数目和"以byte记的文 件的大小"两者并不是严格的512倍数的关系,因为file可以有holes
• 指向文件block的指针

• 前12个指向一个block
• 第13个指向一个block,这个block里面的所有数据都是指针(一个指针4Bytes,根据block size的不同,可以存储数目不同的指针)
• 第14个指向两层block指针数组
• 第15个指向三层block指针数组

• VFS提供了一系列的接口,比如open(), read(), write(), lseek(), close()等等, Linux上面的应用只需要知道这些接口就可以了
• 每种具体的file system就提供VFS接口的实现就可以了.(如果有些接口无法实现,比 如Microsoft VFAT就不支持symlink(), 这种情况下,VFAT直接返回error code给VFS 层)

                       +-----------------+
                       |  Application    |
                       +--------+--------+
                                |
                                |
                                |
           +--------------------+---------------------+
           |   Virtual File System (VFS)              |
           +--------------------+---------------------+
                                |
     +-------------+------------+------------+------------+
     |             |            |            |            |
     |             |            |            |            |
+---------+   +----+----+  +----+----+  +----+----+  +----+----+
|  ext2   |   |  ext3   |  | Reiserfs|  |  VFAT   |  |  NFS    |
+---------+   +---------+  +---------+  +---------+  +---------+

       在系统崩溃之后,必须做一次file-system consistency check(fsck).

• 把所有的meta update行动,都在真正行动之前先log下步骤.
• 真正行动起来进行update的时候如果遇到了crash,可以从log里面读取信息进行修复

• 已经被mount的文件系统的信息可以从Linux特有的/proc/下面读取,具体文件是/proc/mounts /proc/mounts是一个kernel 数据结构的interface.所以这里面的信息是最为准确的
• mount(8)和umount(8)这两个命令本身会自动更新的文件是/etc/mtab, 这个文件里面 的内容和/proc/mounts里面的内容是相似的,但是更加详细.但是不够准确,因为mount() 和umount()系统调用(和mount(8)不一样)是不会更新这个文件的
• /etc/fstab文件,由系统管理员更新,保存了"可以被"mount的文件系统(不再是"已经 被mount的系统"了),这个文件还是被mount(8), umount(8), fsck(8)命令所使用.

/dev/sda9 /boot ext3 rw 0 0

• 被mount的device
• mount point
• file-system type
• mount flag: 上面的例子表示这个文件系统是可读可写的
• dump(8)用来控制file-system operation的数字./proc/mounts和/etc/mtab不使这 个数字,所以一直为0
• fsck(8)用来控制file-system order的数字/proc/mounts和/etc/mtable不使用这个 数字,所以一直为0

1. synchronizatoin technique
2. primitive form of IPC (interprocess communication)

• kernel观察到了hardware exception.比如除以0， 访问了不能访问的内存地址。
• 用户输入了特殊的键盘组合。比如Ctrl+C， Ctrl+Z
• software envent，比如timer时间到了。process CPU时间用完了

• traditional signal:从1到31,被kernel用来通知process有event发生
• realtime signal

• signal把event通知到process了,叫做delivered
• event发生和delivered之间叫做pending

• ignored: 有些signal直接就不能被process察觉
• killed: signal默认杀死process
• killed,并且产生core dump file: core dump file是process崩溃时刻的virtual memory image
• stopped: process进入suspended状态
• resumed: process得到signal又可以从suspended重新开始运行

• 运行signal handler
• ignore signal: 是process发出"对策"ignore,并不是default行为就是ignore的signal 对于那种default行为是杀死process的signal, ignore的"对抗"很重要
• default action should occur: 如果signal的行为被process在之前改过,我们想reset 回signal的default behavior的时候,就可以用到这个.

1. signal handler设置了global flag后就马上退出了.然后由main函数每过一段时间 就去check这些flag,并继续处理
2. signal handler做"一定程度上"的cleanup,然后要么"直接关闭这个process",要么 使用"全局goto":放弃一部分stack压榨的结果,到main以下的"原来定好"的一层stack 里面去处理.(细心的人会发现这其实就是exception)

hfeng@hfeng-laptop:~/tmp/tt$ ulimit -c
0
hfeng@hfeng-laptop:~/tmp/tt$ ulimit -c 10000000
hfeng@hfeng-laptop:~/tmp/tt$ ulimit -c
10000000
hfeng@hfeng-laptop:~/tmp/tt$ sleep 30
^\退出 (核心已转储)
hfeng@hfeng-laptop:~/tmp/tt$ ls
core

• 如果不是这样的话,有些process则永远无法被唤醒.
• 一个stopped的process被SIGCONT唤醒了以后.如果有其他pending的要stop它的signal 一概被忽略,否则如果一直有stop signal在stop期间pending,那么永远都continue不了.

• TASK_INTERRUPTIBLE: process正在等待某个event发生.假设这个为eventA.如果这 时候由于eventB产生了signal的话. sleep的process是会被"伪唤醒"的:也就是wake up了以后马上处理eventB.由于不是自己要等待的那个eventA. 在handle了eventB之 后要马上再去sleep. 此状态在ps(1)下显示为S
• TASK_UNINTERRUPTIBLE: process在等待eventA发生,并且其会block"所有的signal"这 个所有"甚至包括SIGKILL(修正一下前面对SIGKILL过分肯定的描述)". 由于block了 所有其他的signal,这个process必须等到自己的eventA发生,handle了之后,才可能被 关闭. 此状态在ps(1)下显示为D.

• fork() system call: 允许一个process(通常是parent process)来创建新的child process,其创建方式是:让新的process完全拷贝一下自己的parent.所谓fork其实就 是一个"分叉"成两个一样的.
• exit(status): 这并不是一个system call(_exit()是), 调用这个函数的进程自动 放弃自己的一切资源(内存, open file descriptors), 然后这些资源都还给kernel kernel可以分配给其他进程.status是退出的信息说明,如果有这个process的parent 在wait它,那么parent可以得到这个status
• wait(&status) system call: 如果调用wait()的process有child还没有通过调用 exit()结束, 那么wait()就会一直的suspend, 直到自己child里面有一个exit()的. 这个&status就是exit(status)的那个参数status
• execve(pathname, argv, envp) system call:
  1. 把pathname指向的program调入入内存的text segment,而当前已有的text被抛弃. 同时, 内存中data (both initialized and bss), heap, stack区域都重新根据 新的text segment来进行调整
  2. 内存中stack上面的argv和env list布局依靠从argv, envp中传入的参数进行重 新设定
  3. 有很多execve()的变体的library function(内部都是调用的execve()),它们统 称为exec(), 但是并没有一个system call叫做exec,这只是一个统称.

• 有两个process存在了
• 而且在每个process里面都从fork()完成的下一条语句继续运行

• parent和child的内容是完全一致的,但是我们知道内容一致是可能发生的. 如果是 两普通的个process, 他们也有可能是所有segment内容一致,但是他们的"虚拟内存" 地址不一样,所以还是要映射到不同的物理地址,也就会在"两块不同的物理地址上存 储相同的一些内容"
• 前面描述的普通的两个process所有segment相同的情况,毕竟是少数.而fork则是最 经常发生的.每一次fork, parent和child的所有segment都一致.我们就会在想是不 是可以让他们的"虚拟内存地址"指向的物理地址也一样.这样一来,就可以减少一半的 物理内存使用, 这就是所谓的COW
• COW当然还有另外一半,那就是共享的这些物理内存,一旦有一个bytes被改动,那么意 味着parent和child已经完成了分家,这个时候,要重新分配物理内存让child的虚拟 内存地址来使用.
• COW说完了,再来讨论下COW的影响:共享物理内存的改动,可以是child改,也可以是parent 改.区别如下:
  1. parent改的话,那么parent一改,就要复制当前的segment信息,重新创建一份物理 内存给child. 而child很大可能性会调用exec(), 这样一来所有的复制出来的物 理内存就要再次被"刷入"新的内容.
  2. child改的话,很大可能就是马上调用exec(), 那么就不需要再把共享物理内存的 内容再拷贝一遍,然后再"刷入"新的内容.可以马上"刷入"新的内存,提高了COW的 效率.
  3. 所以在调度的时候, Linux scheduler更倾向于让child先运行.但是要记住这并不 是绝对的.parent也有可能先运行!

• 返回-1表示没有创建process成功
• 返回newly created child process id表示当前的进程是parent
• 返回0,表示当前的进程是child

• child不会创建新的page或者page table,而是直接的和parent共享内存空间,直到child 调用了exec(),或者_exit()直接退出
• 在vfork()返回之后, parent一直是suspend的状态,直到child调用了exec()或者_exit (也就是说scheduler肯定会先让child运行)

• 如果在child的fork()和exec()之间改动了内存,那么当parent的fork()可以return 的时候,也会看到这些改动.这是非常危险的.
• child总是会先被调度

After a fork(), the parent’s state is already active in the CPU
and its memory-management information is already cached in the
hardware memory management unit’s translation look-aside buffer (TLB).

• wait的一方其实是处于等待signal的状态,suspend当前的process.
• active的一方会在自己任务都完成后,发送signal给wait的一方.

• abnormal termination: 收到了一个signal,而且这个signal的defualt action是terminate 当前process
• normal termination:使用_exit() system call来达到的termination

  #include <unistd.h>
  void _exit(int status);
  

• 退出handers
• stdio stream buffer被清空
• 调用_exit() system call

• C89会返回任意值
• C99会返回exit(0)

• 关闭1.open file descriptor, 2.directory stream, 3.message catalog descriptors 还有4.conversion descriptors
• 所有的file lock都会被release
• System V shared memory segment都会被detach
• 如果关闭的是terminal的controlling process. 那么就会发送SIGHUP signal给所有 的foreground process
• 所有的open的POSIX named semaphore都关闭
• 所有的memory lock都relase
• 所有使用mmap()建立的memory mapping都unmap

• 要在正常运行的时候进行注册handler
• 在normal exit(也就是调用exit()函数)的时候就会运行这个handler
• 调用_exit()或者被signal关闭的process不会调用exit handler

• 如果没有一个child process结束,那么wait()就会一直block, 直到有一个process 结束. 如果在wait()调用之前以及有child结束了,那么wait()就会立马返回
• status是表示child 如何terminate的信息
• wait()会返回结束的child的PID

• 如果parent在child结束之前就结束了.那么child的parent就变成了init
• 如果child在parent调用wait之前就结束了.那么这个child就会变成zombie进程.因为 zombie进程还是会占用一点点的资源(child process ID, termination status, resource usage statistics), 其他的资源都可以被其他process所使用了.

• initialized data segment
• uninitialized data segment
• heap segment

• 各个process的之间share information非常困难.必须使用interprocess communication
• 使用fork()来创建process是非常耗费资源的.

• thread之间因为共享了大部分的内存空间(除了stack), 所以share information变得 很容易.但是为了防止多个thread竞争资源的情况出现,我们必须使用"同步手段"
• thread creation相比于fork来说速度快了有十倍.(在linux上面 thread的创建其实 是只有clone()步骤,而没有fork()步骤. clone()步骤之后,大部分的内存空间都共享 了,所以明显比fork()后再遇到写入然后创建新的page table要快)

• processID and parent processID
• process group ID and session ID
• controlling terminal
• process credentials
• open file descriptors
• record locsk created using fcntl()
• signal dispositions
• file system
• interval timers
• System V semaphore undo values
• resource limts
• CPU time consumed
• resources consumed
• nice value

• threadID
• signal mask
• thread-specific data
• alternate signal stack
• the errno variable
• floating-point environment
• realtime scheduling policy and priority
• CPU affinity
• capabilities
• stack

• 一方面保证了traditional Unix代码的兼容性(依然使用errno作为全局变量)
• 另一方面,在用户使用thread的情况下(引入了errno.h), 通过把errno重新定义为 macro的方式,让errno变成一个threadLocal的变量(脑补java里面的threadLocal定义)

• _REENTRANT preprocessor macro会被定义, 这会让一些reentrant function显示出 来
• 程序会和libpthread库一起编译(和-lpthread效果一样)

• 新的thread是运行“一小部分的program”，就是由`start`所指定的function所在的 区域.这个`start`函数是一个返回值为void*的函数. void*是一种神奇的类型,可以 通过类型转换来变成最常见的类型,比如int

  int j == (int)((void*)k)
  

• 新的thread运行所需要的参数写在`arg`里面. 一般来说arg指向global或者heap 变 量,当然也可以为空.arg的类型,也是上面说的"全能类型"void*
• `thread`指向一个类型为pthread_t的结构体, 这个结构体里面存储着唯一标示thread 的信息.会在pthread_crate()返回前拷贝完毕.
• `attr`指向一个类型为pthread_attr_t的结构体.如果`attr`为NULL,那么thread就会 安装很多默认属性创建.

• thread的start function自己调用了return,换句话说就是thread自己觉得自己的使 命完成了,自动选择了退出
• thread调用pthread_exit()退出.其作用和start function调用return一样,但是调用 pthread_exit()又有其特点因为pthread_exit()可以隐藏在start function调用的 其他函数里面.
• 可以使用pthread_cancle()来结束线程
• 任意一个thread(包括main thread)调用exit都会结束process,同样也会结束属于这 个process的所有的thread.main函数调用return也是一样的效果.所以如果想让main 函数结束后其他thread还继续运行,那么main thread里面需要调用pthread_exit()而 不是exit()或者return.

• process有parent和child之分,只能是parent wait child.但是thread没有parent和 child的区别. 一个threadA创建了threadB,但是threadB也可以join threadA
• process parent可以wait"任意一个child"(通过waitpid(-1, &status, option),但 是thread不能.(因为thread是平等的, join'任意一个thread',可能会join一个library function创建的thread)

• thread stack的地址和大小
• thread的scheduling policy
• thread的priority
• thread是否joinable或者detached

• thread间的数据分享特别的容易
• thread的创建非常简单.切换也快速

• 我们要保证我们thread里面调用的函数是thread-safe的(或者in a thread-safe manner)
• 一个thread里面的bug可以摧毁所有本process其他的threads, 因为process的thread 分享地址空间
• 多个thread是会竞争virtual memory的,而多个process每人都有一个地址空间.

• 不要在多线程环境下使用signal
• thread还会分享file descriptor, current working directory等其他资源.这即可 能是优势,又可能是劣势.

       我们必须让不同的thread不要在同一时间修改同一个变量(或者一个修改,
       其他读取)

• 在访问shared resource之前locak the mutex for the shared resources
• 访问shared resource
• 在使用shared resource之后, unlock the mutex

• 我们首先有很多的thread来produce一些东西(例子中是avail)

  static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
  
  static int avail = 0;
  
  /* Code to produce a unit ommitted */
  s = pthread_mutex_lock(&mtx);
  if (s != 0) {
      errExitEN(s, "pthread_mutex_lock");
  }
  
  avail++;
  
  s = pthread_mutex_unlock(&mtx);
  if (s != 0) {
      errExitEN(s, "pthread_mutex_unlock");
  }
  

• 然后我们会由一个consumer(比如是main thread)来消耗avail个"产品"

  for (;;) {
      s = pthread_mutex_lock(&mtx);
      if (s != 0) {
          errExitEN(s, "pthread_mutex_lock");
      }
  
      while (avail > 0) {
          /* Do somethign with produced unit */
          avail--;
      }
  
      s = pthread_mutex_unlock(&mtx);
      if (s != 0) {
          errExitEn(s, "pthread_mutex_unlock");
      }
  }
  

• 一个显而易见的方法就是给function加mutex,当进入function的时候lock mutex,当 退出function的时候release mutex.这样做的坏处是如果threads大量的使用这些函 数,这些函数其实都是"线性"执行的,虽然获得了"安全性",但是失去了"并发性"
• 一个更加合理的做法:是减小mutex的作用域,原来是保护整个函数,现在,可以通过对 函数的分析,只保护函数中涉及到shared variable的部分(critical section),这样 一来只有在同时运行critical section的时候是"线性的"

asctime()      getservbyport() nl_langinfo()
basename()     getservent()    ptsname()
catgets()      getutxent()     putc_unlocked()
crypt()        getutxid()      putchar_unlocked()
ctime()        getutxline()    putenv()
dbm_clearerr() gmtime()        pututxline()
dbm_close()    hcreate()       rand()
dbm_delete()   hdestroy()      readdir()
dbm_error()    hsearch()       setenv()
dbm_fetch()    inet_ntoa()     setgrent()
dbm_firstkey() l64a()          setkey()
dbm_nextkey()  lgamma()        setpwent()
dbm_open()     lgammaf()       setutxent()
dbm_store()    lgammal()       strerror()
dirname()      localeconv()    strsignal()
dlerror()      localtime()     strtok()
drand48()      lrand48()       system()
encrypt()      mblen()         ttyname()
endgrent()     mbtowc()        unsetenv()
endpwent()     mrand48()       wctomb()
endutxent()
nftw()

• malloc系列函数,必须访问global linked list of free blocks on the heap
• 还有一些"历史遗留"的函数,他们设计的时候,还没考虑那么多,直接就会使用一块static 的内存来返回值(下一次再调用这个函数,这个值又被改写了). 比如asctime()

• 如果我们从main函数里面调用thread,那么我们可以先创建mutex,然后再创建thread. 因为mutex在thread创建之前就有了,那么多个thread就不必担心,直接使用mutex就可 以了
• 但是如果我们先创建了thread,然后thread里面的代码开始创建mutex,由于thread有 多个,那么很可能创建mutex的代码执行了多次.我们需要一种

           某段代码执行多次,但是只有第一次有作用的机制: one-time initialization
  

• once_control是一个指向变量的指针,而且必须如下statically initialized

  pthread_once_t once_var = PTHREAD_ONCE_INIT;
  

• init是一个指向函数的指针,这个函数是用来初始化的

  void
  init(void)
  {
      /* Function body */
  }
  

                     +----------------+
+--------+           | TSD bufer for  |
|ThreadA |---------->| myfunc() in    |
+--------+           | ThreadA        |
                     +----------------+

                     +----------------+
+--------+           | TSD bufer for  |
|ThreadB |---------->| myfunc() in    |
+--------+           | ThreadB        |
                     +----------------+

                     +----------------+
+--------+           | TSD bufer for  |
|ThreadC |---------->| myfunc() in    |
+--------+           | ThreadC        |
                     +----------------+

• PTHREAD_CANCEL_ENABLE: 默认设置,其他thread一旦要求自己cancel,那么就cancel
• PTHREAD_CANCEL_DISABLE: 即便其他thread要求自己的cancel,也不为所动,保持pending 状态.

• 如果thread是main thread,那么空间非常大(无限接近3G,在32bit机器上面)
• 如果thread不是main thread,那么stack的大小一般是固定的.32bit机器上面是2MB

• 如果想在每个thread里面多申请几个automatic 变量或者函数多嵌套几次的话,就需 要增加stack的大小
• 如果想让机器多运行几个thread,那么在虚拟内存空间有限(比如32bit机器是3G的情 况下,如果不改小thread stack的默认大小2MB的话,最多只可以有1500个thread同时 运行)

• 开始： leader创建这个group， 作为开始
• 结束： group里面所有的process都离开，作为结束（process离开group的定义是： 要么加入其他group，要么terminate）

• Control + C : SIGINT
• Control + \ : SIGQUIT
• Control + Z : SIGTSTP

• session 的id是session leader group的group id，为400
  1. session 的 session leadergroup 的id， 是这个process group的leader process 的pid为，也就是PID为400的bash
  2. session中第二个process group是find 和 wc，其中find是process group leader 其PID658作为这个process group的GID
  3. session中第三个process group是sort 和 uniq，其中sort是process group leader 其PID660作为这个process group的GID
• 这些process分成了两种,都被controlling terminal所控制：
  • foreground： sort, uniq
  • background: bash, find, wc
• 下图就是上面例子的解释

  

  Figure 9: process-groups

• 公平性:每个process都有机会使用CPU
• 响应性:每个process不需要等待太久

• 它是long-lived的,一般来说daemon都是从机器启动就运行,然后直到机器关机才退出 的.
• 它是在后台运行的,而且"没有controlling terminal"(这一点决定了,我们加上'&'运 行的程序只是background process而不是daemon process).所以对于daemon来说,它 不会收到如下两类signal:
  1. job-control signal
  2. terminal-relative signal

• cron: 在特定的实现执行特定的command
• sshd: secure shell daemon, 允许用户从远程登录
• httpd:http server daemon,用来服务web页面
• inetd: Internet superserver daemon,会监听某些port上面的请求,并且服务于它.

• 在系统启动中同时被创建
• 在ps(1)里面显示的时候,名字被[]包围, 比如

  vagrant@ elpa (master) $ ps -aux
  USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
  root         1  0.0  0.1  37652  5756 ?        Ss   11:11   0:01 /sbin/init
  root         2  0.0  0.0      0     0 ?        S    11:11   0:00 [kthreadd]
  root         3  0.0  0.0      0     0 ?        S    11:11   0:00 [ksoftirqd/0]
  root         4  0.0  0.0      0     0 ?        R    11:11   0:02 [kworker/0:0]
  root         5  0.0  0.0      0     0 ?        S<   11:11   0:00 [kworker/0:0H]
  root         6  0.0  0.0      0     0 ?        S    11:11   0:00 [kworker/u4:0]
  root         7  0.0  0.0      0     0 ?        S    11:11   0:01 [rcu_sched]
  

• 每一个application都创建一个socket. socket是一种工具需要"沟通"双方都需要的 工具,所以每个application都需要一个socket
• server把自己的socket绑定到一个well-known port, 这样一来, client就可以通过 <IP>:<Port>

• domain: 常见的domain有如下三种

  Domain	Communication preformed	Communication between applications	Address format	Address Structure
  AF_UNIX	within kernel	on same host	pathname	sockaddr_un
  AF_INET	via IPv4	on hosts connected via an IPv4 network	32-bit IPv4 + 16-bit port	sockaddr_in
  AF_INET6	via IPv6	on hotts connected via an IPv6 network	128-bit IPv6+16-bit port	sockaddr_in6

• type: 说的是socket type, 不同的domain都会提供如下两种socket type: Stream 和Datagram, 它俩的特点如下

  Property	Stream	Datagram
  Reliable delivery?	Y	N
  Message boundaries preserved?	N	Y
  Connection-oriented?	Y	N

• protocol一般都是0, 早期这个protocol是用来使用default protocol用的,但是现 在已经被废弃, 设置为0的意思就是不使用任何default protocol

• reliable:意味着要么,我们成功的把数据完整的传递给对方,要么,我传递的不完整的 话,我肯定知道,我要"警告对方"数据可能损坏
• bidirectional: 意味着数据都是双向传递的, client端有一个socket, server端有 另外一个socket, 这两个socket之间,无论哪个方向都是可以传递信息的(后面阅读有感)
• byte-stream: 就是没有message boundaries的概念

• out of order
• duplicated
• 根本没有传输到对方

• socket():创建new socket
• bind():bind一个socket到一个address,通常是server才需要这个步骤,因为server要 绑定一个well-known的 address,client才能找到. client就不需要一个特别著名的地址
• listen(): listen允许stream socket来接听incoming connection
• accept(): accept用来接受从peer application传来的connection请求, 必须首先是 一个listening socket,才能accept其他connection
• connect(): 就是client一端的socket,去拼命的联系server端的socket, 当然了,因 为"忙音"的存在,不一定能联系成功(后面阅读有感)

• socket() 是建立socket,这就和"安装电话"一样.为了让两个地方的人通信,两个地方 都必须安装电话. 为了让两个application通信,两个application也都必须create socket!!(这个是我第一次对socket有了正确的理解!!)
• 在真正的"打电话(传递数据)"之前,还是有一些工作要做:
  • server端: 必须使用bind()把自己绑定在一个well-known 地址,然后listen()等待 新的connection来访问. 对比telephone就是为自己的电话申请一个well-known的 号码,比如123,然后还要把电话打开,这样其他电话才能打进来
  • client端(首先也要socket()安装电话), 它在知道server端号码的情况下, 可以直接 拨打,也就是connect(), 然后就是等待接通啦
  • server端的listen()在有其他incomming connection来临的情况下,会调用accept() 来接听connection,就好比我们听到电话响,就拿起电话和client对话. 注意,一旦 你接听了一个电话,另外其他像打进来的电话就是"忙音"了
• 一旦电话接通,那么就可以对话了,一旦两个socket建立了connection,那么就可以在 两个方向进行数据传输了.

• 使用connect()去主动联系其他socket的,叫做active open socket
• 使用listen()等待其他socket, 然后accept() block直到其他socket来临的socket叫做 passive open socket.

• 如果两者希望通信,那么必须要通信双方都要有邮局(得通邮),所以通信双方都使用socket() 来各自建立一个邮局
• 为了让对方知道自己的地址,需要使用bind()来把自己的邮局和一个well-known的地 址联系起来.一般来收,只是server端需要bind(), 但是如果希望server回信给client 那么client也得进行bind()
• client端一般都会"发起"一次通信,通过sendto(), 当然了server端的回信也是sendto()
• server端读取client的通信是通过recvfrom()
• 当没有通信需求的时候,使用close()关闭socket

  

  Figure 11: datagram-socket.png

• AF_是family的前缀(ipv4, ipv6都用这个)意思是Address Family
• sun_意思是socket unix
• SUSv3并没有规定sun_path的长度,因为历史上有92, 104, 108等多种默认值

• 不能bind 一个socket到existing pathname(bind() fails with the error EADDRINUSE)
• 最好bind一个socket到absolute pathname. 因为更不容易出错
• 一个socket只能bound to 一个pathname,一个pathname也只能对应一个socket
• 不能使用open()来打开一个socket
• 如果一个socket不再需要了, pathname entry可以使用unlink()来移除

• 先是client和server都使用的header file

  #include <sys/un.h>
  #include <sys/socket.h>
  #include "tlpi_hr.h"
  
  #define SV_SOCK_PATH "/tmp/us_xfr"
  #define BUF_SIZE 100
  

• UNIX domain下使用stream socket传递的server

  #include "us_xfr.h"
  
  #define BACKLOG 5
  
  int main(int argc, char *argv[])
  {
      struct sockaddr_un addr;
      int sfd, cfd;
      ssize_t numRead;
      char buf[BUF_SIZE];
  
      sfd = socket(AF_UNIX, SOCK_STREAM, 0);
      if (sfd == -1)
          errExit("socket");
  
      /* Construct server socket address, bind socket to it,
         and make this a listeing socket.
       */
  
      if (remove(SV_SOCK_PATH) == -1 && errno != ENOENT)
          errExit("remove-%s", SV_SOCK_PATH);
  
      memset(&addr, 0, sizeof(struct sockaddr_un));
      addr.sun_family = AF_UNIX;
      strncpy(addr.sun_path, SV_SOCK_PATH, sizeof(addr.sun_path) - 1);
  
      if (bind(sfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1)
          errExit("bind");
      if (listen(sfd, BACKLOG) == -1)
          errExit("listen");
  
      for (;;) {                  /* Hendle client connections iteratively */
          /* Accept a connection. The connection is returned on a new
             socket, 'cfd'; the listening socket('sfd') remains open and can
             be used to accept further connections
           */
  
          cfd = accept(sfd, NULL, NULL);
          if (cfd == -1)
              errExit("accept");
  
          /* Transfer data from connected socket to stdout until EOF */
  
          while ((numRead = read(cfd, buf, BUF_SIZE)) > 0)
              if (write(STDOUT_FILENO, buf, numRead) != numRead)
                  fatal("partial/failed write");
  
          if (numRead == -1)
              errExit("read");
  
          if (close(cfd) == -1)
              errMsg("close");
      }
  }
  

• client端代码如下

  #include "us_xfr.h"
  
  int main(int argc, char *argv[])
  {
      struct sockaddr_un addr;
      int sfd;
      ssize_t numRead;
      char buf[BUF_SIZE];
  
      sfd = socket(AF_UNIX, SOCK_STREAM, 0); /* Create client socket */
      if (sfd == -1)
          errExit("socket");
  
      /* Construct server address, and make the connection */
      memset(&addr, 0, sizeof(struct sockaddr_un));
      addr.sun_family = AF_UNIX;
      strncpy(addr.sun_path, SV_SOCK_PATH, sizeof(addr.sun_path) - 1):
  
      if (connect(sfd, (struct sockaddr *)&addr,
                  sizeof(struct sockaddr_un)) == -1)
          errExit("connect");
  
      /* Copy stdin to socket */
      while ((numRead = read(STDIN_FILENO, buf, BUF_SIZE)) > 0)
          if (write(sfd, buf, numRead) != numRead)
              fatal("partial/failed write");
  
      if (numRead == -1)
          errExit("read");
      exit(EXIT_SUCCESS);
  }
  

Communication using datagram sockets is unreliable

• 头文件

  #include <sys/un.h>
  #include <sys/socket.h>
  #include <ctype.h>
  #include "tlpi_hdr.h"
  
  #define BUF_SIZE 10
  
  #define SV_SOCK_PATH "/tmp/un_ucase"
  

• server端代码

  #include "ud_ucase.h"
  
  int main(int argc, char *argv[])
  {
      struct sockaddr_un svaddr, claddr;
      int sfd, j;
      ssize_t numBytes;
      socklen_t len;
      char buf[BUF_SIZE];
  
      sfd = socket(AF_UNIX, SOCK_DGRAM, 0); /* Create server socket */
  
      if (sfd == -1)
          errExit("socket");
  
      /* Construct well-known address and bind server socket to it */
  
      if (remove(SV_SOCK_PATH) == -1 && errno != ENOENT)
          errExit("remove-%s", SV_SOCK_PATH);
  
      memset(&svaddr, 0, sizeof(struct sockaddr_un));
      svaddr.sun_family = AF_UNIX;
      strncpy(svaddr.sun_path, SV_SOCK_PATH, sizeof(svaddr.sun_path) - 1);
  
      if (bind(sfd, (struct sockaddr *)&svaddr, sizeof(struct sockaddr_un)) == -1)
          errExit("bind");
  
      /* Eeceive messages, convertto uppercase, and return to client */
  
      for (;;) {
          len = sizeof(struct sockaddr_un);
          numBytes = recvfrom(sfd, buf, BUF_SIZE, 0
                              (struct sockaddr *)&claddr, &len);
          if (numBytes == -1)
              errExit("recvfrom");
  
          printf("Server received %ld bytes from %s\n", (long) numBytes,
                 claddr.sun_path);
  
          for (j = 0; j < numBytes; j++)
              buf[j] = toupper((unsigned char) buf[j]);
  
          if (sendto(sfd, buf, numBytes, 0, (struct sockaddr*)&claddr, len) != numBytes)
              fatal("sendto");
      }
      return 0;
  }
  

• client端代码

  #incude "ud_ucase.h"
  
  int main(int argc, char *argv[])
  {
      struct sockaddr_un svaddr, claddr;
      int sfd, j;
      size_t msgLen;
      ssize_t numBytes;
      char resp[BUF_SIZE];
  
      if (argc < 2 || strcmp(argv[1], "--help") == 0)
          usageErr("%s msg...\n", argv[0]);
  
      /* Crate client socke; bindto unique pathname (Base on PID) */
      sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
      if (sfd == -1)
          errExit("socket");
  
      memset(&claddr, 0, sizeof(struct sockaddr_un));
      claddr.sun_family = AF_UNIX;
  
      snprintf(claddr.sun_path, sizeof(claddr.sun_path),
               "/tmp/ud_ucase_cl.%ld", (long)getpid());
  
      if (bind(sfd, (struct sockaddr*)&claddr, sizeof(struct sockaddr_un)) == -1)
          errExit("bind");
  
      /* Construct addressof server */
  
      memset(&svaddr, 0, sizeof(struct sockaddr_un));
      svaddr.sun_family = AF_UNIX;
      strncpy(svaddr.sun_path, SV_SOCK_PATH, sizeof(svaddr.sun_path) - 1);
  
      /* Send messages to server;echo responseson stdout */
  
      for (j = 1; j < argc; j++) {
          msgLen = strlen(argv[j]);
          if (sendto(sfd, argv[j], msgLen, 0, (struct sockaddr*)&svaddr,
                     sizeof(struct sockaddr_un)) != msgLen)
              fatal("sendto");
  
          numBytes = recvfrom(sfd, resp, BUF_SIZE, 0, NULL, NULL);
          if (numBytes == -1)
              errExit("recvfrom");
          printf("Response %d: %.*s\n", j, (int)numBytes, resp);
      }
  
      remove(claddr.sun_path);
      exit(EXIT_SUCCESS);
  }
  

• 为了能够和一个Unix domain stream socket connect, process需要对这个file有 write permission
• 为了能够在一个Unix domain datagram socket上传输数据, process需要对这个file 有write permission