linux26內核編程指導實例

㈠ 嵌入式系統linux內核開發實戰指南的目錄

第1部分 嵌入式系統硬體開發
第1章 嵌入式系統概述 2
這一章對嵌入式系統的概念及其特點和應用作了概括介紹，筆者根據自己多年的經驗闡述了對嵌入式系統的理解，並對一些常見的嵌入式處理器的硬體數據進行了比較。
1.1 嵌入式系統概念 2
1.2 嵌入式處理器 3
1.3 嵌入式系統應用 4
1.4 嵌入式系統發展 4
1.5 一些嵌入式處理器的硬體特性比較 5
第2章 ARM處理器概述 16
為了使本書內容完整，從第2章到第7章中的內容大部分是筆者閱讀《ARM體系結構與編程》（詳情參見附錄中的參考文獻）的筆記和心得，把與嵌入式系統開發和Linux內核密切相關的硬體知識進行了概括和整理，本章主要介紹了ARM處理器的特點、ARM處理器的體系架構版本和ARM處理器系列。
2.1 ARM發展歷程 16
2.2 ARM處理器特點 17
2.3 ARM處理器應用 17
2.4 ARM體系架構 18
2.4.1 ARM體系架構版本 18
2.4.2 ARM體系架構變種（Variant） 20
2.4.3 ARM體系架構版本命名格式 22
2.5 ARM處理器 22
2.5.1 ARM7系列處理器 23
2.5.2 ARM9系列處理器 24
2.5.3 ARM9E系列處理器 24
2.5.4 ARM10E系列處理器 25
2.5.5 SecurCore系列處理器 25
2.5.6 StrongARM處理器 26
2.5.7 Xscale處理器 26
第3章 ARM指令及其定址方式 27
本章主要介紹了ARM處理器的指令和定址方式以及ARM匯編偽指令，這是做ARM處理器應用系統底層軟體開發必備的知識。
3.1 ARM處理器的程序狀態寄存器（PSR） 27
3.2 ARM指令的條件碼 28
3.3 ARM指令介紹 29
3.3.1 跳轉指令 29
3.3.2 數據處理指令 30
3.3.3 乘法指令 31
3.3.4 雜類算術指令 32
3.3.5 狀態寄存器訪問指令 32
3.3.6 Load/Store內存訪問指令 33
3.3.7 批量Load/Store內存訪問指令 34
3.3.8 LDREX和STREX指令 35
3.3.9 信號量操作指令 37
3.3.10 異常中斷產生指令 37
3.3.11 ARM協處理器指令 37
3.4 ARM指令定址方式 39
3.4.1 數據處理指令的操作數的定址方式 39
3.4.2 字及無符號位元組的Load/Store指令的定址方式 43
3.4.3 雜類Load/Store指令的定址方式 47
3.4.4 批量Load/Store指令的定址方式 49
3.4.5 協處理器Load/Store指令的定址方式 51
3.4.6 ARM指令的定址方式總結 52
3.5 ARM匯編偽操作（Directive） 53
3.5.1 符號定義偽操作 54
3.5.2 數據定義偽操作 54
3.5.3 匯編控制偽操作 56
3.5.4 棧中數據幀描述偽操作 57
3.5.5 信息報告偽操作 57
3.5.6 其他偽操作 58
3.6 ARM匯編偽指令 59
3.7 Thumb指令介紹 60
第4章 ARM處理器內存管理單元（MMU） 61
本章主要介紹了ARM處理器內存管理單元（MMU）的工作原理，Linux內存管理功能是通過處理器硬體MMU實現的，在沒有MMU的處理器系統中，Linux只能工作在物理地址模式，沒有虛擬（線性）地址空間的概念。
4.1 ARM處理器中CP15協處理器的寄存器 61
4.1.1 訪問CP15寄存器的指令 61
4.1.2 CP15寄存器介紹 62
4.2 MMU簡介 70
4.3 系統訪問存儲空間的過程 71
4.3.1 使能MMU時的情況 71
4.3.2 禁止MMU時的情況 71
4.3.3 使能/禁止MMU時應注意的問題 72
4.4 ARM處理器地址變換過程 72
4.4.1 MMU的一級映射描述符 73
4.4.2 MMU的二級映射描述符 74
4.4.3 基於段的地址變換過程 75
4.4.4 粗粒度大頁地址變換過程 75
4.4.5 粗粒度小頁地址變換過程 76
4.4.6 細粒度大頁地址變換過程 76
4.4.7 細粒度小頁地址變換過程 77
4.4.8 細粒度極小頁地址變換過程 77
4.5 ARM存儲空間訪問許可權控制 78
4.6 TLB操作 79
4.6.1 使TLB內容無效 79
4.6.2 鎖定TLB內容 79
4.6.3 解除TLB中被鎖定的地址變換條目 80
4.7 存儲訪問失效 80
4.7.1 MMU失效（MMU Fault） 80
4.7.2 外部存儲訪問失效（External Abort） 81
第5章 ARM處理器的Cache和Write Buffer 82
本章主要介紹了ARM處理器高速緩存（Cache）和寫緩存（Write Buffer）的工作原理，使讀者了解如何提高處理器的性能。
5.1 Cache和Write Buffer一般性介紹 82
5.1.1 Cache工作原理 82
5.1.2 地址映像方式 83
5.1.3 Cache寫入方式原理簡介 84
5.1.4 關於Write-through和Write-back 85
5.1.5 Cache替換策略 86
5.1.6 使用Cache的必要性 87
5.1.7 使用Cache的可行性 87
5.2 ARM處理器中的Cache和Write Buffer 88
5.2.1 基本概念 88
5.2.2 Cache工作原理 88
5.2.3 Cache地址映射和變換方法 89
5.2.4 Cache分類 90
5.2.5 Cache替換演算法 91
5.2.6 Cache內容鎖定 91
5.2.7 MMU映射描述符中B位和C位的含義 92
5.2.8 Cache和Writer Buffer編程介面 93
5.3 ARM處理器的快速上下文切換技術 94
5.3.1 FCSE概述 94
5.3.2 FCSE原理 94
5.3.3 FCSE編程介面 95
第6章 ARM處理器存儲訪問一致性問題 97
本章介紹了在支持MMU、Cache和DMA的系統中可能出現的存儲訪問一致性問題，以及Linux中解決類似問題的方法。
6.1 存儲訪問一致性問題介紹 97
6.1.1 地址映射關系變化造成的數據不一致性 97
6.1.2 指令cache的數據不一致性問題 98
6.1.3 DMA造成的數據不一致問題 99
6.1.4 指令預取和自修改代碼 99
6.2 Linux中解決存儲訪問一致性問題的方法 99
第7章 ARM處理器工作模式與異常中斷處理 101
本章主要介紹了ARM處理器的工作模式和異常中斷處理過程，這是ARM處理器系統啟動程序編寫者或Bootloader開發人員的必備知識。
7.1 ARM處理器工作模式 101
7.2 ARM處理器異常中斷向量表和優先順序 103
7.3 ARM處理器異常中斷處理 104
7.3.1 進入異常中斷處理 104
7.3.2 退出異常中斷處理 105
7.4 ARM處理器的中斷（IRQ或FIQ） 109
第8章 ARM處理器啟動過程 110
本章根據筆者的開發經驗介紹了ARM處理器系統的啟動過程以及編寫ARM處理器系統啟動程序需要注意的事項。
8.1 ARM處理器上電/復位操作 110
8.2 ARM處理器系統初始化過程 111
8.3 ARM處理器系統初始化編程注意事項 111
第9章 嵌入式系統設計與調試 113
本章根據筆者10多年的開發經驗介紹了嵌入式系統的設計流程和調試方法，列舉了大量筆者工作中碰到的實際案例。本章內容對於嵌入式系統硬體開發和調試有較高的參考、指導價值。
9.1 嵌入式系統設計流程 113
9.2 嵌入式系統硬體原理設計與審核 114
9.3 硬體設計工具軟體 117
9.4 嵌入式系統調試模擬工具 117
9.5 嵌入式系統調試診斷方法 118
第10章 自製簡易JTAG下載燒寫工具 123
本章根據筆者自己製作簡易JTAG線纜的經驗，介紹了簡易JTAG線纜的硬體原理和軟體流程，這是初學者必備的最廉價的工具，必須掌握。
10.1 JTAG簡介 123
10.1.1 一些基本概念 124
10.1.2 JTAG介面信號 124
10.1.3 TAP控制器的狀態機 125
10.1.4 JTAG介面指令集 129
10.2 簡易JTAG線纜原理 130
10.2.1 PC並口定義 130
10.2.2 PC並口的寄存器 131
10.2.3 簡易JTAG線纜原理圖 133
10.2.4 簡易JTAG線纜燒寫連接圖（見圖10-5） 134
10.3 簡易JTAG燒寫代碼分析 135
10.3.1 簡易JTAG燒寫程序（flashp）使用說明 135
10.3.2 flash與CPU連接及flash屬性描述文件 136
10.3.3 簡易JTAG燒寫程序的執行邏輯和流程 138
第2部分 Linux內核開發初步
第11章 Bootloader 142
本章根據筆者的工作經驗介紹了流行的幾種Bootloader、Bootloader應該具備的基本功能以及Bootloader的裁剪與移植。
11.1 Bootloader的任務和作用 142
11.2 各種各樣的Bootloader 143
11.3 Bootloader編譯環境 144
11.4 Bootloader的移植與裁減 145
11.5 編譯Bootloader 145
11.6 燒寫Bootloader 146
11.7 Bootloader使用舉例 148
11.8 Bootloader修改舉例 149
第12章 創建嵌入式Linux開發環境 151
本章介紹了如何創建嵌入式系統Linux內核交叉開發環境，本章和後續3章的內容是嵌入式系統Linux內核開發的基礎，必須掌握。
12.1 安裝Linux host 151
12.2 在虛擬機中安裝Linux host 152
12.3 安裝Linux交叉編譯環境 157
12.4 在主機上設置TFTP Server 160
12.5 在主機上設置DHCP Server 161
12.6 在主機上設置Telnet server 161
12.7 在開發過程中使用NFS 162
12.8 設置超級終端 163
第13章 編譯Linux內核 166
本章介紹了Linux內核的配置和編譯方法。
13.1 獲取Linux內核源代碼 166
13.2 Linux內核目錄結構 166
13.3 配置Linux內核 167
13.4 編譯Linux內核 168
第14章 創建Linux根文件系統 170
本章介紹了Linux的根文件系統的結構以及創建根文件系統的方法。
14.1 根文件系統概述 170
14.2 根文件系統目錄結構 171
14.3 獲取根文件系統組件源代碼 171
14.4 編譯根文件系統源代碼 171
14.5 創建一個32MB的RAMDISK根文件系統 173
14.6 在根文件系統中添加驅動模塊或者應用程序 173
第15章 固化Linux內核和根文件系統 174
本章介紹了固化（燒寫）Linux內核和根文件系統的方法。
第16章 關於Clinux 176
本章簡要介紹了Clinux與標准Linux的區別。
16.1 Clinux簡介 176
16.2 Clinux源代碼目錄結構 177
16.3 Clinux與標准Linux的區別 178
16.4 編譯Clinux 179
第3部分 Linux 2.6內核原理
第17章 Linux 2.6.10@ARM啟動過程 182
本章以start_kernel()和init()函數中調用到的函數說明的方式，介紹了從Linux匯編代碼入口到init內核進程最後調用用戶空間init命令的Linux整個啟動過程。本章內容是筆者第一次閱讀Linux內核源代碼時對這些函數的注釋，僅供讀者了解start_kernel()和init()函數中調用到的每個函數的大致功能時使用。
17.1 Linux 2.6.10中與ARM處理器平台硬體相關的結構和全局變數 182
17.1.1 相關數據結構 182
17.1.2 相關全局變數 187
17.2 Linux匯編代碼入口 189
17.3 Linux匯編入口處CPU的狀態 189
17.4 start_kernel()函數之前的匯編代碼執行過程 190
17.5 start_kernel()函數中調用的函數介紹 192
17.5.1 lock_kernel()函數 192
17.5.2 page_address_init()函數 192
17.5.3 printk(linux_banner) 193
17.5.4 setup_arch(&command_line)函數 193
17.5.5 setup_per_cpu_areas()函數 198
17.5.6 smp_prepare_boot_cpu()函數 199
17.5.7 sched_init()函數 199
17.5.8 build_all_zonelists()函數 200
17.5.9 page_alloc_init()函數 200
17.5.10 printk(Kernel command line: %s , saved_command_line) 201
17.5.11 parse_early_param()函數 201
17.5.12 parse_args()函數 201
17.5.13 sort_main_extable()函數 202
17.5.14 trap_init()函數 202
17.5.15 rcu_init()函數 202
17.5.16 init_IRQ()函數 203
17.5.17 pidhash_init()函數 203
17.5.18 init_timers()函數 203
17.5.19 softirq_init()函數 204
17.5.20 time_init()函數 204
17.5.21 console_init()函數 205
17.5.22 profile_init()函數 206
17.5.23 local_irq_enable()函數 207
17.5.24 vfs_caches_init_early()函數 207
17.5.25 mem_init()函數 208
17.5.26 kmem_cache_init()函數 210
17.5.27 numa_policy_init()函數 225
17.5.28 calibrate_delay()函數 227
17.5.29 pidmap_init()函數 228
17.5.30 pgtable_cache_init()函數 229
17.5.31 prio_tree_init()函數 229
17.5.32 anon_vma_init()函數 229
17.5.33 fork_init(num_physpages)函數 229
17.5.34 proc_caches_init()函數 230
17.5.35 buffer_init()函數 231
17.5.36 unnamed_dev_init()函數 231
17.5.37 security_init()函數 231
17.5.38 vfs_caches_init(num_physpages)函數 232
17.5.39 radix_tree_init()函數 237
17.5.40 signals_init()函數 237
17.5.41 page_writeback_init()函數 237
17.5.42 proc_root_init()函數 238
17.5.43 check_bugs()函數 240
17.5.44 acpi_early_init()函數 244
17.5.45 rest_init()函數 244
17.6 init()進程執行過程 265
17.6.1 smp_prepare_cpus(max_cpus)函數 265
17.6.2 do_pre_smp_initcalls()函數 265
17.6.3 fixup_cpu_present_map()函數 267
17.6.4 smp_init()函數 267
17.6.5 sched_init_smp()函數 268
17.6.6 populate_rootfs()函數 268
17.6.7 do_basic_setup()函數 283
17.6.8 sys_access()函數 292
17.6.9 free_initmem()函數 301
17.6.10 unlock_kernel()函數 301
17.6.11 numa_default_policy()函數 302
17.6.12 sys_p()函數 302
17.6.13 execve()函數 302
第18章 Linux內存管理 305
從本章開始，筆者將帶領讀者走進神秘的Linux內核世界。筆者在閱讀內核源代碼以及兩本相關參考書（見參考文獻）的基礎上，以自己的理解和語言總結概括了Linux內核每個組件的原理。筆者對與每個內核組件相關的關鍵數據結構和全局變數作了盡量詳盡的說明，並且對核心函數進行了詳細注釋，在向讀者灌輸理論知識的同時引導讀者自己去閱讀、分析Linux內核源代碼。本章講解了Linux內核第一大核心組件「內存管理」的原理和實現內幕。
18.1 Linux內存管理概述 305
18.1.1 Linux內存管理的一些基本概念 305
18.1.2 內存管理相關數據結構 309
18.1.3 內存管理相關宏和全局變數 330
18.1.4 Linux內存管理的任務 341
18.1.5 Linux中的物理和虛擬存儲空間布局 341
18.2 為虛擬（線性地址）存儲空間建立頁表 345
18.3 設置存儲空間的訪問控制屬性 348
18.4 Linux中的內存分配和釋放 350
18.4.1 在系統啟動初期申請內存 350
18.4.2 系統啟動之後的內存分配與釋放 360
第19章 Linux進程管理 480
本章講解了Linux內核第二大核心組件「進程管理」的原理和實現內幕。
19.1 進程管理概述 480
19.1.1 進程相關概念 480
19.1.2 進程分類 481
19.1.3 0號進程 481
19.1.4 1號進程 481
19.1.5 其他一些內核線程 482
19.1.6 進程描述符（struct task_struct） 482
19.1.7 進程狀態 482
19.1.8 進程標識符（PID） 483
19.1.9 current宏定義 484
19.1.10 進程鏈表 484
19.1.11 PID hash表和鏈表 485
19.1.12 硬體上下文（Hardware Context） 485
19.1.13 進程資源限制 485
19.1.14 進程管理相關數據結構 486
19.1.15 進程管理相關宏定義 502
19.1.16 進程管理相關全局變數 514
19.2 進程管理相關初始化 520
19.3 進程創建與刪除 529
19.4 進程調度 551
19.4.1 進程類型 553
19.4.2 進程調度類型 554
19.4.3 基本時間片計算方法 555
19.4.4 動態優先順序演算法 556
19.4.5 互動式進程 556
19.4.6 普通進程調度 557
19.4.7 實時進程調度 557
19.4.8 進程調度函數分析 558
19.5 進程切換 576
19.6 用戶態進程間通信 581
19.6.1 信號（Signal） 581
19.6.2 管道（pipe）和FIFO（命名管道） 627
19.6.3 進程間通信原語（System V IPC） 641
第20章 Linux文件管理 651
本章講解了Linux內核第三大核心組件「文件系統」的原理和實現內幕。
20.1 文件系統概述 651
20.1.1 Linux文件管理相關概念 652
20.1.2 Linux文件管理相關數據結構 657
20.1.3 Linux文件管理相關宏定義 682
20.1.4 Linux文件管理相關全局變數 691
20.2 文件管理相關初始化 699
20.3 文件系統類型注冊 711
20.4 掛接文件系統 712
20.5 文件系統類型超級塊讀取 730
20.5.1 get_sb_single()通用超級塊讀取函數 731
20.5.2 get_sb_nodev()通用超級塊讀取函數 737
20.5.3 get_sb_bdev()通用超級塊讀取函數 738
20.5.4 get_sb_pseudo()通用超級塊讀取函數 740
20.6 路徑名查找 747
20.7 訪問文件操作 759
20.7.1 打開文件 759
20.7.2 關閉文件 766
20.7.3 讀文件 768
20.7.4 寫文件 785
20.8 非同步I/O系統調用 792
20.9 Linux特殊文件系統 792
20.9.1 rootfs文件系統 793
20.9.2 sysfs文件系統 797
20.9.3 devfs設備文件系統 800
20.9.4 bdev塊設備文件系統 803
20.9.5 ramfs文件系統 804
20.9.6 proc文件系統 804
20.10 磁碟文件系統 813
20.10.1 ext2文件系統相關數據結構 813
20.10.2 ext2文件系統磁碟分區格式 819
20.10.3 ext2文件系統的各種文件 820
20.10.4 創建ext2文件系統 821
20.10.5 ext2文件系統的操作方法 822
20.11 關於initramfs 824
20.11.1 initramfs概述 824
20.11.2 initramfs與initrd的區別 824
20.11.3 initramfs相關全局變數 825
20.11.4 initramfs被編譯鏈接的位置 825
20.11.5 initramfs文件的生成過程 825
20.11.6 initramfs二進制文件格式說明（cpio格式） 828
20.11.7 initramfs二進制文件和列表文件對照示例 829
20.11.8 initramfs利弊 830
20.12 關於initrd 830
20.12.1 initrd概述 830
20.12.2 initrd相關全局變數 831
20.13 關於gzip壓縮文件 832
第21章 Linux模塊設計 834
本章講解了Linux內核模塊程序與應用程序的區別以及如何編寫和載入Linux內核模塊程序。
21.1 Linux模塊設計概述 834
21.2 Linux的內核空間和用戶空間 834
21.3 內核模塊與應用程序的區別 835
21.4 編譯模塊 837
21.5 裝載和卸載模塊 837
21.6 模塊層疊 838
21.7 模塊版本依賴 839
21.8 模塊編程示例 839
第22章 Linux系統異常中斷管理 841
本章講解了Linux內核如何管理系統異常中斷以及Linux系統調用的實現內幕。
22.1 Linux異常中斷處理 841
22.2 指令預取和數據訪問中止異常中斷處理 849
22.2.1 指令預取中止異常中斷處理 850
22.2.2 數據訪問中止異常中斷處理 858
22.3 Linux中斷處理 863
22.3.1 內核模式下的中斷處理 863
22.3.2 用戶模式下的中斷處理 867
22.4 從中斷返回 868
22.5 Linux中斷管理 869
22.5.1 Linux中斷管理相關數據結構與全局變數 870
22.5.2 Linux中斷管理初始化 872
22.5.3 安裝和卸載中斷處理程序 874
22.5.4 使能和禁止中斷 878
22.6 Linux系統調用 880
22.6.1 Linux系統調用內核實現過程 880
22.6.2 從系統調用返回 889
22.6.3 Linux系統調用用戶程序介面函數 890
22.6.4 Linux系統調用用戶介面函數與內核實現函數之間參數傳遞 899
第23章 Linux軟中斷和工作隊列 901
本章講解了Linux內核中的兩種延遲處理機制「軟中斷」和「工作隊列」的原理和實現。
23.1 概述 901
23.2 Linux軟中斷 902
23.2.1 軟中斷相關數據結構和全局變數 903
23.2.2 軟中斷初始化 904
23.2.3 軟中斷的核心操作函數do_softirq() 908
23.2.4 軟中斷看護進程執行函數ksoftirqd() 912
23.2.5 如何使用軟中斷 913
23.3 Linux工作隊列 918
23.3.1 Linux工作隊列相關數據結構和全局變數 918
23.3.2 Linux工作隊列初始化 921
23.3.3 將工作加入到工作隊列中 924
23.3.4 工作者進程執行函數worker_thread() 928
23.3.5 使用Linux工作隊列 931
第24章 Linux並發與競態 933
本章講解了Linux內核同步機制，包括幾種鎖定技術以及免鎖演算法。
24.1 並發與競態概述 933
24.1.1 Linux中的並發源 934
24.1.2 競態可能導致的後果 934
24.1.3 避免競態的規則 934
24.2 消除競態的「鎖定」技術 935
24.2.1 信號量（semphore）和互斥體（mutual exclusion） 935
24.2.2 讀寫信號量（rw_semaphore） 938
24.2.3 完成量（completion） 941
24.2.4 自旋鎖（spinlock_t） 942
24.2.5 讀寫自旋鎖（rwlock_t） 946
24.2.6 使用「鎖定」技術的注意事項 949
24.3 消除競態的非「鎖定」方法 949
24.3.1 免鎖演算法 949
24.3.2 原子操作 950
24.3.3 位操作 951
24.3.4 順序鎖 952
24.3.5 讀-復制-更新（Read-Copy-Update，RCU） 954
第25章 Linux設備驅動程序 958
本章講解了Linux內核第四大核心組件「設備驅動」的原理和實現內幕。同時還總結歸納了編寫各種設備驅動程序的方法和步驟。
25.1 設備驅動程序概述 958
25.1.1 設備驅動程序組成部分 959
25.1.2 設備號 959
25.1.3 設備文件 960
25.1.4 編寫設備驅動程序的關鍵 961
25.2 字元設備驅動程序 961
25.2.1 字元設備相關數據結構 961
25.2.2 字元設備相關全局變數 963
25.2.3 字元設備驅動程序全局初始化 963
25.2.4 為字元設備分配設備號 964
25.2.5 注冊字元設備驅動程序 968
25.2.6 字元設備的操作方法 971
25.2.7 用戶對字元設備驅動程序的調用過程 972
25.2.8 如何編寫字元設備驅動程序 974
25.2.9 關於TTY設備驅動程序 974
25.2.10 控制台設備驅動程序 975
25.3 塊設備驅動程序 986
25.3.1 塊設備相關數據結構 986
25.3.2 塊設備相關宏定義 997
25.3.3 塊設備相關全局變數 999
25.3.4 塊設備驅動程序全局初始化 1004
25.3.5 為塊設備分配主設備號 1006
25.3.6 注冊塊設備驅動程序 1009
25.3.7 塊設備驅動程序的操作方法 1017
25.3.8 調用塊設備驅動程序過程 1017
25.3.9 I/O調度 1031
25.3.10 如何編寫塊設備驅動程序 1032
25.4 網路設備驅動程序 1033
25.4.1 網路設備驅動程序概述 1033
25.4.2 網路設備相關數據結構 1034
25.4.3 網路設備相關宏定義 1044
25.4.4 網路設備相關全局變數 1045
25.4.5 創建net_device結構 1046
25.4.6 注冊網路設備 1048
25.4.7 網路設備的操作方法 1050
25.4.8 網路設備中斷服務程序 1051
25.4.9 如何編寫網路設備驅動程序 1051
25.5 PCI設備驅動程序 1052
25.5.1 PCI介面定義 1053
25.5.2 PCI設備的三個地址空間 1057
25.5.3 PCI匯流排仲裁 1058
25.5.4 PCI設備編號 1059
25.5.5 如何訪問PCI配置空間 1059
25.5.6 如何配置PCI設備 1061
25.5.7 PCI驅動程序相關數據結構 1062
25.5.8 PCI驅動程序相關宏定義 1068
25.5.9 PCI驅動程序相關全局變數 1068
25.5.10 Bootloader和內核做的事 1069
25.5.11 PCI驅動程序注冊 1069
25.5.12 PCI驅動程序介面函數 1071
25.5.13 如何編寫PCI驅動程序 1072
第4部分 Linux內核開發高級指南
第26章 Linux系統參數設置 1076
從本章開始的後續章節主要講解了比較高級或者平時較少關注的Linux內核方面的知識，本章講解了Linux中的4種系統參數格式和設置方法。
26.1 旗語系統參數（tag） 1076
26.1.1 與旗語系統參數相關數據結構和全局變數 1076
26.1.2 旗語系統參數說明 1082
26.1.3 旗語系統參數設置方法 1084
26.2 前期命令行設置的系統參數 1084
26.2.1 與前期命令行系統參數相關數據結構和全局變數 1084
26.2.2 前期命令行設置的系統參數說明 1085
26.2.3 前期命令行系統參數設置方法 1086
26.2.4 如何添加自己的前期命令行設置的系統參數 1087
26.3 老式命令行系統參數 1087
26.3.1 與老式命令行系統參數相關數據結構和全局變數 1087
26.3.2 老式命令行設置的系統參數說明 1088
26.3.3 老式命令行設置的系統參數設置方法 1089
26.3.4 如何添加自己的老式命令行設置的系統參數 1089
26.4 命令行系統參數 1089
26.4.1 與命令行系統參數相關數據結構和全局變數 1089
26.4.2 命令行設置的系統參數說明 1090
26.4.3 命令行設置的系統參數設置方法 1090
第27章 Linux內核調試 1091
本章介紹了Linux內核的調試方法。
27.1 打開Linux內核及其各模塊自帶的調試開關 1091
27.2 內核剖析（Profiling） 1093
27.3 通過列印調試（printk） 1095
27.3.1 關於printk() 1095
27.3.2 內核信息級別 1096
27.3.3 列印速度限制 1097
27.3.4 控制台重定向 1098
27.4 使用proc文件系統調試 1098
27.5 oops消息 1098
27.6 通過跟蹤命令strace調試 1099
27.7 使用gdb、kdb、kgdb調試 1099
第28章 Linux內核移植 1101
本章介紹了Linux內核的移植方法。
第29章 Linux內核優化 1104
本章介紹了Linux內核的優化方法。
29.1 編譯優化 1104
29.2 根據CPU特性進行優化 1105
29.3 對內核進行裁減 1105
29.4 優化系統內存配置 1106
29.5 優化系統啟動過程以縮減系統啟動時間 1106
29.6 內存映射優化 1107
29.7 工具軟體輔助優化 1107
第30章 Linux定時器 1109
本章介紹了Linux內核的軟體定時器。
30.1 定時器相關數據結構 1109
30.2 定時器相關宏定義 1111
30.3 定時器相關全局變數 1112
30.4 定時器和時鍾初始化 1113
30.5 獲取系統時間 1114
30.6 延遲函數 1115
30.7 與定時器相關系統調用 1115
30.8 使用定時器方法 1116
第31章 雜項 1117
本章介紹了PER_CPU變數以及Linux中的數據類型定義。
31.1 per_cpu變數 1117
31.2 Linux中的數據類型定義 1118
第32章 編譯鏈接文件說明 1119
本章注釋了ARM處理器系統中Linux內核的鏈接文件，以幫助讀者了解編譯出來的Linux內核各區段在內存中的存放位置。
參考文獻 1125

