linux裝置驅動歸納總結(三):4.ioctl的實現【轉】

weixin_34162629發表於2017-01-03

本文轉載自:http://blog.chinaunix.net/uid-25014876-id-59419.html

linux裝置驅動歸納總結(三):4.ioctl的實現

 

一、ioctl的簡介:

雖然在檔案操作結構體"struct file_operations"中有很多對應的裝置操作函式,但是有些命令是實在找不到對應的操作函式。如CD-ROM的驅動,想要一個彈出光碟機的操作,這種操作並不是所有的字元裝置都需要的,所以檔案操作結構體也不會有對應的函式操作。

 

出於這樣的原因,ioctl就有它的用處了————一些沒辦法歸類的函式就統一放在ioctl這個函式操作中,通過指定的命令來實現對應的操作。所以,ioctl函式裡面都實現了多個的對硬體的操作,通過應用層傳入的命令來呼叫相應的操作。

 

來個圖來說一下應用層與驅動函式的ioctl之間的聯絡:

上面的圖可以看出,fd通過核心後找到對應的inodefile結構體指標並傳給驅動函式,而另外兩個引數卻沒有修改(型別改了沒什麼關係)

 

簡單介紹一下函式:

int (*ioctl) (struct inode * node, struct file *filp, unsigned int cmd, unsigned long arg);

引數:

1)inodefileioctl的操作有可能是要修改檔案的屬性,或者訪問硬體。要修改

檔案屬性的話,就要用到這兩個結構體了,所以這裡傳來了它們的指標。

2)cmd:命令,接下來要長篇大論地說。

3)arg:引數,接下來也要長篇大論。

返回值:

1)如果傳入的非法命令,ioctl返回錯誤號-EINVAL

2)核心中的驅動函式返回值都有一個預設的方法,只要是正數,核心就會傻乎乎的認為這是正確的返回,並把它傳給應用層,如果是負值,核心就會認為它是錯誤號了。

Ioctl裡面多個不同的命令,那就要看它函式的實現來決定返回值了。打個比方,如果ioctl裡面有一個類似read的函式,那返回值也就可以像read一樣返回。

當然,不返回也是可以的。

 

二、ioctlcmd

 

說白了,cmd就是一個數,如果應用層傳來的數值在驅動中有對應的操作,這樣就就可以了。

 

來個最簡單的ioctl實現:3rd_char_4/1st

 

1)要先定義個命令,就用一個簡單的0,來個命令的標頭檔案,驅動和應用函式都要包含這個標頭檔案

/*test_cmd.h*/

1 #ifndef _TEST_CMD_H

2 #define _TEST_CMD_H

3

4 #define TEST_CLEAR 0

5

6 #endif /*_TEST_CMD_H*/

 

2)驅動實現ioctl

命令TEST_CLEAR的操作就是清空驅動中的kbuf

122 int test_ioctl (struct inode *node, struct file *filp, unsigned int cmd, uns igned long arg)

123 {

124 int ret = 0;

125 struct _test_t *dev = filp->private_data;

126

127 switch(cmd){

128 case TEST_CLEAR:

129 memset(dev->kbuf, 0, DEV_SIZE);

130 dev->cur_size = 0;

131 filp->f_pos = 0;

132 ret = 0;

133 break;

134 default: /*命令錯誤時的處理*/

135 P_DEBUG("error cmd!\n");

136 ret = - EINVAL;

137 break;

138 }

139

140 return ret;

141 }

 

3)再來個應用程式:

1 #include

2 #include

3 #include

4 #include

5 #include

6 #include "test_cmd.h"

7

8 int main(void)

9 {

10 char buf[20];

11 int fd;

12 int ret;

13

14 fd = open("/dev/test", O_RDWR);

15 if(fd < 0)

16 {

17 perror("open");

18 return -1;

19 }

20

21 write(fd, "xiao bai", 10); //1先寫入

22

23 ioctl(fd, TEST_CLEAR); //2再清空

24

25 ret = read(fd, buf, 10); //3再驗證

26 if(ret < 0)

27 {

28 perror("read");

29 }

30

31 close(fd);

32 return 0;

33 }

注:這裡為了read返回出錯,我修改了驅動的readwrite函式的開始時的第一個

判斷,一看就知道了。

 

