Linux系统编程-文件操作

最基本的访问文件方法是：使用read()和write()系统调用。在一个文件能被访问之前，必须通过open()

或者creat()系统调用打开它，一旦使用完毕，则用close()系统调用来关闭文件。

1.open

#include

#include

#include

int open(const char *pathname, int flags);

int open(const char *pathname, int flags, mode_t mode);

返回值：成功返回新分配的文件描述符，出错返回-1并设置errno

eg:

int fd;

fd = open("/home/kidd/aaa",O_RDONLY);

if(fd == -1)

/*error*/

pathname 参数是要打开或创建的文件名,和fopen一样，pathname 既可以是相对路径也可以是绝对路径。

flags参数有一系列常数值可供选择，可以同时选择多个常数用按位或运算符连接起来，

所以这些常数的宏定义都以O_开头，表示or 。

以下三个三先一：

O_RDONLY 只读打开

O_WRONLY 只写打开

O_RDWR 可读可写打开

以下可多选（以或的形式）（进行按位或运算，用以修改打开文件请求的行为）

O_APPEND

表示追加。如果文件已有内容，这次打开文件所写的数据附加到文件的末尾而不覆盖原来的内容。

（文件将以追加模式下打开。就是说，在每次写操作之前，文件位置指针将被置于文件末尾，即使

在进程刚刚完成写操作并改变文件位置指针之后，如有另一进程开始写操作，情形也是如此。）O_CREAT

若此文件不存在则由（内核来）创建它。使用此选项时需要提供第三个参数mode，表示该文件的访问权限。

有0666。如果文件已存在，本标志无效，除非给出了O_EXCL标志。

当文件创建时，mode参数提供新建文件的权限。系统并不在该次打开文件时检查权限，所以你可以进行相反的操作，例如设置文件为只读权限，但却在打开文件后进行写操作。最终写入磁盘的权限位还需让mode参数与用户文件创建的掩码（即umask）做按位与操作后来确定。 umask 022,mode 0666,文件权限为0644（0666&~022）

O_EXCL

如果同时指定了O_CREAT，并且文件已存在，则出错返回。（用来防止文件创建时出现单键竞争。）O_TRUNC

如果文件已存在且为普通文件，并且以只写或可读可写方式打开，则将其长度截断（Truncate）为0字节。

对于FIFO或者终端设备，该参数被忽略。在其他文件类型上则没有定义。因为截断文件需要写权限，所以O_TRUNC和O_RDONLY同时使用也是没有定义的。

eg: int fd;

fd = open("/home/teach/pearl", O_WRONLY|O_TRUNC);

if(fd == -1)

/*error*/

O_NONBLOCK

对于设备文件，以O_NONBLOCK方式打开可以做非阻塞I/O （Nonblock I/O ）。

例子：下面的代码对文件file进行写操作。如果文件不存在，且假定umask值为022，将建立权限值为0644的文件（即使mode参数指定为0664）。如果文件已存在，它的长度会被截断成0。

int fd;

fd =

open(file,O_WRONLY|O_CREAT|O_TRUNC,S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH);

if(fd == -1)

/*error*/

补充：mode参数可以是以下内容：

S_IRWXU 所有者拥有读写和执行权限

S_IRUSR 所有者拥有读权限

S_IWUSR 所有者拥有写权限

S_IXUSR 所有者拥有执行权限

S_IRWXG 组拥有读写和执行权限

S_IRGRP 组拥有读权限

S_IWGRP 组拥有写权限

S_IXGRP 组拥有执行权限

S_IRWXO 任何其他人都有读写和执行权限

S_IROTH 任何其他人都有读权限

S_IWOTH 任何其他人都有写权限

S_IXOTH 任何其他人都有执行权限

函数与C 标准I/O 库的fopen函数有些细微的区别：

1 以可写的方式fopen一个文件时，如果文件不存在会自动创建，而open一个文件时必须明

确指定O_CREAT才会创建文件，否则文件不存在就出错返回。

2 以w 或w+方式fopen一个文件时，如果文件已存在就截断为0 字节，而open一个文件时必须

