一、關於系統調用

linux 裏面的每個系統調用是靠一些宏，一張系統調用表，一個系統調用入口來完成的。

函數

1.宏

就是_syscallN(type,name,x...) 其中N是系統調用所需的參數數目，type是返回類型，name即面向用戶的系統調用函數名，x...是調用參數，個數即爲N。

例如：

#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
 type name(type1 arg1,type2 arg2,type3 arg3) \
 { \
 long __res; \
 __asm__ volatile ("int $0x80" \
 : "=a" (__res) \
 : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
 "d" ((long)(arg3))); \
 if (__res>=0) \
 return (type) __res; \
 errno=-__res; \
 return -1; \
 }

（這是2.0.33版本）這些宏定義於include\asm\Unistd.h。該文件中還以__NR_name的形式定義了164個常數，這些常數就是系統調用函數name的函數指針在系統調用表中的偏移量。

2.系統調用表

這個表按系統調用號（即前面提到的__NR_name）排列了所有系統調用函數的指針，以供系統調用入口函數查找。從這張表看得出，linux給它所支持的系統調用函數取名叫sys_name。

3.系統調用入口函數

ENTRY(system_call)
 pushl %eax # save orig_eax
 SAVE_ALL
 #ifdef __SMP__
 ENTER_KERNEL
 #endif
 movl $-ENOSYS,EAX(%esp)
 cmpl $(NR_syscalls),%eax
 jae ret_from_sys_call
 movl SYMBOL_NAME(sys_call_table)(,%eax,4),%eax
 testl %eax,%eax
 je ret_from_sys_call
 #ifdef __SMP__
 GET_PROCESSOR_OFFSET(%edx)
 movl SYMBOL_NAME(current_set)(,%edx),%ebx
 #else
 movl SYMBOL_NAME(current_set),%ebx
 #endif
 andl $~CF_MASK,EFLAGS(%esp)
 movl %db6,%edx
 movl %edx,dbgreg6(%ebx)
 testb $0x20,flags(%ebx) 
 jne 1f
 call *%eax
 movl %eax,EAX(%esp) 
 jmp ret_from_sys_call

這段代碼現保存所有的寄存器值，然後檢查調用號（__NR_name）是否合法（在系統調用表中查找），找到正確的函數指針後，就調用該函數（即你真正希望內核幫你運行的函數）。運行返回後，將調用ret_from_sys_call，這裏就是著名的進程調度時機之一。

當在程序代碼中用到系統調用時，編譯器會將上面提到的宏展開，展開後的代碼實際上是將系統調用號放入ax後移用int 0x80使處理器轉向系統調用入口，然後查找系統調用表，進而由內核調用真正的功能函數。

二、Linux下C語言嵌入彙編

A :Intel和AT&T彙編語法差異

1。前綴：

Intel彙編寄存器和立即數無需前綴。而AT&T則寄存器前綴爲%，立即數前綴爲$。
eg：
  Intex Syntax
   mov eax,1
   mov ebx,0ffh
   int 80h
  AT&T Syntax
   movl $1,%eax
   movl $0xff,%ebx
   int   $0x80

2。二者對操作數處理方向不同：

eg：
  Intel 彙編語法：
   instr dest,source
   mov eax,[ecx]
  AT&T 彙編語法：
   instr   source,dest
   movl (%ecx),%eax

3。內存變量語法差異：

Intel語法使用中括號[]，後者使用小括號()
eg：
  Intex Syntax
   mov eax,[ebx]
   mov eax,[ebx+3]
  AT&T Syntax
   movl (%ebx),%eax
   movl 3(%ebx),%eax

4。後綴：

AT&T彙編指令有後綴，以表明數據類型（8位、16位等）；Intel則根據寄存器自動識別。
eg：
   Intel Syntax
   mov al,bl
   mov ax,bx
   mov eax,ebx
   mov eax, dword ptr [ebx]
  AT&T Syntax
   movb %bl,%al
   movw %bx,%ax
   movl %ebx,%eax
   movl (%ebx),%eax

5。變址尋址的計算方法

Intel：segreg:[base+index*scale+disp]
AT&T： %segreg:disp(base,index,scale).
例子：

