Linux字符设备架构是如何实现的？

2020-12-18 14:12

／／从上一次文件位置指针的位置开始写入数据
kbuf ＝ mycd－＞buffer ＋＊ppos；
／／拷贝数据到内核空间
ret ＝ copy＿from＿user（kbuf， ubuf， n）；
if（ret ！＝ 0）
return －EFAULT；
／／更新文件位置指针的值
＊ppos ＋＝ n；
／／更新dev＿fifo．len
mycd－＞len ＋＝ n；
printk（＂dev＿fifo＿write success！＂）；
return n；
｝
／／linux 内核在2．6以后，已经废弃了ioctl函数指针结构，取而代之的是
long dev＿fifo＿unlocked＿ioctl（struct file ＊file， unsigned int cmd，
unsigned long arg）
｛
int ret ＝ 0；
struct mycdev ＊mycd ＝ file－＞private＿data；
if（＿IOC＿TYPE（cmd）！＝DEV＿FIFO＿TYPE）｛
pr＿err（＂cmd ％u，bad magic 0x％x／0x％x．＂，cmd，＿IOC＿TYPE（cmd），DEV＿FIFO＿TYPE）；
return－ENOTTY；
｝
if（＿IOC＿DIR（cmd）＆＿IOC＿READ）
ret＝！access＿ok（VERIFY＿WRITE，（void ＿＿user＊）arg，＿IOC＿SIZE（cmd））；
else if（＿IOC＿DIR（cmd）＆＿IOC＿WRITE ）
ret＝！access＿ok（VERIFY＿READ，（void ＿＿user＊）arg，＿IOC＿SIZE（cmd））；
if（ret）｛
pr＿err（＂bad access ％ld．＂，ret）；
return－EFAULT；
｝
switch（cmd）
｛
case DEV＿FIFO＿CLEAN：
printk（＂CMD：CLEAN＂）；
memset（mycd－＞buffer， 0， sizeof（mycd－＞buffer））；
break；
case DEV＿FIFO＿SETVALUE：
printk（＂CMD：SETVALUE＂）；
mycd－＞len ＝ arg；
break；
case DEV＿FIFO＿GETVALUE：
printk（＂CMD：GETVALUE＂）；
ret ＝ put＿user（mycd－＞len，（int ＊）arg）；
break；
default：
return －EFAULT；
｝
return ret；
｝
／／设备操作函数接口
static const struct file＿operations fifo＿operations ＝｛
．owner ＝ THIS＿MODULE，
．open ＝ dev＿fifo＿open，
．read ＝ dev＿fifo＿read，
．write ＝ dev＿fifo＿write，
．unlocked＿ioctl ＝ dev＿fifo＿unlocked＿ioctl，
｝；
／／模块入口
int ＿＿init dev＿fifo＿init（void）
｛
int i ＝ 0；
int n ＝ 0；
int ret；
struct device ＊device；
gcd ＝ kzalloc（ndevices ＊ sizeof（struct mycdev）， GFP＿KERNEL）；
if（！gcd）｛
return －ENOMEM；
｝
／／设备号：主设备号（12bit）｜次设备号（20bit）
dev＿num ＝ MKDEV（MAJOR＿NUM， 0）；
／／静态注册设备号
ret ＝ register＿chrdev＿region（dev＿num，ndevices，＂dev＿fifo＂）；
if（ret ＜ 0）｛
／／静态注册失败，进行动态注册设备号
ret ＝alloc＿chrdev＿region（＆dev＿num，0，ndevices，＂dev＿fifo＂）；
if（ret ＜ 0）｛
printk（＂Fail to register＿chrdev＿region＂）；
goto err＿register＿chrdev＿region；
｝
｝
／／创建设备类
cls ＝ class＿create（THIS＿MODULE，＂dev＿fifo＂）；
if（IS＿ERR（cls））｛
ret ＝ PTR＿ERR（cls）；
goto err＿class＿create；
｝
printk（＂ndevices ：％d＂，ndevices）；
for（n ＝ 0；n ＜ ndevices；n ＋＋）
｛
／／初始化字符设备
cdev＿init（＆gcd［n］．cdev，＆fifo＿operations）；
／／添加设备到操作系统
ret ＝ cdev＿add（＆gcd［n］．cdev，dev＿num ＋ n，1）；
if （ret ＜ 0）
｛
goto err＿cdev＿add；
｝
／／导出设备信息到用户空间（／sys／class／类名／设备名）
device ＝ device＿create（cls，NULL，dev＿num ＋n，NULL，＂dev＿fifo％d＂，n）；
if（IS＿ERR（device））｛
ret ＝ PTR＿ERR（device）；
printk（＂Fail to device＿create＂）；
goto err＿device＿create；
｝
｝
printk（＂Register dev＿fito to system，ok！＂）；
return 0；
err＿device＿create：
／／将已经导出的设备信息除去
for（i ＝ 0；i ＜ n；i ＋＋）
｛
device＿destroy（cls，dev＿num ＋ i）；
｝
err＿cdev＿add：
／／将已经添加的全部除去
for（i ＝ 0；i ＜ n；i ＋＋）
｛
cdev＿del（＆gcd［i］．cdev）；
｝
err＿class＿create：
unregister＿chrdev＿region（dev＿num， ndevices）；
err＿register＿chrdev＿region：
return ret；
｝
void ＿＿exit dev＿fifo＿exit（void）
｛
int i；
／／删除sysfs文件系统中的设备
for（i ＝ 0；i ＜ ndevices；i ＋＋）
｛
device＿destroy（cls，dev＿num ＋ i）；
｝
／／删除系统中的设备类
class＿destroy（cls）；
／／从系统中删除添加的字符设备
for（i ＝ 0；i ＜ ndevices；i ＋＋）
｛
cdev＿del（＆gcd［i］．cdev）；
｝
／／释放申请的设备号
unregister＿chrdev＿region（dev＿num， ndevices）；
return；
｝
module＿init（dev＿fifo＿init）；
module＿exit（dev＿fifo＿exit）；

