~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/char_dev.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/fs/char_dev.c
  3  *
  4  *  Copyright (C) 1991, 1992  Linus Torvalds
  5  */
  6 
  7 #include <linux/init.h>
  8 #include <linux/fs.h>
  9 #include <linux/kdev_t.h>
 10 #include <linux/slab.h>
 11 #include <linux/string.h>
 12 
 13 #include <linux/major.h>
 14 #include <linux/errno.h>
 15 #include <linux/module.h>
 16 #include <linux/seq_file.h>
 17 
 18 #include <linux/kobject.h>
 19 #include <linux/kobj_map.h>
 20 #include <linux/cdev.h>
 21 #include <linux/mutex.h>
 22 #include <linux/backing-dev.h>
 23 #include <linux/tty.h>
 24 
 25 #include "internal.h"
 26 
 27 static struct kobj_map *cdev_map;
 28 
 29 static DEFINE_MUTEX(chrdevs_lock);
 30 
 31 static struct char_device_struct {
 32         struct char_device_struct *next;
 33         unsigned int major;
 34         unsigned int baseminor;
 35         int minorct;
 36         char name[64];
 37         struct cdev *cdev;              /* will die */
 38 } *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
 39 
 40 /* index in the above */
 41 static inline int major_to_index(unsigned major)
 42 {
 43         return major % CHRDEV_MAJOR_HASH_SIZE;
 44 }
 45 
 46 #ifdef CONFIG_PROC_FS
 47 
 48 void chrdev_show(struct seq_file *f, off_t offset)
 49 {
 50         struct char_device_struct *cd;
 51 
 52         if (offset < CHRDEV_MAJOR_HASH_SIZE) {
 53                 mutex_lock(&chrdevs_lock);
 54                 for (cd = chrdevs[offset]; cd; cd = cd->next)
 55                         seq_printf(f, "%3d %s\n", cd->major, cd->name);
 56                 mutex_unlock(&chrdevs_lock);
 57         }
 58 }
 59 
 60 #endif /* CONFIG_PROC_FS */
 61 
 62 /*
 63  * Register a single major with a specified minor range.
 64  *
 65  * If major == 0 this functions will dynamically allocate a major and return
 66  * its number.
 67  *
 68  * If major > 0 this function will attempt to reserve the passed range of
 69  * minors and will return zero on success.
 70  *
 71  * Returns a -ve errno on failure.
 72  */
 73 static struct char_device_struct *
 74 __register_chrdev_region(unsigned int major, unsigned int baseminor,
 75                            int minorct, const char *name)
 76 {
 77         struct char_device_struct *cd, **cp;
 78         int ret = 0;
 79         int i;
 80 
 81         cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
 82         if (cd == NULL)
 83                 return ERR_PTR(-ENOMEM);
 84 
 85         mutex_lock(&chrdevs_lock);
 86 
 87         /* temporary */
 88         if (major == 0) {
 89                 for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
 90                         if (chrdevs[i] == NULL)
 91                                 break;
 92                 }
 93 
 94                 if (i < CHRDEV_MAJOR_DYN_END)
 95                         pr_warn("CHRDEV \"%s\" major number %d goes below the dynamic allocation range\n",
 96                                 name, i);
 97 
 98                 if (i == 0) {
 99                         ret = -EBUSY;
100                         goto out;
101                 }
102                 major = i;
103         }
104 
105         cd->major = major;
106         cd->baseminor = baseminor;
107         cd->minorct = minorct;
108         strlcpy(cd->name, name, sizeof(cd->name));
109 
110         i = major_to_index(major);
111 
112         for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
113                 if ((*cp)->major > major ||
114                     ((*cp)->major == major &&
115                      (((*cp)->baseminor >= baseminor) ||
116                       ((*cp)->baseminor + (*cp)->minorct > baseminor))))
117                         break;
118 
119         /* Check for overlapping minor ranges.  */
120         if (*cp && (*cp)->major == major) {
121                 int old_min = (*cp)->baseminor;
122                 int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
123                 int new_min = baseminor;
124                 int new_max = baseminor + minorct - 1;
125 
126                 /* New driver overlaps from the left.  */
127                 if (new_max >= old_min && new_max <= old_max) {
128                         ret = -EBUSY;
129                         goto out;
130                 }
131 
132                 /* New driver overlaps from the right.  */
133                 if (new_min <= old_max && new_min >= old_min) {
134                         ret = -EBUSY;
135                         goto out;
136                 }
137         }
138 
139         cd->next = *cp;
140         *cp = cd;
141         mutex_unlock(&chrdevs_lock);
142         return cd;
143 out:
144         mutex_unlock(&chrdevs_lock);
145         kfree(cd);
146         return ERR_PTR(ret);
147 }
148 
149 static struct char_device_struct *
150 __unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
151 {
152         struct char_device_struct *cd = NULL, **cp;
153         int i = major_to_index(major);
154 
155         mutex_lock(&chrdevs_lock);
156         for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
157                 if ((*cp)->major == major &&
158                     (*cp)->baseminor == baseminor &&
159                     (*cp)->minorct == minorct)
160                         break;
161         if (*cp) {
162                 cd = *cp;
163                 *cp = cd->next;
164         }
165         mutex_unlock(&chrdevs_lock);
166         return cd;
167 }
168 
169 /**
170  * register_chrdev_region() - register a range of device numbers
171  * @from: the first in the desired range of device numbers; must include
172  *        the major number.
173  * @count: the number of consecutive device numbers required
174  * @name: the name of the device or driver.
175  *
176  * Return value is zero on success, a negative error code on failure.
177  */
178 int register_chrdev_region(dev_t from, unsigned count, const char *name)
179 {
180         struct char_device_struct *cd;
181         dev_t to = from + count;
182         dev_t n, next;
183 
184         for (n = from; n < to; n = next) {
185                 next = MKDEV(MAJOR(n)+1, 0);
186                 if (next > to)
187                         next = to;
188                 cd = __register_chrdev_region(MAJOR(n), MINOR(n),
189                                next - n, name);
190                 if (IS_ERR(cd))
191                         goto fail;
192         }
193         return 0;
194 fail:
195         to = n;
196         for (n = from; n < to; n = next) {
197                 next = MKDEV(MAJOR(n)+1, 0);
198                 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
199         }
200         return PTR_ERR(cd);
201 }
202 
203 /**
204  * alloc_chrdev_region() - register a range of char device numbers
205  * @dev: output parameter for first assigned number
206  * @baseminor: first of the requested range of minor numbers
207  * @count: the number of minor numbers required
208  * @name: the name of the associated device or driver
209  *
210  * Allocates a range of char device numbers.  The major number will be
211  * chosen dynamically, and returned (along with the first minor number)
212  * in @dev.  Returns zero or a negative error code.
213  */
214 int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
215                         const char *name)
216 {
217         struct char_device_struct *cd;
218         cd = __register_chrdev_region(0, baseminor, count, name);
219         if (IS_ERR(cd))
220                 return PTR_ERR(cd);
221         *dev = MKDEV(cd->major, cd->baseminor);
222         return 0;
223 }
224 
225 /**
226  * __register_chrdev() - create and register a cdev occupying a range of minors
227  * @major: major device number or 0 for dynamic allocation
228  * @baseminor: first of the requested range of minor numbers
229  * @count: the number of minor numbers required
230  * @name: name of this range of devices
231  * @fops: file operations associated with this devices
232  *
233  * If @major == 0 this functions will dynamically allocate a major and return
234  * its number.
235  *
236  * If @major > 0 this function will attempt to reserve a device with the given
237  * major number and will return zero on success.
238  *
239  * Returns a -ve errno on failure.
240  *
241  * The name of this device has nothing to do with the name of the device in
242  * /dev. It only helps to keep track of the different owners of devices. If
243  * your module name has only one type of devices it's ok to use e.g. the name
244  * of the module here.
245  */
246 int __register_chrdev(unsigned int major, unsigned int baseminor,
247                       unsigned int count, const char *name,
248                       const struct file_operations *fops)
249 {
250         struct char_device_struct *cd;
251         struct cdev *cdev;
252         int err = -ENOMEM;
253 
254         cd = __register_chrdev_region(major, baseminor, count, name);
255         if (IS_ERR(cd))
256                 return PTR_ERR(cd);
257 
258         cdev = cdev_alloc();
259         if (!cdev)
260                 goto out2;
261 
262         cdev->owner = fops->owner;
263         cdev->ops = fops;
264         kobject_set_name(&cdev->kobj, "%s", name);
265 
266         err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
267         if (err)
268                 goto out;
269 
270         cd->cdev = cdev;
271 
272         return major ? 0 : cd->major;
273 out:
274         kobject_put(&cdev->kobj);
275 out2:
276         kfree(__unregister_chrdev_region(cd->major, baseminor, count));
277         return err;
278 }
279 
280 /**
281  * unregister_chrdev_region() - unregister a range of device numbers
282  * @from: the first in the range of numbers to unregister
283  * @count: the number of device numbers to unregister
284  *
285  * This function will unregister a range of @count device numbers,
286  * starting with @from.  The caller should normally be the one who
287  * allocated those numbers in the first place...
288  */
289 void unregister_chrdev_region(dev_t from, unsigned count)
290 {
291         dev_t to = from + count;
292         dev_t n, next;
293 
294         for (n = from; n < to; n = next) {
295                 next = MKDEV(MAJOR(n)+1, 0);
296                 if (next > to)
297                         next = to;
298                 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
299         }
300 }
301 
302 /**
303  * __unregister_chrdev - unregister and destroy a cdev
304  * @major: major device number
305  * @baseminor: first of the range of minor numbers
306  * @count: the number of minor numbers this cdev is occupying
307  * @name: name of this range of devices
308  *
309  * Unregister and destroy the cdev occupying the region described by
310  * @major, @baseminor and @count.  This function undoes what
311  * __register_chrdev() did.
312  */
313 void __unregister_chrdev(unsigned int major, unsigned int baseminor,
314                          unsigned int count, const char *name)
315 {
316         struct char_device_struct *cd;
317 
318         cd = __unregister_chrdev_region(major, baseminor, count);
319         if (cd && cd->cdev)
320                 cdev_del(cd->cdev);
321         kfree(cd);
322 }
323 
324 static DEFINE_SPINLOCK(cdev_lock);
325 
326 static struct kobject *cdev_get(struct cdev *p)
327 {
328         struct module *owner = p->owner;
329         struct kobject *kobj;
330 
331         if (owner && !try_module_get(owner))
332                 return NULL;
333         kobj = kobject_get(&p->kobj);
334         if (!kobj)
335                 module_put(owner);
336         return kobj;
337 }
338 
339 void cdev_put(struct cdev *p)
340 {
341         if (p) {
342                 struct module *owner = p->owner;
343                 kobject_put(&p->kobj);
344                 module_put(owner);
345         }
346 }
347 
348 /*
349  * Called every time a character special file is opened
350  */
351 static int chrdev_open(struct inode *inode, struct file *filp)
352 {
353         const struct file_operations *fops;
354         struct cdev *p;
355         struct cdev *new = NULL;
356         int ret = 0;
357 
358         spin_lock(&cdev_lock);
359         p = inode->i_cdev;
360         if (!p) {
361                 struct kobject *kobj;
362                 int idx;
363                 spin_unlock(&cdev_lock);
364                 kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
365                 if (!kobj)
366                         return -ENXIO;
367                 new = container_of(kobj, struct cdev, kobj);
368                 spin_lock(&cdev_lock);
369                 /* Check i_cdev again in case somebody beat us to it while
370                    we dropped the lock. */
371                 p = inode->i_cdev;
372                 if (!p) {
373                         inode->i_cdev = p = new;
374                         list_add(&inode->i_devices, &p->list);
375                         new = NULL;
376                 } else if (!cdev_get(p))
377                         ret = -ENXIO;
378         } else if (!cdev_get(p))
379                 ret = -ENXIO;
380         spin_unlock(&cdev_lock);
381         cdev_put(new);
382         if (ret)
383                 return ret;
384 
385         ret = -ENXIO;
386         fops = fops_get(p->ops);
387         if (!fops)
388                 goto out_cdev_put;
389 
390         replace_fops(filp, fops);
391         if (filp->f_op->open) {
392                 ret = filp->f_op->open(inode, filp);
393                 if (ret)
394                         goto out_cdev_put;
395         }
396 
397         return 0;
398 
399  out_cdev_put:
400         cdev_put(p);
401         return ret;
402 }
403 
404 void cd_forget(struct inode *inode)
405 {
406         spin_lock(&cdev_lock);
407         list_del_init(&inode->i_devices);
408         inode->i_cdev = NULL;
409         inode->i_mapping = &inode->i_data;
410         spin_unlock(&cdev_lock);
411 }
412 
413 static void cdev_purge(struct cdev *cdev)
414 {
415         spin_lock(&cdev_lock);
416         while (!list_empty(&cdev->list)) {
417                 struct inode *inode;
418                 inode = container_of(cdev->list.next, struct inode, i_devices);
419                 list_del_init(&inode->i_devices);
420                 inode->i_cdev = NULL;
421         }
422         spin_unlock(&cdev_lock);
423 }
424 
425 /*
426  * Dummy default file-operations: the only thing this does
427  * is contain the open that then fills in the correct operations
428  * depending on the special file...
429  */
430 const struct file_operations def_chr_fops = {
431         .open = chrdev_open,
432         .llseek = noop_llseek,
433 };
434 
435 static struct kobject *exact_match(dev_t dev, int *part, void *data)
436 {
437         struct cdev *p = data;
438         return &p->kobj;
439 }
440 
441 static int exact_lock(dev_t dev, void *data)
442 {
443         struct cdev *p = data;
444         return cdev_get(p) ? 0 : -1;
445 }
446 
447 /**
448  * cdev_add() - add a char device to the system
449  * @p: the cdev structure for the device
450  * @dev: the first device number for which this device is responsible
451  * @count: the number of consecutive minor numbers corresponding to this
452  *         device
453  *
454  * cdev_add() adds the device represented by @p to the system, making it
455  * live immediately.  A negative error code is returned on failure.
456  */
457 int cdev_add(struct cdev *p, dev_t dev, unsigned count)
458 {
459         int error;
460 
461         p->dev = dev;
462         p->count = count;
463 
464         error = kobj_map(cdev_map, dev, count, NULL,
465                          exact_match, exact_lock, p);
466         if (error)
467                 return error;
468 
469         kobject_get(p->kobj.parent);
470 
471         return 0;
472 }
473 
474 /**
475  * cdev_set_parent() - set the parent kobject for a char device
476  * @p: the cdev structure
477  * @kobj: the kobject to take a reference to
478  *
479  * cdev_set_parent() sets a parent kobject which will be referenced
480  * appropriately so the parent is not freed before the cdev. This
481  * should be called before cdev_add.
482  */
483 void cdev_set_parent(struct cdev *p, struct kobject *kobj)
484 {
485         WARN_ON(!kobj->state_initialized);
486         p->kobj.parent = kobj;
487 }
488 
489 /**
490  * cdev_device_add() - add a char device and it's corresponding
491  *      struct device, linkink
492  * @dev: the device structure
493  * @cdev: the cdev structure
494  *
495  * cdev_device_add() adds the char device represented by @cdev to the system,
496  * just as cdev_add does. It then adds @dev to the system using device_add
497  * The dev_t for the char device will be taken from the struct device which
498  * needs to be initialized first. This helper function correctly takes a
499  * reference to the parent device so the parent will not get released until
500  * all references to the cdev are released.
501  *
502  * This helper uses dev->devt for the device number. If it is not set
503  * it will not add the cdev and it will be equivalent to device_add.
504  *
505  * This function should be used whenever the struct cdev and the
506  * struct device are members of the same structure whose lifetime is
507  * managed by the struct device.
508  *
509  * NOTE: Callers must assume that userspace was able to open the cdev and
510  * can call cdev fops callbacks at any time, even if this function fails.
511  */
512 int cdev_device_add(struct cdev *cdev, struct device *dev)
513 {
514         int rc = 0;
515 
516         if (dev->devt) {
517                 cdev_set_parent(cdev, &dev->kobj);
518 
519                 rc = cdev_add(cdev, dev->devt, 1);
520                 if (rc)
521                         return rc;
522         }
523 
524         rc = device_add(dev);
525         if (rc)
526                 cdev_del(cdev);
527 
528         return rc;
529 }
530 
531 /**
532  * cdev_device_del() - inverse of cdev_device_add
533  * @dev: the device structure
534  * @cdev: the cdev structure
535  *
536  * cdev_device_del() is a helper function to call cdev_del and device_del.
537  * It should be used whenever cdev_device_add is used.
538  *
539  * If dev->devt is not set it will not remove the cdev and will be equivalent
540  * to device_del.
541  *
542  * NOTE: This guarantees that associated sysfs callbacks are not running
543  * or runnable, however any cdevs already open will remain and their fops
544  * will still be callable even after this function returns.
545  */
546 void cdev_device_del(struct cdev *cdev, struct device *dev)
547 {
548         device_del(dev);
549         if (dev->devt)
550                 cdev_del(cdev);
551 }
552 
553 static void cdev_unmap(dev_t dev, unsigned count)
554 {
555         kobj_unmap(cdev_map, dev, count);
556 }
557 
558 /**
559  * cdev_del() - remove a cdev from the system
560  * @p: the cdev structure to be removed
561  *
562  * cdev_del() removes @p from the system, possibly freeing the structure
563  * itself.
564  *
565  * NOTE: This guarantees that cdev device will no longer be able to be
566  * opened, however any cdevs already open will remain and their fops will
567  * still be callable even after cdev_del returns.
568  */
569 void cdev_del(struct cdev *p)
570 {
571         cdev_unmap(p->dev, p->count);
572         kobject_put(&p->kobj);
573 }
574 
575 
576 static void cdev_default_release(struct kobject *kobj)
577 {
578         struct cdev *p = container_of(kobj, struct cdev, kobj);
579         struct kobject *parent = kobj->parent;
580 
581         cdev_purge(p);
582         kobject_put(parent);
583 }
584 
585 static void cdev_dynamic_release(struct kobject *kobj)
586 {
587         struct cdev *p = container_of(kobj, struct cdev, kobj);
588         struct kobject *parent = kobj->parent;
589 
590         cdev_purge(p);
591         kfree(p);
592         kobject_put(parent);
593 }
594 
595 static struct kobj_type ktype_cdev_default = {
596         .release        = cdev_default_release,
597 };
598 
599 static struct kobj_type ktype_cdev_dynamic = {
600         .release        = cdev_dynamic_release,
601 };
602 
603 /**
604  * cdev_alloc() - allocate a cdev structure
605  *
606  * Allocates and returns a cdev structure, or NULL on failure.
607  */
608 struct cdev *cdev_alloc(void)
609 {
610         struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
611         if (p) {
612                 INIT_LIST_HEAD(&p->list);
613                 kobject_init(&p->kobj, &ktype_cdev_dynamic);
614         }
615         return p;
616 }
617 
618 /**
619  * cdev_init() - initialize a cdev structure
620  * @cdev: the structure to initialize
621  * @fops: the file_operations for this device
622  *
623  * Initializes @cdev, remembering @fops, making it ready to add to the
624  * system with cdev_add().
625  */
626 void cdev_init(struct cdev *cdev, const struct file_operations *fops)
627 {
628         memset(cdev, 0, sizeof *cdev);
629         INIT_LIST_HEAD(&cdev->list);
630         kobject_init(&cdev->kobj, &ktype_cdev_default);
631         cdev->ops = fops;
632 }
633 
634 static struct kobject *base_probe(dev_t dev, int *part, void *data)
635 {
636         if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
637                 /* Make old-style 2.4 aliases work */
638                 request_module("char-major-%d", MAJOR(dev));
639         return NULL;
640 }
641 
642 void __init chrdev_init(void)
643 {
644         cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
645 }
646 
647 
648 /* Let modules do char dev stuff */
649 EXPORT_SYMBOL(register_chrdev_region);
650 EXPORT_SYMBOL(unregister_chrdev_region);
651 EXPORT_SYMBOL(alloc_chrdev_region);
652 EXPORT_SYMBOL(cdev_init);
653 EXPORT_SYMBOL(cdev_alloc);
654 EXPORT_SYMBOL(cdev_del);
655 EXPORT_SYMBOL(cdev_add);
656 EXPORT_SYMBOL(cdev_set_parent);
657 EXPORT_SYMBOL(cdev_device_add);
658 EXPORT_SYMBOL(cdev_device_del);
659 EXPORT_SYMBOL(__register_chrdev);
660 EXPORT_SYMBOL(__unregister_chrdev);
661 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp