fs/char_dev.c

   1 /*
   2  *  linux/fs/char_dev.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/init.h>
   9 #include <linux/fs.h>
  10 #include <linux/slab.h>
  11 #include <linux/string.h>
  12
  13 #include <linux/major.h>
  14 #include <linux/string.h>
  15 #include <linux/errno.h>
  16 #include <linux/module.h>
  17 #include <linux/smp_lock.h>
  18 #include <linux/devfs_fs_kernel.h>
  19
  20 #include <linux/kobject.h>
  21 #include <linux/kobj_map.h>
  22 #include <linux/cdev.h>
  23
  24 #ifdef CONFIG_KMOD
  25 #include <linux/kmod.h>
  26 #endif
  27
  28 static struct kobj_map *cdev_map;
  29
  30 #define MAX_PROBE_HASH 255      /* random */
  31
  32 static rwlock_t chrdevs_lock = RW_LOCK_UNLOCKED;
  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         const char *name;
  40         struct file_operations *fops;
  41         struct cdev *cdev;              /* will die */
  42 } *chrdevs[MAX_PROBE_HASH];
  43
  44 /* index in the above */
  45 static inline int major_to_index(int major)
  46 {
  47         return major % MAX_PROBE_HASH;
  48 }
  49
  50 /* get char device names in somewhat random order */
  51 int get_chrdev_list(char *page)
  52 {
  53         struct char_device_struct *cd;
  54         int i, len;
  55
  56         len = sprintf(page, "Character devices:\n");
  57
  58         read_lock(&chrdevs_lock);
  59         for (i = 0; i < ARRAY_SIZE(chrdevs) ; i++) {
  60                 for (cd = chrdevs[i]; cd; cd = cd->next)
  61                         len += sprintf(page+len, "%3d %s\n",
  62                                        cd->major, cd->name);
  63         }
  64         read_unlock(&chrdevs_lock);
  65
  66         return len;
  67 }
  68
  69 /*
  70  * Register a single major with a specified minor range.
  71  *
  72  * If major == 0 this functions will dynamically allocate a major and return
  73  * its number.
  74  *
  75  * If major > 0 this function will attempt to reserve the passed range of
  76  * minors and will return zero on success.
  77  *
  78  * Returns a -ve errno on failure.
  79  */
  80 static struct char_device_struct *
  81 __register_chrdev_region(unsigned int major, unsigned int baseminor,
  82                            int minorct, const char *name)
  83 {
  84         struct char_device_struct *cd, **cp;
  85         int ret = 0;
  86         int i;
  87
  88         cd = kmalloc(sizeof(struct char_device_struct), GFP_KERNEL);
  89         if (cd == NULL)
  90                 return ERR_PTR(-ENOMEM);
  91
  92         write_lock_irq(&chrdevs_lock);
  93
  94         /* temporary */
  95         if (major == 0) {
  96                 for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
  97                         if (chrdevs[i] == NULL)
  98                                 break;
  99                 }
 100
 101                 if (i == 0) {
 102                         ret = -EBUSY;
 103                         goto out;
 104                 }
 105                 major = i;
 106                 ret = major;
 107         }
 108
 109         cd->major = major;
 110         cd->baseminor = baseminor;
 111         cd->minorct = minorct;
 112         cd->name = name;
 113
 114         i = major_to_index(major);
 115
 116         for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
 117                 if ((*cp)->major > major ||
 118                     ((*cp)->major == major && (*cp)->baseminor >= baseminor))
 119                         break;
 120         if (*cp && (*cp)->major == major &&
 121             (*cp)->baseminor < baseminor + minorct) {
 122                 ret = -EBUSY;
 123                 goto out;
 124         }
 125         cd->next = *cp;
 126         *cp = cd;
 127         write_unlock_irq(&chrdevs_lock);
 128         return cd;
 129 out:
 130         write_unlock_irq(&chrdevs_lock);
 131         kfree(cd);
 132         return ERR_PTR(ret);
 133 }
 134
 135 static struct char_device_struct *
 136 __unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
 137 {
 138         struct char_device_struct *cd = NULL, **cp;
 139         int i = major_to_index(major);
 140
 141         write_lock_irq(&chrdevs_lock);
 142         for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
 143                 if ((*cp)->major == major &&
 144                     (*cp)->baseminor == baseminor &&
 145                     (*cp)->minorct == minorct)
 146                         break;
 147         if (*cp) {
 148                 cd = *cp;
 149                 *cp = cd->next;
 150         }
 151         write_unlock_irq(&chrdevs_lock);
 152         return cd;
 153 }
 154
 155 int register_chrdev_region(dev_t from, unsigned count, char *name)
 156 {
 157         struct char_device_struct *cd;
 158         dev_t to = from + count;
 159         dev_t n, next;
 160
 161         for (n = from; n < to; n = next) {
 162                 next = MKDEV(MAJOR(n)+1, 0);
 163                 if (next > to)
 164                         next = to;
 165                 cd = __register_chrdev_region(MAJOR(n), MINOR(n),
 166                                next - n, name);
 167                 if (IS_ERR(cd))
 168                         goto fail;
 169         }
 170         return 0;
 171 fail:
 172         to = n;
 173         for (n = from; n < to; n = next) {
 174                 next = MKDEV(MAJOR(n)+1, 0);
 175                 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
 176         }
 177         return PTR_ERR(cd);
 178 }
 179
 180 int alloc_chrdev_region(dev_t *dev, unsigned count, char *name)
 181 {
 182         struct char_device_struct *cd;
 183         cd = __register_chrdev_region(0, 0, count, name);
 184         if (IS_ERR(cd))
 185                 return PTR_ERR(cd);
 186         *dev = MKDEV(cd->major, cd->baseminor);
 187         return 0;
 188 }
 189
 190 int register_chrdev(unsigned int major, const char *name,
 191                     struct file_operations *fops)
 192 {
 193         struct char_device_struct *cd;
 194         struct cdev *cdev;
 195         char *s;
 196         int err = -ENOMEM;
 197
 198         cd = __register_chrdev_region(major, 0, 256, name);
 199         if (IS_ERR(cd))
 200                 return PTR_ERR(cd);
 201
 202         cdev = cdev_alloc();
 203         if (!cdev)
 204                 goto out2;
 205
 206         cdev->owner = fops->owner;
 207         cdev->ops = fops;
 208         strcpy(cdev->kobj.name, name);
 209         for (s = strchr(cdev->kobj.name, '/'); s; s = strchr(s, '/'))
 210                 *s = '!';
 211
 212         err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
 213         if (err)
 214                 goto out;
 215
 216         cd->cdev = cdev;
 217
 218         return major ? 0 : cd->major;
 219 out:
 220         kobject_put(&cdev->kobj);
 221 out2:
 222         __unregister_chrdev_region(cd->major, 0, 256);
 223         return err;
 224 }
 225
 226 void unregister_chrdev_region(dev_t from, unsigned count)
 227 {
 228         dev_t to = from + count;
 229         dev_t n, next;
 230
 231         for (n = from; n < to; n = next) {
 232                 next = MKDEV(MAJOR(n)+1, 0);
 233                 if (next > to)
 234                         next = to;
 235                 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
 236         }
 237 }
 238
 239 int unregister_chrdev(unsigned int major, const char *name)
 240 {
 241         struct char_device_struct *cd;
 242         cdev_unmap(MKDEV(major, 0), 256);
 243         cd = __unregister_chrdev_region(major, 0, 256);
 244         if (cd && cd->cdev)
 245                 cdev_del(cd->cdev);
 246         kfree(cd);
 247         return 0;
 248 }
 249
 250 static spinlock_t cdev_lock = SPIN_LOCK_UNLOCKED;
 251 /*
 252  * Called every time a character special file is opened
 253  */
 254 int chrdev_open(struct inode * inode, struct file * filp)
 255 {
 256         struct cdev *p;
 257         struct cdev *new = NULL;
 258         int ret = 0;
 259
 260         spin_lock(&cdev_lock);
 261         p = inode->i_cdev;
 262         if (!p) {
 263                 struct kobject *kobj;
 264                 int idx;
 265                 spin_unlock(&cdev_lock);
 266                 kobj = kobj_lookup(cdev_map, kdev_t_to_nr(inode->i_rdev), &idx);
 267                 if (!kobj)
 268                         return -ENODEV;
 269                 new = container_of(kobj, struct cdev, kobj);
 270                 spin_lock(&cdev_lock);
 271                 p = inode->i_cdev;
 272                 if (!p) {
 273                         inode->i_cdev = p = new;
 274                         inode->i_cindex = idx;
 275                         list_add(&inode->i_devices, &p->list);
 276                         new = NULL;
 277                 } else if (!cdev_get(p))
 278                         ret = -ENODEV;
 279         } else if (!cdev_get(p))
 280                 ret = -ENODEV;
 281         spin_unlock(&cdev_lock);
 282         cdev_put(new);
 283         if (ret)
 284                 return ret;
 285         filp->f_op = fops_get(p->ops);
 286         if (!filp->f_op) {
 287                 cdev_put(p);
 288                 return -ENODEV;
 289         }
 290         if (filp->f_op->open) {
 291                 lock_kernel();
 292                 ret = filp->f_op->open(inode,filp);
 293                 unlock_kernel();
 294         }
 295         if (ret)
 296                 cdev_put(p);
 297         return ret;
 298 }
 299
 300 void cd_forget(struct inode *inode)
 301 {
 302         spin_lock(&cdev_lock);
 303         list_del_init(&inode->i_devices);
 304         inode->i_cdev = NULL;
 305         spin_unlock(&cdev_lock);
 306 }
 307
 308 void cdev_purge(struct cdev *cdev)
 309 {
 310         spin_lock(&cdev_lock);
 311         while (!list_empty(&cdev->list)) {
 312                 struct inode *inode;
 313                 inode = container_of(cdev->list.next, struct inode, i_devices);
 314                 list_del_init(&inode->i_devices);
 315                 inode->i_cdev = NULL;
 316         }
 317         spin_unlock(&cdev_lock);
 318 }
 319
 320 /*
 321  * Dummy default file-operations: the only thing this does
 322  * is contain the open that then fills in the correct operations
 323  * depending on the special file...
 324  */
 325 struct file_operations def_chr_fops = {
 326         .open = chrdev_open,
 327 };
 328
 329 const char *cdevname(kdev_t dev)
 330 {
 331         static char buffer[40];
 332         const char *name = "unknown-char";
 333         unsigned int major = major(dev);
 334         unsigned int minor = minor(dev);
 335         int i = major_to_index(major);
 336         struct char_device_struct *cd;
 337
 338         read_lock(&chrdevs_lock);
 339         for (cd = chrdevs[i]; cd; cd = cd->next)
 340                 if (cd->major == major)
 341                         break;
 342         if (cd)
 343                 name = cd->name;
 344         sprintf(buffer, "%s(%d,%d)", name, major, minor);
 345         read_unlock(&chrdevs_lock);
 346
 347         return buffer;
 348 }
 349
 350 static struct kobject *exact_match(dev_t dev, int *part, void *data)
 351 {
 352         struct cdev *p = data;
 353         return &p->kobj;
 354 }
 355
 356 static int exact_lock(dev_t dev, void *data)
 357 {
 358         struct cdev *p = data;
 359         return cdev_get(p) ? 0 : -1;
 360 }
 361
 362 int cdev_add(struct cdev *p, dev_t dev, unsigned count)
 363 {
 364         int err = kobject_add(&p->kobj);
 365         if (err)
 366                 return err;
 367         return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
 368 }
 369
 370 void cdev_unmap(dev_t dev, unsigned count)
 371 {
 372         kobj_unmap(cdev_map, dev, count);
 373 }
 374
 375 void cdev_del(struct cdev *p)
 376 {
 377         kobject_del(&p->kobj);
 378         kobject_put(&p->kobj);
 379 }
 380
 381 struct kobject *cdev_get(struct cdev *p)
 382 {
 383         struct module *owner = p->owner;
 384         struct kobject *kobj;
 385
 386         if (owner && !try_module_get(owner))
 387                 return NULL;
 388         kobj = kobject_get(&p->kobj);
 389         if (!kobj)
 390                 module_put(owner);
 391         return kobj;
 392 }
 393
 394 void cdev_put(struct cdev *p)
 395 {
 396         if (p) {
 397                 kobject_put(&p->kobj);
 398                 module_put(p->owner);
 399         }
 400 }
 401
 402 static decl_subsys(cdev, NULL, NULL);
 403
 404 static void cdev_default_release(struct kobject *kobj)
 405 {
 406         struct cdev *p = container_of(kobj, struct cdev, kobj);
 407         cdev_purge(p);
 408 }
 409
 410 static void cdev_dynamic_release(struct kobject *kobj)
 411 {
 412         struct cdev *p = container_of(kobj, struct cdev, kobj);
 413         cdev_purge(p);
 414         kfree(p);
 415 }
 416
 417 static struct kobj_type ktype_cdev_default = {
 418         .release        = cdev_default_release,
 419 };
 420
 421 static struct kobj_type ktype_cdev_dynamic = {
 422         .release        = cdev_dynamic_release,
 423 };
 424
 425 static struct kset kset_dynamic = {
 426         .subsys = &cdev_subsys,
 427         .kobj = {.name = "major",},
 428         .ktype = &ktype_cdev_dynamic,
 429 };
 430
 431 struct cdev *cdev_alloc(void)
 432 {
 433         struct cdev *p = kmalloc(sizeof(struct cdev), GFP_KERNEL);
 434         if (p) {
 435                 memset(p, 0, sizeof(struct cdev));
 436                 p->kobj.kset = &kset_dynamic;
 437                 INIT_LIST_HEAD(&p->list);
 438                 kobject_init(&p->kobj);
 439         }
 440         return p;
 441 }
 442
 443 void cdev_init(struct cdev *cdev, struct file_operations *fops)
 444 {
 445         INIT_LIST_HEAD(&cdev->list);
 446         kobj_set_kset_s(cdev, cdev_subsys);
 447         cdev->kobj.ktype = &ktype_cdev_default;
 448         kobject_init(&cdev->kobj);
 449         cdev->ops = fops;
 450 }
 451
 452 static struct kobject *base_probe(dev_t dev, int *part, void *data)
 453 {
 454         char name[30];
 455         sprintf(name, "char-major-%d", MAJOR(dev));
 456         request_module(name);
 457         return NULL;
 458 }
 459
 460 void __init chrdev_init(void)
 461 {
 462         subsystem_register(&cdev_subsys);
 463         kset_register(&kset_dynamic);
 464         cdev_map = kobj_map_init(base_probe, &cdev_subsys);
 465 }