036a573d3426ae8fc23f02e25cbe81477037be8d
[dragonfly.git] / sys / kern / kern_conf.c
1 /*-
2  * Parts Copyright (c) 1995 Terrence R. Lambert
3  * Copyright (c) 1995 Julian R. Elischer
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. All advertising materials mentioning features or use of this software
15  *    must display the following acknowledgement:
16  *      This product includes software developed by Terrence R. Lambert.
17  * 4. The name Terrence R. Lambert may not be used to endorse or promote
18  *    products derived from this software without specific prior written
19  *    permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY Julian R. Elischer ``AS IS'' AND ANY
22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE TERRENCE R. LAMBERT BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * $FreeBSD: src/sys/kern/kern_conf.c,v 1.73.2.3 2003/03/10 02:18:25 imp Exp $
34  * $DragonFly: src/sys/kern/kern_conf.c,v 1.23 2007/05/09 00:53:34 dillon Exp $
35  */
36
37 #include <sys/param.h>
38 #include <sys/kernel.h>
39 #include <sys/sysctl.h>
40 #include <sys/systm.h>
41 #include <sys/module.h>
42 #include <sys/malloc.h>
43 #include <sys/conf.h>
44 #include <sys/vnode.h>
45 #include <sys/queue.h>
46 #include <sys/device.h>
47 #include <sys/disk.h>
48 #include <machine/stdarg.h>
49
50 #include <sys/sysref2.h>
51
52 #include <sys/devfs.h>
53
54 MALLOC_DEFINE(M_DEVT, "cdev_t", "dev_t storage");
55
56 static int free_devt;
57 SYSCTL_INT(_debug, OID_AUTO, free_devt, CTLFLAG_RW, &free_devt, 0, "");
58 int dev_ref_debug = 0;
59 SYSCTL_INT(_debug, OID_AUTO, dev_refs, CTLFLAG_RW, &dev_ref_debug, 0, "");
60
61 /*
62  * cdev_t and u_dev_t primitives.  Note that the major number is always
63  * extracted from si_umajor, not from si_devsw, because si_devsw is replaced
64  * when a device is destroyed.
65  */
66 int
67 major(cdev_t dev)
68 {
69         if (dev == NULL)
70                 return NOUDEV;
71         return(dev->si_umajor);
72 }
73
74 int
75 minor(cdev_t dev)
76 {
77         if (dev == NULL)
78                 return NOUDEV;
79         return(dev->si_uminor);
80 }
81
82 /*
83  * Compatibility function with old udev_t format to convert the
84  * non-consecutive minor space into a consecutive minor space.
85  */
86 int
87 lminor(cdev_t dev)
88 {
89         int y;
90
91         if (dev == NULL)
92                 return NOUDEV;
93         y = dev->si_uminor;
94         if (y & 0x0000ff00)
95                 return NOUDEV;
96         return ((y & 0xff) | (y >> 8));
97 }
98
99 /*
100  * Convert a device pointer to an old style device number.  Return NOUDEV
101  * if the device is invalid or if the device (maj,min) cannot be converted
102  * to an old style udev_t.
103  */
104 udev_t
105 dev2udev(cdev_t dev)
106 {
107         if (dev == NULL)
108                 return NOUDEV;
109
110         return (udev_t)dev->si_inode;
111 }
112
113 /*
114  * Convert a device number to a device pointer.  The device is referenced
115  * ad-hoc, meaning that the caller should call reference_dev() if it wishes
116  * to keep ahold of the returned structure long term.
117  *
118  * The returned device is associated with the currently installed cdevsw
119  * for the requested major number.  NULL is returned if the major number
120  * has not been registered.
121  */
122 cdev_t
123 udev2dev(udev_t x, int b)
124 {
125         if (x == NOUDEV || b != 0)
126                 return(NULL);
127
128         return devfs_find_device_by_udev(x);
129 }
130
131 int
132 dev_is_good(cdev_t dev)
133 {
134         if (dev != NULL && dev->si_ops != &dead_dev_ops)
135                 return(1);
136         return(0);
137 }
138
139 /*
140  * Various user device number extraction and conversion routines
141  */
142 int
143 uminor(udev_t dev)
144 {
145         if (dev == NOUDEV)
146                 return(-1);
147         return(dev & 0xffff00ff);
148 }
149
150 int
151 umajor(udev_t dev)
152 {
153         if (dev == NOUDEV)
154                 return(-1);
155         return((dev & 0xff00) >> 8);
156 }
157
158 udev_t
159 makeudev(int x, int y)
160 {
161         if ((x & 0xffffff00) || (y & 0x0000ff00))
162                 return NOUDEV;
163         return ((x << 8) | y);
164 }
165
166 /*
167  * Create an internal or external device.
168  *
169  * This routine creates and returns an unreferenced ad-hoc entry for the
170  * device which will remain intact until the device is destroyed.  If the
171  * caller intends to store the device pointer it must call reference_dev()
172  * to retain a real reference to the device.
173  *
174  * If an entry already exists, this function will set (or override)
175  * its cred requirements and name (XXX DEVFS interface).
176  */
177 cdev_t
178 make_dev(struct dev_ops *ops, int minor, uid_t uid, gid_t gid,
179         int perms, const char *fmt, ...)
180 {
181         cdev_t  devfs_dev;
182         __va_list ap;
183
184         /*
185          * compile the cdevsw and install the device
186          */
187         compile_dev_ops(ops);
188
189         devfs_dev = devfs_new_cdev(ops, minor, NULL);
190         __va_start(ap, fmt);
191         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
192                     32, fmt, ap);
193         __va_end(ap);
194
195         devfs_debug(DEVFS_DEBUG_INFO,
196                     "make_dev called for %s\n",
197                     devfs_dev->si_name);
198         devfs_create_dev(devfs_dev, uid, gid, perms);
199
200         return (devfs_dev);
201 }
202
203 /*
204  * make_dev_covering has equivalent functionality to make_dev, except that it
205  * also takes the cdev of the underlying device. Hence this function should
206  * only be used by systems and drivers which create devices covering others
207  */
208 cdev_t
209 make_dev_covering(struct dev_ops *ops, struct dev_ops *bops, int minor,
210             uid_t uid, gid_t gid, int perms, const char *fmt, ...)
211 {
212         cdev_t  devfs_dev;
213         __va_list ap;
214
215         /*
216          * compile the cdevsw and install the device
217          */
218         compile_dev_ops(ops);
219
220         devfs_dev = devfs_new_cdev(ops, minor, bops);
221         __va_start(ap, fmt);
222         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
223                     32, fmt, ap);
224         __va_end(ap);
225
226         devfs_debug(DEVFS_DEBUG_INFO,
227                     "make_dev called for %s\n",
228                     devfs_dev->si_name);
229         devfs_create_dev(devfs_dev, uid, gid, perms);
230
231         return (devfs_dev);
232 }
233
234
235
236 cdev_t
237 make_only_devfs_dev(struct dev_ops *ops, int minor, uid_t uid, gid_t gid,
238         int perms, const char *fmt, ...)
239 {
240         cdev_t  devfs_dev;
241         __va_list ap;
242
243         /*
244          * compile the cdevsw and install the device
245          */
246         compile_dev_ops(ops);
247         devfs_dev = devfs_new_cdev(ops, minor, NULL);
248
249         /*
250          * Set additional fields (XXX DEVFS interface goes here)
251          */
252         __va_start(ap, fmt);
253         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
254                     32, fmt, ap);
255         __va_end(ap);
256
257         devfs_create_dev(devfs_dev, uid, gid, perms);
258
259         return (devfs_dev);
260 }
261
262 cdev_t
263 make_only_dev(struct dev_ops *ops, int minor, uid_t uid, gid_t gid,
264         int perms, const char *fmt, ...)
265 {
266         cdev_t  devfs_dev;
267         __va_list ap;
268
269         /*
270          * compile the cdevsw and install the device
271          */
272         compile_dev_ops(ops);
273         devfs_dev = devfs_new_cdev(ops, minor, NULL);
274         devfs_dev->si_perms = perms;
275         devfs_dev->si_uid = uid;
276         devfs_dev->si_gid = gid;
277
278         /*
279          * Set additional fields (XXX DEVFS interface goes here)
280          */
281         __va_start(ap, fmt);
282         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
283                     32, fmt, ap);
284         __va_end(ap);
285
286         reference_dev(devfs_dev);
287
288         return (devfs_dev);
289 }
290
291 cdev_t
292 make_only_dev_covering(struct dev_ops *ops, struct dev_ops *bops, int minor,
293         uid_t uid, gid_t gid, int perms, const char *fmt, ...)
294 {
295         cdev_t  devfs_dev;
296         __va_list ap;
297
298         /*
299          * compile the cdevsw and install the device
300          */
301         compile_dev_ops(ops);
302         devfs_dev = devfs_new_cdev(ops, minor, bops);
303         devfs_dev->si_perms = perms;
304         devfs_dev->si_uid = uid;
305         devfs_dev->si_gid = gid;
306
307         /*
308          * Set additional fields (XXX DEVFS interface goes here)
309          */
310         __va_start(ap, fmt);
311         kvsnrprintf(devfs_dev->si_name, sizeof(devfs_dev->si_name),
312                     32, fmt, ap);
313         __va_end(ap);
314
315         reference_dev(devfs_dev);
316
317         return (devfs_dev);
318 }
319
320 void
321 destroy_only_dev(cdev_t dev)
322 {
323         release_dev(dev);
324         release_dev(dev);
325         release_dev(dev);
326 }
327
328 /*
329  * destroy_dev() removes the adhoc association for a device and revectors
330  * its ops to &dead_dev_ops.
331  *
332  * This routine releases the reference count associated with the ADHOC
333  * entry, plus releases the reference count held by the caller.  What this
334  * means is that you should not call destroy_dev(make_dev(...)), because
335  * make_dev() does not bump the reference count (beyond what it needs to
336  * create the ad-hoc association).  Any procedure that intends to destroy
337  * a device must have its own reference to it first.
338  */
339 void
340 destroy_dev(cdev_t dev)
341 {
342         if (dev) {
343                 devfs_debug(DEVFS_DEBUG_DEBUG,
344                             "destroy_dev called for %s\n",
345                             dev->si_name);
346                 devfs_destroy_dev(dev);
347         }
348 }
349
350 /*
351  * Make sure all asynchronous disk and devfs related operations have
352  * completed.
353  *
354  * Typically called prior to mountroot to ensure that all disks have
355  * been completely probed and on module unload to ensure that ops
356  * structures have been dereferenced.
357  */
358 void
359 sync_devs(void)
360 {
361         disk_config(NULL);
362         devfs_config();
363         disk_config(NULL);
364         devfs_config();
365 }
366
367 int
368 make_dev_alias(cdev_t target, const char *fmt, ...)
369 {
370         __va_list ap;
371         char *name;
372
373         __va_start(ap, fmt);
374         kvasnrprintf(&name, PATH_MAX, 32, fmt, ap);
375         __va_end(ap);
376
377         devfs_make_alias(name, target);
378         kvasfree(&name);
379
380         return 0;
381 }
382
383 int
384 destroy_dev_alias(cdev_t target, const char *fmt, ...)
385 {
386         __va_list ap;
387         char *name;
388
389         __va_start(ap, fmt);
390         kvasnrprintf(&name, PATH_MAX, 32, fmt, ap);
391         __va_end(ap);
392
393         devfs_destroy_alias(name, target);
394         kvasfree(&name);
395
396         return 0;
397 }
398
399 extern struct dev_ops default_dev_ops;
400
401 cdev_t
402 make_autoclone_dev(struct dev_ops *ops, struct devfs_bitmap *bitmap,
403                 d_clone_t *nhandler, uid_t uid, gid_t gid, int perms, const char *fmt, ...)
404 {
405         __va_list ap;
406         cdev_t dev;
407         char *name;
408
409         __va_start(ap, fmt);
410         kvasnrprintf(&name, PATH_MAX, 32, fmt, ap);
411         __va_end(ap);
412
413         if (bitmap != NULL)
414                 devfs_clone_bitmap_init(bitmap);
415
416         devfs_clone_handler_add(name, nhandler);
417         dev = make_dev_covering(&default_dev_ops, ops, 0xffff00ff,
418                        uid, gid, perms, "%s", name);
419         kvasfree(&name);
420         return dev;
421 }
422
423 void
424 destroy_autoclone_dev(cdev_t dev, struct devfs_bitmap *bitmap)
425 {
426         if (dev == NULL)
427                 return;
428
429         devfs_clone_handler_del(dev->si_name);
430
431         if (bitmap != NULL)
432                 devfs_clone_bitmap_uninit(bitmap);
433
434         destroy_dev(dev);
435 }
436
437
438 /*
439  * Add a reference to a device.  Callers generally add their own references
440  * when they are going to store a device node in a variable for long periods
441  * of time, to prevent a disassociation from free()ing the node.
442  *
443  * Also note that a caller that intends to call destroy_dev() must first
444  * obtain a reference on the device.  The ad-hoc reference you get with
445  * make_dev() and friends is NOT sufficient to be able to call destroy_dev().
446  */
447 cdev_t
448 reference_dev(cdev_t dev)
449 {
450         //kprintf("reference_dev\n");
451
452         if (dev != NULL) {
453                 sysref_get(&dev->si_sysref);
454                 if (dev_ref_debug & 2) {
455                         kprintf("reference dev %p %s(minor=%08x) refs=%d\n",
456                             dev, devtoname(dev), dev->si_uminor,
457                             dev->si_sysref.refcnt);
458                 }
459         }
460         return(dev);
461 }
462
463 /*
464  * release a reference on a device.  The device will be terminated when the
465  * last reference has been released.
466  *
467  * NOTE: we must use si_umajor to figure out the original major number,
468  * because si_ops could already be pointing at dead_dev_ops.
469  */
470 void
471 release_dev(cdev_t dev)
472 {
473         //kprintf("release_dev\n");
474
475         if (dev == NULL)
476                 return;
477         sysref_put(&dev->si_sysref);
478 }
479
480 const char *
481 devtoname(cdev_t dev)
482 {
483         int mynor;
484         int len;
485         char *p;
486         const char *dname;
487
488         if (dev == NULL)
489                 return("#nodev");
490         if (dev->si_name[0] == '#' || dev->si_name[0] == '\0') {
491                 p = dev->si_name;
492                 len = sizeof(dev->si_name);
493                 if ((dname = dev_dname(dev)) != NULL)
494                         ksnprintf(p, len, "#%s/", dname);
495                 else
496                         ksnprintf(p, len, "#%d/", major(dev));
497                 len -= strlen(p);
498                 p += strlen(p);
499                 mynor = minor(dev);
500                 if (mynor < 0 || mynor > 255)
501                         ksnprintf(p, len, "%#x", (u_int)mynor);
502                 else
503                         ksnprintf(p, len, "%d", mynor);
504         }
505         return (dev->si_name);
506 }
507