Linux Block devices-finishing (i)

1. Basic Concepts:

Linux Device Driver Development (Song Baohua):

The difference between a character device and a block device I/O operation is as follows.
(1) Block devices can only accept input and return output in blocks, while character devices are in bytes.

Most devices are character devices because they do not need to be buffered and do not operate at a fixed block size.
(2) block devices have buffers for I/O requests, so they can choose in what order to respond, and character devices do not need to be buffered and read and written directly.

The order in which the read and write is adjusted for storage devices is significant because the read-write sequential sector is faster than the detached sector.
(3) Character devices can only be read and written sequentially, while block devices are randomly accessible.

Although block devices can be accessed randomly, the sequential organization of block device access can improve performance for mechanical devices such as disks.

For a block device, the most important thing is to process the request, and the queue and consolidation of the request is resolved by the I/O scheduling algorithm,

Therefore, the core of the block device driver is the request handler function or the "Manufacturing request" function.

The smallest addressable unit in a block device is a sector, the sector size is generally 2 integer multiples, and the most common size is 512 bytes.

The size of the sector is the physical property of the device, and the sector is the basic unit of all the block devices, which cannot be addressed and manipulated in comparison to its smaller units.

However, many block devices can transmit multiple sectors at once. Although the sector size of most block devices is 512 bytes,

However, other sectors of the size are also common, for example, many Cd-ro M disk sector is 2KB.

Regardless of the actual sector size of the physical device, the sectors that the kernel interacts with the block device driver are in 512-byte units

The following work is usually done in block device-driven module loading functions.
1 Assign, initialize the request queue, bind the request queue, and request the function.
2 Assign, initialize Gendisk, assign value to Gendisk's major, FoPs, queue and so on, add Gendisk finally.
3 Register block device drivers.

Specific code:

[CPP]View PlainCopy

2. #include <linux/module.h>
4. #include <linux/errno.h>
6. #include <linux/interrupt.h>
8. #include <linux/mm.h>
10. #include <linux/fs.h>
12. #include <linux/kernel.h>
14. #include <linux/timer.h>
16. #include <linux/genhd.h>
18. #include <linux/hdreg.h>
20. #include <linux/ioport.h>
22. #include <linux/init.h>
24. #include <linux/wait.h>
26. #include <linux/blkdev.h>
28. #include <linux/blkpg.h>
30. #include <linux/delay.h>
32. #include <linux/io.h>
36. #include <asm/system.h>
38. #include <asm/uaccess.h>
40. #include <asm/dma.h>
44. Static struct Gendisk *ramblock_disk;
46. Static request_queue_t *ramblock_queue;
50. static int major;
54. Static Define_spinlock (Ramblock_lock);
58. Static struct Block_device_operations ramblock_fops = {
60. . Owner = This_module,
62. };
66. #define RAMBLOCK_SIZE (1024*1024)
70. static void Do_ramblock_request (request_queue_t * q)
72. {
74. static int cnt = 0;
76. PRINTK ("Do_ramblock_request%d\n", ++cnt);
78. }
82. static int ramblock_init (void)
84. {
86. / * 1. Assign a gendisk struct * /
88. Ramblock_disk = Alloc_disk (16); /* Secondary device number: number of partitions +1 */
92. / * 2. Set * /
94. /* 2.1 Assign/Set queue: Provide read/write capability */
96. Ramblock_queue = Blk_init_queue (Do_ramblock_request, &ramblock_lock);
98. Ramblock_disk->queue = Ramblock_queue;
102. /* 2.2 Set other properties: such as capacity */
104. Major = Register_blkdev (0, "Ramblock"); / * cat/proc/devices * /
106. Ramblock_disk->major = major;
108. Ramblock_disk->first_minor = 0;
110. sprintf (Ramblock_disk->disk_name, "Ramblock");
112. Ramblock_disk->fops = &ramblock_fops;
114. Set_capacity (Ramblock_disk, ramblock_size/512);
118. / * 3. Register * /
120. Add_disk (Ramblock_disk);
124. return 0;
126. }
130. static void Ramblock_exit (void)
132. {
134. Unregister_blkdev (Major, "Ramblock");
136. Del_gendisk (Ramblock_disk);
138. Put_disk (Ramblock_disk);
140. Blk_cleanup_queue (Ramblock_queue);
142. }
146. Module_init (Ramblock_init);
148. Module_exit (Ramblock_exit);
152. Module_license ("GPL");

Linux Block devices-finishing (i)