URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [raw.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * linux/drivers/char/raw.c
 *
 * Front-end raw character devices.  These can be bound to any block
 * devices to provide genuine Unix raw character device semantics.
 *
 * We reserve minor number 0 for a control interface.  ioctl()s on this
 * device are used to bind the other minor numbers to block devices.
 */
 
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <linux/blkdev.h>
#include <linux/module.h>
#include <linux/raw.h>
#include <linux/capability.h>
#include <linux/uio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/mutex.h>
 
#include <asm/uaccess.h>
 
struct raw_device_data {
        struct block_device *binding;
        int inuse;
};
 
static struct class *raw_class;
static struct raw_device_data raw_devices[MAX_RAW_MINORS];
static DEFINE_MUTEX(raw_mutex);
static const struct file_operations raw_ctl_fops; /* forward declaration */
 
/*
 * Open/close code for raw IO.
 *
 * We just rewrite the i_mapping for the /dev/raw/rawN file descriptor to
 * point at the blockdev's address_space and set the file handle to use
 * O_DIRECT.
 *
 * Set the device's soft blocksize to the minimum possible.  This gives the
 * finest possible alignment and has no adverse impact on performance.
 */
static int raw_open(struct inode *inode, struct file *filp)
{
        const int minor = iminor(inode);
        struct block_device *bdev;
        int err;
 
        if (minor == 0) {        /* It is the control device */
                filp->f_op = &raw_ctl_fops;
                return 0;
        }
 
        mutex_lock(&raw_mutex);
 
        /*
         * All we need to do on open is check that the device is bound.
         */
        bdev = raw_devices[minor].binding;
        err = -ENODEV;
        if (!bdev)
                goto out;
        igrab(bdev->bd_inode);
        err = blkdev_get(bdev, filp->f_mode, 0);
        if (err)
                goto out;
        err = bd_claim(bdev, raw_open);
        if (err)
                goto out1;
        err = set_blocksize(bdev, bdev_hardsect_size(bdev));
        if (err)
                goto out2;
        filp->f_flags |= O_DIRECT;
        filp->f_mapping = bdev->bd_inode->i_mapping;
        if (++raw_devices[minor].inuse == 1)
                filp->f_path.dentry->d_inode->i_mapping =
                        bdev->bd_inode->i_mapping;
        filp->private_data = bdev;
        mutex_unlock(&raw_mutex);
        return 0;
 
out2:
        bd_release(bdev);
out1:
        blkdev_put(bdev);
out:
        mutex_unlock(&raw_mutex);
        return err;
}
 
/*
 * When the final fd which refers to this character-special node is closed, we
 * make its ->mapping point back at its own i_data.
 */
static int raw_release(struct inode *inode, struct file *filp)
{
        const int minor= iminor(inode);
        struct block_device *bdev;
 
        mutex_lock(&raw_mutex);
        bdev = raw_devices[minor].binding;
        if (--raw_devices[minor].inuse == 0) {
                /* Here  inode->i_mapping == bdev->bd_inode->i_mapping  */
                inode->i_mapping = &inode->i_data;
                inode->i_mapping->backing_dev_info = &default_backing_dev_info;
        }
        mutex_unlock(&raw_mutex);
 
        bd_release(bdev);
        blkdev_put(bdev);
        return 0;
}
 
/*
 * Forward ioctls to the underlying block device.
 */
static int
raw_ioctl(struct inode *inode, struct file *filp,
                  unsigned int command, unsigned long arg)
{
        struct block_device *bdev = filp->private_data;
 
        return blkdev_ioctl(bdev->bd_inode, NULL, command, arg);
}
 
static void bind_device(struct raw_config_request *rq)
{
        device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
                      "raw%d", rq->raw_minor);
}
 
/*
 * Deal with ioctls against the raw-device control interface, to bind
 * and unbind other raw devices.
 */
