更具体地说，这意味着 Linux 使用相同的一组系统调用来提供对设备（例如软盘和磁带设备）、网络资源（最常见的是 TCP/IP 连接）、系统终端，甚至内核状态信息的访问。感谢无所不在的系统调用，娴熟地使用与文件相关的调用对于每个 Linux 程序员来说都很重要。让我们仔细查看一下文件 API 背后的一些基本概念，并描述最重要的文件相关系统调用。

Linux 提供许多不同种类的文件。最常见的类型就简称为常规文件，它存储大量用于以后访问的信息。您所使用的绝大部分文件 -- 例如可执行文件（如 /bin/vi）、数据文件（如 /etc/passwd）和系统二进制文件（如 /lib/libc.so.6）-- 都是常规文件。它们通常驻留在磁盘上的某处，但我们稍后会发现，并不一定都是这种情况。

另一种文件类型是目录，它包含了一个其它文件及其位置的列表。使用 ls 命令列出目录中的文件时，它打开该目录的文件，并打印出它所包含的所有文件的信息。

其它文件类型包括块设备（表示文件系统高速缓存的设备，例如硬盘驱动器）、字符设备（表示非高速缓存的设备，例如磁带驱动器、鼠标和系统终端）、管道和套接字（允许进程相互之间对话），以及符号链接（允许文件在目录层次结构中有多个名称）。

大多数文件都有一个或多个引用它们的符号名。这些符号名是一组由 / 字符定界的字符串，并向内核标识文件。它们是 Linux 用户所熟悉的路径名；例如，路径名 /home/ewt/article 引用的是我手提电脑中包含这篇文章文本的文件。没有两个文件可以共享相同的名称（但单一文件可以有多个名称），因此路径名唯一地标识单一文件。

进程可以访问的每个文件都由一个小的非负整数标识，称为“文件描述符”。文件描述符由打开文件的系统调用创建，并由从当前进程创建的新子进程继承。就是说，当进程启动了一个新程序时，原始进程的打开文件通常是由新程序继承的。

按照约定，大多数程序保留前三个文件描述符（0、1 和 2）用于特殊目的 -- 访问所谓的标准输出、标准输出和标准错误流。文件描述符 0 是标准输入，这里许多程序都将从外部世界接收输入。文件描述符 1 是标准输出。大多数程序在这里显示正常的输出。对于与错误情况相关的输出，使用文件描述符 2（标准错误）。

任何习惯使用 Linux shell 的人都曾看到过标准输入、输出和错误文件描述符的使用。通常，shell 运行命令时带文件描述符 0、1 和 2，都是指 shell 的终端。当使用 > 字符指示 shell 将一个程序的输出发送给另一个程序时，shell 在调用新程序之前打开该文件作为文件描述符 1。这将导致程序将它的输出发送给指定的文件而不是用户终端；其妙处是，对于程序本身，这是透明的！

与之类似，"<" 字符指示 shell 使用特定的文件作为文件描述符 0。这样就强迫程序从该文件中读取它的输入；这两种情况下，任何来自程序的错误仍将出现在终端上，如同它们在文件描述符 2 的情况下发送给标准错误一样。（在 "bash" shell 中，可以使用 2> 而不是 > 将标准错误重定向）。这种类型的文件重定向是 Linux 命令行最强大的特性之一。

使用任何与文件相关的系统调用之前，程序应该包括 <fcntl.h> 和 <unistd.h>；它们为最普遍的文件例程提供了函数原型和常数。在下面的示例代码中，我们假设每个程序开始处都有

#include <fcntl.h>
#include <unistd.h>

首先，让我们了解如何读写文件。凭直觉就可以知道，read() 和 write() 系统调用是执行这些操作的最常用方法。这两种系统调用将有三个自变量：要访问的文件描述符、指向要读写的信息的指针以及应该读写的字符数。返回成功读写的 字符数。清单 1 说明了一个简单的程序，它从标准输入（文件描述符 0）中读取一行，并将它写入标准输出（文件描述符 1）：

清单 1：

void main(void) {
char buf[100];
int num;

num = read(0, buf, sizeof(buf));
write(1, "I got: ", 7); /* Length of "I got: " is 7! */
write(1, buf, num);
}

关于这个处理有两个值得注意的问题。首先，我们要求 read() 返回 100 个字符，但如果我们运行这个程序，只有在用户按下了 "enter" 键以后才能获得输入。许多文件操作都根据最佳效果工作：它们尝试返回程序要求的所有信息，但只有部分能够成功。缺省情况下，终端配置成一旦存在 "\n" 或新行符（通过按 "enter" 键产生）时，就从 read() 调用返回。这实际上非常方便，因为大多数用户都希望程序无论如何都是面向行的。但常规数据文件并非如此，如果依靠它就可能产生不可预料的结果。

