devfs_devs.c revision 110063 
1#define DEBUG 1
2/*
3 * Copyright (c) 2000
4 *	Poul-Henning Kamp.  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. Neither the name of the University nor the names of its contributors
12 *    may be used to endorse or promote products derived from this software
13 *    without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * From: FreeBSD: src/sys/miscfs/kernfs/kernfs_vfsops.c 1.36
28 *
29 * $FreeBSD: head/sys/fs/devfs/devfs_devs.c 110063 2003-01-29 22:36:45Z phk $
30 */
31
32#include "opt_devfs.h"
33#include "opt_mac.h"
34
35#include <sys/param.h>
36#include <sys/systm.h>
37#include <sys/conf.h>
38#include <sys/dirent.h>
39#include <sys/kernel.h>
40#include <sys/lock.h>
41#include <sys/mac.h>
42#include <sys/malloc.h>
43#include <sys/proc.h>
44#include <sys/sysctl.h>
45#include <sys/vnode.h>
46
47#include <machine/atomic.h>
48
49#include <fs/devfs/devfs.h>
50
51static dev_t devfs_inot[NDEVFSINO];
52static dev_t *devfs_overflow;
53static int devfs_ref[NDEVFSINO];
54static int *devfs_refoverflow;
55static int devfs_nextino = 3;
56static int devfs_numino;
57static int devfs_topino;
58static int devfs_noverflowwant = NDEVFSOVERFLOW;
59static int devfs_noverflow;
60static unsigned devfs_generation;
61
62static void devfs_attemptoverflow(int insist);
63static struct devfs_dirent *devfs_find (struct devfs_dirent *dd, const char *name, int namelen);
64
65SYSCTL_NODE(_vfs, OID_AUTO, devfs, CTLFLAG_RW, 0, "DEVFS filesystem");
66SYSCTL_UINT(_vfs_devfs, OID_AUTO, noverflow, CTLFLAG_RW,
67	&devfs_noverflowwant, 0, "Size of DEVFS overflow table");
68SYSCTL_UINT(_vfs_devfs, OID_AUTO, generation, CTLFLAG_RD,
69	&devfs_generation, 0, "DEVFS generation number");
70SYSCTL_UINT(_vfs_devfs, OID_AUTO, inodes, CTLFLAG_RD,
71	&devfs_numino, 0, "DEVFS inodes");
72SYSCTL_UINT(_vfs_devfs, OID_AUTO, topinode, CTLFLAG_RD,
73	&devfs_topino, 0, "DEVFS highest inode#");
74
75static int *
76devfs_itor(int inode)
77{
78	if (inode < NDEVFSINO)
79		return (&devfs_ref[inode]);
80	else if (inode < NDEVFSINO + devfs_noverflow)
81		return (&devfs_refoverflow[inode - NDEVFSINO]);
82	else
83		panic ("YRK!");
84}
85
86static void
87devfs_dropref(int inode)
88{
89	int *ip;
90
91	ip = devfs_itor(inode);
92	atomic_add_int(ip, -1);
93}
94
95static int
96devfs_getref(int inode)
97{
98	int *ip, i, j;
99	dev_t *dp;
100
101	ip = devfs_itor(inode);
102	dp = devfs_itod(inode);
103	for (;;) {
104		i = *ip;
105		j = i + 1;
106		if (!atomic_cmpset_int(ip, i, j))
107			continue;
108		if (*dp != NULL)
109			return (1);
110		atomic_add_int(ip, -1);
111		return(0);
112	}
113}
114
115struct devfs_dirent **
116devfs_itode (struct devfs_mount *dm, int inode)
117{
118
119	if (inode < NDEVFSINO)
120		return (&dm->dm_dirent[inode]);
121	if (devfs_overflow == NULL)
122		return (NULL);
123	if (inode < NDEVFSINO + devfs_noverflow)
124		return (&dm->dm_overflow[inode - NDEVFSINO]);
125	return (NULL);
126}
127
128dev_t *
129devfs_itod (int inode)
130{
131
132	if (inode < NDEVFSINO)
133		return (&devfs_inot[inode]);
134	if (devfs_overflow == NULL)
135		return (NULL);
136	if (inode < NDEVFSINO + devfs_noverflow)
137		return (&devfs_overflow[inode - NDEVFSINO]);
138	return (NULL);
139}
140
141static void
142devfs_attemptoverflow(int insist)
143{
144	dev_t **ot;
145	int *or;
146	int n, nb;
147
148	/* Check if somebody beat us to it */
149	if (devfs_overflow != NULL)
150		return;
151	ot = NULL;
152	or = NULL;
153	n = devfs_noverflowwant;
154	nb = sizeof (dev_t *) * n;
155	MALLOC(ot, dev_t **, nb, M_DEVFS, (insist ? 0 : M_NOWAIT) | M_ZERO);
156	if (ot == NULL)
157		goto bail;
158	nb = sizeof (int) * n;
159	MALLOC(or, int *, nb, M_DEVFS, (insist ? 0 : M_NOWAIT) | M_ZERO);
160	if (or == NULL)
161		goto bail;
162	if (!atomic_cmpset_ptr(&devfs_overflow, NULL, ot))
163		goto bail;
164	devfs_refoverflow = or;
165	devfs_noverflow = n;
166	printf("DEVFS Overflow table with %d entries allocated when %d in use\n", n, devfs_numino);
167	return;
168
169bail:
170	/* Somebody beat us to it, or something went wrong. */
171	if (ot != NULL)
172		FREE(ot, M_DEVFS);
173	if (or != NULL)
174		FREE(or, M_DEVFS);
175	return;
176}
177
178static struct devfs_dirent *
179devfs_find(struct devfs_dirent *dd, const char *name, int namelen)
180{
181	struct devfs_dirent *de;
182
183	TAILQ_FOREACH(de, &dd->de_dlist, de_list) {
184		if (namelen != de->de_dirent->d_namlen)
185			continue;
186		if (bcmp(name, de->de_dirent->d_name, namelen) != 0)
187			continue;
188		break;
189	}
190	return (de);
191}
192
193struct devfs_dirent *
194devfs_newdirent(char *name, int namelen)
195{
196	int i;
197	struct devfs_dirent *de;
198	struct dirent d;
199
200	d.d_namlen = namelen;
201	i = sizeof (*de) + GENERIC_DIRSIZ(&d);
202	MALLOC(de, struct devfs_dirent *, i, M_DEVFS, M_ZERO);
203	de->de_dirent = (struct dirent *)(de + 1);
204	de->de_dirent->d_namlen = namelen;
205	de->de_dirent->d_reclen = GENERIC_DIRSIZ(&d);
206	bcopy(name, de->de_dirent->d_name, namelen);
207	de->de_dirent->d_name[namelen] = '\0';
208	vfs_timestamp(&de->de_ctime);
209	de->de_mtime = de->de_atime = de->de_ctime;
210	de->de_links = 1;
211#ifdef MAC
212	mac_init_devfsdirent(de);
213#endif
214	return (de);
215}
216
217struct devfs_dirent *
218devfs_vmkdir(char *name, int namelen, struct devfs_dirent *dotdot)
219{
220	struct devfs_dirent *dd;
221	struct devfs_dirent *de;
222
223	dd = devfs_newdirent(name, namelen);
224
225	TAILQ_INIT(&dd->de_dlist);
226
227	dd->de_dirent->d_type = DT_DIR;
228	dd->de_mode = 0555;
229	dd->de_links = 2;
230	dd->de_dir = dd;
231
232	de = devfs_newdirent(".", 1);
233	de->de_dirent->d_type = DT_DIR;
234	de->de_dir = dd;
235	de->de_flags |= DE_DOT;
236	TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list);
237
238	de = devfs_newdirent("..", 2);
239	de->de_dirent->d_type = DT_DIR;
240	if (dotdot == NULL)
241		de->de_dir = dd;
242	else
243		de->de_dir = dotdot;
244	de->de_flags |= DE_DOTDOT;
245	TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list);
246
247	return (dd);
248}
249
250static void
251devfs_delete(struct devfs_dirent *dd, struct devfs_dirent *de)
252{
253
254	if (de->de_symlink) {
255		FREE(de->de_symlink, M_DEVFS);
256		de->de_symlink = NULL;
257	}
258	if (de->de_vnode)
259		de->de_vnode->v_data = NULL;
260	TAILQ_REMOVE(&dd->de_dlist, de, de_list);
261#ifdef MAC
262	mac_destroy_devfsdirent(de);
263#endif
264	FREE(de, M_DEVFS);
265}
266
267void
268devfs_purge(struct devfs_dirent *dd)
269{
270	struct devfs_dirent *de;
271
272	for (;;) {
273		de = TAILQ_FIRST(&dd->de_dlist);
274		if (de == NULL)
275			break;
276		devfs_delete(dd, de);
277	}
278	FREE(dd, M_DEVFS);
279}
280
281
282int
283devfs_populate(struct devfs_mount *dm)
284{
285	int i, j;
286	dev_t dev, pdev;
287	struct devfs_dirent *dd;
288	struct devfs_dirent *de, **dep;
289	char *q, *s;
290
291	if (dm->dm_generation == devfs_generation)
292		return (0);
293	lockmgr(&dm->dm_lock, LK_UPGRADE, 0, curthread);
294	if (devfs_noverflow && dm->dm_overflow == NULL) {
295		i = devfs_noverflow * sizeof (struct devfs_dirent *);
296		MALLOC(dm->dm_overflow, struct devfs_dirent **, i,
297			M_DEVFS, M_ZERO);
298	}
299	while (dm->dm_generation != devfs_generation) {
300		dm->dm_generation = devfs_generation;
301		for (i = 0; i <= devfs_topino; i++) {
302			dev = *devfs_itod(i);
303			dep = devfs_itode(dm, i);
304			de = *dep;
305			if (dev == NULL && de == DE_DELETED) {
306				*dep = NULL;
307				continue;
308			}
309			if (dev == NULL && de != NULL) {
310				dd = de->de_dir;
311				*dep = NULL;
312				TAILQ_REMOVE(&dd->de_dlist, de, de_list);
313				if (de->de_vnode)
314					de->de_vnode->v_data = NULL;
315				FREE(de, M_DEVFS);
316				devfs_dropref(i);
317				continue;
318			}
319			if (dev == NULL)
320				continue;
321			if (de != NULL)
322				continue;
323			if (!devfs_getref(i))
324				continue;
325			dd = dm->dm_basedir;
326			s = dev->si_name;
327			for (;;) {
328				for (q = s; *q != '/' && *q != '\0'; q++)
329					continue;
330				if (*q != '/')
331					break;
332				de = devfs_find(dd, s, q - s);
333				if (de == NULL) {
334					de = devfs_vmkdir(s, q - s, dd);
335#ifdef MAC
336					mac_create_devfs_directory(
337					    dm->dm_mount, s, q - s, de);
338#endif
339					de->de_inode = dm->dm_inode++;
340					TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list);
341					dd->de_links++;
342				}
343				s = q + 1;
344				dd = de;
345			}
346			de = devfs_newdirent(s, q - s);
347			if (dev->si_flags & SI_ALIAS) {
348				de->de_inode = dm->dm_inode++;
349				de->de_uid = 0;
350				de->de_gid = 0;
351				de->de_mode = 0755;
352				de->de_dirent->d_type = DT_LNK;
353				pdev = dev->si_parent;
354				j = strlen(pdev->si_name) + 1;
355				MALLOC(de->de_symlink, char *, j, M_DEVFS, 0);
356				bcopy(pdev->si_name, de->de_symlink, j);
357			} else {
358				de->de_inode = i;
359				de->de_uid = dev->si_uid;
360				de->de_gid = dev->si_gid;
361				de->de_mode = dev->si_mode;
362				de->de_dirent->d_type = DT_CHR;
363			}
364#ifdef MAC
365			mac_create_devfs_device(dm->dm_mount, dev, de);
366#endif
367			*dep = de;
368			de->de_dir = dd;
369			devfs_rules_apply(dm, de);
370			TAILQ_INSERT_TAIL(&dd->de_dlist, de, de_list);
371#if 0
372			printf("Add ino%d %s\n", i, dev->si_name);
373#endif
374		}
375	}
376	lockmgr(&dm->dm_lock, LK_DOWNGRADE, 0, curthread);
377	return (0);
378}
379
380static void
381devfs_create(dev_t dev)
382{
383	int ino, i, *ip;
384	dev_t *dp;
385
386	for (;;) {
387		/* Grab the next inode number */
388		ino = devfs_nextino;
389		i = ino + 1;
390		/* wrap around when we reach the end */
391		if (i >= NDEVFSINO + devfs_noverflow)
392			i = 3;
393		if (!atomic_cmpset_int(&devfs_nextino, ino, i))
394			continue;
395
396		/* see if it was occupied */
397		dp = devfs_itod(ino);
398		if (dp == NULL)
399			Debugger("dp == NULL\n");
400		if (*dp != NULL)
401			continue;
402		ip = devfs_itor(ino);
403		if (ip == NULL)
404			Debugger("ip == NULL\n");
405		if (*ip != 0)
406			continue;
407
408		if (!atomic_cmpset_ptr(dp, NULL, dev))
409			continue;
410
411		dev->si_inode = ino;
412		for (;;) {
413			i = devfs_topino;
414			if (i >= ino)
415				break;
416			if (atomic_cmpset_int(&devfs_topino, i, ino))
417				break;
418			printf("failed topino %d %d\n", i, ino);
419		}
420		break;
421	}
422
423	atomic_add_int(&devfs_numino, 1);
424	atomic_add_int(&devfs_generation, 1);
425	if (devfs_overflow == NULL && devfs_numino + 100 > NDEVFSINO)
426		devfs_attemptoverflow(0);
427}
428
429static void
430devfs_destroy(dev_t dev)
431{
432	int ino, i;
433
434	ino = dev->si_inode;
435	dev->si_inode = 0;
436	if (ino == 0)
437		return;
438	if (atomic_cmpset_ptr(devfs_itod(ino), dev, NULL)) {
439		atomic_add_int(&devfs_generation, 1);
440		atomic_add_int(&devfs_numino, -1);
441		i = devfs_nextino;
442		if (ino < i)
443			atomic_cmpset_int(&devfs_nextino, i, ino);
444	}
445}
446
447static void
448devfs_init(void *junk)
449{
450	devfs_create_hook = devfs_create;
451	devfs_destroy_hook = devfs_destroy;
452	devfs_rules_init();
453}
454
455SYSINIT(devfs, SI_SUB_DEVFS, SI_ORDER_FIRST, devfs_init, NULL);
456
457