Microsoft Word - 扉页

Transcription

1 第 3 章 文件系统简介 在 UNIX 族的操作系统中, 文件系统占有十分重要的地位, 文件的概念涵盖了 UNIX 设备和操作对象的全部内容, 对设备的操作方式几乎可以与对普通文件的操作等价 本章对文件系统进行简单的介绍, 主要包括如下内容 : Linux 下文件的内涵 ; Linux 下的文件系统布局和文件系统的树形结构 ; Linux 下的普通文件和设备文件 ; Linux 下虚拟文件系统的含义 ; 文件的常用操作方法 文件句柄的含义 open() 函数 close() 函数 read() 函数和 write() 函数的使用及简单实例 ; 文件操作的高级用法, 包含 ioctl() 对特定设备文件进行控制, 用 fcntl() 函数控制文件,mmap() 的用法及 fstat() 获得文件的状态值及状态值的含义 3.1 Linux 下的文件系统 文件系统狭义的概念是一种对存储设备上的数据进行组织和控制的机制 在 Linux 下 ( 当然包含 UNIX), 文件的含义比较广泛, 文件的概念不仅仅包含通常意义的保存在磁盘的各种格式的数据, 还包含目录, 甚至各种各样的设备, 如键盘 鼠标 网卡 标准输出等, 引用一句经典的话 UNIX 下一切皆文件 Linux 下文件的内涵 Linux 下的文件系统是对复杂系统进行合理抽象的一个经典的例子, 它通过一套统一的接口函数对不同的文件进行操作 例如 open() 函数不仅可以打开 ext2 类型的文件, 还可以打开 fat32 类型的文件, 并且包括如串口设备 显卡等, 只不过打开设备的名称不同而已 Linux 下的文件主要分为如下几种 普通文件 : 例如保存在磁盘上的 C 文件 可执行文件, 以及目录等, 这种文件的特性是数据在存储设备上存放, 内核提供了对数据的抽象访问, 此种文件为一种字节流, 访问接口完全独立于在磁盘上的存储数据 字符设备文件 : 是一种能够像文件一样被访问的设备, 例如控制台 串口等 块设备文件 : 磁盘是此类设备文件的典型代表, 与普通文件的区别是操作系统对数据的访问进行的重新的格式设计 socket 文件 : 它是 Linux 中通过网络进行通信的方式, 对网络的访问可以通过文件描述符的抽象实现, 访问网络和访问普通文件相似

2 第 1 篇 Linux 网络开发基础 在 Linux 中用户空间对各种文件的操作是类似的, 因为虚拟文件系统 VFS 提供了同一套 API 文件系统的创建 在 Linux 下对磁盘进行操作的工具是 fdisk, 与 Windows 下的 fdisk 功能有些类似, 但是命令的格式完全不同 1. 系统分区情况 使用 fdisk 命令查看当前磁盘的情况 : # fdisk l ( 列出当前系统的磁盘情况 ) Disk /dev/sdb: 1073 MB, bytes ( 磁盘 sdb 的大小 ) 255 heads, 63 sectors/track, 130 cylinders, total sectors( 柱面情况 ) Units = sectors of 1 * 512 = 512 bytes ( 每个单元的情况 ) Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x Disk /dev/sdb doesn't contain a valid partition table( 磁盘 sdb 还没有进行分区 ) Disk /dev/sda: 32.2 GB, bytes ( 磁盘 sda 的分区情况 ) 255 heads, 63 sectors/track, 3916 cylinders, total sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x000e70b4 Device Boot Start End Blocks Id System /dev/sda1 * Linux (sda1 的开始 结束 分区类型 ) /dev/sda Extended (sda2 为扩展分区 ) /dev/sda Linux swap / Solaris (sda5 逻辑分区 ) 2. 建立分区 可以看到, 磁盘 /dev/sdb 没有使用, 现在尝试用 fdisk 在没有使用的磁盘 /dev/sdb 上进行分区, 先查看分区情况, 然后建立一个 100M 大小的初级分区, 将分区表写入磁盘并退出 : # fdisk /dev/sdb ( 对 sdb 进行分区 ) Device contains neither a valid DOS partition table, nor Sun, SGI or OSF disklabel Building a new DOS disklabel with disk identifier 0x5607baf1. Changes will remain in memory only, until you decide to write them. After that, of course, the previous content won't be recoverable. Warning: invalid flag 0x0000 of partition table 4 will be corrected by w(rite) Command (m for help): p ( 查看磁盘当前的分区情况 ) 62

3 第 3 章 文件系统简介 Disk /dev/sdb: 1073 MB, bytes 255 heads, 63 sectors/track, 130 cylinders, total sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x5607baf1 Device Boot Start End Blocks Id System Command (m for help): m( 打印命令 ) Command action a toggle a bootable flag ( 设置为启动分区 ) b edit bsd disklabel ( 编辑 bsd 磁盘 ) c toggle the dos compatibility flag ( 设置 dos 兼容标志 ) d delete a partition ( 删除一个分区 ) l list known partition types ( 列出当前系统可支持的分区方式 ) m print this menu n add a new partition ( 增加一个分区 ) o create a new empty DOS partition table ( 建议一个新的 DOS 分区表 ) p print the partition table ( 打印分区情况 ) q quit without saving changes ( 不保存退出 ) s create a new empty Sun disklabel ( 建立一个新的 Sun 空磁盘 ) t change a partition's system id ( 改变分区的 ID) u change display/entry units ( 改变显示单元 ) v verify the partition table ( 修正分区表 ) w write table to disk and exit ( 将之前的修改写入磁盘并推出 ) x extra functionality (experts only) ( 专家模式 ) Command (m for help): n ( 建立一个新分区 ) Partition type: ( 选择分区类型 ) p primary (0 primary, 0 extended, 4 free) ( 主分区 ) e extended ( 扩展分区 ) Select (default p):p ( 输入 p, 选择建立一个主分区 ) Partition number (1-4): 1 ( 分区的第一个分区 ) First sector ( , default 2048): ( 开始扇区, 默认为 2048) Using default value 2048 ( 按下 Enter 键, 选择默认值 ) Last sector, +sectors or +size{k,m,g} ( , default ): +100M ( 建立一个 100Mbytes 的分区 ) Command (m for help): w ( 写入磁盘并退出 ) The partition table has been altered! Calling ioctl() to re-read partition table.( 调用 ioctl() 函数重读分区进行检查 ) Syncing disks. ( 同步磁盘, 将缓存的信息写入磁盘 ) 3. 查看分区是否成功 列出系统的分区情况, 查看上述分区操作是否成功 # fdisk l Disk /dev/sdb: 1073 MB, bytes 224 heads, 19 sectors/track, 492 cylinders, total sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x4629e5b8 Device Boot Start End Blocks Id System 63

