本文章中的示例代碼是在 CentOS 5.4 64 位環境下運行通過的，在其它 unix 系統上沒有測試過。

Linux 操作系統中的命令實際上是編譯好的可執行程序，比如說 ls 這個命令，這個文件位于 /bin 目錄下面，當我們用 file /bin/ls 命令查看的時候會有以下輸出：

[root@localhost ~]# file /bin/ls
/bin/ls: ELF 64-bit LSB executable,
AMD x86-64, version 1 (SYSV), for GNU/Linux 2.6.9,
dynamically linked (uses shared libs), for GNU/Linux 2.6.9, stripped

這個命令通過調用 stat 系統調用和 /usr/share/file/magic.mgc 文件來決定文件的類型。如上的 /bin/ls 是一個 ELF 格式的動態鏈接的 64 位的可執行文件。

系統調用是用戶程序和操作系統內核之間的接口，我們可以使用操作系統提供的系統調用來請求分配資源和服務。我們可以通過 man 2 章節來查找 Linux 提供的系統調用的具體使用方法。有關文件操作的常見系統調用命令有：open、creat、close、read、write、lseek、opendir、readdir、mkdir、stat 等等。

cp 命令的實現

cp 命令的模擬實現

大家也都知道 cp 這個命令主要的作用就是把一個文件從一個位置復制到另一個位置。比如現在 /root 目錄下有一個 test.txt 文件，如果我們用 cp test.txt test2.txt 命令的話，在同一個目錄下面就會生成一個同樣內容的 test2.txt 文件了。

那么 cp 命令是怎么實現的呢，我們看如下代碼：

清單 1. cp 命令實現代碼

#include
#include
#include
#include
#define BUFFERSIZE 4096
#define COPYMODE 0644
void oops(char *, char *);
main(int argc, char * argv[])
{
int in_fd, out_fd, n_chars;
char buf[BUFFERSIZE];
if ( argc != 3 ){
fprintf( stderr, "usage: %s source destination\n", *argv);
exit(1);
}
if ( (in_fd=open(argv[1], O_RDONLY)) == -1 ){
oops("Cannot open ", argv[1]);
}
if ( (out_fd=creat( argv[2], COPYMODE)) == -1 ){
oops( "Cannot creat", argv[2]);
}
while ( (n_chars = read(in_fd , buf, BUFFERSIZE)) > 0 ){
if ( write( out_fd, buf, n_chars ) != n_chars ){
oops("Write error to ", argv[2]);
}
}
if ( n_chars == -1 ){
oops("Read error from ", argv[1]);
}
if ( close(in_fd) == -1 || close(out_fd) == -1 )
oops("Error closing files","");
}
void oops(char *s1, char *s2)
{
fprintf(stderr,"Error: %s ", s1);
perror(s2);
exit(1);
}

該程序的主要實現思想是：打開一個輸入文件，創建一個輸出文件，建立一個 BUFFERSIZE 大小的緩沖區;然后在判斷輸入文件未完的循環中，每次讀入多少就向輸出文件中寫入多少，直到輸入文件結束。

cp 命令實現的說明

讓我來詳細的講述一下這個程序：

·開頭四行包含了 4 個頭文件， 文件包含了 fprintf、perror 的函數原型定義; 文件包含了 read、write 的函數原型定義; 文件包含了 open、creat 的函數原型定義、 文件包含了 exit 的函數原型定義。這些函數原型有些是系統調用、有些是庫函數，通常都可以在 /usr/include 目錄中找到這些頭文件。

·接下來的 2 行以宏定義的方式定義了 2 個常量。BUFFERSIZE 用來表示緩沖區的大小、COPYMODE 用來定義創建文件的權限。

·接下來的一行定義了一個函數原型 oops，該函數的具體定義在最后出現，用來輸出出錯信息到 stderr，也就是標準錯誤輸出的文件流。

·接下來主程序開始。首先定義了 2 個文件描述符、一個存放讀出字節數的變量 n_chars、和一個 BUFFERSIZE 大小的字符數組用來作為拷貝文件的緩沖區。