明确指定O_TRUNC才会截断文件，否则直接在原来的数据上改写。

第三个参数mode指定文件权限，可以用八进制数表示，比如0644表示-rw-r--r--

实验

1.umask

0022

用touch命令创建一个文件时，创建权限是0666，而touch进程继承了Shell进程的umask掩码，

所以最终的文件权限是0666&~022=0644 。

2.touch aaa.c

ll aaa.c

-rw-r--r-- 1 root root 0 01-30 14:18 aaa.c

同样道理，用gcc 编译生成一个可执行文件时，创建权限是0777，而最终的文件权限

是0777&~022=0755 。

gcc aaa.c

ll a.out

-rwxr-xr-x 1 root root 4943 01-30 14:20 a.out

3.umask 0

再重复上述实验

Given a pathname for a file, open() returns a file descriptor, a small, non-negative integer for use in

subsequent system calls (read(2), write(2), lseek(2),

fcntl(2), etc.). The file descriptor returned by a suc-

cessful call will be the lowest-numbered file descriptor

not currently open for the process.

The parameter flags must include one of the following access modes: O_RDONLY, O_WRONLY, or O_RDWR. These

request opening the file read-only, write-only, or

read/write, respectively.

In addition, zero or more file creation flags and file status flags can be bitwise-or’d in flags. The file

creation flags are O_CREAT, O_EXCL, O_NOCTTY, and

O_TRUNC. The file status flags are all of the remaining

flags listed below. The distinction between these two

groups of flags is that the file status flags can be

retrieved and (in some cases) modified using fcntl(2).

The full list of file creation flags and file status

flags is as follows:

O_APPEND

The file is opened in append mode. Before each

write(), the file offset is positioned at the end

of the file, as if with lseek(). O_APPEND may

lead to corrupted files on NFS file systems if

more than one process appends data to a file at

once. This is because NFS does not support

appending to a file, so the client kernel has to

simulate it, which can’t be done without a race

condition.

O_CREAT

If the file does not exist it will be created.

The owner (user ID) of the file is set to the

effective user ID of the process. The group own-

ership (group ID) is set either to the effective

group ID of the process or to the group ID of the

parent directory (depending on filesystem type

and mount options, and the mode of the parent

directory, see, e.g., the mount options bsdgroups

and sysvgroups of the ext2 filesystem, as

described in mount(8)).

O_EXCL

When used with O_CREAT, if the file already

exists it is an error and the open() will fail.

In this context, a symbolic link exists, regard-

less of where it points to. O_EXCL is broken on

dition. The solution for performing atomic file

locking using a lockfile is to create a unique

file on the same file system (e.g., incorporating

hostname and pid), use link(2) to make a link to

the lockfile. If link() returns 0, the lock is

successful. Otherwise, use stat(2) on the unique

file to check if its link count has increased to

2, in which case the lock is also successful.

O_NONBLOCK or O_NDELAY

When possible, the file is opened in non-blocking

mode. Neither the open() nor any subsequent oper-

ations on the file descriptor which is returned

will cause the calling process to wait. For the

handling of FIFOs (named pipes), see also

fifo(7). For a discussion of the effect of

O_NONBLOCK in conjunction with mandatory file

locks and with file leases, see fcntl(2).

O_TRUNC

If the file already exists and is a regular file

and the open mode allows writing (i.e., is O_RDWR

or O_WRONLY) it will be truncated to length 0.

If the file is a FIFO or terminal device file,

the O_TRUNC flag is ignored. Otherwise the effect

of O_TRUNC is unspecified.

The argument mode specifies the permissions to use in case a new file is created. It is modified by the pro- cess’s umask in the usual way: the permissions of the created file are (mode & ~umask). Note that this mode only applies to future accesses of the newly created file; the open() call that creates a read-only file may well return a read/write file descriptor.

RETURN VALUE

open() and creat() return the new file descriptor, or -1 if an error occurred (in which case, errno is set appro- priately).

ERRORS

EACCES

The requested access to the file is not allowed,

or search permission is denied for one of the

directories in the path prefix of pathname, or

the file did not exist yet and write access to