static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                        unsigned int command, unsigned long arg)
{
        struct raw_config_request rq;
        struct raw_device_data *rawdev;
        int err = 0;
 
        switch (command) {
        case RAW_SETBIND:
        case RAW_GETBIND:
 
                /* First, find out which raw minor we want */
 
                if (copy_from_user(&rq, (void __user *) arg, sizeof(rq))) {
                        err = -EFAULT;
                        goto out;
                }
 
                if (rq.raw_minor <= 0 || rq.raw_minor >= MAX_RAW_MINORS) {
                        err = -EINVAL;
                        goto out;
                }
                rawdev = &raw_devices[rq.raw_minor];
 
                if (command == RAW_SETBIND) {
                        dev_t dev;
 
                        /*
                         * This is like making block devices, so demand the
                         * same capability
                         */
                        if (!capable(CAP_SYS_ADMIN)) {
                                err = -EPERM;
                                goto out;
                        }
 
                        /*
                         * For now, we don't need to check that the underlying
                         * block device is present or not: we can do that when
                         * the raw device is opened.  Just check that the
                         * major/minor numbers make sense.
                         */
 
                        dev = MKDEV(rq.block_major, rq.block_minor);
                        if ((rq.block_major == 0 && rq.block_minor != 0) ||
                                        MAJOR(dev) != rq.block_major ||
                                        MINOR(dev) != rq.block_minor) {
                                err = -EINVAL;
                                goto out;
                        }
 
                        mutex_lock(&raw_mutex);
                        if (rawdev->inuse) {
                                mutex_unlock(&raw_mutex);
                                err = -EBUSY;
                                goto out;
                        }
                        if (rawdev->binding) {
                                bdput(rawdev->binding);
                                module_put(THIS_MODULE);
                        }
                        if (rq.block_major == 0 && rq.block_minor == 0) {
                                /* unbind */
                                rawdev->binding = NULL;
                                device_destroy(raw_class,
                                                MKDEV(RAW_MAJOR, rq.raw_minor));
                        } else {
                                rawdev->binding = bdget(dev);
                                if (rawdev->binding == NULL)
                                        err = -ENOMEM;
                                else {
                                        __module_get(THIS_MODULE);
                                        bind_device(&rq);
                                }
                        }
                        mutex_unlock(&raw_mutex);
                } else {
                        struct block_device *bdev;
 
                        mutex_lock(&raw_mutex);
                        bdev = rawdev->binding;
                        if (bdev) {
                                rq.block_major = MAJOR(bdev->bd_dev);
                                rq.block_minor = MINOR(bdev->bd_dev);
                        } else {
                                rq.block_major = rq.block_minor = 0;
                        }
                        mutex_unlock(&raw_mutex);
                        if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) {
                                err = -EFAULT;
                                goto out;
                        }
                }
                break;
        default:
                err = -EINVAL;
                break;
        }
out:
        return err;
}
 
static const struct file_operations raw_fops = {
        .read   =       do_sync_read,
        .aio_read =     generic_file_aio_read,
        .write  =       do_sync_write,
        .aio_write =    generic_file_aio_write_nolock,
        .open   =       raw_open,
        .release=       raw_release,
        .ioctl  =       raw_ioctl,
        .owner  =       THIS_MODULE,
};
 
static const struct file_operations raw_ctl_fops = {
        .ioctl  =       raw_ctl_ioctl,
        .open   =       raw_open,
        .owner  =       THIS_MODULE,
};
 
static struct cdev raw_cdev;
 
static int __init raw_init(void)
{
        dev_t dev = MKDEV(RAW_MAJOR, 0);
        int ret;
 
        ret = register_chrdev_region(dev, MAX_RAW_MINORS, "raw");
        if (ret)
                goto error;
 
        cdev_init(&raw_cdev, &raw_fops);
        ret = cdev_add(&raw_cdev, dev, MAX_RAW_MINORS);
        if (ret) {
                kobject_put(&raw_cdev.kobj);
                goto error_region;
        }
 
        raw_class = class_create(THIS_MODULE, "raw");
        if (IS_ERR(raw_class)) {
                printk(KERN_ERR "Error creating raw class.\n");
                cdev_del(&raw_cdev);
                ret = PTR_ERR(raw_class);
                goto error_region;
        }
        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), "rawctl");
 
        return 0;
 
error_region:
        unregister_chrdev_region(dev, MAX_RAW_MINORS);
error:
        return ret;
}
 
static void __exit raw_exit(void)
{
        device_destroy(raw_class, MKDEV(RAW_MAJOR, 0));
        class_destroy(raw_class);
        cdev_del(&raw_cdev);
        unregister_chrdev_region(MKDEV(RAW_MAJOR, 0), MAX_RAW_MINORS);
}
 
