在 UNIX/Linux 系統中，一切皆文件，這句話想必都有聽過。對于文件的操作幾乎適用于所有的設備，這也就看出了文件操作的重要性了。在C語言再學習部分有講過標準I/O文件操作，參看：C語言再學習 -- 文件?下面我們來講解下系統文件I/O的。

一、文件描述符

1、文件描述符簡介

首先從文件描述符開始講起。因為，對于內核而言，所有打開的文件都是通過文件描述符引用的。那么文件描述符到底是什么？

文件描述符（file descriptor）通常是一個小的非負整數，內核用以標識一個特定進程正在訪問的文件。當打開一個現有文件或創建一個新文件時，內核向進程返回一個文件描述符。當讀、寫一個文件時，使用 open 或 create 返回的文件描述符標識該文件，將其作為參數傳送給 read 或 write。

2、標準輸入、標準輸出和標準錯誤

按照慣例，UNIX 系統 shell 把文件描述符 0 與進程的標準輸入（standard input）關聯，文件描述符 1 與標準輸出（standard output）關聯，文件描述符 2 與標準錯誤（standard error）關聯。這是各種 shell 以及很多應用程序使用的慣例，與 UNIX 內核無關。盡管如此，如果不遵循這種慣例，很多 UNIX 系統應用程序就不能正常工作。

這部分講 shell 編程重定向時，可參看UNIX再學習 -- shell編程

POSIX 定義了 STDIN_FILENO、STDOUT_FILENO 和 STDERR_FILENO 來代替 0、1、2。這三個符號常量的定義位于頭文件?<unistd.h>

查看 /usr/include/unistd.h /* Standard file descriptors. */ #define STDIN_FILENO 0 /* Standard input. */ #define STDOUT_FILENO 1 /* Standard output. */ #define STDERR_FILENO 2 /* Standard error output. */ 文件描述符的有效范圍是 0 到 OPEN_MAX。一般來說，每個進程最多可以打開 64 個文件（0 — 63）。對于 FreeBSD 8.0、Linux 3.2.0、Mac OS X 10.6.8 以及 Solaris 10 來說，文件描述符的變化范圍幾乎是無限的，它只受系統配置的存儲器總量、整型的字長以及系統管理員所配置的軟限制和硬限制的約束。

OPEN_MAX：每個進程最大打開文件數。查看如下：

查看 man sysconf PEN_MAX - _SC_OPEN_MAXThe maximum number of files that a process can have open at any time. Must not be less than _POSIX_OPEN_MAX (20). 或參看：man sysconf()
#include <unistd.h> #include <stdio.h> int main (void) {printf("_SC_ARG_MAX: %ld\n", sysconf(_SC_ARG_MAX));printf("_SC_CHILD_MAX: %ld\n", sysconf(_SC_CHILD_MAX));printf("_SC_CLK_TCK: %ld\n", sysconf(_SC_CLK_TCK));printf("_SC_NGROUPS_MAX: %ld\n", sysconf(_SC_NGROUPS_MAX));printf("_SC_OPEN_MAX: %ld\n", sysconf(_SC_OPEN_MAX));printf("_SC_JOB_CONTROL: %ld\n", sysconf(_SC_JOB_CONTROL));printf("_SC_SAVED_IDS: %ld\n", sysconf(_SC_SAVED_IDS));printf("_SC_VERSION: %ld\n", sysconf(_SC_VERSION));return 0; } 輸出結果： _SC_ARG_MAX: 2097152 _SC_CHILD_MAX: 7892 _SC_CLK_TCK: 100 _SC_NGROUPS_MAX: 65536 _SC_OPEN_MAX: 1024 _SC_JOB_CONTROL: 1 _SC_SAVED_IDS: 1 _SC_VERSION: 200809 可得，在 Ubuntu 12.04 下測試結果為：_SC_OPEN_MAX =1024?

而在?/apue.3e/exercises/openmax.c 也是有獲取系統的 _SC_OPEN_MAX 的程序，可自行查看。

3、最大文件描述符數