#include <stdio.h>
         int main(void) {
             long eax=4;
             long ebx=2;
             __asm__ __volatile__ ("addl %1, %0"
                    : "=b"((long)ebx)
                     : "a"((long)eax), "b"((long)ebx)
                   : "1"
                   );
            printf("ebx=%d\n", ebx);
            return 0;
         }

輸出結果：ebx=6

B：linux下c語言內嵌彙編格式：

__asm__("<asm routine>" : output : input : modify);
output, input, modify都是引號括起來的字符串，他們直接用冒號分隔，每個都可以有多項，項之間用逗號分隔，最多總共不能超過10個，output要用“=”開頭。

C：寄存器縮寫約定

Abbrev Register
a   %eax/%ax/%al
b   %ebx/%bx/%bl
c   %ecx/%cx/%cl
d   %edx/%dx/%dl
S   %esi/%si
D   %edi/%di
m   memory
q 由編譯器在a、b、c、d中任意選擇
寄存器還可以使用數字形式的縮寫，0～9 (%0-%9)，所以會有最多10個項的限制。
系統調用：
1。系統調用號存在eax中
2。系統調用參數要少於6個，分別存放在ebx, ecx, edx, esi, edi
3。返回值存在eax中
4。參數超過5個，用ebx指向存放參數的內存。如果壓入堆棧，要注意參數順序反過來。
彙編文件入口：
如果使用gcc編譯，入口爲main；如果用as和ld編譯連接，入口使用_start，可以用ld的-e選項指定程序入口：ld -e main -o hello hello.o。
彙編程序運行時出現segmentation fault：
程序運行完時，處理器試圖去執行下一個內存單元的指令，內存中沒有指令或者爲非法指令，硬件或者os包含機制就會發現
這個異常而產生段包含錯誤。解決方法，加上退出程序的系統調用就可以了。
eg：
       1 #.include "defines.h"
       2 .data
       3 hello:
       4 .string "hello world\n"
       5
       6 .globl   main
       7 main:
       8 #write
       9 movl     $4,%eax
      10 #stdout
      11 movl     $1,%ebx
      12 #content
      13 movl     $hello,%ecx
      14 #length of string
      15 movl     $12,%edx
      16 #system call
      17 int      $0x80
      18
      19 #exit
      20 movl     $1,%eax
      21 int      $0x80
      22
      23 ret
//------------------------------------------------------------------------------------------------------------------------
// 詳細說明：
//------------------------------------------------------------------------------------------------------------------------

D:內嵌彙編舉例

在內嵌彙編中，可以將C語言表達式指定爲彙編指令的操作數，而且不用去管如何將C語言表達式的值讀入哪個寄存器，以及如何將計算結果寫回C變量，你只要告訴程序中C語言表達式與彙編指令操作數之間的對應關係即可， GCC會自動插入代碼完成必要的操作。使用內嵌彙編，要先編寫彙編指令模板，然後將C語言表達式與指令的操作數相關聯，並告訴GCC對這些操作有哪些限制條件。例如在下面的彙編語句：

__asm__ __violate__(
 "movl %1,%0" 
 : "=r" (result) 
 : "m" (input)
 );

其中“movl %1,%0”是指令模板；“%0”和“%1”代表指令的操作數，稱爲佔位符，內嵌彙編靠它們將C語言表達式與指令操作數相對應。指令模板後面用小括號括起來的是C語言表達式也即我們通常所說的變量，本例中只有兩個：“result”和“input”，他們按照出現的順序分別與指令操作數 “%0”，“%1，”對應；注意對應順序：第一個C表達式對應“%0”；第二個表達式對應“%1”，依次類推，操作數至多有10個，分別用 “%0”，“%1”….“%9，”表示。在每個操作數前面有一個用引號括起來的字符串，字符串的內容是對該操作數的限制或者說要求。“result”前面的限制字符串是“=r”，其中“=”表示“result”是輸出操作數，“r”表示需要將“result”與某個通用寄存器相關聯，先將操作數的值讀入寄存器，然後在指令中使用相應寄存器，而不是“result”本身，當然指令執行完後需要將寄存器中的值存入變量“result”，從表面上看好像是指令直接對“result”進行操作，實際上GCC做了隱式處理，這樣我們可以少寫一些指令。“input”前面的“r”表示該表達式需要先放入某個寄存器，然後在指令中使用該寄存器參加運算。
我們將上面的內嵌代碼放到一個C源文件中，然後使用gcc –c–S得到該C文件源代碼相對應的彙編代碼，然後查看一下彙編代碼，看看GCC是如何處理的。
C源文件如下內容如下，注意該代碼沒有實際意義，僅僅作爲例子。