4)驗證一下:

[root: 1st]# insmod test.ko

major[253] minor[0]

hello kernel

[root: 1st]# mknod /dev/test c 253 0

[root: 1st]# ./app

[test_write]write 10 bytes, cur_size:[10]

[test_write]kbuf is [xiao bai]

read: No such device or address //哈哈!出錯了!因為沒資料讀取。

 

 

按照上面的方法來定義一個命令是完全可以的,但核心開發人員發現這樣有點不對勁。

如果有兩個不同的裝置,但它們的ioctlcmd卻一樣的,哪天有誰不小心開啟錯了,並且呼叫ioctl,這樣就完蛋了。因為這個檔案裡面同樣有cmd對應實現。

為了防止這樣的事情發生,核心對cmd又有了新的定義,規定了cmd都應該不一樣。

 

三、ioctl中的cmd

 

一個cmd被分為了4個段,每一段都有各自的意義,cmd的定義在。注:但實際上中只是包含了,這說明了這是跟平臺相關的,ARM的定義在,但這檔案也是包含別的檔案,千找萬找,終於找到了。

 

在中,cmd拆分如下:

解釋一下四部分,全部都在和ioctl-number.txt這兩個文件有說明。

1)幻數:說得再好聽的名字也只不過是個0~0xff的數,佔8bit(_IOC_TYPEBITS)。這個數是用來區分不同的驅動的,像裝置號申請的時候一樣,核心有一個文件給出一些推薦的或者已經被使用的幻數。

/*Documentation/ioctl/ioctl-number.txt*/

164 'w' all CERN SCI driver

165 'y' 00-1F packet based user level communications

166<mailto:zapman@interlan.net>

167 'z' 00-3F CAN bus card

168<mailto:hdstich@connectu.ulm.circular.de>

169 'z' 40-7F CAN bus card

170<mailto:oe@port.de>

可以看到'x'是還沒有人用的,我就拿這個當幻數!

 

2)序數:用這個數來給自己的命令編號,佔8bit(_IOC_NRBITS),我的程式從1開始排序。

 

3)資料傳輸方向:佔2bit(_IOC_DIRBITS)。如果涉及到要傳參,核心要求描述一下傳輸的方向,傳輸的方向是以應用層的角度來描述的。

1)_IOC_NONE:值為0,無資料傳輸。

2)_IOC_READ:值為1,從裝置驅動讀取資料。

3)_IOC_WRITE:值為2,往裝置驅動寫入資料。

4)_IOC_READ|_IOC_WRITE:雙向資料傳輸。

 

4)資料大小:與體系結構相關ARM下佔14bit(_IOC_SIZEBITS),如果資料是int,核心給這個賦的值就是sizeof(int)

 

強調一下,核心是要求按這樣的方法把cmd分類,當然你也可以不這樣幹,這只是為了迎合核心的要求,讓自己的程式看上去很正宗。上面我的程式沒按要求照樣執行。

 

既然核心這樣定義cmd,就肯定有方法讓使用者方便定義:

_IO(type,nr) //沒有引數的命令

_IOR(type,nr,size) //該命令是從驅動讀取資料

_IOW(type,nr,size) //該命令是從驅動寫入資料

_IOWR(type,nr,size) //雙向資料傳輸

上面的命令已經定義了方向,我們要傳的是幻數(type)、序號(nr)和大小(size)。在這裡szie的引數只需要填引數的型別,如int,上面的命令就會幫你檢測型別的正確然後賦值sizeof(int)

 

有生成cmd的命令就必有拆分cmd的命令:

_IOC_DIR(cmd) //從命令中提取方向

_IOC_TYPE(cmd) //從命令中提取幻數

_IOC_NR(cmd) //從命令中提取序數

_IOC_SIZE(cmd) //從命令中提取資料大小

 

越講就越複雜了,既然講到這,隨便就講一下預定義命令。

預定義命令是由核心來識別並且實現相應的操作,換句話說,一旦你使用了這些命令,你壓根也不要指望你的驅動程式能夠收到,因為核心拿掉就把它處理掉了。

 

分為三類:

1)可用於任何檔案的命令

2)只用於普通檔案的命令

3)特定檔案系統型別的命令

 