通過上面可知，默認的 Linux 進程的最大打開文件描述符數是 1024。但是在某些情況下這點文件描述符數是遠遠不夠的，可根據需要進行更改。

第一種方法：通過 ulimit 命令修改 ?

參看：ulimit 命令? ?? ulimit 用于限制 shell 啟動進程所占用的資源，支持以下各種類型的限制：所創建的內核文件的大小、進程數據塊的大小、Shell 進程創建文件的大小、內存鎖住的大小、常駐內存集的大小、打開文件描述符的數量、分配堆棧的最大大小、CPU 時間、單個用戶的最大線程數、Shell 進程所能使用的最大虛擬內存。同時，它支持硬資源和軟資源的限制。? 作為臨時限制，ulimit 可以作用于通過使用其命令登錄的 shell 會話，在會話終止時便結束限制，并不影響于其他 shell 會話。而對于長期的固定限制，ulimit 命令語句又可以被添加到由登錄 shell 讀取的文件中，作用于特定的 shell 用戶。 選項： 選項 [options] 含義 例子 -H 設置硬資源限制，一旦設置不能增加。 ulimit – Hs 64；限制硬資源，線程棧大小為 64K。 -S 設置軟資源限制，設置后可以增加，但是不能超過硬資源設置。 ulimit – Sn 32；限制軟資源，32 個文件描述符。 -a 顯示當前所有的 limit 信息。 ulimit – a；顯示當前所有的 limit 信息。 -c 最大的 core 文件的大小， 以 blocks 為單位。 ulimit – c unlimited； 對生成的 core 文件的大小不進行限制。 -d 進程最大的數據段的大小，以 Kbytes 為單位。 ulimit -d unlimited；對進程的數據段大小不進行限制。 -f 進程可以創建文件的最大值，以 blocks 為單位。 ulimit – f 2048；限制進程可以創建的最大文件大小為 2048 blocks。 -l 最大可加鎖內存大小，以 Kbytes 為單位。 ulimit – l 32；限制最大可加鎖內存大小為 32 Kbytes。 -m 最大內存大小，以 Kbytes 為單位。 ulimit – m unlimited；對最大內存不進行限制。 -n 可以打開最大文件描述符的數量。 ulimit – n 128；限制最大可以使用 128 個文件描述符。 -p 管道緩沖區的大小，以 Kbytes 為單位。 ulimit – p 512；限制管道緩沖區的大小為 512 Kbytes。 -s 線程棧大小，以 Kbytes 為單位。 ulimit – s 512；限制線程棧的大小為 512 Kbytes。 -t 最大的 CPU 占用時間，以秒為單位。 ulimit – t unlimited；對最大的 CPU 占用時間不進行限制。 -u 用戶最大可用的進程數。 ulimit – u 64；限制用戶最多可以使用 64 個進程。 -v 進程最大可用的虛擬內存，以 Kbytes 為單位。 ulimit – v 200000；限制最大可用的虛擬內存為 200000 Kbytes。
英文信息，可?man bash?查看
ulimit [-HSTabcdefilmnpqrstuvx [limit]]Provides control over the resources available to the shell and to processes started by it, on systems that allow such con‐trol. The -H and -S options specify that the hard or soft limit is set for the given resource. A hard limit cannot beincreased by a non-root user once it is set; a soft limit may be increased up to the value of the hard limit. If neither -Hnor -S is specified, both the soft and hard limits are set. The value of limit can be a number in the unit specified for theresource or one of the special values hard, soft, or unlimited, which stand for the current hard limit, the current softlimit, and no limit, respectively. If limit is omitted, the current value of the soft limit of the resource is printed,unless the -H option is given. When more than one resource is specified, the limit name and unit are printed before thevalue. Other options are interpreted as follows:-a All current limits are reported-b The maximum socket buffer size-c The maximum size of core files created-d The maximum size of a process's data segment-e The maximum scheduling priority ("nice")-f The maximum size of files written by the shell and its children-i The maximum number of pending signals-l The maximum size that may be locked into memory-m The maximum resident set size (many systems do not honor this limit)-n The maximum number of open file descriptors (most systems do not allow this value to be set)-p The pipe size in 512-byte blocks (this may not be set)-q The maximum number of bytes in POSIX message queues-r The maximum real-time scheduling priority-s The maximum stack size-t The maximum amount of cpu time in seconds-u The maximum number of processes available to a single user-v The maximum amount of virtual memory available to the shell and, on some systems, to its children-x The maximum number of file locks-T The maximum number of threadsIf limit is given, it is the new value of the specified resource (the -a option is display only). If no option is given,then -f is assumed. Values are in 1024-byte increments, except for -t, which is in seconds, -p, which is in units of512-byte blocks, and -T, -b, -n, and -u, which are unscaled values. The return status is 0 unless an invalid option or argu‐ment is supplied, or an error occurs while setting a new limit.實例：