另一个要注意的问题是我们不必在显示输出后写一个 \n。read() 调用给了我们来自用户的 \n，只将那个 \n 通过 write() 写回标准输出。如果您希望在没有新行符的情况下看到发生的事件，尝试将最后一行改为

write(1, buf, num - 1);

有关这个简单示例的最后一点：buf 绝对不包含实际的 C 字符串。C 字符串由标记字符串结束的单一 \0 字符终止。因为 read() 不将 \0 添加到缓冲区的结尾，在 read() 上使用 strlen()（或任何其它 C 字符串函数）将可能铸成大错！这种行为可以让 read() 和 write() 对包括 \0 字符的数据处理，而这对于一般字符串函数来说是不可能的。

read() 和 write() 系统调用可以对绝大多数文件起作用。但它们不对目录起作用，目录应该通过特殊函数（例如 readdir()）来访问。另外，read() 和 write() 对于某些类型的套接字也不起作用。

某些文件，例如常规文件和块设备文件，使用文件指针的概念。它指定在文件中，下一个 read() 调用从哪里读取，下一个 write() 调用从哪里写入。read() 或 write() 后，文件指针随着已处理的字符数（在内部，通过内核）增加。这样，使用单一循环就可以方便地读取文件中的所有数据。清单 2 就是示例：

清单 2：

char buffer[1024];
while ((num = read(0, buffer, 1024))) {
printf("got some data\n");
}

这个循环将读取标准输入上的所有数据，自动在每次读取后增加内核的内部文件指针。当文件指针处于文件结尾时，read() 将返回 0 并退出循环。某些文件（例如字符设备 -- 终端就是很好的一例）本身没有文件指针，所以对于这一点，该程序将继续运行，直到用户提供文件结束标记（通过按 "Ctrl-D"）为止。

到现在为止，我们已经知道如何读写文件了，下一步要学习如何打开一个新文件。打开不同类型的文件有不同方法；我们将在这里讨论的方法是通过路径名打开在文 件系统中表示的文件；包括常规文件、目录、设备文件和指定的管道。某些套接字文件有路径名，那些必须通过替代方法打开。

撇开放弃权利的，open() 系统调用可以让程序访问大多数系统文件。open() 是个不寻常的系统调用，因为它获取两个或者三个自变量：

int open(const char *
pathname,
int flags);

或者，
int open(const char *
pathname,
int flags,
int perm);

第一种形式更普遍一些；它打开一个已存在的文件。第二种格式应该在需要创建文件时使用。第三个自变量指定应该给予新文件的访问权限。

open() 的第一个参数是以正常 C 字符串表示的全路径名（即以 \0 终止）。第二个参数指定文件应该如何打开，并包括逻辑“与”操作的一个或多个以下标志：

O_RDONLY：文件可以只读
O_RDWR：文件可以读写
O_APPEND：文件可以读或附加
O_CREAT：如果文件还不存在则应该创建
O_EXCL：如果文件已存在，失败而不是创建它（只应该使用 O_CREAT）
O_TRUNC：如果文件已存在，从中除去所有数据（与创建新文件类似）

open() 的第三个参数只在使用 O_CREAT 时需要；它指定了以数字表示的文件许可权（格式与 chown 命令的数值许可权自变量的格式相同。为 open() 指定的许可权受用户的 umask 影响，后者允许用户指定一系列新文件应该获得的缺省许可权。大多数创建文件的程序都使用第三个自变量 0666 调用 open()，可以让用户通过 umask 来控制程序的缺省许可权。（大多数 shell 的 umask 命令都可以更改它。）

例如，清单 3 显示了如何为进行读写打开文件、如果它不存在则创建，以及废弃其中的数据：

清单 3：

int fd;
fd = open("myfile", O_RDWR | O_CREAT | O_TRUNC, 0666)
if (fd < 0) {
/* Some error occurred */
/* ... */
}

open() 返回引用文件的文件描述符。回忆一下，文件描述符总是 >= 0。如果 open() 返回了一个负值，就表示发生了错误，全局变量错误号包含了描述问题的 Unix 错误代码。open() 总尽量返回最小数，如果没有使用文件描述符 0，open() 将总返回 0。

进程带文件结束时，它应该通过 close() 系统调用关闭它，该系统调用的格式为：

