2 * Parts Copyright (c) 1995 Terrence R. Lambert
3 * Copyright (c) 1995 Julian R. Elischer
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
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
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.11 2005/03/23 02:50:53 dillon Exp $
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>
44 #include <sys/vnode.h>
45 #include <sys/queue.h>
46 #include <sys/device.h>
47 #include <machine/stdarg.h>
49 #define cdevsw_ALLOCSTART (NUMCDEVSW/2)
51 MALLOC_DEFINE(M_DEVT
, "dev_t", "dev_t storage");
54 * This is the number of hash-buckets. Experiements with 'real-life'
55 * udev_t's show that a prime halfway between two powers of two works
60 /* The number of dev_t's we can create before malloc(9) kick in. */
63 static struct specinfo devt_stash
[DEVT_STASH
];
64 static LIST_HEAD(, specinfo
) dev_hash
[DEVT_HASH
];
65 static LIST_HEAD(, specinfo
) dev_free_list
;
68 SYSCTL_INT(_debug
, OID_AUTO
, free_devt
, CTLFLAG_RW
, &free_devt
, 0, "");
69 int dev_ref_debug
= 0;
70 SYSCTL_INT(_debug
, OID_AUTO
, dev_refs
, CTLFLAG_RW
, &dev_ref_debug
, 0, "");
73 * dev_t and u_dev_t primitives. Note that the major number is always
74 * extracted from si_udev, not from si_devsw, because si_devsw is replaced
75 * when a device is destroyed.
82 return((x
->si_udev
>> 8) & 0xff);
90 return(x
->si_udev
& 0xffff00ff);
101 return ((i
& 0xff) | (i
>> 8));
105 * This is a bit complex because devices are always created relative to
106 * a particular cdevsw, including 'hidden' cdevsw's (such as the raw device
107 * backing a disk subsystem overlay), so we have to compare both the
108 * devsw and udev fields to locate the correct device.
110 * The device is created if it does not already exist. If SI_ADHOC is not
111 * set the device will be referenced (once) and SI_ADHOC will be set.
112 * The caller must explicitly add additional references to the device if
113 * the caller wishes to track additional references.
117 hashdev(struct cdevsw
*devsw
, int x
, int y
)
124 udev
= makeudev(x
, y
);
125 hash
= udev
% DEVT_HASH
;
126 LIST_FOREACH(si
, &dev_hash
[hash
], si_hash
) {
127 if (si
->si_devsw
== devsw
&& si
->si_udev
== udev
)
130 if (stashed
>= DEVT_STASH
) {
131 MALLOC(si
, struct specinfo
*, sizeof(*si
), M_DEVT
,
132 M_WAITOK
|M_USE_RESERVE
|M_ZERO
);
133 } else if (LIST_FIRST(&dev_free_list
)) {
134 si
= LIST_FIRST(&dev_free_list
);
135 LIST_REMOVE(si
, si_hash
);
137 si
= devt_stash
+ stashed
++;
138 si
->si_flags
|= SI_STASHED
;
140 si
->si_devsw
= devsw
;
141 si
->si_flags
|= SI_HASHED
| SI_ADHOC
;
144 LIST_INSERT_HEAD(&dev_hash
[hash
], si
, si_hash
);
145 si
->si_port
= devsw
->d_port
;
147 if (devsw
!= &dead_cdevsw
)
150 printf("create dev %p %s(minor=%08x) refs=%d\n",
151 si
, devtoname(si
), uminor(si
->si_udev
),
158 * Convert a device pointer to a device number
169 * Convert a device number to a device pointer. The device is referenced
170 * ad-hoc, meaning that the caller should call reference_dev() if it wishes
171 * to keep ahold of the returned structure long term.
173 * The returned device is associated with the currently installed cdevsw
174 * for the requested major number. NODEV is returned if the major number
175 * has not been registered.
178 udev2dev(udev_t x
, int b
)
181 struct cdevsw
*devsw
;
183 if (x
== NOUDEV
|| b
!= 0)
185 devsw
= cdevsw_get(umajor(x
), uminor(x
));
188 dev
= hashdev(devsw
, umajor(x
), uminor(x
));
193 dev_is_good(dev_t dev
)
195 if (dev
!= NODEV
&& dev
->si_devsw
!= &dead_cdevsw
)
201 * Various user device number extraction and conversion routines
206 return(dev
& 0xffff00ff);
212 return((dev
& 0xff00) >> 8);
216 makeudev(int x
, int y
)
218 return ((x
<< 8) | y
);
222 * Create an internal or external device.
224 * Device majors can be overloaded and used directly by the kernel without
225 * conflict, but userland will only see the particular device major that
226 * has been installed with cdevsw_add().
228 * This routine creates and returns an unreferenced ad-hoc entry for the
229 * device which will remain intact until the device is destroyed. If the
230 * caller intends to store the device pointer it must call reference_dev()
231 * to retain a real reference to the device.
233 * If an entry already exists, this function will set (or override)
234 * its cred requirements and name (XXX DEVFS interface).
237 make_dev(struct cdevsw
*devsw
, int minor
, uid_t uid
, gid_t gid
,
238 int perms
, const char *fmt
, ...)
245 * compile the cdevsw and install the device
247 compile_devsw(devsw
);
248 dev
= hashdev(devsw
, devsw
->d_maj
, minor
);
251 * Set additional fields (XXX DEVFS interface goes here)
254 i
= kvprintf(fmt
, NULL
, dev
->si_name
, 32, ap
);
255 dev
->si_name
[i
] = '\0';
262 * This function is similar to make_dev() but no cred information or name
266 make_adhoc_dev(struct cdevsw
*devsw
, int minor
)
270 dev
= hashdev(devsw
, devsw
->d_maj
, minor
);
275 * This function is similar to make_dev() except the new device is created
276 * using an old device as a template.
279 make_sub_dev(dev_t odev
, int minor
)
283 dev
= hashdev(odev
->si_devsw
, umajor(odev
->si_udev
), minor
);
286 * Copy cred requirements and name info XXX DEVFS.
288 if (dev
->si_name
[0] == 0 && odev
->si_name
[0])
289 bcopy(odev
->si_name
, dev
->si_name
, sizeof(dev
->si_name
));
294 * destroy_dev() removes the adhoc association for a device and revectors
295 * its devsw to &dead_cdevsw.
297 * This routine releases the reference count associated with the ADHOC
298 * entry, plus releases the reference count held by the caller. What this
299 * means is that you should not call destroy_dev(make_dev(...)), because
300 * make_dev() does not bump the reference count (beyond what it needs to
301 * create the ad-hoc association). Any procedure that intends to destroy
302 * a device must have its own reference to it first.
305 destroy_dev(dev_t dev
)
311 if ((dev
->si_flags
& SI_ADHOC
) == 0) {
316 printf("destroy dev %p %s(minor=%08x) refs=%d\n",
317 dev
, devtoname(dev
), uminor(dev
->si_udev
),
320 if (dev
->si_refs
< 2) {
321 printf("destroy_dev(): too few references on device! "
322 "%p %s(minor=%08x) refs=%d\n",
323 dev
, devtoname(dev
), uminor(dev
->si_udev
),
326 dev
->si_flags
&= ~SI_ADHOC
;
327 if (dev
->si_flags
& SI_HASHED
) {
328 hash
= dev
->si_udev
% DEVT_HASH
;
329 LIST_REMOVE(dev
, si_hash
);
330 dev
->si_flags
&= ~SI_HASHED
;
334 * We have to release the cdevsw reference before we replace the
335 * device switch with dead_cdevsw.
337 if (dead_cdevsw
.d_port
== NULL
)
338 compile_devsw(&dead_cdevsw
);
339 if (dev
->si_devsw
&& dev
->si_devsw
!= &dead_cdevsw
)
340 cdevsw_release(dev
->si_devsw
);
343 dev
->si_devsw
= &dead_cdevsw
;
344 dev
->si_port
= dev
->si_devsw
->d_port
;
345 --dev
->si_refs
; /* release adhoc association reference */
346 release_dev(dev
); /* release callers reference */
350 * Destroy all ad-hoc device associations associated with a domain within a
351 * device switch. Only the minor numbers are included in the mask/match
354 * Unlike the cdevsw functions whos link structures do not contain
355 * any major bits, this function scans through the dev list via si_udev
356 * which is a 32 bit field that contains both major and minor bits.
357 * Because of this, we must mask the minor bits in the passed mask variable
358 * to allow -1 to be specified generically.
360 * The caller must not include any major bits in the match value.
363 destroy_all_dev(struct cdevsw
*devsw
, u_int mask
, u_int match
)
370 for (i
= 0; i
< DEVT_HASH
; ++i
) {
371 ndev
= LIST_FIRST(&dev_hash
[i
]);
372 while ((dev
= ndev
) != NULL
) {
373 ndev
= LIST_NEXT(dev
, si_hash
);
374 KKASSERT(dev
->si_flags
& SI_ADHOC
);
375 if (dev
->si_devsw
== devsw
&&
376 (dev
->si_udev
& mask
) == match
386 * Add a reference to a device. Callers generally add their own references
387 * when they are going to store a device node in a variable for long periods
388 * of time, to prevent a disassociation from free()ing the node.
390 * Also note that a caller that intends to call destroy_dev() must first
391 * obtain a reference on the device. The ad-hoc reference you get with
392 * make_dev() and friends is NOT sufficient to be able to call destroy_dev().
395 reference_dev(dev_t dev
)
400 printf("reference dev %p %s(minor=%08x) refs=%d\n",
401 dev
, devtoname(dev
), uminor(dev
->si_udev
),
409 * release a reference on a device. The device will be freed when the last
410 * reference has been released.
412 * NOTE: we must use si_udev to figure out the original (major, minor),
413 * because si_devsw could already be pointing at dead_cdevsw.
416 release_dev(dev_t dev
)
421 KKASSERT(dev
->si_refs
> 0);
423 if (dev
->si_refs
<= 0) {
424 printf("Warning: extra release of dev %p(%s)\n",
425 dev
, devtoname(dev
));
426 free_devt
= 0; /* prevent bad things from occuring */
431 printf("release dev %p %s(minor=%08x) refs=%d\n",
432 dev
, devtoname(dev
), uminor(dev
->si_udev
),
435 if (dev
->si_refs
== 0) {
436 if (dev
->si_flags
& SI_ADHOC
) {
437 printf("Warning: illegal final release on ADHOC"
438 " device %p(%s), the device was never"
440 dev
, devtoname(dev
));
442 if (dev
->si_flags
& SI_HASHED
) {
443 printf("Warning: last release on device, no call"
444 " to destroy_dev() was made! dev %p(%s)\n",
445 dev
, devtoname(dev
));
450 if (SLIST_FIRST(&dev
->si_hlist
) != NULL
) {
451 printf("Warning: last release on device, vnode"
452 " associations still exist! dev %p(%s)\n",
453 dev
, devtoname(dev
));
454 free_devt
= 0; /* prevent bad things from occuring */
456 if (dev
->si_devsw
&& dev
->si_devsw
!= &dead_cdevsw
) {
457 cdevsw_release(dev
->si_devsw
);
458 dev
->si_devsw
= NULL
;
461 if (dev
->si_flags
& SI_STASHED
) {
462 bzero(dev
, sizeof(*dev
));
463 LIST_INSERT_HEAD(&dev_free_list
, dev
, si_hash
);
481 if (dev
->si_name
[0] == '#' || dev
->si_name
[0] == '\0') {
483 len
= sizeof(dev
->si_name
);
484 if ((dname
= dev_dname(dev
)) != NULL
)
485 snprintf(p
, len
, "#%s/", dname
);
487 snprintf(p
, len
, "#%d/", major(dev
));
491 if (mynor
< 0 || mynor
> 255)
492 snprintf(p
, len
, "%#x", (u_int
)mynor
);
494 snprintf(p
, len
, "%d", mynor
);
496 return (dev
->si_name
);