The Linux Kernel Module Programming Guide is a free book; you may reproduce and/or modify it under the terms of the Open Software License, version 1.1. You can obtain a copy of this license at https://opensource.org/licenses/osl.php.

This book is distributed in the hope it will be useful, but without any warranty, without even the implied warranty of merchantability or fitness for a particular purpose.

The author encourages wide distribution of this book for personal or commercial use, provided the above copyright notice remains intact and the method adheres to the provisions of the Open Software License. In summary, you may copy and distribute this book free of charge or for a profit. No explicit permission is required from the author for reproduction of this book in any medium, physical or electronic.

Derivative works and translations of this document must be placed under the Open Software License, and the original copyright notice must remain intact. If you have contributed new material to this book, you must make the material and source code available for your revisions. Please make revisions and updates available directly to the document maintainer, Peter Jay Salzman <p@dirac.org>. This will allow for the merging of updates and provide consistent revisions to the Linux community.

If you publish or distribute this book commercially, donations, royalties, and/or printed copies are greatly appreciated by the author and the Linux Documentation Project (LDP). Contributing in this way shows your support for free software and the LDP. If you have questions or comments, please contact the address above.

1. 作者聲明

《Linux內核驅動模塊編程指南》最初是由Ori Pomerantz為2.2版本的內核編寫的 ，後來，Ori將文檔維護的任務交給了Peter Jay Salzman，Peter完成了2.4內核版本文檔 的編寫，畢竟Linux內核驅動模塊是一個更新很快的內容。現在，Peter也無法騰出足夠的 時間來完成2.6內核版本文檔的編寫，目前該2.6內核版本的文檔由合作者Michael Burian 完成。

2. 版本和注意

Linux內核模塊是一塊不斷更新進步的內容，在LKMPG上總有關於是否保留還是曆史 版本的爭論。Michael和我最終是決定為每個新的穩定版本內核建立一個新的文檔分支。也 就是說LKMPG 2.4.x專注於2.4的內核，而LKMPG 2.6.x將專注於2.6的內核。我們不會在一 篇文檔中提供對舊版本內核的支持，對此感興趣的讀者應該尋找相關版本的文檔分支。

在文檔中的絕大部分源代碼和討論都應該適用於其它平台，但我無法提供任何保證。其中的一個例外就是 Chapter 12, 中斷處理該章的源代碼和討論就隻適用於x86平台。

3. 感謝

感謝下列人士為此文檔提供了他們寶貴的意見。他們是：Ignacio Martin, David Porter, Daniele Paolo,Scarpazza 和 Dimo Velev。

4. 譯者注

我，譯者，名叫田競，目前是一名在北京郵電大學就讀的通信專業的大學生。 自高中起我就是Linux的愛好者並追隨至今。我喜歡Linux給我帶來的自由，我想大家也一樣。沒有人不向往自由。

我學習內核模塊編寫時最初閱讀的是Orelly出版社的使用2.0版本的內核的書籍，但如同我預料的一樣， 書中的許多事例由於內核代碼的變化而無法使用。這讓想親自體驗內核模塊的神秘的我非常苦惱。 我在Linux文檔計劃在上海的鏡像站ldp.linuxforum.net上找到了這篇文檔。

受原作者Ori的鼓勵，基於上次完成的LKMPG 2.4的，內容有稍許的改變和擴充。應該是目前最新的了。 翻譯的方式有所改變，在基於LDP認可的docbook格式上翻譯，通過docbook2html轉換為附件中的html文檔。 由於對docbook不是很熟悉，其中的一些標題尚未翻譯，而且可能破壞了原有的tag，導致html出現一些錯誤顯示， 但總體來說很少。修改了很多2.4中的錯別字。

學習並分享學習的過程是我翻譯的最終目的。

補注：不知為何，原譯者田競未能及時更新此文檔。我發電子郵件詢問並請求做一些維護工作，但他至今仍未給我答複。我冒 昧地做一下更新和維護工作，為大家盡微薄之力，希望原譯者看此文到後能聯係我。譯文的版權完全屬於原譯者田競，我不想保留任何版權， 但我會對翻譯質量負責。我的郵箱是xiyou [dot] wangcong [at] gmail [dot] com。總的來說，我對原文中的 一些技術錯誤做了訂正（我已經通知原文作者），對原譯文中的一些用詞和錯字做了更改，也使本文與最新的LKMPG版本2.6.3版一致。我也會繼續 做維護工作，如發現有任何錯誤可以通過上麵的郵箱聯係我，我會及時修訂。