顯示當前最大打開文件描述符數

# ulimit -n 1024

修改當前用戶環境下的最大打開文件描述符數 （臨時更改）

設置當前用戶環境下的最大打開文件描述符數為 65536 # ulimit -HSn 65536查看： # ulimit -n 65536

將指令添加到腳本中 （永久更改）

添加到 單用戶目錄下：/etc/bash.bashrc?或?~/.bashrc

echo "ulimit -HSn 65536" >> ~/.bashrc 或者 echo "ulimit -HSn 65536" >> /etc/bash.bashrc 我使用的是 root 超級用戶登錄，而非 non-root 登錄的，所以放在?/etc/profile 等針對所有用戶的不起作用。

還有網上說的寫到 rc.local 我也沒有實現。

第二種方法：修改 limits.conf 文件 （永久更改）

在 /etc/security/limits.conf 文件最后加入如下兩行：

* soft nofile 65536 * hard nofile 65536 ?其中 * 代表所有用戶，nofile 是代表最大文件打開數。用 non-root 登錄，通過 ulimit -n 查看是否生效。

告訴你個不幸的消息，很遺憾我的沒有生效。將 * 改為 root 則可以生效，因為我用的不是 non-root 登錄的。

查看最大文件描述符數上限

當然，這個最大文件描述符數也是有上限的，比如設置一個很大的數，會提示如下錯誤： # ulimit -n 100000000 bash: ulimit: open files: 無法修改 limit 值: 不允許的操作 而最大文件描述符數的上限值是在?/proc/sys/fs/nr_open 設置的，默認為?1048576 你也可以修改它，比如執行： echo 2000000 > /proc/sys/fs/nr_open

4、混淆的概念

在我看到的很多文章里，有不少將?/proc/sys/fs/file-max 看作了 最大文件描述符數的上限值，其實是不對的。那么到底 file-max 和 nr_open 有什么區別呢？ 查看?linux/Documentation/sysctl/fs.txt，可看到關于 file-max 和 nr_open 的解釋： file-max & file-nr:The kernel allocates file handles dynamically, but as yet it doesn't free them again.The value in file-max denotes the maximum number of file- handles that the Linux kernel will allocate. When you get lots of error messages about running out of file handles, you might want to increase this limit.Historically, the three values in file-nr denoted the number of allocated file handles, the number of allocated but unused file handles, and the maximum number of file handles. Linux 2.6 always reports 0 as the number of free file handles -- this is not an error, it just means that the number of allocated file handles exactly matches the number of used file handles.Attempts to allocate more file descriptors than file-max are reported with printk, look for "VFS: file-max limit <number> reached".nr_open:This denotes the maximum number of file-handles a process can allocate. Default value is 1024*1024 (1048576) which should be enough for most machines. Actual limit depends on RLIMIT_NOFILE resource limit.翻譯一下： 關于 file-max 內核可以動態的分配文件句柄，但到目前為止是不會釋放它們的。
file-max 的值表示Linux內核分配的最大文件句柄數，如果你看到了很多關于打開文件數已經達到了最大值的錯誤信息，你可以試著增加該值的限制。 在kernel 2.6之前的版本中，file-nr 中的值由三部分組成，分別為：1.已經分配的文件句柄數，2.已經分配但沒有使用的文件句柄數，3.最大文件句柄數。但在 kernel 2.6 版本中第二項的值總為 0，這并不是一個錯誤，它實際上意味著已經分配的文件句柄無一浪費的都已經被使用了。
關于 nr_open nr_open 的值表示一個進程可以分配的最大文件句柄數。 默認值為1024 * 1024（1048576），應該足夠用于大多數機器。 實際限制取決于RLIMIT_NOFILE資源限制。

