linux裝置驅動第三篇：寫一個簡單的字元裝置驅動

阿新 • • 發佈：2019-01-05

在linux裝置驅動第一篇：裝置驅動程式簡介中簡單介紹了字元驅動，本篇簡單介紹如何寫一個簡單的字元裝置驅動。本篇借鑑LDD中的原始碼，實現一個與硬體裝置無關的字元裝置驅動，僅僅操作從核心中分配的一些記憶體。

下面就開始學習如何寫一個簡單的字元裝置驅動。首先我們來分解一下字元裝置驅動都有那些結構或者方法組成，也就是說實現一個可以使用的字元裝置驅動我們必須做些什麼工作。

1、主裝置號和次裝置號

對於字元裝置的訪問是通過檔案系統中的裝置名稱進行的。他們通常位於/dev目錄下。如下：

[email protected]:~$ ls -l /dev/
total 0
brw-rw----  1 root disk        7,   0  3月 25 10:34 loop0
brw-rw----  1 root disk        7,   1  3月 25 10:34 loop1
brw-rw----  1 root disk        7,   2  3月 25 10:34 loop2
crw-rw-rw-  1 root tty         5,   0  3月 25 12:48 tty
crw--w----  1 root tty         4,   0  3月 25 10:34 tty0
crw-rw----  1 root tty         4,   1  3月 25 10:34 tty1
crw--w----  1 root tty         4,  10  3月 25 10:34 tty10

其中b代表塊裝置，c代表字元裝置。對於普通檔案來說，ls -l會列出檔案的長度，而對於裝置檔案來說，上面的7,5,4等代表的是對應裝置的主裝置號，而後面的0,1,2,10等則是對應裝置的次裝置號。那麼主裝置號和次裝置號分別代表什麼意義呢？一般情況下，可以這樣理解，主裝置號標識裝置對應的驅動程式，也就是說1個主裝置號對應一個驅動程式。當然，現在也有多個驅動程式共享主裝置號的情況。而次裝置號有核心使用，用於確定/dev下的裝置檔案對應的具體裝置。舉一個例子，虛擬控制檯和串列埠終端有驅動程式4管理，而不同的終端分別有不同的次裝置號。

1.1、裝置編號的表達

在核心中，dev_t用來儲存裝置編號，包括主裝置號和次裝置號。在2.6的核心版本種，dev_t是一個32位的數，其中12位用來表示主裝置號，其餘20位用來標識次裝置號。通過dev_t獲取主裝置號和次裝置號使用下面的巨集： MAJOR(dev_t dev); MINOR(dev_t dev); 相反，通過主裝置號和次裝置號轉換為dev_t型別使用： MKDEV(int major, int minor);

1.2、分配和釋放裝置編號

在構建一個字元裝置之前，驅動程式首先要獲得一個或者多個裝置編號，這類似一個營業執照，有了營業執照才在核心中正常工作營業。完成此工作的函式是：

int register_chrdev_region(dev_t first, unsigned int count, const char *name);

first是要分配的裝置編號範圍的起始值。count是連續裝置的編號的個數。name是和該裝置編號範圍關聯的裝置名稱，他將出現在/proc/devices和sysfs中。此函式成功返回0，失敗返回負的錯誤碼。此函式是在已知主裝置號的情況下使用，在未知主裝置號的情況下，我們使用下面的函式：

int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, const char *name);

dev用於輸出申請到的裝置編號，firstminor要使用的第一個此裝置編號。在不使用時需要釋放這些裝置編號，已提供其他裝置程式使用：

void unregister_chrdev_region(dev_t dev, unsigned int count);

此函式多在模組的清除函式中呼叫。分配到裝置編號之後，我們只是拿到了營業執照，雖說現在已經準備的差不多了,但是我們只是從核心中申請到了裝置號,應用程式還是不能對此裝置作任何事情,我們需要一個簡單的函式來把裝置編號和此裝置能實現的功能連線起來,這樣我們的模組才能提供具體的功能.這個操作很簡單，稍後就會提到，在此之前先介紹幾個重要的資料結構。

2、重要的資料結構

註冊裝置編號僅僅是完成一個字元裝置驅動的第一步。下面介紹大部分驅動都會包含的三個重要的核心的資料結構。

2.1、檔案操作file_operations

file_operations是第一個重要的結構，定義在 <linux/fs.h>, 是一個函式指標的集合，裝置所能提供的功能大部分都由此結構提供。這些操作也是裝置相關的系統呼叫的具體實現。此結構的具體實現如下所示：