extern int
 input,result;
 void test(void)
 {
 input= 1;
 __asm__ __volatile__ ("movl %1,%0" :
 "=r" (result) : "r" (input));
 return;
 }

對應的彙編代碼如下;
行號          代碼                 解釋
1
7
8               movl $1, input     對應C語言語句input = 1;
9               movl input, %eax
10 #APP GCC插入的註釋，表示內嵌彙編開始
11             movl %eax,%eax       我們的內嵌彙編語句
12 #NO_APP GCC 插入的註釋，表示內嵌彙編結束
13             movl %eax, result      將結果存入result變量
從彙編代碼可以看出，第9行和第13行是GCC，自動增加的代碼，GCC根據限定字符串決定如何處理C表達式，本例兩個表達式都被指定爲“r”型，所以先使用指令：
movl input, %eax將input讀入寄存器%eax；GCC，也指定一個寄存器與輸出變量result相關，本例也是%eax，等得到操作結果後再使用指令：
movl %eax, result將寄存器的值寫回C變量result中。
從上面的彙編代碼我們可以看出與result和input，相關連的寄存器都是%eax，GCC使用%eax，替換內嵌彙編指令模板中的%0，%1 。movl %eax,%eax顯然這一句可以不要。但是沒有優化，所以這一句沒有被去掉。
由此可見，C表達式或者變量與寄存器的關係由GCC自動處理，我們只需使用限制字符串指導GCC如何處理即可。限制字符必須與指令對操作數的要求相匹配，否則產生的彙編代碼將會有錯，讀者可以將上例中的兩個“r”，都改爲“m”(m，表示操作數放在內存，而不是寄存器中)，編譯後得到的結果是：movl input, result 很明顯這是一條非法指令，因此限制字符串必須與指令對操作數的要求匹配。例如指令movl允許寄存器到寄存器，立即數到寄存器等，但是不允許內存到內存的操作，因此兩個操作數不能同時使用“m”作爲限定字符。

1 語法

內嵌彙編語法如下：
__asm__(
彙編語句模板:
輸出部分:
輸入部分:
破壞描述部分)
共四個部分：彙編語句模板，輸出部分，輸入部分，破壞描述部分，各部分使用“:”格開，彙編語句模板必不可少，其他三部分可選，如果使用了後面的部分，而前面部分爲空，也需要用“:”格開，相應部分內容爲空。例如：
__asm__ __volatile__(
"CLI":
:"memory")

彙編語句模板

彙編語句模板由彙編語句序列組成，語句之間使用“;”、“\n”或“\n\t”分開。指令中的操作數可以使用佔位符引用C語言變量，操作數佔位符最多10 個，名稱如下：%0，%1…，%9。指令中使用佔位符表示的操作數，總被視爲long型（4個字節），但對其施加的操作根據指令可以是字或者字節，當把操作數當作字或者字節使用時，默認爲低字或者低字節。對字節操作可以顯式的指明是低字節還是次字節。方法是在%和序號之間插入一個字母，“b”代表低字節，“h”代表高字節，例如：%h1。

輸出部分

輸出部分描述輸出操作數，不同的操作數描述符之間用逗號格開，每個操作數描述符由限定字符串和C語言變量組成。每個輸出操作數的限定字符串必須包含“=”表示他是一個輸出操作數。
例：
__asm__ __volatile__(
"pushfl ;
popl %0 ;
cli"
:"=g" (x)
)
描述符字符串表示對該變量的限制條件，這樣GCC就可以根據這些條件決定如何分配寄存器，如何產生必要的代碼處理指令操作數與C表達式或C變量之間的聯繫。