（1）概念解析

先說 file_max

前面的翻譯，我們已經知道?file-max 的值表示Linux內核分配的最大文件句柄數。 讓我們再查看一下更多關于它的內容： man proc /proc/sys/fs/file-maxThis file defines a system-wide limit on the number of open files for all processes. (See also setrlimit(2), which can beused by a process to set the per-process limit, RLIMIT_NOFILE, on the number of files it may open.) If you get lots of errormessages about running out of file handles, try increasing this value:echo 100000 > /proc/sys/fs/file-maxThe kernel constant NR_OPEN imposes an upper limit on the value that may be placed in file-max.If you increase /proc/sys/fs/file-max, be sure to increase /proc/sys/fs/inode-max to 3-4 times the new value of/proc/sys/fs/file-max, or you will run out of inodes.翻譯一下： 該文件定義了所有進程的打開文件數量的系統范圍限制。 （另見setrlimit（2），可以是被一個進程用來設置每個進程的限制，RLIMIT_NOFILE，對它可能打開的文件數。）如果你收到很多錯誤關于運行文件句柄的消息，嘗試增加此值。
內核常量 NR_OPEN 對可以放在 file-max中 的值施加上限。如果增加 /proc/sys/fs/file-max，請確保將 /pro /sys/fs/inode-max 增加到新值的 3-4 倍，否則?/proc/sys/fs/file-max，否則將用盡inode。 比 file-max 中的值大 3-4 倍，因為 stdin，stdout 和網絡套接字也需要一個 inode 來處理它們。

意思是，修改file-max時也要按其值的 3-4 倍來修改 inode-max。 而file-max 的值我們可以使用 cat 查看： # cat /proc/sys/fs/file-max 100987 而有種說法是?file-max 一般為內存大小（KB）的 10% 來計算，如果使用 shell，可以這樣計算： # grep MemTotal /proc/meminfo | awk '{printf("%d\n",$2/10)}' 102479經比較，可能由于有各種其他原因導致 file-max 沒有設置為內存的 10%。
再有關于?file-nr 中的值由三部分組成，分別為：1.已經分配的文件句柄數，2.已經分配但沒有使用的文件句柄數，3.最大文件句柄數。第二項的值總為 0，這并不是一個錯誤，它實際上意味著已經分配的文件句柄無一浪費的都已經被使用了。 # cat /proc/sys/fs/file-nr 6464 0 100987
而，file-max 的值也有兩種方式修改： 第一種：臨時更改echo 1000000 > /proc/sys/fs/file-max第二種：永久更改 修改 /etc/sysctl.conf 文件，末尾增加 fs.file-max = 1000000

注意幾句話， file-max 的值表示Linux內核分配的最大文件句柄數。 file-max?該文件定義了所有進程的打開文件數量的系統范圍限制。（系統級）
ulimit 用于限制 shell 啟動進程所占用的資源。 （進程級）
nr_open 的值表示一個進程可以分配的最大文件句柄數。 （進程級） 這也間接說明了，nr_open 是 ulimit -HSn 的上限值。

（2）系統級 和 進程級 的區別

首先，系統級

我們剛才有查看 file-nr： # cat /proc/sys/fs/file-nr 6464 0 100987file-nr 中的值由三部分組成，分別為：1.已經分配的文件句柄數，2.已經分配但沒有使用的文件句柄數，3.最大文件句柄數。也就是說，系統文件描述符的數量目前被使用 6464. 例如，查看 proc 目錄：