struct file_operations {
        //它是一個指向擁有這個結構的模組的指標. 這個成員用來在它的操作還在被使用時阻止模組被解除安裝. 幾乎所有時間中, 它被簡單初始化為 THIS_MODULE
        struct module *owner;
        loff_t (*llseek) (struct file *, loff_t, int);
        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
        ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
        ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
        ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
        ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
        int (*iterate) (struct file *, struct dir_context *);
        unsigned int (*poll) (struct file *, struct poll_table_struct *);
        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
        int (*mmap) (struct file *, struct vm_area_struct *);
        int (*open) (struct inode *, struct file *);
        int (*flush) (struct file *, fl_owner_t id);
        int (*release) (struct inode *, struct file *);
        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
        int (*aio_fsync) (struct kiocb *, int datasync);
        int (*fasync) (int, struct file *, int);
        int (*lock) (struct file *, int, struct file_lock *);
        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
        int (*check_flags)(int);
        int (*flock) (struct file *, int, struct file_lock *);
        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
        ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
        int (*setlease)(struct file *, long, struct file_lock **);
        long (*fallocate)(struct file *file, int mode, loff_t offset,
                          loff_t len);
        int (*show_fdinfo)(struct seq_file *m, struct file *f);
};

需要說明的是這裡面的函式在驅動中不用全部實現，不支援的操作留置為NULL。

2.2、檔案結構struct file

struct file, 定義於 <linux/fs.h>, 是裝置驅動中第二個最重要的資料結構。檔案結構代表一個開啟的檔案. (它不特定給裝置驅動; 系統中每個開啟的檔案有一個關聯的 struct file 在核心空間). 它由核心在 open 時建立, 並傳遞給在檔案上操作的任何函式, 直到最後的關閉. 在檔案的所有例項都關閉後, 核心釋放這個資料結構。file結構的詳細可參考fs.h，這裡列出來幾個重要的成員。

struct file_operations *f_op：就是上面剛剛介紹的檔案操作的集合結構。
mode_t f_mode：檔案模式確定檔案是可讀的或者是可寫的(或者都是), 通過位 FMODE_READ 和 FMODE_WRITE. 你可能想在你的 open 或者 ioctl 函式中檢查這個成員的讀寫許可, 但是你不需要檢查讀寫許可, 因為核心在呼叫你的方法之前檢查. 當檔案還沒有為那種存取而開啟時讀或寫的企圖被拒絕, 驅動甚至不知道這個情況
loff_t f_pos：當前讀寫位置. loff_t 在所有平臺都是 64 位。驅動可以讀這個值, 如果它需要知道檔案中的當前位置, 但是正常地不應該改變它。
unsigned int f_flags：這些是檔案標誌, 例如 O_RDONLY, O_NONBLOCK, 和 O_SYNC. 驅動應當檢查 O_NONBLOCK 標誌來看是否是請求非阻塞操作。
void *private_data：open 系統呼叫設定這個指標為 NULL, 在為驅動呼叫 open 方法之前. 你可自由使用這個成員或者忽略它; 你可以使用這個成員來指向分配的資料, 但是接著你必須記住在核心銷燬檔案結構之前, 在 release 方法中釋放那個記憶體. private_data 是一個有用的資源, 在系統呼叫間保留狀態資訊, 我們大部分例子模組都使用它

2.3、inode 結構

inode 結構由核心在內部用來表示檔案. 因此, 它和代表開啟檔案描述符的檔案結構是不同的. 可能有代表單個檔案的多個開啟描述符的許多檔案結構, 但是它們都指向一個單個 inode 結構。

inode 結構包含大量關於檔案的資訊。但對於驅動程式編寫來說一般不用關心，暫且不說。

3、字元裝置的註冊

核心在內部使用型別 struct cdev 的結構來代表字元裝置. 在核心呼叫你的裝置操作前, 你編寫分配並註冊一個或幾個這些結構。

有 2 種方法來分配和初始化一個這些結構. 如果你想在執行時獲得一個獨立的 cdev 結構, 你可以為此使用這樣的程式碼:

struct cdev *my_cdev = cdev_alloc();
my_cdev->ops = &my_fops;

更多的情況是把cdv結構嵌入到你自己封裝的裝置結構中，這時需要使用下面的方法來分配和初始化：