4 第 1 篇 Linux 网络开发基础 /dev/sdb Linux Disk /dev/sda: 32.2 GB, bytes 255 heads, 63 sectors/track, 3916 cylinders, total sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk identifier: 0x000e70b4 Device Boot Start End Blocks Id System /dev/sda1 * Linux /dev/sda Extended /dev/sda Linux swap / Solaris 4. 格式化分区 磁盘多一个 sdb1 分区 仅进行分区, 分区后的空间并不能使用, 需要使用 mkfs 格式化分区 sdb1: # mkfs.ext4 /dev/sdb1 ( 将 /dev/sdb1 格式化为 ext4 类型的系统 ) mke2fs 1.42 (29-Nov-2011) 文件系统标签 = OS type: Linux 块大小 =1024 (log=0) 分块大小 =1024 (log=0) Stride=0 blocks, Stripe width=0 blocks inodes, blocks 5120 blocks (5.00%) reserved for the super user 第一个数据块 =1 Maximum filesystem blocks= block groups 8192 blocks per group, 8192 fragments per group 1976 inodes per group Superblock backups stored on blocks: 8193, 24577, 40961, 57345, Allocating group tables: 完成正在写入 inode 表 : 完成 Creating journal (4096 blocks): 完成 Writing superblocks and filesystem accounting information: 完成 5. 挂载分区 建立一个 /test 目录, 将 sdb1 挂接上去 # mount /dev/sdb1 /test 查看分区挂载情况 用命令 df 可以查看当前文件系统的情况, 例如 : # df 文件系统 1K- 块 已用 可用已用 % 挂载点 /dev/sda % / udev % /dev tmpfs % /run

5 第 3 章 文件系统简介 none % /run/lock none % /run/shm /dev/sdb % /test 挂接文件系统 Linux 系统下, 要使用一个文件系统需要先将文件系统的分区挂载到系统上 mount 命令用于挂载文件, 它有很多选项 mount 命令的使用格式为 : mount t type mountpoint device o options 上述命令表示将文件类型为 type 的设备 device 挂载到 mountpoint 上, 挂载时要遵循 options 的设置 进行分区挂载时经常使用的是 -t 选项 例如, -t vfat 表示挂载 Windows 下的 fat32 等文件类型 ; -t proc 则表示挂载 proc 文件类型 挂载命令的 -o 选项是一个重量级的设置, 经常用于挂载比较特殊的文件属性 在嵌入式 Linux 下, 根文件系统经常是不可写的, 要对其中的文件进行修改, 需要使用 -o 选项重新进行挂载 例如, -o rewrite,rw 将文件系统重新进行挂载, 并将其属性改为可读写 Linux 也支持挂载网络文件系统, 例如 NFS 文件系统等, 挂载 NFS 文件系统的命令如下 : mount -t nfs 服务器地址 :/ 目录挂载点 下面是一个挂载 nfs 文件系统的例子, 例如在 IP 地址为 的机器做了一个 NFS 服务器, 提供 x 网段上的 NFS 服务 可以使用下面的命令来实现 : # showmount -e ( 查看 NFS 服务器共享的文件文件夹 ) Export list for : /opt/nfsroot ( 位于 机器上的 /opt/nfsroot 目录 ) # mkdir /mnt/nfsmount ( 在本地机器建一个目录, 作为 NFS 挂载点 ) # mount -t nfs :/opt/nfsroot /mnt/nfsmount ( 挂载 NFS) # df h ( 查看本地机挂载 NFS 是不是成功了 ) 文件系统 容量已用可用已用 % 挂载点 /dev/sda1 26G 5.4G 19G 22% / udev 2.0G 4.0K 2.0G 1% /dev tmpfs 805M 804K 805M 1% /run none 5.0M 0 5.0M 0% /run/lock none 2.0G 152K 2.0G 1% /run/shm /dev/sdb1 97M 5.6M 87M 7% /test :/opt/sirnfs 63G 47G 17G 74% /mnt/nfsmount ( 这是挂载成功后的显示 ) 索引节点 inode 在 Linux 下存储设备或存储设备的某个分区格式化为文件系统后, 有两个主要的概念来描述它, 一个是索引节点 (inode), 另一个是块 (Block) 块是用来存储数据的, 索引节点则是用来存储数据的信息, 这些信息包括文件大小 属主 归属的用户组 读写权限等 索引节点为每个文件进行信息索引, 所以就有了索引节点的数值 通过查询索引节点, 能够快速地找到对应的文件 这就像一本书, 存储设备是一本书 65

