学习笔记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 中的设备分为块设备和字符设备 . 块设备主要应用于随机采取中 ; 而字符设备常应用于顺序采取中 .

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