㈡ 嵌入式Linux程序設計案例與實驗教程的目錄

前言
教學建議
第1章LiFlUX開發基礎
1．1Linux系統概述
1．1．1Linux簡介
1．1．2Linux系統的特點
1．1．3Linux系統的組成
1．2Linux系統的使用
實驗1．1熟悉Linux基本命令與文件目錄系統
1．3全屏幕編輯器與vi
1．3．1vi簡介
1．3．2基本命令
1．3．3常用操作
實驗1．2全屏幕編輯器vi的使用
1．4LinuxS11ell編程
1．4．1Shell程序的編寫和執行
1．4．2Shell的變數
1．4．3Shell的測試命令
1．4．4條件語句
1．4．5循環語句
1．4．6函數
實驗1．3Shell腳本編程實驗
第2章嵌入式Linux系統基礎
2．1構建嵌入式Linux系統環境
2．1．1交叉編譯
2．1．2交叉編譯器
2．1．3NFS
實驗2．1嵌入式Linux開發環境的建立
2．2Linuxc程序設計
2．2．1C程序設計概述
2．2．2Makefile介紹
2．2．3Makefile中的變數
2．2．4Makefile隱含規則
實驗2．2Makefite與helloworld
2．3Linux多線程庫編程
2．3．1多線程
2．3．2Linux下的多線程
2．3．3生產者-消費者模型簡述
2．3．4緩沖區操作概述
2．3．5幾個線程API
實驗2．3Linux多線程使用實例生產者-消費者協議
2．4進程創建以及進程間通信
2．4．1進程概述
2．4．2進程的相關函數
2．4．3信號概述
2．4．4信號的相關函數
2．4．5管道概述
2．4．6管道的相關函數
實驗2．4進程相關的應用程序設計
綜合實驗一嵌入式平台的進程管理模擬實驗
第3章嵌入式Linux內核、引導系統和文件系統
3．1Linux內核定製、裁剪和添加
3．1．1概述
3．1．2內核目錄簡介
3．1．3配置文件和配置工具
3．1．4內核的編譯命令
實驗3．1Linux內核裁剪與編譯
3．2嵌入式引導系統技術
3．2．1概述
3．2．2Linux的引導系統vivi與ubOOt
3．3文件系統的構建
3．3．1概述
3．3．2BusyBox
綜合實驗二軟盤Linux操作系統的實現
第4章嵌入式Liflux介面設計與驅動程序
4．1驅動程序設計基礎
4．1．1Linux驅動程序簡介
4．1．2開發驅動程序的方法
4．1．3設備驅動程序的分類
4．1．4主設備號和次設備號
4．1．5設備文件系統(devfs)與Udevfs
實驗4．1虛擬驅動模塊實驗
4．2AD介面驅動程序
4．2．1AD轉換器
4．2．2AD轉換有關參數
4．2．3ARM自帶的AD轉換裝置
實驗4．2AD介面驅動程序
4．3直流電機驅動
4．3．1直流電機介紹
4．3．2直流電機的PWM原理
4．3．3PWMTIMER結構
4．3．4基於ARM的PWM相關寄存器
4．3．5關於程序實現
實驗4．3直流電機PWM驅動實驗
4．4觸摸屏介面設計與驅動
4．4．1觸摸屏的工作原理
4．4．2觸摸屏驅動晶元ADS7843
4．4．3S3C2410晶元的觸摸屏相關配置寄存器
實驗4．4tslib移植和使用
4．5顯示介面與LinuxFrameBuffer
4．5．1FrameBuffer機制介紹
4．5．2LCD簡介
實驗4．5FrameBuffer實驗
4．6V4L程序設計
4．6．1V4L概述
4．6．2V4L設備的體系結構
實驗4．6Linux視頻V4L驅動實驗
4．7OSS程序設計
4．7．1oSS概述
4．7．2OSS設備的體系結構
4．7．30SS驅動分析
4．7．4OSS用戶空間編程
實驗4．7Linux音頻OSS驅動實驗
綜合實驗三五子棋游戲的實現
第5章嵌入式Linux開源軟體移植與應用
5．1嵌入式WebServerGoAhead的移植與應用
5．1．1嵌入式web伺服器
5．1．2GoAhead介紹
5．1．3GoAhead在ARM平台上的移植
5．1．4頁面操作
實驗5．1嵌入式WebServerGoAhead實驗
5．2嵌入式WebServicegSOAP的移植與應用
5．2．1gSOAP介紹
5．2．2gSOAP裁剪
5．2．3gSOAP應用
實驗5．2WebServicegSOAP實驗
5．3嵌入式資料庫SQLite的移植與使用
5．3．1嵌入式資料庫
5．3．2SQLite介紹
5．3．3SQLite在ARM平台上的移植
5．3．4SQLite的使用
實驗5．3SQLite移植實驗
5．4播放器Mplayer的移植
5．4．1Mplayer介紹
5．4．2Mplayer在ARM平台上的移植
實驗5．4Mplayer到ARM平台上的移植
5．5ffmpeg應用：
5．5．1ffmpeg簡介
5．5．2ffmpeg在ARM上的移植
5．5．3ffmpeg命令應用實例
5．5．4ffmpeg中幾個重要的數據結構
5．5．5ffmpeg應用開發
實驗5．5ffmpeg移植與應用
5．6開源軟體移植的一般過程
5．6．1軟體移植的概念
5．6．2軟體移植過程
5．7JIME—phoneME移植
5．7．1phoneME簡介
5．7．2軟體移植過程與效果
5．8嵌入式瀏覽器konqueror移植
5．8．1konqueror簡介
5．8．2軟體移植過程與效果
綜合實驗四基於WebServiee的嵌入式計算器
第6章嵌入式Linux圖形用戶界面
6．1嵌入式GUI簡介
6．1．1嵌入式GUI的特點
6．1．2嵌入式GUI的種類
6．2嵌入式GUI—Qt
6．2．1Qt與Qt/Embedded簡介
6．2．2Qt的特點
6．2．3Qt的執行過程
6．2．4Qt的插槽機制
6．2．5一個完整的Qt程序
6．2．6QtDesigner介紹
實驗6．1Qt圖形界面相關實驗
6．3基於Qt技術的Qtopia
6．3．1Qtopia簡介
6．3．2Qtopia的功能
6．3．3Qtopia編程
實驗6．2Qtopia的移植以及編程
綜合實驗五電子點菜系統
第7章嵌入式Unux下的通信應用
7．1嵌入式Linux下的串口通信
7．1．1串口簡介
7．1．2串口編程
7．1．3串口編程應用實例
實驗7．1串口通信實驗
7．2嵌入式Linux網路編程
7．2．1網路通信
7．2．2Socket簡介
7．2．3網路編程
實驗7．2Socket相關程序設計
7．3嵌入式藍牙技術
7．3．1藍牙技術
7．3．2藍牙體系結構
7．3．3藍牙通信網路
7．3．4LinuxBluetooth軟體層
7．3．5USB適配器
實驗7．3藍牙相關實驗
7．4CAN匯流排
7．4．1CAN匯流排簡介
7．4．2CAN匯流排硬體特徵
7．4．3CAN控制器驅動
實驗7．4CAN匯流排實驗
第8章嵌入式系統硬體設計基礎與標准
8．1嵌入式系統的硬體組成
8．1．1嵌入式微處理器
8．1．2存儲器
8．1．3輸入/輸出設備
8．1．4通信與擴展介面
8．2硬體設計基礎知識
8．2．1計算機體系結構
8．2．2電子技術
8．2．3抗干擾技術
8．2．4印製電路板
8．3硬體設計中應注意的一些問題
8．3．1IC元件的選擇
8．3．2元件封裝設計
8．3．3PCB設計精度
8．3．4分離元件的正確使用
8．3．5高速PCB設計方法
8．3．6PCB設計的一般原則
實驗8．1常用模擬電路和數字電路原理
實驗8．22410—S電路原理圖閱讀
實驗8．32410—S所用晶元數據手冊閱讀
實驗8．4OMAP5910核心板電路原理
綜合實驗六基於OMAP的加密終端硬體設計
第9章OMAP5910與LinuxGateway
9．1OMAP5910體系結構
9．1．1MPU子系統
9．1．2DSP子系統
9．2LinuxDSPGateway
9．2．1DSPGateway的由來
9．2．2DSPGateway的Mailbox機制
9．2．3通信緩沖
9．2．4Mailbox命令協議
9．2．5DSPGateway的設備介面
實驗9．1OMAP910雙核間基本通信
9．3OMAP5910圖像處理
9．3．1圖片格式
9．3．2數字圖像演算法
實驗9．2OMAP圖像處理實驗
綜合實驗七基於OMAP的加密終端的實現(軟體部分)
第10章嵌入式Linux綜合項目實例
10．1基於嵌入式平台的電梯監控系統
10．1．1系統概述
10．1．2系統設計
10．1．3系統實現
10．1．4項目小結
10．2基於藍牙技術的嵌入式點菜系統
10．2．1系統概述
10．2．2系統設計
10．2．3系統實現
10．2．4項目小結
10．3基於WebSenrice的數字油田監控系統
10．3．1系統概述
10．3．2系統設計
10．3．3系統實現
10．3．4項目小結
10．4基於嵌入式與WebService的智能家居系統
10．4．1系統概述
10．4．2系統設計
10．4．3系統實現
10．4．4項目小結
10．5基於OMAP的音頻與視頻處理
10．5．1概述
10．5．2MPEG壓縮
10．5．3音視頻數據在雙處理器間的傳輸模塊設計
10．5．4音頻處理方案設計
10．5．5視頻處理方案設計
10．5．6項目小結
參考文獻
……