int close(int fd);

close 的文件描述符是传递给 close() 的唯一自变量，在成功情况下返回 0。尽管 close() 失败的情况比较少见，但如果文件描述符引用的是远程服务器上的文件，系统无法正确清空它的高速缓存，close() 就可能真的失败。进程终止时，内核自动关闭所有还在打开的文件。

最后的一个常见文件操作是移动文件指针。这（自然）只对带文件指针的文件有意义，如果尝试在不恰当的文件上尝试该操作就会返回错误。lseek() 系统调用用于以下目的：

off_t lseek(int fd, off_t pos, int whence);

off_t 类型是表达 longint （long 就是 lseek 中 "l" 的来历）的一种别致方法。lseek() 返回相对于文件开始处文件指针的最终位置，如果有错误，则返回 -1。这个系统调用希望被移动的文件指针所属的文件描述符作为第一个自变量，将它移动到文件中的位置作为第二个自变量。最后一个自变量描述文件指针的移动 方式。

SEEK_SET 将它移动到从文件开始算起的 pos 字节。
SEEK_END 将它移动到从文件结尾算起的 pos 字节。
SEEK_CUR 从它当前位置开始向文件结尾移动 pos 字节。

open()、close()、write()、read() 和 lseek() 的组合为 Linux 提供了基本的文件访问 API。虽然还有许多其它操纵文件的函数，但这里描述的是最常用的。

大多数程序员都使用熟悉的 ANSI C 库文件函数，例如 fopen() 和 fread()，而不是在此描述的低级系统调用。可以预见到，fopen() 和 fread() 是在用户级别库中这些系统调用的基础上实现的。仍然会经常看到低级系统调用的使用，特别是在更复杂的程序中。通过熟悉这些例程和接口，您就可以成为一个真 正的 Unix 黑客了。

关于作者
Erik Troan 是 Red Hat Software 的开发者，Linux Application Development 一书的作者之一。可以通过 ewt@redhat.com 与他联系。

1      tr -d  ''\r''<oldfile> newfile    **删掉回车**

2 应用-s参数：-s 删除所有重复出现字符序列，只保留第一个；

              即将重复出现字符串压缩为一个字符串。例如：

  tr  -s "\n"<oldfile> newfile    **删掉空行**

3      tr  "[a-z]" "[A-Z]"<oldfile> newfile   **小写到大写**

    或 tr  "[:lower:]" "[:upper:]"<oldfile> newfile

有问题的两点：

1 $ echo "this is a test " | tr -s "this" "that"

    that at a tet #不能够根据整个词进行替换

2 $ echo "this is a test " | tr -d "is"

    th  a tet  #把每一个字符都删除，不能当做整个字符串来处理

　　指令：mkfs

　　使用权限: 超级使用者

　　使用方式: mkfs [-V] [-t fstype] [fs-options] filesys [blocks]

　　说明：建立 linux 档案系统在特定的 partition 上

　　参数：

　　例子:

　　在 /dev/hda5 上建一个 msdos 的档案系统，同时检查是否有坏轨存在，并且将过程详细列出来:

　　mkfs -V -t msdos -c /dev/hda5

Linux 指令：文件系统--sync

　　名称 : sync

　　使用权限 : 系统管理者

　　使用方式 : sync

　　说明 : Linux 系统中欲写入硬盘的资料有的时候会了效率起见，会写到 filesystem buffer 中，这个 buffer 是一块记忆体空间，如果欲写入硬盘的资料存于此 buffer 中，而系统又突然断电的话，那么资料就会流失了，sync 指令会将存于 buffer 中的资料强制写入硬盘中。

名称: swapon

　　使用者权限: 超级使用者(super-user)

　　使用方式:

　　参数：

　　swapon 是开启swap。

　　相对的，便有一个关闭swap的指令，swapoff。

1．4 icache中的inode对象存取接口——iget／iput

