iTOP4412开发板Android5.1.1移植教程

对于传统的操作系统来说，普通的 I/O 操作一般会被内核缓存，这种 I/O 被称作缓存 I/O。本文所介绍的文件访问机制不经过操作系统内核的缓存，数据直接在磁盘和应用程序地址空间进行传输，所以该文件访问的机制称作为直接 I/O。Linux 中就提供了这样一种文件访问机制，对于那种将 I/O 缓存存放在用户地址空间的应用程序来说，直接 I/O 是一种非常高效的手段。
% Y; t% ]8 q) A“Linux 中一切皆文件”这句话已经不知道说了多少遍了，后面也会提到很多次。那么在深入学习之前，肯定要掌握对 Linux 文件的各种操作，包括读、写、创建等基本知识。
1 ]& u5 C& i# @4 q- U: {本章配套视频为：2 D, w5 W# ~0 W
“视频 05_01 文件 IO 之 open 打开操作”
+ o7 u1 a3 V' h5 K2 {, T“视频 05_02 文件 IO 之 creat 创建操作”
# C7 K, z0 G& [. K" F  v8 T“视频 05_03 文件 IO 之 write 写操作”/ a! x# U) r& ?- u2 Q, e% O7 K/ |
“视频 05_04 文件 IO 之 read 读操作”
5 E  v$ a) d; I7 H& U3 d, h16.1 Linux 中 中 IO  的概念介绍
) A$ m7 P& W: x9 r: T: B- x8 t, o所有的 I/O 操作都是通过读文件或者写文件来完成的。在这里，把所有的外围设备，包括键盘和显示器，都看成是文件系统中的文件。* i/ ~/ m+ L. z" d4 Y
什么是缓存 I/O% U9 O0 C" d( i5 r' N6 p$ S
缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操作系统会将 I/O 的数据缓存在文件系统的页缓存（ page cache ） 中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。缓存 I/O 有
0 O2 p2 l; ^6 r& P, B8 v2 D8 T以下这些优点：5 n6 Q$ S* }5 l& l) w  V3 v
缓存 I/O 使用了操作系统内核缓冲区，在一定程度上分离了应用程序空间和实际的物理设备。
6 M& m* J5 R0 ?8 o缓存 I/O 可以减少读盘的次数，从而提高性能。9 f. c' r4 m! K( F
当应用程序尝试读取某块数据的时候，如果这块数据已经存放在了页缓存中，那么这块数据就可以立即返回给应用程序，而不需要经过实际的物理读盘操作。当然，如果数据在应用程序读取之前并未被存放在页缓存中，那么就需要先将数据从磁盘读到页缓存中去。对于写操作来说，应用程序也会将数据先写到/ |# `9 Y& ]1 F* |( }
页缓存中去，数据是否被立即写到磁盘上去取决于应用程序所采用的写操作机制：如果用户采用的是同步写机制（ synchronous writes ）, 那么数据会立即被写回到磁盘上，应用程序会一直等到数据被写完为止；如果用户采用的是延迟写机制（ deferred writes ），那么应用程序就完全不需要等到数据全部被写回到磁盘，数据只要被写到页缓存中去就可以了。在延迟写机制的情况下，操作系统会定期地将放在页缓存中的数据刷到磁盘上。与异步写机制（ asynchronous writes ）不同的是，延迟写机制在数据完全写到磁盘上的时候不会通知应用程序，而异步写机制在数据完全写到磁盘上的时候是会返回给应用程序的。所以延迟写机制本身是存在数据丢失的风险的，而异步写机制则不会有这方面的担心。
4 D8 m; a1 Z/ j9 s8 T2 F. l$ r0 p& _缓存 I/O  的缺点
4 y( Z" F7 D* ?! s% C7 T在缓存 I/O 机制中，DMA 方式可以将数据直接从磁盘读到页缓存中，或者将数据从页缓存直接写回到磁盘上，而不能直接在应用程序地址空间和磁盘之间进行数据传输，这样的 话，数据在传输过程中需要在应用程序地址空间和页缓存之间进行多次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是
" v9 B# K1 U' t4 ?/ |: b0 W! T8 a非常大的。/ P7 X& v, N4 ~0 h9 F
对于某些特殊的应用程序来说，避开操作系统内核缓冲区而直接在应用程序地址空间和磁盘之间传输数据会比使用操作系统内核缓冲区获取更好的性能，下边这一小节中提到的自缓存应用程序就是其中的一种。
# N4 r! B2 R% c8 L小贴士-关于文件的相关知识的一点说明5 o+ w" [1 H) U0 Y0 ]! M
在 Linux 中，文件非常重要，所以在 linux 系统中提供了丰富的文件操作函数。* ^' m* ^4 T2 o3 c2 [  x  j: l
在系统编程中，只会介绍编程中用到的最终的 API 和必须掌握的知识，还有大量的和文件相关的知识，例如高级 IO，制作文件系统，虚拟文件系统，文件共享，网络文件系统等等。: J8 F  M) H9 ^7 k) v9 C# z
如果真是要详细的介绍整个 linux 文件，可能好几千页的书都介绍不完，而且对于大家学习初期也没有太大的帮助，得不偿失。8 o+ T0 Y0 R1 t% s
手册中还会以其它形式介绍文件相关的知识，有的时候会介绍一步一步介绍如何操作，例如制作文件系统，NFS 网络启动；有时候会介绍如何使用，例如内核教程中介绍的虚拟文件系统等等。大家如果感兴趣，在学习教程之外可以通过学习相关知识，去了解更加具体的含义。
  N. P& _$ i5 Q' c) f! {# I文件对于 Linux 实在是太重要了，不过大家学习了本章的知识和实验，了解其他和文件系统相关的知识，在后面 Linux 编程中遇到的问题基本可以自行解决了。
