您的位置：360文档中心› linux文件读写

linux文件读写

合集下载

linux读取文件命令

linux读取文件命令

linux读取文件命令Linux系统读取文件内容我们可以通过相关命令来实现，下面由店铺为大家整理了linux的读取文件命令的相关知识，希望对大家有帮助!linux的读取文件命令总结linux读取文件命令1.cat 与 taccat的功能是将文件从第一行开始连续的将内容输出在屏幕上。

但是cat并不常用，原因是当文件大，行数比较多时，屏幕无法全部容下时，只能看到一部分内容。

cat语法：cat [-n] 文件名 (-n ：显示时，连行号一起输出)tac的功能是将文件从最后一行开始倒过来将内容数据输出到屏幕上。

我们可以发现，tac实际上是cat反过来写。

这个命令也不常用。

tac语法：tac 文件名。

linux读取文件命令2.more和less(常用)more的功能是将文件从第一行开始，根据输出窗口的大小，适当的输出文件内容。

当一页无法全部输出时，可以用“回车键”向下翻行，用“空格键”向下翻页。

退出查看页面，请按“q”键。

另外，more还可以配合管道符“|”(pipe)使用，例如:ls -al | more more的语法：more 文件名Enter 向下n行，需要定义，默认为1行;Ctrl f 向下滚动一屏;空格键向下滚动一屏;Ctrl b 返回上一屏;= 输出当前行的行号;:f 输出文件名和当前行的行号;v 调用vi编辑器;! 命令调用Shell，并执行命令;q 退出moreless的功能和more相似，但是使用more无法向前翻页，只能向后翻。

less可以使用【pageup】和【pagedown】键进行前翻页和后翻页，这样看起来更方便。

less的语法：less 文件名less还有一个功能，可以在文件中进行搜索你想找的内容，假设你想在passwd文件中查找有没有weblogic字符串，那么你可以这样来做：[root@redhat etc]# less passwd然后输入：/weblogic回车此时如果有weblogic字符串，linux会把该字符已高亮方式显示。

Linux下C语言的文件读写

Linux下C语言的文件读写

Linux下C语言的文件（fputc,fgetc,fwrite,fread对文件读写操作）//==================================fputc 向文件写入字符#include <stdio.h>#include <stdlib.h>main(){FILE *fp;char ch;if((fp=fopen("test.txt","w"))==NULL){printf("不能打开文件\n");exit(0);}while ((ch=getchar())!='\n')fputc( ch, fp );fclose(fp);}-------------小提示：fp=fopen("test.txt","w") ，把"w"改为"a" 可以创建文件并且追加写入内容exit(0); 需要包含stdlib.h 头文件，才能使用//============================================================fgetc 读取字符#include <stdio.h>#include <stdlib.h>main( int argc, char *argv[] ){char ch;FILE *fp;int i;if((fp=fopen(argv[1],"r"))==NULL){printf("不能打开文件\n");exit(0);}while ((ch=fgetc(fp))!=EOF)putchar(ch);fclose(fp);}文件结尾，通过判断EOF//============================================================== fwrite 的使用使数组或结构体等类型可以进行一次性读写#include <stdio.h>#include <stdlib.h>main(){FILE *fp1;int i;struct student{char name[10];int age;float score[2];char addr[15];}stu;if((fp1=fopen("test.txt","wb"))==NULL){printf("不能打开文件");exit(0);}printf("请输入信息，姓名年龄分数1 分数2 地址:\n");for( i=0;i<2;i++){scanf("%s %d %f %f %s",,&stu.age,&stu.score[0],&stu.score[1], stu.addr);fwrite(&stu,sizeof(stu),1,fp1);}fclose(fp1);}//=============================================================== fread 的使用#include <stdio.h>#include <stdlib.h>main(){FILE *fp1;int i;struct student{char name[10];int age;float score[2];char addr[15];}stu;if((fp1=fopen("test.txt","rb"))==NULL){printf("不能打开文件");exit(0);}printf("读取文件的内容如下:\n");for (i=0;i<2;i++){fread(&stu,sizeof(stu),1,fp1);printf("%s %d %7.2f %7.2f %s\n",,stu.age,stu.score[0],stu.score[1],stu.addr);}fclose(fp1);}。

linux ext4 读写流程

linux ext4 读写流程

linux ext4 读写流程
Linux ext4 文件的读写流程涉及到多个环节，下面是详细的读写流程：
1. 用户层请求：用户层通过系统调用（如write() 函数）发起文件读写请求。

2. 系统调用处理：内核接收到用户层的读写请求后，会进行相应的处理。

例如，write() 函数会将数据缓冲到内核缓冲区，然后准备进行实际的磁盘写入。

3. 磁盘分配策略：ext4 文件系统根据磁盘空间情况和文件系统参数来决定如何分配新的数据块。

这一过程涉及到ext4 特定的磁盘分配策略，如扩展块分配（extend_block）和迁移块（move_block）等。

4. 文件系统元数据操作：内核会更新文件系统的元数据，如文件索引、文件大小、分配位图等，以反映磁盘上实际的数据变化。

5. 块设备操作：内核将数据从用户缓冲区拷贝到磁盘的ext4 块设备上。

这一过程涉及到块设备的I/O 操作，如block_write() 函数。

6. 同步和挂起：根据ext4 文件系统的配置，内核可能会在写入数据
后同步磁盘数据（如使用fsync() 函数）并挂起其他I/O 操作。

7. 完成操作：内核完成磁盘写入后，将返回结果给用户层，通知读写操作成功或失败。

读流程类似，只是在磁盘读取数据时，数据是从磁盘的ext4 块设备读取到内核缓冲区，然后传递给用户层。

需要注意的是，这里的读写流程是一个简化版，实际操作可能会根据具体情况进行调整。

ext4 文件系统的读写性能取决于多个因素，如磁盘性能、文件系统参数和内核优化等。

在不同场景下，ext4 文件系统的读写流程可能会有所不同。

Linux内核态文件读写相关函数API

Linux内核态文件读写相关函数API

Linux内核态⽂件读写相关函数API1、前⾔Linux系统中的⽂件系统由两层结构进⾏构建：第⼀层为虚拟⽂件系统（VFS），第⼆层则是各种不同的具体的⽂件系统。

VFS则是将各种具体的⽂件系统的公共部分抽取出来，从⽽形成⼀个抽象层，是Linux系统内核的⼀部分，它位于⽤户程序和具体的⽂件系统之间，对⽤户提供了标准的⽂件系统调⽤接⼝，对于具体的⽂件系统，通过⼀系列的对不同⽂件系统公⽤的函数指针来实际调⽤具体⽂件系统的函数，完成实际的各种差异操作。

对于⽤户，对⽂件的读写操作时，可以使⽤函数open()、read()、write()和close()等，当在Linux内核中，肯定是没有这些函数可以使⽤，这个时候，可以使⽤内核的⼀些函数filp_open()、vfs_read()、vfs_write()、和filp_close()等去完成⽂件的读写。