1．4．1 iget()——引用一个inode对象
其他内核模块要想访问一个inode对象，必须通过iget()访问接口。该函数会首先在icache的哈希链表中查找相应的inode对象，如果找到，则将该对象的引用计数加1，然后返回该inode对象的指针。如果没有找到，则通过调用get_new_inode（）函数分配一个新的inode对象。该函数的源代码如下所示（include/linux/fs.h）：
static inline struct inode *iget(struct super_block *sb, unsigned long ino)
{
return iget4(sb, ino, NULL, NULL);
}
可以看出，实际的工作是由iget4()函数（带有4个参数的iget函数，所以叫iget4）来完成的，其源码如下（inode.c）：
struct inode *iget4(struct super_block *sb, unsigned long ino, find_inode_t find_actor, void *opaque)
{
struct list_head * head = inode_hashtable + hash(sb,ino);
struct inode * inode;

spin_lock(&inode_lock);
inode = find_inode(sb, ino, head, find_actor, opaque);
if (inode) {
__iget(inode);
spin_unlock(&inode_lock);
wait_on_inode(inode);
return inode;
}
spin_unlock(&inode_lock);

/*
* get_new_inode() will do the right thing, re-trying the search
* in case it had to block at any point.
*/
return get_new_inode(sb, ino, head, find_actor, opaque);
}
NOTE:
（1）首先，通过散列函数hash找到该inode对象应该在那个哈希链表中，然后调用find_inode（）函数在该哈希链表中查找是否存在该inode对象。。
（2）如果在哈希链表中找到了相应的inode对象（由超级块对象指针sb和索引节点号ino唯一确定），则先调用__iget（）函数增加该inode对象的引用计数。然后调用wait_on_inode（）函数等待该inode对象被其他内核模块解锁。最后，直接返回这个inode对象的指针。
（3）如果没有找到，则调用get_new_inode()函数分配一个新的inode对象。
内联函数__iget()用来增加一个inode对象的引用计数。该函数首先判断inode对象的I_count的当前值。如果它非0，则将I_count加1后就直接返回。如果它为0，则先将I_count加1，然后就看看这个inode对象当前是否为脏，如果为脏（I_state&I_DIRTY非0），那就什么也不做，让该inode对象继续待在超级块对象的s_dirty链表中。如果不为脏，则将该inode对象从原来的“类型”链表（应该在inode_unused链表中）中删除，并将其连入到inode_in_use链表中。最后将icache统计信息中的未使用inode个数减1。
static inline void __iget(struct inode * inode)
{
if (atomic_read(&inode->i_count)) {
atomic_inc(&inode->i_count);
return;
}
atomic_inc(&inode->i_count);
if (!(inode->i_state & I_DIRTY)) {
list_del(&inode->i_list);
list_add(&inode->i_list, &inode_in_use);
}
inodes_stat.nr_unused--;
}
wait_on_inode()函数测试一个inode对象是否已经被加锁，如果是，则调用__wait_on_inode()函数等待该inode被解锁。否则就直接返回：
static inline void wait_on_inode(struct inode *inode)
{
if (inode->i_state & I_LOCK)
__wait_on_inode(inode);
}
get_new_inode()函数用于得到一个新的inode对象。该函数首先调用alloc_inode宏从inode_cachep这个slab分配器缓存中分配一个新的inode对象。如下所示：
static struct inode * get_new_inode(struct super_block *sb, unsigned long ino, struct list_head *head, find_inode_t find_actor, void *opaque)
{
struct inode * inode;

inode = alloc_inode();
if (inode) {
struct inode * old;

spin_lock(&inode_lock);
/* We released the lock, so.. */
old = find_inode(sb, ino, head, find_actor, opaque);
if (!old) {
inodes_stat.nr_inodes++;
list_add(&inode->i_list, &inode_in_use);
list_add(&inode->i_hash, head);
inode->i_sb = sb;
inode->i_dev = sb->s_dev;
inode->i_ino = ino;
inode->i_flags = 0;
atomic_set(&inode->i_count, 1);
inode->i_state = I_LOCK;
spin_unlock(&inode_lock);

clean_inode(inode);
sb->s_op->read_inode(inode);

/*
* This is special! We do not need the spinlock
* when clearing I_LOCK, because we're guaranteed
* that nobody else tries to do anything about the
* state of the inode when it is locked, as we
* just created it (so there can be no old holders
* that haven't tested I_LOCK).
*/
inode->i_state &= ~I_LOCK;
wake_up(&inode->i_wait);

return inode;
}

/*
* Uhhuh, somebody else created the same inode under
* us. Use the old inode instead of the one we just
* allocated.
*/
__iget(old);
spin_unlock(&inode_lock);
destroy_inode(inode);
inode = old;
wait_on_inode(inode);
}
return inode;
}