! \% I3 s3 @# V% S9 K函数头文件
/ O/ \( \3 l3 ^! G0 H在所有的 Linux 系统中，如果需要对文件的进行操作，只要包含如下 4 个头文件即可。
' K/ m/ [+ A# j/ }0 F0 S#include <unistd.h>3 ?8 f$ {) X" I. ]' M" t
#include <sys/types.h>- {: }% B# \1 {( ^; I! E: p# v
#include <sys/stat.h>
+ @) |& B2 M! _# {8 R: a#include <fcntl.h>
. ~; t/ x3 q) W. B9 F" X, K上面四个头文件中包含了打开，关闭，创建，读文件，写文件的函数，还有标志位，以及在不同 32 位以及 64 位系统下数据长度的宏变量定义。
% C2 v2 p& l5 l' j16.2  打开文件函数 open8 O6 l! Z  l8 r4 x- u# A
使用 open 函数的时候会返回一个文件句柄，文件句柄是文件的唯一识别符 ID。对文件的操作必须从读取句柄开始。3 Z- i2 L0 G; o; m5 O
先来看一下函数 open 的两个原型。3 k! \& p' R! S
int open(const char *path, int oflags);
5 o7 f, r1 U) ~! V% r$ q, x有两个参数的‘open’函数主要用于创建文件，在本章的 10.5.5 小节会和创建文件的函数 creat 的同时介绍具体用法，并给出例子。3 U% O. I: P9 ~4 p5 L0 v) l
int open(const char *path, int oflags,mode_t mode);" k1 l: ^# A; k4 [5 Y
open 函数可以建立一个文件或者设备的访问路径。在打开或创建文件时可以指定文件的属性及用户的
/ }& s$ r$ ]8 R权限等参数。
% T. e2 m' z! R7 t% Z& ~第一个参数 path 表示：路径名或者文件名。路径名为绝对路径名，例如开发板中的 led 驱动的设备节点/dev/leds。0 H( h4 ?6 Q; `$ L: O# F. l. J8 \. l$ N
第二个参数 oflags 表示：打开文件所采取的动作。下 面 三 个 选 项 是 必 须 选 择 其 中 之 一的 。6 b# `6 {+ |5 ]5 w3 ?) |" }
O_RDONLY 文件只读' [. C1 x& E2 ?9 J8 }
O_WRONLY 文件只写/ p3 n/ g0 b( ~$ o
O_RDWR 文件可读可写
$ R' Z" }+ D0 k1 @- E, d下面是可以任意选择的。
! I+ m' s+ c8 h, v. tO_APPEND 每次写操作都写入文件的末尾# |+ K5 W3 u7 E+ P+ p. @% ^) f4 l
O_CREAT 如果指定文件不存在，则创建这个文件
) e' B' L  I6 V8 b' oO_EXCL 如果要创建的文件已存在，则返回 -1，并且修改 errno 的值
& J9 N4 i$ N- J1 S& r9 J0 aO_TRUNC 如果文件存在，并且以只写/读写方式打开，则清空文件全部内容
6 v5 m0 @' N  d7 n0 m5 u  q+ UO_NOCTTY 如果路径名指向终端设备，不要把这个设备用作控制终端。
' ~2 G- v0 a# `" @  m& KO_NONBLOCK 如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O 设置为非阻塞模式4 {. c' j+ v  k6 R8 D
（nonblocking mode），后面会介绍什么是阻塞和非阻塞。
" X; d* b+ [, n* }  J# P# \- XO_NDELAY 和 O_NONBLOCK 功能类似，调用 O_NDELAY 和使用的 O_NONBLOCK 功能是一样的。第三个参数 mode 表示：设置创建文件的权限。, Q( l" C" t2 r
S_IRUSR,S_IWUSER,S_IXUSR,S_IRGRP,S_IWGRP,S_IXGRP,S_IROTH,S_IWOTH,S_IXOTH. 其中 R：读，W：写，X：执行，USR：文件所属的用户，GRP：文件所属的组，OTH： 其他用户。第三个参数可以直接使用参数代替，参考 10.4.5 小节‘Linux 权限’。
' h7 P! z; u4 f4 X0 _4 K8 U2 L前面用过的‘chmod 0777 helloworld’命令，其中的含义是一样的，只不过 chmod 是在文件创建之后再修改权限。7 n( c  T- \6 L2 x: z
open  函数代码" }. ]0 {3 \  {4 f7 a
编写简单的 open.c 文件测试 open 函数。首先添加头文件，如下图所示。+ J* u9 F$ H3 |2 y" f% z& u
首先添加头文件，如下图所示。