1.1. 什麼是內核模塊？

現在，你是不是想編寫內核模塊。你應該懂得C語言，寫過一些用戶程序， 那麼現在你將要見識一些真實的東西。在這裏，你會看到一個野蠻的指針是如何 毀掉你的文件係統的，一次內核崩潰意味著重啟動。

什麼是內核模塊？內核模塊是一些可以讓操作係統內核在需要時載入和執 行的代碼，這同樣意味著它可以在不需要時由操作係統卸載。它們擴展了操作係 統內核的功能卻不需要重新啟動係統。舉例子來說，其中一種內核模塊時設備驅 動程序模塊，它們用來讓操作係統正確識別，使用安裝在係統上的硬件設備。如 果沒有內核模塊，我們不得不一次又一次重新編譯生成單內核操作係統的內核鏡 像來加入新的功能。這還意味著一個臃腫的內核。

1.2. 內核模塊是如何被調入內核工作的？

你可以通過執行lsmod命令來查看內核已經加載了哪 些內核模塊, 該命令通過讀取/proc/modules文件的內容 來獲得所需信息。

這些內核模塊是如何被調入內核的？當操作係統內核需要的擴展功能不存 在時，內核模塊管理守護進程kmod[1]執行modprobe去加載內核模 塊。兩種類型的參數被傳遞給modprobe：

• 一個內核模塊的名字像softdog或是ppp。

• 通用識別符像char-major-10-30。

當傳遞給modprobe是通用識別符時，modprobe首先在文件 /etc/modules.conf查找該字符串。如果它發現的一行別名像：

alias char-major-10-30 softdog
	

它就明白通用識別符是指向內核模塊softdog.o。

然後，modprobe遍曆文件/lib/modules/version/modules.dep 來判斷是否有其它內核模塊需要在該模塊加載前被加載。該文件是由命令depmod -a 建立，保存著內核模塊的依賴關係。舉例來說，msdos.o依賴於模塊fat.o 內核模塊已經被內核載入。當要加載的內核模塊需要使用別的模塊提供的符號鏈接時（多半是變量或函數）， 那麼那些提供這些所需符號鏈接的內核模塊就被該模塊所依賴。

最終，modprobe調用insmod先加載被依賴的模塊，然後加載該被內核要求的模塊。modprobe將insmod指向 /lib/modules/version/[2]目錄，該目錄為默認標準存放內核模塊的目錄。insmod對內核模塊存放位置 的處理相當呆板，所以modprobe應該很清楚的知道默認標準的內核模塊存放的位置。所以，當你想要載入一個內 核模塊時，你可以執行：

insmod /lib/modules/2.5.1/kernel/fs/fat/fat.o
insmod /lib/modules/2.5.1/kernel/fs/msdos/msdos.o
	

或隻是執行"modprobe -a msdos"。

Linux提供modprobe, insmod and depmod在一個名為modutils 或 mod-utils的工具包內。

在結束本章前，讓我們來看一個 /etc/modules.conf文件：

#This file is automatically generated by update-modules
path[misc]=/lib/modules/2.4.?/local
keep
path[net]=~p/mymodules
options mydriver irq=10
alias eth0 eepro
	

用'#'起始的行為注釋。空白行被忽略。

以 path[misc]起始的行告訴modprobe用 /lib/modules/2.4.?/local替代搜尋 misc內核模塊的路徑。正如你看到的，命令解釋器shell的元字符也可以使用。

以path[net]起始的行告訴modprobe 在目錄 ~p/mymodules搜索網絡方麵的內核模塊。但是，在path[net] 指令之前使用的"keep" 指令告訴modprobe隻是將該路徑添加到標準搜索路徑中，而不是像對待 misc前麵那樣進行替換。

以alias 起始的的行使modprobe加載eepro.o當kmod 以通用識別符'eth0' 要求加載相應內核模塊時。