輸入部分

輸入部分描述輸入操作數，不同的操作數描述符之間使用逗號格開，每個操作數描述符由限定字符串和C語言表達式或者C語言變量組成。
例1：
__asm__ __volatile__ (
"lidt %0"
:
: "m" (real_mode_idt)
);
例二（bitops.h）：
Static __inline__ void __set_bit(int nr, volatile void * addr)
{
__asm__(
"btsl%1,%0" :
"=m"(ADDR) :
"Ir"(nr));
}
後例功能是將(*addr)的第nr位設爲1。第一個佔位符%0與C語言變量ADDR對應，第二個佔位符%1與C語言變量nr對應。因此上面的彙編語句代碼與下面的僞代碼等價：
btsl nr, ADDR，
該指令的兩個操作數不能全是內存變量，因此將nr的限定字符串指定爲“Ir”，將nr，與立即數或者寄存器相關聯，這樣兩個操作數中只有ADDR爲內存變量。

限制字符

限制字符列表

限制字符有很多種，有些是與特定體系結構相關，此處僅列出常用的限定字符和i386中可能用到的一些常用的限定符。它們的作用是指示編譯器如何處理其後的C語言變量與指令操作數之間的關係，例如是將變量放在寄存器中還是放在內存中等，下表列出了常用的限定字母。
分類限定符描述通用寄存器
“a”將輸入變量放入eax
這裏有一個問題：假設eax已經被使用，那怎麼辦？
其實很簡單：因爲GCC知道eax已經被使用，它在這段彙編代碼的起始處插入一條語句pushl %eax，將eax內容保存到堆棧，然後在這段代碼結束處再增加一條語句popl %eax，恢復eax的內容
“b”將輸入變量放入ebx
“c”將輸入變量放入ecx
“d”將輸入變量放入edx
“s”將輸入變量放入esi
“d”將輸入變量放入edi
“q”將輸入變量放入eax，ebx ,ecx ，edx中的一個
“r”將輸入變量放入通用寄存器，也就是eax ，ebx，ecx,edx，esi，edi中的一個
“A”把eax和edx，合成一個64位的寄存器(uselong longs)
“m”內存變量
“o”操作數爲內存變量，但是其尋址方式是偏移量類型，也即是基址尋址，或者是基址加變址尋址
“V”操作數爲內存變量，但尋址方式不是偏移量類型
“,” 操作數爲內存變量，但尋址方式爲自動增量
“p”操作數是一個合法的內存地址（指針）
寄存器或內存
“g” 將輸入變量放入eax，ebx，ecx ，edx中的一個或者作爲內存變量
“X”操作數可以是任何類型
立即數
“I” 0-31 之間的立即數（用於32位移位指令）
“J” 0-63 之間的立即數（用於64 位移位指令）
“N” 0-255 ，之間的立即數（用於out 指令）
“i” 立即數
“n” 立即數，有些系統不支持除字以外的立即數，這些系統應該使用“n”而不是“i”
匹配
“0”，“1 ，”... “9 ”
表示用它限制的操作數與某個指定的操作數匹配，也即該操作數就是指定的那個操作數，例如用“0 ”去描述“％1”操作數，那麼“%1”引用的其實就是“%0”操作數，注意作爲限定符字母的0－9 ，與指令中的“％0”－“％9”的區別，前者描述操作數，後者代表操作數。
後面有詳細描述 & 該輸出操作數不能使用過和輸入操作數相同的寄存器後面有詳細描述
操作數類型
“=” 操作數在指令中是隻寫的（輸出操作數）
“+” 操作數在指令中是讀寫類型的（輸入輸出操作數）
浮點數
“f” 浮點寄存器“t”第一個浮點寄存器“u”第二個浮點寄存器“G”標準的80387浮點常數% 該操作數可以和下一個操作數交換位置例如addl的兩個操作數可以交換順序（當然兩個操作數都不能是立即數）# 部分註釋，從該字符到其後的逗號之間所有字母被忽略* 表示如果選用寄存器，則其後的字母被忽略現在繼續看上面的例子，"=m" (ADDR)表示ADDR爲內存變量（“m”），而且是輸出變量（“=”）；"Ir" (nr)表示nr，爲0－31之間的立即數（“I”）或者一個寄存器操作數（“r”）。