（1）由于在调用get_new_inode函数时，调用者已经释放了inode_lock锁，因此在inode_lock被释放到调用get_new_inode函数期间，其他内核模块有可能已经创建了（sb,ino）所确定的索引节点。所以，get_new_inode函数必须重新调用find_inode函数，以再一次在哈希链表中查找是否已存在相应的inode对象。
（2）如果find_inode（）返回一个有效的指针，则说明其它模块已经创建了（sb,ino）这个inode对象，因此就要调用destroy_inode（）函数来销毁一开始创建的inode对象，然后调用__iget()函数增加所找到的inode对象的引用计数，然后用wait_on_inode（）函数等待他被解锁。
（3）如果find_inode()返回NULL，则对先前所分配的inode对象进行初始化。其中，要调用clean_inode（）函数和超级块的s_op->read_inode()方法，以从块设备上读取磁盘索引节点的内容。最后，返回所分配的inode对象的指针。

1．4．2 iput（）函数——释放对一个inode对象的引用
当其他内核对象或模块不再需要一个inode对象时，必须通过iput（）函数，来解除对该inode对象的引用。
iput()函数将inode对象的引用计数减1。如果减到了0，则将该inode释放。否则就直接返回。
/**
* iput - put an inode
* @inode: inode to put
*
* Puts an inode, dropping its usage count. If the inode use count hits
* zero the inode is also then freed and may be destroyed.
*/

void iput(struct inode *inode)
{
if (inode) {
struct super_operations *op = NULL;

if (inode->i_sb && inode->i_sb->s_op)
op = inode->i_sb->s_op;
if (op && op->put_inode)
op->put_inode(inode);

if (!atomic_dec_and_lock(&inode->i_count, &inode_lock))
return;

if (!inode->i_nlink) {
list_del(&inode->i_hash);
INIT_LIST_HEAD(&inode->i_hash);
list_del(&inode->i_list);
INIT_LIST_HEAD(&inode->i_list);
inode->i_state|=I_FREEING;
inodes_stat.nr_inodes--;
spin_unlock(&inode_lock);

if (inode->i_data.nrpages)
truncate_inode_pages(&inode->i_data, 0);

if (op && op->delete_inode) {
void (*delete)(struct inode *) = op->delete_inode;
/* s_op->delete_inode internally recalls clear_inode() */
delete(inode);
} else
clear_inode(inode);
if (inode->i_state != I_CLEAR)
BUG();
} else {
if (!list_empty(&inode->i_hash)) {
if (!(inode->i_state & I_DIRTY)) {
list_del(&inode->i_list);
list_add(&inode->i_list,
&inode_unused);
}
inodes_stat.nr_unused++;
spin_unlock(&inode_lock);
return;
} else {
/* magic nfs path */
list_del(&inode->i_list);
INIT_LIST_HEAD(&inode->i_list);
inode->i_state|=I_FREEING;
inodes_stat.nr_inodes--;
spin_unlock(&inode_lock);
clear_inode(inode);
}
}
destroy_inode(inode);
}
}
对该函数的注释如下：
（1）函数首先调用超级块对象中的s_op->put_inode（）方法（如果有的话）来释放这个inode对象。
（2）通过atomic_dec_and_lock原子操作将I_count减1，并同时对inode_lock进行加锁。如果I_count在减1后还为非0值，则直接返回。否则就进行下面的处理。
（3）如果该inode的i_nlink值为0，则说明文件系统中已经没有任何文件链接到这个inode对象上。对于这种情况，iput()先将这个inode从其所属的哈希链表和“类型”链表中摘除。然后在其i_count中设置I_FREEING标志，表示正在释放这个inode对象。最后，看看是否定义了超级块对象方法s_op->delete_inode()，如果有则调用该方法删除相应的磁盘索引节点，如果未定义该方法，则调用clear_inode（）函数来清除这个inode对象。最后，用destroy_inode()将这个内存索引节点释放给inode_cachep slab分配器缓存。
（4）如果该inode的i_nlink不为0，则说明虽然没有人引用这个inode对象，但fs中还有文件链接与这个inode对象相关联，因此这个inode对象有可能再次被引用。对于这种情况，iput()函数首先判断这个inode对象是否正连接在哈希链表中。如果是，则将这个inode对象放到inode_unused链表中（当然，前提是这个inode对象不在s_dirty链表中，如果他在s_dirty链表中，则让他继续待在s_dirty链表中），然后直接返回就可以了。如果不是，则这个inode对象已经不用继续留在icache中了（反正通过哈希链表也找不到他），因此将这个inode对象从其所属的“类型”链表中摘除，然后调用clear_inode()方法清除这个inode对象，最后调用destroy_indoe（）将这个内存索引节点释放回inode_cachep slab分配器缓存。注意！这里不能调用超级块对象的delete_inode（）方法来删除对应的磁盘索引节点，因为fs中还有文件链接与这个inode相关联。