你不會發現像"alias block-major-2 floppy"這樣的別名行在文件/etc/modules.conf 因為modprobe已經知道在絕大多數係統上安裝的標準的設備的驅動模塊。

現在你已經知道內核模塊是如何被調入的了。當你想寫你自己的依賴於其它模塊的內核模塊時， 還有一些內容沒有提供。這個相對高級的問題將在以後的章節中介紹，當我們已經完成前麵的學習後。

2.1. Hello, World (part 1): 最簡單的內核模塊

當第一個洞穴程序員在第一台洞穴計算機的牆上上鑿寫第一個程序時， 這是一個在羚羊皮上輸出`Hello, world'的字符串。羅馬的編程書籍上是以 `Salut, Mundi'這樣的程序開始的。 我不明白人們為什麼要破壞這個傳統， 但我認為還是不明白為好。我們將從編寫一係列的`Hello, world'模塊開始， 一步步展示編寫內核模塊的基礎的方方麵麵。

這可能是一個最簡單的模塊了。先別急著編譯它。我們將在下章模塊編譯的章節介紹相關內容。

/*  
 *  hello-1.c - The simplest kernel module.
 */
#include <linux/module.h>	/* Needed by all modules */
#include <linux/kernel.h>	/* Needed for KERN_ALERT */

int init_module(void)
{
	printk(KERN_INFO "Hello world 1.\n");

	/* 
	 * A non 0 return means init_module failed; module can't be loaded. 
	 */
	return 0;
}

void cleanup_module(void)
{
	printk(KERN_INFO "Goodbye world 1.\n");
}

一個內核模塊應該至少包含兩個函數。一個“開始”(初始化)的函數被稱為init_module() 還有一個“結束” (幹一些收尾清理的工作)的函數被稱為cleanup_module() ，當內核模塊被rmmod卸載時被執行。實際上，從內核版本2.3.13開始這種情況有些改變。 你可以為你的開始和結束函數起任意的名字。 你將在以後學習如何實現這一點Section 2.3。 實際上，這個新方法時推薦的實現方法。但是，許多人仍然使init_module()和 cleanup_module()作為他們的開始和結束函數。

一般，init_module()要麼向內核注冊它可以處理的事物，要麼用自己的代碼 替代某個內核函數(代碼通常這樣做然後再去調用原先的函數代碼)。函數 cleanup_module()應該撤消任何init_module()做的事，從而 內核模塊可以被安全的卸載。

最後，任一個內核模塊需要包含linux/module.h。 我們僅僅需要包含 linux/kernel.h當需要使用 printk()記錄級別的宏擴展時KERN_ALERT，相關內容將在Section 2.1.1中介紹。

2.2. 編譯內核模塊

內核模塊在用gcc編譯時需要使用特定的參數。另外，一些宏同樣需要定義。 這是因為在編譯成可執行文件和內核模塊時， 內核頭文件起的作用是不同的。 以往的內核版本需要我們去在Makefile中手動設置這些設定。盡管這些Makefile是按目錄分層次 安排的，但是這其中有許多多餘的重複並導致代碼樹大而難以維護。 幸運的是，一種稱為kbuild的新方法被引入，現在外部的可加載內核模塊的編譯的方法已經同內核編譯統一起來。想了解更多的編 譯非內核代碼樹中的模塊(就像我們將要編寫的)請參考幫助文件linux/Documentation/kbuild/modules.txt。

現在讓我們看一個編譯名為hello-1.c的模塊的簡單的Makefile：

obj-m += hello-1.o

all:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
       
clean:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

現在你可以通過執行命令 make編譯模塊。 你應該得到同下麵類似的屏幕輸出：

hostname:~/lkmpg-examples/02-HelloWorld# make
make -C /lib/modules/2.6.11/build M=/root/lkmpg-examples/02-HelloWorld modules
make[1]: Entering directory `/usr/src/linux-2.6.11'
  CC [M] /root/lkmpg-examples/02-HelloWorld/hello-1.o
 Building modules, stage 2.
  MODPOST
  CC      /root/lkmpg-examples/02-HelloWorld/hello-1.mod.o
  LD [M] /root/lkmpg-examples/02-HelloWorld/hello-1.ko
make[1]: Leaving directory `/usr/src/linux-2.6.11'
hostname:~/lkmpg-examples/02-HelloWorld#

