Linux学习 --系统IO

包含的头文件


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
API 
int open (const char *name, int flags);
int open (const char *name, int flags, mode_t
mode);

 creat()函数

O WRONLY | O CREAT | O TRUNC的组合经常在open函数中使用，因此专门给它设计了一个creat()函数

头文件
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h>

API 
int creat (const char *name, mode_t mode);

头文件
#include <unistd.h>

API 
ssize_t read (int fd, void *buf, size_t len);

该函数返回由fd指向的文件当前偏移量读取len个字节到buf中，如果读取成功返回写入到buf的字节数，出错返回-1并设置errno。且每次读取之后打开文件的偏移量都会增加之前的读取字节数

ssize_t ret;    //读取结果的返回值
while (len != 0 && (ret = read(fd, buf, len)) !=0)
//当要读取的len!=0且文件偏移没达到EOF时可读取文件
{
if (len > SSIZE_MAX)    //len是有上限的，它不能超过0x7fffffff
 
len = SSIZE_MAX;

    //读取出错返回-1
    if (ret == -1) {
        //错误原因确认，如果为EINTR（被信号中断）申请重新开始读取
        if (errno == EINTR)
            continue;
if (errno == EAGAIN)     //在非阻塞模式下如果没有读到数据时返回该值
/* resubmit later */

        //打印错误原因
        perror(”read”);
        break;
    }
    //读取成功修改len值
    len -= ret;    //len减去已经读取的字节数
    buf += ret; //移动buf指针
}

头文件
#include <unistd.h>

API 
ssize_t write (int fd, const void *buf, size_t 
count);

unsigned long word = 1720;    //要写入的结构
size_t count;            
ssize_t nr;                //保存返回值
count = sizeof(word);    //要写入的字节数
nr = write(fd, &word, count);
if (nr == -1)            //写入失败
/* error, check errno */
else if (nr != count)    //写入量不是要求的字节数
/* possible error, but ’errno’ not set */


/*通过循环部分写入确保要写入的数据都写入成功，同read*/
ssize_t ret, nr; 
while (len != 0 && (ret = write (fd, buf, len)) 
!= 0) { 
if (ret == -1) { 
if (errno == EINTR) 
continue; 
perror (”write”); 
break; 
} 
len -= ret; 
buf += ret; 
}

包含头文件
#include <unistd.h>
API 
int fsync (int fd);
int fdatasync (int fd);    

返回值和错误码

成功时都返回0，失败返回-1并设置errno

Sync()
对磁盘中所有缓冲区进行同步

包含的头文件
#include <unistd.h>
API 
void sync (void);

总是成功返回并确保数据和元数据（数据的相关联信息，如数据的组织，数据域等）都能写入磁盘

包含头文件
#include <unistd.h>

API
int close (int fd); 

调用成功返回0，否则-1并设置errno

头文件包含
#include <sys/types.h> 
#include <unistd.h>

API 
off_t lseek (int fd, off_t pos, int origin); 

调用成功返回新文件位置，失败返回-1，并设置errno值

包含的头文件
#include <unistd.h>

API 
ssize_t pread (int fd, void *buf, size_t count, 
off_t pos);
从文件描述符fd的pos位置读取count个字节到buf中


包含的头文件
#include <unistd.h>
API 
ssize_t pwrite (int fd, const void *buf, size_t 
count, off_t pos); 

从buf中写入count个字节到fd文件描述符指定的文件中中

Pread返回0表示EOF，pwrite表面没有写任何东西

二者返回-1并设置errno,lseek（）和read()和write()的错误码都可能出现

包含头文件
#include <unistd.h> 
#include <sys/types.h>
API 
int ftruncate (int fd, off_t len); 
int truncate (const char *path, off_t len);
成功返回0，失败返回-1并设置错误码

#include <unistd.h> 
#include <stdio.h> 
int main( ) 
{ 
int ret;

ret = truncate (”./pirate.txt”, 45); 
if (ret == -1) { 
perror (”truncate”); 
return -1; 
} 
return 0; 
} 

包含头文件
#include <sys/time.h> 
#include <sys/types.h> 
#include <unistd.h>

相关API 
int select (int n, 
fd_set *readfds, 
fd_set *writefds, 
fd_set *exceptfds, 
struct timeval *timeout); 
FD_CLR(int fd, fd_set *set); 
FD_ISSET(int fd, fd_set *set); 
FD_SET(int fd, fd_set *set); 
FD_ZERO(fd_set *set);

#include <sys/time.h> 
struct timeval { 
long tv_sec; /* seconds */ 
long tv_usec; /* microseconds */ 
};

typedef struct fd_set {
    unsigned long fds_bits[FD_SETSIZE / sizeof(unsigned long)];
} fd_set;

//从指定集合中移除所有文件描述符
FD_ZERO(&writefds); 
//向指定集合中添加一个文件描述符
FD_SET(fd, &writefds);
//从指定集合中移除一个文件描述符
FD_CLR(fd, &writefds);

//确认某个文件描述符是否还在集合中
if (FD_ISSET(fd, &readfds)) 

如果还在则返回非零值，说明I/O已经就绪可读写

如果返回零说明不在集合中，I/O还没准备好读写

Select实现微秒级延迟

struct timeval tv; 
tv.tv_sec = 0; 
tv.tv_usec = 500;        //微秒 
/* sleep for 500 microseconds */ 
select (0, NULL, NULL, NULL, &tv); 

关于pselect()

包含头文件
#define _XOPEN_SOURCE 600 
#include <sys/select.h>

API 
int pselect (int n, 
fd_set *readfds, 
fd_set *writefds, 
fd_set *exceptfds, 
const struct timespec *timeout, 
const sigset_t *sigmask); 
FD_CLR(int fd, fd_set *set); 
FD_ISSET(int fd, fd_set *set); 
FD_SET(int fd, fd_set *set); 
FD_ZERO(fd_set *set); 