然后 main 函数如下。

上图中打开了三个文件分别属于不同的情况。
. Y  }' I# |6 ^) E, z/dev/leds 已经在开发板中存在，属于驱动的设备节点，在 linux 驱动教程中会具体介绍
1 b# o1 m! s3 n: K! W- {/ B: b/bin/test1 和/bin/test2 都不存在
! a1 _3 Z" u1 H6 D3 k使用 open 函数调用上面三个文件，如果出错就会打印错误，然后打印句柄。
& T" B/ H1 W$ c, M/ G, p) J1 j编译运行测试& Y: j  U) i; F5 Q
在 Ubuntu 系统下，如下图所示，进入前面实验创建的目录“/home/linuxsystEMCode/iofile”，使用命令“mkdir iofile”新建 iofile 文件夹，将源码 open.c 拷贝进去，进入新建的文件夹 iofileopen，如下图所示。

使用命令“ARM-none-linux-gnueabi-gcc -o open open.c -static”编译 open 文件，如下图所示，使用命令“ls”可以看到生成了 open 可执行文件。

这里介绍 U 盘拷贝代码的方法，也可以编译进文件系统，具体方法参考 10.3.5 小节。将编译成的可执行文件 open，拷贝到 U 盘，启动开发板，插入 U 盘，加载 U 盘，运行程序如下。

如上图所示，可以看到打开/dev/leds 成功，这个是板载 LED 的内核驱动，调用的时候， 还调用了内核驱动中的函数，这个函数会打印“LEDS_CTL DEBUGevice Opened Success!”和“LEDS_CTL DEBUGeviceOpened Success!”
" {5 z( {8 O& X3 V* Y2 l然后打印句柄 ID，/dev/leds fd is 3
# |  E# t7 t% z! }调用“/bin/test1”会报错“open /bin/test1 failed”，这种打开文件的方式是 linux 中标准的用法，几乎所有对文件的 open 操作都会加上出错报警的语句。! M0 V2 K- ?$ Y: Y
创建“/bin/test2”会打印“/bin/test2 fd is 4”，表明创建“/bin/test2 ”成功了。  J+ q5 @; w6 i) ~) ?9 n2 X5 D
使用命令“ls /bin/test2”，查看一下对应目录‘/bin’下应该新建了“test2”,如下图所示。