㈢ 如何在Linux內核里增加一個系統調用

一、Linux0.11下添加系統調用：x0dx0ax0dx0a我在bochs2.2.1中對linux0.11內核添加了一個新的系統調用，步驟如下： x0dx0a1./usr/src/linux/include/unistd.h中添加：#define __NR_mytest 87 x0dx0a然後在下面聲明函數原型：int mytest(); x0dx0a2./usr/src/linux/include/linux/sys.h中添加:extern int sys_mytest(); x0dx0a然後在sys_call_table中最後加上sys_mytest； x0dx0a3.在/usr/src/linux/kernel/sys.c中添加函數實現如下： x0dx0aint sys_mytest(){ x0dx0aprintk("This is a test!"); x0dx0areturn 123; x0dx0a} x0dx0a4.在/usr/src/linux/kernel/system_call.s中對系統調用號加1（原來是86改成了87） x0dx0a5.然後到/usr/src/linux目錄下編譯內核make clean; make Image x0dx0a6. cp /usr/src/linux/include/unistd.h /usr/include/unistd.h x0dx0a7. reset bochs x0dx0a8. 在/usr/root中生成test.c文件如下： x0dx0a#define __LIBRARY__ x0dx0a#include x0dx0a_syscall0(int,mytest) x0dx0aint main(){ x0dx0aint a; x0dx0aa = mytest(); x0dx0aprintf("%d", a); x0dx0areturn 0; x0dx0a} x0dx0a9.然後gcc test.c編譯之後運行a.out，前面所有步驟都通過，但是每次調用都是返回-1，然後我查過errno為1（表示操作不允許），就不知道為什麼了？ x0dx0a系統知道的高手們能夠告知一下，不勝感激！這個問題困擾我很久了！ x0dx0ax0dx0a二、新Linux內核添加系統調用x0dx0ax0dx0a如何在Linux系統中添加新的系統調用x0dx0a系統調用是應用程序和操作系統內核之間的功能介面。其主要目的是使得用戶可以使用操作系統提供的有關設備管理、輸入/輸入系統、文件系統和進程式控制制、通信以及存儲管理等方面的功能，而不必了解系統程序的內部結構和有關硬體細節，從而起到減輕用戶負擔和保護系統以及提高資源利用率的作用。x0dx0ax0dx0aLinux操作系統作為自由軟體的代表，它優良的性能使得它的應用日益廣泛，不僅得到專業人士的肯定，而且商業化的應用也是如火如荼。在Linux中，大部分的系統調用包含在Linux的libc庫中，通過標準的C函數調用方法可以調用這些系統調用。那麼，對Linux的發燒友來說，如何在Linux中增加新的系統調用呢？ x0dx0a1 Linux系統調用機制x0dx0ax0dx0a在Linux系統中，系統調用是作為一種異常類型實現的。它將執行相應的機器代碼指令來產生異常信號。產生中斷或異常的重要效果是系統自動將用戶態切換為核心態來對它進行處理。這就是說，執行系統調用異常指令時，自動地將系統切換為核心態，並安排異常處理程序的執行。Linux用來實現系統調用異常的實際指令是：x0dx0ax0dx0aInt $0x80x0dx0ax0dx0a這一指令使用中斷/異常向量號128（即16進制的80）將控制權轉移給內核。為達到在使用系統調用時不必用機器指令編程，在標準的C語言庫中為每一系統調用提供了一段短的子程序，完成機器代碼的編程工作。事實上，機器代碼段非常簡短。它所要做的工作只是將送給系統調用的參數載入到CPU寄存器中，接著執行int $0x80指令。然後運行系統調用，系統調用的返回值將送入CPU的一個寄存器中，標準的庫子程序取得這一返回值，並將它送回用戶程序。x0dx0ax0dx0a為使系統調用的執行成為一項簡單的任務，Linux提供了一組預處理宏指令。它們可以用在程序中。這些宏指令取一定的參數，然後擴展為調用指定的系統調用的函數。x0dx0ax0dx0a這些宏指令具有類似下面的名稱格式：x0dx0ax0dx0a_syscallN（parameters）x0dx0ax0dx0a其中N是系統調用所需的參數數目，而parameters則用一組參數代替。這些參數使宏指令完成適合於特定的系統調用的擴展。例如，為了建立調用setuid（）系統調用的函數，應該使用：x0dx0ax0dx0a_syscall1（ int， setuid， uid_t， uid ）x0dx0ax0dx0asyscallN（ ）宏指令的第1個參數int說明產生的函數的返回值的類型是整型，第2個參數setuid說明產生的函數的名稱。後面是系統調用所需要的每個參數。這一宏指令後面還有兩個參數uid_t和uid分別用來指定參數的類型和名稱。x0dx0ax0dx0a另外，用作系統調用的參數的數據類型有一個限制，它們的容量不能超過四個位元組。這是因為執行int $0x80指令進行系統調用時，所有的參數值都存在32位的CPU寄存器中。使用CPU寄存器傳遞參數帶來的另一個限制是可以傳送給系統調用的參數的數目。這個限制是最多可以傳遞5個參數。所以Linux一共定義了6個不同的_syscallN（）宏指令，從_syscall0（）、_syscall1（）直到_syscall5（）。x0dx0ax0dx0a一旦_syscallN（）宏指令用特定系統調用的相應參數進行了擴展，得到的結果是一個與系統調用同名的函數，它可以在用戶程序中執行這一系統調用。x0dx0a2 添加新的系統調用 x0dx0a如果用戶在Linux中添加新的系統調用，應該遵循幾個步驟才能添加成功，下面幾個步驟詳細說明了添加系統調用的相關內容。x0dx0ax0dx0a（1） 添加源代碼x0dx0ax0dx0a第一個任務是編寫加到內核中的源程序，即將要加到一個內核文件中去的一個函數，該函數的名稱應該是新的系統調用名稱前面加上sys_標志。假設新加的系統調用為mycall(int number)，在/usr/src/linux/kernel/sys.c文件中添加源代碼，如下所示：x0dx0aasmlinkage int sys_mycall(int number) x0dx0a{ x0dx0areturn number; x0dx0a}x0dx0a作為一個最簡單的例子，我們新加的系統調用僅僅返回一個整型值。x0dx0ax0dx0a（2） 連接新的系統調用x0dx0ax0dx0a添加新的系統調用後，下一個任務是使Linux內核的其餘部分知道該程序的存在。為了從已有的內核程序中增加到新的函數的連接，需要編輯兩個文件。x0dx0ax0dx0a在我們所用的Linux內核版本（RedHat 6.0，內核為2.2.5-15）中，第一個要修改的文件是：x0dx0ax0dx0a/usr/src/linux/include/asm-i386/unistd.hx0dx0ax0dx0a該文件中包含了系統調用清單，用來給每個系統調用分配一個唯一的號碼。文件中每一行的格式如下：x0dx0ax0dx0a#define __NR_name NNNx0dx0ax0dx0a其中，name用系統調用名稱代替，而NNN則是該系統調用對應的號碼。應該將新的系統調用名稱加到清單的最後，並給它分配號碼序列中下一個可用的系統調用號。我們的系統調用如下：x0dx0ax0dx0a#define __NR_mycall 191x0dx0ax0dx0a系統調用號為191，之所以系統調用號是191，是因為Linux-2.2內核自身的系統調用號碼已經用到190。x0dx0ax0dx0a第二個要修改的文件是：x0dx0ax0dx0a/usr/src/linux/arch/i386/kernel/entry.Sx0dx0ax0dx0a該文件中有類似如下的清單：x0dx0a.long SYMBOL_NAME（）x0dx0ax0dx0a該清單用來對sys_call_table[]數組進行初始化。該數組包含指向內核中每個系統調用的指針。這樣就在數組中增加了新的內核函數的指針。我們在清單最後添加一行：x0dx0a.long SYMBOL_NAME(sys_mycall)x0dx0ax0dx0a（3） 重建新的Linux內核x0dx0ax0dx0a為使新的系統調用生效，需要重建Linux的內核。這需要以超級用戶身份登錄。x0dx0a#pwd x0dx0a/usr/src/linux x0dx0a#x0dx0ax0dx0a超級用戶在當前工作目錄（/usr/src/linux）下，才可以重建內核。x0dx0ax0dx0a#make config x0dx0a#make dep x0dx0a#make clearn x0dx0a#make bzImagex0dx0ax0dx0a編譯完畢後，系統生成一可用於安裝的、壓縮的內核映象文件：x0dx0ax0dx0a/usr/src/linux/arch/i386/boot/bzImage x0dx0a（4） 用新的內核啟動系統 x0dx0a要使用新的系統調用，需要用重建的新內核重新引導系統。為此，需要修改/etc/lilo.conf文件，在我們的系統中，該文件內容如下：x0dx0ax0dx0aboot=/dev/hda x0dx0amap=/boot/map x0dx0ainstall=/boot/boot.b x0dx0aprompt x0dx0atimeout=50 x0dx0ax0dx0aimage=/boot/vmlinuz-2.2.5-15 x0dx0alabel=linux x0dx0aroot=/dev/hdb1 x0dx0a read-only x0dx0ax0dx0aother=/dev/hda1 x0dx0alabel=dos x0dx0atable=/dev/hadx0dx0ax0dx0a首先編輯該文件，添加新的引導內核：x0dx0aimage=/boot/bzImage-new x0dx0alabel=linux-new x0dx0aroot=/dev/hdb1 x0dx0aread-onlyx0dx0ax0dx0a添加完畢，該文件內容如下所示：x0dx0aboot=/dev/hda x0dx0amap=/boot/map x0dx0ainstall=/boot/boot.b x0dx0aprompt x0dx0atimeout=50 x0dx0ax0dx0aimage=/boot/bzImage-new x0dx0alabel=linux-new x0dx0aroot=/dev/hdb1 x0dx0aread-only x0dx0ax0dx0aimage=/boot/vmlinuz-2.2.5-15 x0dx0alabel=linux x0dx0aroot=/dev/hdb1 x0dx0aread-only x0dx0ax0dx0aother=/dev/hda1 x0dx0alabel=dos x0dx0atable=/dev/hdax0dx0ax0dx0a這樣，新的內核映象bzImage-new成為預設的引導內核。為了使用新的lilo.conf配置文件，還應執行下面的命令：x0dx0a#cp /usr/src/linux/arch/i386/boot/zImage /boot/bzImage-newx0dx0ax0dx0a其次配置lilo:x0dx0ax0dx0a# /sbin/lilox0dx0ax0dx0a現在，當重新引導系統時，在boot:提示符後面有三種選擇：linux-new 、linux、dos，新內核成為預設的引導內核。x0dx0a至此，新的Linux內核已經建立，新添加的系統調用已成為操作系統的一部分，重新啟動Linux，用戶就可以在應用程序中使用該系統調用了。x0dx0ax0dx0a（5）使用新的系統調用x0dx0ax0dx0a在應用程序中使用新添加的系統調用mycall。同樣為實驗目的，我們寫了一個簡單的例子xtdy.c。x0dx0ax0dx0a/* xtdy.c */ x0dx0a#include x0dx0a_syscall1(int,mycall,int,ret) x0dx0amain() x0dx0a{ x0dx0aprintf("%d \n",mycall(100)); x0dx0a}x0dx0a編譯該程序：x0dx0a# cc -o xtdy xtdy.cx0dx0a執行：x0dx0a# xtdyx0dx0a結果：x0dx0a# 100x0dx0a注意，由於使用了系統調用，編譯和執行程序時，用戶都應該是超級用戶身份。

