学习笔记03-学习《精通UNIX下C语言编程及项目实践》

六、低级文件编程库

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

  低级文件编程库听起来似乎低级, 其实它是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中的设备分为块设备和字符设备. 块设备主要应用于随机采取中; 而字符设备常应用于顺序采取中.

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