6 第 1 篇 Linux 网络开发基础 的整体, 块是书的内容, 而索引节点相当于一本书的目录, 如果要查询某方面的内容, 可以通过查询前面的目录, 快速地获得内容的信息, 例如位置 大小等 要查看索引节点的信息, 可以使用命令 ls, 加上参数 -i 例如, 使用 ls 查看 hello.c 的索引节点信息, 可知索引节点的值为 $ls -li hello.c rw-rw-r-- 1 linux-c linux-c 77 5 月 29 14:57 hello.c 在 Linux 的文件系统中, 索引节点值是文件的标识, 并且这个值是唯一的, 两个不同文件的索引节点值是不同的, 索引节点值相同的文件它的内容是相同的, 仅仅文件名不同 修改两个索引节点值相同的文件中的一个文件, 另一个文件的内容也跟着发生改变 例如下面的一个例子, 使用命令 ln 为文件 hello.c 创建一个硬链接, 命名其文件名为 hello2.c, 并查看属性的变化情况 $ls li hello.c ( 查看 hello.c 的属性 ) rw-rw-r-- 1 linux-c linux-c 77 5 月 29 14:57 hello.c $ ln hello.c hello2.c ( 通过 ln 来创建 hello.c 的硬链接文件 hello2.c ) $ ls -li hello* ( 列出 hello.c 和 hello2.c ) rw-rw-r-- 2 linux-c linux-c 77 5 月 29 14:57 hello2.c rw-rw-r-- 2 linux-c linux-c 77 5 月 29 14:57 hello.c 可以看出,hello.c 在没有创建硬链接文件 hello2.c 的时候, 其链接个数是 1( 即 -rw-rw-r-- 后的那个数值 ), 创建了硬链接 hello2.c 后, 这个值变成了 2 也就是说, 每次为 hello.c 创建一个新的硬链接文件后, 其硬链接个数都会增加 1 索引节点值相同的文件, 二者的关系是互为硬链接 当修改其中一个文件的内容时, 互为硬链接的文件内容也会跟着变化 如果删除互为硬链接关系的某个文件时, 其他的文件并不受影响 例如把 hello2.c 删除后, 还是一样能看到 hello.c 的内容, 并且 hello.c 仍是存在的 这是由于索引节点对于每一个文件有一个引用计数, 当创建硬链接的时候, 引用计数会增加 1, 删除文件的时候引用计数会减 1, 当引用计数为 0 的时候, 系统会删除此文件 目录不能创建硬链接, 只有文件才能创建硬链接 如果目录也可以创建硬链接, 很容易在系统内部形成真实的环状文件系统, 对文件系统的维护造成很大的困难 目录可以使用软链接的方式创建, 可使用命令 ln s 普通文件 普通文件是指在硬盘 CD U 盘等存储介质上的数据和文件结构 在本节中所指的文件系统是一个狭义的概念, 仅仅按照普通文件在磁盘中组织方式的不同来区分 普通文件的概念与 Windows 下面文件的概念是相同的 可以对文件进行打开 读出数据 写入数据 关闭 删除等操作 在 Linux 下, 目录也作为一种普通文件存在 设备文件 Linux 下用设备文件来表示所支持的设备, 每个设备文件除了设备名, 还有 3 个属性, 66

7 第 3 章 文件系统简介 即类型 主设备号 次设备号 例如, 查看 sdb1, 可以获得磁盘分区 sdb1 的属性, 属性的含义如下 : $ls /dev/sdb1 -l brw-rw root disk 8, 17 5 月 30 17:20 /dev/sdb1 设备类型 : 设备属性的第一个字符是这个设备文件的类型 第一个字符为 c, 表明这个设备是一个字符设备文件 第一个字符为 b, 表明这个设备是一个块设备文件 sdb1 的第 1 个字符为 b, 可知它是一个块设备文件 主设备号 : 每一个设备文件都有一个 主设备号, 使用 ls -l 命令输出的第 5 个字段即为主设备号 主设备号是表示系统存取这个设备的 内核驱动 驱动程序是 Linux 内核中代码的一部分, 其作用是用来控制一种特殊设备的输入输出 大多数的 Linux 操作系统都有多种设备驱动程序 ; 每一个设备文件名中的主设备号就代表这个设备使用的是那个设备驱动程序 lsdev 命令可以列出当前内核中配置的驱动程序和这些驱动程序对应的主设备号 次设备号 : 每一个设备文件都有一个次设备号 次设备号 是一个 24 位的十六进制数字, 它定义了这个设备在系统中的物理位置 设备文件名 : 设备文件名用于表示设备的名称, 它遵循标准的命令方式, 使得设备的分辨更容易 1. 字符设备与块设备 字符类型的设备可以在一次数据读写过程中传送任意大小的数据, 多个字符的访问是通过多次读写来完成的, 通常用于访问连续的字符 例如, 终端 打印机 moderm 和绘图仪等设备是字符类型设备 块设备文件可以在一次读写过程中访问固定大小的数据, 通过块设备文件进行数据读写的时候, 系统先从内存的缓冲区中读写数据, 而不是直接与设备进行数据读写, 这种访问方式可以大幅度地提高读写性能 块类型设备可以随机地访问数据, 而数据的访问时间和数据位于设备中的位置无关 常用的块设备有硬盘 软盘和 CD-ROM 及 RAM 类型磁盘 2. 设备文件的创建 设备文件是通过 mknod 命令来创建的 其命令格式为 : mknod [OPTION]... NAME TYPE [MAJOR MINOR] 其参数有设备文件名 NAME 操作模式 TYPE 主设备号 MAJOR 及次设备号 MINOR 主设备号和次设备号两个参数合并成一个 16 位的无符号短整数, 高 8 位表示主设备号, 低 8 位表示次设备号 可以在 include/linux/major.h 文件中找到所支持的主设备号 设备文件通常位于 /dev 目录下, 表 3.1 显示了目录 /dev 下的一些设备文件的属性 注意同一主设备号既可以标识字符设备, 也可以标识块设备 一个设备文件通常与一个硬件设备 ( 如硬盘,/dev/hda) 相关联, 或者与硬件设备的某一物理或逻辑分区 ( 如磁盘分区,/dev/hda2) 相关联 但在某些情况下, 设备文件不会和任何实际的硬件关联, 而是表示一个虚拟的逻辑设备 例如,/dev/null 就是对应于一个 黑洞 的设备文件, 所有写入这个文件的数据都被简单地丢弃 67