㈣ linux內核編譯詳細教程及開發Linux系統

已發送到[email protected]

㈤ Linux C編程從初學到精通的目 錄

第1部分 基礎篇
第1章 Linux系統概述 1
1.1 什麼是Linux 2
1.2 Linux系統特點及主要功能 2
1.2.1 Linux系統特點 3
1.2.2 Linux系統的主要功能 3
1.3 Linux的內核版本和發行版本 5
1.4 系統的安裝 6
1.4.1 系統安裝前的准備工作 6
1.4.2 從光碟安裝Linux 6
1.4.3 從硬碟安裝Linux 22
1.4.4 在虛擬機下安裝Linux 22
1.5 Shell的使用 27
1.5.1 Shell簡介 27
1.5.2 常見Shell的種類 28
1.5.3 Shell的簡單使用 29
1.5.4 通配符 30
1.5.5 引號 31
1.5.6 注釋符 33
1.6 Linux常用命令 33
1.6.1 與目錄相關的命令 33
1.6.2 與文件相關的命令 34
1.6.3 與網路服務相關的命令 35
1.7 本章小結 35
實戰演練 36
第2章 C語言編程基礎 37
2.1 C語言的歷史背景 38
2.2 C語言的特點 38
2.3 C語言的基本數據類型 39
2.3.1 整型 39
2.3.2 實型 40
2.3.3 字元型 41
2.4 運算符與表達式 43
2.4.1 算術運算符與算術表達式 43
2.4.2 賦值運算符與賦值表達式 44
2.4.3 逗號運算符與逗號表達式 45
2.5 C程序的3種基本結構 46
2.5.1 順序結構 46
2.5.2 選擇結構 47
2.5.3 循環結構 51
2.6 C語言中的數據輸入與輸出 54
2.6.1 字元輸出函數putchar 54
2.6.2 字元輸入函數getchar 54
2.6.3 格式輸出函數printf 54
2.6.4 格式輸入函數scanf 56
2.7 函數 57
2.7.1 函數的定義 57
2.7.2 函數的調用 58
2.7.3 變數的存儲類別 59
2.8 數組 62
2.8.1 一維數組的定義和使用 63
2.8.2 二維數組的定義和使用 64
2.8.3 字元數組和字元串 65
2.8.4 常用字元串處理函數 66
2.9 指針 69
2.9.1 地址和指針 69
2.9.2 指針的定義和使用 70
2.9.3 數組與指針 71
2.9.4 字元串與指針 72
2.9.5 指向函數的指針 72
2.10 結構體和共用體 73
2.10.1 定義和引用結構體 73
2.10.2 結構體數組 74
2.10.3 指向結構體的指針 74
2.10.4 共用體 75
2.10.5 使用typedef定義類型 77
2.11 鏈表 77
2.11.1 鏈表概述 77
2.11.2 建立動態單向鏈表 78
2.11.3 單向鏈表的輸出 80
2.11.4 對單向鏈表的刪除操作 80
2.11.5 對單向鏈表的插入操作 81
2.11.6 循環鏈表 82
2.11.7 雙向鏈表 82
2.12 位運算符和位運算 83
2.12.1 「按位與」運算符（&） 84
2.12.2 「按位或」運算符（|） 84
2.12.3 「取反」運算符（~） 84
2.12.4 「異或」運算符（^） 84
2.12.5 移位運算符（<<和>>） 85
2.12.6 位域 85
2.13 C語言預處理命令 86
2.13.1 宏定義 86
2.13.2 文件包含 87
2.13.3 條件編譯 88
2.13.4 #error等其他常用預處理命令 89
2.14 本章小結 89
實戰演練 89
第3章 vi與Emacs編輯器 91
3.1 vi的使用 92
3.1.1 啟動與退出vi 92
3.1.2 vi的命令行模式 93
3.1.3 vi的插入模式 96
3.1.4 vi的底行模式 96
3.2 vi使用實例 97
3.3 Emacs的使用 100
3.3.1 啟動與退出Emacs 101
3.3.2 Emacs下的基本操作 102
3.4 Emacs使用實例 107
3.5 本章小結 109
實戰演練 109
第4章 gcc編譯器與gdb調試器 110
4.1 gcc編譯器簡介 111
4.2 如何使用gcc 112
4.2.1 gcc編譯初步 112
4.2.2 警告提示功能 114
4.2.3 優化gcc 116
4.2.4 連接庫 119
4.2.5 同時編譯多個源程序 120
4.2.6 管道 120
4.2.7 調試選項 121
4.3 gdb調試器 122
4.3.1 gdb簡介 122
4.3.2 gdb常用命令 123
4.3.3 gdb調試初步 124
4.4 gdb的使用詳解 126
4.4.1 調用gdb 127
4.4.2 使用斷點 127
4.4.3 查看運行時數據 129
4.4.4 查看源程序 133
4.4.5 改變程序的執行 135
4.5 xxgdb調試器簡介 138
4.6 本章小結 139
實戰演練 139
第5章 make的使用和Makefile的編寫 141
5.1 什麼是make 142
5.1.1 make機制概述 142
5.1.2 make與Makefile的關系 144
5.2 Makefile的書寫規則 147
5.2.1 Makefile的基本語法規則 148
5.2.2 在規則中使用通配符 149
5.2.3 偽目標 149
5.2.4 多目標 151
5.2.5 自動生成依賴性 151
5.3 Makefile的命令 152
5.4 變數 154
5.4.1 變數的基礎 154
5.4.2 賦值變數 154
5.4.3 define關鍵字 156
5.4.4 override指示符 156
5.4.5 目標變數和模式變數 157
5.5 常用函數調用 158
5.5.1 字元串處理函數 158
5.5.2 文件名操作函數 162
5.5.3 循環函數 164
5.5.4 條件判斷函數 165
5.5.5 其他常用函數 166
5.6 隱式規則 168
5.6.1 隱式規則舉例 168
5.6.2 隱式規則中的變數 169
5.6.3 使用模式規則 170
5.7 本章小結 173
實戰演練 173
第2部分 提高篇
第6章 文件I/O操作 174
6.1 Linux文件系統簡介 175
6.1.1 Linux的文件系統結構 175
6.1.2 文件類型 176
6.1.3 文件訪問許可權 179
6.2 基於文件描述符的I/O操作 179
6.2.1 文件描述符 180
6.2.2 標准輸入、標准輸出和標准出錯 180
6.2.3 文件重定向 181
6.2.4 文件的創建、打開與關閉 182
6.2.5 文件的定位 186
6.2.6 文件的讀寫 188
6.3 文件的屬性操作 192
6.3.1 改變文件訪問許可權 192
6.3.2 改變文件所有者 193
6.3.3 重命名 193
6.3.4 修改文件長度 194
6.4 文件的其他操作 195
6.4.1 stat、fstat和lstat函數 195
6.4.2 p和p2函數 196
6.4.3 fcntl函數 197
6.4.4 sync和fsync函數 197
6.5 特殊文件的操作 198
6.5.1 目錄文件的操作 198
6.5.2 鏈接文件的操作 201
6.5.3 管道文件的操作 204
6.5.4 設備文件 204
6.6 本章小結 205
實戰演練 205
第7章 基於流的I/O操作 206
7.1 流與緩存 207
7.1.1 流和FILE對象 207
7.1.2 標准輸入、標准輸出和標准出錯 207
7.1.3 緩存 207
7.1.4 對緩存的操作 210
7.2 流的打開與關閉 212
7.2.1 流的打開 212
7.2.2 流的關閉 214
7.2.3 流關閉前的工作 216
7.3 流的讀寫 216
7.3.1 基於字元的I/O 217
7.3.2 基於行的I/O 220
7.3.3 直接I/O 222
7.3.4 格式化I/O 224
7.4 本章小結 226
實戰演練 227
第8章 進程式控制制 228
8.1 進程的基本概念 229
8.1.1 Linux進程簡介 229
8.1.2 進程與作業 230
8.1.3 進程標識 230
8.2 進程式控制制的相關函數 232
8.2.1 fork和vfork函數 232
8.2.2 exec函數 237
8.2.3 exit和_exit函數 242
8.2.4 wait和waitpid函數 245
8.2.5 進程的一生 251
8.2.6 用戶ID和組ID 251
8.2.7 system函數 253
8.3 多個進程間的關系 255
8.3.1 進程組 255
8.3.2 會話期 256
8.3.3 控制終端 257
8.4 本章小結 259
實戰演練 259
第9章 信號 260
9.1 Linux信號簡介 261
9.1.1 信號的基本概念 261
9.1.2 信號處理機制 265
9.2 信號操作的相關函數 267
9.2.1 信號的處理 267
9.2.2 信號的發送 274
9.2.3 信號的阻塞 282
9.2.4 計時器與信號 284
9.3 本章小結 286
實戰演練 287
第10章 進程間通信 288
10.1 進程間通信簡介 289
10.2 管道 290
10.2.1 管道的概念 290
10.2.2 管道的創建與關閉 291
10.2.3 管道的讀寫 292
10.3 命名管道 297
10.3.1 命名管道的概念 297
10.3.2 命名管道的創建 297
10.3.3 命名管道的讀寫 299
10.4 消息隊列 303
10.4.1 消息隊列的概念 303
10.4.2 消息隊列的創建與打開 305
10.4.3 消息隊列的讀寫 306
10.4.4 獲得或設置消息隊列屬性 308
10.5 共享內存 312
10.5.1 共享內存的概念 312
10.5.2 共享內存的相關操作 313
10.6 信號量 318
10.6.1 信號量的概念 319
10.6.2 信號量集的相關操作 320
10.7 本章小結 325
實戰演練 326
第11章 網路編程 327
11.1 網路編程的基礎知識 328
11.1.1 計算機網路體系結構 328
11.1.2 傳輸控制協議TCP 333
11.1.3 用戶數據報協議UDP 335
11.1.4 客戶機/伺服器模式 336
11.2 套介面編程基礎 336
11.2.1 什麼是套介面 337
11.2.2 埠號的概念 338
11.2.3 套介面的數據結構 338
11.2.4 基本函數 340
11.3 TCP套介面編程 343
11.3.1 TCP套介面通信工作流程 343
11.3.2 TCP套介面Client/Server程序實例 356
11.4 UDP套介面編程 360
11.4.1 UDP套介面通信工作流程 360
11.4.2 UDP套介面Client/Server程序實例 362
11.5 原始套介面編程 365
11.5.1 原始套介面的創建 365
11.5.2 原始套介面程序實例 365
11.6 本章小結 376
實戰演練 376
第12章 Linux圖形界面編程 377
12.1 Linux下的圖形界面編程簡介 378
12.1.1 Qt簡介 378
12.1.2 GTK+簡介 378
12.2 界面基本元件 381
12.2.1 一個簡單的例子 381
12.2.2 窗口 383
12.2.3 標簽 385
12.2.4 按鈕 386
12.2.5 文本框 387
12.3 界面布局元件 389
12.3.1 表格 390
12.3.2 框 393
12.3.3 窗格 395
12.4 其他常用元件 398
12.4.1 進度條、微調按鈕、組合框 398
12.4.2 單選按鈕、復選按鈕 402
12.4.3 下拉菜單 404
12.5 信號與回調函數 406
12.6 本章小結 409
實戰演練 409
第3部分 實戰篇
第13章 設計Linux下的計算器 411
13.1 軟體功能分析 412
13.2 程序模塊的劃分 413
13.3 軟體的具體實現 415
13.3.1 頭文件 415
13.3.2 十六進制界面顯示函數 416
13.3.3 十進制界面顯示函數 417
13.3.4 八進制界面顯示函數 418
13.3.5 二進制界面顯示函數 419
13.3.6 進制間轉換函數 420
13.3.7 信號處理模塊 423
13.3.8 主函數 432
13.4 軟體使用效果演示 438
13.5 本章小結 439
第14章 Linux平台下聊天軟體的設計 440
14.1 軟體功能概述 441
14.1.1 伺服器端功能需求 441
14.1.2 客戶端功能需求 442
14.1.3 錯誤處理需求 442
14.2 Glade集成開發工具簡介 443
14.3 軟體功能模塊劃分 444
14.3.1 伺服器功能模塊劃分 444
14.3.2 客戶端功能模塊劃分 445
14.3.3 消息標識的定義 445
14.3.4 消息結構體的設計 446
14.4 伺服器程序的具體實現 447
14.4.1 伺服器消息處理流程 447
14.4.2 伺服器主要函數和變數 448
14.4.3 伺服器消息處理模塊的設計與實現 449
14.4.4 伺服器數據存儲的方法 450
14.4.5 用戶注冊流程 450
14.5 客戶端程序的具體實現 451
14.5.1 客戶端操作流程 451
14.5.2 客戶端發送和接收消息流程 451
14.5.3 客戶端主要函數和變數 452
14.5.4 客戶端功能模塊的設計與實現 453
14.6 聊天軟體使用效果演示 455
14.7 本章小結 459
第15章 Linux遠程管理工具的設計 460
15.1 軟體功能概述 461
15.1.1 Webmin簡介 461
15.1.2 軟體總體設計 461
15.2 伺服器端程序設計 463
15.2.1 伺服器端工作流程 463
15.2.2 系統用戶管理操作 464
15.2.3 系統用戶組的管理操作 466
15.2.4 系統服務啟動管理 468
15.2.5 DNS管理操作 469
15.2.6 Apache服務管理操作 471
15.2.7 FTP服務管理操作 474
15.3 客戶端程序 475
15.3.1 連接界面 475
15.3.2 主界面 477
15.4 本章小結 479
第16章 Linux下簡易防火牆軟體的設計 480
16.1 Netfilter基礎 481
16.1.1 什麼是Netfilter 481
16.1.2 Netfilter的HOOK機制 482
16.1.3 HOOK的調用 485
16.1.4 HOOK的實現 486
16.1.5 IPTables簡介 488
16.1.6 Netfilter可以實現的控制功能 489
16.2 軟體設計概述 491
16.2.1 軟體整體框架 491
16.2.2 管理端的設計 492
16.2.3 控制端的設計 493
16.3 用Netfilter設計控制端功能模塊 495
16.3.1 ICMP管理控制模塊 495
16.3.2 FTP管理控制模塊 497
16.3.3 HTTP管理控制模塊 499
16.3.4 模塊的編譯、載入與卸載 499
16.4 軟體功能測試 501
16.5 本章小結 503
第17章 基於Linux的嵌入式家庭網關遠程交互操作平台的設計 504
17.1 嵌入式技術簡介 505
17.1.1 嵌入式系統的概念 505
17.1.2 嵌入式操作系統 506
17.1.3 嵌入式處理器 507
17.2 家庭網關的概念及其網路體系結構 509
17.2.1 智能家庭網路的概念 509
17.2.2 家庭網關的遠程交互操作技術簡介 510
17.2.3 嵌入式家庭網關的網路體系結構 510
17.3 嵌入式家庭網關的開發平台 511
17.3.1 S3C2410微處理器簡介 511
17.3.2 交叉編譯環境的建立 513
17.4 遠程交互平台的設計 515
17.4.1 應用軟體的開發模式 515
17.4.2 嵌入式Web伺服器 516
17.4.3 通用網關介面CGI 519
17.5 Linux下軟體模塊的具體實現 520
17.5.1 登錄驗證模塊 521
17.5.2 串口通信模塊 521
17.5.3 中央空調控制模塊 522
17.5.4 智能水表數據採集模塊 528
17.5.5 試驗結果 528
17.6 本章小結 529