其實上面的我三類我也沒搞懂,反正我自己隨便編了幾個數當命令都沒出錯,如果真的怕出錯,那就不要用別人已經使用的幻數就行了。

 

講了這麼多,終於要上程式了,修改一下上一個程式,讓它看起來比較有內涵。

/3rd_char/3rd_char_4/2nd

1)先改一下命令:

/*test_cmd.h*/

1 #ifndef _TEST_CMD_H

2 #define _TEST_CMD_H

3

4 #define TEST_MAGIC 'x' //定義幻數

5 #define TEST_MAX_NR 1 //定義命令的最大序數,只有一個命令當然是1

6

7 #define TEST_CLEAR _IO(TEST_MAGIC, 0)

8

9 #endif /*_TEST_CMD_H*/

 

2)既然這麼辛苦改了cmd,在驅動函式當然要做一些引數檢驗:

/*test.c*/

122 int test_ioctl (struct inode *node, struct file *filp, unsigned int cmd, unsigned long arg)

123 {

124 int ret = 0;

125 struct _test_t *dev = filp->private_data;

126

127 /*既然這麼費勁定義了命令,當然要檢驗命令是否有效*/

128 if(_IOC_TYPE(cmd) != TEST_MAGIC) return - EINVAL;

129 if(_IOC_NR(cmd) > TEST_MAX_NR) return - EINVAL;

130

131 switch(cmd){

132 case TEST_CLEAR:

133 memset(dev->kbuf, 0, DEV_SIZE);

134 dev->cur_size = 0;

135 filp->f_pos = 0;

136 ret = 0;

137 break;

138 default: /*命令錯誤時的處理*/

139 P_DEBUG("error cmd!\n");

140 ret = - EINVAL;

141 break;

142 }

143

144 return ret;

145 }

每個引數的傳入都會先檢驗一下幻數還有序數是否正確。

 

3)應用程式的驗證

結果跟上一個完全一樣,因為命令的操作沒有修改

[root: 2nd]# insmod test.ko

major[253] minor[0]

hello kernel

[root: 2nd]# mknod /dev/test c 253 0

[root: 2nd]# ./app

[test_write]write 10 bytes, cur_size:[10]

[test_write]kbuf is [xiao bai]

read: No such device or address

 

五、ioctl中的arg之整數傳參。

 

 

上面講的例子都沒有使用ioctl的傳參。這裡先要說一下ioctl傳參的方式。

 

應用層的ioctl的第三個引數是"...",這個跟printf"..."可不一樣,printf中是意味這你可以傳任意個數的引數,而ioctl最多也只能傳一個,"..."的意思是讓核心不要檢查這個引數的型別。也就是說,從使用者層可以傳入任何引數,只要你傳入的個數是1.

 

一般會有兩種的傳參方法:

1)整數,那可是省力又省心,直接使用就可以了。

2)指標,通過指標的就傳什麼型別都可以了,當然用起來就比較煩。

 

先說簡單的,使用整數作為引數:

例子,實現個命令,通過傳入引數更改偏移量,雖然llseek已經實現,這裡只是想驗證一下正數傳參的方法。

 

1)先加個命令:

1 #ifndef _TEST_CMD_H

2 #define _TEST_CMD_H

3

4 #define TEST_MAGIC 'x' //定義幻數

5 #define TEST_MAX_NR 2 //定義命令的最大序數

6

7 #define TEST_CLEAR _IO(TEST_MAGIC, 1)

8 #define TEST_OFFSET _IO(TEST_MAGIC, 2)

9

10 #endif /*_TEST_CMD_H*/

這裡有人會問了,明明你是要傳入引數,為什麼不用_IOW而用_IO定義命令呢?

原因有二:

1)因為定義資料的傳輸方向是為了好讓驅動的函式驗證資料的安全性,而一般指標才需要檢驗安全性,因為有人會惡意傳參(回想一下copy_to_user)

2)個人喜好,方便我寫程式介紹另一種傳參方法,說白了命令也只是一個數,只要不要跟預定義命令衝突就可以了。

 

2)更新test_ioctl

122 int test_ioctl (struct inode *node, struct file *filp, unsigned int cmd, uns igned long arg)

