2 * Copyright (c) 2000-2015 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
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.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
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.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
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.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
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.
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
66 * @(#)vfs_lookup.c 8.10 (Berkeley) 5/27/95
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,
75 #include <sys/param.h>
76 #include <sys/systm.h>
77 #include <sys/syslimits.h>
79 #include <sys/namei.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 */
95 #include <security/mac_framework.h>
99 #include <sys/xattr.h>
102 * The minimum volfs-style pathname is 9.
103 * Example: "/.vol/1/2"
105 #define VOLFS_MIN_PATH_LEN 9
108 static void kdebug_lookup(struct vnode
*dp
, struct componentname
*cnp
);
111 static int vfs_getrealpath(const char * path
, char * realpath
, size_t bufsize
, vfs_context_t ctx
);
112 #define MAX_VOLFS_RESTARTS 5
115 static int lookup_traverse_mountpoints(struct nameidata
*ndp
, struct componentname
*cnp
, vnode_t dp
, int vbusyflags
, vfs_context_t ctx
);
116 static int lookup_handle_symlink(struct nameidata
*ndp
, vnode_t
*new_dp
, vfs_context_t ctx
);
117 static int lookup_authorize_search(vnode_t dp
, struct componentname
*cnp
, int dp_authorized_in_cache
, vfs_context_t ctx
);
118 static void lookup_consider_update_cache(vnode_t dvp
, vnode_t vp
, struct componentname
*cnp
, int nc_generation
);
119 static int lookup_handle_found_vnode(struct nameidata
*ndp
, struct componentname
*cnp
, int rdonly
,
120 int vbusyflags
, int *keep_going
, int nc_generation
,
121 int wantparent
, int atroot
, vfs_context_t ctx
);
122 static int lookup_handle_emptyname(struct nameidata
*ndp
, struct componentname
*cnp
, int wantparent
);
125 static int lookup_handle_rsrc_fork(vnode_t dp
, struct nameidata
*ndp
, struct componentname
*cnp
, int wantparent
, vfs_context_t ctx
);
131 * Convert a pathname into a pointer to a locked inode.
133 * The FOLLOW flag is set when symbolic links are to be followed
134 * when they occur at the end of the name translation process.
135 * Symbolic links are always followed for all other pathname
136 * components other than the last.
138 * The segflg defines whether the name is to be copied from user
139 * space or kernel space.
141 * Overall outline of namei:
144 * get starting directory
145 * while (!done && !error) {
146 * call lookup to search path.
147 * if symbolic link, massage name in buffer and continue
151 * ENOENT No such file or directory
152 * ELOOP Too many levels of symbolic links
153 * ENAMETOOLONG Filename too long
154 * copyinstr:EFAULT Bad address
155 * copyinstr:ENAMETOOLONG Filename too long
156 * lookup:EBADF Bad file descriptor
160 * lookup:ERECYCLE vnode was recycled from underneath us in lookup.
161 * This means we should re-drive lookup from this point.
166 namei(struct nameidata
*ndp
)
168 struct filedesc
*fdp
; /* pointer to file descriptor state */
169 struct vnode
*dp
; /* the directory we are searching */
170 struct vnode
*usedvp
= ndp
->ni_dvp
; /* store pointer to vp in case we must loop due to
171 heavy vnode pressure */
172 u_long cnpflags
= ndp
->ni_cnd
.cn_flags
; /* store in case we have to restore after loop */
174 struct componentname
*cnp
= &ndp
->ni_cnd
;
175 vfs_context_t ctx
= cnp
->cn_context
;
176 proc_t p
= vfs_context_proc(ctx
);
178 /* XXX ut should be from context */
179 uthread_t ut
= (struct uthread
*)get_bsdthread_info(current_thread());
183 int volfs_restarts
= 0;
185 size_t bytes_copied
= 0;
190 if (!vfs_context_ucred(ctx
) || !p
)
191 panic ("namei: bad cred/proc");
192 if (cnp
->cn_nameiop
& (~OPMASK
))
193 panic ("namei: nameiop contaminated with flags");
194 if (cnp
->cn_flags
& OPMASK
)
195 panic ("namei: flags contaminated with nameiops");
199 * A compound VNOP found something that needs further processing:
200 * either a trigger vnode, a covered directory, or a symlink.
202 if (ndp
->ni_flag
& NAMEI_CONTLOOKUP
) {
203 int rdonly
, vbusyflags
, keep_going
, wantparent
;
205 rdonly
= cnp
->cn_flags
& RDONLY
;
206 vbusyflags
= ((cnp
->cn_flags
& CN_NBMOUNTLOOK
) != 0) ? LK_NOWAIT
: 0;
208 wantparent
= cnp
->cn_flags
& (LOCKPARENT
| WANTPARENT
);
210 ndp
->ni_flag
&= ~(NAMEI_CONTLOOKUP
);
212 error
= lookup_handle_found_vnode(ndp
, &ndp
->ni_cnd
, rdonly
, vbusyflags
,
213 &keep_going
, ndp
->ni_ncgeneration
, wantparent
, 0, ctx
);
217 if ((cnp
->cn_flags
& ISSYMLINK
) == 0) {
218 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
);
220 goto continue_symlink
;
230 * Get a buffer for the name to be translated, and copy the
231 * name into the buffer.
233 if ((cnp
->cn_flags
& HASBUF
) == 0) {
234 cnp
->cn_pnbuf
= ndp
->ni_pathbuf
;
235 cnp
->cn_pnlen
= PATHBUFLEN
;
238 if ((UIO_SEG_IS_USER_SPACE(ndp
->ni_segflg
) == 0)
239 && (ndp
->ni_segflg
!= UIO_SYSSPACE
)
240 && (ndp
->ni_segflg
!= UIO_SYSSPACE32
)) {
241 panic("%s :%d - invalid ni_segflg\n", __FILE__
, __LINE__
);
243 #endif /* LP64_DEBUG */
246 if (UIO_SEG_IS_USER_SPACE(ndp
->ni_segflg
)) {
247 error
= copyinstr(ndp
->ni_dirp
, cnp
->cn_pnbuf
,
248 cnp
->cn_pnlen
, &bytes_copied
);
250 error
= copystr(CAST_DOWN(void *, ndp
->ni_dirp
), cnp
->cn_pnbuf
,
251 cnp
->cn_pnlen
, &bytes_copied
);
253 if (error
== ENAMETOOLONG
&& !(cnp
->cn_flags
& HASBUF
)) {
254 MALLOC_ZONE(cnp
->cn_pnbuf
, caddr_t
, MAXPATHLEN
, M_NAMEI
, M_WAITOK
);
255 if (cnp
->cn_pnbuf
== NULL
) {
260 cnp
->cn_flags
|= HASBUF
;
261 cnp
->cn_pnlen
= MAXPATHLEN
;
268 ndp
->ni_pathlen
= bytes_copied
;
272 * Since the name cache may contain positive entries of
273 * the incorrect case, force lookup() to bypass the cache
274 * and call directly into the filesystem for each path
275 * component. Note: the FS may still consult the cache,
276 * but can apply rules to validate the results.
278 if (proc_is_forcing_hfs_case_sensitivity(p
))
279 cnp
->cn_flags
|= CN_SKIPNAMECACHE
;
283 * Check for legacy volfs style pathnames.
285 * For compatibility reasons we currently allow these paths,
286 * but future versions of the OS may not support them.
288 if (ndp
->ni_pathlen
>= VOLFS_MIN_PATH_LEN
&&
289 cnp
->cn_pnbuf
[0] == '/' &&
290 cnp
->cn_pnbuf
[1] == '.' &&
291 cnp
->cn_pnbuf
[2] == 'v' &&
292 cnp
->cn_pnbuf
[3] == 'o' &&
293 cnp
->cn_pnbuf
[4] == 'l' &&
294 cnp
->cn_pnbuf
[5] == '/' ) {
297 /* Attempt to resolve a legacy volfs style pathname. */
298 MALLOC_ZONE(realpath
, caddr_t
, MAXPATHLEN
, M_NAMEI
, M_WAITOK
);
301 * We only error out on the ENAMETOOLONG cases where we know that
302 * vfs_getrealpath translation succeeded but the path could not fit into
303 * MAXPATHLEN characters. In other failure cases, we may be dealing with a path
304 * that legitimately looks like /.vol/1234/567 and is not meant to be translated
306 if ((realpath_err
= vfs_getrealpath(&cnp
->cn_pnbuf
[6], realpath
, MAXPATHLEN
, ctx
))) {
307 FREE_ZONE(realpath
, MAXPATHLEN
, M_NAMEI
);
308 if (realpath_err
== ENOSPC
|| realpath_err
== ENAMETOOLONG
){
309 error
= ENAMETOOLONG
;
313 if (cnp
->cn_flags
& HASBUF
) {
314 FREE_ZONE(cnp
->cn_pnbuf
, cnp
->cn_pnlen
, M_NAMEI
);
316 cnp
->cn_pnbuf
= realpath
;
317 cnp
->cn_pnlen
= MAXPATHLEN
;
318 ndp
->ni_pathlen
= strlen(realpath
) + 1;
319 cnp
->cn_flags
|= HASBUF
| CN_VOLFSPATH
;
323 #endif /* CONFIG_VOLFS */
326 /* If we are auditing the kernel pathname, save the user pathname */
327 if (cnp
->cn_flags
& AUDITVNPATH1
)
328 AUDIT_ARG(upath
, ut
->uu_cdir
, cnp
->cn_pnbuf
, ARG_UPATH1
);
329 if (cnp
->cn_flags
& AUDITVNPATH2
)
330 AUDIT_ARG(upath
, ut
->uu_cdir
, cnp
->cn_pnbuf
, ARG_UPATH2
);
331 #endif /* CONFIG_AUDIT */
334 * Do not allow empty pathnames
336 if (*cnp
->cn_pnbuf
== '\0') {
343 * determine the starting point for the translation.
345 if ((ndp
->ni_rootdir
= fdp
->fd_rdir
) == NULLVP
) {
346 if ( !(fdp
->fd_flags
& FD_CHROOT
))
347 ndp
->ni_rootdir
= rootvnode
;
349 cnp
->cn_nameptr
= cnp
->cn_pnbuf
;
351 ndp
->ni_usedvp
= NULLVP
;
353 if (*(cnp
->cn_nameptr
) == '/') {
354 while (*(cnp
->cn_nameptr
) == '/') {
358 dp
= ndp
->ni_rootdir
;
359 } else if (cnp
->cn_flags
& USEDVP
) {
363 dp
= vfs_context_cwd(ctx
);
365 if (dp
== NULLVP
|| (dp
->v_lflag
& VL_DEAD
)) {
369 ndp
->ni_dvp
= NULLVP
;
375 * Give MACF policies a chance to reject the lookup
376 * before performing any filesystem operations.
377 * This hook is called before resolving the path and
378 * again each time a symlink is encountered.
379 * NB: policies receive path information as supplied
380 * by the caller and thus cannot be trusted.
382 error
= mac_vnode_check_lookup_preflight(ctx
, dp
, cnp
->cn_nameptr
, cnp
->cn_namelen
);
388 ndp
->ni_startdir
= dp
;
390 if ( (error
= lookup(ndp
)) ) {
395 * Check for symbolic link
397 if ((cnp
->cn_flags
& ISSYMLINK
) == 0) {
402 /* Gives us a new path to process, and a starting dir */
403 error
= lookup_handle_symlink(ndp
, &dp
, ctx
);
409 * only come here if we fail to handle a SYMLINK...
410 * if either ni_dvp or ni_vp is non-NULL, then
411 * we need to drop the iocount that was picked
412 * up in the lookup routine
416 vnode_put(ndp
->ni_dvp
);
418 vnode_put(ndp
->ni_vp
);
420 if ( (cnp
->cn_flags
& HASBUF
) ) {
421 cnp
->cn_flags
&= ~HASBUF
;
422 FREE_ZONE(cnp
->cn_pnbuf
, cnp
->cn_pnlen
, M_NAMEI
);
424 cnp
->cn_pnbuf
= NULL
;
426 ndp
->ni_dvp
= NULLVP
;
430 * Deal with volfs fallout.
432 * At this point, if we were originally given a volfs path that
433 * looks like /.vol/123/456, then we would have had to convert it into
434 * a full path. Assuming that part worked properly, we will now attempt
435 * to conduct a lookup of the item in the namespace. Under normal
436 * circumstances, if a user looked up /tmp/foo and it was not there, it
437 * would be permissible to return ENOENT.
439 * However, we may not want to do that here. Specifically, the volfs path
440 * uniquely identifies a certain item in the namespace regardless of where it
441 * lives. If the item has moved in between the time we constructed the
442 * path and now, when we're trying to do a lookup/authorization on the full
443 * path, we may have gotten an ENOENT.
445 * At this point we can no longer tell if the path no longer exists
446 * or if the item in question no longer exists. It could have been renamed
447 * away, in which case the /.vol identifier is still valid.
449 * Do this dance a maximum of MAX_VOLFS_RESTARTS times.
451 if ((error
== ENOENT
) && (ndp
->ni_cnd
.cn_flags
& CN_VOLFSPATH
)) {
452 if (volfs_restarts
< MAX_VOLFS_RESTARTS
) {
459 if (error
== ERECYCLE
){
460 /* vnode was recycled underneath us. re-drive lookup to start at
461 the beginning again, since recycling invalidated last lookup*/
462 ndp
->ni_cnd
.cn_flags
= cnpflags
;
463 ndp
->ni_dvp
= usedvp
;
472 namei_compound_available(vnode_t dp
, struct nameidata
*ndp
)
474 if ((ndp
->ni_flag
& NAMEI_COMPOUNDOPEN
) != 0) {
475 return vnode_compound_open_available(dp
);
482 lookup_authorize_search(vnode_t dp
, struct componentname
*cnp
, int dp_authorized_in_cache
, vfs_context_t ctx
)
490 if (!dp_authorized_in_cache
) {
491 error
= vnode_authorize(dp
, NULL
, KAUTH_VNODE_SEARCH
, ctx
);
496 error
= mac_vnode_check_lookup(ctx
, dp
, cnp
);
499 #endif /* CONFIG_MACF */
505 lookup_consider_update_cache(vnode_t dvp
, vnode_t vp
, struct componentname
*cnp
, int nc_generation
)
508 isdot_or_dotdot
= (cnp
->cn_namelen
== 1 && cnp
->cn_nameptr
[0] == '.') || (cnp
->cn_flags
& ISDOTDOT
);
510 if (vp
->v_name
== NULL
|| vp
->v_parent
== NULLVP
) {
511 int update_flags
= 0;
513 if (isdot_or_dotdot
== 0) {
514 if (vp
->v_name
== NULL
)
515 update_flags
|= VNODE_UPDATE_NAME
;
516 if (dvp
!= NULLVP
&& vp
->v_parent
== NULLVP
)
517 update_flags
|= VNODE_UPDATE_PARENT
;
520 vnode_update_identity(vp
, dvp
, cnp
->cn_nameptr
, cnp
->cn_namelen
, cnp
->cn_hash
, update_flags
);
523 if ( (cnp
->cn_flags
& MAKEENTRY
) && (vp
->v_flag
& VNCACHEABLE
) && LIST_FIRST(&vp
->v_nclinks
) == NULL
) {
525 * missing from name cache, but should
526 * be in it... this can happen if volfs
527 * causes the vnode to be created or the
528 * name cache entry got recycled but the
530 * check to make sure that ni_dvp is valid
531 * cache_lookup_path may return a NULL
532 * do a quick check to see if the generation of the
533 * directory matches our snapshot... this will get
534 * rechecked behind the name cache lock, but if it
535 * already fails to match, no need to go any further
537 if (dvp
!= NULLVP
&& (nc_generation
== dvp
->v_nc_generation
) && (!isdot_or_dotdot
))
538 cache_enter_with_gen(dvp
, vp
, cnp
, nc_generation
);
545 * Can change ni_dvp and ni_vp. On success, returns with iocounts on stream vnode (always) and
546 * data fork if requested. On failure, returns with iocount data fork (always) and its parent directory
547 * (if one was provided).
550 lookup_handle_rsrc_fork(vnode_t dp
, struct nameidata
*ndp
, struct componentname
*cnp
, int wantparent
, vfs_context_t ctx
)
552 vnode_t svp
= NULLVP
;
553 enum nsoperation nsop
;
557 if (dp
->v_type
!= VREG
) {
561 switch (cnp
->cn_nameiop
) {
563 if (cnp
->cn_flags
& CN_ALLOWRSRCFORK
) {
571 if (cnp
->cn_flags
& CN_ALLOWRSRCFORK
) {
579 /* Make sure our lookup of "/..namedfork/rsrc" is allowed. */
580 if (cnp
->cn_flags
& CN_ALLOWRSRCFORK
) {
593 if (cnp
->cn_flags
& CN_RAW_ENCRYPTED
)
594 nsflags
|= NS_GETRAWENCRYPTED
;
596 /* Ask the file system for the resource fork. */
597 error
= vnode_getnamedstream(dp
, &svp
, XATTR_RESOURCEFORK_NAME
, nsop
, nsflags
, ctx
);
599 /* During a create, it OK for stream vnode to be missing. */
600 if (error
== ENOATTR
|| error
== ENOENT
) {
601 error
= (nsop
== NS_CREATE
) ? 0 : ENOENT
;
606 /* The "parent" of the stream is the file. */
609 vnode_put(ndp
->ni_dvp
);
615 ndp
->ni_vp
= svp
; /* on create this may be null */
617 /* Restore the truncated pathname buffer (for audits). */
618 if (ndp
->ni_pathlen
== 1 && ndp
->ni_next
[0] == '\0') {
619 ndp
->ni_next
[0] = '/';
621 cnp
->cn_flags
&= ~MAKEENTRY
;
627 #endif /* NAMEDRSRCFORK */
631 * --One on ni_vp. One on ni_dvp if there is more path, or we didn't come through the
632 * cache, or we came through the cache and the caller doesn't want the parent.
635 * --Leaves us in the correct state for the next step, whatever that might be.
636 * --If we find a symlink, returns with iocounts on both ni_vp and ni_dvp.
637 * --If we are to look up another component, then we have an iocount on ni_vp and
639 * --If we are done, returns an iocount on ni_vp, and possibly on ni_dvp depending on nameidata flags.
640 * --In the event of an error, may return with ni_dvp NULL'ed out (in which case, iocount
644 lookup_handle_found_vnode(struct nameidata
*ndp
, struct componentname
*cnp
, int rdonly
,
645 int vbusyflags
, int *keep_going
, int nc_generation
,
646 int wantparent
, int atroot
, vfs_context_t ctx
)
655 if (ndp
->ni_vp
== NULLVP
) {
656 panic("NULL ni_vp in %s\n", __FUNCTION__
);
664 * Take into account any additional components consumed by
665 * the underlying filesystem.
667 if (cnp
->cn_consume
> 0) {
668 cnp
->cn_nameptr
+= cnp
->cn_consume
;
669 ndp
->ni_next
+= cnp
->cn_consume
;
670 ndp
->ni_pathlen
-= cnp
->cn_consume
;
673 lookup_consider_update_cache(ndp
->ni_dvp
, dp
, cnp
, nc_generation
);
677 * Check to see if the vnode has been mounted on...
678 * if so find the root of the mounted file system.
679 * Updates ndp->ni_vp.
681 error
= lookup_traverse_mountpoints(ndp
, cnp
, dp
, vbusyflags
, ctx
);
688 if (vfs_flags(vnode_mount(dp
)) & MNT_MULTILABEL
) {
689 error
= vnode_label(vnode_mount(dp
), NULL
, dp
, NULL
, 0, ctx
);
696 * Check for symbolic link
698 if ((dp
->v_type
== VLNK
) &&
699 ((cnp
->cn_flags
& FOLLOW
) || (ndp
->ni_flag
& NAMEI_TRAILINGSLASH
) || *ndp
->ni_next
== '/')) {
700 cnp
->cn_flags
|= ISSYMLINK
;
706 * Check for bogus trailing slashes.
708 if ((ndp
->ni_flag
& NAMEI_TRAILINGSLASH
)) {
709 if (dp
->v_type
!= VDIR
) {
713 ndp
->ni_flag
&= ~(NAMEI_TRAILINGSLASH
);
718 * Deny namei/lookup requests to resolve paths that point to shadow files.
719 * Access to shadow files must be conducted by explicit calls to VNOP_LOOKUP
720 * directly, and not use lookup/namei
722 if (vnode_isshadow (dp
)) {
730 * Not a symbolic link. If more pathname,
731 * continue at next component, else return.
733 * Definitely have a dvp if there's another slash
735 if (*ndp
->ni_next
== '/') {
736 cnp
->cn_nameptr
= ndp
->ni_next
+ 1;
738 while (*cnp
->cn_nameptr
== '/') {
743 cp
= cnp
->cn_nameptr
;
744 vnode_put(ndp
->ni_dvp
);
745 ndp
->ni_dvp
= NULLVP
;
756 * Disallow directory write attempts on read-only file systems.
759 (cnp
->cn_nameiop
== DELETE
|| cnp
->cn_nameiop
== RENAME
)) {
764 /* If SAVESTART is set, we should have a dvp */
765 if (cnp
->cn_flags
& SAVESTART
) {
767 * note that we already hold a reference
768 * on both dp and ni_dvp, but for some reason
769 * can't get another one... in this case we
770 * need to do vnode_put on dp in 'bad2'
772 if ( (vnode_get(ndp
->ni_dvp
)) ) {
776 ndp
->ni_startdir
= ndp
->ni_dvp
;
778 if (!wantparent
&& ndp
->ni_dvp
) {
779 vnode_put(ndp
->ni_dvp
);
780 ndp
->ni_dvp
= NULLVP
;
783 if (cnp
->cn_flags
& AUDITVNPATH1
)
784 AUDIT_ARG(vnpath
, dp
, ARG_VNODE1
);
785 else if (cnp
->cn_flags
& AUDITVNPATH2
)
786 AUDIT_ARG(vnpath
, dp
, ARG_VNODE2
);
790 * Caller wants the resource fork.
792 if ((cnp
->cn_flags
& CN_WANTSRSRCFORK
) && (dp
!= NULLVP
)) {
793 error
= lookup_handle_rsrc_fork(dp
, ndp
, cnp
, wantparent
, ctx
);
801 kdebug_lookup(ndp
->ni_vp
, cnp
);
806 error
= lookup_handle_emptyname(ndp
, cnp
, wantparent
);
817 * Comes in iocount on ni_vp. May overwrite ni_dvp, but doesn't interpret incoming value.
820 lookup_handle_emptyname(struct nameidata
*ndp
, struct componentname
*cnp
, int wantparent
)
828 * A degenerate name (e.g. / or "") which is a way of
829 * talking about a directory, e.g. like "/." or ".".
831 if (dp
->v_type
!= VDIR
) {
835 if (cnp
->cn_nameiop
!= LOOKUP
) {
841 * note that we already hold a reference
842 * on dp, but for some reason can't
843 * get another one... in this case we
844 * need to do vnode_put on dp in 'bad'
846 if ( (vnode_get(dp
)) ) {
852 cnp
->cn_flags
&= ~ISDOTDOT
;
853 cnp
->cn_flags
|= ISLASTCN
;
854 ndp
->ni_next
= cnp
->cn_nameptr
;
857 if (cnp
->cn_flags
& AUDITVNPATH1
)
858 AUDIT_ARG(vnpath
, dp
, ARG_VNODE1
);
859 else if (cnp
->cn_flags
& AUDITVNPATH2
)
860 AUDIT_ARG(vnpath
, dp
, ARG_VNODE2
);
861 if (cnp
->cn_flags
& SAVESTART
)
862 panic("lookup: SAVESTART");
870 * This is a very central and rather complicated routine.
872 * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
873 * The starting directory is taken from ni_startdir. The pathname is
874 * descended until done, or a symbolic link is encountered. The variable
875 * ni_more is clear if the path is completed; it is set to one if a
876 * symbolic link needing interpretation is encountered.
878 * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
879 * whether the name is to be looked up, created, renamed, or deleted.
880 * When CREATE, RENAME, or DELETE is specified, information usable in
881 * creating, renaming, or deleting a directory entry may be calculated.
882 * If flag has LOCKPARENT or'ed into it, the parent directory is returned
883 * locked. If flag has WANTPARENT or'ed into it, the parent directory is
884 * returned unlocked. Otherwise the parent directory is not returned. If
885 * the target of the pathname exists and LOCKLEAF is or'ed into the flag
886 * the target is returned locked, otherwise it is returned unlocked.
887 * When creating or renaming and LOCKPARENT is specified, the target may not
888 * be ".". When deleting and LOCKPARENT is specified, the target may be ".".
890 * Overall outline of lookup:
893 * identify next component of name at ndp->ni_ptr
894 * handle degenerate case where name is null string
895 * if .. and crossing mount points and on mounted filesys, find parent
896 * call VNOP_LOOKUP routine for next component name
897 * directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
898 * component vnode returned in ni_vp (if it exists), locked.
899 * if result vnode is mounted on and crossing mount points,
900 * find mounted on vnode
901 * if more components of name, do next level at dirloop
902 * return the answer in ni_vp, locked if LOCKLEAF set
903 * if LOCKPARENT set, return locked parent in ni_dvp
904 * if WANTPARENT set, return unlocked parent in ni_dvp
907 * ENOENT No such file or directory
908 * EBADF Bad file descriptor
909 * ENOTDIR Not a directory
910 * EROFS Read-only file system [CREATE]
911 * EISDIR Is a directory [CREATE]
912 * cache_lookup_path:ERECYCLE (vnode was recycled from underneath us, redrive lookup again)
913 * vnode_authorize:EROFS
914 * vnode_authorize:EACCES
915 * vnode_authorize:EPERM
916 * vnode_authorize:???
917 * VNOP_LOOKUP:ENOENT No such file or directory
918 * VNOP_LOOKUP:EJUSTRETURN Restart system call (INTERNAL)
925 lookup(struct nameidata
*ndp
)
927 char *cp
; /* pointer into pathname argument */
928 vnode_t tdp
; /* saved dp */
929 vnode_t dp
; /* the directory we are searching */
930 int docache
= 1; /* == 0 do not cache last component */
931 int wantparent
; /* 1 => wantparent or lockparent flag */
932 int rdonly
; /* lookup read-only flag bit */
933 int dp_authorized
= 0;
935 struct componentname
*cnp
= &ndp
->ni_cnd
;
936 vfs_context_t ctx
= cnp
->cn_context
;
938 int nc_generation
= 0;
939 vnode_t last_dp
= NULLVP
;
944 * Setup: break out flag bits into variables.
946 if (cnp
->cn_flags
& NOCACHE
) {
949 wantparent
= cnp
->cn_flags
& (LOCKPARENT
| WANTPARENT
);
950 rdonly
= cnp
->cn_flags
& RDONLY
;
951 cnp
->cn_flags
&= ~ISSYMLINK
;
954 dp
= ndp
->ni_startdir
;
955 ndp
->ni_startdir
= NULLVP
;
957 if ((cnp
->cn_flags
& CN_NBMOUNTLOOK
) != 0)
958 vbusyflags
= LK_NOWAIT
;
959 cp
= cnp
->cn_nameptr
;
962 if ( (vnode_getwithref(dp
)) ) {
968 error
= lookup_handle_emptyname(ndp
, cnp
, wantparent
);
979 if ( (error
= cache_lookup_path(ndp
, cnp
, dp
, ctx
, &dp_authorized
, last_dp
)) ) {
983 if ((cnp
->cn_flags
& ISLASTCN
)) {
985 cnp
->cn_flags
|= MAKEENTRY
;
987 cnp
->cn_flags
|= MAKEENTRY
;
991 if (ndp
->ni_vp
!= NULLVP
) {
993 * cache_lookup_path returned a non-NULL ni_vp then,
994 * we're guaranteed that the dp is a VDIR, it's
995 * been authorized, and vp is not ".."
997 * make sure we don't try to enter the name back into
998 * the cache if this vp is purged before we get to that
999 * check since we won't have serialized behind whatever
1000 * activity is occurring in the FS that caused the purge
1003 nc_generation
= dp
->v_nc_generation
- 1;
1005 goto returned_from_lookup_path
;
1009 * Handle "..": two special cases.
1010 * 1. If at root directory (e.g. after chroot)
1011 * or at absolute root directory
1012 * then ignore it so can't get out.
1013 * 2. If this vnode is the root of a mounted
1014 * filesystem, then replace it with the
1015 * vnode which was mounted on so we take the
1016 * .. in the other file system.
1018 if ( (cnp
->cn_flags
& ISDOTDOT
) ) {
1020 * if this is a chroot'ed process, check if the current
1021 * directory is still a subdirectory of the process's
1024 if (ndp
->ni_rootdir
&& (ndp
->ni_rootdir
!= rootvnode
) &&
1025 dp
!= ndp
->ni_rootdir
) {
1027 int is_subdir
= FALSE
;
1029 sdir_error
= vnode_issubdir(dp
, ndp
->ni_rootdir
,
1030 &is_subdir
, vfs_context_kernel());
1033 * If we couldn't determine if dp is a subdirectory of
1034 * ndp->ni_rootdir (sdir_error != 0), we let the request
1037 if (!sdir_error
&& !is_subdir
) {
1039 dp
= ndp
->ni_rootdir
;
1041 * There's a ref on the process's root directory
1042 * but we can't use vnode_getwithref here as
1043 * there is nothing preventing that ref being
1044 * released by another thread.
1046 if (vnode_get(dp
)) {
1054 if (dp
== ndp
->ni_rootdir
|| dp
== rootvnode
) {
1058 * we're pinned at the root
1059 * we've already got one reference on 'dp'
1060 * courtesy of cache_lookup_path... take
1061 * another one for the ".."
1062 * if we fail to get the new reference, we'll
1063 * drop our original down in 'bad'
1065 if ( (vnode_get(dp
)) ) {
1070 goto returned_from_lookup_path
;
1072 if ((dp
->v_flag
& VROOT
) == 0 ||
1073 (cnp
->cn_flags
& NOCROSSMOUNT
))
1075 if (dp
->v_mount
== NULL
) { /* forced umount */
1080 dp
= tdp
->v_mount
->mnt_vnodecovered
;
1084 if ( (vnode_getwithref(dp
)) ) {
1095 * We now have a segment name to search for, and a directory to search.
1098 ndp
->ni_vp
= NULLVP
;
1100 if (dp
->v_type
!= VDIR
) {
1104 if ( (cnp
->cn_flags
& DONOTAUTH
) != DONOTAUTH
) {
1105 error
= lookup_authorize_search(dp
, cnp
, dp_authorized
, ctx
);
1112 * Now that we've authorized a lookup, can bail out if the filesystem
1113 * will be doing a batched operation. Return an iocount on dvp.
1116 if ((cnp
->cn_flags
& ISLASTCN
) && namei_compound_available(dp
, ndp
) && !(cnp
->cn_flags
& CN_WANTSRSRCFORK
)) {
1118 if ((cnp
->cn_flags
& ISLASTCN
) && namei_compound_available(dp
, ndp
)) {
1119 #endif /* NAMEDRSRCFORK */
1120 ndp
->ni_flag
|= NAMEI_UNFINISHED
;
1121 ndp
->ni_ncgeneration
= dp
->v_nc_generation
;
1125 nc_generation
= dp
->v_nc_generation
;
1129 * Filesystems that support hardlinks may want to call vnode_update_identity
1130 * if the lookup operation below will modify the in-core vnode to belong to a new point
1131 * in the namespace. VFS cannot infer whether or not the look up operation makes the vnode
1132 * name change or change parents. Without this, the lookup may make update
1133 * filesystem-specific in-core metadata but fail to update the v_parent or v_name
1134 * fields in the vnode. If VFS were to do this, it would be necessary to call
1135 * vnode_update_identity on every lookup operation -- expensive!
1137 * However, even with this in place, multiple lookups may occur in between this lookup
1138 * and the subsequent vnop, so, at best, we could only guarantee that you would get a
1139 * valid path back, and not necessarily the one that you wanted.
1144 * If you are now looking up /foo/b and the vnode for this link represents /tmp/a,
1145 * vnode_update_identity will fix the parentage so that you can get /foo/b back
1146 * through the v_parent chain (preventing you from getting /tmp/b back). It would
1147 * not fix whether or not you should or should not get /tmp/a vs. /foo/b.
1150 error
= VNOP_LOOKUP(dp
, &ndp
->ni_vp
, cnp
, ctx
);
1154 if ((error
== ENOENT
) &&
1155 (dp
->v_mount
!= NULL
) &&
1156 (dp
->v_mount
->mnt_flag
& MNT_UNION
)) {
1158 error
= lookup_traverse_union(tdp
, &dp
, ctx
);
1170 if (error
!= EJUSTRETURN
)
1173 if (ndp
->ni_vp
!= NULLVP
)
1174 panic("leaf should be empty");
1178 * At this point, error should be EJUSTRETURN.
1180 * If CN_WANTSRSRCFORK is set, that implies that the
1181 * underlying filesystem could not find the "parent" of the
1182 * resource fork (the data fork), and we are doing a lookup
1183 * for a CREATE event.
1185 * However, this should be converted to an error, as the
1186 * failure to find this parent should disallow further
1187 * progress to try and acquire a resource fork vnode.
1189 if (cnp
->cn_flags
& CN_WANTSRSRCFORK
) {
1195 error
= lookup_validate_creation_path(ndp
);
1199 * We return with ni_vp NULL to indicate that the entry
1200 * doesn't currently exist, leaving a pointer to the
1201 * referenced directory vnode in ndp->ni_dvp.
1203 if (cnp
->cn_flags
& SAVESTART
) {
1204 if ( (vnode_get(ndp
->ni_dvp
)) ) {
1208 ndp
->ni_startdir
= ndp
->ni_dvp
;
1211 vnode_put(ndp
->ni_dvp
);
1214 kdebug_lookup(ndp
->ni_dvp
, cnp
);
1217 returned_from_lookup_path
:
1218 /* We'll always have an iocount on ni_vp when this finishes. */
1219 error
= lookup_handle_found_vnode(ndp
, cnp
, rdonly
, vbusyflags
, &keep_going
, nc_generation
, wantparent
, atroot
, ctx
);
1227 /* namei() will handle symlinks */
1228 if ((dp
->v_type
== VLNK
) &&
1229 ((cnp
->cn_flags
& FOLLOW
) || (ndp
->ni_flag
& NAMEI_TRAILINGSLASH
) || *ndp
->ni_next
== '/')) {
1234 * Otherwise, there's more path to process.
1235 * cache_lookup_path is now responsible for dropping io ref on dp
1236 * when it is called again in the dirloop. This ensures we hold
1237 * a ref on dp until we complete the next round of lookup.
1247 vnode_put(ndp
->ni_dvp
);
1249 vnode_put(ndp
->ni_vp
);
1250 ndp
->ni_vp
= NULLVP
;
1253 kdebug_lookup(dp
, cnp
);
1259 ndp
->ni_vp
= NULLVP
;
1262 kdebug_lookup(dp
, cnp
);
1267 * Given a vnode in a union mount, traverse to the equivalent
1268 * vnode in the underlying mount.
1271 lookup_traverse_union(vnode_t dvp
, vnode_t
*new_dvp
, vfs_context_t ctx
)
1273 char *path
= NULL
, *pp
;
1274 const char *name
, *np
;
1277 struct nameidata nd
;
1282 if (vp
&& vp
->v_flag
& VROOT
) {
1283 *new_dvp
= vp
->v_mount
->mnt_vnodecovered
;
1284 if (vnode_getwithref(*new_dvp
))
1289 path
= (char *) kalloc(MAXPATHLEN
);
1296 * Walk back up to the mountpoint following the
1297 * v_parent chain and build a slash-separated path.
1298 * Then lookup that path starting with the covered vnode.
1300 pp
= path
+ (MAXPATHLEN
- 1);
1304 name
= vnode_getname(vp
);
1306 printf("lookup_traverse_union: null parent name: .%s\n", pp
);
1311 if ((len
+ 1) > (pp
- path
)) { // Enough space for this name ?
1312 error
= ENAMETOOLONG
;
1313 vnode_putname(name
);
1316 for (np
= name
+ len
; len
> 0; len
--) // Copy name backwards
1318 vnode_putname(name
);
1320 if (vp
== NULLVP
|| vp
->v_flag
& VROOT
)
1325 /* Evaluate the path in the underlying mount */
1326 NDINIT(&nd
, LOOKUP
, OP_LOOKUP
, USEDVP
, UIO_SYSSPACE
, CAST_USER_ADDR_T(pp
), ctx
);
1327 nd
.ni_dvp
= dvp
->v_mount
->mnt_vnodecovered
;
1330 *new_dvp
= nd
.ni_vp
;
1334 kfree(path
, MAXPATHLEN
);
1339 lookup_validate_creation_path(struct nameidata
*ndp
)
1341 struct componentname
*cnp
= &ndp
->ni_cnd
;
1344 * If creating and at end of pathname, then can consider
1345 * allowing file to be created.
1347 if (cnp
->cn_flags
& RDONLY
) {
1350 if ((cnp
->cn_flags
& ISLASTCN
) && (ndp
->ni_flag
& NAMEI_TRAILINGSLASH
) && !(cnp
->cn_flags
& WILLBEDIR
)) {
1358 * Modifies only ni_vp. Always returns with ni_vp still valid (iocount held).
1361 lookup_traverse_mountpoints(struct nameidata
*ndp
, struct componentname
*cnp
, vnode_t dp
,
1362 int vbusyflags
, vfs_context_t ctx
)
1368 vnode_t mounted_on_dp
;
1369 int current_mount_generation
= 0;
1371 vnode_t triggered_dp
= NULLVP
;
1373 #define MAX_TRIGGER_RETRIES 1
1376 if (dp
->v_type
!= VDIR
|| cnp
->cn_flags
& NOCROSSMOUNT
)
1383 current_mount_generation
= mount_generation
;
1385 while (dp
->v_mountedhere
) {
1386 vnode_lock_spin(dp
);
1387 if ((mp
= dp
->v_mountedhere
)) {
1395 if (ISSET(mp
->mnt_lflag
, MNT_LFORCE
)) {
1396 mount_dropcrossref(mp
, dp
, 0);
1397 break; // don't traverse into a forced unmount
1401 if (vfs_busy(mp
, vbusyflags
)) {
1402 mount_dropcrossref(mp
, dp
, 0);
1403 if (vbusyflags
== LK_NOWAIT
) {
1411 error
= VFS_ROOT(mp
, &tdp
, ctx
);
1413 mount_dropcrossref(mp
, dp
, 0);
1421 ndp
->ni_vp
= dp
= tdp
;
1422 if (dp
->v_type
!= VDIR
) {
1423 #if DEVELOPMENT || DEBUG
1424 panic("%s : Root of filesystem not a directory\n",
1435 * The triggered_dp check here is required but is susceptible to a
1436 * (unlikely) race in which trigger mount is done from here and is
1437 * unmounted before we get past vfs_busy above. We retry to deal with
1438 * that case but it has the side effect of unwanted retries for
1439 * "special" processes which don't want to trigger mounts.
1441 if (dp
->v_resolve
&& retry_cnt
< MAX_TRIGGER_RETRIES
) {
1442 error
= vnode_trigger_resolve(dp
, ndp
, ctx
);
1445 if (dp
== triggered_dp
)
1452 #endif /* CONFIG_TRIGGERS */
1455 mp
= mounted_on_dp
->v_mountedhere
;
1458 mount_lock_spin(mp
);
1459 mp
->mnt_realrootvp_vid
= dp
->v_id
;
1460 mp
->mnt_realrootvp
= dp
;
1461 mp
->mnt_generation
= current_mount_generation
;
1473 * Takes ni_vp and ni_dvp non-NULL. Returns with *new_dp set to the location
1474 * at which to start a lookup with a resolved path, and all other iocounts dropped.
1477 lookup_handle_symlink(struct nameidata
*ndp
, vnode_t
*new_dp
, vfs_context_t ctx
)
1480 char *cp
; /* pointer into pathname argument */
1484 struct user_iovec s_uiovec
;
1485 struct kern_iovec s_kiovec
;
1488 char uio_buf
[ UIO_SIZEOF(1) ];
1489 } u_uio_buf
; /* union only for aligning uio_buf correctly */
1490 int need_newpathbuf
;
1492 struct componentname
*cnp
= &ndp
->ni_cnd
;
1496 if (ndp
->ni_loopcnt
++ >= MAXSYMLINKS
) {
1500 if ((error
= mac_vnode_check_readlink(ctx
, ndp
->ni_vp
)) != 0)
1503 if (ndp
->ni_pathlen
> 1 || !(cnp
->cn_flags
& HASBUF
))
1504 need_newpathbuf
= 1;
1506 need_newpathbuf
= 0;
1508 if (need_newpathbuf
) {
1509 MALLOC_ZONE(cp
, char *, MAXPATHLEN
, M_NAMEI
, M_WAITOK
);
1516 auio
= uio_createwithbuffer(1, 0, UIO_SYSSPACE
, UIO_READ
,
1517 &u_uio_buf
.uio_buf
[0], sizeof(u_uio_buf
.uio_buf
));
1519 uio_addiov(auio
, CAST_USER_ADDR_T(cp
), MAXPATHLEN
);
1521 error
= VNOP_READLINK(ndp
->ni_vp
, auio
, ctx
);
1523 if (need_newpathbuf
)
1524 FREE_ZONE(cp
, MAXPATHLEN
, M_NAMEI
);
1529 * Safe to set unsigned with a [larger] signed type here
1530 * because 0 <= uio_resid <= MAXPATHLEN and MAXPATHLEN
1533 linklen
= MAXPATHLEN
- (u_int
)uio_resid(auio
);
1534 if (linklen
+ ndp
->ni_pathlen
> MAXPATHLEN
) {
1535 if (need_newpathbuf
)
1536 FREE_ZONE(cp
, MAXPATHLEN
, M_NAMEI
);
1538 return ENAMETOOLONG
;
1540 if (need_newpathbuf
) {
1541 long len
= cnp
->cn_pnlen
;
1543 tmppn
= cnp
->cn_pnbuf
;
1544 bcopy(ndp
->ni_next
, cp
+ linklen
, ndp
->ni_pathlen
);
1546 cnp
->cn_pnlen
= MAXPATHLEN
;
1548 if ( (cnp
->cn_flags
& HASBUF
) )
1549 FREE_ZONE(tmppn
, len
, M_NAMEI
);
1551 cnp
->cn_flags
|= HASBUF
;
1553 cnp
->cn_pnbuf
[linklen
] = '\0';
1555 ndp
->ni_pathlen
+= linklen
;
1556 cnp
->cn_nameptr
= cnp
->cn_pnbuf
;
1559 * starting point for 'relative'
1560 * symbolic link path
1565 * get rid of references returned via 'lookup'
1567 vnode_put(ndp
->ni_vp
);
1568 vnode_put(ndp
->ni_dvp
); /* ALWAYS have a dvp for a symlink */
1570 ndp
->ni_vp
= NULLVP
;
1571 ndp
->ni_dvp
= NULLVP
;
1574 * Check if symbolic link restarts us at the root
1576 if (*(cnp
->cn_nameptr
) == '/') {
1577 while (*(cnp
->cn_nameptr
) == '/') {
1581 if ((dp
= ndp
->ni_rootdir
) == NULLVP
) {
1592 * relookup - lookup a path name component
1593 * Used by lookup to re-aquire things.
1596 relookup(struct vnode
*dvp
, struct vnode
**vpp
, struct componentname
*cnp
)
1598 struct vnode
*dp
= NULL
; /* the directory we are searching */
1599 int wantparent
; /* 1 => wantparent or lockparent flag */
1600 int rdonly
; /* lookup read-only flag bit */
1602 #ifdef NAMEI_DIAGNOSTIC
1603 int i
, newhash
; /* DEBUG: check name hash */
1604 char *cp
; /* DEBUG: check name ptr/len */
1606 vfs_context_t ctx
= cnp
->cn_context
;;
1609 * Setup: break out flag bits into variables.
1611 wantparent
= cnp
->cn_flags
& (LOCKPARENT
|WANTPARENT
);
1612 rdonly
= cnp
->cn_flags
& RDONLY
;
1613 cnp
->cn_flags
&= ~ISSYMLINK
;
1615 if (cnp
->cn_flags
& NOCACHE
)
1616 cnp
->cn_flags
&= ~MAKEENTRY
;
1618 cnp
->cn_flags
|= MAKEENTRY
;
1623 * Check for degenerate name (e.g. / or "")
1624 * which is a way of talking about a directory,
1625 * e.g. like "/." or ".".
1627 if (cnp
->cn_nameptr
[0] == '\0') {
1628 if (cnp
->cn_nameiop
!= LOOKUP
|| wantparent
) {
1632 if (dp
->v_type
!= VDIR
) {
1636 if ( (vnode_get(dp
)) ) {
1642 if (cnp
->cn_flags
& SAVESTART
)
1643 panic("lookup: SAVESTART");
1647 * We now have a segment name to search for, and a directory to search.
1649 if ( (error
= VNOP_LOOKUP(dp
, vpp
, cnp
, ctx
)) ) {
1650 if (error
!= EJUSTRETURN
)
1654 panic("leaf should be empty");
1657 * If creating and at end of pathname, then can consider
1658 * allowing file to be created.
1665 * We return with ni_vp NULL to indicate that the entry
1666 * doesn't currently exist, leaving a pointer to the
1667 * (possibly locked) directory inode in ndp->ni_dvp.
1675 * Check for symbolic link
1677 if (dp
->v_type
== VLNK
&& (cnp
->cn_flags
& FOLLOW
))
1678 panic ("relookup: symlink found.\n");
1682 * Disallow directory write attempts on read-only file systems.
1685 (cnp
->cn_nameiop
== DELETE
|| cnp
->cn_nameiop
== RENAME
)) {
1689 /* ASSERT(dvp == ndp->ni_startdir) */
1702 * Free pathname buffer
1705 nameidone(struct nameidata
*ndp
)
1707 if (ndp
->ni_cnd
.cn_flags
& HASBUF
) {
1708 char *tmp
= ndp
->ni_cnd
.cn_pnbuf
;
1710 ndp
->ni_cnd
.cn_pnbuf
= NULL
;
1711 ndp
->ni_cnd
.cn_flags
&= ~HASBUF
;
1712 FREE_ZONE(tmp
, ndp
->ni_cnd
.cn_pnlen
, M_NAMEI
);
1718 * Log (part of) a pathname using the KERNEL_DEBUG_CONSTANT mechanism, as used
1719 * by fs_usage. The path up to and including the current component name are
1720 * logged. Up to NUMPARMS*4 bytes of pathname will be logged. If the path
1721 * to be logged is longer than that, then the last NUMPARMS*4 bytes are logged.
1722 * That is, the truncation removes the leading portion of the path.
1724 * The logging is done via multiple KERNEL_DEBUG_CONSTANT calls. The first one
1725 * is marked with DBG_FUNC_START. The last one is marked with DBG_FUNC_END
1726 * (in addition to DBG_FUNC_START if it is also the first). There may be
1727 * intermediate ones with neither DBG_FUNC_START nor DBG_FUNC_END.
1729 * The first KERNEL_DEBUG_CONSTANT passes the vnode pointer and 12 bytes of
1730 * pathname. The remaining KERNEL_DEBUG_CONSTANT calls add 16 bytes of pathname
1731 * each. The minimum number of KERNEL_DEBUG_CONSTANT calls required to pass
1732 * the path are used. Any excess padding in the final KERNEL_DEBUG_CONSTANT
1733 * (because not all of the 12 or 16 bytes are needed for the remainder of the
1734 * path) is set to zero bytes, or '>' if there is more path beyond the
1735 * current component name (usually because an intermediate component was not
1738 * NOTE: If the path length is greater than NUMPARMS*4, or is not of the form
1739 * 12+N*16, there will be no padding.
1741 * TODO: If there is more path beyond the current component name, should we
1742 * force some padding? For example, a lookup for /foo_bar_baz/spam that
1743 * fails because /foo_bar_baz is not found will only log "/foo_bar_baz", with
1744 * no '>' padding. But /foo_bar/spam would log "/foo_bar>>>>".
1746 #if (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST)
1749 kdebug_lookup_gen_events(long *dbg_parms
, int dbg_namelen
, void *dp
, boolean_t lookup
)
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.
1759 code
= VFS_LOOKUP
| DBG_FUNC_START
;
1761 code
= VFS_LOOKUP_DONE
| DBG_FUNC_START
;
1763 if (dbg_namelen
<= (int)(3 * sizeof(long)))
1764 code
|= DBG_FUNC_END
;
1766 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE
, code
, kdebug_vnode(dp
), dbg_parms
[0], dbg_parms
[1], dbg_parms
[2], 0);
1768 code
&= ~DBG_FUNC_START
;
1770 for (i
=3, dbg_namelen
-= (3 * sizeof(long)); dbg_namelen
> 0; i
+=4, dbg_namelen
-= (4 * sizeof(long))) {
1771 if (dbg_namelen
<= (int)(4 * sizeof(long)))
1772 code
|= DBG_FUNC_END
;
1774 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE
, code
, dbg_parms
[i
], dbg_parms
[i
+1], dbg_parms
[i
+2], dbg_parms
[i
+3], 0);
1779 kdebug_lookup(vnode_t dp
, struct componentname
*cnp
)
1783 long dbg_parms
[NUMPARMS
];
1785 /* Collect the pathname for tracing */
1786 dbg_namelen
= (cnp
->cn_nameptr
- cnp
->cn_pnbuf
) + cnp
->cn_namelen
;
1787 dbg_nameptr
= cnp
->cn_nameptr
+ cnp
->cn_namelen
;
1789 if (dbg_namelen
> (int)sizeof(dbg_parms
))
1790 dbg_namelen
= sizeof(dbg_parms
);
1791 dbg_nameptr
-= dbg_namelen
;
1793 /* Copy the (possibly truncated) path itself */
1794 memcpy(dbg_parms
, dbg_nameptr
, dbg_namelen
);
1796 /* Pad with '\0' or '>' */
1797 if (dbg_namelen
< (int)sizeof(dbg_parms
)) {
1798 memset((char *)dbg_parms
+ dbg_namelen
,
1799 *(cnp
->cn_nameptr
+ cnp
->cn_namelen
) ? '>' : 0,
1800 sizeof(dbg_parms
) - dbg_namelen
);
1802 kdebug_lookup_gen_events(dbg_parms
, dbg_namelen
, (void *)dp
, TRUE
);
1805 #else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST) */
1808 kdebug_lookup_gen_events(long *dbg_parms __unused
, int dbg_namelen __unused
, void *dp __unused
)
1813 kdebug_lookup(struct vnode
*dp __unused
, struct componentname
*cnp __unused
)
1816 #endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST) */
1819 vfs_getbyid(fsid_t
*fsid
, ino64_t ino
, vnode_t
*vpp
, vfs_context_t ctx
)
1824 mp
= mount_lookupby_volfsid(fsid
->val
[0], 1);
1829 /* Get the target vnode. */
1831 error
= VFS_ROOT(mp
, vpp
, ctx
);
1833 error
= VFS_VGET(mp
, ino
, vpp
, ctx
);
1840 * Obtain the real path from a legacy volfs style path.
1842 * Valid formats of input path:
1847 * "555/123456/foobar"
1850 * 555 represents the volfs file system id
1851 * '@' and '2' are aliases to the root of a file system
1852 * 123456 represents a file id
1853 * "foobar" represents a file name
1857 vfs_getrealpath(const char * path
, char * realpath
, size_t bufsize
, vfs_context_t ctx
)
1860 struct mount
*mp
= NULL
;
1868 /* Get file system id and move str to next component. */
1869 id
= strtoul(path
, &str
, 10);
1870 if (id
== 0 || str
[0] != '/') {
1873 while (*str
== '/') {
1878 mp
= mount_lookupby_volfsid(id
, 1);
1880 return (EINVAL
); /* unexpected failure */
1882 /* Check for an alias to a file system root. */
1883 if (ch
== '@' && str
[1] == '\0') {
1887 /* Get file id and move str to next component. */
1888 ino
= strtouq(str
, &str
, 10);
1891 /* Get the target vnode. */
1893 error
= VFS_ROOT(mp
, &vp
, ctx
);
1895 error
= VFS_VGET(mp
, ino
, &vp
, ctx
);
1903 /* Get the absolute path to this vnode. */
1904 error
= build_path(vp
, realpath
, bufsize
, &length
, 0, ctx
);
1907 if (error
== 0 && *str
!= '\0') {
1908 int attempt
= strlcat(realpath
, str
, MAXPATHLEN
);
1909 if (attempt
> MAXPATHLEN
){
1910 error
= ENAMETOOLONG
;
1919 lookup_compound_vnop_post_hook(int error
, vnode_t dvp
, vnode_t vp
, struct nameidata
*ndp
, int did_create
)
1921 if (error
== 0 && vp
== NULLVP
) {
1922 panic("NULL vp with error == 0.\n");
1926 * We don't want to do any of this if we didn't use the compound vnop
1927 * to perform the lookup... i.e. if we're allowing and using the legacy pattern,
1928 * where we did a full lookup.
1930 if ((ndp
->ni_flag
& NAMEI_COMPOUND_OP_MASK
) == 0) {
1935 * If we're going to continue the lookup, we'll handle
1936 * all lookup-related updates at that time.
1938 if (error
== EKEEPLOOKING
) {
1943 * Only audit or update cache for *found* vnodes. For creation
1944 * neither would happen in the non-compound-vnop case.
1946 if ((vp
!= NULLVP
) && !did_create
) {
1948 * If MAKEENTRY isn't set, and we've done a successful compound VNOP,
1949 * then we certainly don't want to update cache or identity.
1951 if ((error
!= 0) || (ndp
->ni_cnd
.cn_flags
& MAKEENTRY
)) {
1952 lookup_consider_update_cache(dvp
, vp
, &ndp
->ni_cnd
, ndp
->ni_ncgeneration
);
1954 if (ndp
->ni_cnd
.cn_flags
& AUDITVNPATH1
)
1955 AUDIT_ARG(vnpath
, vp
, ARG_VNODE1
);
1956 else if (ndp
->ni_cnd
.cn_flags
& AUDITVNPATH2
)
1957 AUDIT_ARG(vnpath
, vp
, ARG_VNODE2
);
1961 * If you created (whether you opened or not), cut a lookup tracepoint
1962 * for the parent dir (as would happen without a compound vnop). Note: we may need
1963 * a vnode despite failure in this case!
1965 * If you did not create:
1966 * Found child (succeeded or not): cut a tracepoint for the child.
1967 * Did not find child: cut a tracepoint with the parent.
1969 if (kdebug_enable
) {
1970 kdebug_lookup(vp
? vp
: dvp
, &ndp
->ni_cnd
);