請注意2.6的內核現在引入一種新的內核模塊命名規範：內核模塊現在使用.ko的文件後綴(代替 以往的.o後綴)，這樣內核模塊就可以同常規的目標文件區別開。這樣做的理由是它們包含一個附加的.modinfo段， 那裏存放著關於模塊的附加信息。我們將馬上看到這些信息的好處。

使用modinfo hello-*.ko來看看它是什麼樣的信息。

hostname:~/lkmpg-examples/02-HelloWorld# modinfo hello-1.ko
filename:       hello-1.ko
vermagic:       2.6.11 preempt PENTIUMII 4KSTACKS gcc-3.3
depends:

到目前為止，沒什麼驚人的。一旦我們對後麵的一個例子，hello-5.ko，使用modinfo，那將會改變。

hostname:~/lkmpg-examples/02-HelloWorld# modinfo hello-5.ko
filename:       hello-5.ko
license:        GPL
author:         Peter Jay Salzman
vermagic:       2.6.11 preempt PENTIUMII 4KSTACKS gcc-3.3
depends:
parm:           myintArray:An array of integers (array of int)
parm:           mystring:A character string (charp)
parm:           mylong:A long integer (long)
parm:           myint:An integer (int)
parm:           myshort:A short integer (short)
hostname:~/lkmpg-examples/02-HelloWorld#

這裏有很多有用的信息去看。報告錯誤的作者信息，許可證信息，甚至對它接受參數的簡短描述。

更詳細的文檔請參考 linux/Documentation/kbuild/makefiles.txt。在研究Makefile之前請確認你已經參考了這些文檔。它很可能會節省你很多工作。

現在是使用insmod ./hello-1.ko命令加載該模塊的時候了(忽略任何你看到的關於內核汙染的輸出 顯示，我們將在以後介紹相關內容)。

所有已經被加載的內核模塊都羅列在文件/proc/modules中。cat一下這個文件看一下你的模塊是否真的 成為內核的一部分了。如果是，祝賀你！你現在已經是內核模塊的作者了。當你的新鮮勁過去後，使用命令 rmmod hello-1.卸載模塊。再看一下/var/log/messages文件的內容是否有相關的日誌內容。

這兒是另一個練習。看到了在聲明 init_module()上的注釋嗎? 改變返回值非零，重新編譯再加載，發生了什麼？

2.3. Hello World (part 2)

在內核Linux 2.4中，你可以為你的模塊的“開始”和“結束”函數起任意的名字。它們不再必須使用 init_module()和cleanup_module()的名字。這可以通過宏 module_init()和module_exit()實現。這些宏在頭文件linux/init.h定義。唯一需要注意的地方是函數必須在宏的使用前定義，否則會有編譯 錯誤。下麵就是一個例子。

/*  
 *  hello-2.c - Demonstrating the module_init() and module_exit() macros.
 *  This is preferred over using init_module() and cleanup_module().
 */
#include <linux/module.h>	/* Needed by all modules */
#include <linux/kernel.h>	/* Needed for KERN_ALERT */
#include <linux/init.h>		/* Needed for the macros */

static int __init hello_2_init(void)
{
	printk(KERN_INFO "Hello, world 2\n");
	return 0;
}

static void __exit hello_2_exit(void)
{
	printk(KERN_INFO "Goodbye, world 2\n");
}

module_init(hello_2_init);
module_exit(hello_2_exit);

現在我們已經寫過兩個真正的模塊了。添加編譯另一個模塊的選項十分簡單，如下：

obj-m += hello-1.o
obj-m += hello-2.o
all:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

現在讓我們來研究一下linux/drivers/char/Makefile這個實際中的例子。就如同你看到的， 一些被編譯進內核 (obj-y)，但是這些obj-m哪裏去了呢？對於熟悉shell腳本的人這不難理解。這些在Makefile中隨處可見 的obj-$(CONFIG_FOO)的指令將會在CONFIG_FOO被設置後擴展為你熟悉的obj-y或obj-m。這其實就是你在使用 make menuconfig編譯內核時生成的linux/.config中設置的東西。

2.4. Hello World (part 3): 關於__init和__exit宏