8 第 1 篇 Linux 网络开发基础 表 3.1 Linux 下的设备名简介 设备名 设备类型 主设备号 次设备号 说 明 /dev/fd0 块设备 2 0 软磁盘 /dev/hda 块设备 3 0 第 1 个 IDE 类型硬盘 /dev/hda2 块设备 3 2 第 1 个 IDE 硬盘上的第 2 个主分区 /dev/hdb 块设备 3 64 第 2 个 IDE 硬盘 /dev/hdb3 块设备 3 67 第 2 个 IDE 硬盘上的第 3 个主分区 /dev/ttyp0 字符设备 3 0 终端 /dev/console 字符设备 5 1 控制台 /dev/lp1 字符设备 6 1 打印机 /dev/ttys0 字符设备 4 64 第一个串口 /dev/rtc 字符设备 实时时钟 /dev/null 字符设备 1 3 空设备 3. 设备文件的简单操作 设备描述符 /dev/console 是控制台的文件描述符, 可以对其进行操作, 例如下面的命令将可能造成系统循环运行, 甚至死机 $cat /dev/console 上面的命令将控制台的输入打印出来 下面的命令向标准输出传入字符串 test, 系统将字符串 test 发给标准输出 : $echo "test">/dev/stdout 嵌入式设备中常用的 Framebuffer 设备是一个字符设备, 当系统打开 Framebuffer 设置的时候 ( 通常可以在系统启动的时候, 修改启动参数, 例如在 kernel 一行增加 vga=0x314 启动一个 分辨率的帧缓冲设备 ), 运行如下命令, 先将 Framebuffer 设备 fb0 的数据写入文件 test.txt 中, 然后利用 cat 命令将数据写入帧缓存设备 fb0: $cat /dev/fb0 > test.txt( 获得帧缓存设备的数据 ) $cat test.txt > /dev/fb0( 将数据写入帧缓存设备 ) 虚拟文件系统 VFS Linux 的文件系统是由虚拟文件系统作为媒介搭建起来的, 虚拟文件系统 VFS(Virtual File Systems) 是 Linux 内核层实现的一种架构, 为用户空间提供统一的文件操作接口 它在内核内部为不同的真实文件系统提供一致的抽象接口 如图 3.1 所示, 用户应用程序通过系统调用, 与内核中的虚拟文件系统交互, 操作实际的文件系统和设备 在图 3.1 中可以看出,Linux 文件系统支持多种类型的文件, 对多种类型的文件系统进行了抽象 通过一组相同的系统调用接口,Linux 可以在各种设备上实现多种不同的文件系统 例如,write() 函数可以向多种不同的文件系统上写入数据, 调用 write() 函数的应用 68

9 第 3 章 文件系统简介 文件系统 图 3.1 Linux 文件系统示意图 程序不用管文件的具体存储位置和文件系统的类型, 但是当写入数据的时候, 函数会正常返回 VFS 是文件系统的接口框架 这个组件导出一组接口, 然后将它们抽象到各个文件系统, 各个文件系统的具体实现方式差异很大 有两个针对文件系统对象的缓存 (inode 和 dentry), 它们缓存的对象是最近使用过的文件系统 每个文件系统实现 ( 如 ext4 vfat 等 ) 导出一组通用接口, 供 VFS 使用 缓冲区用于缓存文件系统和相关块设备二者之间的请求 例如, 对底层设备驱动程序的读写请求会通过缓冲区缓存来传递 这就允许在其中缓存请求, 减少访问物理设备的次数, 加快访问速度 以最近使用 (LRU) 列表的形式管理缓冲区缓存 注意, 可以使用 sync 命令将缓冲区缓存中的请求发送到存储媒体 ( 迫使所有未写的数据发送到设备驱动程序, 进而发送到存储设备 ) 1. 文件系统类型 Linux 的文件系统用一组通用对象来表示, 这些对象是超级块 (superblock) 节点索引 (inode) 目录结构(dentry) 和文件 (file) 超级块是每种文件系统的根, 用于描述和维护文件系统的状态 文件系统中管理的每个对象 ( 文件或目录 ) 在 Linux 中表示为一个索引节点 inode inode 包含管理文件系统中的对象所需的所有元数据 ( 包括可以在对象上执行的操作 ) 另一组结构称为 dentry, 它们用来实现名称和 inode 之间的映射, 有一个目录缓存用来保存最近使用的 dentry dentry 还维护目录和文件之间的关系, 支持目录和文件在文件系统中的移动 VFS 文件表示一个打开的文件 ( 保存打开的文件的状态, 像文件的读偏移量和写偏移量等 ) struct file_system_type { const char *name; /* 文件类型名称 */ int fs_flags; /* 标志 */ struct super_block *(*read_super) (struct super_block *, void *, int); /* 读超级块函数 */ 69

10 第 1 篇 Linux 网络开发基础 }; struct module *owner; /* 所有者 */ struct file_system_type * next; /* 下一个文件类型 */ struct list_head fs_supers; /* 头结构 */ 可以使用一组注册函数在 Linux 中动态地添加或删除文件系统 Linux 的内核中保存系统所支持的文件系统的列表, 可以通过 /proc 文件系统在用户空间中查看这个列表 虚拟文件系统还显示当前系统中与文件系统相关联的具体设备 在 Linux 中添加新文件系统的方法是调用 register_filesystem 这个函数的参数定义一个文件系统结构(file_system_type) 的引用, 这个结构定义文件系统的名称 一组属性和两个超级块函数, 也可以注销文件系统 在注册新的文件系统时, 会把这个文件系统和它的相关信息添加到 file_systems 列表中 在命令行上输入 cat/proc/filesystems, 就可以查看这个列表 例如 : $ cat /proc/filesystems nodev sysfs /*sys 文件 */ nodev rootfs /*root 文件 */ nodev proc /*proc 文件 */ nodev sockfs /* 套接字文件 */ nodev pipefs /* 管道文件 */ nodev tmpfs /* 临时文件 */ nodev ramfs /* 内存文件 */ nodev mqueue /* 队列 */ nodev usbfs /*USB 文件 */ ext3 /*EXT3 类型文件 */ nodev vmhgfs /* 虚拟机 */ nodev vmblock 2. 超级块 超级块结构用来表示一个文件系统, 结构如下 : struct super_block {... unsigned long long s_maxbytes; /* 最大文件尺寸 */ struct file_system_type *s_type; /* 文件的类型 */ const struct super_operations *s_op; /* 超级块的操作, 主要是对 inode 的操作 */... char s_id[32]; /* 文件系统的名称 */ }; 由于篇幅的关系省略了很多信息, 读者可以从 linux/fs.h 文件中获得全部的代码 这个结构包含一个文件系统所需要的信息, 例如文件系统名称 文件系统中最大文件的大小, 以及对 inode 块的操作函数等 在 Linux 系统中每种文件类型都有一个超级块, 例如, 如果系统中存在 ext4 和 vfat, 则存在两个超级块, 分别表示 ext4 文件系统和 vfat 文件系统 struct super_operations { struct inode *(*alloc_inode)(struct super_block *sb);/* 申请节点 */ void (*destroy_inode)(struct inode *); /* 销毁节点 */ 70

11 第 3 章 文件系统简介 }; void (*dirty_inode) (struct inode *); int (*write_inode) (struct inode *, int); /* 写节点 */ void (*drop_inode) (struct inode *); /* 摘取节点 */... 超级块中的一个重要元素是超级块操作函数的定义 这个结构定义一组用来管理这个文件系统中的节点索引 inode 的函数 例如, 可以使用函数 alloc_inode() 来分配 inode, 用函数 destroy_inode() 删除 inode 可以用 read_inode() 和 write_inode() 读写 inode, 用 sync_fs() 执行文件系统同步 可以在 Linux 的源代码树的文件 Linux/include/Linux/fs.h 中找到 super_operations 结构 Linux 文件系统中所支持的每个文件系统都实现一套自己的 inode 操作方法, 这些方法实现超级块所定义的功能并向 VFS 层提供通用的抽象 3. 文件操作 在文件 fs.h 中定义了文件操作的结构, 通常实际的文件系统都要实现对应的操作函数, 例如打开文件 open 关闭文件 close 读取数据 read 和写入数据 write 等 struct file_operations { struct module *owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char user *, size_t, loff_t *); ssize_t (*write) (struct file *, const char user *, size_t, loff_t *); ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t); /* 异步读 */ ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t); /* 异步写 */ int (*readdir) (struct file *, void *, filldir_t); /* 读目录 */ unsigned int (*poll) (struct file *, struct poll_table_struct *); /*poll 操作 */ int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); /*ioctl 函数 */ long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); /* 非锁定 ioctl*/ long (*compat_ioctl) (struct file *, unsigned int, unsigned long); /* 简装 ioctl*/ int (*mmap) (struct file *, struct vm_area_struct *); /* 内存映射 */ int (*open) (struct inode *, struct file *); /* 打开 */ int (*flush) (struct file *, fl_owner_t id); /* 写入 */ int (*release) (struct inode *, struct file *); /* 释放 */ int (*fsync) (struct file *, struct dentry *, int datasync); /* 同步 */ int (*aio_fsync) (struct kiocb *, int datasync); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); /* 锁定 */ ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); int (*check_flags)(int); int (*dir_notify)(struct file *filp, unsigned long arg); int (*flock) (struct file *, int, struct file_lock *); 71