·接下來判斷輸入參數的個數是否為 3，也就是程序名 argv[0]、拷貝源文件 argv[1]、目標文件 argv[2]。不為 3 的話就輸出錯誤信息到 stderr，然后退出程序。

·接下來的 2 行，用 open 系統調用以 O_RDONLY 只讀模式打開拷貝源文件，如果打開失敗就輸出錯誤信息并退出。如果想了解文件打開模式的詳細內容請使用命令 man 2 open，來查看幫助文檔。

·接下來的 2 行，用 creat 系統調用以 COPYMODE 的權限建立一個文件，如果建立失敗函數的返回值為 -1 的話，就輸出錯誤信息并退出。

·接下來的循環是拷貝的主要過程。它從輸入文件描述符 in_fd 中，讀入 BUFFERSIZE 字節的數據，存放到 buf 字符數組中。在正常讀入的情況下，read 函數返回實際讀入的字節數，也就是說只要沒有異常情況和文件沒有讀到結尾，那么 n_chars 中存放的就是實際讀出的字節的數字。然后 write 函數將從 buf 緩沖區中，讀出 n_chars 個字符，寫入 in_out 輸出文件描述符。由于 write 系統調用返回的是實際寫入成功的字節數。所以當讀出 N 個字符，又成功寫入 N 個字符到輸出文件描述符中去的時候，就表示寫成功了，否則就報告寫入錯誤。

·最后就是用 close 系統調用關閉打開的輸入和輸出文件描述符。#p#

rm 命令的實現

rm 命令的模擬實現

rm 命令主要是用來刪除一個文件。

該命令的實現代碼如下：

清單 2. rm 命令代碼

#include
#include
#include
int main(int argc , char * argv[]) {
int rt;
if(argc != 2){
exit(2);
}else{
if((rt = unlink(argv[1])) != 0){
fprintf(stderr,"error.");
exit(3);
}
}
return 0;
}

其中程序的關鍵是 unlink 系統調用，unlink 函數原型包含在 頭文件里面。

用 strace 來跟蹤命令

我們從這個程序的創建過程來分析這個程序。

這個命令的模擬程序是怎么寫出來的呢?

首先，我們可以在機器上 touch test 建立一個 test 文件，然后調用 strace rm test 命令來查看 rm 命令具體使用了那些系統調用。

通過查看，我們看到主要使用的系統調用如下：