123 {

124 int ret = 0;

125 struct _test_t *dev = filp->private_data;

126

127 /*既然這麼費勁定義了命令,當然要檢驗命令是否有效*/

128 if(_IOC_TYPE(cmd) != TEST_MAGIC) return - EINVAL;

129 if(_IOC_NR(cmd) > TEST_MAX_NR) return - EINVAL;

130

131 switch(cmd){

132 case TEST_CLEAR:

133 memset(dev->kbuf, 0, DEV_SIZE);

134 dev->cur_size = 0;

135 filp->f_pos = 0;

136 ret = 0;

137 break;

138 case TEST_OFFSET: //根據傳入的引數更改偏移量

139 filp->f_pos += (int)arg;

140 P_DEBUG("change offset!\n");

141 ret = 0;

142 break;

143 default: /*命令錯誤時的處理*/

144 P_DEBUG("error cmd!\n");

145 ret = - EINVAL;

146 break;

147 }

148

149 return ret;

150 }

TSET_OFFSET命令就是根據傳參更改偏移量,不過這裡要注意一個問題,那就是引數的型別,驅動函式必須要知道從應用傳來的引數是什麼型別,不然就沒法使用。在這個函式裡,從應用層傳來的引數是int,因此在驅動中也得用int

 

3)再改一下應用程式:

1 #include

2 #include

3 #include

4 #include

5 #include

6

7 #include "test_cmd.h"

8

9 int main(void)

10 {

11 char buf[20];

12 int fd;

13 int ret;

14

15 fd = open("/dev/test", O_RDWR);

16 if(fd < 0)

17 {

18 perror("open");

19 return -1;

20 }

21

22 write(fd, "xiao bai", 10); //先寫入

23

24 ioctl(fd, TEST_OFFSET, -10); //再改偏移量

25

26 ret = read(fd, buf, 10); //再讀資料

27 printf(" buf is [%s]\n", buf);

28 if(ret < 0)

29 {

30 perror("read");

31 }

32

33 close(fd);

34 return 0;

35 }

 

4)驗證一下

[root: 3rd]# insmod test.ko

major[253] minor[0]

hello kernel

[root: 3rd]# mknod /dev/test c 253 0

[root: 3rd]# ./app

[test_write]write 10 bytes, cur_size:[10]

[test_write]kbuf is [xiao bai]

[test_ioctl]change offset! //更改偏移量

[test_read]read 10 bytes, cur_size:[0] //沒錯誤,成功讀取!

buf is [xiao bai]

 

上面的傳參很簡單把,接下來說一下以指標傳參。

考慮到引數不可能永遠只是一個正數這麼簡單,如果要傳多一點的東西,譬如是結構體,那就得用上指標了。

 

六、ioctl中的arg之指標傳參。

 

一講到從應用程式傳來的指標,就得想起我邪惡的傳入了非法指標的例子。所以,驅動程式中任何與應用層打交道的指標,都得先檢驗指標的安全性。

 

說到這檢驗又有兩種方法:

1)用的時候才檢驗。

2)一進來ioctl就檢驗。

 

先說用的時候檢驗,說白了就是用copy_xx_user系列函式,下面實現一下:

1)先定義個命令

1 #ifndef _TEST_CMD_H

2 #define _TEST_CMD_H

3

4 struct ioctl_data{

5 unsigned int size;

6 char buf[100];

7 };

8

9 #define DEV_SIZE 100

10

11 #define TEST_MAGIC 'x' //定義幻數

12 #define TEST_MAX_NR 3 //定義命令的最大序數

13

14 #define TEST_CLEAR _IO(TEST_MAGIC, 1)

15 #define TEST_OFFSET _IO(TEST_MAGIC, 2)

16 #define TEST_KBUF _IO(TEST_MAGIC, 3)

17

18 #endif /*_TEST_CMD_H*/

這裡有定義多了一個函式,雖然這個命令是涉及到了指標的傳參,但我還是_IOW,還是那一句,現在還不需要用上。

該命令的操作是傳進一個結構體指標,驅動根據結構體的內容修改kbufcur_size和偏移量。

 

2)來個實現函式:

122 int test_ioctl (struct inode *node, struct file *filp, unsigned int cmd, uns igned long arg)

