1/*
2 * Copyright (c) 2000-2015 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/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
29/*
30 * Copyright (c) 1982, 1986, 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 * (c) UNIX System Laboratories, Inc.
33 * All or some portions of this file are derived from material licensed
34 * to the University of California by American Telephone and Telegraph
35 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
36 * the permission of UNIX System Laboratories, Inc.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * @(#)vfs_lookup.c 8.10 (Berkeley) 5/27/95
67 */
68/*
69 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
70 * support for mandatory and extensible security protections. This notice
71 * is included in support of clause 2.2 (b) of the Apple Public License,
72 * Version 2.0.
73 */
74
75#include <sys/param.h>
76#include <sys/systm.h>
77#include <sys/syslimits.h>
78#include <sys/time.h>
79#include <sys/namei.h>
80#include <sys/vm.h>
81#include <sys/vnode_internal.h>
82#include <sys/mount_internal.h>
83#include <sys/errno.h>
84#include <sys/malloc.h>
85#include <sys/filedesc.h>
86#include <sys/proc_internal.h>
87#include <sys/kdebug.h>
88#include <sys/unistd.h> /* For _PC_NAME_MAX */
89#include <sys/uio_internal.h>
90#include <sys/kauth.h>
91#include <kern/kalloc.h>
92#include <security/audit/audit.h>
93#include <sys/dtrace.h> /* to get the prototype for strstr() in sys/dtrace_glue.h */
94#if CONFIG_MACF
95#include <security/mac_framework.h>
96#endif
97
98#if NAMEDRSRCFORK
99#include <sys/xattr.h>
100#endif
101/*
102 * The minimum volfs-style pathname is 9.
103 * Example: "/.vol/1/2"
104 */
105#define VOLFS_MIN_PATH_LEN 9
106
107
108#if CONFIG_VOLFS
109static int vfs_getrealpath(const char * path, char * realpath, size_t bufsize, vfs_context_t ctx);
110#define MAX_VOLFS_RESTARTS 5
111#endif
112
113static int lookup_traverse_mountpoints(struct nameidata *ndp, struct componentname *cnp, vnode_t dp, int vbusyflags, vfs_context_t ctx);
114static int lookup_handle_symlink(struct nameidata *ndp, vnode_t *new_dp, vfs_context_t ctx);
115static int lookup_authorize_search(vnode_t dp, struct componentname *cnp, int dp_authorized_in_cache, vfs_context_t ctx);
116static void lookup_consider_update_cache(vnode_t dvp, vnode_t vp, struct componentname *cnp, int nc_generation);
117static int lookup_handle_found_vnode(struct nameidata *ndp, struct componentname *cnp, int rdonly,
118 int vbusyflags, int *keep_going, int nc_generation,
119 int wantparent, int atroot, vfs_context_t ctx);
120static int lookup_handle_emptyname(struct nameidata *ndp, struct componentname *cnp, int wantparent);
121
122#if NAMEDRSRCFORK
123static int lookup_handle_rsrc_fork(vnode_t dp, struct nameidata *ndp, struct componentname *cnp, int wantparent, vfs_context_t ctx);
124#endif
125
126
127
128/*
129 * Convert a pathname into a pointer to a locked inode.
130 *
131 * The FOLLOW flag is set when symbolic links are to be followed
132 * when they occur at the end of the name translation process.
133 * Symbolic links are always followed for all other pathname
134 * components other than the last.
135 *
136 * The segflg defines whether the name is to be copied from user
137 * space or kernel space.
138 *
139 * Overall outline of namei:
140 *
141 * copy in name
142 * get starting directory
143 * while (!done && !error) {
144 * call lookup to search path.
145 * if symbolic link, massage name in buffer and continue
146 * }
147 *
148 * Returns: 0 Success
149 * ENOENT No such file or directory
150 * ELOOP Too many levels of symbolic links
151 * ENAMETOOLONG Filename too long
152 * copyinstr:EFAULT Bad address
153 * copyinstr:ENAMETOOLONG Filename too long
154 * lookup:EBADF Bad file descriptor
155 * lookup:EROFS
156 * lookup:EACCES
157 * lookup:EPERM
158 * lookup:ERECYCLE vnode was recycled from underneath us in lookup.
159 * This means we should re-drive lookup from this point.
160 * lookup: ???
161 * VNOP_READLINK:???
162 */
163int
164namei(struct nameidata *ndp)
165{
166 struct filedesc *fdp; /* pointer to file descriptor state */
167 struct vnode *dp; /* the directory we are searching */
168 struct vnode *usedvp = ndp->ni_dvp; /* store pointer to vp in case we must loop due to
169 heavy vnode pressure */
170 u_long cnpflags = ndp->ni_cnd.cn_flags; /* store in case we have to restore after loop */
171 int error;
172 struct componentname *cnp = &ndp->ni_cnd;
173 vfs_context_t ctx = cnp->cn_context;
174 proc_t p = vfs_context_proc(ctx);
175#if CONFIG_AUDIT
176/* XXX ut should be from context */
177 uthread_t ut = (struct uthread *)get_bsdthread_info(current_thread());
178#endif
179
180#if CONFIG_VOLFS
181 int volfs_restarts = 0;
182#endif
183 size_t bytes_copied = 0;
184
185 fdp = p->p_fd;
186
187#if DIAGNOSTIC
188 if (!vfs_context_ucred(ctx) || !p)
189 panic ("namei: bad cred/proc");
190 if (cnp->cn_nameiop & (~OPMASK))
191 panic ("namei: nameiop contaminated with flags");
192 if (cnp->cn_flags & OPMASK)
193 panic ("namei: flags contaminated with nameiops");
194#endif
195
196 /*
197 * A compound VNOP found something that needs further processing:
198 * either a trigger vnode, a covered directory, or a symlink.
199 */
200 if (ndp->ni_flag & NAMEI_CONTLOOKUP) {
201 int rdonly, vbusyflags, keep_going, wantparent;
202
203 rdonly = cnp->cn_flags & RDONLY;
204 vbusyflags = ((cnp->cn_flags & CN_NBMOUNTLOOK) != 0) ? LK_NOWAIT : 0;
205 keep_going = 0;
206 wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
207
208 ndp->ni_flag &= ~(NAMEI_CONTLOOKUP);
209
210 error = lookup_handle_found_vnode(ndp, &ndp->ni_cnd, rdonly, vbusyflags,
211 &keep_going, ndp->ni_ncgeneration, wantparent, 0, ctx);
212 if (error)
213 goto out_drop;
214 if (keep_going) {
215 if ((cnp->cn_flags & ISSYMLINK) == 0) {
216 panic("We need to keep going on a continued lookup, but for vp type %d (tag %d)\n", ndp->ni_vp->v_type, ndp->ni_vp->v_tag);
217 }
218 goto continue_symlink;
219 }
220
221 return 0;
222
223 }
224
225vnode_recycled:
226
227 /*
228 * Get a buffer for the name to be translated, and copy the
229 * name into the buffer.
230 */
231 if ((cnp->cn_flags & HASBUF) == 0) {
232 cnp->cn_pnbuf = ndp->ni_pathbuf;
233 cnp->cn_pnlen = PATHBUFLEN;
234 }
235#if LP64_DEBUG
236 if ((UIO_SEG_IS_USER_SPACE(ndp->ni_segflg) == 0)
237 && (ndp->ni_segflg != UIO_SYSSPACE)
238 && (ndp->ni_segflg != UIO_SYSSPACE32)) {
239 panic("%s :%d - invalid ni_segflg\n", __FILE__, __LINE__);
240 }
241#endif /* LP64_DEBUG */
242
243retry_copy:
244 if (UIO_SEG_IS_USER_SPACE(ndp->ni_segflg)) {
245 error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf,
246 cnp->cn_pnlen, &bytes_copied);
247 } else {
248 error = copystr(CAST_DOWN(void *, ndp->ni_dirp), cnp->cn_pnbuf,
249 cnp->cn_pnlen, &bytes_copied);
250 }
251 if (error == ENAMETOOLONG && !(cnp->cn_flags & HASBUF)) {
252 MALLOC_ZONE(cnp->cn_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
253 if (cnp->cn_pnbuf == NULL) {
254 error = ENOMEM;
255 goto error_out;
256 }
257
258 cnp->cn_flags |= HASBUF;
259 cnp->cn_pnlen = MAXPATHLEN;
260 bytes_copied = 0;
261
262 goto retry_copy;
263 }
264 if (error)
265 goto error_out;
266 ndp->ni_pathlen = bytes_copied;
267 bytes_copied = 0;
268
269 /*
270 * Since the name cache may contain positive entries of
271 * the incorrect case, force lookup() to bypass the cache
272 * and call directly into the filesystem for each path
273 * component. Note: the FS may still consult the cache,
274 * but can apply rules to validate the results.
275 */
276 if (proc_is_forcing_hfs_case_sensitivity(p))
277 cnp->cn_flags |= CN_SKIPNAMECACHE;
278
279#if CONFIG_VOLFS
280 /*
281 * Check for legacy volfs style pathnames.
282 *
283 * For compatibility reasons we currently allow these paths,
284 * but future versions of the OS may not support them.
285 */
286 if (ndp->ni_pathlen >= VOLFS_MIN_PATH_LEN &&
287 cnp->cn_pnbuf[0] == '/' &&
288 cnp->cn_pnbuf[1] == '.' &&
289 cnp->cn_pnbuf[2] == 'v' &&
290 cnp->cn_pnbuf[3] == 'o' &&
291 cnp->cn_pnbuf[4] == 'l' &&
292 cnp->cn_pnbuf[5] == '/' ) {
293 char * realpath;
294 int realpath_err;
295 /* Attempt to resolve a legacy volfs style pathname. */
296 MALLOC_ZONE(realpath, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
297 if (realpath) {
298 /*
299 * We only error out on the ENAMETOOLONG cases where we know that
300 * vfs_getrealpath translation succeeded but the path could not fit into
301 * MAXPATHLEN characters. In other failure cases, we may be dealing with a path
302 * that legitimately looks like /.vol/1234/567 and is not meant to be translated
303 */
304 if ((realpath_err= vfs_getrealpath(&cnp->cn_pnbuf[6], realpath, MAXPATHLEN, ctx))) {
305 FREE_ZONE(realpath, MAXPATHLEN, M_NAMEI);
306 if (realpath_err == ENOSPC || realpath_err == ENAMETOOLONG){
307 error = ENAMETOOLONG;
308 goto error_out;
309 }
310 } else {
311 if (cnp->cn_flags & HASBUF) {
312 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
313 }
314 cnp->cn_pnbuf = realpath;
315 cnp->cn_pnlen = MAXPATHLEN;
316 ndp->ni_pathlen = strlen(realpath) + 1;
317 cnp->cn_flags |= HASBUF | CN_VOLFSPATH;
318 }
319 }
320 }
321#endif /* CONFIG_VOLFS */
322
323#if CONFIG_AUDIT
324 /* If we are auditing the kernel pathname, save the user pathname */
325 if (cnp->cn_flags & AUDITVNPATH1)
326 AUDIT_ARG(upath, ut->uu_cdir, cnp->cn_pnbuf, ARG_UPATH1);
327 if (cnp->cn_flags & AUDITVNPATH2)
328 AUDIT_ARG(upath, ut->uu_cdir, cnp->cn_pnbuf, ARG_UPATH2);
329#endif /* CONFIG_AUDIT */
330
331 /*
332 * Do not allow empty pathnames
333 */
334 if (*cnp->cn_pnbuf == '\0') {
335 error = ENOENT;
336 goto error_out;
337 }
338 ndp->ni_loopcnt = 0;
339
340 /*
341 * determine the starting point for the translation.
342 */
343 if ((ndp->ni_rootdir = fdp->fd_rdir) == NULLVP) {
344 if ( !(fdp->fd_flags & FD_CHROOT))
345 ndp->ni_rootdir = rootvnode;
346 }
347 cnp->cn_nameptr = cnp->cn_pnbuf;
348
349 ndp->ni_usedvp = NULLVP;
350
351 if (*(cnp->cn_nameptr) == '/') {
352 while (*(cnp->cn_nameptr) == '/') {
353 cnp->cn_nameptr++;
354 ndp->ni_pathlen--;
355 }
356 dp = ndp->ni_rootdir;
357 } else if (cnp->cn_flags & USEDVP) {
358 dp = ndp->ni_dvp;
359 ndp->ni_usedvp = dp;
360 } else
361 dp = vfs_context_cwd(ctx);
362
363 if (dp == NULLVP || (dp->v_lflag & VL_DEAD)) {
364 error = ENOENT;
365 goto error_out;
366 }
367 ndp->ni_dvp = NULLVP;
368 ndp->ni_vp = NULLVP;
369
370 for (;;) {
371#if CONFIG_MACF
372 /*
373 * Give MACF policies a chance to reject the lookup
374 * before performing any filesystem operations.
375 * This hook is called before resolving the path and
376 * again each time a symlink is encountered.
377 * NB: policies receive path information as supplied
378 * by the caller and thus cannot be trusted.
379 */
380 error = mac_vnode_check_lookup_preflight(ctx, dp, cnp->cn_nameptr, cnp->cn_namelen);
381 if (error) {
382 goto error_out;
383 }
384#endif
385
386 ndp->ni_startdir = dp;
387
388 if ( (error = lookup(ndp)) ) {
389 goto error_out;
390 }
391
392 /*
393 * Check for symbolic link
394 */
395 if ((cnp->cn_flags & ISSYMLINK) == 0) {
396 return (0);
397 }
398
399continue_symlink:
400 /* Gives us a new path to process, and a starting dir */
401 error = lookup_handle_symlink(ndp, &dp, ctx);
402 if (error != 0) {
403 break;
404 }
405 }
406 /*
407 * only come here if we fail to handle a SYMLINK...
408 * if either ni_dvp or ni_vp is non-NULL, then
409 * we need to drop the iocount that was picked
410 * up in the lookup routine
411 */
412out_drop:
413 if (ndp->ni_dvp)
414 vnode_put(ndp->ni_dvp);
415 if (ndp->ni_vp)
416 vnode_put(ndp->ni_vp);
417 error_out:
418 if ( (cnp->cn_flags & HASBUF) ) {
419 cnp->cn_flags &= ~HASBUF;
420 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
421 }
422 cnp->cn_pnbuf = NULL;
423 ndp->ni_vp = NULLVP;
424 ndp->ni_dvp = NULLVP;
425
426#if CONFIG_VOLFS
427 /*
428 * Deal with volfs fallout.
429 *
430 * At this point, if we were originally given a volfs path that
431 * looks like /.vol/123/456, then we would have had to convert it into
432 * a full path. Assuming that part worked properly, we will now attempt
433 * to conduct a lookup of the item in the namespace. Under normal
434 * circumstances, if a user looked up /tmp/foo and it was not there, it
435 * would be permissible to return ENOENT.
436 *
437 * However, we may not want to do that here. Specifically, the volfs path
438 * uniquely identifies a certain item in the namespace regardless of where it
439 * lives. If the item has moved in between the time we constructed the
440 * path and now, when we're trying to do a lookup/authorization on the full
441 * path, we may have gotten an ENOENT.
442 *
443 * At this point we can no longer tell if the path no longer exists
444 * or if the item in question no longer exists. It could have been renamed
445 * away, in which case the /.vol identifier is still valid.
446 *
447 * Do this dance a maximum of MAX_VOLFS_RESTARTS times.
448 */
449 if ((error == ENOENT) && (ndp->ni_cnd.cn_flags & CN_VOLFSPATH)) {
450 if (volfs_restarts < MAX_VOLFS_RESTARTS) {
451 volfs_restarts++;
452 goto vnode_recycled;
453 }
454 }
455#endif
456
457 if (error == ERECYCLE){
458 /* vnode was recycled underneath us. re-drive lookup to start at
459 the beginning again, since recycling invalidated last lookup*/
460 ndp->ni_cnd.cn_flags = cnpflags;
461 ndp->ni_dvp = usedvp;
462 goto vnode_recycled;
463 }
464
465
466 return (error);
467}
468
469int
470namei_compound_available(vnode_t dp, struct nameidata *ndp)
471{
472 if ((ndp->ni_flag & NAMEI_COMPOUNDOPEN) != 0) {
473 return vnode_compound_open_available(dp);
474 }
475
476 return 0;
477}
478
479static int
480lookup_authorize_search(vnode_t dp, struct componentname *cnp, int dp_authorized_in_cache, vfs_context_t ctx)
481{
482#if !CONFIG_MACF
483#pragma unused(cnp)
484#endif
485
486 int error;
487
488 if (!dp_authorized_in_cache) {
489 error = vnode_authorize(dp, NULL, KAUTH_VNODE_SEARCH, ctx);
490 if (error)
491 return error;
492 }
493#if CONFIG_MACF
494 error = mac_vnode_check_lookup(ctx, dp, cnp);
495 if (error)
496 return error;
497#endif /* CONFIG_MACF */
498
499 return 0;
500}
501
502static void
503lookup_consider_update_cache(vnode_t dvp, vnode_t vp, struct componentname *cnp, int nc_generation)
504{
505 int isdot_or_dotdot;
506 isdot_or_dotdot = (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') || (cnp->cn_flags & ISDOTDOT);
507
508 if (vp->v_name == NULL || vp->v_parent == NULLVP) {
509 int update_flags = 0;
510
511 if (isdot_or_dotdot == 0) {
512 if (vp->v_name == NULL)
513 update_flags |= VNODE_UPDATE_NAME;
514 if (dvp != NULLVP && vp->v_parent == NULLVP)
515 update_flags |= VNODE_UPDATE_PARENT;
516
517 if (update_flags)
518 vnode_update_identity(vp, dvp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_hash, update_flags);
519 }
520 }
521 if ( (cnp->cn_flags & MAKEENTRY) && (vp->v_flag & VNCACHEABLE) && LIST_FIRST(&vp->v_nclinks) == NULL) {
522 /*
523 * missing from name cache, but should
524 * be in it... this can happen if volfs
525 * causes the vnode to be created or the
526 * name cache entry got recycled but the
527 * vnode didn't...
528 * check to make sure that ni_dvp is valid
529 * cache_lookup_path may return a NULL
530 * do a quick check to see if the generation of the
531 * directory matches our snapshot... this will get
532 * rechecked behind the name cache lock, but if it
533 * already fails to match, no need to go any further
534 */
535 if (dvp != NULLVP && (nc_generation == dvp->v_nc_generation) && (!isdot_or_dotdot))
536 cache_enter_with_gen(dvp, vp, cnp, nc_generation);
537 }
538
539}
540
541#if NAMEDRSRCFORK
542/*
543 * Can change ni_dvp and ni_vp. On success, returns with iocounts on stream vnode (always) and
544 * data fork if requested. On failure, returns with iocount data fork (always) and its parent directory
545 * (if one was provided).
546 */
547static int
548lookup_handle_rsrc_fork(vnode_t dp, struct nameidata *ndp, struct componentname *cnp, int wantparent, vfs_context_t ctx)
549{
550 vnode_t svp = NULLVP;
551 enum nsoperation nsop;
552 int nsflags;
553 int error;
554
555 if (dp->v_type != VREG) {
556 error = ENOENT;
557 goto out;
558 }
559 switch (cnp->cn_nameiop) {
560 case DELETE:
561 if (cnp->cn_flags & CN_ALLOWRSRCFORK) {
562 nsop = NS_DELETE;
563 } else {
564 error = EPERM;
565 goto out;
566 }
567 break;
568 case CREATE:
569 if (cnp->cn_flags & CN_ALLOWRSRCFORK) {
570 nsop = NS_CREATE;
571 } else {
572 error = EPERM;
573 goto out;
574 }
575 break;
576 case LOOKUP:
577 /* Make sure our lookup of "/..namedfork/rsrc" is allowed. */
578 if (cnp->cn_flags & CN_ALLOWRSRCFORK) {
579 nsop = NS_OPEN;
580 } else {
581 error = EPERM;
582 goto out;
583 }
584 break;
585 default:
586 error = EPERM;
587 goto out;
588 }
589
590 nsflags = 0;
591 if (cnp->cn_flags & CN_RAW_ENCRYPTED)
592 nsflags |= NS_GETRAWENCRYPTED;
593
594 /* Ask the file system for the resource fork. */
595 error = vnode_getnamedstream(dp, &svp, XATTR_RESOURCEFORK_NAME, nsop, nsflags, ctx);
596
597 /* During a create, it OK for stream vnode to be missing. */
598 if (error == ENOATTR || error == ENOENT) {
599 error = (nsop == NS_CREATE) ? 0 : ENOENT;
600 }
601 if (error) {
602 goto out;
603 }
604 /* The "parent" of the stream is the file. */
605 if (wantparent) {
606 if (ndp->ni_dvp) {
607 vnode_put(ndp->ni_dvp);
608 }
609 ndp->ni_dvp = dp;
610 } else {
611 vnode_put(dp);
612 }
613 ndp->ni_vp = svp; /* on create this may be null */
614
615 /* Restore the truncated pathname buffer (for audits). */
616 if (ndp->ni_pathlen == 1 && ndp->ni_next[0] == '\0') {
617 ndp->ni_next[0] = '/';
618 }
619 cnp->cn_flags &= ~MAKEENTRY;
620
621 return 0;
622out:
623 return error;
624}
625#endif /* NAMEDRSRCFORK */
626
627/*
628 * iocounts in:
629 * --One on ni_vp. One on ni_dvp if there is more path, or we didn't come through the
630 * cache, or we came through the cache and the caller doesn't want the parent.
631 *
632 * iocounts out:
633 * --Leaves us in the correct state for the next step, whatever that might be.
634 * --If we find a symlink, returns with iocounts on both ni_vp and ni_dvp.
635 * --If we are to look up another component, then we have an iocount on ni_vp and
636 * nothing else.
637 * --If we are done, returns an iocount on ni_vp, and possibly on ni_dvp depending on nameidata flags.
638 * --In the event of an error, may return with ni_dvp NULL'ed out (in which case, iocount
639 * was dropped).
640 */
641static int
642lookup_handle_found_vnode(struct nameidata *ndp, struct componentname *cnp, int rdonly,
643 int vbusyflags, int *keep_going, int nc_generation,
644 int wantparent, int atroot, vfs_context_t ctx)
645{
646 vnode_t dp;
647 int error;
648 char *cp;
649
650 dp = ndp->ni_vp;
651 *keep_going = 0;
652
653 if (ndp->ni_vp == NULLVP) {
654 panic("NULL ni_vp in %s\n", __FUNCTION__);
655 }
656
657 if (atroot) {
658 goto nextname;
659 }
660
661 /*
662 * Take into account any additional components consumed by
663 * the underlying filesystem.
664 */
665 if (cnp->cn_consume > 0) {
666 cnp->cn_nameptr += cnp->cn_consume;
667 ndp->ni_next += cnp->cn_consume;
668 ndp->ni_pathlen -= cnp->cn_consume;
669 cnp->cn_consume = 0;
670 } else {
671 lookup_consider_update_cache(ndp->ni_dvp, dp, cnp, nc_generation);
672 }
673
674 /*
675 * Check to see if the vnode has been mounted on...
676 * if so find the root of the mounted file system.
677 * Updates ndp->ni_vp.
678 */
679 error = lookup_traverse_mountpoints(ndp, cnp, dp, vbusyflags, ctx);
680 dp = ndp->ni_vp;
681 if (error) {
682 goto out;
683 }
684
685#if CONFIG_MACF
686 if (vfs_flags(vnode_mount(dp)) & MNT_MULTILABEL) {
687 error = vnode_label(vnode_mount(dp), NULL, dp, NULL, 0, ctx);
688 if (error)
689 goto out;
690 }
691#endif
692
693 /*
694 * Check for symbolic link
695 */
696 if ((dp->v_type == VLNK) &&
697 ((cnp->cn_flags & FOLLOW) || (ndp->ni_flag & NAMEI_TRAILINGSLASH) || *ndp->ni_next == '/')) {
698 cnp->cn_flags |= ISSYMLINK;
699 *keep_going = 1;
700 return (0);
701 }
702
703 /*
704 * Check for bogus trailing slashes.
705 */
706 if ((ndp->ni_flag & NAMEI_TRAILINGSLASH)) {
707 if (dp->v_type != VDIR) {
708 error = ENOTDIR;
709 goto out;
710 }
711 ndp->ni_flag &= ~(NAMEI_TRAILINGSLASH);
712 }
713
714#if NAMEDSTREAMS
715 /*
716 * Deny namei/lookup requests to resolve paths that point to shadow files.
717 * Access to shadow files must be conducted by explicit calls to VNOP_LOOKUP
718 * directly, and not use lookup/namei
719 */
720 if (vnode_isshadow (dp)) {
721 error = ENOENT;
722 goto out;
723 }
724#endif
725
726nextname:
727 /*
728 * Not a symbolic link. If more pathname,
729 * continue at next component, else return.
730 *
731 * Definitely have a dvp if there's another slash
732 */
733 if (*ndp->ni_next == '/') {
734 cnp->cn_nameptr = ndp->ni_next + 1;
735 ndp->ni_pathlen--;
736 while (*cnp->cn_nameptr == '/') {
737 cnp->cn_nameptr++;
738 ndp->ni_pathlen--;
739 }
740
741 cp = cnp->cn_nameptr;
742 vnode_put(ndp->ni_dvp);
743 ndp->ni_dvp = NULLVP;
744
745 if (*cp == '\0') {
746 goto emptyname;
747 }
748
749 *keep_going = 1;
750 return 0;
751 }
752
753 /*
754 * Disallow directory write attempts on read-only file systems.
755 */
756 if (rdonly &&
757 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
758 error = EROFS;
759 goto out;
760 }
761
762 /* If SAVESTART is set, we should have a dvp */
763 if (cnp->cn_flags & SAVESTART) {
764 /*
765 * note that we already hold a reference
766 * on both dp and ni_dvp, but for some reason
767 * can't get another one... in this case we
768 * need to do vnode_put on dp in 'bad2'
769 */
770 if ( (vnode_get(ndp->ni_dvp)) ) {
771 error = ENOENT;
772 goto out;
773 }
774 ndp->ni_startdir = ndp->ni_dvp;
775 }
776 if (!wantparent && ndp->ni_dvp) {
777 vnode_put(ndp->ni_dvp);
778 ndp->ni_dvp = NULLVP;
779 }
780
781 if (cnp->cn_flags & AUDITVNPATH1)
782 AUDIT_ARG(vnpath, dp, ARG_VNODE1);
783 else if (cnp->cn_flags & AUDITVNPATH2)
784 AUDIT_ARG(vnpath, dp, ARG_VNODE2);
785
786#if NAMEDRSRCFORK
787 /*
788 * Caller wants the resource fork.
789 */
790 if ((cnp->cn_flags & CN_WANTSRSRCFORK) && (dp != NULLVP)) {
791 error = lookup_handle_rsrc_fork(dp, ndp, cnp, wantparent, ctx);
792 if (error != 0)
793 goto out;
794
795 dp = ndp->ni_vp;
796 }
797#endif
798 if (kdebug_enable)
799 kdebug_lookup(ndp->ni_vp, cnp);
800
801 return 0;
802
803emptyname:
804 error = lookup_handle_emptyname(ndp, cnp, wantparent);
805 if (error != 0)
806 goto out;
807
808 return 0;
809out:
810 return error;
811
812}
813
814/*
815 * Comes in iocount on ni_vp. May overwrite ni_dvp, but doesn't interpret incoming value.
816 */
817static int
818lookup_handle_emptyname(struct nameidata *ndp, struct componentname *cnp, int wantparent)
819{
820 vnode_t dp;
821 int error = 0;
822
823 dp = ndp->ni_vp;
824 cnp->cn_namelen = 0;
825 /*
826 * A degenerate name (e.g. / or "") which is a way of
827 * talking about a directory, e.g. like "/." or ".".
828 */
829 if (dp->v_type != VDIR) {
830 error = ENOTDIR;
831 goto out;
832 }
833 if (cnp->cn_nameiop != LOOKUP) {
834 error = EISDIR;
835 goto out;
836 }
837 if (wantparent) {
838 /*
839 * note that we already hold a reference
840 * on dp, but for some reason can't
841 * get another one... in this case we
842 * need to do vnode_put on dp in 'bad'
843 */
844 if ( (vnode_get(dp)) ) {
845 error = ENOENT;
846 goto out;
847 }
848 ndp->ni_dvp = dp;
849 }
850 cnp->cn_flags &= ~ISDOTDOT;
851 cnp->cn_flags |= ISLASTCN;
852 ndp->ni_next = cnp->cn_nameptr;
853 ndp->ni_vp = dp;
854
855 if (cnp->cn_flags & AUDITVNPATH1)
856 AUDIT_ARG(vnpath, dp, ARG_VNODE1);
857 else if (cnp->cn_flags & AUDITVNPATH2)
858 AUDIT_ARG(vnpath, dp, ARG_VNODE2);
859 if (cnp->cn_flags & SAVESTART)
860 panic("lookup: SAVESTART");
861
862 return 0;
863out:
864 return error;
865}
866/*
867 * Search a pathname.
868 * This is a very central and rather complicated routine.
869 *
870 * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
871 * The starting directory is taken from ni_startdir. The pathname is
872 * descended until done, or a symbolic link is encountered. The variable
873 * ni_more is clear if the path is completed; it is set to one if a
874 * symbolic link needing interpretation is encountered.
875 *
876 * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
877 * whether the name is to be looked up, created, renamed, or deleted.
878 * When CREATE, RENAME, or DELETE is specified, information usable in
879 * creating, renaming, or deleting a directory entry may be calculated.
880 * If flag has LOCKPARENT or'ed into it, the parent directory is returned
881 * locked. If flag has WANTPARENT or'ed into it, the parent directory is
882 * returned unlocked. Otherwise the parent directory is not returned. If
883 * the target of the pathname exists and LOCKLEAF is or'ed into the flag
884 * the target is returned locked, otherwise it is returned unlocked.
885 * When creating or renaming and LOCKPARENT is specified, the target may not
886 * be ".". When deleting and LOCKPARENT is specified, the target may be ".".
887 *
888 * Overall outline of lookup:
889 *
890 * dirloop:
891 * identify next component of name at ndp->ni_ptr
892 * handle degenerate case where name is null string
893 * if .. and crossing mount points and on mounted filesys, find parent
894 * call VNOP_LOOKUP routine for next component name
895 * directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
896 * component vnode returned in ni_vp (if it exists), locked.
897 * if result vnode is mounted on and crossing mount points,
898 * find mounted on vnode
899 * if more components of name, do next level at dirloop
900 * return the answer in ni_vp, locked if LOCKLEAF set
901 * if LOCKPARENT set, return locked parent in ni_dvp
902 * if WANTPARENT set, return unlocked parent in ni_dvp
903 *
904 * Returns: 0 Success
905 * ENOENT No such file or directory
906 * EBADF Bad file descriptor
907 * ENOTDIR Not a directory
908 * EROFS Read-only file system [CREATE]
909 * EISDIR Is a directory [CREATE]
910 * cache_lookup_path:ERECYCLE (vnode was recycled from underneath us, redrive lookup again)
911 * vnode_authorize:EROFS
912 * vnode_authorize:EACCES
913 * vnode_authorize:EPERM
914 * vnode_authorize:???
915 * VNOP_LOOKUP:ENOENT No such file or directory
916 * VNOP_LOOKUP:EJUSTRETURN Restart system call (INTERNAL)
917 * VNOP_LOOKUP:???
918 * VFS_ROOT:ENOTSUP
919 * VFS_ROOT:ENOENT
920 * VFS_ROOT:???
921 */
922int
923lookup(struct nameidata *ndp)
924{
925 char *cp; /* pointer into pathname argument */
926 vnode_t tdp; /* saved dp */
927 vnode_t dp; /* the directory we are searching */
928 int docache = 1; /* == 0 do not cache last component */
929 int wantparent; /* 1 => wantparent or lockparent flag */
930 int rdonly; /* lookup read-only flag bit */
931 int dp_authorized = 0;
932 int error = 0;
933 struct componentname *cnp = &ndp->ni_cnd;
934 vfs_context_t ctx = cnp->cn_context;
935 int vbusyflags = 0;
936 int nc_generation = 0;
937 vnode_t last_dp = NULLVP;
938 int keep_going;
939 int atroot;
940
941 /*
942 * Setup: break out flag bits into variables.
943 */
944 if (cnp->cn_flags & NOCACHE) {
945 docache = 0;
946 }
947 wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
948 rdonly = cnp->cn_flags & RDONLY;
949 cnp->cn_flags &= ~ISSYMLINK;
950 cnp->cn_consume = 0;
951
952 dp = ndp->ni_startdir;
953 ndp->ni_startdir = NULLVP;
954
955 if ((cnp->cn_flags & CN_NBMOUNTLOOK) != 0)
956 vbusyflags = LK_NOWAIT;
957 cp = cnp->cn_nameptr;
958
959 if (*cp == '\0') {
960 if ( (vnode_getwithref(dp)) ) {
961 dp = NULLVP;
962 error = ENOENT;
963 goto bad;
964 }
965 ndp->ni_vp = dp;
966 error = lookup_handle_emptyname(ndp, cnp, wantparent);
967 if (error) {
968 goto bad;
969 }
970
971 return 0;
972 }
973dirloop:
974 atroot = 0;
975 ndp->ni_vp = NULLVP;
976
977 if ( (error = cache_lookup_path(ndp, cnp, dp, ctx, &dp_authorized, last_dp)) ) {
978 dp = NULLVP;
979 goto bad;
980 }
981 if ((cnp->cn_flags & ISLASTCN)) {
982 if (docache)
983 cnp->cn_flags |= MAKEENTRY;
984 } else
985 cnp->cn_flags |= MAKEENTRY;
986
987 dp = ndp->ni_dvp;
988
989 if (ndp->ni_vp != NULLVP) {
990 /*
991 * cache_lookup_path returned a non-NULL ni_vp then,
992 * we're guaranteed that the dp is a VDIR, it's
993 * been authorized, and vp is not ".."
994 *
995 * make sure we don't try to enter the name back into
996 * the cache if this vp is purged before we get to that
997 * check since we won't have serialized behind whatever
998 * activity is occurring in the FS that caused the purge
999 */
1000 if (dp != NULLVP)
1001 nc_generation = dp->v_nc_generation - 1;
1002
1003 goto returned_from_lookup_path;
1004 }
1005
1006 /*
1007 * Handle "..": two special cases.
1008 * 1. If at root directory (e.g. after chroot)
1009 * or at absolute root directory
1010 * then ignore it so can't get out.
1011 * 2. If this vnode is the root of a mounted
1012 * filesystem, then replace it with the
1013 * vnode which was mounted on so we take the
1014 * .. in the other file system.
1015 */
1016 if ( (cnp->cn_flags & ISDOTDOT) ) {
1017 /*
1018 * if this is a chroot'ed process, check if the current
1019 * directory is still a subdirectory of the process's
1020 * root directory.
1021 */
1022 if (ndp->ni_rootdir && (ndp->ni_rootdir != rootvnode) &&
1023 dp != ndp->ni_rootdir) {
1024 int sdir_error;
1025 int is_subdir = FALSE;
1026
1027 sdir_error = vnode_issubdir(dp, ndp->ni_rootdir,
1028 &is_subdir, vfs_context_kernel());
1029
1030 /*
1031 * If we couldn't determine if dp is a subdirectory of
1032 * ndp->ni_rootdir (sdir_error != 0), we let the request
1033 * proceed.
1034 */
1035 if (!sdir_error && !is_subdir) {
1036 vnode_put(dp);
1037 dp = ndp->ni_rootdir;
1038 /*
1039 * There's a ref on the process's root directory
1040 * but we can't use vnode_getwithref here as
1041 * there is nothing preventing that ref being
1042 * released by another thread.
1043 */
1044 if (vnode_get(dp)) {
1045 error = ENOENT;
1046 goto bad;
1047 }
1048 }
1049 }
1050
1051 for (;;) {
1052 if (dp == ndp->ni_rootdir || dp == rootvnode) {
1053 ndp->ni_dvp = dp;
1054 ndp->ni_vp = dp;
1055 /*
1056 * we're pinned at the root
1057 * we've already got one reference on 'dp'
1058 * courtesy of cache_lookup_path... take
1059 * another one for the ".."
1060 * if we fail to get the new reference, we'll
1061 * drop our original down in 'bad'
1062 */
1063 if ( (vnode_get(dp)) ) {
1064 error = ENOENT;
1065 goto bad;
1066 }
1067 atroot = 1;
1068 goto returned_from_lookup_path;
1069 }
1070 if ((dp->v_flag & VROOT) == 0 ||
1071 (cnp->cn_flags & NOCROSSMOUNT))
1072 break;
1073 if (dp->v_mount == NULL) { /* forced umount */
1074 error = EBADF;
1075 goto bad;
1076 }
1077 tdp = dp;
1078 dp = tdp->v_mount->mnt_vnodecovered;
1079
1080 vnode_put(tdp);
1081
1082 if ( (vnode_getwithref(dp)) ) {
1083 dp = NULLVP;
1084 error = ENOENT;
1085 goto bad;
1086 }
1087 ndp->ni_dvp = dp;
1088 dp_authorized = 0;
1089 }
1090 }
1091
1092 /*
1093 * We now have a segment name to search for, and a directory to search.
1094 */
1095unionlookup:
1096 ndp->ni_vp = NULLVP;
1097
1098 if (dp->v_type != VDIR) {
1099 error = ENOTDIR;
1100 goto lookup_error;
1101 }
1102 if ( (cnp->cn_flags & DONOTAUTH) != DONOTAUTH ) {
1103 error = lookup_authorize_search(dp, cnp, dp_authorized, ctx);
1104 if (error) {
1105 goto lookup_error;
1106 }
1107 }
1108
1109 /*
1110 * Now that we've authorized a lookup, can bail out if the filesystem
1111 * will be doing a batched operation. Return an iocount on dvp.
1112 */
1113#if NAMEDRSRCFORK
1114 if ((cnp->cn_flags & ISLASTCN) && namei_compound_available(dp, ndp) && !(cnp->cn_flags & CN_WANTSRSRCFORK)) {
1115#else
1116 if ((cnp->cn_flags & ISLASTCN) && namei_compound_available(dp, ndp)) {
1117#endif /* NAMEDRSRCFORK */
1118 ndp->ni_flag |= NAMEI_UNFINISHED;
1119 ndp->ni_ncgeneration = dp->v_nc_generation;
1120 return 0;
1121 }
1122
1123 nc_generation = dp->v_nc_generation;
1124
1125 /*
1126 * Note:
1127 * Filesystems that support hardlinks may want to call vnode_update_identity
1128 * if the lookup operation below will modify the in-core vnode to belong to a new point
1129 * in the namespace. VFS cannot infer whether or not the look up operation makes the vnode
1130 * name change or change parents. Without this, the lookup may make update
1131 * filesystem-specific in-core metadata but fail to update the v_parent or v_name
1132 * fields in the vnode. If VFS were to do this, it would be necessary to call
1133 * vnode_update_identity on every lookup operation -- expensive!
1134 *
1135 * However, even with this in place, multiple lookups may occur in between this lookup
1136 * and the subsequent vnop, so, at best, we could only guarantee that you would get a
1137 * valid path back, and not necessarily the one that you wanted.
1138 *
1139 * Example:
1140 * /tmp/a == /foo/b
1141 *
1142 * If you are now looking up /foo/b and the vnode for this link represents /tmp/a,
1143 * vnode_update_identity will fix the parentage so that you can get /foo/b back
1144 * through the v_parent chain (preventing you from getting /tmp/b back). It would
1145 * not fix whether or not you should or should not get /tmp/a vs. /foo/b.
1146 */
1147
1148 error = VNOP_LOOKUP(dp, &ndp->ni_vp, cnp, ctx);
1149
1150 if ( error ) {
1151lookup_error:
1152 if ((error == ENOENT) &&
1153 (dp->v_mount != NULL) &&
1154 (dp->v_mount->mnt_flag & MNT_UNION)) {
1155 tdp = dp;
1156 error = lookup_traverse_union(tdp, &dp, ctx);
1157 vnode_put(tdp);
1158 if (error) {
1159 dp = NULLVP;
1160 goto bad;
1161 }
1162
1163 ndp->ni_dvp = dp;
1164 dp_authorized = 0;
1165 goto unionlookup;
1166 }
1167
1168 if (error != EJUSTRETURN)
1169 goto bad;
1170
1171 if (ndp->ni_vp != NULLVP)
1172 panic("leaf should be empty");
1173
1174#if NAMEDRSRCFORK
1175 /*
1176 * At this point, error should be EJUSTRETURN.
1177 *
1178 * If CN_WANTSRSRCFORK is set, that implies that the
1179 * underlying filesystem could not find the "parent" of the
1180 * resource fork (the data fork), and we are doing a lookup
1181 * for a CREATE event.
1182 *
1183 * However, this should be converted to an error, as the
1184 * failure to find this parent should disallow further
1185 * progress to try and acquire a resource fork vnode.
1186 */
1187 if (cnp->cn_flags & CN_WANTSRSRCFORK) {
1188 error = ENOENT;
1189 goto bad;
1190 }
1191#endif
1192
1193 error = lookup_validate_creation_path(ndp);
1194 if (error)
1195 goto bad;
1196 /*
1197 * We return with ni_vp NULL to indicate that the entry
1198 * doesn't currently exist, leaving a pointer to the
1199 * referenced directory vnode in ndp->ni_dvp.
1200 */
1201 if (cnp->cn_flags & SAVESTART) {
1202 if ( (vnode_get(ndp->ni_dvp)) ) {
1203 error = ENOENT;
1204 goto bad;
1205 }
1206 ndp->ni_startdir = ndp->ni_dvp;
1207 }
1208 if (!wantparent)
1209 vnode_put(ndp->ni_dvp);
1210
1211 if (kdebug_enable)
1212 kdebug_lookup(ndp->ni_dvp, cnp);
1213 return (0);
1214 }
1215returned_from_lookup_path:
1216 /* We'll always have an iocount on ni_vp when this finishes. */
1217 error = lookup_handle_found_vnode(ndp, cnp, rdonly, vbusyflags, &keep_going, nc_generation, wantparent, atroot, ctx);
1218 if (error != 0) {
1219 goto bad2;
1220 }
1221
1222 if (keep_going) {
1223 dp = ndp->ni_vp;
1224
1225 /* namei() will handle symlinks */
1226 if ((dp->v_type == VLNK) &&
1227 ((cnp->cn_flags & FOLLOW) || (ndp->ni_flag & NAMEI_TRAILINGSLASH) || *ndp->ni_next == '/')) {
1228 return 0;
1229 }
1230
1231 /*
1232 * Otherwise, there's more path to process.
1233 * cache_lookup_path is now responsible for dropping io ref on dp
1234 * when it is called again in the dirloop. This ensures we hold
1235 * a ref on dp until we complete the next round of lookup.
1236 */
1237 last_dp = dp;
1238
1239 goto dirloop;
1240 }
1241
1242 return (0);
1243bad2:
1244 if (ndp->ni_dvp)
1245 vnode_put(ndp->ni_dvp);
1246
1247 vnode_put(ndp->ni_vp);
1248 ndp->ni_vp = NULLVP;
1249
1250 if (kdebug_enable)
1251 kdebug_lookup(dp, cnp);
1252 return (error);
1253
1254bad:
1255 if (dp)
1256 vnode_put(dp);
1257 ndp->ni_vp = NULLVP;
1258
1259 if (kdebug_enable)
1260 kdebug_lookup(dp, cnp);
1261 return (error);
1262}
1263
1264/*
1265 * Given a vnode in a union mount, traverse to the equivalent
1266 * vnode in the underlying mount.
1267 */
1268int
1269lookup_traverse_union(vnode_t dvp, vnode_t *new_dvp, vfs_context_t ctx)
1270{
1271 char *path = NULL, *pp;
1272 const char *name, *np;
1273 int len;
1274 int error = 0;
1275 struct nameidata nd;
1276 vnode_t vp = dvp;
1277
1278 *new_dvp = NULL;
1279
1280 if (vp && vp->v_flag & VROOT) {
1281 *new_dvp = vp->v_mount->mnt_vnodecovered;
1282 if (vnode_getwithref(*new_dvp))
1283 return ENOENT;
1284 return 0;
1285 }
1286
1287 path = (char *) kalloc(MAXPATHLEN);
1288 if (path == NULL) {
1289 error = ENOMEM;
1290 goto done;
1291 }
1292
1293 /*
1294 * Walk back up to the mountpoint following the
1295 * v_parent chain and build a slash-separated path.
1296 * Then lookup that path starting with the covered vnode.
1297 */
1298 pp = path + (MAXPATHLEN - 1);
1299 *pp = '\0';
1300
1301 while (1) {
1302 name = vnode_getname(vp);
1303 if (name == NULL) {
1304 printf("lookup_traverse_union: null parent name: .%s\n", pp);
1305 error = ENOENT;
1306 goto done;
1307 }
1308 len = strlen(name);
1309 if ((len + 1) > (pp - path)) { // Enough space for this name ?
1310 error = ENAMETOOLONG;
1311 vnode_putname(name);
1312 goto done;
1313 }
1314 for (np = name + len; len > 0; len--) // Copy name backwards
1315 *--pp = *--np;
1316 vnode_putname(name);
1317 vp = vp->v_parent;
1318 if (vp == NULLVP || vp->v_flag & VROOT)
1319 break;
1320 *--pp = '/';
1321 }
1322
1323 /* Evaluate the path in the underlying mount */
1324 NDINIT(&nd, LOOKUP, OP_LOOKUP, USEDVP, UIO_SYSSPACE, CAST_USER_ADDR_T(pp), ctx);
1325 nd.ni_dvp = dvp->v_mount->mnt_vnodecovered;
1326 error = namei(&nd);
1327 if (error == 0)
1328 *new_dvp = nd.ni_vp;
1329 nameidone(&nd);
1330done:
1331 if (path)
1332 kfree(path, MAXPATHLEN);
1333 return error;
1334}
1335
1336int
1337lookup_validate_creation_path(struct nameidata *ndp)
1338{
1339 struct componentname *cnp = &ndp->ni_cnd;
1340
1341 /*
1342 * If creating and at end of pathname, then can consider
1343 * allowing file to be created.
1344 */
1345 if (cnp->cn_flags & RDONLY) {
1346 return EROFS;
1347 }
1348 if ((cnp->cn_flags & ISLASTCN) && (ndp->ni_flag & NAMEI_TRAILINGSLASH) && !(cnp->cn_flags & WILLBEDIR)) {
1349 return ENOENT;
1350 }
1351
1352 return 0;
1353}
1354
1355/*
1356 * Modifies only ni_vp. Always returns with ni_vp still valid (iocount held).
1357 */
1358static int
1359lookup_traverse_mountpoints(struct nameidata *ndp, struct componentname *cnp, vnode_t dp,
1360 int vbusyflags, vfs_context_t ctx)
1361{
1362 mount_t mp;
1363 vnode_t tdp;
1364 int error = 0;
1365 uint32_t depth = 0;
1366 vnode_t mounted_on_dp;
1367 int current_mount_generation = 0;
1368#if CONFIG_TRIGGERS
1369 vnode_t triggered_dp = NULLVP;
1370 int retry_cnt = 0;
1371#define MAX_TRIGGER_RETRIES 1
1372#endif
1373
1374 if (dp->v_type != VDIR || cnp->cn_flags & NOCROSSMOUNT)
1375 return 0;
1376
1377 mounted_on_dp = dp;
1378#if CONFIG_TRIGGERS
1379restart:
1380#endif
1381 current_mount_generation = mount_generation;
1382
1383 while (dp->v_mountedhere) {
1384 vnode_lock_spin(dp);
1385 if ((mp = dp->v_mountedhere)) {
1386 mp->mnt_crossref++;
1387 vnode_unlock(dp);
1388 } else {
1389 vnode_unlock(dp);
1390 break;
1391 }
1392
1393 if (ISSET(mp->mnt_lflag, MNT_LFORCE)) {
1394 mount_dropcrossref(mp, dp, 0);
1395 break; // don't traverse into a forced unmount
1396 }
1397
1398
1399 if (vfs_busy(mp, vbusyflags)) {
1400 mount_dropcrossref(mp, dp, 0);
1401 if (vbusyflags == LK_NOWAIT) {
1402 error = ENOENT;
1403 goto out;
1404 }
1405
1406 continue;
1407 }
1408
1409 error = VFS_ROOT(mp, &tdp, ctx);
1410
1411 mount_dropcrossref(mp, dp, 0);
1412 vfs_unbusy(mp);
1413
1414 if (error) {
1415 goto out;
1416 }
1417
1418 vnode_put(dp);
1419 ndp->ni_vp = dp = tdp;
1420 if (dp->v_type != VDIR) {
1421#if DEVELOPMENT || DEBUG
1422 panic("%s : Root of filesystem not a directory\n",
1423 __FUNCTION__);
1424#else
1425 break;
1426#endif
1427 }
1428 depth++;
1429 }
1430
1431#if CONFIG_TRIGGERS
1432 /*
1433 * The triggered_dp check here is required but is susceptible to a
1434 * (unlikely) race in which trigger mount is done from here and is
1435 * unmounted before we get past vfs_busy above. We retry to deal with
1436 * that case but it has the side effect of unwanted retries for
1437 * "special" processes which don't want to trigger mounts.
1438 */
1439 if (dp->v_resolve && retry_cnt < MAX_TRIGGER_RETRIES) {
1440 error = vnode_trigger_resolve(dp, ndp, ctx);
1441 if (error)
1442 goto out;
1443 if (dp == triggered_dp)
1444 retry_cnt += 1;
1445 else
1446 retry_cnt = 0;
1447 triggered_dp = dp;
1448 goto restart;
1449 }
1450#endif /* CONFIG_TRIGGERS */
1451
1452 if (depth) {
1453 mp = mounted_on_dp->v_mountedhere;
1454
1455 if (mp) {
1456 mount_lock_spin(mp);
1457 mp->mnt_realrootvp_vid = dp->v_id;
1458 mp->mnt_realrootvp = dp;
1459 mp->mnt_generation = current_mount_generation;
1460 mount_unlock(mp);
1461 }
1462 }
1463
1464 return 0;
1465
1466out:
1467 return error;
1468}
1469
1470/*
1471 * Takes ni_vp and ni_dvp non-NULL. Returns with *new_dp set to the location
1472 * at which to start a lookup with a resolved path, and all other iocounts dropped.
1473 */
1474static int
1475lookup_handle_symlink(struct nameidata *ndp, vnode_t *new_dp, vfs_context_t ctx)
1476{
1477 int error;
1478 char *cp; /* pointer into pathname argument */
1479 uio_t auio;
1480 union {
1481 union {
1482 struct user_iovec s_uiovec;
1483 struct kern_iovec s_kiovec;
1484 } u_iovec;
1485 struct uio s_uio;
1486 char uio_buf[ UIO_SIZEOF(1) ];
1487 } u_uio_buf; /* union only for aligning uio_buf correctly */
1488 int need_newpathbuf;
1489 u_int linklen;
1490 struct componentname *cnp = &ndp->ni_cnd;
1491 vnode_t dp;
1492 char *tmppn;
1493
1494 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
1495 return ELOOP;
1496 }
1497#if CONFIG_MACF
1498 if ((error = mac_vnode_check_readlink(ctx, ndp->ni_vp)) != 0)
1499 return error;
1500#endif /* MAC */
1501 if (ndp->ni_pathlen > 1 || !(cnp->cn_flags & HASBUF))
1502 need_newpathbuf = 1;
1503 else
1504 need_newpathbuf = 0;
1505
1506 if (need_newpathbuf) {
1507 MALLOC_ZONE(cp, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
1508 if (cp == NULL) {
1509 return ENOMEM;
1510 }
1511 } else {
1512 cp = cnp->cn_pnbuf;
1513 }
1514 auio = uio_createwithbuffer(1, 0, UIO_SYSSPACE, UIO_READ,
1515 &u_uio_buf.uio_buf[0], sizeof(u_uio_buf.uio_buf));
1516
1517 uio_addiov(auio, CAST_USER_ADDR_T(cp), MAXPATHLEN);
1518
1519 error = VNOP_READLINK(ndp->ni_vp, auio, ctx);
1520 if (error) {
1521 if (need_newpathbuf)
1522 FREE_ZONE(cp, MAXPATHLEN, M_NAMEI);
1523 return error;
1524 }
1525
1526 /*
1527 * Safe to set unsigned with a [larger] signed type here
1528 * because 0 <= uio_resid <= MAXPATHLEN and MAXPATHLEN
1529 * is only 1024.
1530 */
1531 linklen = MAXPATHLEN - (u_int)uio_resid(auio);
1532 if (linklen + ndp->ni_pathlen > MAXPATHLEN) {
1533 if (need_newpathbuf)
1534 FREE_ZONE(cp, MAXPATHLEN, M_NAMEI);
1535
1536 return ENAMETOOLONG;
1537 }
1538 if (need_newpathbuf) {
1539 long len = cnp->cn_pnlen;
1540
1541 tmppn = cnp->cn_pnbuf;
1542 bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
1543 cnp->cn_pnbuf = cp;
1544 cnp->cn_pnlen = MAXPATHLEN;
1545
1546 if ( (cnp->cn_flags & HASBUF) )
1547 FREE_ZONE(tmppn, len, M_NAMEI);
1548 else
1549 cnp->cn_flags |= HASBUF;
1550 } else
1551 cnp->cn_pnbuf[linklen] = '\0';
1552
1553 ndp->ni_pathlen += linklen;
1554 cnp->cn_nameptr = cnp->cn_pnbuf;
1555
1556 /*
1557 * starting point for 'relative'
1558 * symbolic link path
1559 */
1560 dp = ndp->ni_dvp;
1561
1562 /*
1563 * get rid of references returned via 'lookup'
1564 */
1565 vnode_put(ndp->ni_vp);
1566 vnode_put(ndp->ni_dvp); /* ALWAYS have a dvp for a symlink */
1567
1568 ndp->ni_vp = NULLVP;
1569 ndp->ni_dvp = NULLVP;
1570
1571 /*
1572 * Check if symbolic link restarts us at the root
1573 */
1574 if (*(cnp->cn_nameptr) == '/') {
1575 while (*(cnp->cn_nameptr) == '/') {
1576 cnp->cn_nameptr++;
1577 ndp->ni_pathlen--;
1578 }
1579 if ((dp = ndp->ni_rootdir) == NULLVP) {
1580 return ENOENT;
1581 }
1582 }
1583
1584 *new_dp = dp;
1585
1586 return 0;
1587}
1588
1589/*
1590 * relookup - lookup a path name component
1591 * Used by lookup to re-aquire things.
1592 */
1593int
1594relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
1595{
1596 struct vnode *dp = NULL; /* the directory we are searching */
1597 int wantparent; /* 1 => wantparent or lockparent flag */
1598 int rdonly; /* lookup read-only flag bit */
1599 int error = 0;
1600#ifdef NAMEI_DIAGNOSTIC
1601 int i, newhash; /* DEBUG: check name hash */
1602 char *cp; /* DEBUG: check name ptr/len */
1603#endif
1604 vfs_context_t ctx = cnp->cn_context;;
1605
1606 /*
1607 * Setup: break out flag bits into variables.
1608 */
1609 wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
1610 rdonly = cnp->cn_flags & RDONLY;
1611 cnp->cn_flags &= ~ISSYMLINK;
1612
1613 if (cnp->cn_flags & NOCACHE)
1614 cnp->cn_flags &= ~MAKEENTRY;
1615 else
1616 cnp->cn_flags |= MAKEENTRY;
1617
1618 dp = dvp;
1619
1620 /*
1621 * Check for degenerate name (e.g. / or "")
1622 * which is a way of talking about a directory,
1623 * e.g. like "/." or ".".
1624 */
1625 if (cnp->cn_nameptr[0] == '\0') {
1626 if (cnp->cn_nameiop != LOOKUP || wantparent) {
1627 error = EISDIR;
1628 goto bad;
1629 }
1630 if (dp->v_type != VDIR) {
1631 error = ENOTDIR;
1632 goto bad;
1633 }
1634 if ( (vnode_get(dp)) ) {
1635 error = ENOENT;
1636 goto bad;
1637 }
1638 *vpp = dp;
1639
1640 if (cnp->cn_flags & SAVESTART)
1641 panic("lookup: SAVESTART");
1642 return (0);
1643 }
1644 /*
1645 * We now have a segment name to search for, and a directory to search.
1646 */
1647 if ( (error = VNOP_LOOKUP(dp, vpp, cnp, ctx)) ) {
1648 if (error != EJUSTRETURN)
1649 goto bad;
1650#if DIAGNOSTIC
1651 if (*vpp != NULL)
1652 panic("leaf should be empty");
1653#endif
1654 /*
1655 * If creating and at end of pathname, then can consider
1656 * allowing file to be created.
1657 */
1658 if (rdonly) {
1659 error = EROFS;
1660 goto bad;
1661 }
1662 /*
1663 * We return with ni_vp NULL to indicate that the entry
1664 * doesn't currently exist, leaving a pointer to the
1665 * (possibly locked) directory inode in ndp->ni_dvp.
1666 */
1667 return (0);
1668 }
1669 dp = *vpp;
1670
1671#if DIAGNOSTIC
1672 /*
1673 * Check for symbolic link
1674 */
1675 if (dp->v_type == VLNK && (cnp->cn_flags & FOLLOW))
1676 panic ("relookup: symlink found.\n");
1677#endif
1678
1679 /*
1680 * Disallow directory write attempts on read-only file systems.
1681 */
1682 if (rdonly &&
1683 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
1684 error = EROFS;
1685 goto bad2;
1686 }
1687 /* ASSERT(dvp == ndp->ni_startdir) */
1688
1689 return (0);
1690
1691bad2:
1692 vnode_put(dp);
1693bad:
1694 *vpp = NULL;
1695
1696 return (error);
1697}
1698
1699/*
1700 * Free pathname buffer
1701 */
1702void
1703nameidone(struct nameidata *ndp)
1704{
1705 if (ndp->ni_cnd.cn_flags & HASBUF) {
1706 char *tmp = ndp->ni_cnd.cn_pnbuf;
1707
1708 ndp->ni_cnd.cn_pnbuf = NULL;
1709 ndp->ni_cnd.cn_flags &= ~HASBUF;
1710 FREE_ZONE(tmp, ndp->ni_cnd.cn_pnlen, M_NAMEI);
1711 }
1712}
1713
1714
1715/*
1716 * Log (part of) a pathname using the KERNEL_DEBUG_CONSTANT mechanism, as used
1717 * by fs_usage. The path up to and including the current component name are
1718 * logged. Up to NUMPARMS*4 bytes of pathname will be logged. If the path
1719 * to be logged is longer than that, then the last NUMPARMS*4 bytes are logged.
1720 * That is, the truncation removes the leading portion of the path.
1721 *
1722 * The logging is done via multiple KERNEL_DEBUG_CONSTANT calls. The first one
1723 * is marked with DBG_FUNC_START. The last one is marked with DBG_FUNC_END
1724 * (in addition to DBG_FUNC_START if it is also the first). There may be
1725 * intermediate ones with neither DBG_FUNC_START nor DBG_FUNC_END.
1726 *
1727 * The first KERNEL_DEBUG_CONSTANT passes the vnode pointer and 12 bytes of
1728 * pathname. The remaining KERNEL_DEBUG_CONSTANT calls add 16 bytes of pathname
1729 * each. The minimum number of KERNEL_DEBUG_CONSTANT calls required to pass
1730 * the path are used. Any excess padding in the final KERNEL_DEBUG_CONSTANT
1731 * (because not all of the 12 or 16 bytes are needed for the remainder of the
1732 * path) is set to zero bytes, or '>' if there is more path beyond the
1733 * current component name (usually because an intermediate component was not
1734 * found).
1735 *
1736 * NOTE: If the path length is greater than NUMPARMS*4, or is not of the form
1737 * 12+N*16, there will be no padding.
1738 *
1739 * TODO: If there is more path beyond the current component name, should we
1740 * force some padding? For example, a lookup for /foo_bar_baz/spam that
1741 * fails because /foo_bar_baz is not found will only log "/foo_bar_baz", with
1742 * no '>' padding. But /foo_bar/spam would log "/foo_bar>>>>".
1743 */
1744#if (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST)
1745
1746void
1747kdebug_vfs_lookup(long *dbg_parms, int dbg_namelen, void *dp, uint32_t flags)
1748{
1749 int code;
1750 unsigned int i;
1751 bool lookup = flags & KDBG_VFS_LOOKUP_FLAG_LOOKUP;
1752 bool noprocfilt = flags & KDBG_VFS_LOOKUP_FLAG_NOPROCFILT;
1753
1754 /*
1755 * In the event that we collect multiple, consecutive pathname
1756 * entries, we must mark the start of the path's string and the end.
1757 */
1758 if (lookup) {
1759 code = VFS_LOOKUP | DBG_FUNC_START;
1760 } else {
1761 code = VFS_LOOKUP_DONE | DBG_FUNC_START;
1762 }
1763
1764 if (dbg_namelen <= (int)(3 * sizeof(long)))
1765 code |= DBG_FUNC_END;
1766
1767 if (noprocfilt) {
1768 KDBG_RELEASE_NOPROCFILT(code, kdebug_vnode(dp), dbg_parms[0],
1769 dbg_parms[1], dbg_parms[2]);
1770 } else {
1771 KDBG_RELEASE(code, kdebug_vnode(dp), dbg_parms[0], dbg_parms[1],
1772 dbg_parms[2]);
1773 }
1774
1775 code &= ~DBG_FUNC_START;
1776
1777 for (i=3, dbg_namelen -= (3 * sizeof(long)); dbg_namelen > 0; i+=4, dbg_namelen -= (4 * sizeof(long))) {
1778 if (dbg_namelen <= (int)(4 * sizeof(long)))
1779 code |= DBG_FUNC_END;
1780
1781 if (noprocfilt) {
1782 KDBG_RELEASE_NOPROCFILT(code, dbg_parms[i], dbg_parms[i + 1],
1783 dbg_parms[i + 2], dbg_parms[i + 3]);
1784 } else {
1785 KDBG_RELEASE(code, dbg_parms[i], dbg_parms[i + 1], dbg_parms[i + 2],
1786 dbg_parms[i + 3]);
1787 }
1788 }
1789}
1790
1791void
1792kdebug_lookup_gen_events(long *dbg_parms, int dbg_namelen, void *dp,
1793 boolean_t lookup)
1794{
1795 kdebug_vfs_lookup(dbg_parms, dbg_namelen, dp,
1796 lookup ? KDBG_VFS_LOOKUP_FLAG_LOOKUP : 0);
1797}
1798
1799void
1800kdebug_lookup(vnode_t dp, struct componentname *cnp)
1801{
1802 int dbg_namelen;
1803 char *dbg_nameptr;
1804 long dbg_parms[NUMPARMS];
1805
1806 /* Collect the pathname for tracing */
1807 dbg_namelen = (cnp->cn_nameptr - cnp->cn_pnbuf) + cnp->cn_namelen;
1808 dbg_nameptr = cnp->cn_nameptr + cnp->cn_namelen;
1809
1810 if (dbg_namelen > (int)sizeof(dbg_parms))
1811 dbg_namelen = sizeof(dbg_parms);
1812 dbg_nameptr -= dbg_namelen;
1813
1814 /* Copy the (possibly truncated) path itself */
1815 memcpy(dbg_parms, dbg_nameptr, dbg_namelen);
1816
1817 /* Pad with '\0' or '>' */
1818 if (dbg_namelen < (int)sizeof(dbg_parms)) {
1819 memset((char *)dbg_parms + dbg_namelen,
1820 *(cnp->cn_nameptr + cnp->cn_namelen) ? '>' : 0,
1821 sizeof(dbg_parms) - dbg_namelen);
1822 }
1823 kdebug_vfs_lookup(dbg_parms, dbg_namelen, (void *)dp,
1824 KDBG_VFS_LOOKUP_FLAG_LOOKUP);
1825}
1826
1827#else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST) */
1828
1829void
1830kdebug_vfs_lookup(long *dbg_parms __unused, int dbg_namelen __unused,
1831 void *dp __unused, __unused uint32_t flags)
1832{
1833}
1834
1835static void
1836kdebug_lookup(struct vnode *dp __unused, struct componentname *cnp __unused)
1837{
1838}
1839#endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST) */
1840
1841int
1842vfs_getbyid(fsid_t *fsid, ino64_t ino, vnode_t *vpp, vfs_context_t ctx)
1843{
1844 mount_t mp;
1845 int error;
1846
1847 mp = mount_lookupby_volfsid(fsid->val[0], 1);
1848 if (mp == NULL) {
1849 return EINVAL;
1850 }
1851
1852 /* Get the target vnode. */
1853 if (ino == 2) {
1854 error = VFS_ROOT(mp, vpp, ctx);
1855 } else {
1856 error = VFS_VGET(mp, ino, vpp, ctx);
1857 }
1858
1859 vfs_unbusy(mp);
1860 return error;
1861}
1862/*
1863 * Obtain the real path from a legacy volfs style path.
1864 *
1865 * Valid formats of input path:
1866 *
1867 * "555/@"
1868 * "555/2"
1869 * "555/123456"
1870 * "555/123456/foobar"
1871 *
1872 * Where:
1873 * 555 represents the volfs file system id
1874 * '@' and '2' are aliases to the root of a file system
1875 * 123456 represents a file id
1876 * "foobar" represents a file name
1877 */
1878#if CONFIG_VOLFS
1879static int
1880vfs_getrealpath(const char * path, char * realpath, size_t bufsize, vfs_context_t ctx)
1881{
1882 vnode_t vp;
1883 struct mount *mp = NULL;
1884 char *str;
1885 char ch;
1886 uint32_t id;
1887 ino64_t ino;
1888 int error;
1889 int length;
1890
1891 /* Get file system id and move str to next component. */
1892 id = strtoul(path, &str, 10);
1893 if (id == 0 || str[0] != '/') {
1894 return (EINVAL);
1895 }
1896 while (*str == '/') {
1897 str++;
1898 }
1899 ch = *str;
1900
1901 mp = mount_lookupby_volfsid(id, 1);
1902 if (mp == NULL) {
1903 return (EINVAL); /* unexpected failure */
1904 }
1905 /* Check for an alias to a file system root. */
1906 if (ch == '@' && str[1] == '\0') {
1907 ino = 2;
1908 str++;
1909 } else {
1910 /* Get file id and move str to next component. */
1911 ino = strtouq(str, &str, 10);
1912 }
1913
1914 /* Get the target vnode. */
1915 if (ino == 2) {
1916 error = VFS_ROOT(mp, &vp, ctx);
1917 } else {
1918 error = VFS_VGET(mp, ino, &vp, ctx);
1919 }
1920 vfs_unbusy(mp);
1921 if (error) {
1922 goto out;
1923 }
1924 realpath[0] = '\0';
1925
1926 /* Get the absolute path to this vnode. */
1927 error = build_path(vp, realpath, bufsize, &length, 0, ctx);
1928 vnode_put(vp);
1929
1930 if (error == 0 && *str != '\0') {
1931 int attempt = strlcat(realpath, str, MAXPATHLEN);
1932 if (attempt > MAXPATHLEN){
1933 error = ENAMETOOLONG;
1934 }
1935 }
1936out:
1937 return (error);
1938}
1939#endif
1940
1941void
1942lookup_compound_vnop_post_hook(int error, vnode_t dvp, vnode_t vp, struct nameidata *ndp, int did_create)
1943{
1944 if (error == 0 && vp == NULLVP) {
1945 panic("NULL vp with error == 0.\n");
1946 }
1947
1948 /*
1949 * We don't want to do any of this if we didn't use the compound vnop
1950 * to perform the lookup... i.e. if we're allowing and using the legacy pattern,
1951 * where we did a full lookup.
1952 */
1953 if ((ndp->ni_flag & NAMEI_COMPOUND_OP_MASK) == 0) {
1954 return;
1955 }
1956
1957 /*
1958 * If we're going to continue the lookup, we'll handle
1959 * all lookup-related updates at that time.
1960 */
1961 if (error == EKEEPLOOKING) {
1962 return;
1963 }
1964
1965 /*
1966 * Only audit or update cache for *found* vnodes. For creation
1967 * neither would happen in the non-compound-vnop case.
1968 */
1969 if ((vp != NULLVP) && !did_create) {
1970 /*
1971 * If MAKEENTRY isn't set, and we've done a successful compound VNOP,
1972 * then we certainly don't want to update cache or identity.
1973 */
1974 if ((error != 0) || (ndp->ni_cnd.cn_flags & MAKEENTRY)) {
1975 lookup_consider_update_cache(dvp, vp, &ndp->ni_cnd, ndp->ni_ncgeneration);
1976 }
1977 if (ndp->ni_cnd.cn_flags & AUDITVNPATH1)
1978 AUDIT_ARG(vnpath, vp, ARG_VNODE1);
1979 else if (ndp->ni_cnd.cn_flags & AUDITVNPATH2)
1980 AUDIT_ARG(vnpath, vp, ARG_VNODE2);
1981 }
1982
1983 /*
1984 * If you created (whether you opened or not), cut a lookup tracepoint
1985 * for the parent dir (as would happen without a compound vnop). Note: we may need
1986 * a vnode despite failure in this case!
1987 *
1988 * If you did not create:
1989 * Found child (succeeded or not): cut a tracepoint for the child.
1990 * Did not find child: cut a tracepoint with the parent.
1991 */
1992 if (kdebug_enable) {
1993 kdebug_lookup(vp ? vp : dvp, &ndp->ni_cnd);
1994 }
1995}
1996