module_init(raw_init);
module_exit(raw_exit);
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [raw.c] - Blame information for rev 65

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* linux/drivers/char/raw.c`
3			`*`
4			`* Front-end raw character devices. These can be bound to any block`
5			`* devices to provide genuine Unix raw character device semantics.`
6			`*`
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.`
9			`*/`
10
11			`#include <linux/init.h>`
12			`#include <linux/fs.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
23			`#include <asm/uaccess.h>`
24
25			`struct raw_device_data {`
26			`struct block_device *binding;`
27			`int inuse;`
28			`};`
29
30			`static struct class *raw_class;`
31			`static struct raw_device_data raw_devices[MAX_RAW_MINORS];`
32			`static DEFINE_MUTEX(raw_mutex);`
33			`static const struct file_operations raw_ctl_fops; /* forward declaration */`
34
35			`/*`
36			`* Open/close code for raw IO.`
37			`*`
38			`* We just rewrite the i_mapping for the /dev/raw/rawN file descriptor to`
39			`* point at the blockdev's address_space and set the file handle to use`
40			`* O_DIRECT.`
41			`*`
42			`* Set the device's soft blocksize to the minimum possible. This gives the`
43			`* finest possible alignment and has no adverse impact on performance.`
44			`*/`
45			`static int raw_open(struct inode inode, struct file filp)`
46			`{`
47			`const int minor = iminor(inode);`
48			`struct block_device *bdev;`
49			`int err;`
50
51			`if (minor == 0) { /* It is the control device */`
52			`filp->f_op = &raw_ctl_fops;`
53			`return 0;`
54			`}`
55
56			`mutex_lock(&raw_mutex);`
57
58			`/*`
59			`* All we need to do on open is check that the device is bound.`
60			`*/`
61			`bdev = raw_devices[minor].binding;`
62			`err = -ENODEV;`
63			`if (!bdev)`
64			`goto out;`
65			`igrab(bdev->bd_inode);`
66			`err = blkdev_get(bdev, filp->f_mode, 0);`
67			`if (err)`
68			`goto out;`
69			`err = bd_claim(bdev, raw_open);`
70			`if (err)`
71			`goto out1;`
72			`err = set_blocksize(bdev, bdev_hardsect_size(bdev));`
73			`if (err)`
74			`goto out2;`
75			`filp->f_flags \|= O_DIRECT;`
76			`filp->f_mapping = bdev->bd_inode->i_mapping;`
77			`if (++raw_devices[minor].inuse == 1)`
78			`filp->f_path.dentry->d_inode->i_mapping =`
79			`bdev->bd_inode->i_mapping;`
80			`filp->private_data = bdev;`
81			`mutex_unlock(&raw_mutex);`
82			`return 0;`
83
84			`out2:`
85			`bd_release(bdev);`
86			`out1:`
87			`blkdev_put(bdev);`
88			`out:`
89			`mutex_unlock(&raw_mutex);`
90			`return err;`
91			`}`
92
93			`/*`
94			`* When the final fd which refers to this character-special node is closed, we`
95			`* make its ->mapping point back at its own i_data.`
96			`*/`
97			`static int raw_release(struct inode inode, struct file filp)`
98			`{`
99			`const int minor= iminor(inode);`
100			`struct block_device *bdev;`
101
102			`mutex_lock(&raw_mutex);`
103			`bdev = raw_devices[minor].binding;`
104			`if (--raw_devices[minor].inuse == 0) {`
105			`/* Here inode->i_mapping == bdev->bd_inode->i_mapping */`
106			`inode->i_mapping = &inode->i_data;`
107			`inode->i_mapping->backing_dev_info = &default_backing_dev_info;`
108			`}`
109			`mutex_unlock(&raw_mutex);`
110
111			`bd_release(bdev);`
112			`blkdev_put(bdev);`
113			`return 0;`
114			`}`
115
116			`/*`
117			`* Forward ioctls to the underlying block device.`
118			`*/`
119			`static int`
120			`raw_ioctl(struct inode inode, struct file filp,`
121			`unsigned int command, unsigned long arg)`
122			`{`
123			`struct block_device *bdev = filp->private_data;`
124
125			`return blkdev_ioctl(bdev->bd_inode, NULL, command, arg);`
126			`}`
127
128			`static void bind_device(struct raw_config_request *rq)`
129			`{`
130			`device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));`
131			`device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),`
132			`"raw%d", rq->raw_minor);`
133			`}`
134
135			`/*`
136			`* Deal with ioctls against the raw-device control interface, to bind`
137			`* and unbind other raw devices.`
138			`*/`
139			`static int raw_ctl_ioctl(struct inode inode, struct file filp,`
140			`unsigned int command, unsigned long arg)`
141			`{`
142			`struct raw_config_request rq;`
143			`struct raw_device_data *rawdev;`
144			`int err = 0;`
145
146			`switch (command) {`
147			`case RAW_SETBIND:`
148			`case RAW_GETBIND:`
149
150			`/* First, find out which raw minor we want */`
151
152			`if (copy_from_user(&rq, (void __user *) arg, sizeof(rq))) {`
153			`err = -EFAULT;`
154			`goto out;`
155			`}`
156
157			`if (rq.raw_minor <= 0 \|\| rq.raw_minor >= MAX_RAW_MINORS) {`
158			`err = -EINVAL;`
159			`goto out;`
160			`}`
161			`rawdev = &raw_devices[rq.raw_minor];`
162
163			`if (command == RAW_SETBIND) {`
164			`dev_t dev;`
165
166			`/*`
167			`* This is like making block devices, so demand the`
168			`* same capability`
169			`*/`
170			`if (!capable(CAP_SYS_ADMIN)) {`
171			`err = -EPERM;`
172			`goto out;`
173			`}`
174
175			`/*`
176			`* For now, we don't need to check that the underlying`
177			`* block device is present or not: we can do that when`
178			`* the raw device is opened. Just check that the`
179			`* major/minor numbers make sense.`
180			`*/`
181
182			`dev = MKDEV(rq.block_major, rq.block_minor);`
183			`if ((rq.block_major == 0 && rq.block_minor != 0) \|\|`
184			`MAJOR(dev) != rq.block_major \|\|`
185			`MINOR(dev) != rq.block_minor) {`
186			`err = -EINVAL;`
187			`goto out;`
188			`}`
189
190			`mutex_lock(&raw_mutex);`
191			`if (rawdev->inuse) {`
192			`mutex_unlock(&raw_mutex);`
193			`err = -EBUSY;`
194			`goto out;`
195			`}`
196			`if (rawdev->binding) {`
197			`bdput(rawdev->binding);`
198			`module_put(THIS_MODULE);`
199			`}`
200			`if (rq.block_major == 0 && rq.block_minor == 0) {`
201			`/* unbind */`
202			`rawdev->binding = NULL;`
203			`device_destroy(raw_class,`
204			`MKDEV(RAW_MAJOR, rq.raw_minor));`
205			`} else {`
206			`rawdev->binding = bdget(dev);`
207			`if (rawdev->binding == NULL)`
208			`err = -ENOMEM;`
209			`else {`
210			`__module_get(THIS_MODULE);`
211			`bind_device(&rq);`
212			`}`
213			`}`
214			`mutex_unlock(&raw_mutex);`
215			`} else {`
216			`struct block_device *bdev;`
217
218			`mutex_lock(&raw_mutex);`
219			`bdev = rawdev->binding;`
220			`if (bdev) {`
221			`rq.block_major = MAJOR(bdev->bd_dev);`
222			`rq.block_minor = MINOR(bdev->bd_dev);`
223			`} else {`
224			`rq.block_major = rq.block_minor = 0;`
225			`}`
226			`mutex_unlock(&raw_mutex);`
227			`if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) {`
228			`err = -EFAULT;`
229			`goto out;`
230			`}`
231			`}`
232			`break;`
233			`default:`
234			`err = -EINVAL;`
235			`break;`
236			`}`
237			`out:`
238			`return err;`
239			`}`
240
241			`static const struct file_operations raw_fops = {`
242			`.read = do_sync_read,`
243			`.aio_read = generic_file_aio_read,`
244			`.write = do_sync_write,`
245			`.aio_write = generic_file_aio_write_nolock,`
246			`.open = raw_open,`
247			`.release= raw_release,`
248			`.ioctl = raw_ioctl,`
249			`.owner = THIS_MODULE,`
250			`};`
251
252			`static const struct file_operations raw_ctl_fops = {`
253			`.ioctl = raw_ctl_ioctl,`
254			`.open = raw_open,`
255			`.owner = THIS_MODULE,`
256			`};`
257
258			`static struct cdev raw_cdev;`
259
260			`static int __init raw_init(void)`
261			`{`
262			`dev_t dev = MKDEV(RAW_MAJOR, 0);`
263			`int ret;`
264
265			`ret = register_chrdev_region(dev, MAX_RAW_MINORS, "raw");`
266			`if (ret)`
267			`goto error;`
268
269			`cdev_init(&raw_cdev, &raw_fops);`
270			`ret = cdev_add(&raw_cdev, dev, MAX_RAW_MINORS);`
271			`if (ret) {`
272			`kobject_put(&raw_cdev.kobj);`
273			`goto error_region;`
274			`}`
275
276			`raw_class = class_create(THIS_MODULE, "raw");`
277			`if (IS_ERR(raw_class)) {`
278			`printk(KERN_ERR "Error creating raw class.\n");`
279			`cdev_del(&raw_cdev);`
280			`ret = PTR_ERR(raw_class);`
281			`goto error_region;`
282			`}`
283			`device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), "rawctl");`
284
285			`return 0;`
286
287			`error_region:`
288			`unregister_chrdev_region(dev, MAX_RAW_MINORS);`
289			`error:`
290			`return ret;`
291			`}`
292
293			`static void __exit raw_exit(void)`
294			`{`
295			`device_destroy(raw_class, MKDEV(RAW_MAJOR, 0));`
296			`class_destroy(raw_class);`
297			`cdev_del(&raw_cdev);`
298			`unregister_chrdev_region(MKDEV(RAW_MAJOR, 0), MAX_RAW_MINORS);`
299			`}`
300
301			`module_init(raw_init);`
302			`module_exit(raw_exit);`
303			`MODULE_LICENSE("GPL");`