12 第 1 篇 Linux 网络开发基础 }; ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); int (*setlease)(struct file *, long, struct file_lock **); ext4 文件系统实现了如下的文件操作, 当打开一个 ext2 格式的文件时, 系统调用 ext4 文件系统注册的 open() 函数, 即函数 generic_file_open() const struct file_operations ext4_file_operations = {.llseek = generic_file_llseek,.read = do_sync_read,.write = do_sync_write,.aio_read = generic_file_aio_read,.aio_write = generic_file_aio_write,.unlocked_ioctl = ext4_ioctl, #ifdef CONFIG_COMPAT.compat_ioctl = ext4_compat_ioctl, #endif.mmap = generic_file_mmap,.open = generic_file_open,.release = ext4_release_file,.fsync = ext4_sync_file,.splice_read = generic_file_splice_read,.splice_write = generic_file_splice_write, }; 3.2 文件的通用操作方法 本节将介绍文件的通用操作方法 先介绍如何建立文件 打开文件 读取和写入数据, 最后介绍了一些常用的文件控制函数, 包括 stat() fctnl() 和 ioctl() 本节中的例子大多数指的是磁盘中的文件操作, 但是其操作方法并不限于此, 对设备文件同样有效 文件描述符 在 Linux 下用文件描述符来表示设备文件和普通文件 文件描述符是一个整型的数据, 所有对文件的操作都通过文件描述符实现 文件描述符是文件系统中连接用户空间和内核空间的枢纽 当打开一个或者创建一个文件时, 内核空间创建相应的结构, 并生成一个整型的变量传递给用户空间的对应进程 进程用这个文件描述符来对文件进行操作 用户空间的文件操作, 例如读或写一个文件时, 将文件描述符作为参数传送给 read 或 write 读写函数的系统调用到达内核时, 内核解析作为文件描述符的整型变量, 找出对应的设备文件运行相应的函数, 并返回用户空间结果 文件描述符的范围是 0~OPEN_MAX, 因此是一个有限的资源, 在使用完毕后要及时释放, 通常是调用 close() 函数关闭 文件描述符的值仅在同一个进程中有效, 即不同进程的文件描述符, 同一个值很可能描述的不是同一个设备或者普通文件 在 Linux 系统中有 3 个已经分配的文件描述符, 即标准输入 标准输出和标准错误, 它们文件描述符的值分别为 0 1 和 2 读者可以查看/dev/ 下的 stdin( 标准输入 ) stdout 72

13 第 3 章 文件系统简介 ( 标准输出 ) 和 stderr( 标准错误 ), 会发现分别指向了 /proc/self/fd/ 目录下的 文件 打开创建文件 open() create() 函数 在 Linux 下,open() 函数用于打开一个已经存在的文件或者创建一个新文件,create() 函数用于创建一个新文件 1. 函数 open() create() 介绍 这两个函数的原型如下, 根据用户设置的标志 flags 和模式 mode 在路径 pathname 下建立或者打开一个文件 int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode); 在使用这些函数的时候, 需要包含头文件 sys/types.h sys/stat.h 和 fcntl.h open() 函数打开 pathname 指定的文件, 当函数成功时, 返回一个整型的文件描述符 这个函数正常情况下会返回一个文件描述符的值, 在出错的时候会返回 1 打开文件的时候需要指定打开的文件路径, 这个参数由 pathname 指定 函数会根据这个参数的值在路径中查找文件并试图打开或者建立文件 pathname 所指的为一个字符串变量, 这个变量的长度在不同的系统下其最大长度有差别, 通常情况下为 1024 个字节 当所给的路径长度大于这个数值的时候, 系统会对字符串进行截断, 仅选择最前面的字节进行操作 文件的打开标志 flags 用于设置文件打开后允许的操作方式, 可以为只读 只写或读写 分别用 O_RDONLY( 只读 ) O_WRONLY( 只写 ) 和 O_RDWR( 读写 ) 表示 在打开文件的时候必须指定上述的三种模式之一 三个参数中 O_RDONLY 通常定义为 0, O_WRONLY 定义为 1,O_RDWR 定义为 2 参数 flags 除了上述三个选项之外, 还有一些可选的参数 O_APPEND 选项 : 使每次对文件进行写操作都追加到文件的尾端 O_CREAT: 如果文件不存在则创建它, 当使用此选择项时, 第三个参数 mode 需要同时设定, 用来说明新文件的权限 O_EXCL: 查看文件是否存在 如果同时指定了 O_CREAT, 而文件已经存在, 会返回错误 用这种方法可以安全地打开一个文件 O_TRUNC: 将文件长度截断为 0 如果此文件存在, 并且文件成功打开, 则会将其长度截短为 0 例如: open(pathname,o_rdwro_creat O_TRUNC, mode); 通常使用 O_TRUNC 选项对需要清空的文件进行归零操作 O_NONBLOCK 打开文件为非阻塞方式, 如果不指定此项, 默认的打开方式为阻塞方式, 即对文件的读写操作需要等待操作的返回状态 其中, 参数 mode 用于表示打开文件的权限,mode 的使用必须结合 flags 的 O_CREAT 使用, 否则是无效的 它们的值在表 3.2 中列出, 这些值指定用户操作文件的权限 73