基本上和select一致，但存在不同点

使用的超时结构体不同，增加了纳秒级别的计时

struct timespec { 
long tv_sec; /* seconds */ 
long tv_nsec; /* nanoseconds */ 
};

在sigmask = NULL时，等同于select（）

增加pselect是为了增加sigmask参数解决信号和等待文件描述符之间的竞争条件

poll系统调用

Poll()的系统调用是System V 的IO多路复用方案

头文件
#include <sys/poll.h>
API 
int poll (struct pollfd *fds, unsigned int nfds, 
int timeout);

参数

Fds:文件描述符结构体

Nfds:结构体个数

Timeout超时时间

pollfd结构体：

头文件
#include <sys/poll.h> 
struct pollfd { 
int fd; /* file descriptor */ 
short events; /* requested events to watch */ 
short revents; /* returned events witnessed */ 
};
当事件不再成立时，events的事件会被转移到revents中

要监视的事件的位掩码

poll的使用案#include <unistd.h>#include <sys/poll.h>#define TIMEOUT 5 /* poll timeout, in seconds */int main (void)

{
//两个事件结构体
struct pollfd fds[2];
int ret;
/* watch stdin for input */

//STDIN_FILENO表示的是标准输入描述符，这里表示监视标准输入描述符是否可读（用户是否写入数据）的事件

fds[0].fd = STDIN_FILENO; 
fds[0].events = POLLIN; /* watch stdout for ability to write (almost always true) */

//STDOUT_FILENO表示的是标准输出描述符，这里表示监视标准输出描述符是否写阻塞（有没有数据可以写入这个文件描述符）的事件
fds[1].fd = STDOUT_FILENO; 
fds[1].events = POLLOUT; 
/* All set, block! */
//执行poll
 ret = poll (fds, 2, TIMEOUT * 1000);
 if (ret == -1) { perror (”poll”); return 1; } 
if (!ret) { printf (”%d seconds elapsed.\n”, TIMEOUT); return 0; } 
//返回0代表执行成功，其它都出现错误
 if (fds[0].revents & POLLIN)　　// revents中出现POLLIN，说明事件成立（用户写入了数据）

　　　　printf (”stdin is readable\n”);

ppoll()

头文件
#define _GNU_SOURCE 
#include <sys/poll.h>
API 
int ppoll 
(struct pollfd *fds, 
nfds_t nfds, 
const struct timespec *timeout, 
const sigset_t *sigmask);

poll 和select哪个好用？

poll系统调用优先级>select

使用poll不用去计算文件描述符的最大值

相比较select需要确定文件描述符最大值，poll只需要定义数组就够了

Select返回后再次进入需重新初始化，poll不需要

但是

Select的移植性更好，部分Unix系统不支持poll()

select提供微秒级定时服务，poll提供的纳秒级其实是不精确的

内核内幕

Linux如何实现IO？

-虚拟文件系统（VFS），页缓存，页回写，IO调度器

虚拟文件系统

作用：允许内核在不知道文件系统类型的情况下，使用文件系统函数和操作文件系统数据

实现原理：使用一种通用文件模型，它是所有Linux文件系统的基础。它要求所有的文件系统之间需要有共性

举个例子来说，当在用户空间的某应用调用了read()系统调用，在该进程进入内核态时将系统调用转交给处理器处理，最后交给read()系统调用。内核确定read（）的文件描述符对应的对象类型后调用相应类型的read()函数。该类型的read（）函数执行完后执行结果返回给用户空间的read()调用。（即将数据复制返回给用户空间的系统调用处理器，然后复制数据到用户空间），最后用户空间的read（）系统调用返回使进程继续执行

页缓存

页缓存是一种在内存中保存最近磁盘文件系统访问过的数据的方式（访问硬盘的速度要远远慢于访问内存）-----------空间换时间

 内核寻找数据的第一站

页缓存是内核寻找文件系统数据的第一站，只有在页缓存中找不到需要的数据才会调用存储子系统从磁盘中读取数据。当某一数据被读取时，就会从磁盘中读入页缓存，后续再从缓存中读出去

页缓存动态进行，随着越来越多数据进入缓存，缓存区会增大，但存在最大空间。

当不能再增大缓存区时，释放掉最少使用到的页来腾出空间存储硬盘读取的数据，或者和硬盘交换一块很少使用的数据。使用哪种方式，Linux内核使用了平衡交换数据和清理页缓存的启发式方法。可以通过配置一个值来改变倾向，值偏高时倾向于页缓存保留（硬盘交换数据），较低时偏向于清理缓存

页缓存预读机制 -每次读请求时会从磁盘数据中读取更多的数据到内存中（减少读取磁盘的次数），当内核读取磁盘一块数据时，也会读取其后1/2块数据。内核可以在进程操作第一块读取的内存数据时完成预读，等进程对下一块硬盘数据发出请求时直接将预读数据交过去而不需要再进行I/O操作

内核管理预读 -当某个进程持续使用预读来的数据，内核会增加预读窗口，预读更多的数据。

页回写

向硬盘中写入数据利用了缓存区机制（具体参考write()函数），进程发出写请求时，写入的数据会被拷贝到一片缓存区中并标记该缓存区为‘脏’内存，当对同一片缓存区进入二次写操作时也只是对缓存区数据进行更新。

最终要将‘脏’数据写入硬盘实现内存和硬盘的数据同步，这一过程称为“回写”

触发回写机制

1. 缓存区空闲内存小于某个值时，回写到硬盘中
2. 脏的缓存区寿命超过设定的阈值时间时回写到硬盘中

回写由内核线程pdflush操作，以上两个条件会触发该线程执行