123 {

124 int ret = 0;

125 struct _test_t *dev = filp->private_data;

126 struct ioctl_data val;

127

128 /*既然這麼費勁定義了命令,當然要檢驗命令是否有效*/

129 if(_IOC_TYPE(cmd) != TEST_MAGIC) return - EINVAL;

130 if(_IOC_NR(cmd) > TEST_MAX_NR) return - EINVAL;

131

132 switch(cmd){

133 case TEST_CLEAR:

134 memset(dev->kbuf, 0, DEV_SIZE);

135 dev->cur_size = 0;

136 filp->f_pos = 0;

137 ret = 0;

138 break;

139 case TEST_OFFSET: //根據傳入的引數更改偏移量

140 filp->f_pos += (int)arg;

141 P_DEBUG("change offset!\n");

142 ret = 0;

143 break;

144 case TEST_KBUF: //修改kbuf

145 if(copy_from_user(&val, (struct ioctl_data *)arg, sizeof(struct ioctl_data))){

146 ret = - EFAULT;

147 goto RET;

148 }

149 memset(dev->kbuf, 0, DEV_SIZE);

150 memcpy(dev->kbuf, val.buf, val.size);

151 dev->cur_size = val.size;

152 filp->f_pos = 0;

153 ret = 0;

154 break;

155 default: /*命令錯誤時的處理*/

156 P_DEBUG("error cmd!\n");

157 ret = - EINVAL;

158 break;

159 }

160

161 RET:

162 return ret;

163 }

145行,因為指標是從使用者程式傳來,所以必須檢查安全性。

 

3)來個應用程式

9 int main(void)

10 {

11 char buf[20];

12 int fd;

13 int ret;

14

15 struct ioctl_data my_data= {

16 .size = 10,

17 .buf = "123456789"

18 };

19

20 fd = open("/dev/test", O_RDWR);

21 if(fd < 0)

22 {

23 perror("open");

24 return -1;

25 }

26

27 write(fd, "xiao bai", 10);

28

29 ioctl(fd, TEST_KBUF, &my_data);

30

31 ret = read(fd, buf, 10);

32 printf(" buf is [%s]\n", buf);

33 if(ret < 0)

34 {

35 perror("read");

36 }

37

38 close(fd);

39 return 0;

40 }

 

4)再來驗證一下:

[root: 4th]# ./app

[test_write]write 10 bytes, cur_size:[10]

[test_write]kbuf is [xiao bai]

[test_read]read 10 bytes, cur_size:[0]

buf is [123456789] //成功!

注:類似copy_xx_user的函式含有put_userget_user等,我就不細說了。

 

下面說第二種方法:進入ioctl後使用access_ok檢測。

宣告一下:下面的驗證方法是不正確的。如果不想看下去的話,今天的內容已經講完了。

 

先說一下access_ok的使用

access_ok(type, addr, size)

使用:檢測地址的安全性

引數:

type:用於指定資料傳輸的方向,VERIFY_READ表示要讀取應用層資料,VERIFT_WRITE表示要往應用層寫如資料。注意:這裡和IOR IOW的方向相反。如果既讀取又寫入,那就使用VERIFY_WRITE

addr:使用者空間的地址

size:資料的大小

返回值:

成功返回1,失敗返回0

 

既然知道怎麼用,就直接來程式了:

1)定義命令

1 #ifndef _TEST_CMD_H

2 #define _TEST_CMD_H

3

4 struct ioctl_data{

5 unsigned int size;

6 char buf[100];

7 };

8

9 #define DEV_SIZE 100

10

11 #define TEST_MAGIC 'x' //定義幻數

12 #define TEST_MAX_NR 3 //定義命令的最大序數

13

14 #define TEST_CLEAR _IO(TEST_MAGIC, 1)

15 #define TEST_OFFSET _IO(TEST_MAGIC, 2)

16 #define TEST_KBUF _IOW(TEST_MAGIC, 3, struct ioctl_data)

17

18 #endif /*_TEST_CMD_H*/

這裡終於要用_IOW了!

 

2)實現ioctl

122 int test_ioctl (struct inode *node, struct file *filp, unsigned int cmd, uns igned long arg)

123 {

124 int ret = 0;

125 struct _test_t *dev = filp->private_data;

126

127 /*既然這麼費勁定義了命令,當然要檢驗命令是否有效*/

128 if(_IOC_TYPE(cmd) != TEST_MAGIC) return - EINVAL;

129 if(_IOC_NR(cmd) > TEST_MAX_NR) return - EINVAL;

130 /*根據提取命令指定的方向判斷指標的安全性*/

131 if(_IOC_DIR(cmd) & _IOC_READ)

132 ret = access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));