void cdev_init(struct cdev *cdev, struct file_operations *fops);

後面的例子程式就是這麼做的。一旦 cdev 結構建立, 最後的步驟是把它告訴核心：

int cdev_add(struct cdev *dev, dev_t num, unsigned int count)

這裡, dev 是 cdev 結構, num 是這個裝置響應的第一個裝置號, count 是應當關聯到裝置的裝置號的數目. 常常 count 是 1。

從系統去除一個字元裝置, 呼叫:

void cdev_del(struct cdev *dev);

4、一個簡單的字元裝置

上面大致介紹了實現一個字元裝置所要做的工作，下面就來一個真實的例子來總結上面介紹的內容。原始碼中的關鍵地方已經作了註釋。

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/timer.h>
#include <asm/atomic.h>
#include <linux/slab.h>
#include <linux/device.h>

#define CDEVDEMO_MAJOR 255  /*預設cdevdemo的主裝置號*/

static int cdevdemo_major = CDEVDEMO_MAJOR;

/*裝置結構體,此結構體可以封裝裝置相關的一些資訊等
  訊號量等也可以封裝在此結構中，後續的裝置模組一般都
  應該封裝一個這樣的結構體，但此結構體中必須包含某些
  成員，對於字元裝置來說，我們必須包含struct cdev cdev*/
struct cdevdemo_dev	
{
	struct cdev cdev;
};

struct cdevdemo_dev *cdevdemo_devp;	/*裝置結構體指標*/

/*檔案開啟函式，上層對此裝置呼叫open時會執行*/
int cdevdemo_open(struct inode *inode, struct file *filp)	
{
	printk(KERN_NOTICE "======== cdevdemo_open ");
	return 0;
}

/*檔案釋放，上層對此裝置呼叫close時會執行*/
int cdevdemo_release(struct inode *inode, struct file *filp)	
{
	printk(KERN_NOTICE "======== cdevdemo_release ");	
	return 0;
}

/*檔案的讀操作，上層對此裝置呼叫read時會執行*/
static ssize_t cdevdemo_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
	printk(KERN_NOTICE "======== cdevdemo_read ");	
}

/* 檔案操作結構體，文中已經講過這個結構*/
static const struct file_operations cdevdemo_fops =
{
	.owner = THIS_MODULE,
	.open = cdevdemo_open,
	.release = cdevdemo_release,
	.read = cdevdemo_read,
};

/*初始化並註冊cdev*/
static void cdevdemo_setup_cdev(struct cdevdemo_dev *dev, int index)
{
	printk(KERN_NOTICE "======== cdevdemo_setup_cdev 1");	
	int err, devno = MKDEV(cdevdemo_major, index);
	printk(KERN_NOTICE "======== cdevdemo_setup_cdev 2");

	/*初始化一個字元裝置，裝置所支援的操作在cdevdemo_fops中*/	
	cdev_init(&dev->cdev, &cdevdemo_fops);
	printk(KERN_NOTICE "======== cdevdemo_setup_cdev 3");	
	dev->cdev.owner = THIS_MODULE;
	dev->cdev.ops = &cdevdemo_fops;
	printk(KERN_NOTICE "======== cdevdemo_setup_cdev 4");	
	err = cdev_add(&dev->cdev, devno, 1);
	printk(KERN_NOTICE "======== cdevdemo_setup_cdev 5");
	if(err)
	{
		printk(KERN_NOTICE "Error %d add cdevdemo %d", err, index);	
	}
}

