《CSAPP》第十章：系统级I/O

ANSI C提供标准I/O库，C++提供重载操作符，在Linux系统中使用内核提供的系统级Unix I/O函数来实现较高级别的I/O函数，学习Unix I/O有利于

理解其他系统概念。I/O是系统不可或缺的一部分，它们之间是循环依赖。例如，I/O在进程的创建和执行中扮演关键角色，进程创建又在不同进程间的文件共享中扮演关键角色？？
除了使用Unix I/O以外别无选择。例如标准I/O库没有提供读取文件元数据的方式，I/O库本身也存在问题，不能用于网络编程
这章的学习将为学习网络编程和并发性奠定坚实的基础

Unix I/O

Linux中，所有I/O设备都被模型化为文件，这种方式允许Linux内核引出一个简单、低级的应用接口，称为Unix I/O，这就使得所有输入输出都以一种统一的方式执行

打开文件：应用程序要求内核打开相应文件，内核就返回一个小的非负整数，叫做描述符。内核记录有关打开这个文件的所有信息，应用程序只需记住这个描述符
标准输入、输出和错误：Shell创建每个进程的时候都会打开三个文件（可查看xv6源码的8507行）
改变文件位置：这是从文件开头起始的字节偏移量，可通过seek显示设置文件的当前位置
读写文件：读写文件就是磁盘和内存的交换
关闭文件：当通知内核关闭程序时，内核就会释放文件打开时创建的数据结构，并将这个描述符恢复到可用的描述符池中

文件

Linux文件也有不同的类型

普通文件：对内核而言，文本文件和二进制文件没有区别
目录：包含一组链接的文件，其中每个链接都有一个文件名映射到一个文件
套接字：用来与另一个进程进程跨网络通信的文件

打开

作为上下文的一部分，每个进程都有一个当前工作目录，来确定在目录层次结构中的当前位置

进程通过调用open函数来打开一个已经存在的文件或创建新文件

1	int open(char *filename,int flags,mode_t mode);

该函数将filename转换为文件描述符并返回，返回的描述符是进程中未使用的最小描述符。

flags参数指明访问方式，如O_RDONLY O_WRONLY O_RDWR O_CREATE等模式，具体参考书

mode参数指明新文件的访问权限位。作为上下文一部分，每个进程都有一个umask，它通过调用umask函数来设置，此时文件的访问权限为mode & ~umask，例如

#define DEF_MODE S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IWOTH
#define DEF_UMASK S_IWGRP | S_IWOTH

umaks(DEF_UMASK);
fd = open("foo.txt",O_CREATE | O_WRONLY,DEF_MODE);

读写

通过下面两个函数执行输入输出

1 2	ssize_t read(int fd,void buf,size_t n); ssize_t write(int fd,const void buf,size_t n);

read函数从描述符fd的当前位置复制最多n个字节到内存位置buf，返回-1表示错误，返回0表示EOF，否则返回实际传送的字节数量

在x86-64系统中，size_t定义为unsigned long，ssize_t定义为long，因为read函数可能返回负数，必须是有符号数，因为这个原因，该函数能读取的最大字节数减少了一半

有些时候，两个函数传送的字节数量比定义的n值要少，这意味着出错误

遇到EOF
从终端读取文本行：如键盘和显示器，每个read函数读取一个文本行，返回的不足值就是文本行大小
读写网络套接字：内部缓冲约束和网络延迟会引起返回不足值

RIO

RIO提供了两类不同的函数

无缓冲的输入输出函数：直接在文件和内存之间传送数据，没有应用级缓存，它们对二进制数据读写到网络和从网络读写二进制数据很有用
带缓冲的输入函数：这些函数是线程安全

无缓冲

/*
 * rio_readn - robustly read n bytes (unbuffered)
 */
/* $begin rio_readn */
ssize_t rio_readn(int fd, void *usrbuf, size_t n)
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;

    while (nleft > 0) {
        if ((nread = read(fd, bufp, nleft)) < 0) {
            if (errno == EINTR) /* Interrupted by sig handler return */
                nread = 0;      /* and call read() again */
            else
                return -1;      /* errno set by read() */
        }
        else if (nread == 0)
            break;              /* EOF */
        nleft -= nread;
        bufp += nread;
    }
    return (n - nleft);         /* return >= 0 */
}
/* $end rio_readn */