133 else if(_IOC_DIR(cmd) & _IOC_WRITE)

134 ret = access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));

135 if(!ret) return - EFAULT;

136

137 switch(cmd){

138 case TEST_CLEAR:

139 memset(dev->kbuf, 0, DEV_SIZE);

140 dev->cur_size = 0;

141 filp->f_pos = 0;

142 ret = 0;

143 break;

144 case TEST_OFFSET: //根據傳入的引數更改偏移量

145 filp->f_pos += (int)arg;

146 P_DEBUG("change offset!\n");

147 ret = 0;

148 break;

149 case TEST_KBUF: //修改kbuf

150 memset(dev->kbuf, 0, DEV_SIZE);

151 memcpy(dev->kbuf, ((struct ioctl_data *)arg)->buf,

152 ((struct ioctl_data *)arg)->size);

153 dev->cur_size = ((struct ioctl_data *)arg)->size;

154 filp->f_pos = 0;

155 ret = 0;

156 break;

157 default: /*命令錯誤時的處理*/

158 P_DEBUG("error cmd!\n");

159 ret = - EINVAL;

160 break;

161 }

162

163 return ret;

164 }

上面並沒有用copy_to_user,而是通過access_ok來檢測。

 

3)再來個應用程式:

9 int main(void)

10 {

11 char buf[20];

12 int fd;

13 int ret;

14

15 struct ioctl_data my_data= {

16 .size = 10,

17 .buf = "123456789"

18 };

19

20 fd = open("/dev/test", O_RDWR);

21 if(fd < 0)

22 {

23 perror("open");

24 return -1;

25 }

26

27 write(fd, "xiao bai", 10);

28

29 ret = ioctl(fd, TEST_KBUF, &my_data);

30 if(ret < 0)

31 {

32 perror("ioctl");

33 }

34

35 ret = read(fd, buf, 10);

36 printf(" buf is [%s]\n", buf);

37 if(ret < 0)

38 {

39 perror("read");

40 }

41

42 close(fd);

43 return 0;

44 }

 

4)驗證一下:效果和上一個一樣

[root: 5th]# ./app

[test_write]write 10 bytes, cur_size:[10]

[test_write]kbuf is [xiao bai]

[test_read]read 10 bytes, cur_size:[0]

buf is [123456789]

 

下面就要如正題了,這個驅動是有問題的,那就是驗證安全性完全不起作用!當我傳入非法指標時,驅動同樣會輸出,不信可以自己傳個邪惡地址(void *)0進去試一下。

 

修改應用程式一樣程式碼:

29 ret = ioctl(fd, TEST_KBUF, &my_data);

 

上面是我做的錯誤實現,我本來想驗證,只要經過access_ok檢驗,資料就會安全,沒想到經過access_ok檢驗之後照樣會出錯。

但是,copy_to_user同樣是先呼叫access_ok再呼叫memcpy,它卻沒出錯。這個我事情我現在都沒搞明白,如果誰知道了麻煩指點一下。

 

我查了裝置驅動第三版,在144頁有這樣的說法:

1.access_ok並沒有做完的所有的記憶體檢查,

2.大多數的驅動程式碼都不是用access_ok的,後面的記憶體管理會講述。

 

在這裡書本上有這樣的約定:(都是我自己的理解)

1.傳入指標需要檢查安全性。memcpy函式儘量不要在核心中使用。

2.copy_to_user.copy_from_user.get_user.put_user函式會再拷貝資料前檢測指標的安全性。不需要access_ok

3.如果在ioctl函式開頭使用了accsee_ok檢驗資料,接下來的程式碼可以使用__put_user__get_user這些不需要檢測的函式(書上有例子)

 

雖然還有寫東西還沒搞懂,但個人覺得,如果使用個access_ok要這麼麻煩的話,那我就不用好了,以後我就使用copy_xx_user函式,省力又省心。

 

 

 

七、總結:

 

這次講了ioctl的實現:

1)命令是怎麼定義。

2)引數怎麼傳遞。

 

相關文章