另外的“dev/leds”本身就存在，如下图所示，这是驱动的设备节点文件，在后面的实验会介绍如何操作调用，在 linux 驱动实验中会介绍这个设备节点文件是如何生成的。

16.3  创建函数 creat 和 和 open
8 C9 g8 x* S( z! kcreat  函数介绍4 \7 N( I! y! o1 I
关于 creat 函数，首先这个单词并不是表示创建的意思，创建的英文单词是“create”， 这是早期的一个小的拼写错误，却一直沿用下来。9 g. I; t7 D- Z5 R
在介绍 open 函数的时候，可以看到 open 函数有两种形式，一个是两个参数一个是三个参数，早期的时候 open 只有三个参数的形式，三个参数的形式会导致 open 函数无法打开一个未创建的文件，也就是无法建立文件，所以就有了这个 creat 函数。# u' ~+ q, J2 R- G
现在 creat 函数可以完全用 open 替代，考虑到在阅读代码的时候可能会碰到，所以简单介绍一下。$ |7 i3 X2 l+ q, A/ \
creat 函数原型如下。+ e5 y3 V" J" X+ M' G7 Q& f2 v
int creat(const char * pathname, mode_t mode);) A  P) e; C: N) D" z) S8 B
creat 函数只有两个参数，参数的含义和 open 类似。大家看到这个函数的时候知道它是创建文件的就成，在写代码的时候完全可以用 open 代替。
# Z7 Q9 h+ a, J5 [2 n7 G- zcreat  函数例程
: v8 ^5 T, @1 y& b2 g# R编写简单的 creat.c 文件测试 creat 函数。首先添加头文件，如下所示。

然后 main 函数如下所示。

第 22 行、27 行、31，open 可以打开已有的文件，也可以打开不存在的文件，即创建文件，创建文件的时候需要在参数中添加标志位 O_CREAT。在第 27 行代码中，没有添加标志位，运行的时候肯定会报错，这么写是希望大家能够记住这个参数。
- H: _& ^; M4 h! s第 36 行是使用 creat 函数创建文件“test3”，注意一下 creat 函数和 open 函数在创建文件的时候，参数的区别。# a: E1 {( w* m+ E: c
编译运行测试

在 Ubuntu 系统下，如下图所示，进入前面实验创建的目录“/home/linuxsystemcode/iofile”，将源码creat.c 拷贝进去，如下图所示。

使用命令“arm-none-linux-gnueabi-gcc -o creat creat.c -static”编译 creat.c 文件，如下图所示，使用命令“ls”可以看到生成了 creat 可执行文件。

这里介绍 U 盘拷贝代码的方法，也可以编译进文件系统，具体方法参考 10.3.5 小节
2 S5 j; a7 J+ G$ {/ N) b+ ~将编译成的可执行文件 creat，拷贝到 U 盘，启动开发板，插入 U 盘，加载 U 盘，运行程序如下。

如上图所示。
8 u+ [8 ~3 |+ _1 |2 D打开文件"/dev/leds"成功，这个文件已经存在. d+ F% S# Y. W- e' V# W  `4 w
打开文件"/bin/test1"失败,因为没有添加参数 O_CREAT，这个文件不存在，新建的时候需要参数
5 A4 e7 G) d7 y, y1 S5 JO_CREAT。
' t& @! f; R0 d, }2 O  h打开文件"/bin/test2"成功，不存在这个文件，创建成功。
3 U) z2 J7 s: b3 r打开文件"/bin/test3"成功，不存在这个文件，使用 creat 新建成功。
" B: j: [+ F% s! c' u如下图所示，使用命令“ls /bin/test* ”在“/bin”目录下可以看到新建的文件 test2 和 test3。