14 第 1 篇 Linux 网络开发基础 表 3.2 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 其他用户对文件有执行权限 使用函数 open() 的例子 这个例子为在当前目录下打开一个文件名为 test.txt 的文件, 并根据文件是否成功打开打印输出不同的结果 程序的代码如下 : 01 /*ex03-open-01.c 打开文件的例子 */ 02 #include <sys/types.h> 03 #include <sys/stat.h> 04 #include <fcntl.h> 05 #include <stdio.h> 06 int main(void) 07 { 08 int fd = -1; /* 文件描述符声明 */ 09 char filename[] = "test.txt"; /* 打开的文件名 */ 10 fd = open(filename,o_rdwr); /* 打开文件为可读写方式 */ 11 if(-1 == fd){ /* 打开失败 */ 12 printf("open file %s failure!, fd:%d\n",filename,fd); 13 } else { /* 打开成功 */ 14 printf("open file %s success,fd:%d\n",filename,fd); 15 } 16 return 0; 17 } 将上述代码保存到文件 ex03-open-01.c 中, 按照如下的命令进行编译 : $gcc o open-01 open-01.c 运行编译出来的可执行文件 open-01, 会发现第一次执行失败 : $./open-01 Open file test.txt failure!, fd:-1 因为此时当前目录下没有文件 test.txt, 所以打开文件会失败 建立一个空的 test.txt 文件 :

15 第 3 章 文件系统简介 $echo "">test.txt 再次运行程序 : $./open-01 Open file test.txt success,fd:3 这次打开文件成功了, 返回的文件描述符的值为 3 在 Linux 下如果之前没有其他文件打开, 第一个调用打开文件成功的程序, 返回的描述符为最低值, 即 3 因为 文件描述符分配给了系统, 表示标准输入 ( 描述符 0) 标准输出( 描述符 1) 和标准错误 ( 描述符 2) 在 Linux 下可以直接对这 3 个描述符进行操作 ( 例如读写 ), 而不用打开 关闭 open() 函数不仅可以打开一般的文件, 而且可以打开设备文件, 例如 open() 函数可以打开设备 /dev/sda1, 即磁盘的第一个分区, 将文件 open-01.c 中打开的文件名修改为 : char filename[] = "/dev/sda1"; 保存为文件名 open-02.c, 重新编译后运行, 结果为 : $gcc o open-02 open-02.c #./open-02 Open file /dev/sda1 success,fd:3 O_CREAT 可以创建文件, 与 O_EXCL 结合使用可以编写容错的程序, 例如将 open-01.c 修改为如下代码 : 01 /* 文件 open-03.c,o_creat 和 O_EXCL 的使用 */ 02 #include <sys/types.h> 03 #include <sys/stat.h> 04 #include <fcntl.h> 05 #include <stdio.h> 06 int main(void) 07 { 08 int fd = -1; 09 char filename[] = "test.txt"; /* 打开文件, 如果文件不存在, 则报错 */ 10 fd = open(filename,o_rdwr O_CREAT O_EXCL,S_IRWXU); 11 if(-1 == fd){ /* 文件已经存在 */ 12 printf("file %s exist!,reopen it",filename); 13 fd = open(filename,o_rdwr); /* 重新打开 */ 14 printf("fd:%d\n",fd); 15 } else { /* 文件不存在, 创建并打开 */ 16 printf("open file %s success,fd:%d\n",filename,fd); 17 } 18 return 0; 19 } 将代码保存为 open-03.c, 编译文件 : $gcc o open-03 open-03.c 当文件 test.txt 存在时运行的结果为 : $./ open-03 File test.txt exist!,reopen itfd:3 删除 test.txt 后再次运行 open-03, 结果为 : 75

