六、低级文件编程库

  低级文件编程库常常用于访问终端、管道、设备和套接字等特殊文件, 一般不用于普通磁盘文件, 这是标准文件编程库的特长.

  低级文件编程库听起来似乎低级, 其实它是UNIX中的I/O系统调用. 它们使用文件描述符, 直接读写各类文件.

  低级文件编程库在输入输出上只有块读写的功能.

文件锁

  多用户多任务操作系统非常重要的一个内容就是文件锁. 用户在更新文件时, 期望可以使用某种机制, 防止两进程同时更新文件同一区域而造成写丢失, 或者防止文件内容在未更新完毕时被读取等并发引起的问题, 这种机制就是文件锁.

  进程在操作文件期间, 可以使用文件锁, 锁定文件中的敏感信息, 防止其他进程越权操作该部分信息. 函数fcntl提供了对文件任意区域设置锁的能力, 既可以锁住全部文件, 又可以锁住文件的部分记录, 故文件锁又称为'记录锁'.

  根据文件锁的访问方式, 可以区分为读锁和写锁两种. 文件记录在同一时刻, 可以设置多个读锁, 但仅能设置一个写锁, 并且读写锁不能同时存在.

  当函数fcntl专用于锁操作时, 其原型为

int fcntl(int fildes, int cmd, struct flock *arg);

  其中, 结构flock用于描述文件锁的信息, 定义于头文件'fcntl.h'中, 如下所示

struct flock {
      short l_type;    // 锁类型, 取值为F_RDLCK, F_WRLCK或F_UNLCK之一
      short l_whence;  // 锁区域开始地址的相对位置, 取值为SEEK_SET, SEEK_CUR或SEEK_END之一
      off_t l_start;    // 锁区域开始地址偏移量
      off_t l_len;     // 锁区域的长度, 0表示锁至文件末
      pid_t l_pid;    // 拥有锁的进程ID号
};

  函数fcntl在专用于锁操作时, 参数cmd有三种取值:

  (a) F_GETLK. 获取文件描述符fileds对应文件指定区域的文件锁信息.

  (b) F_SETLK. 在文件描述符fileds对应的文件中指定区域设置锁信息.

  (c) F_SETLKW. 该命令是F_SETLK命令的阻塞版本.

  文件锁最典型应用于两个方面: 一是锁定文件中的临界数据, 比如并发投票时文件记录的投票数; 二是利用具有互斥性质的写锁, 实现进程的并发控制.

  在锁机制的使用中,最常见的操作有锁的请求, 释放和测试等, 下面一一说明.

  (a) 测试锁. 设计函数SeeLock, 查询文件描述符fd对应文件的锁信息.

void SeeLock(int fd, int start, int len)
{                             // 查询描述符fd对应文件从start处开始的len字节中的锁信息
        struct flock arg;
 
        arg.l_type = F_WRLCK;
        arg.l_whence = SEEK_SET;
        arg.l_start = start;
        arg.l_len = len;
 
        if(fcntl(fd, F_GETLK, &arg) == -1)
                 fprintf(stderr, "See Lock failed.\n");
        else if(arg.l_type == F_UNLCK)
                 fprintf(stderr, "No Lock From %d to %d\n", start, start+len);
        else if(arg.l_type == F_WRLCK)
                 fprintf(stderr, "Write Lock From %d to %d, id = %d\n", start, start+len, arg.l_pid);
        else if(arg.l_type == F_RDLCK)
                 fprintf(stderr, "Read Lock From %d to %d, id = %d\n", start, start+len, arg.l_pid);
}

  (b) 申请读锁. 以阻塞方式设计共享读锁申请函数GetReadLock.

void GetReadLock(int fd, int start, int len)
{                          // 以阻塞方式在描述符fd对应文件中从start处的len字节上申请共享读锁
        struct flock arg;
 
        arg.l_type = F_RDLCK;
        arg.l_whence = SEEK_SET;
        arg.l_start = start;
        arg.l_len = len;
                                                                                                                                              
        if(fcntl(fd, F_SETLKW, &arg) == -1)
                fprintf(stderr, "[%d] See Read Lock failed.\n", getpid());
        else
                fprintf(stderr, "[%d] Set Read Lock From %d to %d\n", getpid(), start, start+len);
}

  (c) 申请写锁. 以阻塞方式设计互斥写锁申请函数GetWrtieLock.