這裏展示了內核2.2以後引入的一個新特性。注意在負責“初始化”和“清理收尾”的函數定義處的變化。宏 __init的使用會在初始化完成後丟棄該函數並收回所占內存，如果該模塊被編譯進內核，而不是動態加載。

也有一個宏__initdata同__init 類似，隻不過對變量有效。

宏__exit將忽略“清理收尾”的函數如果該模塊被編譯進內核。同宏 __exit一樣，對動態加載模塊是無效的。這很容易理解。編譯進內核的模塊 是沒有清理收尾工作的, 而動態加載的卻需要自己完成這些工作。

這些宏在頭文件linux/init.h定義，用來釋放內核占用的內存。 當你在啟動時看到這樣的Freeing unused kernel memory: 236k freed內核輸出，上麵的 那些正是內核所釋放的。

/*  
 *  hello-3.c - Illustrating the __init, __initdata and __exit macros.
 */
#include <linux/module.h>	/* Needed by all modules */
#include <linux/kernel.h>	/* Needed for KERN_ALERT */
#include <linux/init.h>		/* Needed for the macros */

static int hello3_data __initdata = 3;

static int __init hello_3_init(void)
{
	printk(KERN_INFO "Hello, world %d\n", hello3_data);
	return 0;
}

static void __exit hello_3_exit(void)
{
	printk(KERN_INFO "Goodbye, world 3\n");
}

module_init(hello_3_init);
module_exit(hello_3_exit);

2.5. Hello World (part 4): 內核模塊許可證和內核模塊文檔說明

如果你在使用2.4或更新的內核，當你加載你的模塊時，你也許注意到了這些輸出信息：

# insmod xxxxxx.o
Warning: loading xxxxxx.o will taint the kernel: no license
  See https://www.tux.org/lkml/#export-tainted for information about tainted modules
Hello, world 3
Module xxxxxx loaded, with warnings
	

在2.4或更新的內核中，一種識別代碼是否在GPL許可下發布的機製被引入， 因此人們可以在使用非公開的源代碼產品時得到警告。這通過在下一章展示的宏 MODULE_LICENSE()當你設置在GPL證書下發布你的代碼時， 你可以取消這些警告。這種證書機製在頭文件linux/module.h 實現，同時還有一些相關文檔信息。

/*
 * The following license idents are currently accepted as indicating free
 * software modules
 *
 *	"GPL"				[GNU Public License v2 or later]
 *	"GPL v2"			[GNU Public License v2]
 *	"GPL and additional rights"	[GNU Public License v2 rights and more]
 *	"Dual BSD/GPL"			[GNU Public License v2
 *					 or BSD license choice]
 *	"Dual MPL/GPL"			[GNU Public License v2
 *					 or Mozilla license choice]
 *
 * The following other idents are available
 *
 *	"Proprietary"			[Non free products]
 *
 * There are dual licensed components, but when running with Linux it is the
 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
 * is a GPL combined work.
 *
 * This exists for several reasons
 * 1.	So modinfo can show license info for users wanting to vet their setup 
 *	is free
 * 2.	So the community can ignore bug reports including proprietary modules
 * 3.	So vendors can do likewise based on their own policies
 */

類似的，宏MODULE_DESCRIPTION()用來描述模塊的用途。 宏MODULE_AUTHOR()用來聲明模塊的作者。宏MODULE_SUPPORTED_DEVICE() 聲明模塊支持的設備。

這些宏都在頭文件linux/module.h定義， 並且內核本身並不使用這些宏。它們隻是用來提供識別信息，可用工具程序像objdump查看。 作為一個練習，使用grep從目錄linux/drivers看一看這些模塊的作者是如何 為他們的模塊提供識別信息和檔案的。

我推薦在/usr/src/linux-2.6.x/目錄下使用類似grep -inr MODULE_AUTHOR *的命令。不熟悉命令行工具的人可能喜歡網上那樣的方法， 搜索提供LXR做索引的內核源代碼樹的網站（或在自己的本地機器上安裝它）。

使用像emacs或vi那樣傳統的Unix編輯器的用戶將會發現tag文件很有用。它們能夠在/usr/src/linux-2.6.x/ 下用make tags或make TAGS生成。 一旦你在內核目錄樹中得到了這種tag文件，你就能把鼠標放到某個函數調用上使用一些組合鍵直接跳 到函數的定義處。