使用 ps 指令查看當前終端啟動的進程 使用 ps -aux 表示顯示所有包含其他使用者的進程
使用 ps -aux | more 表示將ps -aux的結果進行分屏顯示
# psPID TTY TIME CMD2401 pts/1 00:00:00 bash3054 pts/1 00:00:00 ps # ps -aux | more Warning: bad ps syntax, perhaps a bogus '-'? See http://procps.sf.net/faq.html USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.1 3612 2024 ? Ss 10:53 0:01 /sbin/init root 2 0.0 0.0 0 0 ? S 10:53 0:00 [kthreadd] root 3 0.0 0.0 0 0 ? S 10:53 0:00 [ksoftirqd/0] root 6 0.0 0.0 0 0 ? S 10:53 0:00 [migration/0] root 7 0.0 0.0 0 0 ? S 10:53 0:01 [watchdog/0] root 8 0.0 0.0 0 0 ? S< 10:53 0:00 [cpuset] root 9 0.0 0.0 0 0 ? S< 10:53 0:00 [khelper] root 10 0.0 0.0 0 0 ? S 10:53 0:00 [kdevtmpfs] .....那我們就看看當前終端啟動的進程 2401 lsof 命令可以查出某個進程打開的文件數目，wc -l 只顯示列數 lsof使用，參看：lsof 命令 # lsof | grep '2401' | wc -l 20意思是有20個文件被打開查詢進程使用的文件描述符數目# ls -l /proc/2401/fd/ | wc -l 5意思是文件描述符只有5個所以說，一個文件即使被打開，也可能沒有文件描述符，比如當前工作目錄，內存映射文件和可執行文本文件。
以上的 fd 就是系統文件描述符。

再者，進程級

比如，使用open 和 close 函數查看 fd 的值： //open函數和close函數的使用 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h>int main(void) {// while (1){int fd = open("a.txt",O_WRONLY|O_CREAT|O_TRUNC,0644);if(-1 == fd){perror("open"),exit(-1);}printf ("fd = %d\n", fd); #if 1 //2.關閉文件int res = close(fd);if(-1 == res){perror("close"),exit(-1);}#endif // }return 0; } 輸出結果： fd = 3 該程序，除去標準輸入（0）、標準輸出（1）、標準錯誤（2），文件描述符從 3 開始。 將上面的程序改為循環，其結果為：忽略.... fd = 1019 fd = 1020 fd = 1021 fd = 1022 fd = 1023 open: Too many open files 可以看到當 fd = 1023 再往后，出現錯誤?open: Too many open files，而這個 1024，不就是在 Ubuntu 12.04 下測試結果為：_SC_OPEN_MAX =1024 即： # ulimit -n 1024 這里的 fd 是進程級的文件描述符。

5、文件描述符和文件指針

（1）文件描述符和文件指針比較