2、常⽤API接⼝接下来，简单介绍相关的内核API接⼝是如何使⽤的，对于filp_open()、filp_close()、vfs_read()、vfs_write()函数的声名在⽂件linux/fs.h中。

（1）⽂件打开filp_open函数原型如下：struct file *filp_open(const char *filename, int flags, umode_t mode);参数说明：filename：要打开或创建⽂件的字符串名称，包括路径部分；flags：⽂件的打开⽅式，该取值与open()函数类似，可以取O_CREATE、O_RDWR、O_RDONLY；mode：创建⽂件时使⽤该参数，设置⽂件的读写权限，其它情况可以设置为0。

返回值：⽂件打开成功返回正确的struct file *指针，失败返回错误的指针。

注意：函数filp_open()将返回struct file *结构指针，将会提供给后继的函数进⾏使⽤，需要使⽤IS_ERR()来校验指针的有效性。

linuxshell之终端读写文件数据流和重定向,,《,》

linuxshell之终端读写文件数据流和重定向,,《,》

linuxshell之终端读写⽂件数据流和重定向,,《,》终端实现⽂件中数据流的读写；重定向命令列表如下：命令说明command > file将输出重定向到 file。

将终端数据写到⽂件file中command < file将输⼊重定向到 file。

将⽂件command >> file将输出以追加的⽅式重定向到 file。

n > file将⽂件描述符为 n 的⽂件重定向到 file。

n >> file将⽂件描述符为 n 的⽂件以追加的⽅式重定向到 file。

n >& m将输出⽂件 m 和 n 合并。

n <& m将输⼊⽂件 m 和 n 合并。

<< tag将开始标记 tag 和结束标记 tag 之间的内容作为输⼊。

需要注意的是⽂件描述符 0 通常是标准输⼊（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。

这⾥可以⽤于⽇志打印到⽂件；输出重定向重定向⼀般通过在命令间插⼊特定的符号来实现。

特别的，这些符号的语法如下所⽰:command1 > file1上⾯这个命令执⾏command1然后将输出的内容存⼊file1。

注意任何file1内的已经存在的内容将被新内容替代。

如果要将新内容添加在⽂件末尾，请使⽤>>操作符。

实例执⾏下⾯的 who 命令，它将命令的完整的输出重定向在⽤户⽂件中(users):$ who > users执⾏后，并没有在终端输出信息，这是因为输出已被从默认的标准输出设备（终端）重定向到指定的⽂件。

你可以使⽤ cat 命令查看⽂件内容：$ cat users_mbsetupuser console Oct 31 17:35tianqixin console Oct 31 17:35tianqixin ttys000 Dec 1 11:33输出重定向会覆盖⽂件内容，请看下⾯的例⼦：$ echo "菜鸟教程：" > users$ cat users菜鸟教程：$如果不希望⽂件内容被覆盖，可以使⽤ >> 追加到⽂件末尾，例如：$ echo "菜鸟教程：" >> users$ cat users菜鸟教程：菜鸟教程：$输⼊重定向和输出重定向⼀样，Unix 命令也可以从⽂件获取输⼊，语法为：command1 < file1这样，本来需要从键盘获取输⼊的命令会转移到⽂件读取内容。

linux 读取文件的原理

linux 读取文件的原理

linux 读取文件的原理
Linux 读取文件的原理主要涉及到操作系统、文件系统和硬件等多个方面。

下面是一个简要的概述：
1.文件系统：Linux 系统使用的是类Unix 的文件系统，称为Ext4。

文件系统负责管理文件在硬盘上的存储和访问，以及文件的权限和属性等信息。

当一个程序试图读取一个文件时，文件系统会接收到这个请求，并查找文件在硬盘上的位置。

2.打开文件：要读取一个文件，首先需要打开这个文件。

在Linux 中，打开文件是通过系统调用（如open() 或fopen()）实现的。

这些系统调用会向操作系统发出请求，请求中包含文件名和打开文件的模式（例如只读、写入等）。

操作系统会查找文件并返回一个文件描述符，这个文件描述符是一个整数，用于标识已经打开的文件。

3.读取文件数据：一旦文件被打开，就可以通过系统调用（如read() 或fread()）来读取文件的内容。

这些系统调用会向操作系统发出请求，请求中包含文件描述符、读取的起始位置和要读取的字节数。

操作系统会将读取的请求传递给硬件，硬件会从硬盘中读取相应的数据，并将其存储在内存中。

4.关闭文件：当读取完文件后，需要通过系统调用（如close() 或fclose()）来关闭文件。

这个系统调用会将文件描述符释放回操作系统，以便其他程序可以使用它。

linux读写权限解析

linux读写权限解析

linux读写权限解析
在Linux 系统中，每个文件和目录都有一组读写权限，用于控制对它们的访问。

这些权限分为三个部分：所有者、组和其他用户。

每个部分都有读、写和执行权限，可以用数字表示，如下所示：
- 4：表示读权限
- 2：表示写权限
- 1：表示执行权限
因此，权限可以用三个数字表示，例如644 表示所有者有读和写权限，组用户有读权限，其他用户只有读权限。

具体的权限如下：
- r（4）：读取文件内容或列出目录中的文件。

- w（2）：写入文件或在目录中创建新文件。

- x（1）：执行文件或进入目录。

在设置文件或目录的权限时，可以使用chmod命令。

例如，要将文件的权限设置为644，可以使用以下命令：
```bash
chmod 644 filename
```
要设置目录的权限，可以使用相同的命令，但需要在最后加上"/"。

```bash
chmod 644 dirname/
```
总之，读写权限是Linux 系统中控制文件和目录访问的重要机制，了解它们的含义和设置方法对于管理文件和目录非常重要。

Linux文件系统之文件的读写

Linux文件系统之文件的读写

