Linux系統調用全面解析：連接用戶與內核的橋梁
其實系統調用沒那么復雜：它就像用戶態與內核態之間的 “橋梁”，每一次調用都是一次 “合規的資源申請”。搞懂它的原理，不僅能幫你快速定位errno錯誤、優化程序性能，更能理解 Linux 系統 “隔離與協作” 的設計思想。當我們在 Linux 系統上運行程序時，程序經常需要與操作系統內核進行交互，以獲取某些資源或執行特定的任務，比如讀寫文件、創建進程、分配內存等 。
而 Linux 系統調用，就是用戶程序與操作系統內核之間溝通的橋梁，是一種讓用戶程序能夠訪問操作系統內核提供的服務的機制。它在 Linux 系統中處于極為關鍵的地位，對于理解操作系統的工作原理、編寫高效穩定的應用程序，以及進行系統級的開發和優化都起著不可或缺的作用。接下來，就讓我們一起深入探索 Linux 系統調用的奧秘吧。
一、Linux 系統調用是什么？
1.1Linux 系統調用概述
在 Linux 系統中，系統調用是操作系統內核為用戶空間的程序提供的一組接口，它就像是一扇特殊的 “門”，讓用戶程序能夠請求內核執行一些特權操作，比如訪問硬件資源、管理文件系統、控制進程等 。簡單來說，系統調用是用戶程序與操作系統內核之間進行交互的一種機制。
你可以把 Linux 系統想象成一個龐大且復雜的工廠，內核就是工廠的核心管理部門，負責調配所有的資源和運作。而用戶程序則像是工廠里的普通工人，他們需要完成各種任務，但沒有直接調配核心資源的權限。當工人（用戶程序）需要某些特殊資源或執行特定任務時，就必須通過系統調用這個 “傳話筒” 向管理部門（內核）提出請求 。
1.2系統調用的重要性
系統調用在操作系統中占據著舉足輕重的地位，是操作系統提供服務和實現功能的基礎機制，在資源管理、進程控制、文件操作、設備管理等眾多方面發揮著關鍵作用。
在資源管理方面，系統調用允許用戶程序請求內核分配和管理系統資源，如內存、CPU 時間片、文件描述符等。通過系統調用，內核可以根據系統的整體狀態和資源使用情況，合理地分配資源，確保各個進程能夠公平、有效地使用資源，避免資源沖突和浪費。比如，當一個程序需要使用內存時，它會通過系統調用向內核請求分配一定大小的內存空間，內核會在內存管理模塊中進行相應的處理，為程序分配合適的內存塊，并返回一個指向該內存塊的指針，供程序使用。
進程控制是操作系統的核心功能之一，系統調用為進程的創建、執行、終止和等待等操作提供了接口。例如，fork () 系統調用用于創建一個新的進程，它是一個與父進程幾乎完全相同的子進程，擁有自己獨立的進程標識符（PID）。父進程可以通過 wait () 或 waitpid () 系統調用等待子進程結束，并獲取子進程的退出狀態，以便進行后續的處理。這些系統調用使得開發者能夠方便地控制進程的生命周期，實現多進程編程，提高程序的并發處理能力。
文件操作是日常計算機使用中最常見的任務之一，系統調用為文件的打開、關閉、讀取、寫入、定位等操作提供了統一的接口。應用程序通過 open () 系統調用打開一個文件，并獲得一個文件描述符，后續對文件的所有操作都通過這個文件描述符進行。write () 系統調用用于向文件中寫入數據，read () 系統調用則用于從文件中讀取數據。這些系統調用屏蔽了底層文件系統的復雜性，使得開發者可以專注于文件操作的邏輯，而不必關心具體的文件存儲和訪問方式。
在設備管理方面，系統調用為應用程序提供了訪問硬件設備的能力。無論是磁盤、打印機、網絡接口等設備，都可以通過相應的系統調用來進行控制和交互。例如，ioctl () 系統調用常用于對設備進行控制操作，如設置設備的參數、獲取設備的狀態信息等。通過系統調用，應用程序可以與各種硬件設備進行通信，實現設備的驅動和管理，使得操作系統能夠充分發揮硬件設備的功能。
1.3為什么需要系統調用
linux內核中設置了一組用于實現系統功能的子程序，稱為系統調用。系統調用和普通庫函數調用非常相似，只是系統調用由操作系統核心提供，運行于內核態，而普通的函數調用由函數庫或用戶自己提供，運行于用戶態。
一般的，進程是不能訪問內核的。它不能訪問內核所占內存空間也不能調用內核函數。CPU硬件決定了這些（這就是為什么它被稱作“保護模式”）。
為了和用戶空間上運行的進程進行交互，內核提供了一組接口。透過該接口，應用程序可以訪問硬件設備和其他操作系統資源。這組接口在應用程序和內核之間扮演了使者的角色，應用程序發送各種請求，而內核負責滿足這些請求(或者讓應用程序暫時擱置)。實際上提供這組接口主要是為了保證系統穩定可靠，避免應用程序肆意妄行，惹出大麻煩。
系統調用在用戶空間進程和硬件設備之間添加了一個中間層，該層主要作用有三個：
- 它為用戶空間提供了一種統一的硬件的抽象接口。比如當需要讀些文件的時候，應用程序就可以不去管磁盤類型和介質，甚至不用去管文件所在的文件系統到底是哪種類型。
- 系統調用保證了系統的穩定和安全。作為硬件設備和應用程序之間的中間人，內核可以基于權限和其他一些規則對需要進行的訪問進行裁決。舉例來說，這樣可以避免應用程序不正確地使用硬件設備，竊取其他進程的資源，或做出其他什么危害系統的事情。
- 每個進程都運行在虛擬系統中，而在用戶空間和系統的其余部分提供這樣一層公共接口，也是出于這種考慮。如果應用程序可以隨意訪問硬件而內核又對此一無所知的話，幾乎就沒法實現多任務和虛擬內存，當然也不可能實現良好的穩定性和安全性。在Linux中，系統調用是用戶空間訪問內核的惟一手段；除異常和中斷外，它們是內核惟一的合法入口。
二、用戶空間與內核空間
對 32 位操作系統而言，它的尋址空間（虛擬地址空間，或叫線性地址空間）為 4G（2的32次方）。也就是說一個進程的最大地址空間為 4G。操作系統的核心是內核(kernel)，它獨立于普通的應用程序，可以訪問受保護的內存空間，也有訪問底層硬件設備的所有權限。為了保證內核的安全，現在的操作系統一般都強制用戶進程不能直接操作內核。
具體的實現方式基本都是由操作系統將虛擬地址空間劃分為兩部分，一部分為內核空間，另一部分為用戶空間。針對 Linux 操作系統而言，最高的 1G 字節(從虛擬地址 0xC0000000 到 0xFFFFFFFF)由內核使用，稱為內核空間。而較低的 3G 字節(從虛擬地址 0x00000000 到 0xBFFFFFFF)由各個進程使用，稱為用戶空間。
圖片
2.1用戶空間
用戶空間是應用程序運行的區域，它為應用程序提供了一個相對獨立和受保護的執行環境。在 32 位的 Linux 系統中，通常將虛擬地址空間的低 3GB 劃分為用戶空間，每個用戶進程都擁有自己獨立的用戶空間，這使得不同進程之間的地址空間相互隔離，一個進程的崩潰不會影響其他進程的正常運行，就像一個個獨立的小房間，每個房間里的活動互不干擾 。
用戶空間的應用程序具有受限的訪問權限，它們無法直接操作硬件資源，如CPU、內存、I/O設備等。這是因為硬件資源的直接操作需要較高的權限，而用戶空間的應用程序運行在較低的特權級別（如 x86 架構中的 Ring 3），以防止應用程序對系統造成破壞。如果把操作系統比作一個大型工廠，硬件資源就是工廠里的核心生產設備，而用戶空間的應用程序就像是工廠里的普通工人，他們不能隨意操作核心生產設備，必須通過特定的流程（系統調用）向管理層（內核）提出申請 。
2.2內核空間
內核空間是操作系統內核的執行區域，是操作系統的核心部分，負責管理系統的硬件資源和提供各種基本服務。在 32 位的 Linux 系統中，虛擬地址空間的高 1GB 通常被劃分為內核空間，所有進程共享這部分內核空間。內核空間就像是工廠的管理層，擁有最高的權限，可以直接訪問和控制所有硬件資源，執行特權指令。
內核空間擁有完全控制硬件資源的權限，它可以直接操作 CPU、內存、I/O 設備等，負責進程調度、內存管理、文件系統管理、設備驅動等關鍵功能。例如，在內核空間中，內核可以根據進程的優先級和資源需求，合理地分配 CPU 時間片，確保各個進程能夠公平地使用 CPU 資源；內核還負責管理物理內存和虛擬內存之間的映射關系，為進程分配和回收內存；此外，內核還通過設備驅動程序與各種硬件設備進行交互，實現對硬件設備的控制和管理。
2.3為什么需要區分內核空間與用戶空間
在 CPU 的所有指令中，有些指令是非常危險的，如果錯用，將導致系統崩潰，比如清內存、設置時鐘等。如果允許所有的程序都可以使用這些指令，那么系統崩潰的概率將大大增加。所以，CPU 將指令分為特權指令和非特權指令，對于那些危險的指令，只允許操作系統及其相關模塊使用，普通應用程序只能使用那些不會造成災難的指令。比如 Intel 的 CPU 將特權等級分為 4 個級別：Ring0~Ring3。
其實 Linux 系統只使用了 Ring0 和 Ring3 兩個運行級別(Windows 系統也是一樣的)。當進程運行在 Ring3 級別時被稱為運行在用戶態，而運行在 Ring0 級別時被稱為運行在內核態。
當進程運行在內核空間時就處于內核態，而進程運行在用戶空間時則處于用戶態。
在內核態下，進程運行在內核地址空間中，此時 CPU 可以執行任何指令。運行的代碼也不受任何的限制，可以自由地訪問任何有效地址，也可以直接進行端口的訪問。
在用戶態下，進程運行在用戶地址空間中，被執行的代碼要受到 CPU 的諸多檢查，它們只能訪問映射其地址空間的頁表項中規定的在用戶態下可訪問頁面的虛擬地址，且只能對任務狀態段(TSS)中 I/O 許可位圖(I/O Permission Bitmap)中規定的可訪問端口進行直接訪問。
對于以前的 DOS 操作系統來說，是沒有內核空間、用戶空間以及內核態、用戶態這些概念的。可以認為所有的代碼都是運行在內核態的，因而用戶編寫的應用程序代碼可以很容易的讓操作系統崩潰掉。
對于 Linux 來說，通過區分內核空間和用戶空間的設計，隔離了操作系統代碼(操作系統的代碼要比應用程序的代碼健壯很多)與應用程序代碼。即便是單個應用程序出現錯誤也不會影響到操作系統的穩定性，這樣其它的程序還可以正常的運行(Linux 可是個多任務系統啊！)。
所以，區分內核空間和用戶空間本質上是要提高操作系統的穩定性及可用性
三、系統調用的執行過程
Linux 系統調用的執行過程涉及多個關鍵步驟，從用戶程序發起調用，到內核進行處理，再到最終返回結果給用戶程序，每一步都至關重要。接下來，我們將詳細探討 Linux 系統調用的執行過程。
3.1準備階段
在用戶程序調用系統調用之前，首先需要設置相關參數，這些參數包括系統調用號以及其他與具體系統調用相關的參數。系統調用號是一個唯一的標識符，用于標識不同的系統調用。每個系統調用都被分配了一個特定的編號，就像圖書館里的每一本書都有一個唯一的編號一樣，方便快速查找和識別 。
在 x86 架構中，系統調用號通常通過 EAX 寄存器傳遞給內核。例如，對于常見的 read 系統調用，其系統調用號為 3（在不同架構和內核版本中可能會有所不同）。除了系統調用號，還需要傳遞其他參數，如 read 系統調用需要傳遞文件描述符（通過 EBX 寄存器傳遞）、緩沖區指針（通過 ECX 寄存器傳遞）和讀取的字節數（通過 EDX 寄存器傳遞） 。
3.2觸發系統調用
用戶程序設置好參數后，需要通過特定的指令來觸發系統調用，從而進入內核態執行相應的操作。在 x86 架構中，傳統上常用的指令是 int 0x80，這是一條軟中斷指令。當 CPU 執行到 int 0x80 指令時，會產生一個軟件中斷，從而觸發系統調用機制。隨著技術的發展，x86 架構從內核 2.6.11 版本開始引入了 syscall 指令，它比 int 0x80 指令具有更高的性能。syscall 指令通過特定的寄存器（如 RAX、RDI、RSI 等）來傳遞系統調用號和參數，能夠更高效地實現從用戶態到內核態的切換 。
除了 x86 架構，其他架構也有各自對應的觸發系統調用的方式。在 ARM 架構中，通常使用 svc（Supervisor Call）指令來觸發系統調用，該指令會導致處理器進入特權模式，從而執行內核中的系統調用處理程序 。
3.3進入內核態
當用戶程序觸發系統調用后，CPU 會從用戶態切換到內核態，這是一個關鍵的狀態轉換過程。在這個過程中，CPU 會保存當前用戶程序的上下文信息，包括寄存器的值、程序計數器（PC）等，以便在系統調用完成后能夠恢復用戶程序的執行。
CPU 通過中斷向量表來確定系統調用處理程序的入口地址。中斷向量表是一個存儲中斷處理程序入口地址的表格，每個中斷向量對應一個特定的中斷類型。對于系統調用，會有一個特定的中斷向量（如 x86 架構中 int 0x80 對應的中斷向量），CPU 根據這個中斷向量在中斷向量表中查找對應的系統調用處理程序的入口地址，然后跳轉到該地址開始執行內核代碼 。
3.4參數檢查與處理
在內核開始執行系統調用之前，需要對用戶程序傳遞過來的參數進行合法性檢查，這是確保系統安全性和穩定性的重要環節。內核會檢查參數的類型、范圍、有效性等，以防止用戶程序傳遞非法參數導致系統崩潰或出現安全漏洞。
對于涉及指針的參數，內核會檢查指針是否指向合法的內存地址，并且該內存地址是否屬于用戶程序的地址空間，防止用戶程序通過傳遞非法指針來訪問內核空間或其他進程的內存空間。對于文件描述符參數，內核會檢查文件描述符是否有效，是否指向一個已經打開的文件，以及當前進程是否具有對該文件的相應操作權限 。
3.5執行系統調用函數
內核完成參數檢查后，會根據系統調用號從系統調用表中找到對應的系統調用函數，并執行該函數。系統調用表是一個存儲系統調用函數指針的數組，每個系統調用號對應數組中的一個元素，該元素指向相應的系統調用函數。
在 x86 架構的 32 位系統中，系統調用表位于 arch/x86/kernel/syscall_table_32.S 文件中；在 64 位系統中，系統調用表位于 arch/x86/entry/syscalls/syscall_64.tbl 文件中。例如，對于 read 系統調用，內核會在系統調用表中找到對應的函數指針，然后調用該函數來執行實際的讀取操作。在執行過程中，內核會根據用戶傳遞的參數，如文件描述符、緩沖區指針和讀取字節數，來完成文件讀取任務，并將讀取的數據存儲到用戶指定的緩沖區中 。
3.6返回用戶態
當系統調用函數執行完成后，內核會將結果返回給用戶程序，并將 CPU 從內核態切換回用戶態。內核將系統調用的返回值存儲在特定的寄存器中（如 x86 架構中通過 EAX 寄存器返回），然后恢復之前保存的用戶程序的上下文信息，包括寄存器的值、程序計數器等。
CPU 根據恢復的程序計數器的值，跳轉到用戶程序中系統調用指令的下一條指令處繼續執行，從而完成系統調用的整個過程。如果系統調用執行過程中發生錯誤，內核會返回一個錯誤碼，用戶程序可以通過檢查返回值來判斷系統調用是否成功，并根據錯誤碼進行相應的錯誤處理 。
四、Linux 系統調用的分類
Linux 系統調用涵蓋了眾多功能領域，根據其功能特點，可以大致分為以下幾類。
4.1文件操作系統調用
文件操作系統調用主要用于對文件和文件系統進行操作，是實現文件管理和數據存儲的基礎。其中，open函數用于打開或創建文件，在打開或創建文件時可以指定文件的屬性及用戶的權限等各種參數。比如我們想要打開一個名為 “example.txt” 的文件進行讀寫操作，可以這樣使用：
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
int main() {
int fd = open("example.txt", O_RDWR | O_CREAT, 0644);
if (fd == -1) {
perror("Error opening file");
return 1;
}
// 后續對文件的操作
close(fd);
return 0;
}在這個例子中，O_RDWR表示以讀寫方式打開文件，O_CREAT表示如果文件不存在則創建它，0644是文件的權限設置。
read函數用于從文件中讀取數據，write函數則用于向文件寫入數據。例如，我們從一個文件中讀取數據并寫入到另一個文件中：
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#define BUFFER_SIZE 1024
int main() {
int source_fd, target_fd;
char buffer[BUFFER_SIZE];
ssize_t bytes_read, bytes_written;
source_fd = open("source.txt", O_RDONLY);
if (source_fd == -1) {
perror("Error opening source file");
return 1;
}
target_fd = open("target.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (target_fd == -1) {
perror("Error opening target file");
close(source_fd);
return 1;
}
while ((bytes_read = read(source_fd, buffer, BUFFER_SIZE)) > 0) {
bytes_written = write(target_fd, buffer, bytes_read);
if (bytes_written == -1) {
perror("Error writing to target file");
break;
}
}
if (bytes_read == -1) {
perror("Error reading source file");
}
close(source_fd);
close(target_fd);
return 0;
}close函數用于關閉一個已打開的文件，釋放文件描述符，確保系統資源的合理利用。在上述代碼中，我們在文件操作完成后，都使用close函數關閉了文件。
4.2進程控制系統調用
進程控制系統調用用于管理進程的生命周期，包括進程的創建、執行、等待和終止等操作，是實現多任務處理和進程間協作的關鍵。fork函數是用于創建新進程的系統調用，它會創建一個與調用進程（父進程）幾乎完全相同的子進程。子進程復制父進程的代碼段、數據段、堆、棧等資源，并擁有自己獨立的進程 ID（PID），但與父進程共享一些資源，如打開的文件描述符 。例如：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
pid_t pid;
pid = fork();
if (pid < 0) {
perror("fork error");
exit(EXIT_FAILURE);
} else if (pid == 0) {
// 子進程
printf("I am the child process, my pid is %d, my parent's pid is %d\n", getpid(), getppid());
} else {
// 父進程
printf("I am the parent process, my pid is %d, and my child's pid is %d\n", getpid(), pid);
}
return 0;
}在這個例子中，fork函數被調用后，會返回兩次，一次在父進程中返回子進程的 PID，一次在子進程中返回 0。通過判斷返回值，我們可以區分父子進程，并執行不同的代碼邏輯。
exec系列函數用于在當前進程的上下文中執行一個新的程序，它會用新程序的代碼和數據替換當前進程的代碼和數據 。例如，我們可以使用execlp函數來執行一個外部命令：
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
if (fork() == 0) {
// 子進程
if (execlp("ls", "ls", "-l", NULL) < 0) {
perror("execlp error");
exit(1);
}
}
return 0;
}在這個例子中，execlp函數在子進程中執行了 “ls -l” 命令，列出當前目錄下的文件和目錄信息。如果execlp函數執行成功，它不會返回；只有在執行失敗時，才會返回并設置錯誤信息。
wait系列函數用于等待子進程的結束，并獲取子進程的退出狀態 。例如，父進程可以使用wait函數來等待子進程結束：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main() {
pid_t pid;
int status;
pid = fork();
if (pid < 0) {
perror("fork error");
exit(EXIT_FAILURE);
} else if (pid == 0) {
// 子進程
sleep(2);
printf("Child process is exiting\n");
exit(0);
} else {
// 父進程
wait(&status);
if (WIFEXITED(status)) {
printf("Child process exited normally with status %d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
printf("Child process was terminated by signal %d\n", WTERMSIG(status));
}
}
return 0;
}在這個例子中，父進程調用wait函數后，會被阻塞，直到子進程結束。wait函數返回時，通過WIFEXITED和WEXITSTATUS宏可以判斷子進程是否正常退出，并獲取其退出狀態；通過WIFSIGNALED和WTERMSIG宏可以判斷子進程是否被信號終止，并獲取終止信號。
exit函數用于終止當前進程的執行，并將控制權返回給操作系統 。當進程執行到exit函數時，會進行一些清理工作，如關閉打開的文件描述符、釋放內存等，然后終止進程。例如：
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Before exit\n");
exit(0);
printf("This line will not be executed\n");
return 0;
}在這個例子中，當執行到exit(0)時，進程會立即終止，后面的 “This line will not be executed” 不會被輸出。
4.3內存管理系統調用
內存管理系統調用負責管理進程的內存空間，包括內存的分配、釋放和映射等操作，是確保程序高效運行和內存資源合理利用的重要手段。mmap函數用于將文件或設備的內容映射到進程的地址空間中，實現文件的內存映射訪問或共享內存 。例如，我們可以使用mmap函數將一個文件映射到內存中，然后直接對內存進行讀寫操作，而不需要通過read和write系統調用：
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#define FILE_SIZE 1024
int main() {
int fd;
char *file_contents;
struct stat file_stat;
fd = open("example.txt", O_RDWR | O_CREAT, 0644);
if (fd == -1) {
perror("Error opening file");
return 1;
}
if (fstat(fd, &file_stat) == -1) {
perror("Error getting file status");
close(fd);
return 1;
}
file_contents = (char *)mmap(0, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (file_contents == MAP_FAILED) {
perror("mmap error");
close(fd);
return 1;
}
// 對映射的內存進行操作
sprintf(file_contents, "This is a test\n");
if (munmap(file_contents, FILE_SIZE) == -1) {
perror("munmap error");
}
close(fd);
return 0;
}在這個例子中，mmap函數將 “example.txt” 文件的內容映射到進程的地址空間中，返回一個指向映射內存區域的指針file_contents。我們可以像操作普通內存一樣對file_contents進行讀寫操作，操作完成后，使用munmap函數解除內存映射。
brk和sbrk函數用于改變進程數據段的大小，從而實現內存的分配和釋放 。brk函數通過設置進程數據段的結束地址來增加或減少內存空間，sbrk函數則是在當前數據段的基礎上，增加或減少指定大小的內存空間。例如，使用sbrk函數分配一塊內存：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
char *new_memory;
new_memory = (char *)sbrk(1024);
if (new_memory == (void *)-1) {
perror("sbrk error");
return 1;
}
// 使用分配的內存
sprintf(new_memory, "Allocated memory");
printf("%s\n", new_memory);
// 釋放內存，這里通過將數據段大小減少1024字節來實現
if (sbrk(-1024) == (void *)-1) {
perror("sbrk error");
}
return 0;
}在這個例子中，sbrk(1024)函數分配了 1024 字節的內存空間，并返回指向該內存區域的指針new_memory。我們可以對new_memory進行操作，操作完成后，通過sbrk(-1024)函數將數據段大小減少 1024 字節，從而釋放之前分配的內存。不過需要注意的是，brk和sbrk函數的使用相對底層，容易出錯，在實際應用中，通常會使用更高級的內存分配函數，如malloc和free，它們是對brk和sbrk的封裝，提供了更方便和安全的內存管理方式。
4.4設備控制系統調用
設備控制系統調用用于控制硬件設備的操作，實現設備與用戶程序之間的通信和交互，是拓展計算機系統功能和實現設備特定操作的重要途徑。ioctl函數是設備控制系統調用中的一個重要函數，它允許用戶程序對設備進行特定的控制操作 。例如，對于串口設備，我們可以使用ioctl函數來設置串口的波特率、數據位、停止位等參數：
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
int main() {
int fd;
struct termios options;
fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);
if (fd == -1) {
perror("Error opening serial port");
return 1;
}
if (tcgetattr(fd, &options) == -1) {
perror("Error getting serial port attributes");
close(fd);
return 1;
}
cfsetispeed(&options, B9600); // 設置波特率為9600
cfsetospeed(&options, B9600);
options.c_cflag |= (CLOCAL | CREAD);
options.c_cflag &= ~PARENB; // 無校驗位
options.c_cflag &= ~CSTOPB; // 1位停止位
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8; // 8位數據位
if (tcsetattr(fd, TCSANOW, &options) == -1) {
perror("Error setting serial port attributes");
}
close(fd);
return 0;
}在這個例子中，ioctl函數通過tcgetattr和tcsetattr函數來獲取和設置串口設備的屬性。tcgetattr函數用于獲取串口的當前屬性，存儲在options結構體中；然后我們對options結構體中的參數進行修改，設置波特率、校驗位、停止位和數據位等；最后使用tcsetattr函數將修改后的屬性設置到串口設備上。
對于其他設備，如攝像頭、網卡等，ioctl函數也有類似的應用。例如，在視頻采集設備中，使用ioctl函數來設置攝像頭的分辨率、幀率等參數；在網卡設備中，使用ioctl函數來配置網絡接口的 IP 地址、子網掩碼等 。不同的設備驅動程序會定義各自的ioctl命令，用戶程序通過這些命令來實現對設備的特定控制。
五、Linux下系統調用的三種方法
5.1通過 glibc 提供的庫函數
glibc 是 Linux 下使用的開源的標準 C 庫，它是 GNU 發布的 libc 庫，即運行時庫。glibc 為程序員提供豐富的 API（Application Programming Interface），除了例如字符串處理、數學運算等用戶態服務之外，最重要的是封裝了操作系統提供的系統服務，即系統調用的封裝。那么glibc提供的系統調用API與內核特定的系統調用之間的關系是什么呢？
通常情況，每個特定的系統調用對應了至少一個 glibc 封裝的庫函數，如系統提供的打開文件系統調用 sys_open 對應的是 glibc 中的 open 函數；
其次，glibc 一個單獨的 API 可能調用多個系統調用，如 glibc 提供的 printf 函數就會調用如 sys_open、sys_mmap、sys_write、sys_close 等等系統調用；
另外，多個 API 也可能只對應同一個系統調用，如glibc 下實現的 malloc、calloc、free 等函數用來分配和釋放內存，都利用了內核的 sys_brk 的系統調用。
舉例來說，我們通過 glibc 提供的chmod 函數來改變文件 etc/passwd 的屬性為 444：
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
int main()
{
int rc;
rc = chmod("/etc/passwd", 0444);
if (rc == -1)
fprintf(stderr, "chmod failed, errno = %d\n", errno);
else
printf("chmod success!\n");
return 0;
}在普通用戶下編譯運用，輸出結果為：
chmod failed, errno = 1上面系統調用返回的值為-1，說明系統調用失敗，錯誤碼為1，在 /usr/include/asm-generic/errno-base.h 文件中有如下錯誤代碼說明：
#define EPERM 1 /* Operation not permitted */即無權限進行該操作，我們以普通用戶權限是無法修改 /etc/passwd 文件的屬性的，結果正確。
5.2使用 syscall 直接調用
使用上面的方法有很多好處，首先你無須知道更多的細節，如 chmod 系統調用號，你只需了解 glibc 提供的 API 的原型；其次，該方法具有更好的移植性，你可以很輕松將該程序移植到其他平臺，或者將 glibc 庫換成其它庫，程序只需做少量改動。
但有點不足是，如果 glibc 沒有封裝某個內核提供的系統調用時，我就沒辦法通過上面的方法來調用該系統調用。如我自己通過編譯內核增加了一個系統調用，這時 glibc 不可能有你新增系統調用的封裝 API，此時我們可以利用 glibc 提供的syscall 函數直接調用。該函數定義在 unistd.h 頭文件中，函數原型如下：
long int syscall (long int sysno, ...)sysno 是系統調用號，每個系統調用都有唯一的系統調用號來標識。在 sys/syscall.h 中有所有可能的系統調用號的宏定義。
... 為剩余可變長的參數，為系統調用所帶的參數，根據系統調用的不同，可帶0~5個不等的參數，如果超過特定系統調用能帶的參數，多余的參數被忽略。
返回值 該函數返回值為特定系統調用的返回值，在系統調用成功之后你可以將該返回值轉化為特定的類型，如果系統調用失敗則返回 -1，錯誤代碼存放在 errno 中。
還以上面修改 /etc/passwd 文件的屬性為例，這次使用 syscall 直接調用：
#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <errno.h>
int main()
{
int rc;
rc = syscall(SYS_chmod, "/etc/passwd", 0444);
if (rc == -1)
fprintf(stderr, "chmod failed, errno = %d\n", errno);
else
printf("chmod succeess!\n");
return 0;
}在普通用戶下編譯執行，輸出的結果與上例相同。
5.3通過 int 指令陷入
如果我們知道系統調用的整個過程的話，應該就能知道用戶態程序通過軟中斷指令int 0x80 來陷入內核態（在Intel Pentium II 又引入了sysenter指令），參數的傳遞是通過寄存器，eax 傳遞的是系統調用號，ebx、ecx、edx、esi和edi 來依次傳遞最多五個參數，當系統調用返回時，返回值存放在 eax 中。
仍然以上面的修改文件屬性為例，將調用系統調用那段寫成內聯匯編代碼：
#include <stdio.h>
#include <sys/types.h>
#include <sys/syscall.h>
#include <errno.h>
int main()
{
long rc;
char *file_name = "/etc/passwd";
unsigned short mode = 0444;
asm(
"int $0x80"
: "=a" (rc)
: "0" (SYS_chmod), "b" ((long)file_name), "c" ((long)mode)
);
if ((unsigned long)rc >= (unsigned long)-132) {
errno = -rc;
rc = -1;
}
if (rc == -1)
fprintf(stderr, "chmode failed, errno = %d\n", errno);
else
printf("success!\n");
return 0;
}如果 eax 寄存器存放的返回值（存放在變量 rc 中）在 -1~-132 之間，就必須要解釋為出錯碼（在/usr/include/asm-generic/errno.h 文件中定義的最大出錯碼為 132），這時，將錯誤碼寫入 errno 中，置系統調用返回值為 -1；否則返回的是 eax 中的值。
六、系統調用的實現機制
6.1系統調用的觸發
用戶程序運行在用戶態，具有受限的權限，無法直接訪問操作系統內核的資源和執行特權操作。當用戶程序需要操作系統提供的服務時，就需要觸發系統調用 。在 Linux 系統中，用戶程序通常通過軟中斷指令來觸發系統調用，將控制權交給內核。
在 x86 架構的 Linux 系統中，傳統的方式是使用int 0x80指令來觸發系統調用 。當 CPU 執行到int 0x80指令時，會產生一個軟中斷，CPU 會暫停當前用戶程序的執行，保存當前的程序狀態（如寄存器的值、程序計數器等），然后跳轉到內核中預先定義好的中斷處理程序入口。在這個過程中，CPU 會從用戶態切換到內核態，從而使得內核能夠處理系統調用請求。例如，在一個簡單的 C 程序中，如果要調用write系統調用來輸出一些信息到控制臺，在底層實現中，就可能會通過int 0x80指令來觸發系統調用，將write系統調用的相關參數傳遞給內核，讓內核執行實際的寫操作 。
隨著硬件技術的發展，x86_64 架構引入了更高效的syscall指令來觸發系統調用 。syscall指令相比int 0x80指令，具有更低的開銷和更快的執行速度。它通過特定的寄存器來傳遞系統調用號和參數，避免了int 0x80指令中一些復雜的中斷處理過程。例如，在 x86_64 架構下，系統調用號會被存放在rax寄存器中，參數會被存放在rdi、rsi、rdx等寄存器中，然后執行syscall指令，CPU 會直接跳轉到內核中對應的系統調用處理函數，大大提高了系統調用的效率 。
6.2系統調用的流程
用戶程序發起調用：用戶程序通常不會直接調用系統調用的內核函數，而是通過調用標準庫函數來發起系統調用請求。例如，在 C 語言中，我們使用open函數來打開文件，open函數就是標準庫提供的接口 。當用戶程序調用open函數時，標準庫會對函數參數進行處理和封裝，為后續的系統調用做好準備。這些標準庫函數就像是一層 “包裝”，隱藏了系統調用的底層細節，使得用戶程序的編寫更加簡單和方便。
參數傳遞與軟中斷：在用戶程序調用標準庫函數后，標準庫會將系統調用的參數傳遞給操作系統 。如前所述，在 x86 架構中，傳統方式是通過寄存器傳遞參數，然后執行int 0x80指令；在 x86_64 架構中，則是將系統調用號放入rax寄存器，參數放入rdi、rsi等寄存器，然后執行syscall指令 。通過這些軟中斷指令，程序的控制權從用戶態切換到內核態，操作系統內核開始接管程序的執行。
內核執行調用：當內核接收到系統調用請求后，會根據系統調用號來判斷用戶程序需要執行的具體操作 。每個系統調用都有一個唯一的系統調用號，就像是一個 “身份證號碼”，內核通過這個號碼來識別不同的系統調用。內核會根據系統調用號查找系統調用表（后面會詳細介紹系統調用表），找到對應的內核函數，并執行該函數來完成系統調用的功能 。例如，如果系統調用號對應的是write系統調用，內核就會執行sys_write函數，進行實際的文件寫入操作，包括檢查文件權限、定位文件位置、寫入數據等步驟。
返回結果：當系統調用在內核中執行完成后，會將執行結果返回給用戶程序 。返回結果可能是成功執行的返回值，比如文件操作中返回的文件描述符、讀取或寫入的字節數等；也可能是錯誤碼，表示系統調用執行過程中出現了問題 。內核會將返回值存放在特定的寄存器中（如 x86 架構中的eax寄存器，x86_64 架構中的rax寄存器），然后通過特定的指令（如iret或sysret指令）將控制權交還給用戶程序，程序從內核態切換回用戶態，繼續執行用戶程序的后續代碼 。用戶程序可以根據返回結果來判斷系統調用是否成功，并進行相應的處理。
6.3內核態與用戶態的切換
在計算機系統中，為了保證系統的安全性和穩定性，CPU 提供了不同的特權級別，Linux 系統主要使用用戶態和內核態這兩種狀態 。用戶態是程序運行的一種受限狀態，在用戶態下，程序只能執行一些受限的操作，不能直接訪問硬件資源和執行特權指令，這就像是一個普通員工，只能在規定的權限范圍內工作 。而內核態則具有最高權限，操作系統內核運行在內核態，它可以直接訪問硬件資源，執行特權指令，管理系統的各種資源和進程，相當于公司的管理層，擁有最高的決策權和資源調配權 。
當用戶程序發起系統調用時，就需要 進行從用戶態到內核態的 切換 。這是因為系統調用涉及到對硬件資源的訪問或特權操作，需要在內核態下才能執行。上下文切換是系統調用過程中的一個重要環節，它指的是在切換狀態時，保存當前狀態的相關信息（如寄存器的值、程序計數器的值等），以便在返回時 能夠恢復到原來的狀態繼續執行 。
以read系統調用為例，當用戶程序調用read函數時，首先會將read函數的參數（如文件描述符、緩沖區指針、讀取的字節數等）傳遞給標準庫 。標準庫將這些參數進一步傳遞給內核，并通過軟中斷指令觸發系統調用 。此時，CPU 會保存當前用戶態的上下文信息，包括寄存器的值、程序計數器的值等，然后切換到內核態 。在內核態下，內核根據系統調用號找到對應的sys_read函數，并執行該函數來完成文件讀取操作 。完成讀取后，內核會將讀取的結果（如讀取的字節數）存放在特定的寄存器中，然后恢復之前保存的用戶態上下文信息，將控制權交還給用戶程序，程序從內核態切換回用戶態，繼續執行用戶程序的后續代碼 。
這種用戶態和內核態的切換機制，有效地隔離了用戶程序和內核，保證了系統的安全。如果沒有這種隔離機制，用戶程序就可能隨意訪問和修改系統資源，導致系統的不穩定甚至崩潰 。
6.4系統調用表
系統調用表是 Linux 內核中一個非常重要的數據結構，它是一個函數指針數組，用于管理所有的系統調用 。每個系統調用在系統調用表中都有一個對應的表項，表項中存儲著該系統調用對應的內核函數的指針 。可以把系統調用表想象成一個巨大的 “菜單”，每個系統調用就像是菜單上的一道 “菜”，而表項中的函數指針就是制作這道菜的 “菜譜”，內核通過查找這個 “菜單”，就能找到對應的 “菜譜” 來執行系統調用 。
在 x86 架構的 Linux 系統中，系統調用表通常定義在arch/x86/entry/syscall_64.c文件中 。例如，在 64 位 x86 架構下，系統調用表的定義可能如下：
asmlinkage const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {
[0 ... __NR_syscall_max] = &sys_ni_syscall,
#include <asm/syscalls_64.h>
};這里，sys_call_table就是系統調用表，__NR_syscall_max表示系統調用的最大編號 。在初始化時，所有的表項都被初始化為指向sys_ni_syscall函數，sys_ni_syscall是一個未實現系統調用的默認處理函數 。然后，通過編譯時腳本，會將實際的系統調用處理函數填充到對應的表項中 。
每個系統調用都有一個唯一的系統調用號，這個系統調用號就像是 “菜單” 上菜品的編號 。當內核接收到系統調用請求時，會根據系統調用號作為索引，在系統調用表中查找對應的函數指針 。例如，如果接收到的系統調用號是__NR_write（在 x86_64 架構中，__NR_write的值通常為 1），內核就會通過sys_call_table[__NR_write]找到sys_write函數的指針，并調用sys_write函數來執行write系統調用 。通過這種方式，內核能夠快速準確地找到并執行用戶程序請求的系統調用服務 。
七、系統調用與庫函數的關系
7.1庫函數對系統調用的封裝
在 Linux 系統中，大多數系統調用是通過 C 標準庫函數進行封裝的 。C 標準庫為程序員提供了一系列方便易用的函數接口，這些函數在內部通過調用系統調用來實現底層的功能 。以文件操作相關的函數為例，fopen、fread、fwrite、fclose等函數都是 C 標準庫提供的文件操作接口 。當我們使用fopen函數打開一個文件時，fopen函數內部會調用open系統調用，完成文件的打開操作，并返回一個FILE指針，用于后續的文件讀寫操作 。
同樣，fread函數用于從文件中讀取數據，它會在內部調用read系統調用，將數據從文件中讀取到用戶空間的緩沖區中 。fwrite函數用于向文件寫入數據，它會調用write系統調用，將用戶空間緩沖區中的數據寫入到文件中 。fclose函數用于關閉文件，它會調用close系統調用，釋放文件相關的資源 。通過這些庫函數的封裝，程序員無需直接與系統調用打交道，避免了復雜的系統調用參數設置和底層細節處理，提高了編程的效率和代碼的可讀性 。
7.2兩者的區別與聯系
系統調用和庫函數雖然都用于實現特定的功能，但它們在執行環境、功能、開銷等方面存在明顯的區別 。從執行環境來看，系統調用運行在內核態，它可以直接訪問硬件資源和執行特權指令，因為系統調用涉及到對硬件資源的訪問或特權操作，需要在內核態下才能執行 。而庫函數運行在用戶態，它只能執行一些受限的操作，不能直接訪問硬件資源和執行特權指令 。這就好比一個是工廠里的高級管理人員（內核態），可以直接調配各種資源和下達重要指令；另一個是普通員工（用戶態），只能在規定的權限范圍內工作 。
在功能方面，系統調用提供了對操作系統底層功能的訪問，如文件操作、進程控制、內存管理、設備控制等，這些功能直接與操作系統內核相關 。而庫函數則提供了更高級的功能和抽象，它們通常是對系統調用的封裝和擴展，以提供更方便、更易用的接口 。比如fopen函數相比open系統調用，不僅完成了文件的打開操作，還提供了文件流的概念，方便進行格式化讀寫等操作 。
在開銷方面，由于系統調用需要進行從用戶態到內核態的上下文切換，涉及到保存當前進程的狀態、加載新的內核狀態、執行內核代碼、再切換回用戶態等過程，所以開銷相對較大 。而庫函數調用屬于普通的函數調用，在用戶態執行，不涉及上下文切換，開銷相對較小 。這就像從普通員工（用戶態）到高級管理人員（內核態）的身份轉變需要經過一系列復雜的手續（上下文切換），而普通員工之間的協作（庫函數調用）則相對簡單 。
雖然系統調用和庫函數存在上述區別，但它們之間也有著密切的聯系 。庫函數通常是對系統調用的封裝，通過庫函數，程序員可以更方便地使用系統調用提供的功能 。同時，系統調用是庫函數實現其功能的基礎，許多庫函數最終都需要通過調用系統調用來完成底層的操作 。它們相互協作，共同為程序員提供了豐富的功能和便捷的編程接口 。
7.3系統調用的開銷與優化
雖然系統調用為用戶程序提供了強大的功能，但它也存在一定的開銷。了解這些開銷產生的原因，對于優化程序性能至關重要。系統調用過程中，最主要的開銷之一來自用戶態與內核態的切換 。當用戶程序發起系統調用時，需要從用戶態切換到內核態，完成系統調用后再切換回用戶態 。在這個過程中，CPU 需要保存當前用戶態的上下文信息，包括寄存器的值、程序計數器的值等，以便在系統調用結束后能夠恢復到原來的狀態繼續執行用戶程序 。然后加載內核態的上下文信息，執行內核代碼，完成系統調用功能 。
這種上下文切換的過程涉及到多個步驟和操作，需要消耗一定的時間和資源 。例如，在 x86 架構中，使用int 0x80指令觸發系統調用時，CPU 需要進行一系列的中斷處理操作，包括保存用戶態的寄存器值、查找中斷向量表、切換到內核態等，這些操作都會帶來一定的開銷 。而在 x86_64 架構中，雖然syscall指令提高了系統調用的效率，但仍然需要進行上下文切換，只是相對int 0x80指令來說，開銷有所降低 。
除了上下文切換的開銷，保存和恢復寄存器及堆棧上下文也是系統調用開銷的一部分 。在上下文切換時，需要保存當前進程的寄存器值和堆棧指針等信息，以便在返回時能夠恢復到原來的狀態 。這些信息的保存和恢復需要進行內存讀寫操作，也會消耗一定的時間 。不同的寄存器可能需要不同的操作來保存和恢復，例如，一些浮點寄存器（如 FPU、MMX、SSE、AVX 等）的數據量較大，保存和恢復這些寄存器的狀態可能會增加幾 KB 的數據，特別是 AVX 寄存器，AVX2 有 512 字節，AVX - 512 有 2KB，這么大的數據量在上下文切換時還需要讀寫內存，這里的內存讀寫延遲（加上讀寫寄存器）引入的開銷是比較大的 。
雖然現在存在 “延遲狀態加載（lazy state load）” 這樣的機制，當 FPU、MMX、SSE、AVX 寄存器沒有加載數據時，能夠避免加載其中的部分或者全部寄存器數據，從而一定程度上降低開銷 。但如果幾乎所有的任務都使用了這些寄存器狀態信息，那么延遲狀態加載的邏輯反而會變成累贅，增大開銷 。因為上下文切換過程中 “按需加載寄存器的判斷、執行邏輯” 的開銷，可能會超出直接加載這些寄存器數據的開銷 。
針對系統調用的開銷，我們可以采取一些優化方法來提高程序的性能：
減少系統調用次數是一種常見的優化策略。由于系統調用的開銷相對較大，減少系統調用的次數可以顯著降低程序的運行時間。例如，在文件操作中，如果需要頻繁地讀取文件的小數據塊，可以一次性讀取較大的數據塊到內存緩沖區中，然后在用戶態對緩沖區中的數據進行處理，而不是每次都調用read系統調用。在進行網絡通信時，也可以將多個小的網絡請求合并成一個大的請求，減少send和recv系統調用的次數。比如，在一個網絡傳輸的場景中，原本每次發送10 字節的數據，需要調用10 次send系統調用，現在將數據合并成100 字節，只需要調用1 次send系統調用，這樣就大大減少了系統調用的開銷。
批量處理數據也是一種有效的優化方法 。許多系統調用支持批量操作，通過一次系統調用處理多個數據項，可以減少系統調用的次數 。例如，writev和readv系統調用可以在一次操作中寫入或讀取多個緩沖區的數據 。在處理大量文件描述符時，可以使用epoll機制來實現對多個文件描述符的高效管理，通過一次epoll_wait系統調用可以同時監聽多個文件描述符的事件，而不是對每個文件描述符都進行單獨的select或poll系統調用 。以文件傳輸為例，如果要將多個文件的數據發送到網絡上，使用writev系統調用可以將多個文件的數據一次性發送出去，而不需要分別對每個文件調用write系統調用，提高了傳輸效率 。
使用內存映射（mmap）也是一種優化系統調用開銷的方法 。mmap 函數可以將文件或設備的內容映射到進程的地址空間中，使得進程可以直接訪問文件內容，而不需要通過 read 和write 系統調用 。這種方式減少了數據在用戶空間和內核空間之間的拷貝次數，提高了數據訪問的效率 。例如，在處理大型文件時，使用mmap將文件映射到內存中，程序可以像訪問內存一樣直接訪問文件內容，避免了頻繁的系統調用和數據拷貝 。在實現進程間共享內存時，也可以使用mmap來創建共享內存區域，多個進程可以通過映射同一個共享內存區域來實現數據的共享和通信 。
八、實際應用案例
8.1文件操作案例
下面是一個使用open、read、write、close等系統調用進行文件讀寫的示例代碼，通過這個案例，我們可以更直觀地了解這些系統調用的實際應用 。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#define FILE_PATH "example.txt"
#define BUFFER_SIZE 1024
int main() {
int file_descriptor;
ssize_t bytes_read, bytes_written;
char buffer[BUFFER_SIZE];
char *content = "This is some sample content to write to the file.";
// 打開文件，如果文件不存在則創建，權限為可讀可寫
file_descriptor = open(FILE_PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
if (file_descriptor == -1) {
perror("Error opening file");
return 1;
}
// 寫入文件
bytes_written = write(file_descriptor, content, strlen(content));
if (bytes_written == -1) {
perror("Error writing to file");
close(file_descriptor);
return 1;
}
printf("Wrote %zd bytes to the file.\n", bytes_written);
// 將文件指針移動到文件開頭，準備讀取文件
if (lseek(file_descriptor, 0, SEEK_SET) == -1) {
perror("Error seeking to the beginning of the file");
close(file_descriptor);
return 1;
}
// 讀取文件內容
bytes_read = read(file_descriptor, buffer, BUFFER_SIZE - 1);
if (bytes_read == -1) {
perror("Error reading from file");
close(file_descriptor);
return 1;
}
buffer[bytes_read] = '\0'; // 添加字符串結束符
printf("Read from file:\n%s\n", buffer);
// 關閉文件
if (close(file_descriptor) == -1) {
perror("Error closing file");
return 1;
}
return 0;
}這段代碼實現了以下功能：
- 文件打開：使用open系統調用打開名為 “example.txt” 的文件 。O_RDWR參數表示以讀寫模式打開文件，O_CREAT參數表示如果文件不存在則創建它 。S_IRUSR | S_IWUSR設置文件的權限為用戶可讀可寫 。如果open調用失敗，會打印錯誤信息并退出程序 。
- 文件寫入：使用write系統調用將content字符串寫入文件 。write函數的第一個參數是文件描述符，第二個參數是要寫入的數據緩沖區，第三個參數是要寫入的字節數 。如果寫入成功，會打印寫入的字節數；如果失敗，會打印錯誤信息并關閉文件后退出程序 。
- 文件讀取：在寫入文件后，使用lseek系統調用將文件指針移動到文件開頭，以便從文件開頭讀取數據 。然后使用read系統調用從文件中讀取數據到buffer緩沖區 。read函數的第一個參數是文件描述符，第二個參數是用于存儲讀取數據的緩沖區，第三個參數是要讀取的最大字節數 。讀取完成后，在緩沖區末尾添加字符串結束符'\0'，并打印讀取到的文件內容 。如果讀取失敗，會打印錯誤信息并關閉文件后退出程序 。
- 文件關閉：最后，使用close 系統調用關閉文件，釋放文件描述符和相關資源 。如果關閉失敗，會打印錯誤信息 。
通過這個案例，我們可以看到open、read、write、close等系統調用在文件操作中的具體使用方法，以及如何處理可能出現的錯誤 。
8.2進程控制案例
接下來，我們通過一個展示使用fork、exec、wait等系統調用創建子進程、執行新程序和等待子進程結束的示例代碼，深入理解這些系統調用在進程控制中的作用 。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
pid_t pid;
int status;
// 創建子進程
pid = fork();
if (pid < 0) {
perror("fork error");
exit(EXIT_FAILURE);
} else if (pid == 0) {
// 子進程
char *args[] = {"/bin/ls", "-l", NULL};
if (execvp(args[0], args) == -1) {
perror("execvp error");
exit(EXIT_FAILURE);
}
} else {
// 父進程
printf("Parent process, waiting for child to finish...\n");
if (wait(&status) == -1) {
perror("wait error");
exit(EXIT_FAILURE);
}
if (WIFEXITED(status)) {
printf("Child process exited normally with status %d\n", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
printf("Child process was terminated by signal %d\n", WTERMSIG(status));
}
}
return 0;
}代碼執行過程如下：
- 創建子進程：使用fork系統調用創建一個子進程 。fork函數會返回兩次，一次在父進程中，返回值是子進程的 PID；一次在子進程中，返回值是 0 。如果fork調用失敗，會打印錯誤信息并退出程序 。
- 子進程執行新程序：在子進程中（pid == 0的分支），使用execvp系統調用執行/bin/ls -l命令 。execvp函數會用新程序（這里是ls命令）替換子進程的代碼和數據 。如果execvp調用失敗，會打印錯誤信息并退出子進程 。
- 父進程等待子進程結束：在父進程中（pid > 0的分支），使用wait系統調用等待子進程結束 。wait函數會阻塞父進程，直到它的一個子進程結束 。當子進程結束后，wait函數返回，通過WIFEXITED和WEXITSTATUS宏判斷子進程是否正常退出，并獲取其退出狀態；通過WIFSIGNALED和WTERMSIG宏判斷子進程是否被信號終止，并獲取終止信號 。
在這個案例中，fork系統調用用于創建新的進程，使得系統能夠同時運行多個任務 。exec系列系統調用（這里使用的是execvp）用于在子進程中執行新的程序，實現了程序的替換和執行 。wait系統調用用于父進程等待子進程的結束，以便父進程能夠獲取子進程的執行結果，進行后續的處理 。這些系統調用相互配合，實現了進程的創建、執行和管理，是 Linux 系統多進程編程的基礎 。