/*  
 *  hello-4.c - Demonstrates module documentation.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#define DRIVER_AUTHOR "Peter Jay Salzman <p@dirac.org>"
#define DRIVER_DESC   "A sample driver"

static int __init init_hello_4(void)
{
	printk(KERN_INFO "Hello, world 4\n");
	return 0;
}

static void __exit cleanup_hello_4(void)
{
	printk(KERN_INFO "Goodbye, world 4\n");
}

module_init(init_hello_4);
module_exit(cleanup_hello_4);

/*  
 *  You can use strings, like this:
 */

/* 
 * Get rid of taint message by declaring code as GPL. 
 */
MODULE_LICENSE("GPL");

/*
 * Or with defines, like this:
 */
MODULE_AUTHOR(DRIVER_AUTHOR);	/* Who wrote this module? */
MODULE_DESCRIPTION(DRIVER_DESC);	/* What does this module do */

/*  
 *  This module uses /dev/testdevice.  The MODULE_SUPPORTED_DEVICE macro might
 *  be used in the future to help automatic configuration of modules, but is 
 *  currently unused other than for documentation purposes.
 */
MODULE_SUPPORTED_DEVICE("testdevice");

2.6. 從命令行傳遞參數給內核模塊

模塊也可以從命令行獲取參數。但不是通過以前你習慣的argc/argv。

要傳遞參數給模塊，首先將獲取參數值的變量聲明為全局變量。然後使用宏MODULE_PARM()(在頭文件linux/module.h)。運行時，insmod將給變量賦予命令行的參數，如同 ./insmod mymodule.ko myvariable=5。為使代碼清晰，變量的聲明和宏都應該放在 模塊代碼的開始部分。以下的代碼範例也許將比我公認差勁的解說更好。

宏module_param()需要三個參數，變量的名字，其類型和在sysfs中關聯文件的權限。 整數型既可為通常的signed也可為unsigned。 如果你想使用整數數組或者字符串，請看module_param_array()和module_param_string()。

int myint = 3;
module_param(myint, int, 0);

數組同樣被支持。但是情況和2.4時代有點不一樣了。為了追蹤參數的個數，你需要傳遞一個指向數目變量的指針作為第三個參數。 在你自己，你也可以忽略數目並傳遞NULL。我們把兩種可能性都列出來：

int myintarray[2];
module_param_array(myintarray, int, NULL, 0); /* not interested in count */
int myshortarray[4];
int count;
module_parm_array(myshortarray, short, & count, 0); /* put count into "count" variable */

將初始值設為缺省使用的IO端口或IO尋址是一個不錯的作法。如果這些變量有缺省值，則可以進行自動設備檢測， 否則保持當前設置的值。我們將在後續章節解釋清楚相關內容。在這裏我隻是演示如何向一個模塊傳遞參數。

最後，還有這樣一個宏，MODULE_PARM_DESC()被用來注解該模塊可以接收的參數。該宏 兩個參數：變量名和一個格式自由的對該變量的描述。

/*
 *  hello-5.c - Demonstrates command line argument passing to a module.
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/stat.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Peter Jay Salzman");

static short int myshort = 1;
static int myint = 420;
static long int mylong = 9999;
static char *mystring = "blah";
static int myintArray[2] = { -1, -1 };
static int arr_argc = 0;

/* 
 * module_param(foo, int, 0000)
 * The first param is the parameters name
 * The second param is it's data type
 * The final argument is the permissions bits, 
 * for exposing parameters in sysfs (if non-zero) at a later stage.
 */