[root@localhost aa]# strace rm test
execve("/bin/rm", ["rm", "test"], [/* 24 vars */]) = 0
brk(0) = 0xcc66000
mmap(NULL, 4096, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x2aff83ffb000
uname({sys="Linux", node="localhost.localdomain", ...}) = 0
...
...
lstat("test", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
stat("test", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0
geteuid() = 0
getegid() = 0
getuid() = 0
getgid() = 0
access("test", W_OK) = 0
unlink("test") = 0
close(1) = 0
exit_group(0) = ?

我們可以看到起主要作用的就是 unlink(“test”) 這個系統調用。

讓我們來分析一下這些輸出的含義：

·首先第一行 execve 系統調用。該系統調用執行參數“/bin/rm”中的程序(以 #! 開頭的可執行腳本也可以)，后面第一個方括號中表示執行的參數，第二個方括號中表示執行的環境變量。

·接下來的 brk 和 mmap 命令，主要是用來給可執行命令分配內存空間。

·后面的 lstat 系統調用用來確定文件的 mode 信息，包括文件的類型和權限，文件大小等等。

·然后 access 系統調用檢查當前用戶進程對于 test 文件的寫入訪問權限。這里返回值為 0 也就是說進程對于 test 文件有寫入的權限。

·最后調用 unlink 系統調用刪除文件。

這里如果我們建立一個目錄 test1，然后用 rm test1 去刪除這個目錄會有什么結果呢?

我們看到有如下輸出：

rm: cannot remove `test1': Is a directory

這時我們用 strace 命令來追蹤一下，發現輸出主要是如下不同。

unlink("test") = -1 EISDIR (Is a directory)

這里說明了刪除不掉的原因是 unlink 系統調用報錯，unlink 它認為 test 是一個目錄，不予處理。

那么怎么刪除一個目錄呢?應該是用 rmdir 系統調用，這樣就不會出現上述的問題了。#p#

mkdir 命令的實現

mkdir 命令的模擬實現

再讓我們來看看 mkdir 的實現。

完整的代碼如下：

清單 3. mkdir 實現代碼

#include
#include
#include
int main(int argc, char *argv[]){
int rt;
if( (rt = mkdir (argv[1],10705)) == -1 ){
fprintf(stderr,"cannot mkdir");
}
return 0;
}

這段代碼也比較簡單，我這里就不逐行解釋了，主要說以下幾點：

首先 mkdir 函數是定義于 和 頭文件之中的。

而 fprintf 函數是位于 文件之中的。

mkdir 的函數原型如下：

int mkdir(const char *pathname, mode_t mode);

mode 聲明為 mode_t 類型。

那么 mode_t 數據類型是什么數據類型，應該從哪個文件去查看它的定義呢?

mode_t 數據類型究竟是什么類型

讓我們逐步查找一下。

首先從文件 /usr/include/sys/stat.h 中找到 mode_t 類型

/usr/include/sys/stat.h -> typedef __mode_t mode_t;

說明 mode_t 只是對 __mode_t 的一種定義。

然后從 /usr/include/bits/types.h 中找到 __mode_t 類型

/usr/include/bits/types.h -> __STD_TYPE __MODE_T_TYPE __mode_t;

說明 __mode_t 也只是對 __MODE_T_TYPE 的一種定義。

/usr/include/bits/typesizes.h -> #define __MODE_T_TYPE __U32_TYPE

說明 __MODE_T_TYPE 是對 __U32_TYPE 的一種定義。

/usr/include/bits/types.h -> #define __U32_TYPE unsigned int

最后 __U32_TYPE 是一種無符號的整數的定義。

從上述推導可以看出，mode_t 實際上也就是一種無符號整數。

另外如下結構 struct stat 定義中的 st_mode 成員變量也是使用的 mode_t 類型的變量。

從 man 2 stat 中可以找到結構 struct stat 的定義，如下：

struct stat {
dev_t st_dev; /* ID of device containing file */
ino_t st_ino; /* inode number */
mode_t st_mode; /* protection */
nlink_t st_nlink; /* number of hard links */
uid_t st_uid; /* user ID of owner */
gid_t st_gid; /* group ID of owner */
dev_t st_rdev; /* device ID (if special file) */
off_t st_size; /* total size, in bytes */
blksize_t st_blksize; /* blocksize for filesystem I/O */
blkcnt_t st_blocks; /* number of blocks allocated */
time_t st_atime; /* time of last access */
time_t st_mtime; /* time of last modification */
time_t st_ctime; /* time of last status change */
};

該結構也是我們在后面的 tac 命令實現中需要用到的結構體。我們需要用到結構體中的 st_size 成員，該成員反映了被讀取的文件描述符對應的文件的大小。#p#

tac 命令的實現

tac 命令的模擬實現

tac 命令主要用來以倒序的方式顯示一個文本文件的內容，也就是先顯示最后一行的內容，最后顯示第一行的內容。代碼如下：

清單 4. tac 命令實現代碼

#include
#include
#include
#include
#include
#include
#include
#include
#define SIZE 1000001
#define NLINE '\n'
int main(int argc , char *argv[]){
char buf[SIZE];
char *p1,*p2,*p3,*p4;
struct stat *fp;
int fd;
fp=(struct stat *)malloc(sizeof(struct stat));
if(argc != 2){
fprintf(stderr,"input error %s \n");
exit(1);
}
if( (fd=open(argv[1],O_RDONLY)) == -1 ){
fprintf(stderr,"open error %s \n",strerror(errno));
exit(1);
}
if(fstat(fd,fp)== -1){
fprintf(stderr,"fstat error %s \n",strerror(errno));
exit(2);
}
if(fp->st_size > (SIZE-1)){
fprintf(stderr,"buffer size is not big enough \n");
exit(3);
}
if(read(fd,buf,fp->st_size) == -1){
fprintf(stderr,"read error.\n");
exit(4);
}
p1=strchr(buf,NLINE);
p2=strrchr(buf,NLINE);
*p2='\0';
do{
p2=strrchr(buf,NLINE);
p4=p2;
p3=p2+sizeof(char);
printf("%s\n",p3);
*p4='\0';
}while(p2 != p1);
if(p2 == p1){
*p2 = '\0';
printf("%s\n",buf);
}
return 0;
}

讓我們來運行一下該程序：

程序的運行情況如下，假設編譯后的可執行文件名為 emulatetac，有一個文本文件 test.txt。

# gcc emulatetac.c -o emulatetac
# cat test.txt
1
2
3
a
b
# ./emulatetac test.txt
b
a
3
2
1

可以看出文件內容以倒序方式顯示輸出了。

tac 命令實現的說明

下面逐行講解：

·#include 的頭文件，都應該通過 man 2 系統調用命令來查找，這里就不多說了。

·下面定義了一個宏常量 SIZE，該常量主要用來表示能夠讀入最大多少個字節的文件，當文件過大的時候程序就不執行，直接退出。然后定義了宏常量 NLINE 表示換行符'\n'。

·接下來主程序體開始了：首先定義一個字符數組 buf，用來把讀入文件的每個字節都存在該數組里面。

·然后定義了 4 個字符串指針，一個指向結構體 struct stat 的指針 fp，一個文件描述符。

·然后為指向結構體的指針 fp 分配存儲空間。

·接下來判斷輸入參數是否為 2 個，也就是命令本身和文件名。不是 2 個就直接退出。

·然后以只讀方式打開輸入文件名的文件，也就是 test.txt。打開成功的話，把打開的文件賦值到文件描述符 fd 中，錯誤的話退出。

·然后用 fstat 系統調用把文件描述符 fd 中對應文件的元信息，存放到結構體指針 fp 指向的結構中。

·下面判斷當文件的大小超過緩沖區數組 buf 的大小 SIZE-1 時，就退出。

·下面將把文件 test.txt 中的每個字符存放到數組 buf 中。

·下面是程序的核心部分：首先我們找到字符串 buf 中的第一個換行字符存放到 p1 指針里面，然后把最后一個換行字符置為字符串結束符。

·接下來我們從后往前查找字符串 buf 中的換行符，直到遇到第一個換行符 p1。同時打印每個找到的換行符'\n'中的下一個字符開始的字符串，也就剛好是一行文本。

·最后當從后向前找到第一個換行字符時，打印第一行，程序結束。#p#

df 命令的實現

df 命令的模擬實現

通過 strace 命令查看 df 主要使用了如下的系統調用：open、fstat、read、statfs

我這里實際上是模擬實現的 df --block-size=4096 這個命令，也就是說以 4096 字節為塊大小來顯示磁盤使用情況。

這里最為關鍵的是 statfs 這個結構體，該結構體的某些字段被用作 df 命令的輸出字段：

struct statfs {
long f_type; /* type of filesystem (see below) */
long f_bsize; /* optimal transfer block size */
long f_blocks; /* total data blocks in file system */
long f_bfree; /* free blocks in fs */
long f_bavail; /* free blocks avail to non-superuser */
long f_files; /* total file nodes in file system */
long f_ffree; /* free file nodes in fs */
fsid_t f_fsid; /* file system id */
long f_namelen; /* maximum length of filenames */
};
比如：df --block-size=4096 的輸出如下(縱向列出)：
Filesystem
/dev/sda1
4K-blocks
5077005 　　 f_blocks 字段
Used
145105 　　 f_blocks 字段 -f_bfree 字段
Available
4669841 　　 f_bavail 字段
Use%
4% 　　(f_blocks-f_bfree)/ f_blocks*100% 來計算磁盤使用率。
Mounted on
/

模擬實現的代碼如下：

清單 5. 模擬實現代碼

#include
#include
#include
#include
#include
#include
#define SIZE1 100
#define FN "/etc/mtab"
#define SPACE ' '
int displayapartition(char * pt,char * pt1);
int main(void){
char tmpline[SIZE1];
FILE * fp;
char * pt1;
char * pt2;
char * pt3;
if( (fp = fopen(FN,"r")) == NULL ){
fprintf(stderr,"%s \n",strerror(errno));
exit(5);
}
while( fgets(tmpline, SIZE1, fp) != NULL ){
pt1=strchr(tmpline, SPACE);
pt2=pt1+sizeof(char);
*pt1='\0';
pt3=strchr(pt2,SPACE);
*pt3='\0';
if(strstr(tmpline,"/dev") != NULL ){
displayapartition(tmpline,pt2);
}
}
return 0;
}
int displayapartition(char * pt,char * pt1){
struct statfs buf;
statfs(pt1,&buf);
int usage;
usage=ceil((buf.f_blocks-buf.f_bfree)*100/buf.f_blocks);
printf("%s ",pt);
printf("%ld ",buf.f_blocks);
printf("%ld ",buf.f_blocks-buf.f_bfree);
printf("%ld ",buf.f_bavail);
printf("%d%% ",usage);
printf("%s ",pt1);
printf("\n");
return 0;
}

df 命令實現的說明

下面解釋一下這個程序：

·首先，該程序定義了一個函數 displayapartition， 這里先定義它的函數原型。

·然后我們從主程序說起：首先定義了一個 char tmpline[SIZE1] 數組，該數組用來存放從宏定義常量 FN 代表的文件中，打開后存入文件的每行記錄。

·接著定義了一個文件流指針和 3 個字符串指針。

·接下來打開文件 FN 并把結果賦值給文件流變量 fp, 如果打開失敗就退出。

·下面從打開的文件流中讀出 SIZE1 個字符到臨時數組 tmpline。比如讀出一行數據為：/dev/sda1 / ext3 rw 0 0 　將把 /dev/sda1 放入數組 tmpline，把加載點 / 放入指針 pt2，同時判斷字符串 tmpline 是否包含 /dev 字符串，這樣來判斷是否是一個磁盤文件，如果是的話就調用子函數 displayapartition，不是則返回。

·子函數 displayapartition 是做什么的呢?該函數接受 2 個參數，一個是行 /dev/sda1 / ext3 rw 0 0 中的第一列比如：/dev/sda1 也就是實際磁盤作為 pt 指針，一個是行中的第二列比如：/ 也就是掛載點作為 pt1 指針。然后子函數通過 pt1 指針，讀取掛載上的文件系統信息到 buf 數據結構里面。

·根據開頭介紹過的 statfs 結構體，buf.f_blocks 表示打開的文件系統的總數據塊，buf.f_blocks-buf.f_bfree 表示已經使用的數據塊，buf.f_bavail 表示非超級用戶可用的剩余數據塊，磁盤使用率就是前面列出過的計算表達式：(f_blocks- f_bfree)/ f_blocks*100%。通過子函數就可以打印出 df 需要顯示的所有信息到標準輸出了。

小結

本文依次講述了 cp、rm、mkdir、tac、df 命令的主要功能實現代碼，當然每個命令還有很多參數，我這個模擬實現代碼甚至連主要功能的很多細節都沒有實現，比如 df 命令的輸出頭我沒有打印出來，這牽涉到打印頭和輸出格式化等很多細節。所以，從這里我們就可以推斷出，真實的源代碼肯定是考慮得非常全面、嚴謹和健壯的。我這里只是拋磚引玉，希望能給愛好 Linux 的朋友們提供一種理解 Linux 系統的思路。

原文鏈接：http://www.ibm.com/developerworks/cn/linux/l-cn-commands/index.html?ca=drs-

【編輯推薦】

1. 五個不容錯過的Linux命令行技巧
2. Linux新手應該知道的12個基本命令
3. 8則實用的Linux Shell命令