int cdevdemo_init(void)
{
	printk(KERN_NOTICE "======== cdevdemo_init ");	
	int ret;
	dev_t devno = MKDEV(cdevdemo_major, 0);

	struct class *cdevdemo_class;
	/*申請裝置號，如果申請失敗採用動態申請方式*/
	if(cdevdemo_major)
	{
		printk(KERN_NOTICE "======== cdevdemo_init 1");
		ret = register_chrdev_region(devno, 1, "cdevdemo");
	}else
	{
		printk(KERN_NOTICE "======== cdevdemo_init 2");
		ret = alloc_chrdev_region(&devno,0,1,"cdevdemo");
		cdevdemo_major = MAJOR(devno);
	}
	if(ret < 0)
	{
		printk(KERN_NOTICE "======== cdevdemo_init 3");
		return ret;
	}
	/*動態申請裝置結構體記憶體*/
	cdevdemo_devp = kmalloc(sizeof(struct cdevdemo_dev), GFP_KERNEL);
	if(!cdevdemo_devp)	/*申請失敗*/
	{
		ret = -ENOMEM;
		printk(KERN_NOTICE "Error add cdevdemo");	
		goto fail_malloc;
	}

	memset(cdevdemo_devp,0,sizeof(struct cdevdemo_dev));
	printk(KERN_NOTICE "======== cdevdemo_init 3");
	cdevdemo_setup_cdev(cdevdemo_devp, 0);

	/*下面兩行是建立了一個匯流排型別，會在/sys/class下生成cdevdemo目錄
	  這裡的還有一個主要作用是執行device_create後會在/dev/下自動生成
	  cdevdemo裝置節點。而如果不呼叫此函式，如果想通過裝置節點訪問裝置
	  需要手動mknod來建立裝置節點後再訪問。*/
	cdevdemo_class = class_create(THIS_MODULE, "cdevdemo");
	device_create(cdevdemo_class, NULL, MKDEV(cdevdemo_major, 0), NULL, "cdevdemo");

	printk(KERN_NOTICE "======== cdevdemo_init 4");
	return 0;

	fail_malloc:
		unregister_chrdev_region(devno,1);
}

void cdevdemo_exit(void)	/*模組解除安裝*/
{
	printk(KERN_NOTICE "End cdevdemo");	
	cdev_del(&cdevdemo_devp->cdev);	/*登出cdev*/
	kfree(cdevdemo_devp);		/*釋放裝置結構體記憶體*/
	unregister_chrdev_region(MKDEV(cdevdemo_major,0),1);	//釋放裝置號
}

MODULE_LICENSE("Dual BSD/GPL");
module_param(cdevdemo_major, int, S_IRUGO);
module_init(cdevdemo_init);
module_exit(cdevdemo_exit);

Makefile檔案如下：

ifneq ($(KERNELRELEASE),)
obj-m := cdevdemo.o
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif

clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules.order  Module.symvers

溫馨提示：測試環境為Linux ubuntu 3.16.0-33-generic。

5、總結

本篇主要介紹了簡單字元裝置的編寫與實現以及其中的關鍵點。下一篇會主要講解下驅動的一些常用的除錯技巧。

第一時間獲得部落格更新提醒，以及更多技術資訊分享，歡迎關注個人微信公眾平臺:程式設計師互動聯盟(coder_online)，掃一掃下方二維碼或搜尋微訊號coder_online即可關注,我們可以線上交流。

linux裝置驅動第三篇：寫一個簡單的字元裝置驅動

1、主裝置號和次裝置號

1.1、裝置編號的表達

1.2、分配和釋放裝置編號

2、重要的資料結構

2.1、檔案操作file_operations

2.2、檔案結構struct file

2.3、inode 結構

3、字元裝置的註冊

4、一個簡單的字元裝置

5、總結

linux裝置驅動第三篇：寫一個簡單的字元裝置驅動

linux設備驅動第三篇：寫一個簡單的字符設備驅動

linux裝置驅動第三篇：如何實現簡單的字元裝置驅動

第三篇：Certificate Vending Machine – IoT 裝置接入 AWS IoT 平臺解決方案

Linux裝置驅動第七篇：高階字元驅動操作之阻塞IO

linux裝置驅動第四篇：從如何定位oops的程式碼行談驅動除錯方法

linux裝置驅動第五篇：驅動中的併發與竟態

Linux實戰第三篇：RHEL7.3 yum更換實戰

Android應用程式訪問linux驅動第三步：實現並向系統註冊Service

第三篇：python3的檔案讀寫操作

Python基礎第三篇：函數

第三篇：爬蟲框架 - Scrapy

第三篇：數據可視化 - ggplot2

第三篇：開發中的問題及解決方式

Shell第三篇：基本語法

第三篇：python函數

第三篇：Docker容器架構

R實戰第三篇：數據處理

R實戰第三篇：數據處理（基礎）

第三篇：用戶增刪該查及組相關操作

linux裝置驅動第三篇：寫一個簡單的字元裝置驅動

1、主裝置號和次裝置號

1.1、裝置編號的表達

1.2、分配和釋放裝置編號

2、重要的資料結構

2.1、檔案操作file_operations

2.2、檔案結構struct file

2.3、inode 結構

3、字元裝置的註冊

4、一個簡單的字元裝置

5、總結

相關推薦