the parent directory is not allowed. (See also

EEXIST

pathname already exists and O_CREAT and O_EXCL

were used.

EFAULT

pathname points outside your accessible address space.

creat() is equivalent to open() with flags equal to

O_CREAT|O_WRONLY|O_TRUNC.

creat("aa.c",0666); open("aa.c",O_CREAT|O_WRONLY|O_TRUNC,0666);

2.close

#include

int close(int fd);

返回值：成功返回0 ，出错返回-1并设置errno

close()调用解除了已打开的文件描述符的关联，并分离进程和文件的关联。给定的文件描述符不再有效，内核可以随意将其作为随后的open()或creat()调用的返回值而重新使用。

用法：

if(close(fd) == -1)

perror("close");

参数fd是要关闭的文件描述符。需要说明的是，当一个进程终止时，内核对该进程所有尚未关闭的文件描述符调用close关闭，所以即使用户程序不调用close，在终止时内核也会自动关闭

它打开的所有文件。但是对于一个长年累月运行的程序（比如网络服务器），打开的文件描述

符一定要记得关闭，否则随着打开的文件越来越多，会占用大量文件描述符和系统资源。

要注意的是：关闭文件和文件写入磁盘没什么关系。如果想保证文件在关闭前写到磁盘中，需要使用一个先前在“同步I/O”中讨论的同步选项。

关闭文件的副作用：当最后一个引用某文件的文件描述符关闭后，在内核中表示该文件的数据结构就被释放了。当它释放时，与文件关联的inode的内存拷贝被清除。如果没什么连接到该inode了，它可能会从内存中清除（也有可能保留在内存中，因为内核为了效率缓存一些inode，但也可能不需要）。如果文件已经从磁盘上解除链接，但在解除前仍保持打开，它在被关闭且inode从内存中移除前就不会真的被删除。因而，对close()的调用可能会使某个已解除链接的文件最终从磁盘上被删除。

================================================================================== close()

closes a file descriptor, so that it no longer

refers to any file and may be reused. Any record locks

(see fcntl(2)) held on the file it was associated with,

and owned by the process, are removed (regardless of the

file descriptor that was used to obtain the lock).

3作业

1.打开文件/home/akae.txt用于写操作，以追加方式打开.

int fd;

fd = open("/home/akae.txt", O_WRONLY | O_APPEND);

perror("open");

exit(1);

}

2.打开文件/home/akae.txt用于写操作，如果该文件不存在则创建它，创建权限为0666.

fd = open("/home/akae.txt", O_WRONLY | O_CREAT,0666);

if (fd == -1)

{

perror("open");

exit(1);

}

3.打开文件/home/akae.txt用于写操作，如果该文件已存在则截断为0 字节，如果该文件不

存在则创建它，创建权限为0666.

fd = open("/home/akae.txt", O_WRONLY|O_CREAT|O_TRUNC,0666);

4.打开文件/home/akae.txt用于写操作，如果该文件已存在则报错退出，如果该文件不存在

则创建它，创建权限为0666.

fd = open("/home/akae.txt", O_WRONLY|O_CREAT|O_EXCL|O_TRUNC,0666);

---------------------------------------------------------------------------------- 3 creat()函数

O_WRONLY|O_CREAT|O_TRUNC 组合经常被使用，以至于专门有个系统调用来实现

#include

#include

#include

int creat(const char *name, node_t mode);

典型的creat()调用如下：

int fd;

fd = creat(file,0644);

if(fd == -1)

/*error*/

等价于：

int fd;

fd = open(file,O_WRONLY|O_CREAT|O_TRUNC,0644);

if(fd == -1)

/*error*/

即使可以在用户空间上简单creat()的功能，但是在大部分Linux架构上creat()是一个系统调用：int creat(const char *name,int mode)

{

return open(name,O_WRONLY|O_CREAT|O_TRUNC,mode);

}

open()和creat()调用成功时都返回一个文件描述符（int型）。错误时都返回-1，并将errno设置为一个合适的错误值。处理文件打开的错误并不复杂，一般来说，在的打开文件操作前不需要什么处理，典型的方式是提示用户换个文件或终止程序。