头文件内容：

dev＿fifo＿head．h

＃ifndef ＿DEV＿FIFO＿HEAD＿H
＃define ＿DEV＿FIFO＿HEAD＿H
＃define DEV＿FIFO＿TYPE ＇k＇
＃define DEV＿FIFO＿CLEAN ＿IO（DEV＿FIFO＿TYPE，0x10）
＃define DEV＿FIFO＿GETVALUE ＿IOR（DEV＿FIFO＿TYPE，0x11，int）
＃define DEV＿FIFO＿SETVALUE ＿IOW（DEV＿FIFO＿TYPE，0x12，int）
＃endif

Makefile ：

ifeq （＄（KERNELRELEASE），）
KERNEL＿DIR ？＝／lib／modules／＄（shell uname －r）／build
PWD ：＝＄（shell pwd）
modules：
＄（MAKE）－C ＄（KERNEL＿DIR） M＝＄（PWD） modules
．PHONY：modules clean
clean：
＄（MAKE）－C ＄（KERNEL＿DIR） M＝＄（PWD） clean
else
obj－m ：＝ dev＿fifo．o
endif

应用程序：

＃include ＜stdio．h＞
＃include ＜stdlib．h＞
＃include ＜sys／types．h＞
＃include ＜string．h＞
＃include ＜sys／stat．h＞
＃include ＜fcntl．h＞
int main（int argc， const char ＊argv［］）
｛
int fd ；
int n；
char buf［1024］＝＂hello word＂；

fd ＝ open（＂／dev／dev＿fifo0＂，O＿RDWR）；
if（fd ＜ 0）｛
perror（＂Fail ot open＂）；
return －1；
｝
printf（＂open successful ，fd ＝％d＂，fd）；
n ＝ write（fd，buf，strlen（buf））；
if（n ＜ 0）｛
perror（＂Fail to write＂）；
return －1；
｝
printf（＂write ％d bytes！＂，n）；
n ＝ write（fd，buf，strlen（buf））；
if（n ＜ 0）｛
perror（＂Fail to write＂）；
return －1；
｝
printf（＂write ％d bytes！＂，n）；
return 0；
｝