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