匹配限制符

I386
指令集中許多指令的操作數是讀寫型的（讀寫型操作數指先讀取原來的值然後參加運算，最後將結果寫回操作數），例如addl %1,%0，它的作用是將操作數%0與操作數%1的和存入操作數%0，因此操作數%0是讀寫型操作數。老版本的GCC對這種類型操作數的支持不是很好，它將操作數嚴格分爲輸入和輸出兩種，分別放在輸入部分和輸出部分，而沒有一個單獨部分描述讀寫型操作數，因此在GCC中讀寫型的操作數需要在輸入和輸出部分分別描述，靠匹配限制符將兩者關聯到一起注意僅在輸入和輸出部分使用相同的C變量，但是不用匹配限制符，產生的代碼很可能不對，後面會分析原因。匹配限制符是一位數字：“0”、“1”……“9，”，分別表示它限制的C表達式分別與佔位符%0，%1，……%9對應的C變量匹配.
例如使用“0”作爲%1，的限制字符，那麼%0和％1表示同一個C，變量。看一下下面的代碼就知道爲什麼要將讀寫型操作數，分別在輸入和輸出部分加以描述。該例功能是求input+result的和，然後存入result：
extern int input,result;
void test_at_t()
{
result= 0;
input = 1;
__asm__
__volatile__ ("addl %1,%0":"=r"(result): "r"(input));
}
對應的彙編代碼爲：
movl $0,_result
movl $1,_input
movl _input,%edx /APP
addl %edx,%eax /NO_APP
movl %eax,%edx
movl %edx,_result
input 爲輸入型變量，而且需要放在寄存器中，GCC給它分配的寄存器是%edx，在執行addl之前%edx，的內容已經是input的值。可見對於使用“r” 限制的輸入型變量或者表達式，在使用之前GCC會插入必要的代碼將他們的值讀到寄存器；“m”型變量則不需要這一步。讀入input後執行addl，顯然%eax的值不對，需要先讀入result的值纔行。再往後看：movl %eax,%edx和movl %edx,_result的作用是將結果存回result，分配給result的寄存器與分配給input的一樣，都是%edx。
綜上可以總結出如下幾點：
1. 使用“r”限制的輸入變量，GCC先分配一個寄存器，然後將值讀入寄存器，最後用該寄存器替換佔位符；
2. 使用“r”限制的輸出變量，GCC會分配一個寄存器，然後用該寄存器替換佔位符，但是在使用該寄存器之前並不將變量值先讀入寄存器，GCC認爲所有輸出變量以前的值都沒有用處，不讀入寄存器（可能是因爲AT&T彙編源於CISC架構處理器的彙編語言，在CISC處理器中大部分指令的輸入輸出明顯分開，而不像RISC那樣一個操作數既做輸入又做輸出，例如add r0,r1,r2，r0，和r1是輸入，r2是輸出，輸入和輸出分開，沒有使用輸入輸出型操作數，這樣我們就可以認爲r2對應的操作數原來的值沒有用處，也就沒有必要先將操作數的值讀入r2，因爲這是浪費處理器的CPU週期），最後GCC插入代碼，將寄存器的值寫回變量；
3. 輸入變量使用的寄存器在最後一處使用它的指令之後，就可以挪做其他用處，因爲已經不再使用。例如上例中的%edx。在執行完addl之後就作爲與result對應的寄存器。
因爲第二條，上面的內嵌彙編指令不能奏效，因此需要在執行addl之前把result的值讀入寄存器，也許再將result放入輸入部分就可以了（因爲第一條會保證將result先讀入寄存器）。修改後的指令如下（爲了更容易說明問題將input限制符由“r，”改爲“m”）：
extern int input,result;
void test_at_t()
{
result = 0;
input = 1;
__asm__
__volatile__ ("addl %2,%0":"=r"(result):"r"(result),"m"(input));
}
看上去上面的代碼可以正常工作，因爲我們知道%0和%1都和result相關，應該使用同一個寄存器，但是GCC並不去判斷%0和%1，是否和同一個C表達式或變量相關聯（這樣易於產生與內嵌彙編相應的彙編代碼），因此%0和%1使用的寄存器可能不同。我們看一下彙編代碼就知道了。
movl $0,_result
movl $1,_input
movl _result,%edx /APP
addl _input,%eax /NO_APP
movl %eax,%edx
movl %edx,_result
現在在執行addl之前將result的值被讀入了寄存器%edx，但是addl指令的操作數%0卻成了%eax，而不是%edx，與預料的不同，這是因爲 GCC給輸出和輸入部分的變量分配了不同的寄存器，GCC沒有去判斷兩者是否都與result相關，後面會講GCC如何翻譯內嵌彙編，看完之後就不會驚奇啦。
使用匹配限制符後，GCC知道應將對應的操作數放在同一個位置（同一個寄存器或者同一個內存變量）。使用匹配限制字符的代碼如下：
extern int input,result;
void test_at_t()
{
result = 0;
input = 1;
__asm__
__volatile__ ("addl %2,%0":"=r"(result):"0"(result),"m"(input));
}
輸入部分中的result用匹配限制符“0”限制，表示%1與％0，代表同一個變量，輸入部分說明該變量的輸入功能，輸出部分說明該變量的輸出功能，兩者結合表示result是讀寫型。因爲%0和%1，表示同一個C變量，所以放在相同的位置，無論是寄存器還是內存。
相應的彙編代碼爲：
movl $0,_result
movl $1,_input
movl _result,%edx
movl %edx,%eax /APP
addl _input,%eax /NO_APP
movl %eax,%edx
movl %edx,_result
可以看到與result相關的寄存器是%edx，在執行指令addl之前先從%edx將result讀入%eax，執行之後需要將結果從%eax讀入%edx，最後存入result中。這裏我們可以看出GCC處理內嵌彙編中輸出操作數的一點點信息：addl並沒有使用%edx，可見它不是簡單的用 result對應的寄存器%edx去替換%0，而是先分配一個寄存器，執行運算，最後纔將運算結果存入對應的變量，因此GCC是先看該佔位符對應的變量的限制符，發現是一個輸出型寄存器變量，就爲它分配一個寄存器，此時沒有去管對應的C變量，最後GCC，知道還要將寄存器的值寫回變量，與此同時，它發現該變量與%edx關聯，因此先存入%edx，再存入變量。
至此讀者應該明白了匹配限制符的意義和用法。在新版本的GCC中增加了一個限制字符“+”，它表示操作數是讀寫型的，GCC知道應將變量值先讀入寄存器，然後計算，最後寫回變量，而無需在輸入部分再去描述該變量。
例;
extern int input,result;
void test_at_t()
{
result = 0;
input = 1;
__asm__
__volatile__ ("addl %1,%0":"+r"(result):"m"(input));
}
此處用“+”替換了“=”，而且去掉了輸入部分關於result的描述，產生的彙編代碼如下：
movl $0,_result
movl $1,_input
movl _result,%eax /APP
addl _input,%eax /NO_APP
movl %eax,_result
L2:
movl %ebp,%esp
處理的比使用匹配限制符的情況還要好，省去了好幾條彙編代碼。

“&”限制符

限制符“&”在內核中使用的比較多，它表示輸入和輸出操作數不能使用相同的寄存器，這樣可以避免很多錯誤。
舉一個例子，下面代碼的作用是將函數foo的返回值存入變量ret中
__asm__ ( “call foo;movl %%edx,%1”, :”=a”(ret) : ”r”(bar) );
我們知道函數的int型返回值存放在%eax中，但是gcc編譯的結果是輸入和輸出同時使用了寄存器%eax，如下：
movl bar, %eax
#APP
call foo
movl %ebx,%eax
#NO_APP
movl %eax, ret
結果顯然不對，原因是GCC並不知道%eax中的值是我們所要的。避免這種情況的方法是使用“&”限定符，這樣bar就不會再使用%eax寄存器，因爲已被ret指定使用。
_asm__ ( “call foo;movl %%edx,%1”,:”=&a”(ret) : ”r”(bar) );

Linux 系統調用的實現及其彙編代碼的嵌入到C中