㈥ 如何在64位的linux系統上使用匯編和C語言混合編程

編譯和鏈接的時候使用的指令：（AMD處理器，64位操作系統）
編譯鏈接指令
1 nasm -f elf foo.s -o foo.o
2 gcc -c bar.c -o bar.o
3 ld -s -o foobar bar.o foo.o
匯編語言用nasm編寫並用nasm編譯器編譯，而C語言用的是gcc編譯，這些都沒有問題，但是在鏈接的時候出錯了，提示如下：
ld: i386 architecture of input file `foo.o' is incompatible with i386:x86-64 output
google了一下，意思就是nasm 編譯產生的是32位的目標代碼，gcc 在64位平台上默認產生的是64位的目標代碼，這兩者在鏈接的時候出錯，gcc在64位平台上默認以64位的方式鏈接。
這樣在解決的時候就會有兩種解決方案：
<1> 讓gcc 產生32位的代碼，並在鏈接的時候以32位的方式進行鏈接
在這種情況下只需要修改編譯和鏈接指令即可，具體如下：
32位的編譯鏈接指令
1 nasm -f elf foo.s -o foo.o
2 gcc -m32 -c bar.c -o bar.o
3 ld -m elf_i386 -s -o foobar foo.o bar.o
具體的-m32 和 -m elf_i386 請自行查閱gcc （man gcc）

如果你是高版本的gcc（可能是由於更新內核造成的），可能簡單的使用-m32 的時候會提示以下錯誤（使用別人的歷程，自己未曾遇到）：
> In file included from /usr/include/stdio.h:28:0,
> from test.c:1:
> /usr/include/features.h:323:26: fatal error: bits/predefs.h: No such file or directory
> compilation terminated.
這應該是缺少構建32 位可執行程序缺少的包，使用以下指令安裝：
sudo apt-get install libc6-dev-i386
此時應該就沒有什麼問題了。

㈦ 如何進行Linux Kernel 開發

1. 學習匯編語言、C語言，這兩種語言是你進行Linux Kernel開發與維護的必備語言能力，這樣你才有能力閱讀與編寫Linux Kernel的能力。

2. 下載Linux Kernel源代碼，建議下載先前的版本，因為目前的新版本代碼數量太龐大，技術太新，如果是進行Linux Kernel的開發的話，先從簡單的版本0.11或者1.XX.XX版本開始，以前的版本中沒有過多的新技術的代碼，適合入門Linux Kernel的學習。

3. 當你熟悉了Linux Kernel了後，可以下載目前最新的版本Linux Kernel3.18版本的源代碼，裡麵包含了很多的新技術的知識，方便你了解與學習~~~

這是一篇很重要的文檔，它介紹了內核開發的方方面面。這篇文檔已被加入到內核源碼樹的Documentation文檔里（名字為HOWTO），你可以在最新的內核樹里找到它。盡管已經有網友翻譯過這篇文檔，但是我還是決定自己再翻譯一遍。翻譯完之後，我的感觸是如果依靠翻譯來進行學習，速度太慢了。以後的技術文檔直接看英文，適當的做做筆記即可。

山濤

-----------------------------------------------------

How to do Linux Kernel development

-----------------------------------------------------

關於如何進行Linux Kernel development，這篇文檔是最值得你閱讀的一篇。它指導你如何成為一名Linux內核開發者以及如何和Linux內核開發社區一同工作。盡管它不包含內核編程的技能方面的知識，但是本篇能夠給你正確的指導去做內核開發。

如果這篇文檔講述的任何東西已經過時了的話，請給這篇文檔的維護者發送你的更新。

Greg [email protected]

Introction

-----------------

你想成為一名Linux內核開發者嗎？或者你的老闆曾經告訴你：去給某個設備寫個Linux驅動程序。這篇文檔的目標是，通過描述你進行開發時需要經歷的一些流程規則去指導你如何與社區一起工作，教會你所需要的一切從而讓你實現你的目標（成為一名合格的內核開發者，或者寫出合格的令老闆滿意的驅動程序）；這篇文檔也會說明內核社區工作的風格和原因。

內核絕大部分代碼是基於C語言編程，與體系結構有關的一小部分由匯編完成。很好的理解和掌握C語言，是內核開發的必備要求。匯編語言（不同的體系結構有不同的匯編語言）不是必需的，除非你計劃做體系結構相關的底層開發。如果你想加強C語言的掌握，很好的參考資料如下：

- "The C Programming Language" by Kernighan and Ritchie [Prentice Hall]
- "Practical C Programming" by Steve Oualline [O'Reilly]

Linux內核是使用GNU C和GNU工具鏈完成的。盡管它遵循ISO C89標准，但是內核的編寫也使用了許多的GNU C的擴展特性，這些特性不屬於標準的一部分。內核的C編程環境自成體系，不依賴於C標准庫，所以C標準的一部分特性沒有被支持：例如Arbitrary long long divisions和浮點指針不被支持。有時你會很難理解內核基於GNU工具鏈的一些假定以及內核使用的一些GNU C擴展，不幸的是對於這類問題沒有確定性的參考資料。如果你遇到這類問題，建議你查閱GCC的info pages來獲取相關的信息（在Linux PC上，通過命令info gcc可以獲得信息）。

請記住你正在學習如何與已經存在的內核開發社區一起工作。內核開發社區由全球不同地方的開發人員組成，它以代碼、風格、開發流程的高質量標准著稱。這些高質量的標准使內核開發社區（這個組織非常大，地理位置非常分散）能夠非常有效的進行。應當提早努力學習這些高質量標准（編程風格、代碼要求以及開發流程），它們有很好的文檔；不要期望內核開發社區別的開發人員會適應你自己的或者你公司的開發風格。

Legal Issues

------------------

Linux內核代碼基於GPL許可協議發布。請閱讀內核源碼樹的主目錄里的COPYING文件，它提供了GPL許可的詳細描述。如果你有關於GPL許可的進一步問題，請聯系一名律師，不要在Linux kernel mailing list里詢問。Linux kernel mailing list里的開發人員不是律師，所以你不應當聽取他們的任何關於法律事務的建議。

對於一些通常的關於GPL許可的問題和解答，請參考：

http://www.gnu.org/licenses/gpl-faq.html

Documentation

---------------------

Linux內核源碼樹里有大量的非常有用的文檔用於學習，使你與內核社區相互促進和共同發展。當一個新的特性要加入到內核里，建議相關的文檔也要加入到內核里，用於描述如何使用這個新特性；當一個內核的修改導致了內核提供給用戶的介面發生了變化，建議你發送信息或者一個補丁給[email protected]，告訴manual pages的維護者用戶介面的變化。

這里羅列了一些內核源碼樹里的需要閱讀的文檔：

README

這篇文檔簡要的介紹了Linux內核的背景，描述了配置和build內核需要什麼。一個剛剛接觸內核的新手應當從這里開始。（註：build kernel，就是編譯內核源代碼，生成可供系統使用的內核二進制文件（vmlinux/zImage）的過程。

Documentation/Changes

這篇文檔給出了一個用於成功編譯和運行內核的各種軟體包的列表的最小集合。

Documentation/CodingStyle

這篇文檔描述了Linux內核編碼風格，和一些隱藏在背後的基本原理。所有的想加入內核的新代碼應當遵循這篇文檔的指導。絕大數的內核代碼維護者只願意接受那些符合這篇文檔描述的風格的補丁，許多內核開發者也只願意審查那些符合Linux內核編碼風格的代碼。

Documentation/SubmittingPatches

Documentation/SubmittingDrivers

這些文檔清楚而又詳細地告訴你如何成功的創建和向社區遞交一個補丁，包括：

----郵件內容

----郵件格式

----發送者和接收者

遵循文檔里提倡的規則並不一定保證你提交補丁成功（因為所有的補丁遭受詳細而嚴格的內容和風格的審查），但是不遵循它們，提交補丁肯定不成功。

其他的一些非常優秀的描述如何正確的創建補丁的文檔如下：

"The Perfect Patch"
http://www.zip.com.au/~akpm/linux/patches/stuff/tpp.txt
"Linux kernel patch submission format"
http://linux.yyz.us/patch-format.html

Documentation/stable_api_nonsense.txt

這篇文檔描述了有意決定在內核里沒有固定內核API的基本原因，包含下面的討論主題：

---子系統的shim-layers（為了兼容性？）

---操作系統之間的驅動移植性

---減緩內核源碼樹的快速變化（或者說，防止快速變化）

這篇文檔對於理解Linux的開發哲學非常關鍵，也對於從其他操作系統轉移到Linux上的開發人員非常重要。

Documentation/SecurityBugs

如果你確知你在Linux Kernel里發現了security problem，請遵循這篇文檔描述的步驟，幫助通知內核的開發者們並解決這類問題。

Documentation/ManagementStyle

這篇文檔描述了Linux內核開發者們如何進行管理運作，以及運作方法背後的分享精神（shared ethos）。這篇文檔對於那些內核開發新手們（或者那些好奇者）值得一讀，因為它解決或解釋了很多對於內核維護者獨特行為的誤解。

Documentation/stable_kernel_rules.txt

這篇文檔描述了一個穩定的內核版本如何發布的規則，以及需要做些什麼如果你想把一個修改加入到其中的一個版本。

Documentation/kernel-docs.txt

關於內核開發的外部文檔列表。如果你在內核開發的內部文檔中找不到你想要的資料，請參考這篇文檔提供的資料鏈接。

Documentation/applying-patches.txt

這篇文檔很好地描述了什麼是補丁(patch)，以及如何將它應用到內核的不同開發分支(branch)上。

內核里也有大量的由內核源碼自動生成的文檔。其中包括了內核內部API的全面描述，和如何處理好鎖的規則。這些文檔在Documentation/DocBook/下創建，格式可以是PDF、Postscritpt、HTML和man pages，在內核源碼主目錄下通過運行下面命令自動生成：

make pdfdocs

make psdocs

make htmldocs

make mandocs

附上出處鏈接：http://www.cppblog.com/flyonok/archive/2011/04/15/144316.html

㈧ 如何編寫一個簡單的linux內核模塊和設備驅動程序

如何編寫Linux設備驅動程序
回想學習Linux操作系統已經有近一年的時間了，前前後後，零零碎碎的一路學習過來，也該試著寫的東西了。也算是給自己能留下一點記憶和回憶吧！由於完全是自學的，以下內容若有不當之處，還請大家多指教。
Linux是Unix操作系統的一種變種，在Linux下編寫驅動程序的原理和思想完全類似於其他的Unix系統，但它dos或window環境下的驅動程序有很大的區別。在Linux環境下設計驅動程序，思想簡潔，操作方便，功能也很強大，但是支持函數少，只能依賴kernel中的函數，有些常用的操作要自己來編寫，而且調試也不方便。
以下的一些文字主要來源於khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux a-z，還有清華bbs上的有關device driver的一些資料。
一、Linux device driver 的概念
系統調用是操作系統內核和應用程序之間的介面，設備驅動程序是操作系統內核和機器硬體之間的介面。設備驅動程序為應用程序屏蔽了硬體的細節，這樣在應用程序看來，硬體設備只是一個設備文件，應用程序可以象操作普通文件一樣對硬體設備進行操作。設備驅動程序是內核的一部分，它完成以下的功能:
1、對設備初始化和釋放。
2、把數據從內核傳送到硬體和從硬體讀取數據。
3、讀取應用程序傳送給設備文件的數據和回送應用程序請求的數據。
4、檢測和處理設備出現的錯誤。
在Linux操作系統下有三類主要的設備文件類型，一是字元設備，二是塊設備，三是網路設備。字元設備和塊設備的主要區別是:在對字元設備發出讀/寫請求時，實際的硬體I/O一般就緊接著發生了，塊設備則不然，它利用一塊系統內存作緩沖區，當用戶進程對設備請求能滿足用戶的要求，就返回請求的數據，如果不能，就調用請求函數來進行實際的I/O操作。塊設備是主要針對磁碟等慢速設備設計的，以免耗費過多的CPU時間來等待。
已經提到，用戶進程是通過設備文件來與實際的硬體打交道。每個設備文件都都有其文件屬性(c/b)，表示是字元設備還是塊設備?另外每個文件都有兩個設備號，第一個是主設備號，標識驅動程序，第二個是從設備號，標識使用同一個設備驅動程序的不同的硬體設備，比如有兩個軟盤，就可以用從設備號來區分他們。設備文件的的主設備號必須與設備驅動程序在登記時申請的主設備號一致，否則用戶進程將無法訪問到驅動程序。
最後必須提到的是，在用戶進程調用驅動程序時，系統進入核心態，這時不再是搶先式調度。也就是說，系統必須在你的驅動程序的子函數返回後才能進行其他的工作。如果你的驅動程序陷入死循環，不幸的是你只有重新啟動機器了，然後就是漫長的fsck。
讀/寫時，它首先察看緩沖區的內容，如果緩沖區的數據未被處理，則先處理其中的內容。
如何編寫Linux操作系統下的設備驅動程序

二、實例剖析
我們來寫一個最簡單的字元設備驅動程序。雖然它什麼也不做，但是通過它可以了解Linux的設備驅動程序的工作原理。把下面的C代碼輸入機器，你就會獲得一個真正的設備驅動程序。
#define __NO_VERSION__
#include <linux/moles.h>
#include <linux/version.h>
char kernel_version [] = UTS_RELEASE;
這一段定義了一些版本信息，雖然用處不是很大，但也必不可少。Johnsonm說所有的驅動程序的開頭都要包含<linux/config.h>，一般來講最好使用。
由於用戶進程是通過設備文件同硬體打交道，對設備文件的操作方式不外乎就是一些系統調用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系統調用和驅動程序關聯起來呢?這需要了解一個非常關鍵的數據結構：
struct file_operations
{
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}

這個結構的每一個成員的名字都對應著一個系統調用。用戶進程利用系統調用在對設備文件進行諸如read/write操作時，系統調用通過設備文件的主設備號找到相應的設備驅動程序，然後讀取這個數據結構相應的函數指針，接著把控制權交給該函數。這是linux的設備驅動程序工作的基本原理。既然是這樣，則編寫設備驅動程序的主要工作就是編寫子函數，並填充file_operations的各個域。
下面就開始寫子程序。
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include<linux/config.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *node，struct file *file，char *buf，int count)
{
int left;
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}

這個函數是為read調用准備的。當調用read時，read_test()被調用，它把用戶的緩沖區全部寫1。buf 是read調用的一個參數。它是用戶進程空間的一個地址。但是在read_test被調用時，系統進入核心態。所以不能使用buf這個地址，必須用__put_user()，這是kernel提供的一個函數，用於向用戶傳送數據。另外還有很多類似功能的函數。請參考robert著的《Linux內核設計與實現》（第二版）。然而，在向用戶空間拷貝數據之前，必須驗證buf是否可用。這就用到函數verify_area。
static int write_tibet(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_tibet(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT;
return 0;
}
static void release_tibet(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}

這幾個函數都是空操作。實際調用發生時什麼也不做，他們僅僅為下面的結構提供函數指針。
struct file_operations test_fops = {
NULL，
read_test，
write_test，
NULL， /* test_readdir */
NULL，
NULL， /* test_ioctl */
NULL， /* test_mmap */
open_test，
release_test，
NULL， /* test_fsync */
NULL， /* test_fasync */
/* nothing more， fill with NULLs */
};
這樣，設備驅動程序的主體可以說是寫好了。現在要把驅動程序嵌入內核。驅動程序可以按照兩種方式編譯。一種是編譯進kernel，另一種是編譯成模塊(moles)，如果編譯進內核的話，會增加內核的大小，還要改動內核的源文件，而且不能動態的卸載，不利於調試，所以推薦使用模塊方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops);
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}

在用insmod命令將編譯好的模塊調入內存時，init_mole 函數被調用。在這里，init_mole只做了一件事，就是向系統的字元設備表登記了一個字元設備。register_chrdev需要三個參數，參數一是希望獲得的設備號，如果是零的話，系統將選擇一個沒有被佔用的設備號返回。參數二是設備文件名，參數三用來登記驅動程序實際執行操作的函數的指針。
如果登記成功，返回設備的主設備號，不成功，返回一個負值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸載模塊時，cleanup_mole函數被調用，它釋放字元設備test在系統字元設備表中佔有的表項。
一個極其簡單的字元設備可以說寫好了，文件名就叫test.c吧。
下面編譯 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c
得到文件test.o就是一個設備驅動程序。
如果設備驅動程序有多個文件，把每個文件按上面的命令行編譯，然後
ld -r file1.o file2.o -o molename。
驅動程序已經編譯好了，現在把它安裝到系統中去。
$ insmod –f test.o
如果安裝成功，在/proc/devices文件中就可以看到設備test，並可以看到它的主設備號。要卸載的話，運行 :
$ rmmod test
下一步要創建設備文件。
mknod /dev/test c major minor
c 是指字元設備，major是主設備號，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以獲得主設備號，可以把上面的命令行加入你的shell script中去。
minor是從設備號，設置成0就可以了。
我們現在可以通過設備文件來訪問我們的驅動程序。寫一個小小的測試程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}

編譯運行，看看是不是列印出全1 ？
以上只是一個簡單的演示。真正實用的驅動程序要復雜的多，要處理如中斷，dma，I/O port等問題。這些才是真正的難點。請看下節，實際情況的處理。
如何編寫Linux操作系統下的設備驅動程序
三、設備驅動程序中的一些具體問題
1。 I/O Port。
和硬體打交道離不開I/O Port，老的isa設備經常是佔用實際的I/O埠，在linux下，操作系統沒有對I/O口屏蔽，也就是說，任何驅動程序都可對任意的I/O口操作，這樣就很容易引起混亂。每個驅動程序應該自己避免誤用埠。
有兩個重要的kernel函數可以保證驅動程序做到這一點。
1）check_region(int io_port， int off_set)
這個函數察看系統的I/O表，看是否有別的驅動程序佔用某一段I/O口。
參數1：I/O埠的基地址，
參數2：I/O埠佔用的范圍。
返回值：0 沒有佔用， 非0，已經被佔用。
2）request_region(int io_port， int off_set，char *devname)
如果這段I/O埠沒有被佔用，在我們的驅動程序中就可以使用它。在使用之前，必須向系統登記，以防止被其他程序佔用。登記後，在/proc/ioports文件中可以看到你登記的I/O口。
參數1：io埠的基地址。
參數2：io埠佔用的范圍。
參數3：使用這段io地址的設備名。
在對I/O口登記後，就可以放心地用inb()， outb()之類的函來訪問了。
在一些pci設備中，I/O埠被映射到一段內存中去，要訪問這些埠就相當於訪問一段內存。經常性的，我們要獲得一塊內存的物理地址。

2。內存操作
在設備驅動程序中動態開辟內存，不是用malloc，而是kmalloc，或者用get_free_pages直接申請頁。釋放內存用的是kfree，或free_pages。 請注意，kmalloc等函數返回的是物理地址！
注意，kmalloc最大隻能開辟128k-16，16個位元組是被頁描述符結構佔用了。
內存映射的I/O口，寄存器或者是硬體設備的ram(如顯存)一般佔用F0000000以上的地址空間。在驅動程序中不能直接訪問，要通過kernel函數vremap獲得重新映射以後的地址。
另外，很多硬體需要一塊比較大的連續內存用作dma傳送。這塊程序需要一直駐留在內存，不能被交換到文件中去。但是kmalloc最多隻能開辟128k的內存。
這可以通過犧牲一些系統內存的方法來解決。

3。中斷處理
同處理I/O埠一樣，要使用一個中斷，必須先向系統登記。
int request_irq(unsigned int irq ，void(*handle)(int，void *，struct pt_regs *)，
unsigned int long flags， const char *device);
irq: 是要申請的中斷。
handle：中斷處理函數指針。
flags：SA_INTERRUPT 請求一個快速中斷，0 正常中斷。
device：設備名。

如果登記成功，返回0，這時在/proc/interrupts文件中可以看你請求的中斷。
4。一些常見的問題。
對硬體操作，有時時序很重要（關於時序的具體問題就要參考具體的設備晶元手冊啦！比如網卡晶元RTL8139）。但是如果用C語言寫一些低級的硬體操作的話，gcc往往會對你的程序進行優化，這樣時序會發生錯誤。如果用匯編寫呢，gcc同樣會對匯編代碼進行優化，除非用volatile關鍵字修飾。最保險的辦法是禁止優化。這當然只能對一部分你自己編寫的代碼。如果對所有的代碼都不優化，你會發現驅動程序根本無法裝載。這是因為在編譯驅動程序時要用到gcc的一些擴展特性，而這些擴展特性必須在加了優化選項之後才能體現出來。
寫在後面：學習Linux確實不是一件容易的事情，因為要付出很多精力，也必須具備很好的C語言基礎；但是，學習Linux也是一件非常有趣的事情，它裡麵包含了許多高手的智慧和「幽默」，這些都需要自己親自動手才能體會到，O(∩_∩)O~哈哈！