Linux文件系统之文件的读写展开全文------------------------------------------本文系本站原创,欢迎转载!转载请注明出处:/------------------------------------------一：前言文件的读写是文件系统中最核心也是最复杂的一部份,它牵涉到了很多的概念.之前分析文件系统其它操作的时候,遇到与文件系统相关的读写部份都忽略过去了.在这一节里,来讨论一下文件的读写是怎样实现的.二：I/O请求的概述如之前所提到的,为了提高文件的操作效率,文件系统中的内容都是缓存在内存里的.每当发起一个Rear/Write请求的时候,都会到页面高速缓存中寻找具体的页面.如果页面不存在,则在页面高速缓存中建立相关页面的缓存.如果当前的页面不是最新的.那就必须要到具体的文件系统中读取数据了.一般来说,内核提供了这样的界面：它产生一个I/O请求.这个界面为上层隐藏了下层的不同实现.在这个界面中,将产生的I/O 请求提交给I/O调度.再与I/O调度调用具体的块设备驱动程序.整个过程如下图所示：上图中的Generic Block Layer就是上面描述中所说的I/O的界面.接下来我们以上图从下到上的层次进行讨论.三：块设备驱动块设备与字符设备的区别在于：块设备可以随机的访问,例如磁盘.正是因为它可以随机访问,内核才需要一个高效的手段去管理每一个块设备.例如对磁盘的操作,每次移动磁针都需要花不少的时候,所以尽量让其处理完相同磁道内的请求再将磁针移动到另外的磁道.而对于字符设备来说,不存在这样的顾虑,只需按顺序从里面读/写就可以了.先来看一下块设备驱动所涉及到的数据结构.3.1: block_device结构：struct block_device {//主次驱备号dev_t bd_dev; /* not a kdev_t - it's a search key */ //指向bdev文件系统中块设备对应的文件索引号struct inode * bd_inode; /* will die *///计数器,统计块驱备被打开了多少次int bd_openers;// 块设备打开和关闭的信号量struct semaphore bd_sem; /* open/close mutex *///禁止在块设备上建行新安装的信号量struct semaphore bd_mount_sem; /* mount mutex *///已打开的块设备文件inode链表struct list_head bd_inodes;//块设备描述符的当前拥有者void * bd_holder;//统计字段,统计对bd_holder进行更改的次数int bd_holders;//如果当前块设备是一个分区,此成员指向它所属的磁盘的设备//否则指向该描述符的本身struct block_device * bd_contains;//块大小unsigned bd_block_size;//指向分区描述符的指针struct hd_struct * bd_part;/* number of times partitions within this device have been opened. *///统计字段,统计块设备分区被打开的次数unsigned bd_part_count;//读取块设备分区表时设置的标志int bd_invalidated;//指向块设备所属磁盘的gendiskstruct gendisk * bd_disk;//指向块设备描述符链表的指针struct list_head bd_list;//指向块设备的专门描述符backing_dev_infostruct backing_dev_info *bd_inode_backing_dev_info;/** Private data. You must have bd_claim'ed the block_device* to use this. NOTE: bd_claim allows an owner to claim* the same device multiple times, the owner must take special* care to not mess up bd_private for that case.*///块设备的私有区unsigned long bd_private;}通常,对于块设备来说还涉及到一个分区问题.分区在内核中是用hd_struct来表示的.3.2: hd_struct结构：struct hd_struct {//磁盘分区的起始扇区sector_t start_sect;//分区的长度,即扇区的数目sector_t nr_sects;//内嵌的kobjectstruct kobject kobj;//分区的读操作次数,读取扇区数,写操作次数,写扇区数unsigned reads, read_sectors, writes, write_sectors;//policy:如果分区是只读的,置为1.否则为0//partno:磁盘中分区的相对索引int policy, partno;}每个具体的块设备都会都应一个磁盘,在内核中磁盘用gendisk表示.3.3: gendisk结构：struct gendisk {//磁盘的主驱备号int major; /* major number of driver *///与磁盘关联的第一个设备号int first_minor;//与磁盘关联的设备号范围int minors; /* maximum number of minors, =1 for* disks that can't be partitioned. *///磁盘的名字char disk_name[32]; /* name of major driver *///磁盘的分区描述符数组struct hd_struct **part; /* [indexed by minor] *///块设备的操作指针struct block_device_operations *fops;//指向磁盘请求队列指针struct request_queue *queue;//块设备的私有区void *private_data;//磁盘内存区大小（扇区数目）sector_t capacity;//描述磁盘类型的标志int flags;//devfs 文件系统中的名字char devfs_name[64]; /* devfs crap *///不再使用int number; /* more of the same *///指向磁盘中硬件设备的device指针struct device *driverfs_dev;//内嵌kobject指针struct kobject kobj;//记录磁盘中断定时器struct timer_rand_state *random;//如果只读,此值为1.否则为0int policy;//写入磁盘的扇区数计数器atomic_t sync_io; /* RAID *///统计磁盘队列使用情况的时间戳unsigned long stamp, stamp_idle;//正在进行的I/O操作数int in_flight;//统计每个CPU使用磁盘的情况#ifdef CONFIG_SMPstruct disk_stats *dkstats;#elsestruct disk_stats dkstats;#endif}以上三个数据结构的关系,如下图所示：如上图所示：每个块设备分区的bd_contains会指它的总块设备节点,它的bd_part会指向它的分区表.bd_disk会指向它所属的磁盘.从上图中也可以看出：每个磁盘都会对应一个request_queue.对于上层的I/O请求就是通过它来完成的了.它的结构如下：3.4：request_queue结构：struct request_queue{/** Together with queue_head for cacheline sharing*///待处理请求的链表struct list_head queue_head;//指向队列中首先可能合并的请求描述符struct request *last_merge;//指向I/O调度算法指针elevator_t elevator;/** the queue request freelist, one for reads and one for writes *///为分配请请求描述符所使用的数据结构struct request_list rq;//驱动程序策略例程入口点的方法request_fn_proc *request_fn;//检查是否可能将bio合并到请求队列的最后一个请求的方法merge_request_fn *back_merge_fn;//检查是否可能将bio合并到请求队列的第一个请求中的方法merge_request_fn *front_merge_fn;//试图合并两个相邻请求的方法merge_requests_fn *merge_requests_fn;//将一个新请求插入请求队列时所调用的方法make_request_fn *make_request_fn;//该方法反这个处理请求的命令发送给硬件设备prep_rq_fn *prep_rq_fn;//去掉块设备方法unplug_fn *unplug_fn;//当增加一个新段时,该方法驼回可插入到某个已存在的bio 结构中的字节数merge_bvec_fn *merge_bvec_fn;//将某个请求加入到请求队列时,会调用此方法activity_fn *activity_fn;//刷新请求队列时所调用的方法issue_flush_fn *issue_flush_fn;/** Auto-unplugging state*///插入设备时所用到的定时器struct timer_list unplug_timer;//如果请求队列中待处理请求数大于该值,将立即去掉请求设备int unplug_thresh; /* After this many requests *///去掉设备之间的延迟unsigned long unplug_delay; /* After this many jiffies */ //去掉设备时使用的操作队列struct work_struct unplug_work;//struct backing_dev_info backing_dev_info;/** The queue owner gets to use this for whatever they like.* ll_rw_blk doesn't touch it.*///指向块设备驱动程序中的私有数据void *queuedata;//activity_fn（)所用的参数void *activity_data;/** queue needs bounce pages for pages above this limit *///如果页框号大于该值,将使用回弹缓存冲unsigned long bounce_pfn;//回弹缓存区页面的分配标志int bounce_gfp;/** various queue flags, see QUEUE_* below*///描述请求队列的标志unsigned long queue_flags;/** protects queue structures from reentrancy*///指向请求队列锁的指针spinlock_t *queue_lock;/** queue kobject*///内嵌的kobjectstruct kobject kobj;/** queue settings*///请求队列中允许的最大请求数unsigned long nr_requests; /* Max # of requests */ //如果待请求的数目超过了该值,则认为该队列是拥挤的unsigned int nr_congestion_on;//如果待请求数目在这个阀值下,则认为该队列是不拥挤的unsigned int nr_congestion_off;//单个请求所能处理的最大扇区（可调的）unsigned short max_sectors;//单个请求所能处理的最大扇区（硬约束）unsigned short max_hw_sectors;//单个请求所能处理的最大物理段数unsigned short max_phys_segments;//单个请求所能处理的最大物理段数(DMA的约束) unsigned short max_hw_segments;//扇区中以字节为单位的大小unsigned short hardsect_size;//物理段的最大长度（以字节为单位）unsigned int max_segment_size;//段合并的内存边界屏弊字unsigned long seg_boundary_mask;//DMA缓冲区的起始地址和长度的对齐unsigned int dma_alignment;//空闲/忙标记的位图.用于带标记的请求struct blk_queue_tag *queue_tags;//请求队列的引用计数atomic_t refcnt;//请求队列中待处理的请求数unsigned int in_flight;/** sg stuff*///用户定义的命令超时unsigned int sg_timeout;//Not Useunsigned int sg_reserved_size;}request_queue表示的是一个请求队列,每一个请求都是用request来表示的.3.5: request结构：struct request {//用来形成链表struct list_head queuelist; /* looking for ->queue? you must _not_* access it directly, use* blkdev_dequeue_request! *///请求描述符的标志unsigned long flags; /* see REQ_ bits below *//* Maintain bio traversal state for part by part I/O submission.* hard_* are block layer internals, no driver should touch them!*///要传送的下一个扇区sector_t sector; /* next sector to submit *///要传送的扇区数目unsigned long nr_sectors; /* no. of sectors left to submit *//* no. of sectors left to submit in the current segment *///当前bio段传送扇区的数目unsigned int current_nr_sectors;//要传送的下一个扇区号sector_t hard_sector; /* next sector to complete *///整个过程中要传送的扇区号unsigned long hard_nr_sectors; /* no. of sectors left to complete *//* no. of sectors left to complete in the current segment */ //当前bio段要传送的扇区数目unsigned int hard_cur_sectors;/* no. of segments left to submit in the current bio *///unsigned short nr_cbio_segments;/* no. of sectors left to submit in the current bio */unsigned long nr_cbio_sectors;struct bio *cbio; /* next bio to submit *///请求中第一个没有完成的biostruct bio *bio; /* next unfinished bio to complete *///最后的biostruct bio *biotail;//指向I/O调度的私有区void *elevator_private;//请求的状态int rq_status; /* should split this into a few status bits */ //请求所引用的磁盘描述符struct gendisk *rq_disk;//统计传送失败的计数int errors;//请求开始的时间unsigned long start_time;/* Number of scatter-gather DMA addr+len pairs after* physical address coalescing is performed.*///请求的物理段数unsigned short nr_phys_segments;/* Number of scatter-gather addr+len pairs after* physical and DMA remapping hardware coalescing is performed.* This is the number of scatter-gather entries the driver* will actually have to deal with after DMA mapping is done.*///请求的硬段数unsigned short nr_hw_segments;//与请求相关的标识int tag;//数据传送的缓冲区,如果是高端内存,此成员值为NULLchar *buffer;//请求的引用计数int ref_count;//指向包含请求的请求队列描述符request_queue_t *q;struct request_list *rl;//指向数据传送终止的completionstruct completion *waiting;//对设备发达“特殊请求所用到的指针”void *special;/** when request is used as a packet command carrier*///cmd中的数据长度unsigned int cmd_len;//请求类型unsigned char cmd[BLK_MAX_CDB];//data中的数据长度unsigned int data_len;//为了跟踪所传输的数据而使用的指针void *data;//sense字段的数据长度unsigned int sense_len;//指向输出sense缓存区void *sense;//请求超时unsigned int timeout;/** For Power Management requests*///指向电源管理命令所用的结构struct request_pm_state *pm;}请求队列描述符与请求描述符都很复杂,为了简化驱动的设计,内核提供了一个API,供块设备驱动程序来初始化一个请求队列.这就是blk_init_queue（）.它的代码如下：//rfn:驱动程序自动提供的操作I/O的函数.对应请求队列的request_fn//lock:驱动程序提供给请求队列的自旋锁request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock){request_queue_t *q;static int printed;//申请请求队列描述符q = blk_alloc_queue(GFP_KERNEL);if (!q)return NULL;//初始化q->request_listif (blk_init_free_list(q))goto out_init;if (!printed) {printed = 1;printk("Using %s io scheduler\n", chosen_elevator->elevator_name);}//初始化请求队列描述符中的各项操作函数q->request_fn = rfn;q->back_merge_fn = ll_back_merge_fn;q->front_merge_fn = ll_front_merge_fn;q->merge_requests_fn = ll_merge_requests_fn;q->prep_rq_fn = NULL;q->unplug_fn = generic_unplug_device;q->queue_flags = (1 << QUEUE_FLAG_CLUSTER);q->queue_lock = lock;blk_queue_segment_boundary(q, 0xffffffff);//设置q->make_request_fn函数,初始化等待队对列的定时器和等待队列blk_queue_make_request(q, __make_request);//设置max_segment_size,max_hw_segments,max_phys_segments blk_queue_max_segment_size(q, MAX_SEGMENT_SIZE);blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);/** all done*///设置等待队列的I/O调度程序if (!elevator_init(q, chosen_elevator))return q;//失败的处理blk_cleanup_queue(q);out_init:kmem_cache_free(requestq_cachep, q);return NULL;}这个函数中初始化了很多操作指针,这个函数在所有块设备中都是一样的,这样就为通用块设备层提供了一个统一的接口.对于块设备驱动的接口就是我们在blk_init_queue中设置的策略例程了.留意一下关于请求队列的各操作的设置,这在后续的分析中会用到.另外,在请求结构中涉及到了bio结构.bio表示一个段.目前内核中关于I/O的所有操作都是由它来表示的.它的结构如下所示：struct bio {//段的起始扇区sector_t bi_sector;//下一个biostruct bio *bi_next; /* request queue link *///段所在的块设备struct block_device *bi_bdev;//bio的标志unsigned long bi_flags; /* status, command, etc *///Read/Writeunsigned long bi_rw; /* bottom bits READ/WRITE,* top bits priority*///bio_vec的项数unsigned short bi_vcnt; /* how many bio_vec's *///当前正在操作的bio_vecunsigned short bi_idx; /* current index into bvl_vec *//* Number of segments in this BIO after* physical address coalescing is performed.*///结合后的片段数目unsigned short bi_phys_segments;/* Number of segments after physical and DMA remapping * hardware coalescing is performed.*///重映射后的片段数目unsigned short bi_hw_segments;//I/O计数unsigned int bi_size; /* residual I/O count *//** To keep track of the max hw size, we account for the* sizes of the first and last virtually mergeable segments* in this bio*///第一个可以合并的段大小unsigned int bi_hw_front_size;//最后一个可以合并的段大小unsigned int bi_hw_back_size;//最大的bio_vec项数unsigned int bi_max_vecs; /* max bvl_vecs we can hold *///bi_io_vec数组struct bio_vec *bi_io_vec; /* the actual vec list *///I/O完成的方法bio_end_io_t *bi_end_io;//使用计数atomic_t bi_cnt; /* pin count *///拥有者的私有区void *bi_private;//销毁此bio的方法bio_destructor_t *bi_destructor; /* destructor */}bio_vec的结构如下：struct bio_vec {//bi_vec所表示的页面struct page *bv_page;//数据区的长度unsigned int bv_len;//在页面中的偏移量unsigned int bv_offset;}关于bio与bio_vec的关系,用下图表示：现在,我们来思考一个问题：当一个I/O请求提交给请求队列后,它是怎么去调用块设备驱动的策略例程去完成这次I/O的呢？还有,当一个I/O请求被提交给请求队列时,会不会立即调用驱动中的策略例程去完成这次I/O呢？实际上,为了提高效率,所有的I/O都会在一个特定的延时之后才会调用策略例程去完成本次I/O.我们来看一个反面的例子,假设I/O在被提交后马上得到执行.例如.磁盘有磁针在磁盘12.现在有一个磁道1的请求.就会将磁针移动到磁道1.操作完后,又有一个请求过来了,它要操作磁道11.然后又会将磁针移到磁道11.操作完后,又有一个请求过来,要求操作磁道4.此时会将磁针移到磁道4.这个例子中,磁针移动的位置是：12->1->11->4.实际上,磁针的定位是一个很耗时的操作.这样下去,毫无疑问会影响整个系统的效率.我们可以在整个延时内,将所有I/O操作按顺序排列在一起,然后再调用策略例程.于是上例的磁针移动就会变成12->11->4->1.此时磁针只会往一个方向移动.至于怎么样排列请求和选取哪一个请求进行操作,这就是I/O调度的任务了.这部份我们在通用块层再进行分析.内核中有两个操作会完成上面的延时过程.即：激活块设备驱动程序和撤消块设备驱动程序.3.6:块设备驱动程序的激活和撤消激活块设备驱动程序和撤消块设备驱动程序在内核中对应的接口为blk_plug_device（）和blk_remove_plug（）.分别看下它们的操作：void blk_plug_device(request_queue_t *q){WARN_ON(!irqs_disabled());/** don't plug a stopped queue, it must be paired with blk_start_queue()* which will restart the queueing*///如果设置了QUEUE_FLAG_STOPPED.直接退出if (test_bit(QUEUE_FLAG_STOPPED, &q->queue_flags))return;//为请求队列设置QUEUE_FLAG_PLUGGED.if (!test_and_set_bit(QUEUE_FLAG_PLUGGED, &q->queue_flags))//如果之前请求队列的状态不为QUEUE_FLAG_PLUGGED,则设置定时器超时时间mod_timer(&q->unplug_timer, jiffies + q->unplug_delay);}int blk_remove_plug(request_queue_t *q){WARN_ON(!irqs_disabled());//将队列QUEUE_FLAG_PLUGGED状态清除if (!test_and_clear_bit(QUEUE_FLAG_PLUGGED,&q->queue_flags))//如果请求队列之前不为QUEUE_FLAG_PLUGGED标志,直接返回return 0;//如果之前是QUEUE_FLAG_PLUGGED标志,则将定时器删除del_timer(&q->unplug_timer);return 1;}如果请求队列状态为QUEUE_FLAG_PLUGGED,且定时器超时,会有什么样的操作呢？回忆在请求队列初始化函数中,blk_init_queue（）会调用blk_queue_make_request（）.它的代码如下：void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn){…………q->unplug_delay = (3 * HZ) / 1000; /* 3 milliseconds */if (q->unplug_delay == 0)q->unplug_delay = 1;INIT_WORK(&q->unplug_work, blk_unplug_work, q);q->unplug_timer.function = blk_unplug_timeout;q->unplug_timer.data = (unsigned long)q;…………}上面设置了定时器的时间间隔为（3*HZ）/1000.定时器超时的处理函数为blk_unplug_timeout（）.参数为请求队列本身.blk_unplug_timeout()的代码如下：static void blk_unplug_timeout(unsigned long data){request_queue_t *q = (request_queue_t *)data;kblockd_schedule_work(&q->unplug_work);}从上面的代码看出,定时器超时之后,会唤醒q->unplug_work这个工作对列.在blk_queue_make_request（）中,对这个工作队列的初始化为: INIT_WORK(&q->unplug_work, blk_unplug_work, q)即工作队列对应的函数为blk_unplug_work().对应的参数为请求队列本身.代码如下：static void blk_unplug_work(void *data){request_queue_t *q = data;q->unplug_fn(q);}到此,就会调用请求队列的unplug_fn（）操作.在blk_init_queue()对这个成员的赋值如下所示：q->unplug_fn = generic_unplug_device;generic_unplug_device（）对应的代码如下：void __generic_unplug_device(request_queue_t *q){//如果请求队列是QUEUE_FLAG_STOPPED 状态,返回if (test_bit(QUEUE_FLAG_STOPPED, &q->queue_flags))return;//如果请求队列的状态是QUEUE_FLAG_PLUGGED.就会返回1if (!blk_remove_plug(q))return;/** was plugged, fire request_fn if queue has stuff to do*///如果请求对列中的请求,则调用请求队列的reauest_fn函数.也就是驱动程序的//策略例程if (elv_next_request(q))q->request_fn(q);}blk_remove_plug()在上面已经分析过了.这里不再赘述.归根到底,最后的I/O完成操作都会调用块设备驱动的策略例程来完成.四：I/O调度层I/O调度对应的结构如下所示：struct elevator_s{//当要插入一个bio时会调用elevator_merge_fn *elevator_merge_fn;elevator_merged_fn *elevator_merged_fn;elevator_merge_req_fn *elevator_merge_req_fn;//取得下一个请求elevator_next_req_fn *elevator_next_req_fn;//往请求队列中增加请求elevator_add_req_fn *elevator_add_req_fn;elevator_remove_req_fn *elevator_remove_req_fn;elevator_requeue_req_fn *elevator_requeue_req_fn;elevator_queue_empty_fn *elevator_queue_empty_fn;elevator_completed_req_fn *elevator_completed_req_fn;elevator_request_list_fn *elevator_former_req_fn;elevator_request_list_fn *elevator_latter_req_fn;elevator_set_req_fn *elevator_set_req_fn;elevator_put_req_fn *elevator_put_req_fn;elevator_may_queue_fn *elevator_may_queue_fn;//初始化与退出操作elevator_init_fn *elevator_init_fn;elevator_exit_fn *elevator_exit_fn;void *elevator_data;struct kobject kobj;struct kobj_type *elevator_ktype;//调度算法的名字const char *elevator_name;}我们以最简单的NOOP算法为例进行分析.NOOP算法只是做简单的请求合并的操作.的定义如下：elevator_t elevator_noop = {.elevator_merge_fn = elevator_noop_merge,.elevator_merge_req_fn = elevator_noop_merge_requests, .elevator_next_req_fn = elevator_noop_next_request,.elevator_add_req_fn = elevator_noop_add_request,.elevator_name = "noop",}挨个分析里面的各项操作：elevator_noop_merge（）:在请求队列中寻找能否有可以合并的请求.代码如下：int elevator_noop_merge(request_queue_t *q, struct request **req,struct bio *bio){struct list_head *entry = &q->queue_head;struct request *__rq;int ret;//如果请求队列中有last_merge项.则判断last_merge项是否能够合并//在NOOP中一般都不会设置last_mergeif ((ret = elv_try_last_merge(q, bio))) {*req = q->last_merge;return ret;}//遍历请求队列中的请求while ((entry = entry->prev) != &q->queue_head) {__rq = list_entry_rq(entry);if (__rq->flags & (REQ_SOFTBARRIER | REQ_HARDBARRIER)) break;else if (__rq->flags & REQ_STARTED)break;//如果不是一个fs类型的请求?if (!blk_fs_request(__rq))continue;//判断能否与这个请求合并if ((ret = elv_try_merge(__rq, bio))) {*req = __rq;q->last_merge = __rq;return ret;}}return ELEVATOR_NO_MERGE;}Elv_try_merge()用来判断能否与请求合并,它的代码如下：inline int elv_try_merge(struct request *__rq, struct bio *bio) {int ret = ELEVATOR_NO_MERGE;/** we can merge and sequence is ok, check if it's possible *///判断rq与bio是否为同类型的请求if (elv_rq_merge_ok(__rq, bio)) {//如果请求描述符中的起始扇区+ 扇区数= bio的起始扇区//则将bio加到_rq的后面.//返回ELEVATOR_BACK_MERGEif (__rq->sector + __rq->nr_sectors == bio->bi_sector)ret = ELEVATOR_BACK_MERGE;//如果请求描述符中的起始扇区- 扇区数=bio的起始扇区//则将bio加到_rq的前面//返回ELEVATOR_FRONT_MERGEelse if (__rq->sector - bio_sectors(bio) == bio->bi_sector) ret = ELEVATOR_FRONT_MERGE;//如果不可以合并,返回ELEVATOR_NO_MERGE （值为0）return ret;}elv_rq_merge_ok（）代码如下：inline int elv_rq_merge_ok(struct request *rq, struct bio *bio) {//判断rq是否可用if (!rq_mergeable(rq))return 0;/** different data direction or already started, don't merge*///操作是否相同if (bio_data_dir(bio) != rq_data_dir(rq))return 0;/** same device and no special stuff set, merge is ok*///要操作的对象是否一样if (rq->rq_disk == bio->bi_bdev->bd_disk &&!rq->waiting && !rq->special)return 1;return 0;}注意：如果检查成功返回1.失败返回0.elevator_noop_merge_requests（）：将next 从请求队列中取出.代码如下：void elevator_noop_merge_requests(request_queue_t *q, struct request *req,struct request *next){list_del_init(&next->queuelist);}从上面的代码中看到,NOOP算法从请求队列中取出请求,只需要取链表结点即可.不需要进行额外的操作.elevator_noop_next_request():取得下一个请求.代码如下：struct request *elevator_noop_next_request(request_queue_t *q){if (!list_empty(&q->queue_head))return list_entry_rq(q->queue_head.next);return NULL;}很简单,取链表的下一个结点.elevator_noop_add_request（）：往请求队列中插入一个请求.代码如下：void elevator_noop_add_request(request_queue_t *q, struct request *rq,int where){//默认是将rq插和到循环链表末尾struct list_head *insert = q->queue_head.prev;//如果要插到请求队列的前面if (where == ELEVATOR_INSERT_FRONT)insert = &q->queue_head;//不管是什么样的操作,都将新的请求插入到请求队列的末尾list_add_tail(&rq->queuelist, &q->queue_head);/** new merges must not precede this barrier*/if (rq->flags & REQ_HARDBARRIER)q->last_merge = NULL;else if (!q->last_merge)q->last_merge = rq;}五：通用块层的处理通用块层的入口点为generic_make_request().它的代码如下：void generic_make_request(struct bio *bio){request_queue_t *q;sector_t maxsector;//nr_sectors:要操作的扇区数int ret, nr_sectors = bio_sectors(bio);//可能会引起睡眠might_sleep();/* Test device or partition size, when known. *///最大扇区数目maxsector = bio->bi_bdev->bd_inode->i_size >> 9;if (maxsector) {//bio操作的起始扇区sector_t sector = bio->bi_sector;//如果最大扇区数<要操作的扇区数or 最大扇区数与起始扇区的差值小于要操作的扇区数//非法的情况if (maxsector < nr_sectors ||maxsector - nr_sectors < sector) {char b[BDEVNAME_SIZE];/* This may well happen - the kernel calls* bread() without checking the size of the* device, e.g., when mounting a device. */printk(KERN_INFO"attempt to access beyond end of device\n");printk(KERN_INFO "%s: rw=%ld, want=%Lu, limit=%Lu\n", bdevname(bio->bi_bdev, b),bio->bi_rw,(unsigned long long) sector + nr_sectors,(long long) maxsector);set_bit(BIO_EOF, &bio->bi_flags);goto end_io;}}/** Resolve the mapping until finished. (drivers are* still free to implement/resolve their own stacking* by explicitly returning 0)** NOTE: we don't repeat the blk_size check for each new device.* Stacking drivers are expected to know what they are doing.*/do {char b[BDEVNAME_SIZE];//取得块设备的请求对列q = bdev_get_queue(bio->bi_bdev);if (!q) {//请求队列不存在printk(KERN_ERR"generic_make_request: Trying to access ""nonexistent block-device %s (%Lu)\n",bdevname(bio->bi_bdev, b),(long long) bio->bi_sector);end_io://最终会调用bio->bi_end_iobio_endio(bio, bio->bi_size, -EIO);break;}//非法的情况if (unlikely(bio_sectors(bio) > q->max_hw_sectors)) {printk("bio too big device %s (%u > %u)\n",bdevname(bio->bi_bdev, b),bio_sectors(bio),q->max_hw_sectors);goto end_io;}//如果请求队列为QUEUE_FLAG_DEAD//退出if (test_bit(QUEUE_FLAG_DEAD, &q->queue_flags))goto end_io;/** If this device has partitions, remap block n* of partition p to block n+start(p) of the disk.*///如果当前块设备是一个分区,则转到分区所属的块设备blk_partition_remap(bio);//调用请求队列的make_request_fn()ret = q->make_request_fn(q, bio);} while (ret);}在blk_init_queue()中对请求队列的make_request_fn的设置如下所示：blk_init_queue()—> blk_queue_make_request(q, __make_request)void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn){…………q->make_request_fn = mfn;……}这里,等待队对的make_request_fn就被设置为了__make_request.这个函数的代码如下：static int __make_request(request_queue_t *q, struct bio *bio) {struct request *req, *freereq = NULL;int el_ret, rw, nr_sectors, cur_nr_sectors, barrier, err;sector_t sector;//bio的起始扇区sector = bio->bi_sector;//扇区数目nr_sectors = bio_sectors(bio);//当前bio中的bio_vec的扇区数目cur_nr_sectors = bio_cur_sectors(bio);//读/写rw = bio_data_dir(bio);/** low level driver can indicate that it wants pages above a* certain limit bounced to low memory (ie for highmem, or even* ISA dma in theory)*///建立一个弹性回环缓存blk_queue_bounce(q, &bio);spin_lock_prefetch(q->queue_lock);barrier = bio_barrier(bio);if (barrier && !(q->queue_flags & (1 <<QUEUE_FLAG_ORDERED))) {err = -EOPNOTSUPP;goto end_io;}again:spin_lock_irq(q->queue_lock);//请求队列是空的if (elv_queue_empty(q)) {//激活块设备驱动blk_plug_device(q);goto get_rq;}if (barrier)goto get_rq;//调用I/O调度的elevator_merge_fn方法,判断这个bio能否和其它请求合并//如果可以合并,req参数将返回与之合并的请求描述符el_ret = elv_merge(q, &req, bio);switch (el_ret) {//可以合并.且bio加到req的后面case ELEVATOR_BACK_MERGE:BUG_ON(!rq_mergeable(req));if (!q->back_merge_fn(q, req, bio))break;req->biotail->bi_next = bio;req->biotail = bio;req->nr_sectors = req->hard_nr_sectors += nr_sectors; drive_stat_acct(req, nr_sectors, 0);if (!attempt_back_merge(q, req))elv_merged_request(q, req);goto out;//可以合并.且bio加到req的前面case ELEVATOR_FRONT_MERGE:BUG_ON(!rq_mergeable(req));if (!q->front_merge_fn(q, req, bio))break;bio->bi_next = req->bio;req->cbio = req->bio = bio;req->nr_cbio_segments = bio_segments(bio);req->nr_cbio_sectors = bio_sectors(bio);/** may not be valid. if the low level driver said* it didn't need a bounce buffer then it better* not touch req->buffer either...*/req->buffer = bio_data(bio);req->current_nr_sectors = cur_nr_sectors;req->hard_cur_sectors = cur_nr_sectors;req->sector = req->hard_sector = sector;req->nr_sectors = req->hard_nr_sectors += nr_sectors; drive_stat_acct(req, nr_sectors, 0);if (!attempt_front_merge(q, req))elv_merged_request(q, req);goto out;/** elevator says don't/can't merge. get new request*///不可以合并.申请一个新的请求,将且加入请求队列case ELEVATOR_NO_MERGE:break;default:printk("elevator returned crap (%d)\n", el_ret);BUG();}/** Grab a free request from the freelist - if that is empty, check * if we are doing read ahead and abort instead of blocking for* a free slot.*/get_rq://freereq:是新分配的请求描述符if (freereq) {req = freereq;freereq = NULL;} else {//分配一个请求描述符spin_unlock_irq(q->queue_lock);if ((freereq = get_request(q, rw, GFP_ATOMIC)) == NULL) { /** READA bit set*///分配失败err = -EWOULDBLOCK;if (bio_rw_ahead(bio))goto end_io;freereq = get_request_wait(q, rw);}goto again;}req->flags |= REQ_CMD;/** inherit FAILFAST from bio (for read-ahead, and explicit FAILFAST)*/if (bio_rw_ahead(bio) || bio_failfast(bio))req->flags |= REQ_FAILFAST;/** REQ_BARRIER implies no merging, but lets make it explicit */if (barrier)req->flags |= (REQ_HARDBARRIER | REQ_NOMERGE);//初始化新分配的请求描述符req->errors = 0;req->hard_sector = req->sector = sector;req->hard_nr_sectors = req->nr_sectors = nr_sectors;req->current_nr_sectors = req->hard_cur_sectors = cur_nr_sectors;req->nr_phys_segments = bio_phys_segments(q, bio);req->nr_hw_segments = bio_hw_segments(q, bio);req->nr_cbio_segments = bio_segments(bio);req->nr_cbio_sectors = bio_sectors(bio);req->buffer = bio_data(bio); /* see ->buffer comment above */req->waiting = NULL;//将bio 关联到请求描述符req->cbio = req->bio = req->biotail = bio;req->rq_disk = bio->bi_bdev->bd_disk;req->start_time = jiffies;//请将求描述符添加到请求队列中add_request(q, req);out: (R)if (freereq)__blk_put_request(q, freereq);//如果定义了BIO_RW_SYNC.//将调用__generic_unplug_device将块设备驱动,它会直接调用驱动程序的策略例程if (bio_sync(bio))__generic_unplug_device(q);spin_unlock_irq(q->queue_lock);return 0;end_io:bio_endio(bio, nr_sectors << 9, err);return 0;}这个函数的逻辑比较简单,它判断bio能否与请求队列中存在的请求合并,如果可以合并,将其它合并到现有的请求.如果不能合并,则新建一个请求描述符,然后把它插入到请求队列中.上面的代码可以结合之前分析的NOOP算法进行理解.重点分析一下请求描述符的分配过程：分配一个请求描述符的过程如下所示：if ((freereq = get_request(q, rw, GFP_ATOMIC)) == NULL) { /** READA bit set*///分配失败err = -EWOULDBLOCK;if (bio_rw_ahead(bio))goto end_io;freereq = get_request_wait(q, rw);}在分析这段代码之前,先来讨论一下关于请求描述符的分配方式.记得我们在分析请求队列描述符的时候,request_queue中有一个成员：struct request_list rq;它的数据结构如下：struct request_list {//读/写请求描述符的分配计数int count[2];//分配缓存池mempool_t *rq_pool;//如果没有空闲内存时.读/写请求的等待队列wait_queue_head_t wait[2];。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

2.8 write函数

用w r i t e函数向打开文件写数据。 #include <unistd.h> ssize_t write(int filedes, const void * buff, size_t nbytes) ; 返回：若成功为已写的字节数，若出错为- 1。 其返回值通常与参数nbytes的值不同，否则表 示出错。w r i t e出错的一个常见原因是：磁盘已 写满，或者超过了对一个给定进程的文件长度限 制。



在P O S I X . 1应用程序中，整数0、1、 2应被代换成符号常数 STDIN_FILENO、 STDOUT_FILENO和STDERR_FILENO。O。 这些常数都定义在头文件 <unistd.h>中。 文件描述符的范围是0 ~ OPEN_MAX 。 早期的UNIX版本采用的上限值是1 9 (允 许每个进程打开2 0个文件)，现在很多系 统则将其增加至6 3。





f c n t l函数有五种功能： 复制一个现存的描述符, 新文件描述符作为函 数值返(c m d＝F_DUPFD）。 获得/设置文件描述符标记,对应于filedes 的文 件描述符标志作为函数值返回．（c m d = F_GETFD或F_SETFD）。 获得/设置文件状态标志，对应于filedes 的文 件状态标志作为函数值返回。（c m d = F_GETFL或F_SETFL）。 获得/设置异步I / O有权（c m d = F_GETOWN 或F_SETOWN）。 获得/设置记录锁（c m d = F_SETLK , F_SETLKW）。





pathname是要打开或创建的文件的名字。 oflag参数可用来说明此函数的多个选择项。 对于open函数而言，仅当创建新文件时才使 用第三个参数。 用下列一个或多个常数进行或运算构成oflag 参数(这些常数定义在<fcntl.h>头文件中)： O_RDONLY 只读打开。 O_WRONLY 只写打开。 O_RDWR 读、写打开。
2.1、用户程序接口（API）

在linux中用户编程接口（API）遵循了 在UNIX中最流行的应用编程界面标准— POSIX标准。这些系统调用编程接口主要通 过C库（libc）实现的。
系统命令
系统调用 内核空间 用户程序接口API 用户空间
图1 系统调用、API与系统命令之间的关系
2.1文件I/O介绍








#include <sys/types.h> #include <unistd.h> off_t lseek(int filesdes, off_t offset, int whence) ; 返回：若成功为新的文件位移，若出错为- 1。 对参数offset 的解释与参数w h e n c e的值有 关。 若whence是SEEK_SET，则将该文件的位移量设 置为距文件开始处offset 个字节。 若whence是SEEK_CUR ，则将该文件的位移量设 置为其当前值加offset，offset可为正或负。 若whence是SEEK_END ，则将该文件的位移量设 置为文件长度加offset，offset可为正或负。





O_APPEND 每次写时都加到文件的尾端。 O_CREAT 若此文件不存在则创建它。使用此选择项时， 需同时说明第三个参数mode，用其说明该新文件的存 取许可权位。 O_EXCL 如果同时指定了O_CREAT，而文件已经存在， 则出错。这可测试一个文件是否存在，如果不存在则 创建此文件成为一个原子操作。 O_TRUNC 如果此文件存在，而且为只读或只写成功打 开，则将其长度截短为0。 O_NOCTTY 如果p a t h n a m e指的是终端设备，则不 将此设备分配作为此进程的控制终端。 O_NONBLOCK 如果p a t h n a m e指的是一个F I F O、 一个块特殊文件或一个字符特殊文件，则此选择项为 此文件的本次打开操作和后续的I / O操作设置非阻塞 方式。 O_SYNC 使每次w r i t e都等到物理I / O操作完成。
文件状态 O _ R D O N LY O _ W R O N LY O_RDWR
标志说明 只读打开 只写打开 读/写打开
O _APPEN D
O_NONBLOCK O_SYNC O_ASYN C
写时都添加至文件尾
非阻塞方式 等待写完成 异步I / O



F_SETFL 将文件状态标志设置为第三个参数的值 (取为整型值)。可以更改的几个标志是：O _ A P P E N D，O _ N O N B L O C K，O _ S Y N C和O _ A S Y N C。 F_GETOWN 取当前接收S I G I O和S I G U R G信号 的进程I D或进程组I D。 F_SETOWN 设置接收S I G I O和S I G U R G信号的 进程I D或进程组I D。正的a rg指定一个进 程I D， 负的a rg表示等于a rg绝对值的一个进程组I D。


若l s e e k成功执行，则返回新的文件位 移量，为此可以用下列方式确定一个打开 文件的当前位移量： off_t curr_pos; Curr_pos = lseek(fd, 0, SEEK_CUR);
2.7 read函数



用r e a d函数从打开文件中读数据 #include <unistd.h> ssize_t read(int feledes, void *buff, size_t nbytes) ; 返回：读到的字节数，若已到文件尾为0， 若出错为- 1。 如r e a d成功，则返回读到的字节数。如 已到达文件的尾端，则返回0。
2.3 open函数



#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open(const char *pathname, int oflag, …/*, mode_t mode * / ) ; 返回：若成功为文件描述符，若出错为- 1
1、Linux系统调用与文件I/O


1.1、 Linux系统调用 所谓系统调用是指操作系统提供给用户程 序的一组“特殊”接口，用户程序可以通过这 组“特殊”接口来获得操作系统内核提供的特 殊服务。 在linux中用户程序不能直接访问内核提供的 服务。为了更好的保护内核空间，将程序的运 行空间分为内核空间和用户空间，他们运行在 不同的级别上，在逻辑上是相互隔离的。


可用的文件I / O函数——打开文件、读文件、 写文件等等。大多数linux文件I / O只需用到 5个函数：open、read、write、lseek 以及 close。 不带缓存指的是每个r e a d和w r i t e都 调用内核中的一个系统调用。这些不带缓 存的I / O函数不是ANSI C的组成部分，但是 P O S I X 组成部分。
2.2 文件描述符

对于内核而言，所有打开文件都由文件 描述符引用。文件描述符是一个非负整数。 当打开一个现存文件或创建一个新文件时， 内核向进程返回一个文件描述符。当读、 写一个文件时，用o p e n或c r e a t返回的 文件描述符标识该文件，将其作为参数传 送给r e a d或w r i t e。
2.5 close函数


可用close函数关闭一个打开文件： #include <unistd.h> int close (int filedes)； 返回：若成功为0，若出错为- 1 当一个进程终止时，它所有的打开文件都由内 核自动关闭。很多程序都使用这一功能而不显式 地用c l o s e关闭打开的文件。 如：例open.c
2.9.2 用fcntl给文件加锁
当多个用户共同使用、操作一个文件的 时候，linux通常采用的方法是给文件上锁， 来避免共享资源产生竞争的状态。 文件锁包括建议锁和强制性锁。建议性 锁要求上锁文件的进程都要检测是否有锁 存在，并尊重已有的锁。强制性锁由内核 和系统执行的锁。 Fcntl不仅可以实施建议性锁而且可以实 施强制性锁。

2.9.3 fcntl函数格式


#include <sys/types.h> #include <unistd.h> #include <fcnt1.h> int fcnt1(int filedes, int cmd,... struct flock flockptr ) ; struct flock 结构
2.6 lseek函数


每个打开文件都有一个与其相关联的“当前文 件偏移量”。它是一个非负整数，用以度量从文 件开始处计算的字节数。通常，读、写操作都从 当前文件偏移量处开始，并使偏移量增加所读或 写的字节数。按系统默认，当打开一个文件时， 除非指定O_APPEND选择项，否则该位移量被设置 为0。 可以调用l s e e k显式地定位一个打开文件。




关于加锁和解锁区域的说明还要注意下列各点： 该区域可以在当前文件尾端处开始或越过其尾 端处开始，但是不能在文件起始位置之前开始 或越过该起始位置。 如若l_len为0，则表示锁的区域从其起点（由 l_start和l_whence决定）开始直至最大可能位 置为止。也就是不管添写到该文件中多少数据， 它都处于锁的范围。 为了锁整个文件，通常的方法是将l_start说明 为0，l_whence说明为SEEK_SET，l_len说明为 0。
相关文档
最新文档