1
2
3
4
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
27static struct kobj_map *cdev_map;
28
29static DEFINE_MUTEX(chrdevs_lock);
30
31static 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;
38} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
39
40
41static inline int major_to_index(unsigned major)
42{
43 return major % CHRDEV_MAJOR_HASH_SIZE;
44}
45
46#ifdef CONFIG_PROC_FS
47
48void 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
61
62
63
64
65
66
67
68
69
70
71
72
73static 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
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 == 0) {
95 ret = -EBUSY;
96 goto out;
97 }
98 major = i;
99 }
100
101 cd->major = major;
102 cd->baseminor = baseminor;
103 cd->minorct = minorct;
104 strlcpy(cd->name, name, sizeof(cd->name));
105
106 i = major_to_index(major);
107
108 for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
109 if ((*cp)->major > major ||
110 ((*cp)->major == major &&
111 (((*cp)->baseminor >= baseminor) ||
112 ((*cp)->baseminor + (*cp)->minorct > baseminor))))
113 break;
114
115
116 if (*cp && (*cp)->major == major) {
117 int old_min = (*cp)->baseminor;
118 int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
119 int new_min = baseminor;
120 int new_max = baseminor + minorct - 1;
121
122
123 if (new_max >= old_min && new_max <= old_max) {
124 ret = -EBUSY;
125 goto out;
126 }
127
128
129 if (new_min <= old_max && new_min >= old_min) {
130 ret = -EBUSY;
131 goto out;
132 }
133 }
134
135 cd->next = *cp;
136 *cp = cd;
137 mutex_unlock(&chrdevs_lock);
138 return cd;
139out:
140 mutex_unlock(&chrdevs_lock);
141 kfree(cd);
142 return ERR_PTR(ret);
143}
144
145static struct char_device_struct *
146__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
147{
148 struct char_device_struct *cd = NULL, **cp;
149 int i = major_to_index(major);
150
151 mutex_lock(&chrdevs_lock);
152 for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
153 if ((*cp)->major == major &&
154 (*cp)->baseminor == baseminor &&
155 (*cp)->minorct == minorct)
156 break;
157 if (*cp) {
158 cd = *cp;
159 *cp = cd->next;
160 }
161 mutex_unlock(&chrdevs_lock);
162 return cd;
163}
164
165
166
167
168
169
170
171
172
173
174int register_chrdev_region(dev_t from, unsigned count, const char *name)
175{
176 struct char_device_struct *cd;
177 dev_t to = from + count;
178 dev_t n, next;
179
180 for (n = from; n < to; n = next) {
181 next = MKDEV(MAJOR(n)+1, 0);
182 if (next > to)
183 next = to;
184 cd = __register_chrdev_region(MAJOR(n), MINOR(n),
185 next - n, name);
186 if (IS_ERR(cd))
187 goto fail;
188 }
189 return 0;
190fail:
191 to = n;
192 for (n = from; n < to; n = next) {
193 next = MKDEV(MAJOR(n)+1, 0);
194 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
195 }
196 return PTR_ERR(cd);
197}
198
199
200
201
202
203
204
205
206
207
208
209
210int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
211 const char *name)
212{
213 struct char_device_struct *cd;
214 cd = __register_chrdev_region(0, baseminor, count, name);
215 if (IS_ERR(cd))
216 return PTR_ERR(cd);
217 *dev = MKDEV(cd->major, cd->baseminor);
218 return 0;
219}
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242int __register_chrdev(unsigned int major, unsigned int baseminor,
243 unsigned int count, const char *name,
244 const struct file_operations *fops)
245{
246 struct char_device_struct *cd;
247 struct cdev *cdev;
248 int err = -ENOMEM;
249
250 cd = __register_chrdev_region(major, baseminor, count, name);
251 if (IS_ERR(cd))
252 return PTR_ERR(cd);
253
254 cdev = cdev_alloc();
255 if (!cdev)
256 goto out2;
257
258 cdev->owner = fops->owner;
259 cdev->ops = fops;
260 kobject_set_name(&cdev->kobj, "%s", name);
261
262 err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
263 if (err)
264 goto out;
265
266 cd->cdev = cdev;
267
268 return major ? 0 : cd->major;
269out:
270 kobject_put(&cdev->kobj);
271out2:
272 kfree(__unregister_chrdev_region(cd->major, baseminor, count));
273 return err;
274}
275
276
277
278
279
280
281
282
283
284
285void unregister_chrdev_region(dev_t from, unsigned count)
286{
287 dev_t to = from + count;
288 dev_t n, next;
289
290 for (n = from; n < to; n = next) {
291 next = MKDEV(MAJOR(n)+1, 0);
292 if (next > to)
293 next = to;
294 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
295 }
296}
297
298
299
300
301
302
303
304
305
306
307
308
309void __unregister_chrdev(unsigned int major, unsigned int baseminor,
310 unsigned int count, const char *name)
311{
312 struct char_device_struct *cd;
313
314 cd = __unregister_chrdev_region(major, baseminor, count);
315 if (cd && cd->cdev)
316 cdev_del(cd->cdev);
317 kfree(cd);
318}
319
320static DEFINE_SPINLOCK(cdev_lock);
321
322static struct kobject *cdev_get(struct cdev *p)
323{
324 struct module *owner = p->owner;
325 struct kobject *kobj;
326
327 if (owner && !try_module_get(owner))
328 return NULL;
329 kobj = kobject_get(&p->kobj);
330 if (!kobj)
331 module_put(owner);
332 return kobj;
333}
334
335void cdev_put(struct cdev *p)
336{
337 if (p) {
338 struct module *owner = p->owner;
339 kobject_put(&p->kobj);
340 module_put(owner);
341 }
342}
343
344
345
346
347static int chrdev_open(struct inode *inode, struct file *filp)
348{
349 const struct file_operations *fops;
350 struct cdev *p;
351 struct cdev *new = NULL;
352 int ret = 0;
353
354 spin_lock(&cdev_lock);
355 p = inode->i_cdev;
356 if (!p) {
357 struct kobject *kobj;
358 int idx;
359 spin_unlock(&cdev_lock);
360 kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
361 if (!kobj)
362 return -ENXIO;
363 new = container_of(kobj, struct cdev, kobj);
364 spin_lock(&cdev_lock);
365
366
367 p = inode->i_cdev;
368 if (!p) {
369 inode->i_cdev = p = new;
370 list_add(&inode->i_devices, &p->list);
371 new = NULL;
372 } else if (!cdev_get(p))
373 ret = -ENXIO;
374 } else if (!cdev_get(p))
375 ret = -ENXIO;
376 spin_unlock(&cdev_lock);
377 cdev_put(new);
378 if (ret)
379 return ret;
380
381 ret = -ENXIO;
382 fops = fops_get(p->ops);
383 if (!fops)
384 goto out_cdev_put;
385
386 replace_fops(filp, fops);
387 if (filp->f_op->open) {
388 ret = filp->f_op->open(inode, filp);
389 if (ret)
390 goto out_cdev_put;
391 }
392
393 return 0;
394
395 out_cdev_put:
396 cdev_put(p);
397 return ret;
398}
399
400void cd_forget(struct inode *inode)
401{
402 spin_lock(&cdev_lock);
403 list_del_init(&inode->i_devices);
404 inode->i_cdev = NULL;
405 spin_unlock(&cdev_lock);
406}
407
408static void cdev_purge(struct cdev *cdev)
409{
410 spin_lock(&cdev_lock);
411 while (!list_empty(&cdev->list)) {
412 struct inode *inode;
413 inode = container_of(cdev->list.next, struct inode, i_devices);
414 list_del_init(&inode->i_devices);
415 inode->i_cdev = NULL;
416 }
417 spin_unlock(&cdev_lock);
418}
419
420
421
422
423
424
425const struct file_operations def_chr_fops = {
426 .open = chrdev_open,
427 .llseek = noop_llseek,
428};
429
430static struct kobject *exact_match(dev_t dev, int *part, void *data)
431{
432 struct cdev *p = data;
433 return &p->kobj;
434}
435
436static int exact_lock(dev_t dev, void *data)
437{
438 struct cdev *p = data;
439 return cdev_get(p) ? 0 : -1;
440}
441
442
443
444
445
446
447
448
449
450
451
452int cdev_add(struct cdev *p, dev_t dev, unsigned count)
453{
454 int error;
455
456 p->dev = dev;
457 p->count = count;
458
459 error = kobj_map(cdev_map, dev, count, NULL,
460 exact_match, exact_lock, p);
461 if (error)
462 return error;
463
464 kobject_get(p->kobj.parent);
465
466 return 0;
467}
468
469static void cdev_unmap(dev_t dev, unsigned count)
470{
471 kobj_unmap(cdev_map, dev, count);
472}
473
474
475
476
477
478
479
480
481void cdev_del(struct cdev *p)
482{
483 cdev_unmap(p->dev, p->count);
484 kobject_put(&p->kobj);
485}
486
487
488static void cdev_default_release(struct kobject *kobj)
489{
490 struct cdev *p = container_of(kobj, struct cdev, kobj);
491 struct kobject *parent = kobj->parent;
492
493 cdev_purge(p);
494 kobject_put(parent);
495}
496
497static void cdev_dynamic_release(struct kobject *kobj)
498{
499 struct cdev *p = container_of(kobj, struct cdev, kobj);
500 struct kobject *parent = kobj->parent;
501
502 cdev_purge(p);
503 kfree(p);
504 kobject_put(parent);
505}
506
507static struct kobj_type ktype_cdev_default = {
508 .release = cdev_default_release,
509};
510
511static struct kobj_type ktype_cdev_dynamic = {
512 .release = cdev_dynamic_release,
513};
514
515
516
517
518
519
520struct cdev *cdev_alloc(void)
521{
522 struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
523 if (p) {
524 INIT_LIST_HEAD(&p->list);
525 kobject_init(&p->kobj, &ktype_cdev_dynamic);
526 }
527 return p;
528}
529
530
531
532
533
534
535
536
537
538void cdev_init(struct cdev *cdev, const struct file_operations *fops)
539{
540 memset(cdev, 0, sizeof *cdev);
541 INIT_LIST_HEAD(&cdev->list);
542 kobject_init(&cdev->kobj, &ktype_cdev_default);
543 cdev->ops = fops;
544}
545
546static struct kobject *base_probe(dev_t dev, int *part, void *data)
547{
548 if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
549
550 request_module("char-major-%d", MAJOR(dev));
551 return NULL;
552}
553
554void __init chrdev_init(void)
555{
556 cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
557}
558
559
560
561EXPORT_SYMBOL(register_chrdev_region);
562EXPORT_SYMBOL(unregister_chrdev_region);
563EXPORT_SYMBOL(alloc_chrdev_region);
564EXPORT_SYMBOL(cdev_init);
565EXPORT_SYMBOL(cdev_alloc);
566EXPORT_SYMBOL(cdev_del);
567EXPORT_SYMBOL(cdev_add);
568EXPORT_SYMBOL(__register_chrdev);
569EXPORT_SYMBOL(__unregister_chrdev);
570