module_param(myshort, short, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
MODULE_PARM_DESC(myshort, "A short integer");
module_param(myint, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
MODULE_PARM_DESC(myint, "An integer");
module_param(mylong, long, S_IRUSR);
MODULE_PARM_DESC(mylong, "A long integer");
module_param(mystring, charp, 0000);
MODULE_PARM_DESC(mystring, "A character string");

/*
 * module_param_array(name, type, num, perm);
 * The first param is the parameter's (in this case the array's) name
 * The second param is the data type of the elements of the array
 * The third argument is a pointer to the variable that will store the number
 * of elements of the array initialized by the user at module loading time
 * The fourth argument is the permission bits
 */
module_param_array(myintArray, int, &arr_argc, 0000);
MODULE_PARM_DESC(myintArray, "An array of integers");

static int __init hello_5_init(void)
{
	int i;
	printk(KERN_INFO "Hello, world 5\n=============\n");
	printk(KERN_INFO "myshort is a short integer: %hd\n", myshort);
	printk(KERN_INFO "myint is an integer: %d\n", myint);
	printk(KERN_INFO "mylong is a long integer: %ld\n", mylong);
	printk(KERN_INFO "mystring is a string: %s\n", mystring);
	for (i = 0; i < (sizeof myintArray / sizeof (int)); i++)
	{
		printk(KERN_INFO "myintArray[%d] = %d\n", i, myintArray[i]);
	}
	printk(KERN_INFO "got %d arguments for myintArray.\n", arr_argc);
	return 0;
}

static void __exit hello_5_exit(void)
{
	printk(KERN_INFO "Goodbye, world 5\n");
}

module_init(hello_5_init);
module_exit(hello_5_exit);

我建議用下麵的方法實驗你的模塊：

satan# insmod hello-5.ko mystring="bebop" mybyte=255 myintArray=-1
mybyte is an 8 bit integer: 255
myshort is a short integer: 1
myint is an integer: 20
mylong is a long integer: 9999
mystring is a string: bebop
myintArray is -1 and 420
satan# rmmod hello-5
Goodbye, world 5
satan# insmod hello-5.ko mystring="supercalifragilisticexpialidocious" \
> mybyte=256 myintArray=-1,-1
mybyte is an 8 bit integer: 0
myshort is a short integer: 1
myint is an integer: 20
mylong is a long integer: 9999
mystring is a string: supercalifragilisticexpialidocious
myintArray is -1 and -1
satan# rmmod hello-5
Goodbye, world 5
satan# insmod hello-5.ko mylong=hello
hello-5.o: invalid argument syntax for mylong: 'h'

2.7. 由多個文件構成的內核模塊

有時將模塊的源代碼分為幾個文件是一個明智的選擇。

這裏是這樣的一個模塊範例。

/*
 *  start.c - Illustration of multi filed modules
 */

#include <linux/kernel.h>	/* We're doing kernel work */
#include <linux/module.h>	/* Specifically, a module */

int init_module(void)
{
	printk(KERN_INFO "Hello, world - this is the kernel speaking\n");
	return 0;
}

另一個文件：

/*
 *  stop.c - Illustration of multi filed modules
 */

#include <linux/kernel.h>	/* We're doing kernel work */
#include <linux/module.h>	/* Specifically, a module  */

void cleanup_module()
{
	printk(KERN_INFO "Short is the life of a kernel module\n");
}

最後是該模塊的Makefile：

obj-m += hello-1.o
obj-m += hello-2.o
obj-m += hello-3.o
obj-m += hello-4.o
obj-m += hello-5.o
obj-m += startstop.o
startstop-objs := start.o stop.o

all:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
       
clean:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

2.8. 為已編譯的內核編譯模塊

很顯然，我們強烈推薦你編譯一個新的內核，這樣你就可以打開內核中一些有用的排錯功能，像強製卸載模塊(MODULE_FORCE_UNLOAD)： 當該選項被打開時，你可以rmmod -f module強製內核卸載一個模塊，即使內核認為這是不安全的。該選項可以為你節省不少開發時間。

但是，你仍然有許多使用一個正在運行中的已編譯的內核的理由。例如，你沒有編譯和安裝新內核的權限，或者你不希望重啟你的機器來運行新內核。 如果你可以毫無阻礙的編譯和使用一個新的內核，你可以跳過剩下的內容，權當是一個腳注。

如果你僅僅是安裝了一個新的內核代碼樹並用它來編譯你的模塊，當你加載你的模塊時，你很可能會得到下麵的錯誤提示：

insmod: error inserting 'poet_atkm.ko': -1 Invalid module format
	

一些不那麼神秘的信息被紀錄在文件/var/log/messages中；

Jun  4 22:07:54 localhost kernel: poet_atkm: version magic '2.6.5-1.358custom 686 
REGPARM 4KSTACKS gcc-3.3' should be '2.6.5-1.358 686 REGPARM 4KSTACKS gcc-3.3'
	

換句話說，內核拒絕加載你的模塊因為記載版本號的字符串不符(更確切的說是版本印戳)。版本印戳作為一個靜態的字符串存在於內核模塊中，以 vermagic:。 版本信息是在連接階段從文件init/vermagic.o中獲得的。 查看版本印戳和其它在模塊中的一些字符信息，可以使用下麵的命令 modinfo module.ko：

[root@pcsenonsrv 02-HelloWorld]# modinfo hello-4.ko 
license:        GPL
author:         Peter Jay Salzman <p@dirac.org>
description:    A sample driver
vermagic:       2.6.5-1.358 686 REGPARM 4KSTACKS gcc-3.3
depends:        
	

我們可以借助選項--force-vermagic解決該問題，但這種方法有潛在的危險，所以在成熟的模塊中也是不可接受的。 解決方法是我們構建一個同我們預先編譯好的內核完全相同的編譯環境。如何具體實現將是該章後麵的內容。

首先，準備同你目前的內核版本完全一致的內核代碼樹。然後，找到你的當前內核的編譯配置文件。通常它可以在路徑 /boot下找到，使用像config-2.6.x的文件名。你可以直接將它拷貝到內核代碼樹的路徑下： cp /boot/config-`uname -r` /usr/src/linux-`uname -r`/.config。

讓我們再次注意一下先前的錯誤信息：仔細看的話你會發現，即使使用完全相同的配置文件，版本印戳還是有細小的差異的，但這足以導致 模塊加載的失敗。這其中的差異就是在模塊中出現卻不在內核中出現的custom字符串，是由某些發行版提供的修改過的 makefile導致的。檢查/usr/src/linux/Makefile，確保下麵這些特定的版本信息同你使用的內核完全一致：

VERSION = 2
PATCHLEVEL = 6
SUBLEVEL = 5
EXTRAVERSION = -1.358custom
...
	

像上麵的情況你就需要將EXTRAVERSION一項改為-1.358。我們的建議是將原始的makefile備份在 /lib/modules/2.6.5-1.358/build下。 一個簡單的命令cp /lib/modules/`uname -r`/build/Makefile /usr/src/linux-`uname -r`即可。 另外，如果你已經在運行一個由上麵的錯誤的Makefile編譯的內核，你應該重新執行 make，或直接對應/lib/modules/2.6.x/build/include/linux/version.h從文件 /usr/src/linux-2.6.x/include/linux/version.h修改UTS_RELEASE，或用前者覆蓋後者的。

現在，請執行make來更新設置和版本相關的頭文件，目標文件：

[root@pcsenonsrv linux-2.6.x]# make
CHK     include/linux/version.h
UPD     include/linux/version.h
SYMLINK include/asm -> include/asm-i386
SPLIT   include/linux/autoconf.h -> include/config/*
HOSTCC  scripts/basic/fixdep
HOSTCC  scripts/basic/split-include
HOSTCC  scripts/basic/docproc
HOSTCC  scripts/conmakehash
HOSTCC  scripts/kallsyms
CC      scripts/empty.o
...
	

如果你不是確實想編譯一個內核，你可以在SPLIT後通過按下CTRL-C中止編譯過程。因為此時你需要的文件 已經就緒了。現在你可以返回你的模塊目錄然後編譯加載它：此時模塊將完全針對你的當前內核編譯，加載時也不會由任何錯誤提示。

3.1. 內核模塊對比用戶程序

#include <stdio.h>
int main(void)
{ printf("hello"); return 0; }
		

# ls -l /dev/hda[1-3]
brw-rw----  1 root  disk  3, 1 Jul  5  2000 /dev/hda1
brw-rw----  1 root  disk  3, 2 Jul  5  2000 /dev/hda2
brw-rw----  1 root  disk  3, 3 Jul  5  2000 /dev/hda3
		

crw-rw----  1 root  dial 4, 64 Feb 18 23:34 /dev/ttyS0
crw-r-----  1 root  dial 4, 65 Nov 17 10:26 /dev/ttyS1
crw-rw----  1 root  dial 4, 66 Jul  5  2000 /dev/ttyS2
crw-rw----  1 root  dial 4, 67 Jul  5  2000 /dev/ttyS3