參看：文件句柄（file handles） & 文件描述符（file descriptors）
文件描述符（fd）：在linux系統中打開文件就會獲得文件描述符，它是個很小的正整數。每個進程在PCB（Process Control Block）中保存著一份文件描述符表，文件描述符就是這個表的索引，每個表項都有一個指向已打開文件的指針。 文件指針（FILE*）：C 語言中使用文件指針做為 I/O的句柄。文件指針指向進程用戶區中的一個被稱為 FILE 結構的數據結構。FILE 結構包括一個緩沖區和一個文件描述符。而文件描述符是文件描述符表的一個索引，因此從某種意義上說文件指針就是句柄的句柄（在Windows系統上，文件描述符被稱作文件句柄）。
通過?/usr/include/libio.h 查看?C 語言中 _IO_FILE 結構體的定義:? struct _IO_FILE {int _flags; /* High-order word is _IO_MAGIC; rest is flags. */ #define _IO_file_flags _flags/* The following pointers correspond to the C++ streambuf protocol. *//* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */char* _IO_read_ptr; /* Current read pointer */char* _IO_read_end; /* End of get area. */char* _IO_read_base; /* Start of putback+get area. */char* _IO_write_base; /* Start of put area. */char* _IO_write_ptr; /* Current put pointer. */char* _IO_write_end; /* End of put area. */char* _IO_buf_base; /* Start of reserve area. */char* _IO_buf_end; /* End of reserve area. *//* The following fields are used to support backing up and undo. */char *_IO_save_base; /* Pointer to start of non-current get area. */char *_IO_backup_base; /* Pointer to first valid character of backup area */char *_IO_save_end; /* Pointer to end of non-current get area. */struct _IO_marker *_markers;struct _IO_FILE *_chain;int _fileno; #if 0int _blksize; #elseint _flags2; #endif_IO_off_t _old_offset; /* This used to be _offset but it's too small. */#define __HAVE_COLUMN /* temporary *//* 1+column number of pbase(); 0 is unknown. */unsigned short _cur_column;signed char _vtable_offset;char _shortbuf[1];/* char* _save_gptr; char* _save_egptr; */_IO_lock_t *_lock; #ifdef _IO_USE_OLD_IO_FILE };我們可以通過?/usr/include/stdio.h? C??語言中 FILE 結構體的定義:/* Define outside of namespace so the C++ is happy. */ struct _IO_FILE;__BEGIN_NAMESPACE_STD /* The opaque type of streams. This is the definition used elsewhere. */ typedef struct _IO_FILE FILE; __END_NAMESPACE_STD #if defined __USE_LARGEFILE64 || defined __USE_SVID || defined __USE_POSIX \|| defined __USE_BSD || defined __USE_ISOC99 || defined __USE_XOPEN \|| defined __USE_POSIX2 __USING_NAMESPACE_STD(FILE) #endif# define __FILE_defined 1 #endif /* FILE not defined. */ #undef __need_FILE#if !defined ____FILE_defined && defined __need___FILE/* The opaque type of streams. This is the definition used elsewhere. */ typedef struct _IO_FILE __FILE;在這個_IO_FILE結構體中的“int _fileno”就是fd，即文件描述符。舉例驗證：
#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> #include<unistd.h>int main(){char buf[50] = {"file descriptor demo"};FILE *myfile;myfile = fopen("test","w+");if(!myfile){printf("error: openfile failed!\n");}printf("The openfile's descriptor is %d\n", myfile->_fileno);if(write(myfile->_fileno,buf,50)<0){perror("error: write file failed!\n");exit(1);}else{printf("writefile successed!\n");}exit(0); } 輸出結果： The openfile's descriptor is 3 writefile successed!查看 test cat test? file descriptor demoroot

（2）文件描述符和文件指針相互轉換

文件指針轉文件描述符：

參看：百度百科--fileno 函數 fileno int _fileno( FILE *stream );
?fileno?用來取得參數stream指定的文件流所使用的文件描述符。
實例： #include <stdio.h> int main( void ) {printf( "The file descriptor for stdin is %d\n", fileno( stdin ) );printf( "The file descriptor for stdout is %d\n", fileno( stdout ) );printf( "The file descriptor for stderr is %d\n", fileno( stderr ) );return 0; } 輸出結果： The file descriptor for stdin is 0 The file descriptor for stdout is 1 The file descriptor for stderr is 2 #include <stdio.h> int main(void) {FILE *fp;int fd;fp = fopen("/etc/passwd", "r");fd = fileno(fp);printf("fd = %d\n", fd);fclose(fp);return 0; } 輸出結果： fd = 3

文件描述符轉文件指針：

參看：百度百科--fdopen 函數 fdopen
FILE* fdopen(int fd, const char* type);
fdopen 取一個現存的文件描述符，并使一個標準的I / O流與該描述符相結合。此函數常用于由創建管道和網絡通信通道函數獲得的描述符。因為這些特殊類型的文件不能用標準I/O fopen函數打開，首先必須先調用設備專用函數以獲得一個文件描述符，然后用fdopen使一個標準I/O流與該描述符相結合。
實例：標準輸出文件描述符為1 #include<stdio.h> int main (void) {FILE * fp = fdopen (1, "w+");fprintf (fp, "%s\n", "hello!");fclose (fp);return 0; } 輸出結果： hello!

總結

以上是生活随笔為你收集整理的UNIX再学习 -- 文件描述符的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。