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

TOMOYO Linux Cross Reference
Linux/fs/char_dev.c

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

~ [ 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