void GetWriteLock(int fd, int start, int len)
{                      // 以阻塞方式在描述符fd对应文件中从start处的len字节上申请互斥写锁 
        struct flock arg;
                                                                                                                                              
        arg.l_type = F_WRLCK;
        arg.l_whence = SEEK_SET;
        arg.l_start = start;
        arg.l_len = len;
                                                                                                                                              
        if(fcntl(fd, F_SETLKW, &arg) == -1)
                fprintf(stderr, "[%d] See Write Lock failed.\n", getpid());
        else
                fprintf(stderr, "[%d] Set Write Lock From %d to %d\n", getpid(), start, start+len);
}

  (d) 释放锁. 设计文件锁释放函数ReleaseLock.

void ReleaseLock(int fd, int start, int len)
{                      // 在描述符fd对应文件中释放从start处的len字节上的锁 
        struct flock arg;
                                                                                                                                              
        arg.l_type = F_UNLCK;
        arg.l_whence = SEEK_SET;
        arg.l_start = start;
        arg.l_len = len;
                                                                                                                                              
        if(fcntl(fd, F_SETLKW, &arg) == -1)
                fprintf(stderr, "[%d] UnLock failed.\n", getpid());
        else
                fprintf(stderr, "[%d] UnLock From %d to %d\n", getpid(), start, start+len);
}

  下面设计一个文件锁控制进程的实例lock1. 为了观察阻塞方式下的锁申请, 在释放锁前休眠30秒.

#include <stdio.h>
#include <fcntl.h>
 
int main()
{
        int fd;
        struct flock arg;
 
        if((fd = open("/tmp/tlockl", O_RDWR | O_CREAT, 0755)) < 0){
                 fprintf(stderr, "open file failed.\n");
                 exit(1);
        }
 
        SeeLock(fd, 0, 10);
        GetReadLock(fd, 0, 10);
        SeeLock(fd, 11, 20);
        GetWriteLock(fd, 11, 20);
        sleep(30);
        ReleaseLock(fd, 0, 10);
        ReleaseLock(fd, 11, 20);
 
        return 0;
}

  下面是执行情况:

[bill@billstone Unix_study]$ make lockl
cc     lockl.c   -o lockl
[bill@billstone Unix_study]$ ./lockl &           // 先在后台执行
[2] 12725
No Lock From 0 to 10
[12725] Set Read Lock From 0 to 10
No Lock From 11 to 31
[12725] Set Write Lock From 11 to 31        // 此后休眠30秒
[bill@billstone Unix_study]$ ./lockl             // 再次执行
Read Lock From 0 to 10, id = 12725
[12726] Set Read Lock From 0 to 10          // 可在同一区域申请多个共享读锁
Write Lock From 11 to 31, id = 12725
[12725] UnLock From 0 to 10
[12725] UnLock From 11 to 31
[12726] Set Write Lock From 11 to 31        // 在同一区域只能申请一个互斥写锁
[12726] UnLock From 0 to 10
[12726] UnLock From 11 to 31
[2]+  Done                    ./lockl
[bill@billstone Unix_study]$

  七 目录文件编程库

  UNIX专门给出了一组用于目录操作的函数, 可以方便地获取目录项的确切含义.

工作目录

  进程在搜索文件相对路径时都会有一个起始点, 这个起始点称为'当前工作目录'. 在UNIX中对工作目录的操作可分为读取工作目录和更改工作目录两种.

  (1) 读取工作目录. 函数getcwd和getwd都返回工作目录的绝对路径

#include <unistd.h>
char *getcwd(char *buf, size_t size);
char *getwd(char *pathname);

  (2) 更改工作目录.

#include <unistd.h>
int chhdir(const char *path);
int fchdir(int fildes);

  下面是一个读取和更改当前工作目录的例子

[bill@billstone Unix_study]$ cat dirl.c
#include <unistd.h>
#include <stdio.h>
 
