2 * linux/drivers/char/raw.c
4 * Front-end raw character devices. These can be bound to any block
5 * devices to provide genuine Unix raw character device semantics.
7 * We reserve minor number 0 for a control interface. ioctl()s on this
8 * device are used to bind the other minor numbers to block devices.
11 #include <linux/init.h>
13 #include <linux/major.h>
14 #include <linux/blkdev.h>
15 #include <linux/module.h>
16 #include <linux/raw.h>
17 #include <linux/capability.h>
18 #include <linux/uio.h>
19 #include <linux/cdev.h>
20 #include <linux/device.h>
21 #include <linux/mutex.h>
22 #include <linux/smp_lock.h>
24 #include <asm/uaccess.h>
26 struct raw_device_data
{
27 struct block_device
*binding
;
31 static struct class *raw_class
;
32 static struct raw_device_data raw_devices
[MAX_RAW_MINORS
];
33 static DEFINE_MUTEX(raw_mutex
);
34 static const struct file_operations raw_ctl_fops
; /* forward declaration */
37 * Open/close code for raw IO.
39 * We just rewrite the i_mapping for the /dev/raw/rawN file descriptor to
40 * point at the blockdev's address_space and set the file handle to use
43 * Set the device's soft blocksize to the minimum possible. This gives the
44 * finest possible alignment and has no adverse impact on performance.
46 static int raw_open(struct inode
*inode
, struct file
*filp
)
48 const int minor
= iminor(inode
);
49 struct block_device
*bdev
;
52 if (minor
== 0) { /* It is the control device */
53 filp
->f_op
= &raw_ctl_fops
;
58 mutex_lock(&raw_mutex
);
61 * All we need to do on open is check that the device is bound.
63 bdev
= raw_devices
[minor
].binding
;
67 igrab(bdev
->bd_inode
);
68 err
= blkdev_get(bdev
, filp
->f_mode
);
71 err
= bd_claim(bdev
, raw_open
);
74 err
= set_blocksize(bdev
, bdev_logical_block_size(bdev
));
77 filp
->f_flags
|= O_DIRECT
;
78 filp
->f_mapping
= bdev
->bd_inode
->i_mapping
;
79 if (++raw_devices
[minor
].inuse
== 1)
80 filp
->f_path
.dentry
->d_inode
->i_mapping
=
81 bdev
->bd_inode
->i_mapping
;
82 filp
->private_data
= bdev
;
83 mutex_unlock(&raw_mutex
);
90 blkdev_put(bdev
, filp
->f_mode
);
92 mutex_unlock(&raw_mutex
);
98 * When the final fd which refers to this character-special node is closed, we
99 * make its ->mapping point back at its own i_data.
101 static int raw_release(struct inode
*inode
, struct file
*filp
)
103 const int minor
= iminor(inode
);
104 struct block_device
*bdev
;
106 mutex_lock(&raw_mutex
);
107 bdev
= raw_devices
[minor
].binding
;
108 if (--raw_devices
[minor
].inuse
== 0) {
109 /* Here inode->i_mapping == bdev->bd_inode->i_mapping */
110 inode
->i_mapping
= &inode
->i_data
;
111 inode
->i_mapping
->backing_dev_info
= &default_backing_dev_info
;
113 mutex_unlock(&raw_mutex
);
116 blkdev_put(bdev
, filp
->f_mode
);
121 * Forward ioctls to the underlying block device.
124 raw_ioctl(struct inode
*inode
, struct file
*filp
,
125 unsigned int command
, unsigned long arg
)
127 struct block_device
*bdev
= filp
->private_data
;
129 return blkdev_ioctl(bdev
, 0, command
, arg
);
132 static void bind_device(struct raw_config_request
*rq
)
134 device_destroy(raw_class
, MKDEV(RAW_MAJOR
, rq
->raw_minor
));
135 device_create(raw_class
, NULL
, MKDEV(RAW_MAJOR
, rq
->raw_minor
), NULL
,
136 "raw%d", rq
->raw_minor
);
140 * Deal with ioctls against the raw-device control interface, to bind
141 * and unbind other raw devices.
143 static int raw_ctl_ioctl(struct inode
*inode
, struct file
*filp
,
144 unsigned int command
, unsigned long arg
)
146 struct raw_config_request rq
;
147 struct raw_device_data
*rawdev
;
154 /* First, find out which raw minor we want */
156 if (copy_from_user(&rq
, (void __user
*) arg
, sizeof(rq
))) {
161 if (rq
.raw_minor
<= 0 || rq
.raw_minor
>= MAX_RAW_MINORS
) {
165 rawdev
= &raw_devices
[rq
.raw_minor
];
167 if (command
== RAW_SETBIND
) {
171 * This is like making block devices, so demand the
174 if (!capable(CAP_SYS_ADMIN
)) {
180 * For now, we don't need to check that the underlying
181 * block device is present or not: we can do that when
182 * the raw device is opened. Just check that the
183 * major/minor numbers make sense.
186 dev
= MKDEV(rq
.block_major
, rq
.block_minor
);
187 if ((rq
.block_major
== 0 && rq
.block_minor
!= 0) ||
188 MAJOR(dev
) != rq
.block_major
||
189 MINOR(dev
) != rq
.block_minor
) {
194 mutex_lock(&raw_mutex
);
196 mutex_unlock(&raw_mutex
);
200 if (rawdev
->binding
) {
201 bdput(rawdev
->binding
);
202 module_put(THIS_MODULE
);
204 if (rq
.block_major
== 0 && rq
.block_minor
== 0) {
206 rawdev
->binding
= NULL
;
207 device_destroy(raw_class
,
208 MKDEV(RAW_MAJOR
, rq
.raw_minor
));
210 rawdev
->binding
= bdget(dev
);
211 if (rawdev
->binding
== NULL
)
214 __module_get(THIS_MODULE
);
218 mutex_unlock(&raw_mutex
);
220 struct block_device
*bdev
;
222 mutex_lock(&raw_mutex
);
223 bdev
= rawdev
->binding
;
225 rq
.block_major
= MAJOR(bdev
->bd_dev
);
226 rq
.block_minor
= MINOR(bdev
->bd_dev
);
228 rq
.block_major
= rq
.block_minor
= 0;
230 mutex_unlock(&raw_mutex
);
231 if (copy_to_user((void __user
*)arg
, &rq
, sizeof(rq
))) {
245 static const struct file_operations raw_fops
= {
246 .read
= do_sync_read
,
247 .aio_read
= generic_file_aio_read
,
248 .write
= do_sync_write
,
249 .aio_write
= generic_file_aio_write_nolock
,
251 .release
= raw_release
,
253 .owner
= THIS_MODULE
,
256 static const struct file_operations raw_ctl_fops
= {
257 .ioctl
= raw_ctl_ioctl
,
259 .owner
= THIS_MODULE
,
262 static struct cdev raw_cdev
;
264 static int __init
raw_init(void)
266 dev_t dev
= MKDEV(RAW_MAJOR
, 0);
269 ret
= register_chrdev_region(dev
, MAX_RAW_MINORS
, "raw");
273 cdev_init(&raw_cdev
, &raw_fops
);
274 ret
= cdev_add(&raw_cdev
, dev
, MAX_RAW_MINORS
);
276 kobject_put(&raw_cdev
.kobj
);
280 raw_class
= class_create(THIS_MODULE
, "raw");
281 if (IS_ERR(raw_class
)) {
282 printk(KERN_ERR
"Error creating raw class.\n");
284 ret
= PTR_ERR(raw_class
);
287 device_create(raw_class
, NULL
, MKDEV(RAW_MAJOR
, 0), NULL
, "rawctl");
292 unregister_chrdev_region(dev
, MAX_RAW_MINORS
);
297 static void __exit
raw_exit(void)
299 device_destroy(raw_class
, MKDEV(RAW_MAJOR
, 0));
300 class_destroy(raw_class
);
302 unregister_chrdev_region(MKDEV(RAW_MAJOR
, 0), MAX_RAW_MINORS
);
305 module_init(raw_init
);
306 module_exit(raw_exit
);
307 MODULE_LICENSE("GPL");