16 $rm f test.txt $./ open-03 Open file test.txt success,fd:3 第 1 篇 Linux 网络开发基础 查看当前目录下的文件, 会发现多了一个文件大小为 0 的文件 test.txt 创建文件的函数除了可以在打开时创建外, 还可以使用 create() 函数创建一个新文件, 其函数的原型如下 : #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int creat(const char *pathname, mode_t mode); 函数 creat 等于一个 open 的缩写版本, 等效于如下方式的 open open(pathname, O_WRONLYO_CREATO_TRUNC, mode); creat 的返回值与 open 一样, 在成功时为创建文件的描述符 关闭文件 close() 函数 close() 函数关闭一个打开的文件, 之前打开文件所占用的资源 1.close() 函数介绍 close() 函数的原型如下 : #include <unistd.h> int close(int fd); close() 函数关闭一个文件描述符, 关闭以后此文件描述符不再指向任何文件, 从而描述符可以再次使用 当函数执行成功的时候返回 0, 如果有错误发生, 例如文件描述符非法, 返回 1 在使用这个函数的时候, 通常不检查返回值 在打开文件之后, 必须关闭文件 如果一个进程中没有正常关闭文件, 在进程退出的时候系统会自动关闭打开的文件 但是打开一个文件的时候, 系统分配的文件描述符为当前进程中最小的文件描述符的值, 这个值一般情况下是递增的, 而每个进程中的文件描述符的数量是有大小限制的 如果一个进程中频繁地打开文件而又忘记关闭文件, 当系统的文件描述符达到最大限制的时候, 就会因为没有文件描述符可以分配造成打开文件失败 2.close() 函数的例子 下面的代码用于打开当前目录下的 test.txt 文件, 每次打开后并不关闭, 一直到系统出现错误为止 这个程序用于测试当前系统文件描述符的最大支持数量, 代码如下 : 01 int main() 02 { 03 int i = 0; /* 计数器 */ 04 int fd=0; /* 文件描述符 */ 05 for(i=0;fd>=0;i++) /* 循环打开文件直到出错 */ 06 { 07 fd = open("test.txt",o_rdonly); /* 只读打开文件 */ 08 if(fd > 0){ /* 打开文件成功 */ 76

17 第 3 章 文件系统简介 09 printf("fd:%d\n",fd); /* 打印文件描述符 */ 10 } 11 else{ /* 打开文件失败 */ 12 printf("error, can't open file\n"); /* 打印错误 */ 13 exit(0); /* 退出 */ 14 } 15 } 16 } 要测试这个文件需要在当前目录下建立一个 test.txt 的文件, 可以使用 echo"">test.txt 来建立 执行程序后的文件内容为 : fd:3 fd:4... fd:1022 fd:1023 error, can't open file 系统打开第一个文件的文件描述符的值为 3, 一直到文件描述符的值为 1023 都可以正常打开 但是由于程序中一直没有关闭文件, 到文件描述符为 1024 的时候, 由于超过了系统的可分配最大值, 发生了错误 读者可以修改上述的代码, 加入 close() 函数调用后, 会发现程序可以正常地运行 读取文件 read() 函数 用 read() 函数从打开文件中读数据, 用户可以对读入的数据进行操作 1.read() 函数介绍 使用这个函数需要将头文件 unistd.h 加入 read() 函数从文件描述符 fd 对应的文件中读取 count 字节, 放到 buf 开始的缓冲区 如果 count 的值为 0,read() 函数返回 0, 不进行其他操作 ; 如果 count 的值大于 SSIZE_MAX, 结果不可预料 在读取成功的时候, 文件对应的读取位置指针, 向后移动位置, 大小为成功读取的字节数 read() 函数的原型定义格式如下 ssize_t read(int fd, void *buf, size_t count); 如果 read() 函数执行成功, 返回读取的字节数 ; 当返回值为 1 的时候, 读取函数有错误发生 如果已经到达文件的末尾, 返回 0 返回值的数据类型为 ssize_t 这是一个可能不同于 int long 类型的数据类型, 它是一个符号数, 具体实现时可能定义为 long 或者 int read() 函数的参数 fd 是一个文件描述符, 通常是 open() 函数或者 creat() 函数成功返回的值 ; 参数 buf 是一个指针, 它指向缓冲区地址的开始位置, 读入的数据将保存在这个缓冲区中 ; 参数 count, 表示要读取的字节数量, 通常用这个变量来表示缓冲区的大小, 因此 count 的值不要超过缓冲区的大小, 否则很容易造成缓冲区的溢出 在使用 read() 函数时,count 为请求读取的字节数量, 但是 read() 函数不一定能够读取这么多数据, 有多种情况可使实际读到的字节数小于请求读取的字节数 读取普通文件时, 文件中剩余的字节数不够请求的字节数, 例如在文件中剩余了 10 个字节, 而 read() 函数请求读取 80 个字节, 这时 read() 函数会将剩余的 10 个字 77

18 第 1 篇 Linux 网络开发基础 节数写到缓冲区 buf 中, 并返回实际读到的字节数 10 当从中断设备读取数据的时候, 其默认的长度不够 read() 函数请求读取的数据, 例如终端缓冲区的大小为 256 字节, 而 read() 函数请求读取 1024 个字节 当从网络读取数据时, 缓冲区大小可能小于读取请求的数据大小 因此读取数据时, 要判断返回实际读取数据大小来进行处理 2.read() 函数的例子 下面的代码从文本文件 test.txt 中读取数据, 文件中存放的是字符串 quick brown fox jumps over the lazy dog 读取成功后将数据打印出来 01 /* 文件 read-01.c,o_creat 和 O_EXCL 的使用 */ 02 #include <sys/types.h> 03 #include <sys/stat.h> 04 #include <fcntl.h> 05 #include <unistd.h> 06 #include <stdio.h> 07 int main(void) 08 { 09 int fd = -1,i; 10 ssize_t size = -1; 11 char buf[10]; /* 存放数据的缓冲区 */ 12 char filename[] = "test.txt"; fd = open(filename,o_rdonly); /* 打开文件, 如果文件不存在, 则报错 */ 15 if(-1 == fd){ /* 文件已经存在 */ 16 printf("open file %s failure,fd:%d\n",filename,fd); 17 }else { /* 文件不存在, 创建并打开 */ 18 printf("open file %s success,fd:%d\n",filename,fd); 19 } 20 /* 循环读取数据, 直到文件末尾或者出错 */ 21 while(size){ 22 size = read(fd, buf,10); /* 每次读取 10 个字节数据 */ 23 if( -1 == size) { /* 读取数据出错 */ close(fd); /* 关闭文件 */ 26 printf("read file error occurs\n"); return -1; /* 返回 */ 29 }else{ /* 读取数据成功 */ 30 if(size >0 ){ 31 printf("read %d bytes:",size); /* 获得 size 个字节数据 */ 32 printf("\""); /* 打印引号 */ 33 for(i = 0;i<size;i++){ /* 将读取的数据打印出来 */ 34 printf("%c",*(buf+i)); 35 } printf("\"\n"); /* 打印引号并换行 */ 38 }else{ 39 printf("reach the end of file\n"); 40 } 41 } 42 } 43 return 0; 44 } 78