------------------------------------------------------------------------------------- 4 read函数从打开的设备或文件中读取数据

#include

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

该系统调用从由fd指向的文件的当前偏移量至多读count个字节到buf中。成功时，将返回写入buf中的字节数。出错时返回-1，并设置errno.fd所指文件位置指针将会向前移动，移动的长度由之前读取的字节数决定。如果无法在该文件（比如一个字符设备文件）中确定文件位置，读操作总是从“当前”位置开始。

参数count是请求读取的字节数，读上来的数据保存在缓冲区buf 中，同时文件的当前读写位置向后移。注意返回值类型是ssize_t，表示有符号的size_t ，这样既可以返回正的字节数、0 （表示到达文件末尾）也可以返回负值-1 （表示出错）。read函数返回时，返回值说明了buf 中前多少个字节是刚读上来的。有些情况下（比如马上到文件末尾了，不够count个字节了），实际读到的字节数（返回值）会小于请求读的字节数count.

例如：

1,读常规文件时，在读到count个字节之前已到达文件末尾。例如，距文件末尾还有30个字

节而请求读100 个字节，则read返回30，下次read将返回0 。

2,从终端设备读，通常以行为单位，读到换行符就返回了。

3,从网络读，根据不同的传输层协议和内核缓存机制，返回值可能小于请求的字节数，后

面socket 编程部分会详细讲

例子:

从fd所指的文件中读取数据并保存到word中，读取字节数等于unsigned long类型的大小，在32位Linux 系统上是4字节，而在64位系统则是8字节。返回时，nr保存读取字节数，如果出错，则nr为-1：unsigned long word;

ssize_t nr;

/*read a couple bytes into 'word' from 'fd' */

nr = read(fd,&word,sizeof(unsigned long)); //把指针fd的数据读取到word中,读count个if(nr == -1)

/*error*/

可能出现的问题：

1,返回一个比count小的非0正整数。可能可供读取的字节数本来就比count要少、系统调用可能被信号打断、管理可能被破坏（如果fd是个管道）......

2,返回0。当已位于文件尾时，read()系统调用返回0，说明已经到达文件结尾（EOF），这种情况下当然没有字节被读入。EOF并不是一种错误，也回此不用返回-1;它仅仅表示文件位置指针已经位于文件最

后一个有效偏移量之后，之后没有任何数据可读了。然而，如果一个调用需要读count个字节，但

却没一个字节可读，调用将阻塞（睡眠），直到那些字节可以读取为止（假设文件描述符没有在非阻塞

模式下打开）。注意这与返回EOF时不同。就是，“没有数据可读”和“数据末尾”是不同的。在EOF的

情况下，到达了文件末尾。在阻塞的情况下，读操作在等待更多的数据--例如在从套接字或者设备文件

读取的时候。

有些错误是可以恢复的。比如，当read()调用在未读取任何字节前被一个信号打断，它会返回-1（如果为0，则可能和EOF混淆），并设置errno为EINTR。在这种情况下，你可以重新提交读取请求。

对read()的调用会出现的结果：

1,调用返回一个等于count的值。所有count个被读取字节存储在buf中。结果和预期一致。

2,调用返回值在(0~count)之间。读取的字节存入buf中。这种情况出现在一个信号打断了读取过程，或在读取中发生了一个错误，有效字节大于0，但比count字节少时，或者在读入count个字节前已抵达EOF。

再次进行读取（更新了buf和count的值）将读入剩余字节到buf的剩余空间中，或者指出问题发生的原因。

3,调用返回0.这标志着EOF。没有可以读入的数据。

4,调用阻塞了，因为没有可用的用来读取的数据。这在非阻塞模式下不会发生；

5,调用返回-1.并且errno被设置为EINTR。这表示在读入字节之前收到了一个信号。可以重新进行调用。

6,调用返回-1，并且errno被设置为EAGAIN。这表示读取会因没有可用的数据而阻塞，而读请求应该在之后重开。这只在非阻塞模式下发生。

====================================================

DESCRIPTION

read() attempts to read up to count bytes from file

descriptor fd into the buffer starting at buf.

RETURN VALUE