16.4  关闭函数 close# a+ x) y' {1 N  R0 ~
任何一个文件在操作完成之后都需要关闭，这个时候需要调用 close 函数。( ^& E6 h% \# y' O
close  函数介绍( C  D' j& H: d5 H' |
调用 close 函数之后，会取消 open 函数建立的映射关系，句柄将不再有效，占用的空间将被系统释放。0 u" p: }; f# @4 G5 g" u: r
close 函数在头文件“#include <unistd.h>”中，close 函数的使用和参数都比较简单.! m9 }" T* K) s% S8 w* Z: z7 t
int close(int fd);' W- J& Z+ }" \1 _; t9 k  l+ Y
参数 fd，使用 open 函数打开文件之后返回的句柄。返回值，一般很少使用 close 的返回值。
) h7 r" c# Z. l9 Pclose  函数例程5 i6 l3 K/ ?1 p# `# n
调用很简单，在下一个实验中会永到 close 函数。

16.5  写函数 write
: \6 @# |5 z1 w0 t$ c; i( B对文件进行写操作，write 函数使用的比较多。' ]! J0 x. F: V' Y9 w9 {0 S1 L4 _
write  函数介绍
- P  O0 w9 D$ Pwrite 函数在头文件“#include <unistd.h>”中。( X; i6 }9 ~! F+ P* Z$ i
函数原型为 ssize_t write(int fd，const void *buf,size_t count) 参数 fd，使用 open 函数打开文件之后返" v# H/ S/ x6 D6 n7 o
回的句柄。
" v# x, Z5 z7 M  }# E" I4 L2 ]参数*buf，需要写入的数据。$ G% o; Y; Y7 u0 I6 H
参数 count，将参数*buf 中最多 count 个字节写入文件中。
* e" i0 t2 t8 |2 b返回值为 ssize 类型，出错会返回-1，其它数值表示实际写入的字节数。5 {, J& J& I2 E" l0 a0 z
write  函数例程  m' S# P& q. N5 N
编写简单的 write.c 文件测试 write 函数。首先添加头文件，如下所示。, Y5 C1 ?/ ^; [  n; f* M
//标准输入输出头文件+ i2 r* r" S" j$ V1 B1 X0 `' ^9 B( f
#include <stdio.h>
8 q5 G( V" g2 I) T* u//文件操作函数头文件
  f- u% h& s' }$ o% }( Y& M#include <sys/types.h>0 \; ~) ^8 q/ V; |
#include <sys/stat.h>
( \$ I/ a- q* s5 l$ W: ]% B#include <fcntl.h>
# c- P  Z% ]  @, i; X#include <unistd.h>
2 x6 c. h9 y& N7 {4 ]5 ~2 ?#include <string.h>* v8 N3 m7 C( u) N7 \
然后 main 函数如下所示。

如上图代码所示。
, F! o9 @. f6 P0 W3 _( R5 x在 16 行定义了 buffer_write 字符数组。& Z7 ~9 z2 j% e" Q* u
在 18 行，进行写操作之前，必须得到文件的句柄，在这一行中使用 open 函数创建和打开文件“/bin/testwrite"。: e( T7 |1 a  g- n
在 23 行中会调用 write 函数，将 buffer_write 字符数组中的内容写到新建的文件中。
. W: d# L* S" j. [: _/ q3 l在 31 行调用 close 函数，将"/bin/testwrite"文件关闭。- n- x5 I1 D) ~: d/ X2 N1 c4 V
后面测试的时候可以在超级终端中，使用 vi 编辑器打开"/bin/testwrite"文件，可以看到这个文件中有字符 Hello Write Function!.' c+ I, l$ ^: }$ c' }$ O0 R3 |5 F8 I
编译运行测试
1 Y; p' {5 X9 M. l) S! r在 Ubuntu 系统下，如下图所示，进入前面实验创建的目录“/home/linuxsystemcode/iofile”，将源码write.c 拷贝进去，如下图所示。

使用命令“arm-none-linux-gnueabi-gcc -o write write.c -static”编译 write.c 文件，如下图所示，使用命令“ls”可以看到生成了 write 可执行文件。

这里介绍 U 盘拷贝代码的方法，也可以编译进文件系统。
+ @4 i2 ?, x* q将编译成的可执行文件 write，拷贝到 U 盘，启动开发板，插入 U 盘，加载 U 盘，运行程序。如下图所示，打印出了 Write Function OK!。

在代码中定义的文件是"/bin/testwrite"，使用 vi 编辑器打开文件，如下图所示，程序执行运行成功。

16.6  文件的读 read  函数1 F. N+ o+ v3 u; P& {5 S
对文件进行写操作，read 函数使用的比较多。+ L, V) i, _+ k# J/ \& _; \
read  函数介绍- n3 H7 _8 Y7 x" \/ ~
read 函数在头文件“#include <unistd.h>”中。
6 n  |: ~& Y6 M函数原型为 ssize_t read(int fd，void *buf,size_t len)
) f% q  r4 i& I* `2 D7 n参数 fd，使用 open 函数打开文件之后返回的句柄。
1 M! `! }7 p" F3 z6 G% |. e参数*buf，读出的数据保存的位置。, {! C* O$ l  o7 Q8 ~
参数 len，每次最多读 len 个字节。
1 k  q) J3 ~1 d  r  P( |返回值为 ssize 类型，出错会返回-1，其它数值表示实际写入的字节数，返回值大于 0 小于 len 的数
+ E8 d3 ~; {+ e值都是正常的。6 U9 ?* O( ^# x7 Q/ ]: \* p( R
read  函数例程
! y- C; M9 A4 `5 B* G编写简单的 read.c 文件测试 read 函数。3 O% }) z  E- T& \) z
首先添加头文件和定义读函数缓冲区为 1000，如下图所示。
' }/ O1 k- @" u$ n# U: v//标准输入输出头文件6 @; f, z# W5 ^0 b# q: r- @- k/ f
#include <stdio.h>7 b" x' n  I) R. }& D/ Y
//文件操作函数头文件

#include <sys/types.h>
) M# z3 z" `: ^# `5 i#include <sys/stat.h>
$ F5 g+ l9 k9 l2 p; \#include <fcntl.h>. i3 A2 R4 G6 R3 O: t3 D9 N2 P$ l
#include <unistd.h>, }' r$ M' H, p0 V: w9 E" n
#include <string.h>  Q$ A* L! a, Z- U3 C4 ?
然后 main 函数如下图所示。

如上代码所示。 在 1-9 行，头文件。" R4 f( O0 ]0 o, C
在 20 行，使用 open 函数打开或者新建"/bin/testwrite"文件。
! D! T" v- D8 z3 K' H在 23 行，使用 write 函数将 buffer 中的内容写到"/bin/testwrite"文件中。在 35 行，使用 read 函数，将"/bin/testwrite"文件中的内容读出来。
9 `; S$ [! w3 [! \在 38 行，使用打印函数 printf 打印 read 函数读出的数据。在 39 行，调用 close 函数关闭打开的文件，程序结束。
5 m; K7 R3 N8 s最终测试的时候，除了会出现"/bin/testwrite"文件，还会打印 read 函数读取的数据。1 N5 m; Z& V- O3 Y" h( Q
编译运行测试$ E  d+ _* q, E
在 Ubuntu 系统下，如下图所示，进入前面实验创建的目录“/home/linuxsystemcode/iofile”，将源码read.c 拷贝进去，如下图所示。

使用命令“arm-none-linux-gnueabi-gcc -o read read.c -static”编译 read.c 文件，如下图所示，使用命令“ls”可以看到生成了 read 可执行文件。

这里介绍 U 盘拷贝代码的方法，也可以编译进文件系统。
* S0 V8 _4 U& q0 g% ]+ E  S* r将编译成的可执行文件 read，拷贝到 U 盘，启动开发板，插入 U 盘，加载 U 盘，运行程序。如下图所示，可以看到打印出了“Files Content is Hello Write Function”，使代码中预期的结果。