int main()
{
        char buf[255];
 
        fprintf(stderr, "pwd = [%s] \n", getcwd(buf, sizeof(buf)));
        chdir("../");               // 更改工作目录为上一级目录
        fprintf(stderr, "pwd = [%s] \n", getcwd(buf, sizeof(buf)));
 
        return 0;
}
[bill@billstone Unix_study]$ make dirl
cc     dirl.c   -o dirl
[bill@billstone Unix_study]$ pwd
/home/bill/Unix_study
[bill@billstone Unix_study]$ ./dirl
pwd = [/home/bill/Unix_study]
pwd = [/home/bill]                      ; 更改成功
[bill@billstone Unix_study]$ pwd
/home/bill/Unix_study                    ; 不影响当前Shell的工作目录
[bill@billstone Unix_study]$

  读取目录

  '目录文件编程库'不提倡直接更改目录文件内容, 它仅仅执行读取操作

#include <dirent.h>
DIR *opendir(const char *dirname);
struct dirent *readdir(DIR *dirp);
int closedir(DIR *dirp);

  函数opendir打开目录文件dirname, 并返回一个目录流, 存储为DIR结构.

  函数readdir读取当前目录项内容存入参数dirp指向的结构dirent中, 并移动目录文件指针到下一目录项. 目录中每个目录项采用结构dirent描述.

struct dirent {
        long            d_ino;         // 文件对应i节点编号
        __kernel_off_t  d_off;
        unsigned short  d_reclen;
        char            d_name[256];   // 文件名称
};

  下面是一个简单的读取目录程序ls2, 它列举了目录下的全部文件及其对应的i节点编号.

[bill@billstone Unix_study]$ cat ls2.c
#include <stdio.h>
#include <dirent.h>
 
int main(int argc, char **argv)
{
        DIR *pdir;
        struct dirent *pent;
 
        if(argc !=2){
                fprintf(stderr, "Usage: ls2 <directory>\n");
                return 0;
        }
        if((pdir = opendir(argv[1])) == NULL){
                fprintf(stderr, "open dir failed.\n");
                exit(1);
        }
        while(1){
                if((pent = readdir(pdir)) == NULL)
                        break;
                fprintf(stderr, "%5d %s\n", pent->d_ino, pent->d_name);
        }
        closedir(pdir);
 
        return 0;
}

  执行结果如下:

[bill@billstone Unix_study]$ make ls2
cc     ls2.c   -o ls2
[bill@billstone Unix_study]$ ./ls2 /home/bill/Doc
134706 .
   29 ..
134708 学习笔记.doc
[bill@billstone Unix_study]$ ls -ai /home/bill/Doc
 134706 .       29 ..   134708 学习笔记.doc

  八 设备文件

  对于UNIX程序员来说, 操作设备只是一件非常简单的事, 因为UNIX中的所有设备文件都是文件,称为设备文件.

  UNIX中的设备分为块设备和字符设备. 块设备主要应用于随机采取中; 而字符设备常应用于顺序采取中.

  对设备文件的操作一般分为打开、设置、读写和关闭几部分.

《精通UNIX下C语言编程及项目实践》学习笔记目录
http://bbs.pediy.com/showthread.php?t=86392

编译ls2.c时，出现了两条警告信息：
ls2.c: 在函数‘main’中:
ls2.c:18: 警告： 隐式声明与内建函数‘exit’不兼容
ls2.c:24: 警告： 格式‘%5d’需要类型‘int’，但实参 3 的类型为‘__ino_t’

我在运行其他教材的实例时也遇到过“隐式类型与内建函数‘exit’不兼容”的警告，添加＃include <stdlib.h>后警告消失。虽然无视警告也能运行程序，可是总觉得别扭。

我使用的是ubuntu8.10，是否与我使用的系统有关系，其他人有遇到同样的问题吗。。。

我貌似还没有遇到过此种问题，不过楼上给大家提了个醒，不错

顶了,那个问题其实就是没有包含头文件造成的,gcc 会连接到build-in 函数

楼主能不能提供下 打包下载？