Linux下C编程实战
2019獨角獸企業重金招聘Python工程師標準>>>
Linux下的C編程實戰（一）
――開發平臺搭建
1.引言
Linux操作系統在服務器領域的應用和普及已經有較長的歷史，這源于它的開源特點以及其超越Windows的安全性和穩定性。而近年來，
Linux操作系統在嵌入式系統領域的延伸也可謂是如日中天，許多版本的嵌入式Linux系統被開發出來，如ucLinux、RTLinux、ARM-Linux等等。
在嵌入式操作系統方面，Linux的地位是不容懷疑的，它開源、它包含TCP/IP協議棧、它易集成GUI。
鑒于Linux操作系統在服務器和嵌入式系統領域愈來愈廣泛的應用，社會上越來越需要基于Linux操作系統進行編程的開發人員。
瀏覽許多論壇，經常碰到這樣的提問：“現在是不是很流行unix/linux下的c編程？所以想學習一下！但是不知道該從何學起，如何下手！有什
么好的建議嗎？各位高手！哪些書籍比較合適初學者？在深入淺出的過程中應該看哪些不同層次的書？比如好的網站、論壇請大家賜教！不慎
感激！”
鑒于讀者的需求，在本文中，筆者將對Linux平臺下C編程的幾個方面進行實例講解，并力求回答讀者們關心的問題，以與讀者朋友們進行交流
，共同提高。在本文的連載過程中，有任何問題或建議，您可以給筆者發送email：21cnbao@21cn.com，您也可以進入筆者的博客參與討論：
http://blog.donews.com/21cnbao。
筆者建議在PC內存足夠大的情況下，不要直接安裝Linux操作系統，最好把它安裝在運行VMWare虛擬機軟件的Windows平臺上，如下圖：
在Linux平臺下，可用任意一個文本編輯工具編輯源代碼，但筆者建議使用emacs軟件，它具備語法高亮、版本控制等附帶功能，如下圖
：
2.GCC編譯器
GCC是Linux平臺下最重要的開發工具，它是GNU的C和C++編譯器，其基本用法為：
gcc [options] [filenames]
options為編譯選項，GCC總共提供的編譯選項超過100個，但只有少數幾個會被頻繁使用，我們僅對幾個常用選項進行介紹。
假設我們編譯一輸出“Hello World”的程序：
/* Filename:helloworld.c */
main()
{
printf("Hello World"n");
}
最簡單的編譯方法是不指定任何編譯選項：
gcc helloworld.c
它會為目標程序生成默認的文件名a.out，我們可用-o編譯選項來為將產生的可執行文件指定一個文件名來代替a.out。例如，將上述名為
helloworld.c的C程序編譯為名叫helloworld的可執行文件，需要輸入如下命令：
gcc –o helloworld helloworld.c
-c選項告訴GCC僅把源代碼編譯為目標代碼而跳過匯編和連接的步驟；
-S 編譯選項告訴GCC 在為 C代碼產生了匯編語言文件后停止編譯。GCC 產生的匯編語言文件的缺省擴展名是.s，上述程序運行如下命令：
gcc –S helloworld.c
將生成helloworld.c的匯編代碼，使用的是AT&T匯編。用emacs打開匯編代碼如下圖：
-E選項指示編譯器僅對輸入文件進行預處理。當這個選項被使用時，預處理器的輸出被送到標準輸出（默認為屏幕）而不是儲存在文件里。
-O選項告訴GCC對源代碼進行基本優化從而使得程序執行地更快；而-O2選項告訴GCC產生盡可能小和盡可能快的代碼。使用-O2選項編譯的速度
比使用-O時慢，但產生的代碼執行速度會更快。
-g選項告訴GCC產生能被GNU調試器使用的調試信息以便調試你的程序，可喜的是，在GCC里，我們能聯用-g和-O (產生優化代碼)。
-pg選項告訴GCC在你的程序里加入額外的代碼，執行時，產生gprof用的剖析信息以顯示你的程序的耗時情況。
3.GDB調試器
GCC用于編譯程序，而Linux的另一個GNU工具gdb則用于調試程序。gdb是一個用來調試C和C++程序的強力調試器，我們能通過它進行一
系列調試工作，包括設置斷點、觀查變量、單步等。
其最常用的命令如下：
file：裝入想要調試的可執行文件。
kill：終止正在調試的程序。
list：列表顯示源代碼。
next：執行一行源代碼但不進入函數內部。
step：執行一行源代碼而且進入函數內部。
run：執行當前被調試的程序
quit：終止gdb
watch：監視一個變量的值
break：在代碼里設置斷點，程序執行到這里時掛起
make：不退出gdb而重新產生可執行文件
shell：不離開gdb而執行shell
下面我們來演示怎樣用GDB來調試一個求0+1+2+3+…+99的程序：
/* Filename:sum.c */
main()
{
int i, sum;
sum = 0;
for (i = 0; i < 100; i++)
{
sum + = i;
}
printf("the sum of 1+2+...+ is %d", sum);
}
執行如下命令編譯sum.c（加-g選項產生debug信息）：
gcc –g –o sum sum.c
在命令行上鍵入gdb sum并按回車鍵就可以開始調試sum了，再運行run命令執行sum，屏幕上將看到如下內容：
list命令：
list命令用于列出源代碼，對上述程序兩次運行list，將出現如下畫面（源代碼被標行號）：
根據列出的源程序，如果我們將斷點設置在第5行，只需在gdb 命令行提示符下鍵入如下命令設置斷點：(gdb) break 5，執行情況如下圖：
這個時候我們再run，程序會停止在第5行，如下圖：
設置斷點的另一種語法是 break ，它在進入指定函數（function）時停住。
相反的，clear用于清除所有的已定義的斷點，clear 清除設置在函數上的斷點， clear 則清除設置在指定行上的斷點
。
watch命令：
watch命令用于觀查變量或表達式的值，我們觀查sum變量只需要運行watch sum：
watch 為表達式（變量）expr設置一個觀察點，一量表達式值有變化時，程序會停止執行。
要觀查當前設置的watch，可以使用info watchpoints命令。
next、step命令：
next、step用于單步執行，在執行的過程中，被watch變量的變化情況將實時呈現(分別顯示Old value和New value)，如下圖：
next、step命令的區別在于step遇到函數調用，會跳轉到到該函數定義的開始行去執行，而next則不進入到函數內部，它把函數調用語句當作
一條普通語句執行。
4.Make
make是所有想在Linux系統上編程的用戶必須掌握的工具，對于任何稍具規模的程序，我們都會使用到make，幾乎可以說不使用make的程序不具
備任何實用價值。
在此，我們有必要解釋編譯和連接的區別。編譯器使用源碼文件來產生某種形式的目標文件(object files)，在編譯過程中，外部的符號參考
并沒有被解釋或替換（即外部全局變量和函數并沒有被找到）。因此，在編譯階段所報的錯誤一般都是語法錯誤。而連接器則用于連接目標文
件和程序包，生成一個可執行程序。在連接階段，一個目標文件中對別的文件中的符號的參考被解釋，如果有符號不能找到，會報告連接錯誤
。
編譯和連接的一般步驟是：第一階段把源文件一個一個的編譯成目標文件，第二階段把所有的目標文件加上需要的程序包連接成一個可執行文
件。這樣的過程很痛苦，我們需要使用大量的gcc命令。
而make則使我們從大量源文件的編譯和連接工作中解放出來，綜合為一步完成。GNU Make的主要工作是讀進一個文本文件，稱為makefile。這
個文件記錄了哪些文件（目的文件，目的文件不一定是最后的可執行程序，它可以是任何一種文件）由哪些文件（依靠文件）產生，用什么命
令來產生。Make依靠此makefile中的信息檢查磁盤上的文件，如果目的文件的創建或修改時間比它的一個依靠文件舊的話，make就執行相應的
命令，以便更新目的文件。
假設我們寫下如下的三個文件，add.h用于聲明add函數，add.c提供兩個整數相加的函數體，而main.c中調用add函數：
/* filename:add.h */
extern int add(int i, int j);
/* filename:add.c */
int add(int i, int j)
{
return i + j;
};
/* filename:main.c */
#include "add.h"
main()
{
int a, b;
a = 2;
b = 3;
printf("the sum of a+b is %d", add(a + b));
};
怎樣為上述三個文件產生makefile呢？如下：
-------------------------
test : main.o add.o
gcc main.o add.o -o test
main.o : main.c add.h
gcc -c main.c -o main.o
add.o : add.c add.h
gcc -c add.c -o add.o
-----------------------
(注意分割符為TAB鍵）
上述makefile利用add.c和add.h文件執行gcc -c add.c -o add.o命令產生add.o目標代碼，利用main.c和add.h文件執行gcc -c main.c -o
main.o命令產生main.o目標代碼，最后利用main.o和add.o文件（兩個模塊的目標代碼）執行gcc main.o add.o -o test命令產生可執行文件
test。
我們可在makefile中加入變量，另外。環境變量在make過程中也被解釋成make的變量。這些變量是大小寫敏感的，一般使用大寫字母。Make變
量可以做很多事情，例如：
i) 存儲一個文件名列表；
ii) 存儲可執行文件名；
iii) 存儲編譯器選項。
要定義一個變量，只需要在一行的開始寫下這個變量的名字，后面跟一個=號，再跟變量的值。引用變量的方法是寫一個$符號，后面跟（變量
名）。我們把前面的 makefile 利用變量重寫一遍（并假設使用-Wall -O –g編譯選項）：
OBJS = main.o add.o
CC = gcc
CFLAGS = -Wall -O -g
test : $(OBJS)
$(CC) $(OBJS) -o test
main.o : main.c add.h
$(CC) $(CFLAGS) -c main.c -o main.o
add.o : add.c add.h
$(CC) $(CFLAGS) -c add.c -o add.o
makefile 中還可定義清除（clean）目標，可用來清除編譯過程中產生的中間文件，例如在上述makefile文件中添加下列代碼：
clean:
rm -f *.o
運行make clean時，將執行rm -f *.o命令，刪除所有編譯過程中產生的中間文件。
不管怎么說，自己動手編寫makefile仍然是很復雜和煩瑣的，而且很容易出錯。因此，GNU也為我們提供了Automake和Autoconf來輔助快速自動
產生makefile，讀者可以參閱相關資料。
5.小結
本章主要闡述了Linux程序的編寫、編譯、調試方法及make，實際上就是引導讀者學習怎樣在Linux下編程，為后續章節做好準備。
Linux下的C編程實戰（二）
――文件系統編程
1.Linux文件系統
Linux支持多種文件系統，如ext、ext2、minix、iso9660、msdos、fat、vfat、nfs等。在這些具體文件系統的上層，Linux提供了虛擬
文件系統（VFS）來統一它們的行為，虛擬文件系統為不同的文件系統與內核的通信提供了一致的接口。下圖給出了Linux中文件系統的關系：
在Linux平臺下對文件編程可以使用兩類函數：（1）Linux操作系統文件API；（2）C語言I/O庫函數。 前者依賴于Linux系統調用，
后者實際上與操作系統是獨立的，因為在任何操作系統下，使用C語言I/O庫函數操作文件的方法都是相同的。本章將對這兩種方法進行實例講
解。
2.Linux文件API
Linux的文件操作API涉及到創建、打開、讀寫和關閉文件。
創建
int creat(const char *filename, mode_t mode);
參數mode指定新建文件的存取權限，它同umask一起決定文件的最終權限（mode&umask），其中umask代表了文件在創建時需要去掉的一些存取
權限。umask可通過系統調用umask()來改變：
int umask(int newmask);
該調用將umask設置為newmask，然后返回舊的umask，它只影響讀、寫和執行權限。
打開
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
open函數有兩個形式，其中pathname是我們要打開的文件名(包含路徑名稱，缺省是認為在當前路徑下面)，flags可以去下面的一個值或者是幾
個值的組合：
標志
含義
O_RDONLY
以只讀的方式打開文件
O_WRONLY
以只寫的方式打開文件
O_RDWR
以讀寫的方式打開文件
O_APPEND
以追加的方式打開文件
O_CREAT
創建一個文件
O_EXEC
如果使用了O_CREAT而且文件已經存在，就會發生一個錯誤
O_NOBLOCK
以非阻塞的方式打開一個文件
O_TRUNC
如果文件已經存在，則刪除文件的內容
O_RDONLY、O_WRONLY、O_RDWR三個標志只能使用任意的一個。
如果使用了O_CREATE標志，則使用的函數是int open(const char *pathname,int flags,mode_t mode); 這個時候我們還要指定mode標志，用
來表示文件的訪問權限。mode可以是以下情況的組合：
標志
含義
S_IRUSR
用戶可以讀
S_IWUSR
用戶可以寫
S_IXUSR
用戶可以執行
S_IRWXU
用戶可以讀、寫、執行
S_IRGRP
組可以讀
S_IWGRP
組可以寫
S_IXGRP
組可以執行
S_IRWXG
組可以讀寫執行
S_IROTH
其他人可以讀
S_IWOTH
其他人可以寫
S_IXOTH
其他人可以執行
S_IRWXO
其他人可以讀、寫、執行
S_ISUID
設置用戶執行ID
S_ISGID
設置組的執行ID
除了可以通過上述宏進行“或”邏輯產生標志以外，我們也可以自己用數字來表示，Linux總共用5個數字來表示文件的各種權限：第一位表示
設置用戶ID；第二位表示設置組ID；第三位表示用戶自己的權限位；第四位表示組的權限；最后一位表示其他人的權限。每個數字可以取1(執
行權限)、2(寫權限)、4(讀權限)、0(無)或者是這些值的和。例如，要創建一個用戶可讀、可寫、可執行，但是組沒有權限，其他人可以讀、
可以執行的文件，并設置用戶ID位。那么，我們應該使用的模式是1(設置用戶ID)、0(不設置組ID)、7(1+2+4，讀、寫、執行)、0(沒有權限)、
5(1+4，讀、執行)即10705：
open("test", O_CREAT, 10705);
上述語句等價于：
open("test", O_CREAT, S_IRWXU | S_IROTH | S_IXOTH | S_ISUID );
如果文件打開成功，open函數會返回一個文件描述符，以后對該文件的所有操作就可以通過對這個文件描述符進行操作來實現。
讀寫
在文件打開以后，我們才可對文件進行讀寫了，Linux中提供文件讀寫的系統調用是read、write函數：
int read(int fd, const void *buf, size_t length);
int write(int fd, const void *buf, size_t length);
其中參數buf為指向緩沖區的指針，length為緩沖區的大小（以字節為單位）。函數read()實現從文件描述符fd所指定的文件中讀取length個字
節到buf所指向的緩沖區中，返回值為實際讀取的字節數。函數write實現將把length個字節從buf指向的緩沖區中寫到文件描述符fd所指向的文
件中，返回值為實際寫入的字節數。
以O_CREAT為標志的open實際上實現了文件創建的功能，因此，下面的函數等同creat()函數：
int open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
定位
對于隨機文件，我們可以隨機的指定位置讀寫，使用如下函數進行定位：
int lseek(int fd, offset_t offset, int whence);
lseek()將文件讀寫指針相對whence移動offset個字節。操作成功時，返回文件指針相對于文件頭的位置。參數whence可使用下述值：
SEEK_SET：相對文件開頭
SEEK_CUR：相對文件讀寫指針的當前位置
SEEK_END：相對文件末尾
offset可取負值，例如下述調用可將文件指針相對當前位置向前移動5個字節：
lseek(fd, -5, SEEK_CUR);
由于lseek函數的返回值為文件指針相對于文件頭的位置，因此下列調用的返回值就是文件的長度：
lseek(fd, 0, SEEK_END);
關閉
當我們操作完成以后，我們要關閉文件了，只要調用close就可以了，其中fd是我們要關閉的文件描述符：
int close(int fd);
例程：編寫一個程序，在當前目錄下創建用戶可讀寫文件“hello.txt”，在其中寫入“Hello, software weekly”，關閉該文件。再次打開該
文件，讀取其中的內容并輸出在屏幕上。
#include
#include
#include
#include
#define LENGTH 100
main()
{
int fd, len;
char str[LENGTH];
fd = open("hello.txt", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); /* 創建并打開文件 */
if (fd)
{
write(fd, "Hello, Software Weekly", strlen("Hello, software weekly")); /* 寫入Hello, software weekly字符串 */
close(fd);
}
fd = open("hello.txt", O_RDWR);
len = read(fd, str, LENGTH); /* 讀取文件內容 */
str[len] = '"0';
printf("%s"n", str);
close(fd);
};
編譯并運行，執行
3.C語言庫函數
C庫函數的文件操作實際上是獨立于具體的操作系統平臺的，不管是在DOS、Windows、Linux還是在VxWorks中都是這些函數：
創建和打開
FILE *fopen(const char *path, const char *mode);
fopen()實現打開指定文件filename，其中的mode為打開模式，C語言中支持的打開模式如下表：
標志
含義
r, rb
以只讀方式打開
w, wb
以只寫方式打開。如果文件不存在，則創建該文件，否則文件被截斷
a, ab
以追加方式打開。如果文件不存在，則創建該文件
r+, r+b, rb+
以讀寫方式打開
w+, w+b, wh+
以讀寫方式打開。如果文件不存在時，創建新文件，否則文件被截斷
a+, a+b, ab+
以讀和追加方式打開。如果文件不存在，創建新文件
其中b用于區分二進制文件和文本文件，這一點在DOS、Windows系統中是有區分的，但Linux不區分二進制文件和文本文件。
讀寫
C庫函數支持以字符、字符串等為單位，支持按照某中格式進行文件的讀寫，這一組函數為：
int fgetc(FILE *stream);
int fputc(int c, FILE *stream);
char *fgets(char *s, int n, FILE *stream);
int fputs(const char *s, FILE *stream);
int fprintf(FILE *stream, const char *format, ...);
int fscanf (FILE *stream, const char *format, ...);
size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
size_t fwrite (const void *ptr, size_t size, size_t n, FILE *stream);
fread()實現從流stream中讀取加n個字段，每個字段為size字節，并將讀取的字段放入ptr所指的字符數組中，返回實際已讀取的字段數。在讀
取的字段數小于num時，可能是在函數調用時出現錯誤，也可能是讀到文件的結尾。所以要通過調用feof()和ferror()來判斷。
write()實現從緩沖區ptr所指的數組中把n個字段寫到流stream中，每個字段長為size個字節，返回實際寫入的字段數。
另外，C庫函數還提供了讀寫過程中的定位能力，這些函數包括
int fgetpos(FILE *stream, fpos_t *pos);
int fsetpos(FILE *stream, const fpos_t *pos);
int fseek(FILE *stream, long offset, int whence);
等。
關閉
利用C庫函數關閉文件依然是很簡單的操作：
int fclose (FILE *stream);
例程：將第2節中的例程用C庫函數來實現。
#include
#define LENGTH 100
main()
{
FILE *fd;
char str[LENGTH];
fd = fopen("hello.txt", "w+"); /* 創建并打開文件 */
if (fd)
{
fputs("Hello, Software Weekly", fd); /* 寫入Hello, software weekly字符串 */
fclose(fd);
}
fd = fopen("hello.txt", "r");
fgets(str, LENGTH, fd); /* 讀取文件內容 */
printf("%s"n", str);
fclose(fd);
}
4.小結
Linux提供的虛擬文件系統為多種文件系統提供了統一的接口，Linux的文件編程有兩種途徑：基于Linux系統調用；基于C庫函數。這兩
種編程所涉及到文件操作有新建、打開、讀寫和關閉，對隨機文件還可以定位。本章對這兩種編程方法都給出了具體的實例。
Linux下的C編程實戰（三）
――進程控制與進程通信編程
1.Linux進程
Linux進程在內存中包含三部分數據：代碼段、堆棧段和數據段。代碼段存放了程序的代碼。代碼段可以為機器中運行同一程序的數個
進程共享。堆棧段存放的是子程序（函數）的返回地址、子程序的參數及程序的局部變量。而數據段則存放程序的全局變量、常數以及動態數
據分配的數據空間（比如用malloc函數申請的內存）。與代碼段不同，如果系統中同時運行多個相同的程序，它們不能使用同一堆棧段和數據
段。
Linux進程主要有如下幾種狀態：用戶狀態（進程在用戶狀態下運行的狀態）、內核狀態（進程在內核狀態下運行的狀態）、內存中就緒（進程
沒有執行，但處于就緒狀態，只要內核調度它，就可以執行）、內存中睡眠（進程正在睡眠并且處于內存中，沒有被交換到SWAP設備）、就緒
且換出（進程處于就緒狀態，但是必須把它換入內存，內核才能再次調度它進行運行）、睡眠且換出（進程正在睡眠，且被換出內存）、被搶
先（進程從內核狀態返回用戶狀態時，內核搶先于它，做了上下文切換，調度了另一個進程，原先這個進程就處于被搶先狀態）、創建狀態（
進程剛被創建，該進程存在，但既不是就緒狀態，也不是睡眠狀態，這個狀態是除了進程0以外的所有進程的最初狀態）、僵死狀態（進程調用
exit結束，進程不再存在，但在進程表項中仍有記錄，該記錄可由父進程收集）。
下面我們來以一個進程從創建到消亡的過程講解Linux進程狀態轉換的“生死因果”。
（1）進程被父進程通過系統調用fork創建而處于創建態；
（2）fork調用為子進程配置好內核數據結構和子進程私有數據結構后，子進程進入就緒態（或者在內存中就緒，或者因為內存不夠而在SWAP設
備中就緒）；
（3）若進程在內存中就緒，進程可以被內核調度程序調度到CPU運行；
（4）內核調度該進程進入內核狀態，再由內核狀態返回用戶狀態執行。該進程在用戶狀態運行一定時間后，又會被調度程序所調度而進入內核
狀態，由此轉入就緒態。有時進程在用戶狀態運行時，也會因為需要內核服務，使用系統調用而進入內核狀態，服務完畢，會由內核狀態轉回
用戶狀態。要注意的是，進程在從內核狀態向用戶狀態返回時可能被搶占，這是由于有優先級更高的進程急需使用CPU，不能等到下一次調度時
機，從而造成搶占；
（5）進程執行exit調用，進入僵死狀態，最終結束。
2.進程控制
進程控制中主要涉及到進程的創建、睡眠和退出等，在Linux中主要提供了fork、exec、clone的進程創建方法，sleep的進程睡眠和exit的進程
退出調用，另外Linux還提供了父進程等待子進程結束的系統調用wait。
fork
對于沒有接觸過Unix/Linux操作系統的人來說，fork是最難理解的概念之一，它執行一次卻返回兩個值，完全“不可思議”。先看下面的程序
：
int main()
{
int i;
if (fork() == 0)
{
for (i = 1; i < 3; i++)
printf("This is child process"n");
}
else
{
for (i = 1; i < 3; i++)
printf("This is parent process"n");
}
}
執行結果為：
This is child process
This is child process
This is parent process
This is parent process
fork在英文中是“分叉”的意思，這個名字取得很形象。一個進程在運行中，如果使用了fork，就產生了另一個進程，于是進程就“分叉”了
。當前進程為父進程，通過fork()會產生一個子進程。對于父進程，fork函數返回子程序的進程號而對于子程序，fork函數則返回零，這就是
一個函數返回兩次的本質。可以說，fork函數是Unix系統最杰出的成就之一，它是七十年代Unix早期的開發者經過理論和實踐上的長期艱苦探
索后取得的成果。
如果我們把上述程序中的循環放的大一點：
int main()
{
int i;
if (fork() == 0)
{
for (i = 1; i < 10000; i++)
printf("This is child process"n");
}
else
{
for (i = 1; i < 10000; i++)
printf("This is parent process"n");
}
};
則可以明顯地看到父進程和子進程的并發執行，交替地輸出“This is child process”和“This is parent process”。
此時此刻，我們還沒有完全理解fork()函數，再來看下面的一段程序，看看究竟會產生多少個進程，程序的輸出是什么？
int main()
{
int i;
for (i = 0; i < 2; i++)
{
if (fork() == 0)
{
printf("This is child process"n");
}
else
{
printf("This is parent process"n");
}
}
};
exec
在Linux中可使用exec函數族，包含多個函數（execl、execlp、execle、execv、execve和execvp），被用于啟動一個指定路徑和文件名的進程
。
exec函數族的特點體現在：某進程一旦調用了exec類函數，正在執行的程序就被干掉了，系統把代碼段替換成新的程序（由exec類函數執行）
的代碼，并且原有的數據段和堆棧段也被廢棄，新的數據段與堆棧段被分配，但是進程號卻被保留。也就是說，exec執行的結果為：系統認為
正在執行的還是原先的進程，但是進程對應的程序被替換了。
fork函數可以創建一個子進程而當前進程不死，如果我們在fork的子進程中調用exec函數族就可以實現既讓父進程的代碼執行又啟動一個新的
指定進程，這實在是很妙的。fork和exec的搭配巧妙地解決了程序啟動另一程序的執行但自己仍繼續運行的問題，請看下面的例子：
char command[MAX_CMD_LEN];
void main()
{
int rtn; /* 子進程的返回數值 */
while (1)
{
/* 從終端讀取要執行的命令 */
printf(">");
fgets(command, MAX_CMD_LEN, stdin);
command[strlen(command) - 1] = 0;
if (fork() == 0)
{
/* 子進程執行此命令 */
execlp(command, command);
/* 如果exec函數返回，表明沒有正常執行命令，打印錯誤信息*/
perror(command);
exit(errorno);
}
else
{
/* 父進程，等待子進程結束，并打印子進程的返回值 */
wait(&rtn);
printf(" child process return %d"n", rtn);
}
}
};
這個函數基本上實現了一個shell的功能，它讀取用戶輸入的進程名和參數，并啟動對應的進程。
clone
clone是Linux2.0以后才具備的新功能，它較fork更強（可認為fork是clone要實現的一部分），可以使得創建的子進程共享父進程的資源，并
且要使用此函數必須在編譯內核時設置clone_actually_works_ok選項。
clone函數的原型為：
int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);
此函數返回創建進程的PID，函數中的flags標志用于設置創建子進程時的相關選項，具體含義如下表：
標志
含義
CLONE_PARENT
創建的子進程的父進程是調用者的父進程，新進程與創建它的進程成了“兄弟”而不是“父子”
CLONE_FS
子進程與父進程共享相同的文件系統，包括root、當前目錄、umask
CLONE_FILES
子進程與父進程共享相同的文件描述符（file descriptor）表
CLONE_NEWNS
在新的namespace啟動子進程，namespace描述了進程的文件hierarchy
CLONE_SIGHAND
子進程與父進程共享相同的信號處理（signal handler）表
CLONE_PTRACE
若父進程被trace，子進程也被trace
CLONE_VFORK
父進程被掛起，直至子進程釋放虛擬內存資源
CLONE_VM
子進程與父進程運行于相同的內存空間
CLONE_PID
子進程在創建時PID與父進程一致
CLONE_THREAD
Linux 2.4中增加以支持POSIX線程標準，子進程與父進程共享相同的線程群
來看下面的例子：
int variable, fd;
int do_something() {
variable = 42;
close(fd);
_exit(0);
}
int main(int argc, char *argv[]) {
void **child_stack;
char tempch;
variable = 9;
fd = open("test.file", O_RDONLY);
child_stack = (void **) malloc(16384);
printf("The variable was %d"n", variable);
clone(do_something, child_stack, CLONE_VM|CLONE_FILES, NULL);
sleep(1); /* 延時以便子進程完成關閉文件操作、修改變量 */
printf("The variable is now %d"n", variable);
if (read(fd, &tempch, 1) < 1) {
perror("File Read Error");
exit(1);
}
printf("We could read from the file"n");
return 0;
}
運行輸出：
The variable is now 42
File Read Error
程序的輸出結果告訴我們，子進程將文件關閉并將變量修改（調用clone時用到的CLONE_VM、CLONE_FILES標志將使得變量和文件描述符表被共
享），父進程隨即就感覺到了，這就是clone的特點。
sleep
函數調用sleep可以用來使進程掛起指定的秒數，該函數的原型為：
unsigned int sleep(unsigned int seconds);
該函數調用使得進程掛起一個指定的時間，如果指定掛起的時間到了，該調用返回0；如果該函數調用被信號所打斷，則返回剩余掛起的時間數
（指定的時間減去已經掛起的時間）。
exit
系統調用exit的功能是終止本進程，其函數原型為：
void _exit(int status);
_exit會立即終止發出調用的進程，所有屬于該進程的文件描述符都關閉。參數status作為退出的狀態值返回父進程，在父進程中通過系統調用
wait可獲得此值。
wait
wait系統調用包括：
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
wait的作用為發出調用的進程只要有子進程，就睡眠到它們中的一個終止為止； waitpid等待由參數pid指定的子進程退出。
3.進程間通信
Linux的進程間通信（IPC，InterProcess Communication）通信方法有管道、消息隊列、共享內存、信號量、套接口等。
管道分為有名管道和無名管道，無名管道只能用于親屬進程之間的通信，而有名管道則可用于無親屬關系的進程之間。
#define INPUT 0
#define OUTPUT 1
void main()
{
int file_descriptors[2];
/*定義子進程號 */
pid_t pid;
char buf[BUFFER_LEN];
int returned_count;
/*創建無名管道*/
pipe(file_descriptors);
/*創建子進程*/
if ((pid = fork()) == - 1)
{
printf("Error in fork"n");
exit(1);
}
/*執行子進程*/
if (pid == 0)
{
printf("in the spawned (child) process..."n");
/*子進程向父進程寫數據，關閉管道的讀端*/
close(file_descriptors[INPUT]);
write(file_descriptors[OUTPUT], "test data", strlen("test data"));
exit(0);
}
else
{
/*執行父進程*/
printf("in the spawning (parent) process..."n");
/*父進程從管道讀取子進程寫的數據，關閉管道的寫端*/
close(file_descriptors[OUTPUT]);
returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
printf("%d bytes of data received from spawned process: %s"n",
returned_count, buf);
}
}
上述程序中，無名管道以
int pipe(int filedis[2]);
方式定義，參數filedis返回兩個文件描述符filedes[0]為讀而打開，filedes[1]為寫而打開，filedes[1]的輸出是filedes[0]的輸入；
在Linux系統下，有名管道可由兩種方式創建（假設創建一個名為“fifoexample”的有名管道）：
（1）mkfifo("fifoexample","rw");
（2）mknod fifoexample p
mkfifo是一個函數，mknod是一個系統調用，即我們可以在shell下輸出上述命令。
有名管道創建后，我們可以像讀寫文件一樣讀寫之：
/* 進程一：讀有名管道*/
void main()
{
FILE *in_file;
int count = 1;
char buf[BUFFER_LEN];
in_file = fopen("pipeexample", "r");
if (in_file == NULL)
{
printf("Error in fdopen."n");
exit(1);
}
while ((count = fread(buf, 1, BUFFER_LEN, in_file)) > 0)
printf("received from pipe: %s"n", buf);
fclose(in_file);
}
/* 進程二：寫有名管道*/
void main()
{
FILE *out_file;
int count = 1;
char buf[BUFFER_LEN];
out_file = fopen("pipeexample", "w");
if (out_file == NULL)
{
printf("Error opening pipe.");
exit(1);
}
sprintf(buf, "this is test data for the named pipe example"n");
fwrite(buf, 1, BUFFER_LEN, out_file);
fclose(out_file);
}
消息隊列用于運行于同一臺機器上的進程間通信，與管道相似；
共享內存通常由一個進程創建，其余進程對這塊內存區進行讀寫。得到共享內存有兩種方式：映射/dev/mem設備和內存映像文件。前一種方式
不給系統帶來額外的開銷，但在現實中并不常用，因為它控制存取的是實際的物理內存；常用的方式是通過shmXXX函數族來實現共享內存：
int shmget(key_t key, int size, int flag); /* 獲得一個共享存儲標識符 */
該函數使得系統分配size大小的內存用作共享內存；
void *shmat(int shmid, void *addr, int flag); /* 將共享內存連接到自身地址空間中*/
shmid為shmget函數返回的共享存儲標識符，addr和flag參數決定了以什么方式來確定連接的地址，函數的返回值即是該進程數據段所連接的實
際地址。此后，進程可以對此地址進行讀寫操作訪問共享內存。
本質上，信號量是一個計數器，它用來記錄對某個資源（如共享內存）的存取狀況。一般說來，為了獲得共享資源，進程需要執行下列操作：
（1）測試控制該資源的信號量；
（2）若此信號量的值為正，則允許進行使用該資源，進程將進號量減1；
（3）若此信號量為0，則該資源目前不可用，進程進入睡眠狀態，直至信號量值大于0，進程被喚醒，轉入步驟（1）；
（4）當進程不再使用一個信號量控制的資源時，信號量值加1，如果此時有進程正在睡眠等待此信號量，則喚醒此進程。
下面是一個使用信號量的例子，該程序創建一個特定的IPC結構的關鍵字和一個信號量，建立此信號量的索引，修改索引指向的信號量的值，最
后清除信號量：
#include
#include
#include
#include
void main()
{
key_t unique_key; /* 定義一個IPC關鍵字*/
int id;
struct sembuf lock_it;
union semun options;
int i;
unique_key = ftok(".", 'a'); /* 生成關鍵字，字符'a'是一個隨機種子*/
/* 創建一個新的信號量集合*/
id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);
printf("semaphore id=%d"n", id);
options.val = 1; /*設置變量值*/
semctl(id, 0, SETVAL, options); /*設置索引0的信號量*/
/*打印出信號量的值*/
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d"n", i);
/*下面重新設置信號量*/
lock_it.sem_num = 0; /*設置哪個信號量*/
lock_it.sem_op = - 1; /*定義操作*/
lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/
if (semop(id, &lock_it, 1) == - 1)
{
printf("can not lock semaphore."n");
exit(1);
}
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d"n", i);
/*清除信號量*/
semctl(id, 0, IPC_RMID, 0);
}
套接字通信并不為Linux所專有，在所有提供了TCP/IP協議棧的操作系統中幾乎都提供了socket，而所有這樣操作系統，對套接字的編程方法幾
乎是完全一樣的。
4.小節
本章講述了Linux進程的概念，并以多個實例講解了進程控制及進程間通信方法，理解這一章的內容可以說是理解Linux這個操作系統的關鍵。
Linux下的C編程實戰（四）
――“線程”控制與“線程”通信編程
1.Linux“線程”
筆者曾經在《基于嵌入式操作系統VxWorks的多任務并發程序設計》（《軟件報》2006年第5~12期）中詳細敘述了進程和線程的區別，
并曾經說明Linux是一種“多進程單線程”的操作系統。Linux本身只有進程的概念，而其所謂的“線程”本質上在內核里仍然是進程。大家知
道，進程是資源分配的單位，同一進程中的多個線程共享該進程的資源（如作為共享內存的全局變量）。Linux中所謂的“線程”只是在被創建
的時候“克隆”(clone)了父進程的資源，因此，clone出來的進程表現為“線程”，這一點一定要弄清楚。因此，Linux“線程”這個概念只有
在打冒號的情況下才是最準確的，可惜的是幾乎沒有書籍留心去強調這一點。
Linux內核只提供了輕量進程的支持，未實現線程模型，但Linux盡最大努力優化了進程的調度開銷，這在一定程度上彌補無線程的缺陷
。Linux用一個核心進程（輕量進程）對應一個線程，將線程調度等同于進程調度，交給核心完成。
目前Linux中最流行的線程機制為LinuxThreads，所采用的就是線程－進程“一對一”模型，調度交給核心，而在用戶級實現一個包括信號處理
在內的線程管理機制。LinuxThreads由Xavier Leroy (Xavier.Leroy@inria.fr)負責開發完成，并已綁定在GLIBC中發行，它實現了一種
BiCapitalized面向Linux的Posix 1003.1c “pthread”標準接口。Linuxthread可以支持Intel、Alpha、MIPS等平臺上的多處理器系統。
按照POSIX 1003.1c 標準編寫的程序與Linuxthread 庫相鏈接即可支持Linux平臺上的多線程，在程序中需包含頭文件pthread. h，在編譯鏈接
時使用命令：
gcc -D -REENTRANT -lpthread xxx. c
其中-REENTRANT宏使得相關庫函數(如stdio.h、errno.h中函數) 是可重入的、線程安全的(thread-safe)，-lpthread則意味著鏈接庫目錄下的
libpthread.a或libpthread.so文件。使用Linuxthread庫需要2.0以上版本的Linux內核及相應版本的C庫(libc 5.2.18、libc 5.4.12、libc 6)
。
2.“線程”控制
線程創建
進程被創建時，系統會為其創建一個主線程，而要在進程中創建新的線程，則可以調用pthread_create：
pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *
(start_routine)(void*), void *arg);
start_routine為新線程的入口函數，arg為傳遞給start_routine的參數。
每個線程都有自己的線程ID，以便在進程內區分。線程ID在pthread_create調用時回返給創建線程的調用者；一個線程也可以在創建后使用
pthread_self()調用獲取自己的線程ID：
pthread_self (void) ;
線程退出
線程的退出方式有三：
（1）執行完成后隱式退出；
（2）由線程本身顯示調用pthread_exit 函數退出；
pthread_exit (void * retval) ;
（3）被其他線程用pthread_cance函數終止：
pthread_cance (pthread_t thread) ;
在某線程中調用此函數，可以終止由參數thread 指定的線程。
如果一個線程要等待另一個線程的終止，可以使用pthread_join函數，該函數的作用是調用pthread_join的線程將被掛起直到線程ID為參數
thread的線程終止：
pthread_join (pthread_t thread, void** threadreturn);
3.線程通信
線程互斥
互斥意味著“排它”，即兩個線程不能同時進入被互斥保護的代碼。Linux下可以通過pthread_mutex_t 定義互斥體機制完成多線程的互斥操作
，該機制的作用是對某個需要互斥的部分，在進入時先得到互斥體，如果沒有得到互斥體，表明互斥部分被其它線程擁有，此時欲獲取互斥體
的線程阻塞，直到擁有該互斥體的線程完成互斥部分的操作為止。
下面的代碼實現了對共享全局變量x 用互斥體mutex 進行保護的目的：
int x; // 進程中的全局變量
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL); //按缺省的屬性初始化互斥體變量mutex
pthread_mutex_lock(&mutex); // 給互斥體變量加鎖
… //對變量x 的操作
phtread_mutex_unlock(&mutex); // 給互斥體變量解除鎖
線程同步
同步就是線程等待某個事件的發生。只有當等待的事件發生線程才繼續執行，否則線程掛起并放棄處理器。當多個線程協作時，相互作用的任
務必須在一定的條件下同步。
Linux下的C語言編程有多種線程同步機制，最典型的是條件變量(condition variable)。pthread_cond_init用來創建一個條件變量，其函數原
型為：
pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
pthread_cond_wait和pthread_cond_timedwait用來等待條件變量被設置，值得注意的是這兩個等待調用需要一個已經上鎖的互斥體mutex，這
是為了防止在真正進入等待狀態之前別的線程有可能設置該條件變量而產生競爭。pthread_cond_wait的函數原型為：
pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
pthread_cond_broadcast用于設置條件變量，即使得事件發生，這樣等待該事件的線程將不再阻塞：
pthread_cond_broadcast (pthread_cond_t *cond) ;
pthread_cond_signal則用于解除某一個等待線程的阻塞狀態：
pthread_cond_signal (pthread_cond_t *cond) ;
pthread_cond_destroy 則用于釋放一個條件變量的資源。
在頭文件semaphore.h 中定義的信號量則完成了互斥體和條件變量的封裝，按照多線程程序設計中訪問控制機制，控制對資源的同步訪問，提
供程序設計人員更方便的調用接口。
sem_init(sem_t *sem, int pshared, unsigned int val);
這個函數初始化一個信號量sem 的值為val，參數pshared 是共享屬性控制，表明是否在進程間共享。
sem_wait(sem_t *sem);
調用該函數時，若sem為無狀態，調用線程阻塞，等待信號量sem值增加(post )成為有信號狀態；若sem為有狀態，調用線程順序執行，但信號
量的值減一。
sem_post(sem_t *sem);
調用該函數，信號量sem的值增加，可以從無信號狀態變為有信號狀態。
4.實例
下面我們還是以著名的生產者/消費者問題為例來闡述Linux線程的控制和通信。一組生產者線程與一組消費者線程通過緩沖區發生聯系。生產
者線程將生產的產品送入緩沖區，消費者線程則從中取出產品。緩沖區有N 個，是一個環形的緩沖池。
#include
#include
#define BUFFER_SIZE 16 // 緩沖區數量
struct prodcons
{
// 緩沖區相關數據結構
int buffer[BUFFER_SIZE]; /* 實際數據存放的數組*/
pthread_mutex_t lock; /* 互斥體lock 用于對緩沖區的互斥操作 */
int readpos, writepos; /* 讀寫指針*/
pthread_cond_t notempty; /* 緩沖區非空的條件變量 */
pthread_cond_t notfull; /* 緩沖區未滿的條件變量 */
};
/* 初始化緩沖區結構 */
void init(struct prodcons *b)
{
pthread_mutex_init(&b->lock, NULL);
pthread_cond_init(&b->notempty, NULL);
pthread_cond_init(&b->notfull, NULL);
b->readpos = 0;
b->writepos = 0;
}
/* 將產品放入緩沖區,這里是存入一個整數*/
void put(struct prodcons *b, int data)
{
pthread_mutex_lock(&b->lock);
/* 等待緩沖區未滿*/
if ((b->writepos + 1) % BUFFER_SIZE == b->readpos)
{
pthread_cond_wait(&b->notfull, &b->lock);
}
/* 寫數據,并移動指針 */
b->buffer[b->writepos] = data;
b->writepos++;
if (b->writepos > = BUFFER_SIZE)
b->writepos = 0;
/* 設置緩沖區非空的條件變量*/
pthread_cond_signal(&b->notempty);
pthread_mutex_unlock(&b->lock);
}
/* 從緩沖區中取出整數*/
int get(struct prodcons *b)
{
int data;
pthread_mutex_lock(&b->lock);
/* 等待緩沖區非空*/
if (b->writepos == b->readpos)
{
pthread_cond_wait(&b->notempty, &b->lock);
}
/* 讀數據,移動讀指針*/
data = b->buffer[b->readpos];
b->readpos++;
if (b->readpos > = BUFFER_SIZE)
b->readpos = 0;
/* 設置緩沖區未滿的條件變量*/
pthread_cond_signal(&b->notfull);
pthread_mutex_unlock(&b->lock);
return data;
}
/* 測試:生產者線程將1 到10000 的整數送入緩沖區,消費者線
程從緩沖區中獲取整數,兩者都打印信息*/
#define OVER ( - 1)
struct prodcons buffer;
void *producer(void *data)
{
int n;
for (n = 0; n < 10000; n++)
{
printf("%d --->"n", n);
put(&buffer, n);
} put(&buffer, OVER);
return NULL;
}
void *consumer(void *data)
{
int d;
while (1)
{
d = get(&buffer);
if (d == OVER)
break;
printf("--->%d "n", d);
}
return NULL;
}
int main(void)
{
pthread_t th_a, th_b;
void *retval;
init(&buffer);
/* 創建生產者和消費者線程*/
pthread_create(&th_a, NULL, producer, 0);
pthread_create(&th_b, NULL, consumer, 0);
/* 等待兩個線程結束*/
pthread_join(th_a, &retval);
pthread_join(th_b, &retval);
return 0;
}
5.WIN32、VxWorks、Linux線程類比
目前為止，筆者已經創作了《基于嵌入式操作系統VxWorks的多任務并發程序設計》（《軟件報》2006年5~12期連載）、《深入淺出Win32多線
程程序設計》（天極網技術專題）系列，我們來找出這兩個系列文章與本文的共通點。
看待技術問題要瞄準其本質，不管是Linux、VxWorks還是WIN32，其涉及到多線程的部分都是那些內容，無非就是線程控制和線程通信，它們的
許多函數只是名稱不同，其實質含義是等價的，下面我們來列個三大操作系統共同點詳細表單：
事項
WIN32
VxWorks
Linux
線程創建
CreateThread
taskSpawn
pthread_create
線程終止
執行完成后退出；線程自身調用ExitThread 函數即終止自己；被其他線程調用函數TerminateThread函數
執行完成后退出；由線程本身調用exit退出；被其他線程調用函數taskDelete終止
執行完成后退出；由線程本身調用pthread_exit 退出；被其他線程調用函數pthread_cance終止
獲取線程ID
GetCurrentThreadId
taskIdSelf
pthread_self
創建互斥
CreateMutex
semMCreate
pthread_mutex_init
獲取互斥
WaitForSingleObject、
WaitForMultipleObjects
semTake
pthread_mutex_lock
釋放互斥
ReleaseMutex
semGive
phtread_mutex_unlock
創建信號量
CreateSemaphore
semBCreate、semCCreate
sem_init
等待信號量
WaitForSingleObject
semTake
sem_wait
釋放信號量
ReleaseSemaphore
semGive
sem_post
6.小結
本章講述了Linux下多線程的控制及線程間通信編程方法，給出了一個生產者/消費者的實例，并將Linux的多線程與WIN32、VxWorks多
線程進行了類比，總結了一般規律。鑒于多線程編程已成為開發并發應用程序的主流方法，學好本章的意義也便不言自明。
Linux下的C編程實戰（五）
――驅動程序設計
1.引言
設備驅動程序是操作系統內核和機器硬件之間的接口，它為應用程序屏蔽硬件的細節，一般來說，Linux的設備驅動程序需要完成如下功能：
（1）初始化設備；
（2）提供各類設備服務；
（3）負責內核和設備之間的數據交換；
（4）檢測和處理設備工作過程中出現的錯誤。
妙不可言的是，Linux下的設備驅動程序被組織為一組完成不同任務的函數的集合，通過這些函數使得Windows的設備操作猶如文件一般。在應
用程序看來，硬件設備只是一個設備文件，應用程序可以象操作普通文件一樣對硬件設備進行操作。本系列文章的第2章文件系統編程中已經看
到了這些函數的真面目，它們就是open ()、close ()、read ()、write () 等。
Linux主要將設備分為二類：字符設備和塊設備（當然網絡設備及USB等其它設備的驅動編寫方法又稍有不同）。這兩類設備的不同點在于：在
對字符設備發出讀/寫請求時，實際的硬件I/O一般就緊接著發生了，而塊設備則不然，它利用一塊系統內存作緩沖區，當用戶進程對設備請求
能滿足用戶的要求，就返回請求的數據，如果不能，就調用請求函數來進行實際的I/O操作。塊設備主要針對磁盤等慢速設備。以字符設備的驅
動較為簡單，因此本章主要闡述字符設備的驅動編寫。
2.驅動模塊函數
init 函數用來完成對所控設備的初始化工作，并調用register_chrdev() 函數注冊字符設備。假設有一字符設備“exampledev”，則其init
函數為：
void exampledev_init(void)
{
if (register_chrdev(MAJOR_NUM, " exampledev ", &exampledev_fops))
TRACE_TXT("Device exampledev driver registered error");
else
TRACE_TXT("Device exampledev driver registered successfully");
…//設備初始化
}
其中，register_chrdev函數中的參數MAJOR_NUM為主設備號,“exampledev”為設備名，exampledev_fops為包含基本函數入口點的結構體，類
型為file_operations。當執行exampledev_init時，它將調用內核函數register_chrdev，把驅動程序的基本入口點指針存放在內核的字符設備
地址表中，在用戶進程對該設備執行系統調用時提供入口地址。
file_operations結構體定義為：
struct file_operations
{
int (*lseek)();
int (*read)();
int (*write)();
int (*readdir)();
int (*select)();
int (*ioctl)();
int (*mmap)();
int (*open)();
void(*release)();
int (*fsync)();
int (*fasync)();
int (*check_media_change)();
void(*revalidate)();
};
大多數的驅動程序只是利用了其中的一部分，對于驅動程序中無需提供的功能，只需要把相應位置的值設為NULL。對于字符設備來說，要提供
的主要入口有：open ()、release ()、read ()、write ()、ioctl ()。
open()函數 對設備特殊文件進行open()系統調用時，將調用驅動程序的open () 函數：
int open(struct inode * inode ,struct file * file);
其中參數inode為設備特殊文件的inode (索引結點) 結構的指針，參數file是指向這一設備的文件結構的指針。open()的主要任務是確定硬件
處在就緒狀態、驗證次設備號的合法性(次設備號可以用MINOR(inode-> i - rdev) 取得)、控制使用設備的進程數、根據執行情況返回狀態碼
(0表示成功，負數表示存在錯誤) 等；
release()函數 當最后一個打開設備的用戶進程執行close ()系統調用時，內核將調用驅動程序的release () 函數：
void release (struct inode * inode ,struct file * file) ;
release 函數的主要任務是清理未結束的輸入/輸出操作、釋放資源、用戶自定義排他標志的復位等。
read()函數 當對設備特殊文件進行read() 系統調用時，將調用驅動程序read() 函數：
void read(struct inode * inode ,struct file * file ,char * buf ,int count) ;
參數buf是指向用戶空間緩沖區的指針，由用戶進程給出，count 為用戶進程要求讀取的字節數，也由用戶給出。
read() 函數的功能就是從硬設備或內核內存中讀取或復制count個字節到buf 指定的緩沖區中。在復制數據時要注意，驅動程序運行在內核中
，而buf指定的緩沖區在用戶內存區中，是不能直接在內核中訪問使用的，因此，必須使用特殊的復制函數來完成復制工作，這些函數在
segment.h>中定義：
void put_user_byte (char data_byte ,char * u_addr) ;
void put_user_word (short data_word ,short * u_addr) ;
void put_user_long(long data_long ,long * u_addr) ;
void memcpy_tofs (void * u_addr ,void * k_addr ,unsigned long cnt) ;
參數u_addr為用戶空間地址，k_addr 為內核空間地址，cnt為字節數。
write( ) 函數 當設備特殊文件進行write () 系統調用時，將調用驅動程序的write () 函數：
void write (struct inode * inode ,struct file * file ,char * buf ,int count) ;
write ()的功能是將參數buf 指定的緩沖區中的count 個字節內容復制到硬件或內核內存中，和read() 一樣，復制工作也需要由特殊函數來完
成：
unsigned char_get_user_byte (char * u_addr) ;
unsigned char_get_user_word (short * u_addr) ;
unsigned char_get_user_long(long * u_addr) ;
unsigned memcpy_fromfs(void * k_addr ,void * u_addr ,unsigned long cnt) ;
ioctl() 函數 該函數是特殊的控制函數，可以通過它向設備傳遞控制信息或從設備取得狀態信息，函數原型為：
int ioctl (struct inode * inode ,struct file * file ,unsigned int cmd ,unsigned long arg);
參數cmd為設備驅動程序要執行的命令的代碼，由用戶自定義，參數arg 為相應的命令提供參數，類型可以是整型、指針等。
同樣，在驅動程序中，這些函數的定義也必須符合命名規則，按照本文約定，設備“exampledev”的驅動程序的這些函數應分別命名為
exampledev_open、exampledev_ release、exampledev_read、exampledev_write、exampledev_ioctl，因此設備“exampledev”的基本入口點
結構變量exampledev_fops 賦值如下：
struct file_operations exampledev_fops {
NULL ,
exampledev_read ,
exampledev_write ,
NULL ,
NULL ,
exampledev_ioctl ,
NULL ,
exampledev_open ,
exampledev_release ,
NULL ,
NULL ,
NULL ,
NULL
} ;
3.內存分配
由于Linux驅動程序在內核中運行，因此在設備驅動程序需要申請/釋放內存時，不能使用用戶級的malloc/free函數，而需由內核級的函數
kmalloc/kfree () 來實現，kmalloc()函數的原型為：
void kmalloc (size_t size ,int priority);
參數size為申請分配內存的字節數；參數priority說明若kmalloc()不能馬上分配內存時用戶進程要采用的動作：GFP_KERNEL 表示等待，即等
kmalloc()函數將一些內存安排到交換區來滿足你的內存需要，GFP_ATOMIC 表示不等待，如不能立即分配到內存則返回0 值；函數的返回值指
向已分配內存的起始地址，出錯時，返回0。
kmalloc ()分配的內存需用kfree()函數來釋放，kfree ()被定義為：
# define kfree (n) kfree_s( (n) ,0)
其中kfree_s () 函數原型為：
void kfree_s (void * ptr ,int size);
參數ptr為kmalloc()返回的已分配內存的指針，size是要釋放內存的字節數，若為0 時，由內核自動確定內存的大小。
4.中斷
許多設備涉及到中斷操作，因此，在這樣的設備的驅動程序中需要對硬件產生的中斷請求提供中斷服務程序。與注冊基本入口點一樣，驅動程
序也要請求內核將特定的中斷請求和中斷服務程序聯系在一起。在Linux中，用request_irq()函數來實現請求：
int request_irq (unsigned int irq ,void( * handler) int ,unsigned long type ,char * name);
參數irq為要中斷請求號，參數handler為指向中斷服務程序的指針，參數type 用來確定是正常中斷還是快速中斷（正常中斷指中斷服務子程序
返回后，內核可以執行調度程序來確定將運行哪一個進程；而快速中斷是指中斷服務子程序返回后，立即執行被中斷程序，正常中斷type 取值
為0 ，快速中斷type 取值為SA_INTERRUPT），參數name是設備驅動程序的名稱。
5.實例
筆者最近設計了一塊采用三星S3C2410 ARM處理器的電路板（ARM處理器廣泛應用于手機、PDA等嵌入式系統），板上包含四個用戶可編程的發光
二極管（LED），這些LED連接在ARM處理器的可編程I/O口（GPIO）上。下圖給出了ARM中央處理器與LED的連接原理：
我們在ARM處理器上移植Linux操作系統，現在來編寫這些LED的驅動：
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define DEVICE_NAME "leds" /*定義led 設備的名字*/
#define LED_MAJOR 231 /*定義led 設備的主設備號*/
static unsigned long led_table[] =
{
/*I/O 方式led 設備對應的硬件資源*/
GPIO_B10, GPIO_B8, GPIO_B5, GPIO_B6,
};
/*使用ioctl 控制led*/
static int leds_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
switch (cmd)
{
case 0:
case 1:
if (arg > 4)
{
return -EINVAL;
}
write_gpio_bit(led_table[arg], !cmd);
default:
return -EINVAL;
}
}
static struct file_operations leds_fops =
{
owner: THIS_MODULE, ioctl: leds_ioctl,
};
static devfs_handle_t devfs_handle;
static int __init leds_init(void)
{
int ret;
int i;
/*在內核中注冊設備*/
ret = register_chrdev(LED_MAJOR, DEVICE_NAME, &leds_fops);
if (ret < 0)
{
printk(DEVICE_NAME " can't register major number"n");
return ret;
}
devfs_handle = devfs_register(NULL, DEVICE_NAME, DEVFS_FL_DEFAULT, LED_MAJOR,
0, S_IFCHR | S_IRUSR | S_IWUSR, &leds_fops, NULL);
/*使用宏進行端口初始化，set_gpio_ctrl 和write_gpio_bit 均為宏定義*/
for (i = 0; i < 8; i++)
{
set_gpio_ctrl(led_table[i] | GPIO_PULLUP_EN | GPIO_MODE_OUT);
write_gpio_bit(led_table[i], 1);
}
printk(DEVICE_NAME " initialized"n");
return 0;
}
static void __exit leds_exit(void)
{
devfs_unregister(devfs_handle);
unregister_chrdev(LED_MAJOR, DEVICE_NAME);
}
module_init(leds_init);
module_exit(leds_exit);
使用命令方式編譯led 驅動模塊：
#arm-linux-gcc -D__KERNEL__ -I/arm/kernel/include
-DKBUILD_BASENAME=leds -DMODULE -c -o leds.o leds.c
以上命令將生成leds.o 文件，把該文件復制到板子的/lib目錄下，使用以下命令就可以安裝leds驅動模塊：
#insmod /lib/ leds.o
刪除該模塊的命令是：
#rmmod leds
6.小結
本章講述了Linux設備驅動程序的入口函數及驅動程序中的內存申請、中斷等，并給出了一個通過ARM處理器的GPIO口控制LED的驅動實例。
轉載于:https://my.oschina.net/u/2408025/blog/539820
總結
以上是生活随笔為你收集整理的Linux下C编程实战的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 笔记 百度搜索
- 下一篇： 多数据源使用spring-data-jp