Character Device Drivers
The file_operations Structure
The file_operations structure is defined in linux/fs.h, andholds pointers to functions defined by the driver that perform various operations on the device. Each field of thestructure corresponds to the address of some function defined by the driver to handle a requested operation.
For example, every character driver needs to define a function that reads from the device. Thefile_operations structure holds the address of the module's function that performs that operation. Here iswhat the definition looks like for kernel 2.4.2:
Some operations are not implemented by a driver. For example, a driver that handles a video card won't need to readfrom a directory structure. The corresponding entries in thefile_operations structure should be set toNULL.
There is a gcc extension that makes assigning to this structure more convenient. You'll see it in modern drivers,and may catch you by surprise. This is what the new way of assigning to the structure looks like:
1 struct file_operations fops = { 2 read: device_read, 3 write: device_write, 4 open: device_open, 5 release: device_release 6 }; 7
However, there's also a C99 way of assigning to elements of a structure, and this is definitely preferred over usingthe GNU extension. The version of gcc I'm currently using,2.95, supports the new C99 syntax. Youshould use this syntax in case someone wants to port your driver. It will help with compatibility:
1 struct file_operations fops = { 2 .read = device_read, 3 .write = device_write, 4 .open = device_open, 5 .release = device_release 6 }; 7
The meaning is clear, and you should be aware that any member of the structure which you don't explicitly assignwill be initialized toNULL by gcc.
A pointer to a struct file_operations is commonly namedfops.
The file structure
Each device is represented in the kernel by a file structure, which is defined inlinux/fs.h. Be aware that afile is a kernel level structure and never appears in auser space program. It's not the same thing as aFILE, which is defined by glibc and would never appear in akernel space function. Also, its name is a bit misleading; it represents an abstract open `file', not a file on a disk,which is represented by a structure namedinode.
A pointer to a struct file is commonly named filp. You'll also see itrefered to as struct file file. Resist the temptation.
Go ahead and look at the definition of file. Most of the entries you see, likestruct dentry aren't used by device drivers, and you can ignore them. This is because drivers don'tfillfile directly; they only use structures contained in file which are createdelsewhere.
Registering A Device
As discussed earlier, char devices are accessed through device files, usually located in/dev[1]. The major number tells you which driver handles which device file. The minor numberis used only by the driver itself to differentiate which device it's operating on, just in case the driver handles morethan one device.
Adding a driver to your system means registering it with the kernel. This is synonymous with assigning it a majornumber during the module's initialization. You do this by using theregister_chrdev function,defined bylinux/fs.h.
- int register_chrdev(unsigned int major, const char *name,
- struct file_operations *fops);
where unsigned int major is the major number you want to request,const char*name is the name of the device as it'll appear in/proc/devices andstructfile_operations *fops is a pointer to thefile_operations table for your driver. A negativereturn value means the registertration failed. Note that we didn't pass the minor number toregister_chrdev. That's because the kernel doesn't care about the minor number; only our driver usesit.
Now the question is, how do you get a major number without hijacking one that's already in use? The easiest waywould be to look throughDocumentation/devices.txt and pick an unused one. That's a bad way of doingthings because you'll never be sure if the number you picked will be assigned later. The answer is that you can ask thekernel to assign you a dynamic major number.
If you pass a major number of 0 to register_chrdev, the return value will be the dynamicallyallocated major number.The downside is that you can't make a device file in advance, since you don't know what the majornumber will be. 它這裡說了三種方法,最淺顯的做法就是動態分配後,用printk列印出新分配的主裝置號,用dmesg命令就可以產看到。然後建立裝置檔案的時候使用該主裝置號。There are a couple of ways to do this. First, the driver itself can print the newly assigned number andwe can make the device file by hand. Second, the newly registered device will have an entry in/proc/devices, and we can either make the device file by hand or write a shell script to read thefile in and make the device file. The third method is we can have our driver make the the device file using themknod system call after a successful registration and rm during the call tocleanup_module.
Unregistering A Device
We can't allow the kernel module to be rmmod'ed whenever root feels like it. If thedevice file is opened by a process and then we remove the kernel module, using the file would cause a call to the memorylocation where the appropriate function (read/write) used to be. If we're lucky, no other code was loaded there, andwe'll get an ugly error message. If we're unlucky, another kernel module was loaded into the same location, which means ajump into the middle of another function within the kernel. The results of this would be impossible to predict, but theycan't be very positive.
Normally, when you don't want to allow something, you return an error code (a negative number) from the functionwhich is supposed to do it. Withcleanup_module that's impossible because it's a void function.However, there's a counter which keeps track of how many processes are using your module. You can see what it's value isby looking at the 3rd field of/proc/modules. If this number isn't zero,rmmodwill fail. Note that you don't have to check the counter from withincleanup_module because thecheck will be performed for you by the system callsys_delete_module, defined inlinux/module.c. You shouldn't use this counter directly, but there are macros defined inlinux/modules.h which let you increase, decrease and display this counter:
-
MOD_INC_USE_COUNT: Increment the use count.
-
MOD_DEC_USE_COUNT: Decrement the use count.
-
MOD_IN_USE: Display the use count.
It's important to keep the counter accurate; if you ever do lose track of the correct usage count, you'll never beable to unload the module; it's now reboot time, boys and girls. This is bound to happen to you sooner or later during amodule's development.
chardev.c
The next code sample creates a char driver named chardev. You cancat itsdevice file (oropen the file with a program) and the driver will put the number of times the devicefile has been read from into the file. We don't support writing to the file (likeecho "hi" >/dev/hello), but catch these attempts and tell the user that the operation isn't supported. Don't worry if youdon't see what we do with the data we read into the buffer; we don't do much with it. We simply read in the data andprint a message acknowledging that we received it.
Example 4-1. chardev.c