On success, the number of bytes read is returned (zero

indicates end of file), and the file position is

advanced by this number. It is not an error if this

number is smaller than the number of bytes requested;

this may happen for example because fewer bytes are

actually available right now (maybe because we were

close to end-of-file, or because we are reading from a

pipe, or from a terminal), or because read() was inter-

rupted by a signal. On error, -1 is returned, and errno

is set appropriately.

ERRORS

EAGAIN

Non-blocking I/O has been selected using O_NON-BLOCK

and no data was immediately available forreading.

EINTR

The call was interrupted by a signal before any data was read.

读入所有的字节方法：

想要处理所有的错误，并且读入所有count个字节（至少读到EOF）：

ssize_t ret;

while(count !=0 && (ret = read(fd,buf,count))!=0)

{

if(ret == -1)

{

if(errno == EINTR)

continue;

perror("read");

break;

}

count -= ret;

buf += ret;

}

/*

*这段代码处理了所有五种情况。循环从fd所指的当前文件位置读入count个字节到buf中，读入会一直*到读完所有count个字节或者到EOF为止。如果读入了多于0个但少于count个字节，从count中减去*已读字节数，buf增加相应数量的字节数，并重新调用read()。如果调用返回了-1，并且errno等于EINTR *,将重新调用且不更新参数。如果调用返回-1，且errno被设置为其他值，将调用perror()来向标准错*误打印一条描述并终止循环。

*/

非阻塞读：

在没有可读数据时，让调用立即返回，被成为非阻塞I/O。它允许应用在从不阻塞的状况下进行I/O操作，如果

返回-1，且设置errno 为EAGAIN 面不是阻塞掉。在进行非阻塞I/O 时，必须检查EAGAIN ，否则将可能因数据缺失面导致严重的错误。

char buf[100]; //100也可以是其他数字

ssize_t nr;

if(count >SSIZE_MAX)

count = SSIZE_MAX;

start:

nr = read(fd,buf,100);//一个count 为0的read()调用结果是立即返回，且返回值为0

if(nr == -1)

{

if(errno == EINTR) goto start;/*oh shush*/

if(errno == EAGAIN)

/*resubmit later*/

else

/*error*/

}

5.write()函数向打开的设备或文件中写数据

SYNOPSIS

#include

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

一个write()调用从由文件描述符fd 引用文件的当前位置开始，将buf 中至多count 个字节写入文件中。不支持定位的文件（像字符设备）总是从“开头”开始写。

成功时，返回写入字节数，并更新文件位置。错误时，返回-1，并将errno 设置为相应的值。一个write()可以返回0，但这种返回值没有任何特殊含义，只是表示写入了0个字节。

基本用法：

const char *buf = "my ship is solid!";

ssize_t nr;

/*write the string in 'buf' to 'fd'*/

nr = write(fd,buf,strlen(buf));

if(nr == -1)

/*error*/

与read()一样，这种简单用法并不大合适，调用者也需要检查出现部分写的各种可能情况：

unsigned long word = 1720;

size_t count;

ssize_t nr;

count = sizeof(word);

nr = write(fd,buf,count);

if(nr == -1)

/*error*/

if(nr != count)

/*possible error,but 'errno' not set*/

写常规文件时，write 的返回值通常等于请求写的字节数count ，而向终端设备或网络写则不一 在处理EAGAIN 时使用一个goto start 可能实际上没什么意义--大概只需要不使用非阻塞I/O 即可。使用它并不能节省时间，相反还引入了更多的循环带来的开销。

网络读则不一定，如果从终端输入的数据没有换行符，调用read读终端设备就会阻塞，如果网

络上没有接收到数据包，调用read从网络读就会阻塞，至于会阻塞多长时间也是不确定的，如

果一直没有数据到达就一直阻塞在那里。同样，写常规文件是不会阻塞的，而向终端设备或网

络写则不一定。