19 第 3 章 文件系统简介 将上述代码保存到文件 read-01.c 中, 编译文件, 并运行成功编译后生成的可执行文件 read $gcc o read-01 read-01.c $./read-01 Open file test.txt success,fd:3 ( 打开文件成功, 文件描述符为 3) read 10 bytes:"quick brow" ( 读取了 10 个字节数据 : "quick brow") read 10 bytes:"n fox jump" ( 读取了 10 个字节数据 : "n fox jump") read 10 bytes:"s over the" ( 读取了 10 个字节数据 : "s over the") read 9 bytes:" lazy dog" ( 读取了 9 个字节数 : " lazy dog") reach the end of file ( 到达文件末尾 ) 写文件 write() 函数 write() 函数向打开的文件中写入数据, 将用户的数据保存到文件中 1.write() 函数介绍 与 read() 函数的含义相似,write() 函数向文件描述符 fd 写入数据, 数据的大小由 count 指定,buf 为要写入数据的指针,write() 函数返回值为成功写入数据的字节数 当操作的对象是普通文件时, 写文件的位置从文件的当前开始, 操作成功后, 写的位置会增加写入字节数的值 如果在打开文件的时候指定了 O_APPEND 项, 每次写操作之前, 会将写操作的位置移到文件的结尾处 write() 函数的原型如下 #include <unistd.h> ssize_t write(int fd, const void *buf, size_t count); 函数操作成功会返回写入的字节数, 当出错的时候返回 1 出错的原因有多种, 像磁盘已满, 或者文件大小超出系统的设置, 例如 ext2 下的文件大小限制为 2Gbytes 等 写操作的返回值与想写入的字节数会存在差异, 与 read() 函数的原因类似 注意 : 写操作函数并不能保证将数据成功地写入磁盘, 这在异步操作中经常出现,write() 函数通常将数据写入缓冲区, 在合适的时机由系统写入实际的设备 可以调用 fsync() 函数, 显示将输入写入设备 2.write() 函数的例子 假设在磁盘上存在一个大小为 50 字节的文件 test.txt, 向其中写入数据 quick brown fox jumps over the lazy dog, 在写入前后的文件大小不变, 只是文件开始部分的内容改变了 01 /* 文件 write-01.c,write() 函数的使用 */ 02 #include <sys/types.h> 03 #include <sys/stat.h> 04 #include <unistd.h> 05 #include <string.h> 06 #include <fcntl.h> 07 #include <stdio.h> 08 int main(void) 09 { 10 int fd = -1; 79

20 第 1 篇 Linux 网络开发基础 11 ssize_t size = -1; char buf[]="quick brown fox jumps over the lazy dog"; /* 存放数据的缓冲区 */ 14 char filename[] = "test.txt"; fd = open(filename,o_rdwr); /* 打开文件, 如果文件不存在, 则报错 */ 17 if(-1 == fd){ /* 文件已经存在 */ 18 printf("open file %s failure,fd:%d\n",filename,fd); 19 } else { /* 文件不存在, 创建并打开 */ 20 printf("open file %s success,fd:%d\n",filename,fd); 21 } size = write(fd, buf,strlen(buf)); /* 将数据写入到文件 test.txt 中 */ 24 printf("write %d bytes to file %s\n",size,filename); close(fd); /* 关闭文件 */ 27 return 0; 28 } 将此代码存入 write-01.c 后编译, 运行代码并查看文件大小, 会发现文件 test.txt 的大小没有改变但文件的内容发生了变化 : $ ls -l test.txt -rw-rw-r-- 1 linux-c linux-c 51 5 月 31 15:11 test.txt $ cat test.txt aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa $gcc o write write-01.c $./write-01 Open file test.txt success,fd:3 write 39 bytes to file test.txt $ ls -l test.txt -rw-rw-r-- 1 linux-c linux-c 51 5 月 31 15:12 test.txt $ cat test.txt quick brown fox jumps over the lazy dogaaaaaaaaaaa 写入的 39 个字符仅仅覆盖了文件 test.txt 开头的部分 要在写入的时候对文件进行清空, 可以使用 open() 函数的 O_TRUNC 选项, 将打开的函数修改为如下形式 : fd = open(filename,o_rdwr O_TRUNC); 编译后再次运行会发现这次写入后文件的大小变为 39 了 文件偏移 lseek() 函数 在调用 read() 和 write() 函数时, 每次操作成功后, 文件当前的操作位置都会移动 其中隐含了一个概念, 即文件的偏移量 文件的偏移量指的是当前文件操作位置相对于文件开始位置的偏移 每次打开和对文件进行读写操作后, 文件的偏移量都进行了更新 当写入数据成功时, 文件的偏移量要向后移动写入数据的大小 当从文件中读出数据的时候, 文件的偏移量要向后移动读出数据的大小 文件的偏移量是一个非负整数, 表示从文件的开始到当前位置的字节数 一般情况下, 对文件的读写操作都从当前的文件位移量处开始, 并增加读写操作成功的字节数 当打开 80