1 /*
2 * Copyright (c) 2000-2014 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 /*
30 * Copyright 1997,1998 Julian Elischer. All rights reserved.
31 * [email protected]
32 *
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions are
35 * met:
36 * 1. Redistributions of source code must retain the above copyright
37 * notice, this list of conditions and the following disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright notice,
39 * this list of conditions and the following disclaimer in the documentation
40 * and/or other materials provided with the distribution.
41 *
42 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS
43 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
44 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
45 * DISCLAIMED. IN NO EVENT SHALL THE HOLDER OR CONTRIBUTORS BE LIABLE FOR
46 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * SUCH DAMAGE.
53 *
54 * devfs_tree.c
55 */
56 /*
57 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
58 * support for mandatory and extensible security protections. This notice
59 * is included in support of clause 2.2 (b) of the Apple Public License,
60 * Version 2.0.
61 */
62
63 /*
64 * HISTORY
65 * Dieter Siegmund ([email protected]) Thu Apr 8 14:08:19 PDT 1999
66 * - removed mounting of "hidden" mountpoint
67 * - fixed problem in which devnode->dn_vn pointer was not
68 * updated with the vnode returned from checkalias()
69 * - replaced devfs_vntodn() with a macro VTODN()
70 * - rewrote dev_finddir() to not use recursion
71 * - added locking to avoid data structure corruption (DEVFS_(UN)LOCK())
72 * Dieter Siegmund ([email protected]) Wed Jul 14 13:37:59 PDT 1999
73 * - fixed problem with devfs_dntovn() checking the v_id against the
74 * value cached in the device node; a union mount on top of us causes
75 * the v_id to get incremented thus, we would end up returning a new
76 * vnode instead of the existing one that has the mounted_here
77 * field filled in; the net effect was that the filesystem mounted
78 * on top of us would never show up
79 * - added devfs_stats to store how many data structures are actually
80 * allocated
81 */
82
83 /* SPLIT_DEVS means each devfs uses a different devnode for the same device */
84 /* Otherwise the same device always ends up at the same vnode even if */
85 /* reached througgh a different devfs instance. The practical difference */
86 /* is that with the same vnode, chmods and chowns show up on all instances of */
87 /* a device. (etc) */
88
89 #define SPLIT_DEVS 1 /* maybe make this an option */
90 /*#define SPLIT_DEVS 1*/
91
92 #include <sys/param.h>
93 #include <sys/systm.h>
94 #include <sys/kernel.h>
95 #include <sys/conf.h>
96 #include <sys/malloc.h>
97 #include <sys/mount_internal.h>
98 #include <sys/proc.h>
99 #include <sys/vnode_internal.h>
100 #include <stdarg.h>
101 #include <libkern/OSAtomic.h>
102 #include <os/refcnt.h>
103 #define BSD_KERNEL_PRIVATE 1 /* devfs_make_link() prototype */
104 #include "devfs.h"
105 #include "devfsdefs.h"
106
107 #if CONFIG_MACF
108 #include <security/mac_framework.h>
109 #endif
110
111 #if FDESC
112 #include "fdesc.h"
113 #endif
114
115 typedef struct devfs_vnode_event {
116 vnode_t dve_vp;
117 uint32_t dve_vid;
118 uint32_t dve_events;
119 } *devfs_vnode_event_t;
120
121 /*
122 * Size of stack buffer (fast path) for notifications. If
123 * the number of mounts is small, no need to malloc a buffer.
124 */
125 #define NUM_STACK_ENTRIES 5
126
127 typedef struct devfs_event_log {
128 size_t del_max;
129 size_t del_used;
130 devfs_vnode_event_t del_entries;
131 } *devfs_event_log_t;
132
133
134 static void dev_free_hier(devdirent_t *);
135 static int devfs_propogate(devdirent_t *, devdirent_t *, devfs_event_log_t);
136 static int dev_finddir(const char *, devnode_t *, int, devnode_t **, devfs_event_log_t);
137 static int dev_dup_entry(devnode_t *, devdirent_t *, devdirent_t **, struct devfsmount *);
138 void devfs_ref_node(devnode_t *);
139 void devfs_rele_node(devnode_t *);
140 static void devfs_record_event(devfs_event_log_t, devnode_t*, uint32_t);
141 static int devfs_init_event_log(devfs_event_log_t, uint32_t, devfs_vnode_event_t);
142 static void devfs_release_event_log(devfs_event_log_t, int);
143 static void devfs_bulk_notify(devfs_event_log_t);
144 static devdirent_t *devfs_make_node_internal(dev_t, devfstype_t type, uid_t, gid_t, int,
145 int (*clone)(dev_t dev, int action), const char *fmt, va_list ap);
146
147
148 static LCK_GRP_DECLARE(devfs_lck_grp, "devfs_lock");
149 LCK_MTX_DECLARE(devfs_mutex, &devfs_lck_grp);
150 LCK_MTX_DECLARE(devfs_attr_mutex, &devfs_lck_grp);
151
152 os_refgrp_decl(static, devfs_refgrp, "devfs", NULL);
153
154 devdirent_t * dev_root = NULL; /* root of backing tree */
155 struct devfs_stats devfs_stats; /* hold stats */
156
157 static ino_t devfs_unique_fileno = 0;
158
159 #ifdef HIDDEN_MOUNTPOINT
160 static struct mount *devfs_hidden_mount;
161 #endif /* HIDDEN_MOINTPOINT */
162
163 static int devfs_ready = 0;
164 static uint32_t devfs_nmountplanes = 0; /* The first plane is not used for a mount */
165
166 #define DEVFS_NOCREATE FALSE
167 #define DEVFS_CREATE TRUE
168
169 /*
170 * Set up the root directory node in the backing plane
171 * This is happenning before the vfs system has been
172 * set up yet, so be careful about what we reference..
173 * Notice that the ops are by indirection.. as they haven't
174 * been set up yet!
175 * DEVFS has a hidden mountpoint that is used as the anchor point
176 * for the internal 'blueprint' version of the dev filesystem tree.
177 */
178 /*proto*/
179 int
devfs_sinit(void)180 devfs_sinit(void)
181 {
182 int error;
183
184 DEVFS_LOCK();
185 error = dev_add_entry("root", NULL, DEV_DIR, NULL, NULL, NULL, &dev_root);
186 DEVFS_UNLOCK();
187
188 if (error) {
189 printf("devfs_sinit: dev_add_entry failed ");
190 return ENOTSUP;
191 }
192 #ifdef HIDDEN_MOUNTPOINT
193 devfs_hidden_mount = zalloc_flags(mount_zone, Z_WAITOK | Z_ZERO);
194 mount_lock_init(devfs_hidden_mount);
195 TAILQ_INIT(&devfs_hidden_mount->mnt_vnodelist);
196 TAILQ_INIT(&devfs_hidden_mount->mnt_workerqueue);
197 TAILQ_INIT(&devfs_hidden_mount->mnt_newvnodes);
198 #if CONFIG_MACF
199 mac_mount_label_init(devfs_hidden_mount);
200 mac_mount_label_associate(vfs_context_kernel(), devfs_hidden_mount);
201 #endif
202
203 /* Initialize the default IO constraints */
204 mp->mnt_maxreadcnt = mp->mnt_maxwritecnt = MAXPHYS;
205 mp->mnt_segreadcnt = mp->mnt_segwritecnt = 32;
206 mp->mnt_ioflags = 0;
207 mp->mnt_realrootvp = NULLVP;
208 mp->mnt_authcache_ttl = CACHED_LOOKUP_RIGHT_TTL;
209
210 devfs_mount(devfs_hidden_mount, "dummy", NULL, NULL, NULL);
211 dev_root->de_dnp->dn_dvm
212 = (struct devfsmount *)devfs_hidden_mount->mnt_data;
213 #endif /* HIDDEN_MOUNTPOINT */
214 #if CONFIG_MACF
215 mac_devfs_label_associate_directory("/", (int) strlen("/"),
216 dev_root->de_dnp, "/");
217 #endif
218 devfs_ready = 1;
219 return 0;
220 }
221
222 /***********************************************************************\
223 *************************************************************************
224 * Routines used to find our way to a point in the tree *
225 *************************************************************************
226 \***********************************************************************/
227
228
229
230 /***************************************************************
231 * Search down the linked list off a dir to find "name"
232 * return the devnode_t * for that node.
233 *
234 * called with DEVFS_LOCK held
235 ***************************************************************/
236 devdirent_t *
dev_findname(devnode_t * dir,const char * name)237 dev_findname(devnode_t * dir, const char *name)
238 {
239 devdirent_t * newfp;
240 if (dir->dn_type != DEV_DIR) {
241 return 0; /*XXX*/ /* printf?*/
242 }
243 if (name[0] == '.') {
244 if (name[1] == 0) {
245 return dir->dn_typeinfo.Dir.myname;
246 }
247 if ((name[1] == '.') && (name[2] == 0)) {
248 /* for root, .. == . */
249 return dir->dn_typeinfo.Dir.parent->dn_typeinfo.Dir.myname;
250 }
251 }
252 newfp = dir->dn_typeinfo.Dir.dirlist;
253
254 while (newfp) {
255 if (!(strncmp(name, newfp->de_name, sizeof(newfp->de_name)))) {
256 return newfp;
257 }
258 newfp = newfp->de_next;
259 }
260 return NULL;
261 }
262
263 /***********************************************************************
264 * Given a starting node (0 for root) and a pathname, return the node
265 * for the end item on the path. It MUST BE A DIRECTORY. If the 'DEVFS_CREATE'
266 * option is true, then create any missing nodes in the path and create
267 * and return the final node as well.
268 * This is used to set up a directory, before making nodes in it..
269 *
270 * called with DEVFS_LOCK held
271 ***********************************************************************/
272 static int
dev_finddir(const char * path,devnode_t * dirnode,int create,devnode_t ** dn_pp,devfs_event_log_t delp)273 dev_finddir(const char * path,
274 devnode_t * dirnode,
275 int create,
276 devnode_t * * dn_pp,
277 devfs_event_log_t delp)
278 {
279 devnode_t * dnp = NULL;
280 int error = 0;
281 const char * scan;
282 #if CONFIG_MACF
283 char fullpath[DEVMAXPATHSIZE];
284 #endif
285
286
287 if (!dirnode) { /* dirnode == NULL means start at root */
288 dirnode = dev_root->de_dnp;
289 }
290
291 if (dirnode->dn_type != DEV_DIR) {
292 return ENOTDIR;
293 }
294
295 if (strlen(path) > (DEVMAXPATHSIZE - 1)) {
296 return ENAMETOOLONG;
297 }
298
299 #if CONFIG_MACF
300 strlcpy(fullpath, path, DEVMAXPATHSIZE);
301 #endif
302 scan = path;
303
304 while (*scan == '/') {
305 scan++;
306 }
307
308 *dn_pp = NULL;
309
310 while (1) {
311 char component[DEVMAXPATHSIZE];
312 devdirent_t * dirent_p;
313 const char * start;
314
315 if (*scan == 0) {
316 /* we hit the end of the string, we're done */
317 *dn_pp = dirnode;
318 break;
319 }
320 start = scan;
321 while (*scan != '/' && *scan) {
322 scan++;
323 }
324
325 strlcpy(component, start, (scan - start) + 1);
326 if (*scan == '/') {
327 scan++;
328 }
329
330 dirent_p = dev_findname(dirnode, component);
331 if (dirent_p) {
332 dnp = dirent_p->de_dnp;
333 if (dnp->dn_type != DEV_DIR) {
334 error = ENOTDIR;
335 break;
336 }
337 } else {
338 if (!create) {
339 error = ENOENT;
340 break;
341 }
342 error = dev_add_entry(component, dirnode,
343 DEV_DIR, NULL, NULL, NULL, &dirent_p);
344 if (error) {
345 break;
346 }
347 dnp = dirent_p->de_dnp;
348 #if CONFIG_MACF
349 mac_devfs_label_associate_directory(
350 dirnode->dn_typeinfo.Dir.myname->de_name,
351 (int) strlen(dirnode->dn_typeinfo.Dir.myname->de_name),
352 dnp, fullpath);
353 #endif
354 devfs_propogate(dirnode->dn_typeinfo.Dir.myname, dirent_p, delp);
355 }
356 dirnode = dnp; /* continue relative to this directory */
357 }
358 return error;
359 }
360
361
362 /***********************************************************************
363 * Add a new NAME element to the devfs
364 * If we're creating a root node, then dirname is NULL
365 * Basically this creates a new namespace entry for the device node
366 *
367 * Creates a name node, and links it to the supplied node
368 *
369 * called with DEVFS_LOCK held
370 ***********************************************************************/
371 int
dev_add_name(const char * name,devnode_t * dirnode,__unused devdirent_t * back,devnode_t * dnp,devdirent_t ** dirent_pp)372 dev_add_name(const char * name, devnode_t * dirnode, __unused devdirent_t * back,
373 devnode_t * dnp, devdirent_t * *dirent_pp)
374 {
375 devdirent_t * dirent_p = NULL;
376
377 if (dirnode != NULL) {
378 if (dirnode->dn_type != DEV_DIR) {
379 return ENOTDIR;
380 }
381
382 if (dev_findname(dirnode, name)) {
383 return EEXIST;
384 }
385 }
386 /*
387 * make sure the name is legal
388 * slightly misleading in the case of NULL
389 */
390 if (!name || (strlen(name) > (DEVMAXNAMESIZE - 1))) {
391 return ENAMETOOLONG;
392 }
393
394 /*
395 * Allocate and fill out a new directory entry
396 */
397 dirent_p = kalloc_type(devdirent_t, Z_WAITOK | Z_ZERO | Z_NOFAIL);
398
399 /* inherrit our parent's mount info */ /*XXX*/
400 /* a kludge but.... */
401 if (dirnode && (dnp->dn_dvm == NULL)) {
402 dnp->dn_dvm = dirnode->dn_dvm;
403 /* if(!dnp->dn_dvm) printf("parent had null dvm "); */
404 }
405
406 /*
407 * Link the two together
408 * include the implicit link in the count of links to the devnode..
409 * this stops it from being accidentally freed later.
410 */
411 dirent_p->de_dnp = dnp;
412 dnp->dn_links++; /* implicit from our own name-node */
413
414 /*
415 * Make sure that we can find all the links that reference a node
416 * so that we can get them all if we need to zap the node.
417 */
418 if (dnp->dn_linklist) {
419 dirent_p->de_nextlink = dnp->dn_linklist;
420 dirent_p->de_prevlinkp = dirent_p->de_nextlink->de_prevlinkp;
421 dirent_p->de_nextlink->de_prevlinkp = &(dirent_p->de_nextlink);
422 *dirent_p->de_prevlinkp = dirent_p;
423 } else {
424 dirent_p->de_nextlink = dirent_p;
425 dirent_p->de_prevlinkp = &(dirent_p->de_nextlink);
426 }
427 dnp->dn_linklist = dirent_p;
428
429 /*
430 * If the node is a directory, then we need to handle the
431 * creation of the .. link.
432 * A NULL dirnode indicates a root node, so point to ourself.
433 */
434 if (dnp->dn_type == DEV_DIR) {
435 dnp->dn_typeinfo.Dir.myname = dirent_p;
436 /*
437 * If we are unlinking from an old dir, decrement its links
438 * as we point our '..' elsewhere
439 * Note: it's up to the calling code to remove the
440 * us from the original directory's list
441 */
442 if (dnp->dn_typeinfo.Dir.parent) {
443 dnp->dn_typeinfo.Dir.parent->dn_links--;
444 }
445 if (dirnode) {
446 dnp->dn_typeinfo.Dir.parent = dirnode;
447 } else {
448 dnp->dn_typeinfo.Dir.parent = dnp;
449 }
450 dnp->dn_typeinfo.Dir.parent->dn_links++; /* account for the new '..' */
451 }
452
453 /*
454 * put the name into the directory entry.
455 */
456 strlcpy(dirent_p->de_name, name, DEVMAXNAMESIZE);
457
458
459 /*
460 * Check if we are not making a root node..
461 * (i.e. have parent)
462 */
463 if (dirnode) {
464 /*
465 * Put it on the END of the linked list of directory entries
466 */
467 dirent_p->de_parent = dirnode; /* null for root */
468 dirent_p->de_prevp = dirnode->dn_typeinfo.Dir.dirlast;
469 dirent_p->de_next = *(dirent_p->de_prevp); /* should be NULL */
470 /*right?*/
471 *(dirent_p->de_prevp) = dirent_p;
472 dirnode->dn_typeinfo.Dir.dirlast = &(dirent_p->de_next);
473 dirnode->dn_typeinfo.Dir.entrycount++;
474 dirnode->dn_len += strlen(name) + 8;/*ok, ok?*/
475 }
476
477 *dirent_pp = dirent_p;
478 DEVFS_INCR_ENTRIES();
479 return 0;
480 }
481
482
483 /***********************************************************************
484 * Add a new element to the devfs plane.
485 *
486 * Creates a new dev_node to go with it if the prototype should not be
487 * reused. (Is a DIR, or we select SPLIT_DEVS at compile time)
488 * typeinfo gives us info to make our node if we don't have a prototype.
489 * If typeinfo is null and proto exists, then the typeinfo field of
490 * the proto is used intead in the DEVFS_CREATE case.
491 * note the 'links' count is 0 (except if a dir)
492 * but it is only cleared on a transition
493 * so this is ok till we link it to something
494 * Even in SPLIT_DEVS mode,
495 * if the node already exists on the wanted plane, just return it
496 *
497 * called with DEVFS_LOCK held
498 ***********************************************************************/
499 int
dev_add_node(int entrytype,devnode_type_t * typeinfo,devnode_t * proto,devnode_t ** dn_pp,struct devfsmount * dvm)500 dev_add_node(int entrytype, devnode_type_t * typeinfo, devnode_t * proto,
501 devnode_t * *dn_pp, struct devfsmount *dvm)
502 {
503 devnode_t * dnp = NULL;
504 int error = 0;
505
506 #if defined SPLIT_DEVS
507 /*
508 * If we have a prototype, then check if there is already a sibling
509 * on the mount plane we are looking at, if so, just return it.
510 */
511 if (proto) {
512 dnp = proto->dn_nextsibling;
513 while (dnp != proto) {
514 if (dnp->dn_dvm == dvm) {
515 *dn_pp = dnp;
516 return 0;
517 }
518 dnp = dnp->dn_nextsibling;
519 }
520 if (typeinfo == NULL) {
521 typeinfo = &(proto->dn_typeinfo);
522 }
523 }
524 #else /* SPLIT_DEVS */
525 if (proto) {
526 switch (proto->type) {
527 case DEV_BDEV:
528 case DEV_CDEV:
529 *dn_pp = proto;
530 return 0;
531 }
532 }
533 #endif /* SPLIT_DEVS */
534 MALLOC(dnp, devnode_t *, sizeof(devnode_t), M_DEVFSNODE, M_WAITOK);
535 if (!dnp) {
536 return ENOMEM;
537 }
538
539 /*
540 * If we have a proto, that means that we are duplicating some
541 * other device, which can only happen if we are not at the back plane
542 */
543 if (proto) {
544 bcopy(proto, dnp, sizeof(devnode_t));
545 dnp->dn_links = 0;
546 dnp->dn_linklist = NULL;
547 dnp->dn_vn = NULL;
548 dnp->dn_len = 0;
549 /* add to END of siblings list */
550 dnp->dn_prevsiblingp = proto->dn_prevsiblingp;
551 *(dnp->dn_prevsiblingp) = dnp;
552 dnp->dn_nextsibling = proto;
553 proto->dn_prevsiblingp = &(dnp->dn_nextsibling);
554 #if CONFIG_MACF
555 mac_devfs_label_init(dnp);
556 mac_devfs_label_copy(mac_devfs_label(proto), mac_devfs_label(dnp));
557 #endif
558 } else {
559 struct timeval tv;
560
561 /*
562 * We have no prototype, so start off with a clean slate
563 */
564 microtime(&tv);
565 bzero(dnp, sizeof(devnode_t));
566 dnp->dn_type = entrytype;
567 dnp->dn_nextsibling = dnp;
568 dnp->dn_prevsiblingp = &(dnp->dn_nextsibling);
569 dnp->dn_atime.tv_sec = tv.tv_sec;
570 dnp->dn_mtime.tv_sec = tv.tv_sec;
571 dnp->dn_ctime.tv_sec = tv.tv_sec;
572 #if CONFIG_MACF
573 mac_devfs_label_init(dnp);
574 #endif
575 }
576 dnp->dn_dvm = dvm;
577
578 /* Note: this inits the reference count to 1, this is considered unreferenced */
579 os_ref_init_raw(&dnp->dn_refcount, &devfs_refgrp);
580 dnp->dn_ino = devfs_unique_fileno;
581 devfs_unique_fileno++;
582
583 /*
584 * fill out the dev node according to type
585 */
586 switch (entrytype) {
587 case DEV_DIR:
588 /*
589 * As it's a directory, make sure
590 * it has a null entries list
591 */
592 dnp->dn_typeinfo.Dir.dirlast = &(dnp->dn_typeinfo.Dir.dirlist);
593 dnp->dn_typeinfo.Dir.dirlist = (devdirent_t *)0;
594 dnp->dn_typeinfo.Dir.entrycount = 0;
595 /* until we know better, it has a null parent pointer*/
596 dnp->dn_typeinfo.Dir.parent = NULL;
597 dnp->dn_links++; /* for .*/
598 dnp->dn_typeinfo.Dir.myname = NULL;
599 /*
600 * make sure that the ops associated with it are the ops
601 * that we use (by default) for directories
602 */
603 dnp->dn_ops = &devfs_vnodeop_p;
604 dnp->dn_mode |= 0555; /* default perms */
605 break;
606 case DEV_SLNK:
607 /*
608 * As it's a symlink allocate and store the link info
609 * Symlinks should only ever be created by the user,
610 * so they are not on the back plane and should not be
611 * propogated forward.. a bit like directories in that way..
612 * A symlink only exists on one plane and has its own
613 * node.. therefore we might be on any random plane.
614 */
615 dnp->dn_typeinfo.Slnk.name = kalloc_data(typeinfo->Slnk.namelen + 1, Z_WAITOK);
616 if (!dnp->dn_typeinfo.Slnk.name) {
617 error = ENOMEM;
618 break;
619 }
620 strlcpy(dnp->dn_typeinfo.Slnk.name, typeinfo->Slnk.name,
621 typeinfo->Slnk.namelen + 1);
622 dnp->dn_typeinfo.Slnk.namelen = typeinfo->Slnk.namelen;
623 DEVFS_INCR_STRINGSPACE(dnp->dn_typeinfo.Slnk.namelen + 1);
624 dnp->dn_ops = &devfs_vnodeop_p;
625 dnp->dn_mode |= 0555; /* default perms */
626 break;
627 case DEV_CDEV:
628 case DEV_BDEV:
629 /*
630 * Make sure it has DEVICE type ops
631 * and device specific fields are correct
632 */
633 dnp->dn_ops = &devfs_spec_vnodeop_p;
634 dnp->dn_typeinfo.dev = typeinfo->dev;
635 break;
636
637 #if FDESC
638 /* /dev/fd is special */
639 case DEV_DEVFD:
640 dnp->dn_ops = &devfs_devfd_vnodeop_p;
641 dnp->dn_mode |= 0555; /* default perms */
642 break;
643
644 #endif /* FDESC */
645 default:
646 error = EINVAL;
647 }
648
649 if (error) {
650 FREE(dnp, M_DEVFSNODE);
651 } else {
652 *dn_pp = dnp;
653 DEVFS_INCR_NODES();
654 }
655
656 return error;
657 }
658
659
660 /***********************************************************************
661 * called with DEVFS_LOCK held
662 **********************************************************************/
663 void
devnode_free(devnode_t * dnp)664 devnode_free(devnode_t * dnp)
665 {
666 #if CONFIG_MACF
667 mac_devfs_label_destroy(dnp);
668 #endif
669 if (dnp->dn_type == DEV_SLNK) {
670 DEVFS_DECR_STRINGSPACE(dnp->dn_typeinfo.Slnk.namelen + 1);
671 kfree_data(dnp->dn_typeinfo.Slnk.name, dnp->dn_typeinfo.Slnk.namelen + 1);
672 }
673 DEVFS_DECR_NODES();
674 FREE(dnp, M_DEVFSNODE);
675 }
676
677
678 /***********************************************************************
679 * called with DEVFS_LOCK held
680 **********************************************************************/
681 static void
devfs_dn_free(devnode_t * dnp)682 devfs_dn_free(devnode_t * dnp)
683 {
684 if (--dnp->dn_links <= 0) { /* can be -1 for initial free, on error */
685 /*probably need to do other cleanups XXX */
686 if (dnp->dn_nextsibling != dnp) {
687 devnode_t * * prevp = dnp->dn_prevsiblingp;
688 *prevp = dnp->dn_nextsibling;
689 dnp->dn_nextsibling->dn_prevsiblingp = prevp;
690 }
691
692 /* Can only free if there are no references; otherwise, wait for last vnode to be reclaimed */
693 os_ref_count_t rc = os_ref_get_count_raw(&dnp->dn_refcount);
694 if (rc == 1) {
695 /* release final reference from dev_add_node */
696 (void) os_ref_release_locked_raw(&dnp->dn_refcount, &devfs_refgrp);
697 devnode_free(dnp);
698 } else {
699 dnp->dn_lflags |= DN_DELETE;
700 }
701 }
702 }
703
704 /***********************************************************************\
705 * Front Node Operations *
706 * Add or delete a chain of front nodes *
707 \***********************************************************************/
708
709
710 /***********************************************************************
711 * Given a directory backing node, and a child backing node, add the
712 * appropriate front nodes to the front nodes of the directory to
713 * represent the child node to the user
714 *
715 * on failure, front nodes will either be correct or not exist for each
716 * front dir, however dirs completed will not be stripped of completed
717 * frontnodes on failure of a later frontnode
718 *
719 * This allows a new node to be propogated through all mounted planes
720 *
721 * called with DEVFS_LOCK held
722 ***********************************************************************/
723 static int
devfs_propogate(devdirent_t * parent,devdirent_t * child,devfs_event_log_t delp)724 devfs_propogate(devdirent_t * parent, devdirent_t * child, devfs_event_log_t delp)
725 {
726 int error;
727 devdirent_t * newnmp;
728 devnode_t * dnp = child->de_dnp;
729 devnode_t * pdnp = parent->de_dnp;
730 devnode_t * adnp = parent->de_dnp;
731 int type = child->de_dnp->dn_type;
732 uint32_t events;
733
734 events = (dnp->dn_type == DEV_DIR ? VNODE_EVENT_DIR_CREATED : VNODE_EVENT_FILE_CREATED);
735 if (delp != NULL) {
736 devfs_record_event(delp, pdnp, events);
737 }
738
739 /***********************************************
740 * Find the other instances of the parent node
741 ***********************************************/
742 for (adnp = pdnp->dn_nextsibling;
743 adnp != pdnp;
744 adnp = adnp->dn_nextsibling) {
745 /*
746 * Make the node, using the original as a prototype)
747 * if the node already exists on that plane it won't be
748 * re-made..
749 */
750 if ((error = dev_add_entry(child->de_name, adnp, type,
751 NULL, dnp, adnp->dn_dvm,
752 &newnmp)) != 0) {
753 printf("duplicating %s failed\n", child->de_name);
754 } else {
755 if (delp != NULL) {
756 devfs_record_event(delp, adnp, events);
757
758 /*
759 * Slightly subtle. We're guaranteed that there will
760 * only be a vnode hooked into this devnode if we're creating
761 * a new link to an existing node; otherwise, the devnode is new
762 * and no one can have looked it up yet. If we're making a link,
763 * then the buffer is large enough for two nodes in each
764 * plane; otherwise, there's no vnode and this call will
765 * do nothing.
766 */
767 devfs_record_event(delp, newnmp->de_dnp, VNODE_EVENT_LINK);
768 }
769 }
770 }
771 return 0; /* for now always succeed */
772 }
773
774 static uint32_t
remove_notify_count(devnode_t * dnp)775 remove_notify_count(devnode_t *dnp)
776 {
777 uint32_t notify_count = 0;
778 devnode_t *dnp2;
779
780 /*
781 * Could need to notify for one removed node on each mount and
782 * one parent for each such node.
783 */
784 notify_count = devfs_nmountplanes;
785 notify_count += dnp->dn_links;
786 for (dnp2 = dnp->dn_nextsibling; dnp2 != dnp; dnp2 = dnp2->dn_nextsibling) {
787 notify_count += dnp2->dn_links;
788 }
789
790 return notify_count;
791 }
792
793 /***********************************************************************
794 * remove all instances of this devicename [for backing nodes..]
795 * note.. if there is another link to the node (non dir nodes only)
796 * then the devfs_node will still exist as the ref count will be non-0
797 * removing a directory node will remove all sup-nodes on all planes (ZAP)
798 *
799 * Used by device drivers to remove nodes that are no longer relevant
800 * The argument is the 'cookie' they were given when they created the node
801 * this function is exported.. see devfs.h
802 ***********************************************************************/
803 void
devfs_remove(void * dirent_p)804 devfs_remove(void *dirent_p)
805 {
806 devnode_t * dnp = ((devdirent_t *)dirent_p)->de_dnp;
807 devnode_t * dnp2;
808 boolean_t lastlink;
809 struct devfs_event_log event_log;
810 uint32_t log_count = 0;
811 int do_notify = 0;
812 int need_free = 0;
813 struct devfs_vnode_event stackbuf[NUM_STACK_ENTRIES];
814
815 DEVFS_LOCK();
816
817 if (!devfs_ready) {
818 printf("devfs_remove: not ready for devices!\n");
819 goto out;
820 }
821
822 log_count = remove_notify_count(dnp);
823
824 if (log_count > NUM_STACK_ENTRIES) {
825 uint32_t new_count;
826 wrongsize:
827 DEVFS_UNLOCK();
828 if (devfs_init_event_log(&event_log, log_count, NULL) == 0) {
829 do_notify = 1;
830 need_free = 1;
831 }
832 DEVFS_LOCK();
833
834 new_count = remove_notify_count(dnp);
835 if (need_free && (new_count > log_count)) {
836 devfs_release_event_log(&event_log, 1);
837 need_free = 0;
838 do_notify = 0;
839 log_count = log_count * 2;
840 goto wrongsize;
841 }
842 } else {
843 if (devfs_init_event_log(&event_log, NUM_STACK_ENTRIES, &stackbuf[0]) == 0) {
844 do_notify = 1;
845 }
846 }
847
848 /* This file has been deleted */
849 if (do_notify != 0) {
850 devfs_record_event(&event_log, dnp, VNODE_EVENT_DELETE);
851 }
852
853 /* keep removing the next sibling till only we exist. */
854 while ((dnp2 = dnp->dn_nextsibling) != dnp) {
855 /*
856 * Keep removing the next front node till no more exist
857 */
858 dnp->dn_nextsibling = dnp2->dn_nextsibling;
859 dnp->dn_nextsibling->dn_prevsiblingp = &(dnp->dn_nextsibling);
860 dnp2->dn_nextsibling = dnp2;
861 dnp2->dn_prevsiblingp = &(dnp2->dn_nextsibling);
862
863 /* This file has been deleted in this plane */
864 if (do_notify != 0) {
865 devfs_record_event(&event_log, dnp2, VNODE_EVENT_DELETE);
866 }
867
868 if (dnp2->dn_linklist) {
869 do {
870 lastlink = (1 == dnp2->dn_links);
871 /* Each parent of a link to this file has lost a child in this plane */
872 if (do_notify != 0) {
873 devfs_record_event(&event_log, dnp2->dn_linklist->de_parent, VNODE_EVENT_FILE_REMOVED);
874 }
875 dev_free_name(dnp2->dn_linklist);
876 } while (!lastlink);
877 }
878 }
879
880 /*
881 * then free the main node
882 * If we are not running in SPLIT_DEVS mode, then
883 * THIS is what gets rid of the propogated nodes.
884 */
885 if (dnp->dn_linklist) {
886 do {
887 lastlink = (1 == dnp->dn_links);
888 /* Each parent of a link to this file has lost a child */
889 if (do_notify != 0) {
890 devfs_record_event(&event_log, dnp->dn_linklist->de_parent, VNODE_EVENT_FILE_REMOVED);
891 }
892 dev_free_name(dnp->dn_linklist);
893 } while (!lastlink);
894 }
895 out:
896 DEVFS_UNLOCK();
897 if (do_notify != 0) {
898 devfs_bulk_notify(&event_log);
899 devfs_release_event_log(&event_log, need_free);
900 }
901
902 return;
903 }
904
905
906
907 /***************************************************************
908 * duplicate the backing tree into a tree of nodes hung off the
909 * mount point given as the argument. Do this by
910 * calling dev_dup_entry which recurses all the way
911 * up the tree..
912 *
913 * called with DEVFS_LOCK held
914 **************************************************************/
915 int
dev_dup_plane(struct devfsmount * devfs_mp_p)916 dev_dup_plane(struct devfsmount *devfs_mp_p)
917 {
918 devdirent_t * new;
919 int error = 0;
920
921 if ((error = dev_dup_entry(NULL, dev_root, &new, devfs_mp_p))) {
922 return error;
923 }
924 devfs_mp_p->plane_root = new;
925 devfs_nmountplanes++;
926 return error;
927 }
928
929
930
931 /***************************************************************
932 * Free a whole plane
933 *
934 * called with DEVFS_LOCK held
935 ***************************************************************/
936 void
devfs_free_plane(struct devfsmount * devfs_mp_p)937 devfs_free_plane(struct devfsmount *devfs_mp_p)
938 {
939 devdirent_t * dirent_p;
940
941 dirent_p = devfs_mp_p->plane_root;
942 if (dirent_p) {
943 dev_free_hier(dirent_p);
944 dev_free_name(dirent_p);
945 }
946 devfs_mp_p->plane_root = NULL;
947 devfs_nmountplanes--;
948
949 if (devfs_nmountplanes > (devfs_nmountplanes + 1)) {
950 panic("plane count wrapped around.");
951 }
952 }
953
954
955 /***************************************************************
956 * Create and link in a new front element..
957 * Parent can be 0 for a root node
958 * Not presently usable to make a symlink XXX
959 * (Ok, symlinks don't propogate)
960 * recursively will create subnodes corresponding to equivalent
961 * child nodes in the base level
962 *
963 * called with DEVFS_LOCK held
964 ***************************************************************/
965 static int
dev_dup_entry(devnode_t * parent,devdirent_t * back,devdirent_t ** dnm_pp,struct devfsmount * dvm)966 dev_dup_entry(devnode_t * parent, devdirent_t * back, devdirent_t * *dnm_pp,
967 struct devfsmount *dvm)
968 {
969 devdirent_t * entry_p = NULL;
970 devdirent_t * newback;
971 devdirent_t * newfront;
972 int error;
973 devnode_t * dnp = back->de_dnp;
974 int type = dnp->dn_type;
975
976 /*
977 * go get the node made (if we need to)
978 * use the back one as a prototype
979 */
980 error = dev_add_entry(back->de_name, parent, type, NULL, dnp,
981 parent?parent->dn_dvm:dvm, &entry_p);
982 if (!error && (entry_p == NULL)) {
983 error = ENOMEM; /* Really can't happen, but make static analyzer happy */
984 }
985 if (error != 0) {
986 printf("duplicating %s failed\n", back->de_name);
987 goto out;
988 }
989
990 /*
991 * If we have just made the root, then insert the pointer to the
992 * mount information
993 */
994 if (dvm) {
995 entry_p->de_dnp->dn_dvm = dvm;
996 }
997
998 /*
999 * If it is a directory, then recurse down all the other
1000 * subnodes in it....
1001 * note that this time we don't pass on the mount info..
1002 */
1003 if (type == DEV_DIR) {
1004 for (newback = back->de_dnp->dn_typeinfo.Dir.dirlist;
1005 newback; newback = newback->de_next) {
1006 if ((error = dev_dup_entry(entry_p->de_dnp,
1007 newback, &newfront, NULL)) != 0) {
1008 break; /* back out with an error */
1009 }
1010 }
1011 }
1012 out:
1013 *dnm_pp = entry_p;
1014 return error;
1015 }
1016
1017
1018 /***************************************************************
1019 * Free a name node
1020 * remember that if there are other names pointing to the
1021 * dev_node then it may not get freed yet
1022 * can handle if there is no dnp
1023 *
1024 * called with DEVFS_LOCK held
1025 ***************************************************************/
1026
1027 int
dev_free_name(devdirent_t * dirent_p)1028 dev_free_name(devdirent_t * dirent_p)
1029 {
1030 devnode_t * parent = dirent_p->de_parent;
1031 devnode_t * dnp = dirent_p->de_dnp;
1032
1033 if (dnp) {
1034 if (dnp->dn_type == DEV_DIR) {
1035 devnode_t * p;
1036
1037 if (dnp->dn_typeinfo.Dir.dirlist) {
1038 return ENOTEMPTY;
1039 }
1040 p = dnp->dn_typeinfo.Dir.parent;
1041 devfs_dn_free(dnp); /* account for '.' */
1042 devfs_dn_free(p); /* '..' */
1043 }
1044 /*
1045 * unlink us from the list of links for this node
1046 * If we are the only link, it's easy!
1047 * if we are a DIR of course there should not be any
1048 * other links.
1049 */
1050 if (dirent_p->de_nextlink == dirent_p) {
1051 dnp->dn_linklist = NULL;
1052 } else {
1053 if (dnp->dn_linklist == dirent_p) {
1054 dnp->dn_linklist = dirent_p->de_nextlink;
1055 }
1056 }
1057 devfs_dn_free(dnp);
1058 }
1059
1060 dirent_p->de_nextlink->de_prevlinkp = dirent_p->de_prevlinkp;
1061 *(dirent_p->de_prevlinkp) = dirent_p->de_nextlink;
1062
1063 /*
1064 * unlink ourselves from the directory on this plane
1065 */
1066 if (parent) { /* if not fs root */
1067 if ((*dirent_p->de_prevp = dirent_p->de_next)) {/* yes, assign */
1068 dirent_p->de_next->de_prevp = dirent_p->de_prevp;
1069 } else {
1070 parent->dn_typeinfo.Dir.dirlast
1071 = dirent_p->de_prevp;
1072 }
1073 parent->dn_typeinfo.Dir.entrycount--;
1074 parent->dn_len -= strlen(dirent_p->de_name) + 8;
1075 }
1076
1077 DEVFS_DECR_ENTRIES();
1078 kfree_type(devdirent_t, dirent_p);
1079 return 0;
1080 }
1081
1082
1083 /***************************************************************
1084 * Free a hierarchy starting at a directory node name
1085 * remember that if there are other names pointing to the
1086 * dev_node then it may not get freed yet
1087 * can handle if there is no dnp
1088 * leave the node itself allocated.
1089 *
1090 * called with DEVFS_LOCK held
1091 ***************************************************************/
1092
1093 static void
dev_free_hier(devdirent_t * dirent_p)1094 dev_free_hier(devdirent_t * dirent_p)
1095 {
1096 devnode_t * dnp = dirent_p->de_dnp;
1097
1098 if (dnp) {
1099 if (dnp->dn_type == DEV_DIR) {
1100 while (dnp->dn_typeinfo.Dir.dirlist) {
1101 dev_free_hier(dnp->dn_typeinfo.Dir.dirlist);
1102 dev_free_name(dnp->dn_typeinfo.Dir.dirlist);
1103 }
1104 }
1105 }
1106 }
1107
1108
1109 /***************************************************************
1110 * given a dev_node, find the appropriate vnode if one is already
1111 * associated, or get a new one and associate it with the dev_node
1112 *
1113 * called with DEVFS_LOCK held
1114 *
1115 * If an error is returned, then the dnp may have been freed (we
1116 * raced with a delete and lost). A devnode should not be accessed
1117 * after devfs_dntovn() fails.
1118 ****************************************************************/
1119 int
devfs_dntovn(devnode_t * dnp,struct vnode ** vn_pp,__unused struct proc * p)1120 devfs_dntovn(devnode_t * dnp, struct vnode **vn_pp, __unused struct proc * p)
1121 {
1122 struct vnode *vn_p;
1123 int error = 0;
1124 struct vnode_fsparam vfsp;
1125 enum vtype vtype = 0;
1126 int markroot = 0;
1127 int nretries = 0;
1128 int n_minor = DEVFS_CLONE_ALLOC; /* new minor number for clone device */
1129
1130 /*
1131 * We should never come in and find that our devnode has been marked for delete.
1132 * The lookup should have held the lock from entry until now; it should not have
1133 * been able to find a removed entry. Any other pathway would have just created
1134 * the devnode and come here without dropping the devfs lock, so no one would
1135 * have a chance to delete.
1136 */
1137 if (dnp->dn_lflags & DN_DELETE) {
1138 panic("devfs_dntovn: DN_DELETE set on a devnode upon entry.");
1139 }
1140
1141 devfs_ref_node(dnp);
1142
1143 retry:
1144 *vn_pp = NULL;
1145 vn_p = dnp->dn_vn;
1146
1147 if (vn_p) { /* already has a vnode */
1148 uint32_t vid;
1149
1150 vid = vnode_vid(vn_p);
1151
1152 DEVFS_UNLOCK();
1153
1154 /*
1155 * We want to use the drainok variant of vnode_getwithvid
1156 * because we _don't_ want to get an iocount if the vnode is
1157 * is blocked in vnode_drain as it can cause infinite
1158 * loops in vn_open_auth. While in use vnodes are typically
1159 * only reclaimed on forced unmounts, In use devfs tty vnodes
1160 * can be quite frequently reclaimed by revoke(2) or by the
1161 * exit of a controlling process.
1162 */
1163 error = vnode_getwithvid_drainok(vn_p, vid);
1164
1165 DEVFS_LOCK();
1166
1167 if (dnp->dn_lflags & DN_DELETE) {
1168 /*
1169 * our BUSY node got marked for
1170 * deletion while the DEVFS lock
1171 * was dropped...
1172 */
1173 if (error == 0) {
1174 /*
1175 * vnode_getwithvid returned a valid ref
1176 * which we need to drop
1177 */
1178 vnode_put(vn_p);
1179 }
1180
1181 /*
1182 * This entry is no longer in the namespace. This is only
1183 * possible for lookup: no other path would not find an existing
1184 * vnode. Therefore, ENOENT is a valid result.
1185 */
1186 error = ENOENT;
1187 } else if (error == ENODEV) {
1188 /*
1189 * The Filesystem is getting unmounted.
1190 */
1191 error = ENOENT;
1192 } else if (error && (nretries < DEV_MAX_VNODE_RETRY)) {
1193 /*
1194 * If we got an error from vnode_getwithvid, it means
1195 * we raced with a recycle and lost i.e. we asked for
1196 * an iocount only after vnode_drain had been entered
1197 * for the vnode and returned with an error only after
1198 * devfs_reclaim was called on the vnode. devfs_reclaim
1199 * sets dn_vn to NULL but while we were waiting to
1200 * reacquire DEVFS_LOCK, another vnode might have gotten
1201 * associated with the dnp. In either case, we need to
1202 * retry otherwise we will end up returning an ENOENT
1203 * for this lookup but the next lookup will succeed
1204 * because it creates a new vnode (or a racing lookup
1205 * created a new vnode already).
1206 */
1207 error = 0;
1208 nretries++;
1209 goto retry;
1210 }
1211 if (!error) {
1212 *vn_pp = vn_p;
1213 }
1214
1215 goto out;
1216 }
1217
1218 /*
1219 * If we get here, then we've beaten any deletes;
1220 * if someone sets DN_DELETE during a subsequent drop
1221 * of the devfs lock, we'll still vend a vnode.
1222 */
1223
1224 if (dnp->dn_lflags & DN_CREATE) {
1225 dnp->dn_lflags |= DN_CREATEWAIT;
1226 msleep(&dnp->dn_lflags, &devfs_mutex, PRIBIO, 0, 0);
1227 goto retry;
1228 }
1229
1230 dnp->dn_lflags |= DN_CREATE;
1231
1232 switch (dnp->dn_type) {
1233 case DEV_SLNK:
1234 vtype = VLNK;
1235 break;
1236 case DEV_DIR:
1237 if (dnp->dn_typeinfo.Dir.parent == dnp) {
1238 markroot = 1;
1239 }
1240 vtype = VDIR;
1241 break;
1242 case DEV_BDEV:
1243 case DEV_CDEV:
1244 vtype = (dnp->dn_type == DEV_BDEV) ? VBLK : VCHR;
1245 break;
1246 #if FDESC
1247 case DEV_DEVFD:
1248 vtype = VDIR;
1249 break;
1250 #endif /* FDESC */
1251 }
1252 vfsp.vnfs_mp = dnp->dn_dvm->mount;
1253 vfsp.vnfs_vtype = vtype;
1254 vfsp.vnfs_str = "devfs";
1255 vfsp.vnfs_dvp = 0;
1256 vfsp.vnfs_fsnode = dnp;
1257 vfsp.vnfs_cnp = 0;
1258 vfsp.vnfs_vops = *(dnp->dn_ops);
1259
1260 if (vtype == VBLK || vtype == VCHR) {
1261 /*
1262 * Ask the clone minor number function for a new minor number
1263 * to use for the next device instance. If an administative
1264 * limit has been reached, this function will return -1.
1265 */
1266 if (dnp->dn_clone != NULL) {
1267 int n_major = major(dnp->dn_typeinfo.dev);
1268
1269 n_minor = (*dnp->dn_clone)(dnp->dn_typeinfo.dev, DEVFS_CLONE_ALLOC);
1270 if (n_minor == -1) {
1271 error = ENOMEM;
1272 goto out;
1273 }
1274
1275 vfsp.vnfs_rdev = makedev(n_major, n_minor);
1276 } else {
1277 vfsp.vnfs_rdev = dnp->dn_typeinfo.dev;
1278 }
1279 } else {
1280 vfsp.vnfs_rdev = 0;
1281 }
1282 vfsp.vnfs_filesize = 0;
1283 vfsp.vnfs_flags = VNFS_NOCACHE | VNFS_CANTCACHE;
1284 /* Tag system files */
1285 vfsp.vnfs_marksystem = 0;
1286 vfsp.vnfs_markroot = markroot;
1287
1288 DEVFS_UNLOCK();
1289
1290 error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &vn_p);
1291
1292 /* Do this before grabbing the lock */
1293 if (error == 0) {
1294 vnode_setneedinactive(vn_p);
1295 }
1296
1297 DEVFS_LOCK();
1298
1299 if (error == 0) {
1300 vnode_settag(vn_p, VT_DEVFS);
1301
1302 if ((dnp->dn_clone != NULL) && (dnp->dn_vn != NULLVP)) {
1303 panic("devfs_dntovn: cloning device with a vnode?");
1304 }
1305
1306 *vn_pp = vn_p;
1307
1308 /*
1309 * Another vnode that has this devnode as its v_data.
1310 * This reference, unlike the one taken at the start
1311 * of the function, persists until a VNOP_RECLAIM
1312 * comes through for this vnode.
1313 */
1314 devfs_ref_node(dnp);
1315
1316 /*
1317 * A cloned vnode is not hooked into the devnode; every lookup
1318 * gets a new vnode.
1319 */
1320 if (dnp->dn_clone == NULL) {
1321 dnp->dn_vn = vn_p;
1322 }
1323 } else if (n_minor != DEVFS_CLONE_ALLOC) {
1324 /*
1325 * If we failed the create, we need to release the cloned minor
1326 * back to the free list. In general, this is only useful if
1327 * the clone function results in a state change in the cloned
1328 * device for which the minor number was obtained. If we get
1329 * past this point withouth falling into this case, it's
1330 * assumed that any state to be released will be released when
1331 * the vnode is dropped, instead.
1332 */
1333 (void)(*dnp->dn_clone)(dnp->dn_typeinfo.dev, DEVFS_CLONE_FREE);
1334 }
1335
1336 dnp->dn_lflags &= ~DN_CREATE;
1337 if (dnp->dn_lflags & DN_CREATEWAIT) {
1338 dnp->dn_lflags &= ~DN_CREATEWAIT;
1339 wakeup(&dnp->dn_lflags);
1340 }
1341
1342 out:
1343 /*
1344 * Release the reference we took to prevent deletion while we weren't holding the lock.
1345 * If not returning success, then dropping this reference could delete the devnode;
1346 * no one should access a devnode after a call to devfs_dntovn fails.
1347 */
1348 devfs_rele_node(dnp);
1349
1350 return error;
1351 }
1352
1353 /*
1354 * Increment refcount on a devnode; prevents free of the node
1355 * while the devfs lock is not held.
1356 */
1357 void
devfs_ref_node(devnode_t * dnp)1358 devfs_ref_node(devnode_t *dnp)
1359 {
1360 os_ref_retain_locked_raw(&dnp->dn_refcount, &devfs_refgrp);
1361 }
1362
1363 /*
1364 * Release a reference on a devnode. If the devnode is marked for
1365 * free and the refcount is dropped to one, do the free.
1366 */
1367 void
devfs_rele_node(devnode_t * dnp)1368 devfs_rele_node(devnode_t *dnp)
1369 {
1370 os_ref_count_t rc = os_ref_release_locked_raw(&dnp->dn_refcount, &devfs_refgrp);
1371 if (rc < 1) {
1372 panic("devfs_rele_node: devnode without a refcount!");
1373 } else if ((rc == 1) && (dnp->dn_lflags & DN_DELETE)) {
1374 /* release final reference from dev_add_node */
1375 (void) os_ref_release_locked_raw(&dnp->dn_refcount, &devfs_refgrp);
1376 devnode_free(dnp);
1377 }
1378 }
1379
1380 /***********************************************************************
1381 * add a whole device, with no prototype.. make name element and node
1382 * Used for adding the original device entries
1383 *
1384 * called with DEVFS_LOCK held
1385 ***********************************************************************/
1386 int
dev_add_entry(const char * name,devnode_t * parent,int type,devnode_type_t * typeinfo,devnode_t * proto,struct devfsmount * dvm,devdirent_t ** nm_pp)1387 dev_add_entry(const char *name, devnode_t * parent, int type, devnode_type_t * typeinfo,
1388 devnode_t * proto, struct devfsmount *dvm, devdirent_t * *nm_pp)
1389 {
1390 devnode_t * dnp;
1391 int error = 0;
1392
1393 if ((error = dev_add_node(type, typeinfo, proto, &dnp,
1394 (parent?parent->dn_dvm:dvm))) != 0) {
1395 printf("devfs: %s: base node allocation failed (Errno=%d)\n",
1396 name, error);
1397 return error;
1398 }
1399 if ((error = dev_add_name(name, parent, NULL, dnp, nm_pp)) != 0) {
1400 devfs_dn_free(dnp); /* 1->0 for dir, 0->(-1) for other */
1401 printf("devfs: %s: name slot allocation failed (Errno=%d)\n",
1402 name, error);
1403 }
1404 return error;
1405 }
1406
1407 static void
devfs_bulk_notify(devfs_event_log_t delp)1408 devfs_bulk_notify(devfs_event_log_t delp)
1409 {
1410 uint32_t i;
1411 for (i = 0; i < delp->del_used; i++) {
1412 devfs_vnode_event_t dvep = &delp->del_entries[i];
1413 if (vnode_getwithvid(dvep->dve_vp, dvep->dve_vid) == 0) {
1414 vnode_notify(dvep->dve_vp, dvep->dve_events, NULL);
1415 vnode_put(dvep->dve_vp);
1416 }
1417 }
1418 }
1419
1420 static void
devfs_record_event(devfs_event_log_t delp,devnode_t * dnp,uint32_t events)1421 devfs_record_event(devfs_event_log_t delp, devnode_t *dnp, uint32_t events)
1422 {
1423 if (delp->del_used >= delp->del_max) {
1424 panic("devfs event log overflowed.");
1425 }
1426
1427 /* Can only notify for nodes that have an associated vnode */
1428 if (dnp->dn_vn != NULLVP && vnode_ismonitored(dnp->dn_vn)) {
1429 devfs_vnode_event_t dvep = &delp->del_entries[delp->del_used];
1430 dvep->dve_vp = dnp->dn_vn;
1431 dvep->dve_vid = vnode_vid(dnp->dn_vn);
1432 dvep->dve_events = events;
1433 delp->del_used++;
1434 }
1435 }
1436
1437 static int
devfs_init_event_log(devfs_event_log_t delp,uint32_t count,devfs_vnode_event_t buf)1438 devfs_init_event_log(devfs_event_log_t delp, uint32_t count, devfs_vnode_event_t buf)
1439 {
1440 devfs_vnode_event_t dvearr;
1441
1442 if (buf == NULL) {
1443 MALLOC(dvearr, devfs_vnode_event_t, count * sizeof(struct devfs_vnode_event), M_TEMP, M_WAITOK | M_ZERO);
1444 if (dvearr == NULL) {
1445 return ENOMEM;
1446 }
1447 } else {
1448 dvearr = buf;
1449 }
1450
1451 delp->del_max = count;
1452 delp->del_used = 0;
1453 delp->del_entries = dvearr;
1454 return 0;
1455 }
1456
1457 static void
devfs_release_event_log(devfs_event_log_t delp,int need_free)1458 devfs_release_event_log(devfs_event_log_t delp, int need_free)
1459 {
1460 if (delp->del_entries == NULL) {
1461 panic("Free of devfs notify info that has not been intialized.");
1462 }
1463
1464 if (need_free) {
1465 FREE(delp->del_entries, M_TEMP);
1466 }
1467
1468 delp->del_entries = NULL;
1469 }
1470
1471 /*
1472 * Function: devfs_make_node
1473 *
1474 * Purpose
1475 * Create a device node with the given pathname in the devfs namespace.
1476 *
1477 * Parameters:
1478 * dev - the dev_t value to associate
1479 * chrblk - block or character device (DEVFS_CHAR or DEVFS_BLOCK)
1480 * uid, gid - ownership
1481 * perms - permissions
1482 * clone - minor number cloning function
1483 * fmt, ... - path format string with printf args to format the path name
1484 * Returns:
1485 * A handle to a device node if successful, NULL otherwise.
1486 */
1487 void *
devfs_make_node_clone(dev_t dev,int chrblk,uid_t uid,gid_t gid,int perms,int (* clone)(dev_t dev,int action),const char * fmt,...)1488 devfs_make_node_clone(dev_t dev, int chrblk, uid_t uid,
1489 gid_t gid, int perms, int (*clone)(dev_t dev, int action),
1490 const char *fmt, ...)
1491 {
1492 devdirent_t * new_dev = NULL;
1493 devfstype_t type;
1494 va_list ap;
1495
1496 switch (chrblk) {
1497 case DEVFS_CHAR:
1498 type = DEV_CDEV;
1499 break;
1500 case DEVFS_BLOCK:
1501 type = DEV_BDEV;
1502 break;
1503 default:
1504 goto out;
1505 }
1506
1507 va_start(ap, fmt);
1508 new_dev = devfs_make_node_internal(dev, type, uid, gid, perms, clone, fmt, ap);
1509 va_end(ap);
1510 out:
1511 return new_dev;
1512 }
1513
1514
1515 /*
1516 * Function: devfs_make_node
1517 *
1518 * Purpose
1519 * Create a device node with the given pathname in the devfs namespace.
1520 *
1521 * Parameters:
1522 * dev - the dev_t value to associate
1523 * chrblk - block or character device (DEVFS_CHAR or DEVFS_BLOCK)
1524 * uid, gid - ownership
1525 * perms - permissions
1526 * fmt, ... - path format string with printf args to format the path name
1527 * Returns:
1528 * A handle to a device node if successful, NULL otherwise.
1529 */
1530 void *
devfs_make_node(dev_t dev,int chrblk,uid_t uid,gid_t gid,int perms,const char * fmt,...)1531 devfs_make_node(dev_t dev, int chrblk, uid_t uid,
1532 gid_t gid, int perms, const char *fmt, ...)
1533 {
1534 devdirent_t * new_dev = NULL;
1535 devfstype_t type;
1536 va_list ap;
1537
1538 if (chrblk != DEVFS_CHAR && chrblk != DEVFS_BLOCK) {
1539 goto out;
1540 }
1541
1542 type = (chrblk == DEVFS_BLOCK ? DEV_BDEV : DEV_CDEV);
1543
1544 va_start(ap, fmt);
1545 new_dev = devfs_make_node_internal(dev, type, uid, gid, perms, NULL, fmt, ap);
1546 va_end(ap);
1547
1548 out:
1549 return new_dev;
1550 }
1551
1552 static devdirent_t *
devfs_make_node_internal(dev_t dev,devfstype_t type,uid_t uid,gid_t gid,int perms,int (* clone)(dev_t dev,int action),const char * fmt,va_list ap)1553 devfs_make_node_internal(dev_t dev, devfstype_t type, uid_t uid,
1554 gid_t gid, int perms, int (*clone)(dev_t dev, int action), const char *fmt, va_list ap)
1555 {
1556 devdirent_t * new_dev = NULL;
1557 devnode_t * dnp;
1558 devnode_type_t typeinfo;
1559
1560 char *name, buf[256]; /* XXX */
1561 const char *path;
1562 #if CONFIG_MACF
1563 char buff[sizeof(buf)];
1564 #endif
1565 size_t i;
1566 uint32_t log_count;
1567 struct devfs_event_log event_log;
1568 struct devfs_vnode_event stackbuf[NUM_STACK_ENTRIES];
1569 int need_free = 0;
1570
1571 vsnprintf(buf, sizeof(buf), fmt, ap);
1572
1573 #if CONFIG_MACF
1574 bcopy(buf, buff, sizeof(buff));
1575 buff[sizeof(buff) - 1] = 0;
1576 #endif
1577 name = NULL;
1578
1579 for (i = strlen(buf); i > 0; i--) {
1580 if (buf[i] == '/') {
1581 name = &buf[i];
1582 buf[i] = 0;
1583 break;
1584 }
1585 }
1586
1587 if (name) {
1588 *name++ = '\0';
1589 path = buf;
1590 } else {
1591 name = buf;
1592 path = "/";
1593 }
1594
1595 log_count = devfs_nmountplanes;
1596 if (log_count > NUM_STACK_ENTRIES) {
1597 wrongsize:
1598 need_free = 1;
1599 if (devfs_init_event_log(&event_log, log_count, NULL) != 0) {
1600 return NULL;
1601 }
1602 } else {
1603 need_free = 0;
1604 log_count = NUM_STACK_ENTRIES;
1605 if (devfs_init_event_log(&event_log, log_count, &stackbuf[0]) != 0) {
1606 return NULL;
1607 }
1608 }
1609
1610 DEVFS_LOCK();
1611 if (log_count < devfs_nmountplanes) {
1612 DEVFS_UNLOCK();
1613 devfs_release_event_log(&event_log, need_free);
1614 log_count = log_count * 2;
1615 goto wrongsize;
1616 }
1617
1618 if (!devfs_ready) {
1619 printf("devfs_make_node: not ready for devices!\n");
1620 goto out;
1621 }
1622
1623 /* find/create directory path ie. mkdir -p */
1624 if (dev_finddir(path, NULL, DEVFS_CREATE, &dnp, &event_log) == 0) {
1625 typeinfo.dev = dev;
1626 if (dev_add_entry(name, dnp, type, &typeinfo, NULL, NULL, &new_dev) == 0) {
1627 new_dev->de_dnp->dn_gid = gid;
1628 new_dev->de_dnp->dn_uid = uid;
1629 new_dev->de_dnp->dn_mode |= perms;
1630 new_dev->de_dnp->dn_clone = clone;
1631 #if CONFIG_MACF
1632 mac_devfs_label_associate_device(dev, new_dev->de_dnp, buff);
1633 #endif
1634 devfs_propogate(dnp->dn_typeinfo.Dir.myname, new_dev, &event_log);
1635 }
1636 }
1637
1638 out:
1639 DEVFS_UNLOCK();
1640
1641 devfs_bulk_notify(&event_log);
1642 devfs_release_event_log(&event_log, need_free);
1643 return new_dev;
1644 }
1645
1646 /*
1647 * Function: devfs_make_link
1648 *
1649 * Purpose:
1650 * Create a link to a previously created device node.
1651 *
1652 * Returns:
1653 * 0 if successful, -1 if failed
1654 */
1655 int
devfs_make_link(void * original,char * fmt,...)1656 devfs_make_link(void *original, char *fmt, ...)
1657 {
1658 devdirent_t * new_dev = NULL;
1659 devdirent_t * orig = (devdirent_t *) original;
1660 devnode_t * dirnode; /* devnode for parent directory */
1661 struct devfs_event_log event_log;
1662 uint32_t log_count;
1663
1664 va_list ap;
1665 char *p, buf[256]; /* XXX */
1666 size_t i;
1667
1668 DEVFS_LOCK();
1669
1670 if (!devfs_ready) {
1671 DEVFS_UNLOCK();
1672 printf("devfs_make_link: not ready for devices!\n");
1673 return -1;
1674 }
1675 DEVFS_UNLOCK();
1676
1677 va_start(ap, fmt);
1678 vsnprintf(buf, sizeof(buf), fmt, ap);
1679 va_end(ap);
1680
1681 p = NULL;
1682
1683 for (i = strlen(buf); i > 0; i--) {
1684 if (buf[i] == '/') {
1685 p = &buf[i];
1686 buf[i] = 0;
1687 break;
1688 }
1689 }
1690
1691 /*
1692 * One slot for each directory, one for each devnode
1693 * whose link count changes
1694 */
1695 log_count = devfs_nmountplanes * 2;
1696 wrongsize:
1697 if (devfs_init_event_log(&event_log, log_count, NULL) != 0) {
1698 /* No lock held, no allocations done, can just return */
1699 return -1;
1700 }
1701
1702 DEVFS_LOCK();
1703
1704 if (log_count < devfs_nmountplanes) {
1705 DEVFS_UNLOCK();
1706 devfs_release_event_log(&event_log, 1);
1707 log_count = log_count * 2;
1708 goto wrongsize;
1709 }
1710
1711 if (p) {
1712 *p++ = '\0';
1713
1714 if (dev_finddir(buf, NULL, DEVFS_CREATE, &dirnode, &event_log)
1715 || dev_add_name(p, dirnode, NULL, orig->de_dnp, &new_dev)) {
1716 goto fail;
1717 }
1718 } else {
1719 if (dev_finddir("", NULL, DEVFS_CREATE, &dirnode, &event_log)
1720 || dev_add_name(buf, dirnode, NULL, orig->de_dnp, &new_dev)) {
1721 goto fail;
1722 }
1723 }
1724 devfs_propogate(dirnode->dn_typeinfo.Dir.myname, new_dev, &event_log);
1725 fail:
1726 DEVFS_UNLOCK();
1727 devfs_bulk_notify(&event_log);
1728 devfs_release_event_log(&event_log, 1);
1729
1730 return (new_dev != NULL) ? 0 : -1;
1731 }
1732