相对于read()的返回部分读的情况，write()不太可能返回一个部分写的结果。而且，对write()系统调用来说没有EOF情况。对于普通文件，除非发生一个错误，否则write()将保证写入所有的请求。对于普通文件，就不需要进行循环写了。然而对于其他类型--例如套接字---大概得有个循环来保证你真的写入了所有请求原字节。使用循环的另一个好处是，第二次write()调用可能会返回一个错误值用来说明第一次调用为什么进行了一部分写（尽管这种情况不大常见）。请看下面代码：

ssize_t ret,nr;

while(count != 0 && (ret = write(fd,buf,count)) !=0)

{

if(ret == -1)

{

if(errno == EINTR)

continue;

perror("write")

break;

}

}

非阻塞写：

当fd在非阻塞模式下打开时（通过设置O_NONBLOCK参数），并且发起的写操作会正常阻塞时，writ()系统调用返回-1，并设置errno值为EAGAIN。请求应该在稍后重新发起，通常处理变通文件时不会出现这种事。

write()大小限制：

如果count比SSIZE_MAX还大，write()调用的结果是未定义的。count值为0的write()调用将立即返回且返回值为0.

==================================================

DESCRIPTION

write() writes up to count bytes to the file referenced

by the file descriptor fd from the buffer starting at

buf. POSIX requires that a read() which can be proved

to occur after a write() has returned returns the new

data. Note that not all file systems are POSIX conform-

ing.

RETURN VALUE

On success, the number of bytes written are returned

(zero indicates nothing was written). On error, -1 is

returned, and errno is set appropriately. If count is

zero and the file descriptor refers to a regular file, 0

may be returned, or an error could be detected. For a

special file, the results are not portable.

ERRORS

EAGAIN

Non-blocking I/O has been selected using O_NON-

BLOCK and the write would block.

EINTR

The call was interrupted by a signal before any

data was written.

现在明确一下阻塞（Block）这个概念。当进程调用一个阻塞的系统函数时，该进程被置于睡眠

（Sleep）状态，这时内核调度其它进程运行，直到该进程等待的事件发生了（比如网络上接收

到数据包，或者调用sleep指定的睡眠时间到了）它才有可能继续运行。与睡眠状态相对的是运

行（Running ）状态，在Linux内核中，处于运行状态的进程分为两种情况：

1. 正在被调度执行。CPU处于该进程的上下文环境中，程序计数器（eip ）里保存着该进程

的指令地址，通用寄存器里保存着该进程运算过程的中间结果，正在执行该进程的指令，

正在读写该进程的地址空间。

2. 就绪状态。该进程不需要等待什么事件发生，随时都可以执行，但CPU暂时还在执行另一

个进程，所以该进程在一个就绪队列中等待被内核调度。系统中可能同时有多个就绪的进

程，那么该调度谁执行呢？内核的调度算法是基于优先级和时间片的，而且会根据每个进

程的运行情况动态调整它的优先级和时间片，让每个进程都能比较公平地得到机会执行，

同时要兼顾用户体验，不能让和用户交互的进程响应太慢。

------------------------------------------------------------------------------------- 6、用lseek()查找

#include

#include

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

调用在成功时返回新文件位置。错误时返回-1并设置适当的errno值。

lseek()的行为依赖于初始参数，可以为以下值之一：

SEEK_CUR 当前文件位置fd设置为当前值加上pos，pos可以为负值、0、正值。一个为0的pos返回当前文件位置值。

SEEK_END 当前文件位置fd设置为当前文件长度加上pos，pos可以为负值、0、正值。一个为0的pos 设置偏移量为文件末尾。

SEEK_SET 当前文件位置fd设置为pos,一个为0的pos设置偏移量为文件起始。

例子：

--设置文件位置fd为1825：

off_t ret;

ret = lseek(fd,(off_t)1825,SEEK_SET);

if(ret == (off_t)-1)

/*error*/

--设置文件位置fd到文件末尾：

off_t ret;

ret = lseek(fd, 0, SEEK_END);

if(ret == (off_t)-1)

/*error*/

--用SEEK_CUR和0值来确定文件当前位置：(由于lseek()返回更新过的文件位置)

int pos;

pos = lseek(fd,0,SEEK_CUR)

if(pos == (off_t)-1)

/*error*/

else

/*'pos' is the current position(位置) of fd*/