rio_readn从描述符fd的当前位置最多传送n个字节到内存位置usrbuf，可我并没有理解这样做怎么就产生鲁棒性？？

带缓冲

rio_readlineb从一个内部读缓冲区复制一个文本行，当缓冲区变空时，会自动调用read函数重新填满缓冲区，对于既包含文本行也包含二进制文件，则可以使用rio_readnb

/* Persistent state for the robust I/O (Rio) package */
/* $begin rio_t */
#define RIO_BUFSIZE 8192
typedef struct {
    int rio_fd;                /* Descriptor for this internal buf */
    int rio_cnt;               /* Unread bytes in internal buf */
    char *rio_bufptr;          /* Next unread byte in internal buf */
    char rio_buf[RIO_BUFSIZE]; /* Internal buffer */
} rio_t;
/* $end rio_t */

void rio_readinitb(rio_t *rp, int fd);
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);

每打开一个描述符，都会先调用rio_readinitb，将描述符fd和地址rp处的一个类型为rio_t的读缓冲区联系起来

上述函数的核心是rio_read函数，这个函数是最原始Linux read函数的带缓冲版本

/* 
 * rio_read - This is a wrapper for the Unix read() function that
 *    transfers min(n, rio_cnt) bytes from an internal buffer to a user
 *    buffer, where n is the number of bytes requested by the user and
 *    rio_cnt is the number of unread bytes in the internal buffer. On
 *    entry, rio_read() refills the internal buffer via a call to
 *    read() if the internal buffer is empty.
 */
/* $begin rio_read */
static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    while (rp->rio_cnt <= 0) {  /* Refill if buf is empty */
        rp->rio_cnt = read(rp->rio_fd, rp->rio_buf,
                           sizeof(rp->rio_buf));
        if (rp->rio_cnt < 0) {
            if (errno != EINTR) /* Interrupted by sig handler return */
                return -1;
        }
        else if (rp->rio_cnt == 0)  /* EOF */
            return 0;
        else
            rp->rio_bufptr = rp->rio_buf; /* Reset buffer ptr */
    }

    /* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */
    cnt = n;
    if (rp->rio_cnt < n)
        cnt = rp->rio_cnt;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt;
    rp->rio_cnt -= cnt;
    return cnt;
}
/* $end rio_read */

当缓冲区为空时，调用read函数填满它，如果非空，则从读缓冲区复制min(n, rp->rio_cnt)字节到用户缓冲区

共享文件

内核用三个相关的数据结构来表示打开的文件

描述符表：每个进程都有独立的描述符表，该表的索引就是打开的文件描述符，表项则是指向文件表
文件表：所有进程共享这张表，这张表的表项包括当前文件的位置、引用计数、指向v-node表中对应表项的指针
v-node 表：每个表项包含stat结构的大多数信息（即文件元数据）

多个描述符可以通过不同的文件表项引用同一个文件，这样每个描述符都有自己的文件位置，可以从不同位置获取数据

子进程有一个父进程描述符的副本，因此共享相同的打开文件集合，在内核删除相应文件表表项之前，父子进程必须都关闭各自的描述符

I/O重定向

1 2	/* Duplicate FD to FD2, closing FD2 and making it open on the same file. */ int dup2 (int oldfd, int newfd);

该函数复制描述符表项oldfd到描述符表项newfd，具体使用查看MIT 6.828 Assignment:Shell

标准I/O

C语言定义了一组高级输入输出函数，称为标准I/O库，例如fopen fclose fread fwrite printf scanf

标准I/O库将一个打开文件模型化为流。对于程序员来说，一个流就是指向FILE类型的结构的指针，每个ANSI C程序开始时都有三个打开流stdin stdout stderr

类型为FILE的流是对文件描述符和流缓冲区的抽象，流缓冲区的目的就是使开销较高的Linux I/O系统调用的数量尽可能少

总结

Unix I/O模型是在操作系统内核中实现的，标准I/O和RIO则是在基础上实现的包装函数。大多数情况下，标准I/O是更优的选择，但是因为标准I/O和网络文件的不兼容问题，因此Unix I/O比其更适合网络应用程序

参考

MIT 6.828 book_xv6:Chapter 0
APUE：