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 24 #include "internal.h" 25 26 /* 27 * capabilities for /dev/mem, /dev/kmem and similar directly mappable character 28 * devices 29 * - permits shared-mmap for read, write and/or exec 30 * - does not permit private mmap in NOMMU mode (can't do COW) 31 * - no readahead or I/O queue unplugging required 32 */ 33 struct backing_dev_info directly_mappable_cdev_bdi = { 34 .capabilities = ( 35 #ifdef CONFIG_MMU 36 /* permit private copies of the data to be taken */ 37 BDI_CAP_MAP_COPY | 38 #endif 39 /* permit direct mmap, for read, write or exec */ 40 BDI_CAP_MAP_DIRECT | 41 BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP), 42 }; 43 44 static struct kobj_map *cdev_map; 45 46 static DEFINE_MUTEX(chrdevs_lock); 47 48 static struct char_device_struct { 49 struct char_device_struct *next; 50 unsigned int major; 51 unsigned int baseminor; 52 int minorct; 53 char name[64]; 54 struct cdev *cdev; /* will die */ 55 } *chrdevs[CHRDEV_MAJOR_HASH_SIZE]; 56 57 /* index in the above */ 58 static inline int major_to_index(int major) 59 { 60 return major % CHRDEV_MAJOR_HASH_SIZE; 61 } 62 63 #ifdef CONFIG_PROC_FS 64 65 void chrdev_show(struct seq_file *f, off_t offset) 66 { 67 struct char_device_struct *cd; 68 69 if (offset < CHRDEV_MAJOR_HASH_SIZE) { 70 mutex_lock(&chrdevs_lock); 71 for (cd = chrdevs[offset]; cd; cd = cd->next) 72 seq_printf(f, "%3d %s\n", cd->major, cd->name); 73 mutex_unlock(&chrdevs_lock); 74 } 75 } 76 77 #endif /* CONFIG_PROC_FS */ 78 79 /* 80 * Register a single major with a specified minor range. 81 * 82 * If major == 0 this functions will dynamically allocate a major and return 83 * its number. 84 * 85 * If major > 0 this function will attempt to reserve the passed range of 86 * minors and will return zero on success. 87 * 88 * Returns a -ve errno on failure. 89 */ 90 static struct char_device_struct * 91 __register_chrdev_region(unsigned int major, unsigned int baseminor, 92 int minorct, const char *name) 93 { 94 struct char_device_struct *cd, **cp; 95 int ret = 0; 96 int i; 97 98 cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL); 99 if (cd == NULL) 100 return ERR_PTR(-ENOMEM); 101 102 mutex_lock(&chrdevs_lock); 103 104 /* temporary */ 105 if (major == 0) { 106 for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) { 107 if (chrdevs[i] == NULL) 108 break; 109 } 110 111 if (i == 0) { 112 ret = -EBUSY; 113 goto out; 114 } 115 major = i; 116 ret = major; 117 } 118 119 cd->major = major; 120 cd->baseminor = baseminor; 121 cd->minorct = minorct; 122 strlcpy(cd->name, name, sizeof(cd->name)); 123 124 i = major_to_index(major); 125 126 for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next) 127 if ((*cp)->major > major || 128 ((*cp)->major == major && 129 (((*cp)->baseminor >= baseminor) || 130 ((*cp)->baseminor + (*cp)->minorct > baseminor)))) 131 break; 132 133 /* Check for overlapping minor ranges. */ 134 if (*cp && (*cp)->major == major) { 135 int old_min = (*cp)->baseminor; 136 int old_max = (*cp)->baseminor + (*cp)->minorct - 1; 137 int new_min = baseminor; 138 int new_max = baseminor + minorct - 1; 139 140 /* New driver overlaps from the left. */ 141 if (new_max >= old_min && new_max <= old_max) { 142 ret = -EBUSY; 143 goto out; 144 } 145 146 /* New driver overlaps from the right. */ 147 if (new_min <= old_max && new_min >= old_min) { 148 ret = -EBUSY; 149 goto out; 150 } 151 } 152 153 cd->next = *cp; 154 *cp = cd; 155 mutex_unlock(&chrdevs_lock); 156 return cd; 157 out: 158 mutex_unlock(&chrdevs_lock); 159 kfree(cd); 160 return ERR_PTR(ret); 161 } 162 163 static struct char_device_struct * 164 __unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct) 165 { 166 struct char_device_struct *cd = NULL, **cp; 167 int i = major_to_index(major); 168 169 mutex_lock(&chrdevs_lock); 170 for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next) 171 if ((*cp)->major == major && 172 (*cp)->baseminor == baseminor && 173 (*cp)->minorct == minorct) 174 break; 175 if (*cp) { 176 cd = *cp; 177 *cp = cd->next; 178 } 179 mutex_unlock(&chrdevs_lock); 180 return cd; 181 } 182 183 /** 184 * register_chrdev_region() - register a range of device numbers 185 * @from: the first in the desired range of device numbers; must include 186 * the major number. 187 * @count: the number of consecutive device numbers required 188 * @name: the name of the device or driver. 189 * 190 * Return value is zero on success, a negative error code on failure. 191 */ 192 int register_chrdev_region(dev_t from, unsigned count, const char *name) 193 { 194 struct char_device_struct *cd; 195 dev_t to = from + count; 196 dev_t n, next; 197 198 for (n = from; n < to; n = next) { 199 next = MKDEV(MAJOR(n)+1, 0); 200 if (next > to) 201 next = to; 202 cd = __register_chrdev_region(MAJOR(n), MINOR(n), 203 next - n, name); 204 if (IS_ERR(cd)) 205 goto fail; 206 } 207 return 0; 208 fail: 209 to = n; 210 for (n = from; n < to; n = next) { 211 next = MKDEV(MAJOR(n)+1, 0); 212 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n)); 213 } 214 return PTR_ERR(cd); 215 } 216 217 /** 218 * alloc_chrdev_region() - register a range of char device numbers 219 * @dev: output parameter for first assigned number 220 * @baseminor: first of the requested range of minor numbers 221 * @count: the number of minor numbers required 222 * @name: the name of the associated device or driver 223 * 224 * Allocates a range of char device numbers. The major number will be 225 * chosen dynamically, and returned (along with the first minor number) 226 * in @dev. Returns zero or a negative error code. 227 */ 228 int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, 229 const char *name) 230 { 231 struct char_device_struct *cd; 232 cd = __register_chrdev_region(0, baseminor, count, name); 233 if (IS_ERR(cd)) 234 return PTR_ERR(cd); 235 *dev = MKDEV(cd->major, cd->baseminor); 236 return 0; 237 } 238 239 /** 240 * register_chrdev() - Register a major number for character devices. 241 * @major: major device number or 0 for dynamic allocation 242 * @name: name of this range of devices 243 * @fops: file operations associated with this devices 244 * 245 * If @major == 0 this functions will dynamically allocate a major and return 246 * its number. 247 * 248 * If @major > 0 this function will attempt to reserve a device with the given 249 * major number and will return zero on success. 250 * 251 * Returns a -ve errno on failure. 252 * 253 * The name of this device has nothing to do with the name of the device in 254 * /dev. It only helps to keep track of the different owners of devices. If 255 * your module name has only one type of devices it's ok to use e.g. the name 256 * of the module here. 257 * 258 * This function registers a range of 256 minor numbers. The first minor number 259 * is 0. 260 */ 261 int register_chrdev(unsigned int major, const char *name, 262 const struct file_operations *fops) 263 { 264 struct char_device_struct *cd; 265 struct cdev *cdev; 266 char *s; 267 int err = -ENOMEM; 268 269 cd = __register_chrdev_region(major, 0, 256, name); 270 if (IS_ERR(cd)) 271 return PTR_ERR(cd); 272 273 cdev = cdev_alloc(); 274 if (!cdev) 275 goto out2; 276 277 cdev->owner = fops->owner; 278 cdev->ops = fops; 279 kobject_set_name(&cdev->kobj, "%s", name); 280 for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/')) 281 *s = '!'; 282 283 err = cdev_add(cdev, MKDEV(cd->major, 0), 256); 284 if (err) 285 goto out; 286 287 cd->cdev = cdev; 288 289 return major ? 0 : cd->major; 290 out: 291 kobject_put(&cdev->kobj); 292 out2: 293 kfree(__unregister_chrdev_region(cd->major, 0, 256)); 294 return err; 295 } 296 297 /** 298 * unregister_chrdev_region() - return a range of device numbers 299 * @from: the first in the range of numbers to unregister 300 * @count: the number of device numbers to unregister 301 * 302 * This function will unregister a range of @count device numbers, 303 * starting with @from. The caller should normally be the one who 304 * allocated those numbers in the first place... 305 */ 306 void unregister_chrdev_region(dev_t from, unsigned count) 307 { 308 dev_t to = from + count; 309 dev_t n, next; 310 311 for (n = from; n < to; n = next) { 312 next = MKDEV(MAJOR(n)+1, 0); 313 if (next > to) 314 next = to; 315 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n)); 316 } 317 } 318 319 void unregister_chrdev(unsigned int major, const char *name) 320 { 321 struct char_device_struct *cd; 322 cd = __unregister_chrdev_region(major, 0, 256); 323 if (cd && cd->cdev) 324 cdev_del(cd->cdev); 325 kfree(cd); 326 } 327 328 static DEFINE_SPINLOCK(cdev_lock); 329 330 static struct kobject *cdev_get(struct cdev *p) 331 { 332 struct module *owner = p->owner; 333 struct kobject *kobj; 334 335 if (owner && !try_module_get(owner)) 336 return NULL; 337 kobj = kobject_get(&p->kobj); 338 if (!kobj) 339 module_put(owner); 340 return kobj; 341 } 342 343 void cdev_put(struct cdev *p) 344 { 345 if (p) { 346 struct module *owner = p->owner; 347 kobject_put(&p->kobj); 348 module_put(owner); 349 } 350 } 351 352 /* 353 * Called every time a character special file is opened 354 */ 355 static int chrdev_open(struct inode *inode, struct file *filp) 356 { 357 struct cdev *p; 358 struct cdev *new = NULL; 359 int ret = 0; 360 361 spin_lock(&cdev_lock); 362 p = inode->i_cdev; 363 if (!p) { 364 struct kobject *kobj; 365 int idx; 366 spin_unlock(&cdev_lock); 367 kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx); 368 if (!kobj) 369 return -ENXIO; 370 new = container_of(kobj, struct cdev, kobj); 371 spin_lock(&cdev_lock); 372 /* Check i_cdev again in case somebody beat us to it while 373 we dropped the lock. */ 374 p = inode->i_cdev; 375 if (!p) { 376 inode->i_cdev = p = new; 377 list_add(&inode->i_devices, &p->list); 378 new = NULL; 379 } else if (!cdev_get(p)) 380 ret = -ENXIO; 381 } else if (!cdev_get(p)) 382 ret = -ENXIO; 383 spin_unlock(&cdev_lock); 384 cdev_put(new); 385 if (ret) 386 return ret; 387 388 ret = -ENXIO; 389 filp->f_op = fops_get(p->ops); 390 if (!filp->f_op) 391 goto out_cdev_put; 392 393 if (filp->f_op->open) { 394 ret = filp->f_op->open(inode,filp); 395 if (ret) 396 goto out_cdev_put; 397 } 398 399 return 0; 400 401 out_cdev_put: 402 cdev_put(p); 403 return ret; 404 } 405 406 int cdev_index(struct inode *inode) 407 { 408 int idx; 409 struct kobject *kobj; 410 411 kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx); 412 if (!kobj) 413 return -1; 414 kobject_put(kobj); 415 return idx; 416 } 417 418 void cd_forget(struct inode *inode) 419 { 420 spin_lock(&cdev_lock); 421 list_del_init(&inode->i_devices); 422 inode->i_cdev = NULL; 423 spin_unlock(&cdev_lock); 424 } 425 426 static void cdev_purge(struct cdev *cdev) 427 { 428 spin_lock(&cdev_lock); 429 while (!list_empty(&cdev->list)) { 430 struct inode *inode; 431 inode = container_of(cdev->list.next, struct inode, i_devices); 432 list_del_init(&inode->i_devices); 433 inode->i_cdev = NULL; 434 } 435 spin_unlock(&cdev_lock); 436 } 437 438 /* 439 * Dummy default file-operations: the only thing this does 440 * is contain the open that then fills in the correct operations 441 * depending on the special file... 442 */ 443 const struct file_operations def_chr_fops = { 444 .open = chrdev_open, 445 }; 446 447 static struct kobject *exact_match(dev_t dev, int *part, void *data) 448 { 449 struct cdev *p = data; 450 return &p->kobj; 451 } 452 453 static int exact_lock(dev_t dev, void *data) 454 { 455 struct cdev *p = data; 456 return cdev_get(p) ? 0 : -1; 457 } 458 459 /** 460 * cdev_add() - add a char device to the system 461 * @p: the cdev structure for the device 462 * @dev: the first device number for which this device is responsible 463 * @count: the number of consecutive minor numbers corresponding to this 464 * device 465 * 466 * cdev_add() adds the device represented by @p to the system, making it 467 * live immediately. A negative error code is returned on failure. 468 */ 469 int cdev_add(struct cdev *p, dev_t dev, unsigned count) 470 { 471 p->dev = dev; 472 p->count = count; 473 return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p); 474 } 475 476 static void cdev_unmap(dev_t dev, unsigned count) 477 { 478 kobj_unmap(cdev_map, dev, count); 479 } 480 481 /** 482 * cdev_del() - remove a cdev from the system 483 * @p: the cdev structure to be removed 484 * 485 * cdev_del() removes @p from the system, possibly freeing the structure 486 * itself. 487 */ 488 void cdev_del(struct cdev *p) 489 { 490 cdev_unmap(p->dev, p->count); 491 kobject_put(&p->kobj); 492 } 493 494 495 static void cdev_default_release(struct kobject *kobj) 496 { 497 struct cdev *p = container_of(kobj, struct cdev, kobj); 498 cdev_purge(p); 499 } 500 501 static void cdev_dynamic_release(struct kobject *kobj) 502 { 503 struct cdev *p = container_of(kobj, struct cdev, kobj); 504 cdev_purge(p); 505 kfree(p); 506 } 507 508 static struct kobj_type ktype_cdev_default = { 509 .release = cdev_default_release, 510 }; 511 512 static struct kobj_type ktype_cdev_dynamic = { 513 .release = cdev_dynamic_release, 514 }; 515 516 /** 517 * cdev_alloc() - allocate a cdev structure 518 * 519 * Allocates and returns a cdev structure, or NULL on failure. 520 */ 521 struct cdev *cdev_alloc(void) 522 { 523 struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL); 524 if (p) { 525 INIT_LIST_HEAD(&p->list); 526 kobject_init(&p->kobj, &ktype_cdev_dynamic); 527 } 528 return p; 529 } 530 531 /** 532 * cdev_init() - initialize a cdev structure 533 * @cdev: the structure to initialize 534 * @fops: the file_operations for this device 535 * 536 * Initializes @cdev, remembering @fops, making it ready to add to the 537 * system with cdev_add(). 538 */ 539 void cdev_init(struct cdev *cdev, const struct file_operations *fops) 540 { 541 memset(cdev, 0, sizeof *cdev); 542 INIT_LIST_HEAD(&cdev->list); 543 kobject_init(&cdev->kobj, &ktype_cdev_default); 544 cdev->ops = fops; 545 } 546 547 static struct kobject *base_probe(dev_t dev, int *part, void *data) 548 { 549 if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0) 550 /* Make old-style 2.4 aliases work */ 551 request_module("char-major-%d", MAJOR(dev)); 552 return NULL; 553 } 554 555 void __init chrdev_init(void) 556 { 557 cdev_map = kobj_map_init(base_probe, &chrdevs_lock); 558 bdi_init(&directly_mappable_cdev_bdi); 559 } 560 561 562 /* Let modules do char dev stuff */ 563 EXPORT_SYMBOL(register_chrdev_region); 564 EXPORT_SYMBOL(unregister_chrdev_region); 565 EXPORT_SYMBOL(alloc_chrdev_region); 566 EXPORT_SYMBOL(cdev_init); 567 EXPORT_SYMBOL(cdev_alloc); 568 EXPORT_SYMBOL(cdev_del); 569 EXPORT_SYMBOL(cdev_add); 570 EXPORT_SYMBOL(cdev_index); 571 EXPORT_SYMBOL(register_chrdev); 572 EXPORT_SYMBOL(unregister_chrdev); 573 EXPORT_SYMBOL(directly_mappable_cdev_bdi); 574