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