vfs_lookup.c revision 1.207.2.2 1 1.207.2.2 martin /* $NetBSD: vfs_lookup.c,v 1.207.2.2 2021/06/21 14:55:15 martin Exp $ */
2 1.13 cgd
3 1.10 cgd /*
4 1.12 mycroft * Copyright (c) 1982, 1986, 1989, 1993
5 1.12 mycroft * The Regents of the University of California. All rights reserved.
6 1.10 cgd * (c) UNIX System Laboratories, Inc.
7 1.10 cgd * All or some portions of this file are derived from material licensed
8 1.10 cgd * to the University of California by American Telephone and Telegraph
9 1.10 cgd * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 1.10 cgd * the permission of UNIX System Laboratories, Inc.
11 1.10 cgd *
12 1.10 cgd * Redistribution and use in source and binary forms, with or without
13 1.10 cgd * modification, are permitted provided that the following conditions
14 1.10 cgd * are met:
15 1.10 cgd * 1. Redistributions of source code must retain the above copyright
16 1.10 cgd * notice, this list of conditions and the following disclaimer.
17 1.10 cgd * 2. Redistributions in binary form must reproduce the above copyright
18 1.10 cgd * notice, this list of conditions and the following disclaimer in the
19 1.10 cgd * documentation and/or other materials provided with the distribution.
20 1.49 agc * 3. Neither the name of the University nor the names of its contributors
21 1.10 cgd * may be used to endorse or promote products derived from this software
22 1.10 cgd * without specific prior written permission.
23 1.10 cgd *
24 1.10 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 1.10 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 1.10 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 1.10 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 1.10 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 1.10 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 1.10 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 1.10 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 1.10 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 1.10 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 1.10 cgd * SUCH DAMAGE.
35 1.10 cgd *
36 1.26 fvdl * @(#)vfs_lookup.c 8.10 (Berkeley) 5/27/95
37 1.10 cgd */
38 1.38 lukem
39 1.38 lukem #include <sys/cdefs.h>
40 1.207.2.2 martin __KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.207.2.2 2021/06/21 14:55:15 martin Exp $");
41 1.27 thorpej
42 1.203 pooka #ifdef _KERNEL_OPT
43 1.67 chs #include "opt_magiclinks.h"
44 1.203 pooka #endif
45 1.10 cgd
46 1.10 cgd #include <sys/param.h>
47 1.15 cgd #include <sys/systm.h>
48 1.61 thorpej #include <sys/kernel.h>
49 1.10 cgd #include <sys/syslimits.h>
50 1.10 cgd #include <sys/time.h>
51 1.10 cgd #include <sys/namei.h>
52 1.10 cgd #include <sys/vnode.h>
53 1.10 cgd #include <sys/mount.h>
54 1.10 cgd #include <sys/errno.h>
55 1.39 lukem #include <sys/filedesc.h>
56 1.39 lukem #include <sys/hash.h>
57 1.10 cgd #include <sys/proc.h>
58 1.40 wrstuden #include <sys/syslog.h>
59 1.70 elad #include <sys/kauth.h>
60 1.97 ad #include <sys/ktrace.h>
61 1.192 christos #include <sys/dirent.h>
62 1.12 mycroft
63 1.67 chs #ifndef MAGICLINKS
64 1.67 chs #define MAGICLINKS 0
65 1.67 chs #endif
66 1.67 chs
67 1.67 chs int vfs_magiclinks = MAGICLINKS;
68 1.67 chs
69 1.191 christos __CTASSERT(MAXNAMLEN == NAME_MAX);
70 1.191 christos
71 1.10 cgd /*
72 1.61 thorpej * Substitute replacement text for 'magic' strings in symlinks.
73 1.61 thorpej * Returns 0 if successful, and returns non-zero if an error
74 1.61 thorpej * occurs. (Currently, the only possible error is running out
75 1.61 thorpej * of temporary pathname space.)
76 1.61 thorpej *
77 1.61 thorpej * Looks for "@<string>" and "@<string>/", where <string> is a
78 1.61 thorpej * recognized 'magic' string. Replaces the "@<string>" with the
79 1.61 thorpej * appropriate replacement text. (Note that in some cases the
80 1.61 thorpej * replacement text may have zero length.)
81 1.61 thorpej *
82 1.61 thorpej * This would have been table driven, but the variance in
83 1.61 thorpej * replacement strings (and replacement string lengths) made
84 1.61 thorpej * that impractical.
85 1.61 thorpej */
86 1.63 thorpej #define VNL(x) \
87 1.63 thorpej (sizeof(x) - 1)
88 1.63 thorpej
89 1.63 thorpej #define VO '{'
90 1.63 thorpej #define VC '}'
91 1.63 thorpej
92 1.61 thorpej #define MATCH(str) \
93 1.63 thorpej ((termchar == '/' && i + VNL(str) == *len) || \
94 1.63 thorpej (i + VNL(str) < *len && \
95 1.63 thorpej cp[i + VNL(str)] == termchar)) && \
96 1.63 thorpej !strncmp((str), &cp[i], VNL(str))
97 1.61 thorpej
98 1.61 thorpej #define SUBSTITUTE(m, s, sl) \
99 1.115 christos if ((newlen + (sl)) >= MAXPATHLEN) \
100 1.115 christos return 1; \
101 1.63 thorpej i += VNL(m); \
102 1.63 thorpej if (termchar != '/') \
103 1.63 thorpej i++; \
104 1.115 christos (void)memcpy(&tmp[newlen], (s), (sl)); \
105 1.63 thorpej newlen += (sl); \
106 1.63 thorpej change = 1; \
107 1.63 thorpej termchar = '/';
108 1.61 thorpej
109 1.61 thorpej static int
110 1.115 christos symlink_magic(struct proc *p, char *cp, size_t *len)
111 1.61 thorpej {
112 1.66 yamt char *tmp;
113 1.115 christos size_t change, i, newlen, slen;
114 1.115 christos char termchar = '/';
115 1.115 christos char idtmp[11]; /* enough for 32 bit *unsigned* integer */
116 1.101 mjf
117 1.61 thorpej
118 1.66 yamt tmp = PNBUF_GET();
119 1.61 thorpej for (change = i = newlen = 0; i < *len; ) {
120 1.63 thorpej if (cp[i] != '@') {
121 1.61 thorpej tmp[newlen++] = cp[i++];
122 1.63 thorpej continue;
123 1.63 thorpej }
124 1.63 thorpej
125 1.63 thorpej i++;
126 1.63 thorpej
127 1.63 thorpej /* Check for @{var} syntax. */
128 1.63 thorpej if (cp[i] == VO) {
129 1.63 thorpej termchar = VC;
130 1.61 thorpej i++;
131 1.63 thorpej }
132 1.63 thorpej
133 1.63 thorpej /*
134 1.63 thorpej * The following checks should be ordered according
135 1.63 thorpej * to frequency of use.
136 1.63 thorpej */
137 1.63 thorpej if (MATCH("machine_arch")) {
138 1.115 christos slen = VNL(MACHINE_ARCH);
139 1.115 christos SUBSTITUTE("machine_arch", MACHINE_ARCH, slen);
140 1.63 thorpej } else if (MATCH("machine")) {
141 1.115 christos slen = VNL(MACHINE);
142 1.115 christos SUBSTITUTE("machine", MACHINE, slen);
143 1.63 thorpej } else if (MATCH("hostname")) {
144 1.115 christos SUBSTITUTE("hostname", hostname, hostnamelen);
145 1.63 thorpej } else if (MATCH("osrelease")) {
146 1.115 christos slen = strlen(osrelease);
147 1.115 christos SUBSTITUTE("osrelease", osrelease, slen);
148 1.63 thorpej } else if (MATCH("emul")) {
149 1.115 christos slen = strlen(p->p_emul->e_name);
150 1.115 christos SUBSTITUTE("emul", p->p_emul->e_name, slen);
151 1.63 thorpej } else if (MATCH("kernel_ident")) {
152 1.115 christos slen = strlen(kernel_ident);
153 1.115 christos SUBSTITUTE("kernel_ident", kernel_ident, slen);
154 1.63 thorpej } else if (MATCH("domainname")) {
155 1.115 christos SUBSTITUTE("domainname", domainname, domainnamelen);
156 1.63 thorpej } else if (MATCH("ostype")) {
157 1.115 christos slen = strlen(ostype);
158 1.115 christos SUBSTITUTE("ostype", ostype, slen);
159 1.72 elad } else if (MATCH("uid")) {
160 1.115 christos slen = snprintf(idtmp, sizeof(idtmp), "%u",
161 1.72 elad kauth_cred_geteuid(kauth_cred_get()));
162 1.115 christos SUBSTITUTE("uid", idtmp, slen);
163 1.101 mjf } else if (MATCH("ruid")) {
164 1.115 christos slen = snprintf(idtmp, sizeof(idtmp), "%u",
165 1.101 mjf kauth_cred_getuid(kauth_cred_get()));
166 1.115 christos SUBSTITUTE("ruid", idtmp, slen);
167 1.115 christos } else if (MATCH("gid")) {
168 1.115 christos slen = snprintf(idtmp, sizeof(idtmp), "%u",
169 1.115 christos kauth_cred_getegid(kauth_cred_get()));
170 1.115 christos SUBSTITUTE("gid", idtmp, slen);
171 1.115 christos } else if (MATCH("rgid")) {
172 1.115 christos slen = snprintf(idtmp, sizeof(idtmp), "%u",
173 1.115 christos kauth_cred_getgid(kauth_cred_get()));
174 1.115 christos SUBSTITUTE("rgid", idtmp, slen);
175 1.63 thorpej } else {
176 1.63 thorpej tmp[newlen++] = '@';
177 1.63 thorpej if (termchar == VC)
178 1.63 thorpej tmp[newlen++] = VO;
179 1.61 thorpej }
180 1.61 thorpej }
181 1.61 thorpej
182 1.66 yamt if (change) {
183 1.115 christos (void)memcpy(cp, tmp, newlen);
184 1.66 yamt *len = newlen;
185 1.66 yamt }
186 1.66 yamt PNBUF_PUT(tmp);
187 1.61 thorpej
188 1.115 christos return 0;
189 1.61 thorpej }
190 1.61 thorpej
191 1.63 thorpej #undef VNL
192 1.63 thorpej #undef VO
193 1.63 thorpej #undef VC
194 1.63 thorpej #undef MATCH
195 1.63 thorpej #undef SUBSTITUTE
196 1.63 thorpej
197 1.123 dholland ////////////////////////////////////////////////////////////
198 1.123 dholland
199 1.123 dholland /*
200 1.197 dholland * Determine the namei hash (for the namecache) for name.
201 1.131 dholland * If *ep != NULL, hash from name to ep-1.
202 1.131 dholland * If *ep == NULL, hash from name until the first NUL or '/', and
203 1.131 dholland * return the location of this termination character in *ep.
204 1.131 dholland *
205 1.131 dholland * This function returns an equivalent hash to the MI hash32_strn().
206 1.131 dholland * The latter isn't used because in the *ep == NULL case, determining
207 1.131 dholland * the length of the string to the first NUL or `/' and then calling
208 1.131 dholland * hash32_strn() involves unnecessary double-handling of the data.
209 1.131 dholland */
210 1.131 dholland uint32_t
211 1.131 dholland namei_hash(const char *name, const char **ep)
212 1.131 dholland {
213 1.131 dholland uint32_t hash;
214 1.131 dholland
215 1.131 dholland hash = HASH32_STR_INIT;
216 1.131 dholland if (*ep != NULL) {
217 1.131 dholland for (; name < *ep; name++)
218 1.131 dholland hash = hash * 33 + *(const uint8_t *)name;
219 1.131 dholland } else {
220 1.131 dholland for (; *name != '\0' && *name != '/'; name++)
221 1.131 dholland hash = hash * 33 + *(const uint8_t *)name;
222 1.131 dholland *ep = name;
223 1.131 dholland }
224 1.131 dholland return (hash + (hash >> 5));
225 1.131 dholland }
226 1.131 dholland
227 1.197 dholland /*
228 1.197 dholland * Find the end of the first path component in NAME and return its
229 1.197 dholland * length.
230 1.197 dholland */
231 1.197 dholland static size_t
232 1.197 dholland namei_getcomponent(const char *name)
233 1.197 dholland {
234 1.197 dholland size_t pos;
235 1.197 dholland
236 1.197 dholland pos = 0;
237 1.197 dholland while (name[pos] != '\0' && name[pos] != '/') {
238 1.197 dholland pos++;
239 1.197 dholland }
240 1.197 dholland return pos;
241 1.197 dholland }
242 1.197 dholland
243 1.131 dholland ////////////////////////////////////////////////////////////
244 1.131 dholland
245 1.131 dholland /*
246 1.123 dholland * Sealed abstraction for pathnames.
247 1.123 dholland *
248 1.123 dholland * System-call-layer level code that is going to call namei should
249 1.123 dholland * first create a pathbuf and adjust all the bells and whistles on it
250 1.176 dholland * as needed by context.
251 1.123 dholland */
252 1.123 dholland
253 1.123 dholland struct pathbuf {
254 1.123 dholland char *pb_path;
255 1.123 dholland char *pb_pathcopy;
256 1.123 dholland unsigned pb_pathcopyuses;
257 1.123 dholland };
258 1.123 dholland
259 1.123 dholland static struct pathbuf *
260 1.123 dholland pathbuf_create_raw(void)
261 1.123 dholland {
262 1.123 dholland struct pathbuf *pb;
263 1.123 dholland
264 1.123 dholland pb = kmem_alloc(sizeof(*pb), KM_SLEEP);
265 1.123 dholland pb->pb_path = PNBUF_GET();
266 1.123 dholland if (pb->pb_path == NULL) {
267 1.123 dholland kmem_free(pb, sizeof(*pb));
268 1.123 dholland return NULL;
269 1.123 dholland }
270 1.123 dholland pb->pb_pathcopy = NULL;
271 1.123 dholland pb->pb_pathcopyuses = 0;
272 1.123 dholland return pb;
273 1.123 dholland }
274 1.123 dholland
275 1.123 dholland void
276 1.123 dholland pathbuf_destroy(struct pathbuf *pb)
277 1.123 dholland {
278 1.123 dholland KASSERT(pb->pb_pathcopyuses == 0);
279 1.123 dholland KASSERT(pb->pb_pathcopy == NULL);
280 1.123 dholland PNBUF_PUT(pb->pb_path);
281 1.123 dholland kmem_free(pb, sizeof(*pb));
282 1.123 dholland }
283 1.123 dholland
284 1.123 dholland struct pathbuf *
285 1.124 dholland pathbuf_assimilate(char *pnbuf)
286 1.124 dholland {
287 1.124 dholland struct pathbuf *pb;
288 1.124 dholland
289 1.124 dholland pb = kmem_alloc(sizeof(*pb), KM_SLEEP);
290 1.124 dholland pb->pb_path = pnbuf;
291 1.124 dholland pb->pb_pathcopy = NULL;
292 1.124 dholland pb->pb_pathcopyuses = 0;
293 1.124 dholland return pb;
294 1.124 dholland }
295 1.124 dholland
296 1.124 dholland struct pathbuf *
297 1.123 dholland pathbuf_create(const char *path)
298 1.123 dholland {
299 1.123 dholland struct pathbuf *pb;
300 1.123 dholland int error;
301 1.123 dholland
302 1.123 dholland pb = pathbuf_create_raw();
303 1.123 dholland if (pb == NULL) {
304 1.123 dholland return NULL;
305 1.123 dholland }
306 1.123 dholland error = copystr(path, pb->pb_path, PATH_MAX, NULL);
307 1.123 dholland if (error != 0) {
308 1.123 dholland KASSERT(!"kernel path too long in pathbuf_create");
309 1.123 dholland /* make sure it's null-terminated, just in case */
310 1.123 dholland pb->pb_path[PATH_MAX-1] = '\0';
311 1.123 dholland }
312 1.123 dholland return pb;
313 1.123 dholland }
314 1.123 dholland
315 1.123 dholland int
316 1.123 dholland pathbuf_copyin(const char *userpath, struct pathbuf **ret)
317 1.123 dholland {
318 1.123 dholland struct pathbuf *pb;
319 1.123 dholland int error;
320 1.123 dholland
321 1.123 dholland pb = pathbuf_create_raw();
322 1.123 dholland if (pb == NULL) {
323 1.123 dholland return ENOMEM;
324 1.123 dholland }
325 1.123 dholland error = copyinstr(userpath, pb->pb_path, PATH_MAX, NULL);
326 1.123 dholland if (error) {
327 1.123 dholland pathbuf_destroy(pb);
328 1.123 dholland return error;
329 1.123 dholland }
330 1.123 dholland *ret = pb;
331 1.123 dholland return 0;
332 1.123 dholland }
333 1.123 dholland
334 1.123 dholland /*
335 1.173 dholland * XXX should not exist:
336 1.176 dholland * 1. whether a pointer is kernel or user should be statically checkable.
337 1.173 dholland * 2. copyin should be handled by the upper part of the syscall layer,
338 1.173 dholland * not in here.
339 1.123 dholland */
340 1.123 dholland int
341 1.123 dholland pathbuf_maybe_copyin(const char *path, enum uio_seg seg, struct pathbuf **ret)
342 1.123 dholland {
343 1.123 dholland if (seg == UIO_USERSPACE) {
344 1.123 dholland return pathbuf_copyin(path, ret);
345 1.123 dholland } else {
346 1.123 dholland *ret = pathbuf_create(path);
347 1.123 dholland if (*ret == NULL) {
348 1.123 dholland return ENOMEM;
349 1.123 dholland }
350 1.123 dholland return 0;
351 1.123 dholland }
352 1.123 dholland }
353 1.123 dholland
354 1.123 dholland /*
355 1.123 dholland * Get a copy of the path buffer as it currently exists. If this is
356 1.123 dholland * called after namei starts the results may be arbitrary.
357 1.123 dholland */
358 1.123 dholland void
359 1.123 dholland pathbuf_copystring(const struct pathbuf *pb, char *buf, size_t maxlen)
360 1.123 dholland {
361 1.123 dholland strlcpy(buf, pb->pb_path, maxlen);
362 1.123 dholland }
363 1.123 dholland
364 1.123 dholland /*
365 1.123 dholland * These two functions allow access to a saved copy of the original
366 1.123 dholland * path string. The first copy should be gotten before namei is
367 1.123 dholland * called. Each copy that is gotten should be put back.
368 1.123 dholland */
369 1.123 dholland
370 1.123 dholland const char *
371 1.123 dholland pathbuf_stringcopy_get(struct pathbuf *pb)
372 1.123 dholland {
373 1.123 dholland if (pb->pb_pathcopyuses == 0) {
374 1.123 dholland pb->pb_pathcopy = PNBUF_GET();
375 1.123 dholland strcpy(pb->pb_pathcopy, pb->pb_path);
376 1.123 dholland }
377 1.123 dholland pb->pb_pathcopyuses++;
378 1.123 dholland return pb->pb_pathcopy;
379 1.123 dholland }
380 1.123 dholland
381 1.123 dholland void
382 1.123 dholland pathbuf_stringcopy_put(struct pathbuf *pb, const char *str)
383 1.123 dholland {
384 1.123 dholland KASSERT(str == pb->pb_pathcopy);
385 1.123 dholland KASSERT(pb->pb_pathcopyuses > 0);
386 1.123 dholland pb->pb_pathcopyuses--;
387 1.123 dholland if (pb->pb_pathcopyuses == 0) {
388 1.123 dholland PNBUF_PUT(pb->pb_pathcopy);
389 1.123 dholland pb->pb_pathcopy = NULL;
390 1.123 dholland }
391 1.123 dholland }
392 1.123 dholland
393 1.123 dholland
394 1.123 dholland ////////////////////////////////////////////////////////////
395 1.123 dholland
396 1.61 thorpej /*
397 1.173 dholland * namei: convert a pathname into a pointer to a (maybe-locked) vnode,
398 1.173 dholland * and maybe also its parent directory vnode, and assorted other guff.
399 1.173 dholland * See namei(9) for the interface documentation.
400 1.173 dholland *
401 1.10 cgd *
402 1.10 cgd * The FOLLOW flag is set when symbolic links are to be followed
403 1.10 cgd * when they occur at the end of the name translation process.
404 1.10 cgd * Symbolic links are always followed for all other pathname
405 1.10 cgd * components other than the last.
406 1.10 cgd *
407 1.10 cgd * The segflg defines whether the name is to be copied from user
408 1.10 cgd * space or kernel space.
409 1.10 cgd *
410 1.10 cgd * Overall outline of namei:
411 1.10 cgd *
412 1.10 cgd * copy in name
413 1.10 cgd * get starting directory
414 1.10 cgd * while (!done && !error) {
415 1.10 cgd * call lookup to search path.
416 1.10 cgd * if symbolic link, massage name in buffer and continue
417 1.10 cgd * }
418 1.10 cgd */
419 1.117 dholland
420 1.117 dholland /*
421 1.173 dholland * Search a pathname.
422 1.173 dholland * This is a very central and rather complicated routine.
423 1.173 dholland *
424 1.173 dholland * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
425 1.173 dholland * The starting directory is passed in. The pathname is descended
426 1.173 dholland * until done, or a symbolic link is encountered. The variable ni_more
427 1.173 dholland * is clear if the path is completed; it is set to one if a symbolic
428 1.173 dholland * link needing interpretation is encountered.
429 1.173 dholland *
430 1.173 dholland * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
431 1.173 dholland * whether the name is to be looked up, created, renamed, or deleted.
432 1.173 dholland * When CREATE, RENAME, or DELETE is specified, information usable in
433 1.173 dholland * creating, renaming, or deleting a directory entry may be calculated.
434 1.173 dholland * If flag has LOCKPARENT or'ed into it, the parent directory is returned
435 1.173 dholland * locked. Otherwise the parent directory is not returned. If the target
436 1.173 dholland * of the pathname exists and LOCKLEAF is or'ed into the flag the target
437 1.173 dholland * is returned locked, otherwise it is returned unlocked. When creating
438 1.173 dholland * or renaming and LOCKPARENT is specified, the target may not be ".".
439 1.173 dholland * When deleting and LOCKPARENT is specified, the target may be ".".
440 1.173 dholland *
441 1.173 dholland * Overall outline of lookup:
442 1.173 dholland *
443 1.173 dholland * dirloop:
444 1.173 dholland * identify next component of name at ndp->ni_ptr
445 1.173 dholland * handle degenerate case where name is null string
446 1.173 dholland * if .. and crossing mount points and on mounted filesys, find parent
447 1.173 dholland * call VOP_LOOKUP routine for next component name
448 1.173 dholland * directory vnode returned in ni_dvp, locked.
449 1.173 dholland * component vnode returned in ni_vp (if it exists), locked.
450 1.173 dholland * if result vnode is mounted on and crossing mount points,
451 1.173 dholland * find mounted on vnode
452 1.173 dholland * if more components of name, do next level at dirloop
453 1.173 dholland * return the answer in ni_vp, locked if LOCKLEAF set
454 1.173 dholland * if LOCKPARENT set, return locked parent in ni_dvp
455 1.173 dholland */
456 1.173 dholland
457 1.173 dholland
458 1.173 dholland /*
459 1.117 dholland * Internal state for a namei operation.
460 1.173 dholland *
461 1.173 dholland * cnp is always equal to &ndp->ni_cnp.
462 1.117 dholland */
463 1.117 dholland struct namei_state {
464 1.117 dholland struct nameidata *ndp;
465 1.117 dholland struct componentname *cnp;
466 1.117 dholland
467 1.118 dholland int docache; /* == 0 do not cache last component */
468 1.118 dholland int rdonly; /* lookup read-only flag bit */
469 1.118 dholland int slashes;
470 1.137 dholland
471 1.137 dholland unsigned attempt_retry:1; /* true if error allows emul retry */
472 1.117 dholland };
473 1.117 dholland
474 1.118 dholland
475 1.117 dholland /*
476 1.117 dholland * Initialize the namei working state.
477 1.117 dholland */
478 1.117 dholland static void
479 1.117 dholland namei_init(struct namei_state *state, struct nameidata *ndp)
480 1.117 dholland {
481 1.202 riastrad
482 1.117 dholland state->ndp = ndp;
483 1.117 dholland state->cnp = &ndp->ni_cnd;
484 1.117 dholland
485 1.118 dholland state->docache = 0;
486 1.118 dholland state->rdonly = 0;
487 1.118 dholland state->slashes = 0;
488 1.133 dholland
489 1.205 riastrad KASSERTMSG((state->cnp->cn_cred != NULL), "namei: bad cred/proc");
490 1.205 riastrad KASSERTMSG(((state->cnp->cn_nameiop & (~OPMASK)) == 0),
491 1.205 riastrad "namei: nameiop contaminated with flags: %08"PRIx32,
492 1.205 riastrad state->cnp->cn_nameiop);
493 1.205 riastrad KASSERTMSG(((state->cnp->cn_flags & OPMASK) == 0),
494 1.205 riastrad "name: flags contaminated with nameiops: %08"PRIx32,
495 1.205 riastrad state->cnp->cn_flags);
496 1.133 dholland
497 1.133 dholland /*
498 1.133 dholland * The buffer for name translation shall be the one inside the
499 1.133 dholland * pathbuf.
500 1.133 dholland */
501 1.133 dholland state->ndp->ni_pnbuf = state->ndp->ni_pathbuf->pb_path;
502 1.117 dholland }
503 1.117 dholland
504 1.117 dholland /*
505 1.117 dholland * Clean up the working namei state, leaving things ready for return
506 1.117 dholland * from namei.
507 1.117 dholland */
508 1.117 dholland static void
509 1.117 dholland namei_cleanup(struct namei_state *state)
510 1.117 dholland {
511 1.117 dholland KASSERT(state->cnp == &state->ndp->ni_cnd);
512 1.117 dholland
513 1.117 dholland /* nothing for now */
514 1.117 dholland (void)state;
515 1.117 dholland }
516 1.117 dholland
517 1.117 dholland //////////////////////////////
518 1.117 dholland
519 1.117 dholland /*
520 1.133 dholland * Get the directory context.
521 1.133 dholland * Initializes the rootdir and erootdir state and returns a reference
522 1.133 dholland * to the starting dir.
523 1.117 dholland */
524 1.133 dholland static struct vnode *
525 1.196 dholland namei_getstartdir(struct namei_state *state)
526 1.117 dholland {
527 1.117 dholland struct nameidata *ndp = state->ndp;
528 1.117 dholland struct componentname *cnp = state->cnp;
529 1.117 dholland struct cwdinfo *cwdi; /* pointer to cwd state */
530 1.117 dholland struct lwp *self = curlwp; /* thread doing namei() */
531 1.133 dholland struct vnode *rootdir, *erootdir, *curdir, *startdir;
532 1.117 dholland
533 1.133 dholland cwdi = self->l_proc->p_cwdi;
534 1.133 dholland rw_enter(&cwdi->cwdi_lock, RW_READER);
535 1.21 kleink
536 1.133 dholland /* root dir */
537 1.133 dholland if (cwdi->cwdi_rdir == NULL || (cnp->cn_flags & NOCHROOT)) {
538 1.133 dholland rootdir = rootvnode;
539 1.133 dholland } else {
540 1.133 dholland rootdir = cwdi->cwdi_rdir;
541 1.10 cgd }
542 1.123 dholland
543 1.133 dholland /* emulation root dir, if any */
544 1.133 dholland if ((cnp->cn_flags & TRYEMULROOT) == 0) {
545 1.133 dholland /* if we don't want it, don't fetch it */
546 1.133 dholland erootdir = NULL;
547 1.133 dholland } else if (cnp->cn_flags & EMULROOTSET) {
548 1.133 dholland /* explicitly set emulroot; "/../" doesn't override this */
549 1.133 dholland erootdir = ndp->ni_erootdir;
550 1.133 dholland } else if (!strncmp(ndp->ni_pnbuf, "/../", 4)) {
551 1.133 dholland /* explicit reference to real rootdir */
552 1.133 dholland erootdir = NULL;
553 1.133 dholland } else {
554 1.133 dholland /* may be null */
555 1.133 dholland erootdir = cwdi->cwdi_edir;
556 1.133 dholland }
557 1.21 kleink
558 1.133 dholland /* current dir */
559 1.196 dholland curdir = cwdi->cwdi_cdir;
560 1.85 dsl
561 1.133 dholland if (ndp->ni_pnbuf[0] != '/') {
562 1.198 dholland if (ndp->ni_atdir != NULL) {
563 1.198 dholland startdir = ndp->ni_atdir;
564 1.196 dholland } else {
565 1.196 dholland startdir = curdir;
566 1.196 dholland }
567 1.133 dholland erootdir = NULL;
568 1.133 dholland } else if (cnp->cn_flags & TRYEMULROOT && erootdir != NULL) {
569 1.133 dholland startdir = erootdir;
570 1.23 mycroft } else {
571 1.133 dholland startdir = rootdir;
572 1.133 dholland erootdir = NULL;
573 1.23 mycroft }
574 1.133 dholland
575 1.133 dholland state->ndp->ni_rootdir = rootdir;
576 1.133 dholland state->ndp->ni_erootdir = erootdir;
577 1.117 dholland
578 1.117 dholland /*
579 1.133 dholland * Get a reference to the start dir so we can safely unlock cwdi.
580 1.133 dholland *
581 1.133 dholland * XXX: should we hold references to rootdir and erootdir while
582 1.133 dholland * we're running? What happens if a multithreaded process chroots
583 1.133 dholland * during namei?
584 1.117 dholland */
585 1.133 dholland vref(startdir);
586 1.133 dholland
587 1.133 dholland rw_exit(&cwdi->cwdi_lock);
588 1.133 dholland return startdir;
589 1.133 dholland }
590 1.133 dholland
591 1.133 dholland /*
592 1.133 dholland * Get the directory context for the nfsd case, in parallel to
593 1.133 dholland * getstartdir. Initializes the rootdir and erootdir state and
594 1.173 dholland * returns a reference to the passed-in starting dir.
595 1.133 dholland */
596 1.133 dholland static struct vnode *
597 1.196 dholland namei_getstartdir_for_nfsd(struct namei_state *state)
598 1.133 dholland {
599 1.198 dholland KASSERT(state->ndp->ni_atdir != NULL);
600 1.193 dholland
601 1.133 dholland /* always use the real root, and never set an emulation root */
602 1.133 dholland state->ndp->ni_rootdir = rootvnode;
603 1.133 dholland state->ndp->ni_erootdir = NULL;
604 1.133 dholland
605 1.198 dholland vref(state->ndp->ni_atdir);
606 1.198 dholland return state->ndp->ni_atdir;
607 1.133 dholland }
608 1.133 dholland
609 1.133 dholland
610 1.133 dholland /*
611 1.133 dholland * Ktrace the namei operation.
612 1.133 dholland */
613 1.133 dholland static void
614 1.133 dholland namei_ktrace(struct namei_state *state)
615 1.133 dholland {
616 1.133 dholland struct nameidata *ndp = state->ndp;
617 1.133 dholland struct componentname *cnp = state->cnp;
618 1.133 dholland struct lwp *self = curlwp; /* thread doing namei() */
619 1.133 dholland const char *emul_path;
620 1.133 dholland
621 1.97 ad if (ktrpoint(KTR_NAMEI)) {
622 1.90 dsl if (ndp->ni_erootdir != NULL) {
623 1.89 dsl /*
624 1.89 dsl * To make any sense, the trace entry need to have the
625 1.89 dsl * text of the emulation path prepended.
626 1.89 dsl * Usually we can get this from the current process,
627 1.89 dsl * but when called from emul_find_interp() it is only
628 1.89 dsl * in the exec_package - so we get it passed in ni_next
629 1.89 dsl * (this is a hack).
630 1.89 dsl */
631 1.88 dsl if (cnp->cn_flags & EMULROOTSET)
632 1.89 dsl emul_path = ndp->ni_next;
633 1.88 dsl else
634 1.117 dholland emul_path = self->l_proc->p_emul->e_path;
635 1.97 ad ktrnamei2(emul_path, strlen(emul_path),
636 1.124 dholland ndp->ni_pnbuf, ndp->ni_pathlen);
637 1.88 dsl } else
638 1.124 dholland ktrnamei(ndp->ni_pnbuf, ndp->ni_pathlen);
639 1.88 dsl }
640 1.133 dholland }
641 1.133 dholland
642 1.133 dholland /*
643 1.166 dholland * Start up namei. Find the root dir and cwd, establish the starting
644 1.166 dholland * directory for lookup, and lock it. Also calls ktrace when
645 1.133 dholland * appropriate.
646 1.133 dholland */
647 1.133 dholland static int
648 1.196 dholland namei_start(struct namei_state *state, int isnfsd,
649 1.140 dholland struct vnode **startdir_ret)
650 1.133 dholland {
651 1.133 dholland struct nameidata *ndp = state->ndp;
652 1.140 dholland struct vnode *startdir;
653 1.133 dholland
654 1.133 dholland /* length includes null terminator (was originally from copyinstr) */
655 1.133 dholland ndp->ni_pathlen = strlen(ndp->ni_pnbuf) + 1;
656 1.133 dholland
657 1.133 dholland /*
658 1.133 dholland * POSIX.1 requirement: "" is not a valid file name.
659 1.133 dholland */
660 1.133 dholland if (ndp->ni_pathlen == 1) {
661 1.133 dholland return ENOENT;
662 1.133 dholland }
663 1.133 dholland
664 1.133 dholland ndp->ni_loopcnt = 0;
665 1.133 dholland
666 1.133 dholland /* Get starting directory, set up root, and ktrace. */
667 1.193 dholland if (isnfsd) {
668 1.196 dholland startdir = namei_getstartdir_for_nfsd(state);
669 1.133 dholland /* no ktrace */
670 1.133 dholland } else {
671 1.196 dholland startdir = namei_getstartdir(state);
672 1.133 dholland namei_ktrace(state);
673 1.133 dholland }
674 1.97 ad
675 1.200 manu /* NDAT may feed us with a non directory namei_getstartdir */
676 1.207.2.1 martin if (startdir->v_type != VDIR) {
677 1.207.2.1 martin vrele(startdir);
678 1.200 manu return ENOTDIR;
679 1.207.2.1 martin }
680 1.200 manu
681 1.140 dholland vn_lock(startdir, LK_EXCLUSIVE | LK_RETRY);
682 1.117 dholland
683 1.140 dholland *startdir_ret = startdir;
684 1.117 dholland return 0;
685 1.117 dholland }
686 1.117 dholland
687 1.117 dholland /*
688 1.173 dholland * Check for being at a symlink that we're going to follow.
689 1.117 dholland */
690 1.117 dholland static inline int
691 1.144 dholland namei_atsymlink(struct namei_state *state, struct vnode *foundobj)
692 1.117 dholland {
693 1.144 dholland return (foundobj->v_type == VLNK) &&
694 1.139 dholland (state->cnp->cn_flags & (FOLLOW|REQUIREDIR));
695 1.117 dholland }
696 1.117 dholland
697 1.117 dholland /*
698 1.117 dholland * Follow a symlink.
699 1.173 dholland *
700 1.173 dholland * Updates searchdir. inhibitmagic causes magic symlinks to not be
701 1.173 dholland * interpreted; this is used by nfsd.
702 1.174 jakllsch *
703 1.174 jakllsch * Unlocks foundobj on success (ugh)
704 1.117 dholland */
705 1.117 dholland static inline int
706 1.141 dholland namei_follow(struct namei_state *state, int inhibitmagic,
707 1.161 dholland struct vnode *searchdir, struct vnode *foundobj,
708 1.141 dholland struct vnode **newsearchdir_ret)
709 1.117 dholland {
710 1.117 dholland struct nameidata *ndp = state->ndp;
711 1.117 dholland struct componentname *cnp = state->cnp;
712 1.117 dholland
713 1.117 dholland struct lwp *self = curlwp; /* thread doing namei() */
714 1.117 dholland struct iovec aiov; /* uio for reading symbolic links */
715 1.117 dholland struct uio auio;
716 1.117 dholland char *cp; /* pointer into pathname argument */
717 1.117 dholland size_t linklen;
718 1.117 dholland int error;
719 1.117 dholland
720 1.175 yamt KASSERT(VOP_ISLOCKED(searchdir) == LK_EXCLUSIVE);
721 1.175 yamt KASSERT(VOP_ISLOCKED(foundobj) == LK_EXCLUSIVE);
722 1.117 dholland if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
723 1.117 dholland return ELOOP;
724 1.117 dholland }
725 1.161 dholland if (foundobj->v_mount->mnt_flag & MNT_SYMPERM) {
726 1.161 dholland error = VOP_ACCESS(foundobj, VEXEC, cnp->cn_cred);
727 1.117 dholland if (error != 0)
728 1.117 dholland return error;
729 1.117 dholland }
730 1.124 dholland
731 1.124 dholland /* FUTURE: fix this to not use a second buffer */
732 1.124 dholland cp = PNBUF_GET();
733 1.117 dholland aiov.iov_base = cp;
734 1.117 dholland aiov.iov_len = MAXPATHLEN;
735 1.117 dholland auio.uio_iov = &aiov;
736 1.117 dholland auio.uio_iovcnt = 1;
737 1.117 dholland auio.uio_offset = 0;
738 1.117 dholland auio.uio_rw = UIO_READ;
739 1.117 dholland auio.uio_resid = MAXPATHLEN;
740 1.117 dholland UIO_SETUP_SYSSPACE(&auio);
741 1.161 dholland error = VOP_READLINK(foundobj, &auio, cnp->cn_cred);
742 1.117 dholland if (error) {
743 1.124 dholland PNBUF_PUT(cp);
744 1.117 dholland return error;
745 1.117 dholland }
746 1.117 dholland linklen = MAXPATHLEN - auio.uio_resid;
747 1.117 dholland if (linklen == 0) {
748 1.124 dholland PNBUF_PUT(cp);
749 1.124 dholland return ENOENT;
750 1.117 dholland }
751 1.117 dholland
752 1.117 dholland /*
753 1.117 dholland * Do symlink substitution, if appropriate, and
754 1.117 dholland * check length for potential overflow.
755 1.134 dholland *
756 1.134 dholland * Inhibit symlink substitution for nfsd.
757 1.134 dholland * XXX: This is how it was before; is that a bug or a feature?
758 1.117 dholland */
759 1.134 dholland if ((!inhibitmagic && vfs_magiclinks &&
760 1.117 dholland symlink_magic(self->l_proc, cp, &linklen)) ||
761 1.117 dholland (linklen + ndp->ni_pathlen >= MAXPATHLEN)) {
762 1.124 dholland PNBUF_PUT(cp);
763 1.124 dholland return ENAMETOOLONG;
764 1.117 dholland }
765 1.117 dholland if (ndp->ni_pathlen > 1) {
766 1.124 dholland /* includes a null-terminator */
767 1.117 dholland memcpy(cp + linklen, ndp->ni_next, ndp->ni_pathlen);
768 1.124 dholland } else {
769 1.124 dholland cp[linklen] = '\0';
770 1.124 dholland }
771 1.117 dholland ndp->ni_pathlen += linklen;
772 1.124 dholland memcpy(ndp->ni_pnbuf, cp, ndp->ni_pathlen);
773 1.124 dholland PNBUF_PUT(cp);
774 1.167 dholland
775 1.167 dholland /* we're now starting from the beginning of the buffer again */
776 1.167 dholland cnp->cn_nameptr = ndp->ni_pnbuf;
777 1.117 dholland
778 1.174 jakllsch /* must unlock this before relocking searchdir */
779 1.174 jakllsch VOP_UNLOCK(foundobj);
780 1.174 jakllsch
781 1.117 dholland /*
782 1.117 dholland * Check if root directory should replace current directory.
783 1.117 dholland */
784 1.124 dholland if (ndp->ni_pnbuf[0] == '/') {
785 1.141 dholland vput(searchdir);
786 1.117 dholland /* Keep absolute symbolic links inside emulation root */
787 1.141 dholland searchdir = ndp->ni_erootdir;
788 1.141 dholland if (searchdir == NULL ||
789 1.124 dholland (ndp->ni_pnbuf[1] == '.'
790 1.124 dholland && ndp->ni_pnbuf[2] == '.'
791 1.124 dholland && ndp->ni_pnbuf[3] == '/')) {
792 1.117 dholland ndp->ni_erootdir = NULL;
793 1.141 dholland searchdir = ndp->ni_rootdir;
794 1.117 dholland }
795 1.141 dholland vref(searchdir);
796 1.141 dholland vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
797 1.186 dholland while (cnp->cn_nameptr[0] == '/') {
798 1.186 dholland cnp->cn_nameptr++;
799 1.186 dholland ndp->ni_pathlen--;
800 1.186 dholland }
801 1.117 dholland }
802 1.117 dholland
803 1.141 dholland *newsearchdir_ret = searchdir;
804 1.175 yamt KASSERT(VOP_ISLOCKED(searchdir) == LK_EXCLUSIVE);
805 1.117 dholland return 0;
806 1.117 dholland }
807 1.117 dholland
808 1.117 dholland //////////////////////////////
809 1.117 dholland
810 1.39 lukem /*
811 1.173 dholland * Inspect the leading path component and update the state accordingly.
812 1.10 cgd */
813 1.118 dholland static int
814 1.118 dholland lookup_parsepath(struct namei_state *state)
815 1.118 dholland {
816 1.118 dholland const char *cp; /* pointer into pathname argument */
817 1.118 dholland
818 1.118 dholland struct componentname *cnp = state->cnp;
819 1.118 dholland struct nameidata *ndp = state->ndp;
820 1.118 dholland
821 1.118 dholland KASSERT(cnp == &ndp->ni_cnd);
822 1.118 dholland
823 1.10 cgd /*
824 1.10 cgd * Search a new directory.
825 1.10 cgd *
826 1.10 cgd * The last component of the filename is left accessible via
827 1.12 mycroft * cnp->cn_nameptr for callers that need the name. Callers needing
828 1.10 cgd * the name set the SAVENAME flag. When done, they assume
829 1.10 cgd * responsibility for freeing the pathname buffer.
830 1.127 yamt *
831 1.147 dholland * At this point, our only vnode state is that the search dir
832 1.147 dholland * is held and locked.
833 1.10 cgd */
834 1.12 mycroft cnp->cn_consume = 0;
835 1.197 dholland cnp->cn_namelen = namei_getcomponent(cnp->cn_nameptr);
836 1.197 dholland cp = cnp->cn_nameptr + cnp->cn_namelen;
837 1.191 christos if (cnp->cn_namelen > KERNEL_NAME_MAX) {
838 1.118 dholland return ENAMETOOLONG;
839 1.10 cgd }
840 1.10 cgd #ifdef NAMEI_DIAGNOSTIC
841 1.10 cgd { char c = *cp;
842 1.41 soren *(char *)cp = '\0';
843 1.19 christos printf("{%s}: ", cnp->cn_nameptr);
844 1.41 soren *(char *)cp = c; }
845 1.52 yamt #endif /* NAMEI_DIAGNOSTIC */
846 1.12 mycroft ndp->ni_pathlen -= cnp->cn_namelen;
847 1.10 cgd ndp->ni_next = cp;
848 1.23 mycroft /*
849 1.23 mycroft * If this component is followed by a slash, then move the pointer to
850 1.23 mycroft * the next component forward, and remember that this component must be
851 1.23 mycroft * a directory.
852 1.23 mycroft */
853 1.23 mycroft if (*cp == '/') {
854 1.23 mycroft do {
855 1.23 mycroft cp++;
856 1.23 mycroft } while (*cp == '/');
857 1.118 dholland state->slashes = cp - ndp->ni_next;
858 1.118 dholland ndp->ni_pathlen -= state->slashes;
859 1.23 mycroft ndp->ni_next = cp;
860 1.23 mycroft cnp->cn_flags |= REQUIREDIR;
861 1.23 mycroft } else {
862 1.118 dholland state->slashes = 0;
863 1.23 mycroft cnp->cn_flags &= ~REQUIREDIR;
864 1.23 mycroft }
865 1.23 mycroft /*
866 1.23 mycroft * We do special processing on the last component, whether or not it's
867 1.23 mycroft * a directory. Cache all intervening lookups, but not the final one.
868 1.23 mycroft */
869 1.23 mycroft if (*cp == '\0') {
870 1.118 dholland if (state->docache)
871 1.23 mycroft cnp->cn_flags |= MAKEENTRY;
872 1.23 mycroft else
873 1.23 mycroft cnp->cn_flags &= ~MAKEENTRY;
874 1.23 mycroft cnp->cn_flags |= ISLASTCN;
875 1.23 mycroft } else {
876 1.23 mycroft cnp->cn_flags |= MAKEENTRY;
877 1.23 mycroft cnp->cn_flags &= ~ISLASTCN;
878 1.23 mycroft }
879 1.12 mycroft if (cnp->cn_namelen == 2 &&
880 1.12 mycroft cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
881 1.12 mycroft cnp->cn_flags |= ISDOTDOT;
882 1.12 mycroft else
883 1.12 mycroft cnp->cn_flags &= ~ISDOTDOT;
884 1.10 cgd
885 1.118 dholland return 0;
886 1.118 dholland }
887 1.118 dholland
888 1.173 dholland /*
889 1.173 dholland * Call VOP_LOOKUP for a single lookup; return a new search directory
890 1.173 dholland * (used when crossing mountpoints up or searching union mounts down) and
891 1.173 dholland * the found object, which for create operations may be NULL on success.
892 1.204 dholland *
893 1.204 dholland * Note that the new search directory may be null, which means the
894 1.204 dholland * searchdir was unlocked and released. This happens in the common case
895 1.204 dholland * when crossing a mount point downwards, in order to avoid coupling
896 1.204 dholland * locks between different file system volumes. Importantly, this can
897 1.204 dholland * happen even if the call fails. (XXX: this is gross and should be
898 1.204 dholland * tidied somehow.)
899 1.173 dholland */
900 1.118 dholland static int
901 1.147 dholland lookup_once(struct namei_state *state,
902 1.147 dholland struct vnode *searchdir,
903 1.150 dholland struct vnode **newsearchdir_ret,
904 1.147 dholland struct vnode **foundobj_ret)
905 1.118 dholland {
906 1.163 dholland struct vnode *tmpvn; /* scratch vnode */
907 1.163 dholland struct vnode *foundobj; /* result */
908 1.118 dholland struct mount *mp; /* mount table entry */
909 1.118 dholland struct lwp *l = curlwp;
910 1.118 dholland int error;
911 1.118 dholland
912 1.118 dholland struct componentname *cnp = state->cnp;
913 1.118 dholland struct nameidata *ndp = state->ndp;
914 1.118 dholland
915 1.118 dholland KASSERT(cnp == &ndp->ni_cnd);
916 1.175 yamt KASSERT(VOP_ISLOCKED(searchdir) == LK_EXCLUSIVE);
917 1.154 dholland *newsearchdir_ret = searchdir;
918 1.118 dholland
919 1.10 cgd /*
920 1.10 cgd * Handle "..": two special cases.
921 1.10 cgd * 1. If at root directory (e.g. after chroot)
922 1.12 mycroft * or at absolute root directory
923 1.10 cgd * then ignore it so can't get out.
924 1.85 dsl * 1a. If at the root of the emulation filesystem go to the real
925 1.85 dsl * root. So "/../<path>" is always absolute.
926 1.85 dsl * 1b. If we have somehow gotten out of a jail, warn
927 1.40 wrstuden * and also ignore it so we can't get farther out.
928 1.10 cgd * 2. If this vnode is the root of a mounted
929 1.10 cgd * filesystem, then replace it with the
930 1.10 cgd * vnode which was mounted on so we take the
931 1.10 cgd * .. in the other file system.
932 1.10 cgd */
933 1.12 mycroft if (cnp->cn_flags & ISDOTDOT) {
934 1.64 christos struct proc *p = l->l_proc;
935 1.64 christos
936 1.10 cgd for (;;) {
937 1.154 dholland if (searchdir == ndp->ni_rootdir ||
938 1.154 dholland searchdir == rootvnode) {
939 1.147 dholland foundobj = searchdir;
940 1.147 dholland vref(foundobj);
941 1.147 dholland *foundobj_ret = foundobj;
942 1.175 yamt error = 0;
943 1.175 yamt goto done;
944 1.40 wrstuden }
945 1.40 wrstuden if (ndp->ni_rootdir != rootvnode) {
946 1.40 wrstuden int retval;
947 1.73 chs
948 1.147 dholland VOP_UNLOCK(searchdir);
949 1.147 dholland retval = vn_isunder(searchdir, ndp->ni_rootdir, l);
950 1.147 dholland vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
951 1.40 wrstuden if (!retval) {
952 1.40 wrstuden /* Oops! We got out of jail! */
953 1.40 wrstuden log(LOG_WARNING,
954 1.40 wrstuden "chrooted pid %d uid %d (%s) "
955 1.40 wrstuden "detected outside of its chroot\n",
956 1.71 ad p->p_pid, kauth_cred_geteuid(l->l_cred),
957 1.64 christos p->p_comm);
958 1.40 wrstuden /* Put us at the jail root. */
959 1.147 dholland vput(searchdir);
960 1.147 dholland searchdir = NULL;
961 1.147 dholland foundobj = ndp->ni_rootdir;
962 1.147 dholland vref(foundobj);
963 1.147 dholland vref(foundobj);
964 1.147 dholland vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
965 1.150 dholland *newsearchdir_ret = foundobj;
966 1.147 dholland *foundobj_ret = foundobj;
967 1.175 yamt error = 0;
968 1.175 yamt goto done;
969 1.40 wrstuden }
970 1.10 cgd }
971 1.147 dholland if ((searchdir->v_vflag & VV_ROOT) == 0 ||
972 1.12 mycroft (cnp->cn_flags & NOCROSSMOUNT))
973 1.10 cgd break;
974 1.163 dholland tmpvn = searchdir;
975 1.147 dholland searchdir = searchdir->v_mount->mnt_vnodecovered;
976 1.153 dholland vref(searchdir);
977 1.163 dholland vput(tmpvn);
978 1.147 dholland vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
979 1.154 dholland *newsearchdir_ret = searchdir;
980 1.10 cgd }
981 1.10 cgd }
982 1.10 cgd
983 1.10 cgd /*
984 1.10 cgd * We now have a segment name to search for, and a directory to search.
985 1.147 dholland * Our vnode state here is that "searchdir" is held and locked.
986 1.10 cgd */
987 1.12 mycroft unionlookup:
988 1.148 dholland foundobj = NULL;
989 1.148 dholland error = VOP_LOOKUP(searchdir, &foundobj, cnp);
990 1.154 dholland
991 1.73 chs if (error != 0) {
992 1.205 riastrad KASSERTMSG((foundobj == NULL),
993 1.205 riastrad "leaf `%s' should be empty but is %p",
994 1.205 riastrad cnp->cn_nameptr, foundobj);
995 1.10 cgd #ifdef NAMEI_DIAGNOSTIC
996 1.19 christos printf("not found\n");
997 1.52 yamt #endif /* NAMEI_DIAGNOSTIC */
998 1.12 mycroft if ((error == ENOENT) &&
999 1.147 dholland (searchdir->v_vflag & VV_ROOT) &&
1000 1.147 dholland (searchdir->v_mount->mnt_flag & MNT_UNION)) {
1001 1.163 dholland tmpvn = searchdir;
1002 1.147 dholland searchdir = searchdir->v_mount->mnt_vnodecovered;
1003 1.153 dholland vref(searchdir);
1004 1.163 dholland vput(tmpvn);
1005 1.147 dholland vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1006 1.154 dholland *newsearchdir_ret = searchdir;
1007 1.12 mycroft goto unionlookup;
1008 1.10 cgd }
1009 1.12 mycroft
1010 1.10 cgd if (error != EJUSTRETURN)
1011 1.175 yamt goto done;
1012 1.73 chs
1013 1.10 cgd /*
1014 1.23 mycroft * If this was not the last component, or there were trailing
1015 1.51 christos * slashes, and we are not going to create a directory,
1016 1.51 christos * then the name must exist.
1017 1.23 mycroft */
1018 1.51 christos if ((cnp->cn_flags & (REQUIREDIR | CREATEDIR)) == REQUIREDIR) {
1019 1.175 yamt error = ENOENT;
1020 1.175 yamt goto done;
1021 1.23 mycroft }
1022 1.73 chs
1023 1.23 mycroft /*
1024 1.10 cgd * If creating and at end of pathname, then can consider
1025 1.10 cgd * allowing file to be created.
1026 1.10 cgd */
1027 1.118 dholland if (state->rdonly) {
1028 1.175 yamt error = EROFS;
1029 1.175 yamt goto done;
1030 1.10 cgd }
1031 1.73 chs
1032 1.10 cgd /*
1033 1.166 dholland * We return success and a NULL foundobj to indicate
1034 1.166 dholland * that the entry doesn't currently exist, leaving a
1035 1.173 dholland * pointer to the (normally, locked) directory vnode
1036 1.173 dholland * as searchdir.
1037 1.10 cgd */
1038 1.147 dholland *foundobj_ret = NULL;
1039 1.175 yamt error = 0;
1040 1.175 yamt goto done;
1041 1.10 cgd }
1042 1.10 cgd #ifdef NAMEI_DIAGNOSTIC
1043 1.19 christos printf("found\n");
1044 1.52 yamt #endif /* NAMEI_DIAGNOSTIC */
1045 1.10 cgd
1046 1.12 mycroft /*
1047 1.23 mycroft * Take into account any additional components consumed by the
1048 1.23 mycroft * underlying filesystem. This will include any trailing slashes after
1049 1.23 mycroft * the last component consumed.
1050 1.12 mycroft */
1051 1.12 mycroft if (cnp->cn_consume > 0) {
1052 1.118 dholland ndp->ni_pathlen -= cnp->cn_consume - state->slashes;
1053 1.118 dholland ndp->ni_next += cnp->cn_consume - state->slashes;
1054 1.12 mycroft cnp->cn_consume = 0;
1055 1.23 mycroft if (ndp->ni_next[0] == '\0')
1056 1.23 mycroft cnp->cn_flags |= ISLASTCN;
1057 1.12 mycroft }
1058 1.12 mycroft
1059 1.73 chs /*
1060 1.201 hannken * "searchdir" is locked and held, "foundobj" is held,
1061 1.201 hannken * they may be the same vnode.
1062 1.73 chs */
1063 1.201 hannken if (searchdir != foundobj) {
1064 1.201 hannken if (cnp->cn_flags & ISDOTDOT)
1065 1.201 hannken VOP_UNLOCK(searchdir);
1066 1.201 hannken error = vn_lock(foundobj, LK_EXCLUSIVE);
1067 1.201 hannken if (cnp->cn_flags & ISDOTDOT)
1068 1.201 hannken vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1069 1.201 hannken if (error != 0) {
1070 1.201 hannken vrele(foundobj);
1071 1.201 hannken goto done;
1072 1.201 hannken }
1073 1.201 hannken }
1074 1.73 chs
1075 1.10 cgd /*
1076 1.10 cgd * Check to see if the vnode has been mounted on;
1077 1.10 cgd * if so find the root of the mounted file system.
1078 1.10 cgd */
1079 1.204 dholland KASSERT(searchdir != NULL);
1080 1.169 dholland while (foundobj->v_type == VDIR &&
1081 1.169 dholland (mp = foundobj->v_mountedhere) != NULL &&
1082 1.12 mycroft (cnp->cn_flags & NOCROSSMOUNT) == 0) {
1083 1.204 dholland
1084 1.204 dholland KASSERT(searchdir != foundobj);
1085 1.204 dholland
1086 1.206 hannken error = vfs_busy(mp);
1087 1.107 ad if (error != 0) {
1088 1.204 dholland vput(foundobj);
1089 1.175 yamt goto done;
1090 1.107 ad }
1091 1.204 dholland if (searchdir != NULL) {
1092 1.190 yamt VOP_UNLOCK(searchdir);
1093 1.190 yamt }
1094 1.147 dholland vput(foundobj);
1095 1.163 dholland error = VFS_ROOT(mp, &foundobj);
1096 1.206 hannken vfs_unbusy(mp);
1097 1.32 wrstuden if (error) {
1098 1.204 dholland if (searchdir != NULL) {
1099 1.204 dholland vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1100 1.204 dholland }
1101 1.175 yamt goto done;
1102 1.32 wrstuden }
1103 1.190 yamt /*
1104 1.204 dholland * Avoid locking vnodes from two filesystems because
1105 1.204 dholland * it's prone to deadlock, e.g. when using puffs.
1106 1.204 dholland * Also, it isn't a good idea to propagate slowness of
1107 1.204 dholland * a filesystem up to the root directory. For now,
1108 1.204 dholland * only handle the common case, where foundobj is
1109 1.204 dholland * VDIR.
1110 1.204 dholland *
1111 1.204 dholland * In this case set searchdir to null to avoid using
1112 1.204 dholland * it again. It is not correct to set searchdir ==
1113 1.204 dholland * foundobj here as that will confuse the caller.
1114 1.204 dholland * (See PR 40740.)
1115 1.190 yamt */
1116 1.204 dholland if (searchdir == NULL) {
1117 1.204 dholland /* already been here once; do nothing further */
1118 1.204 dholland } else if (foundobj->v_type == VDIR) {
1119 1.190 yamt vrele(searchdir);
1120 1.204 dholland *newsearchdir_ret = searchdir = NULL;
1121 1.190 yamt } else {
1122 1.190 yamt VOP_UNLOCK(foundobj);
1123 1.190 yamt vn_lock(searchdir, LK_EXCLUSIVE | LK_RETRY);
1124 1.190 yamt vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
1125 1.190 yamt }
1126 1.14 mycroft }
1127 1.14 mycroft
1128 1.147 dholland *foundobj_ret = foundobj;
1129 1.175 yamt error = 0;
1130 1.175 yamt done:
1131 1.204 dholland KASSERT(*newsearchdir_ret == NULL ||
1132 1.204 dholland VOP_ISLOCKED(*newsearchdir_ret) == LK_EXCLUSIVE);
1133 1.175 yamt /*
1134 1.175 yamt * *foundobj_ret is valid only if error == 0.
1135 1.175 yamt */
1136 1.175 yamt KASSERT(error != 0 || *foundobj_ret == NULL ||
1137 1.175 yamt VOP_ISLOCKED(*foundobj_ret) == LK_EXCLUSIVE);
1138 1.175 yamt return error;
1139 1.118 dholland }
1140 1.118 dholland
1141 1.131 dholland //////////////////////////////
1142 1.131 dholland
1143 1.173 dholland /*
1144 1.173 dholland * Do a complete path search from a single root directory.
1145 1.173 dholland * (This is called up to twice if TRYEMULROOT is in effect.)
1146 1.173 dholland */
1147 1.131 dholland static int
1148 1.196 dholland namei_oneroot(struct namei_state *state,
1149 1.193 dholland int neverfollow, int inhibitmagic, int isnfsd)
1150 1.131 dholland {
1151 1.131 dholland struct nameidata *ndp = state->ndp;
1152 1.131 dholland struct componentname *cnp = state->cnp;
1153 1.146 dholland struct vnode *searchdir, *foundobj;
1154 1.137 dholland int error;
1155 1.131 dholland
1156 1.196 dholland error = namei_start(state, isnfsd, &searchdir);
1157 1.131 dholland if (error) {
1158 1.164 dholland ndp->ni_dvp = NULL;
1159 1.164 dholland ndp->ni_vp = NULL;
1160 1.131 dholland return error;
1161 1.131 dholland }
1162 1.185 dholland KASSERT(searchdir->v_type == VDIR);
1163 1.131 dholland
1164 1.133 dholland /*
1165 1.139 dholland * Setup: break out flag bits into variables.
1166 1.139 dholland */
1167 1.139 dholland state->docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
1168 1.139 dholland if (cnp->cn_nameiop == DELETE)
1169 1.139 dholland state->docache = 0;
1170 1.139 dholland state->rdonly = cnp->cn_flags & RDONLY;
1171 1.139 dholland
1172 1.139 dholland /*
1173 1.133 dholland * Keep going until we run out of path components.
1174 1.133 dholland */
1175 1.139 dholland cnp->cn_nameptr = ndp->ni_pnbuf;
1176 1.185 dholland
1177 1.185 dholland /* drop leading slashes (already used them to choose startdir) */
1178 1.185 dholland while (cnp->cn_nameptr[0] == '/') {
1179 1.185 dholland cnp->cn_nameptr++;
1180 1.185 dholland ndp->ni_pathlen--;
1181 1.185 dholland }
1182 1.185 dholland /* was it just "/"? */
1183 1.185 dholland if (cnp->cn_nameptr[0] == '\0') {
1184 1.185 dholland foundobj = searchdir;
1185 1.185 dholland searchdir = NULL;
1186 1.185 dholland cnp->cn_flags |= ISLASTCN;
1187 1.185 dholland
1188 1.185 dholland /* bleh */
1189 1.185 dholland goto skiploop;
1190 1.185 dholland }
1191 1.185 dholland
1192 1.131 dholland for (;;) {
1193 1.204 dholland KASSERT(searchdir != NULL);
1194 1.204 dholland KASSERT(VOP_ISLOCKED(searchdir) == LK_EXCLUSIVE);
1195 1.133 dholland
1196 1.133 dholland /*
1197 1.188 dholland * If the directory we're on is unmounted, bail out.
1198 1.188 dholland * XXX: should this also check if it's unlinked?
1199 1.188 dholland * XXX: yes it should... but how?
1200 1.133 dholland */
1201 1.188 dholland if (searchdir->v_mount == NULL) {
1202 1.152 dholland vput(searchdir);
1203 1.164 dholland ndp->ni_dvp = NULL;
1204 1.164 dholland ndp->ni_vp = NULL;
1205 1.131 dholland return (ENOENT);
1206 1.131 dholland }
1207 1.133 dholland
1208 1.133 dholland /*
1209 1.133 dholland * Look up the next path component.
1210 1.133 dholland * (currently, this may consume more than one)
1211 1.133 dholland */
1212 1.138 dholland
1213 1.185 dholland /* There should be no slashes here. */
1214 1.185 dholland KASSERT(cnp->cn_nameptr[0] != '/');
1215 1.138 dholland
1216 1.185 dholland /* and we shouldn't have looped around if we were done */
1217 1.185 dholland KASSERT(cnp->cn_nameptr[0] != '\0');
1218 1.139 dholland
1219 1.139 dholland error = lookup_parsepath(state);
1220 1.139 dholland if (error) {
1221 1.145 dholland vput(searchdir);
1222 1.168 dholland ndp->ni_dvp = NULL;
1223 1.139 dholland ndp->ni_vp = NULL;
1224 1.137 dholland state->attempt_retry = 1;
1225 1.131 dholland return (error);
1226 1.131 dholland }
1227 1.138 dholland
1228 1.150 dholland error = lookup_once(state, searchdir, &searchdir, &foundobj);
1229 1.139 dholland if (error) {
1230 1.204 dholland if (searchdir != NULL) {
1231 1.204 dholland vput(searchdir);
1232 1.204 dholland }
1233 1.168 dholland ndp->ni_dvp = NULL;
1234 1.139 dholland ndp->ni_vp = NULL;
1235 1.138 dholland /*
1236 1.139 dholland * Note that if we're doing TRYEMULROOT we can
1237 1.139 dholland * retry with the normal root. Where this is
1238 1.139 dholland * currently set matches previous practice,
1239 1.139 dholland * but the previous practice didn't make much
1240 1.139 dholland * sense and somebody should sit down and
1241 1.139 dholland * figure out which cases should cause retry
1242 1.139 dholland * and which shouldn't. XXX.
1243 1.138 dholland */
1244 1.139 dholland state->attempt_retry = 1;
1245 1.139 dholland return (error);
1246 1.139 dholland }
1247 1.157 dholland
1248 1.162 dholland if (foundobj == NULL) {
1249 1.162 dholland /*
1250 1.162 dholland * Success with no object returned means we're
1251 1.162 dholland * creating something and it isn't already
1252 1.181 dholland * there. Break out of the main loop now so
1253 1.162 dholland * the code below doesn't have to test for
1254 1.162 dholland * foundobj == NULL.
1255 1.162 dholland */
1256 1.204 dholland /* lookup_once can't have dropped the searchdir */
1257 1.204 dholland KASSERT(searchdir != NULL);
1258 1.181 dholland break;
1259 1.138 dholland }
1260 1.131 dholland
1261 1.131 dholland /*
1262 1.139 dholland * Check for symbolic link. If we've reached one,
1263 1.139 dholland * follow it, unless we aren't supposed to. Back up
1264 1.139 dholland * over any slashes that we skipped, as we will need
1265 1.139 dholland * them again.
1266 1.131 dholland */
1267 1.146 dholland if (namei_atsymlink(state, foundobj)) {
1268 1.139 dholland ndp->ni_pathlen += state->slashes;
1269 1.139 dholland ndp->ni_next -= state->slashes;
1270 1.134 dholland if (neverfollow) {
1271 1.134 dholland error = EINVAL;
1272 1.204 dholland } else if (searchdir == NULL) {
1273 1.204 dholland /*
1274 1.204 dholland * dholland 20160410: lookup_once only
1275 1.204 dholland * drops searchdir if it crossed a
1276 1.204 dholland * mount point. Therefore, if we get
1277 1.204 dholland * here it means we crossed a mount
1278 1.204 dholland * point to a mounted filesystem whose
1279 1.204 dholland * root vnode is a symlink. In theory
1280 1.204 dholland * we could continue at this point by
1281 1.204 dholland * using the pre-crossing searchdir
1282 1.204 dholland * (e.g. just take out an extra
1283 1.204 dholland * reference on it before calling
1284 1.204 dholland * lookup_once so we still have it),
1285 1.204 dholland * but this will make an ugly mess and
1286 1.204 dholland * it should never happen in practice
1287 1.204 dholland * as only badly broken filesystems
1288 1.204 dholland * have non-directory root vnodes. (I
1289 1.204 dholland * have seen this sort of thing with
1290 1.204 dholland * NFS occasionally but even then it
1291 1.204 dholland * means something's badly wrong.)
1292 1.204 dholland */
1293 1.204 dholland error = ENOTDIR;
1294 1.134 dholland } else {
1295 1.152 dholland /*
1296 1.152 dholland * dholland 20110410: if we're at a
1297 1.152 dholland * union mount it might make sense to
1298 1.152 dholland * use the top of the union stack here
1299 1.152 dholland * rather than the layer we found the
1300 1.152 dholland * symlink in. (FUTURE)
1301 1.152 dholland */
1302 1.141 dholland error = namei_follow(state, inhibitmagic,
1303 1.165 dholland searchdir, foundobj,
1304 1.152 dholland &searchdir);
1305 1.134 dholland }
1306 1.131 dholland if (error) {
1307 1.165 dholland KASSERT(searchdir != foundobj);
1308 1.204 dholland if (searchdir != NULL) {
1309 1.204 dholland vput(searchdir);
1310 1.204 dholland }
1311 1.165 dholland vput(foundobj);
1312 1.168 dholland ndp->ni_dvp = NULL;
1313 1.131 dholland ndp->ni_vp = NULL;
1314 1.131 dholland return error;
1315 1.131 dholland }
1316 1.174 jakllsch /* namei_follow unlocks it (ugh) so rele, not put */
1317 1.174 jakllsch vrele(foundobj);
1318 1.167 dholland foundobj = NULL;
1319 1.189 riastrad
1320 1.189 riastrad /*
1321 1.189 riastrad * If we followed a symlink to `/' and there
1322 1.189 riastrad * are no more components after the symlink,
1323 1.189 riastrad * we're done with the loop and what we found
1324 1.189 riastrad * is the searchdir.
1325 1.189 riastrad */
1326 1.189 riastrad if (cnp->cn_nameptr[0] == '\0') {
1327 1.204 dholland KASSERT(searchdir != NULL);
1328 1.189 riastrad foundobj = searchdir;
1329 1.189 riastrad searchdir = NULL;
1330 1.189 riastrad cnp->cn_flags |= ISLASTCN;
1331 1.189 riastrad break;
1332 1.189 riastrad }
1333 1.189 riastrad
1334 1.139 dholland continue;
1335 1.139 dholland }
1336 1.139 dholland
1337 1.139 dholland /*
1338 1.183 dholland * Not a symbolic link.
1339 1.183 dholland *
1340 1.139 dholland * Check for directory, if the component was
1341 1.139 dholland * followed by a series of slashes.
1342 1.139 dholland */
1343 1.190 yamt if ((foundobj->v_type != VDIR) &&
1344 1.190 yamt (cnp->cn_flags & REQUIREDIR)) {
1345 1.204 dholland KASSERT(foundobj != searchdir);
1346 1.204 dholland if (searchdir) {
1347 1.157 dholland vput(searchdir);
1348 1.139 dholland }
1349 1.168 dholland vput(foundobj);
1350 1.168 dholland ndp->ni_dvp = NULL;
1351 1.168 dholland ndp->ni_vp = NULL;
1352 1.139 dholland state->attempt_retry = 1;
1353 1.139 dholland return ENOTDIR;
1354 1.139 dholland }
1355 1.139 dholland
1356 1.139 dholland /*
1357 1.183 dholland * Stop if we've reached the last component.
1358 1.139 dholland */
1359 1.183 dholland if (cnp->cn_flags & ISLASTCN) {
1360 1.183 dholland break;
1361 1.139 dholland }
1362 1.139 dholland
1363 1.183 dholland /*
1364 1.183 dholland * Continue with the next component.
1365 1.183 dholland */
1366 1.183 dholland cnp->cn_nameptr = ndp->ni_next;
1367 1.183 dholland if (searchdir == foundobj) {
1368 1.183 dholland vrele(searchdir);
1369 1.204 dholland } else if (searchdir != NULL) {
1370 1.183 dholland vput(searchdir);
1371 1.183 dholland }
1372 1.183 dholland searchdir = foundobj;
1373 1.183 dholland foundobj = NULL;
1374 1.179 dholland }
1375 1.179 dholland
1376 1.185 dholland skiploop:
1377 1.185 dholland
1378 1.182 dholland if (foundobj != NULL) {
1379 1.146 dholland if (foundobj == ndp->ni_erootdir) {
1380 1.139 dholland /*
1381 1.139 dholland * We are about to return the emulation root.
1382 1.139 dholland * This isn't a good idea because code might
1383 1.139 dholland * repeatedly lookup ".." until the file
1384 1.139 dholland * matches that returned for "/" and loop
1385 1.139 dholland * forever. So convert it to the real root.
1386 1.139 dholland */
1387 1.170 dholland if (searchdir != NULL) {
1388 1.170 dholland if (searchdir == foundobj)
1389 1.170 dholland vrele(searchdir);
1390 1.170 dholland else
1391 1.157 dholland vput(searchdir);
1392 1.170 dholland searchdir = NULL;
1393 1.170 dholland }
1394 1.146 dholland vput(foundobj);
1395 1.146 dholland foundobj = ndp->ni_rootdir;
1396 1.146 dholland vref(foundobj);
1397 1.146 dholland vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
1398 1.131 dholland }
1399 1.139 dholland
1400 1.139 dholland /*
1401 1.158 dholland * If the caller requested the parent node (i.e. it's
1402 1.158 dholland * a CREATE, DELETE, or RENAME), and we don't have one
1403 1.158 dholland * (because this is the root directory, or we crossed
1404 1.158 dholland * a mount point), then we must fail.
1405 1.207.2.2 martin *
1406 1.207.2.2 martin * 20210604 dholland when NONEXCLHACK is set (open
1407 1.207.2.2 martin * with O_CREAT but not O_EXCL) skip this logic. Since
1408 1.207.2.2 martin * we have a foundobj, open will not be creating, so
1409 1.207.2.2 martin * it doesn't actually need or use the searchdir, so
1410 1.207.2.2 martin * it's ok to return it even if it's on a different
1411 1.207.2.2 martin * volume, and it's also ok to return NULL; by setting
1412 1.207.2.2 martin * NONEXCLHACK the open code promises to cope with
1413 1.207.2.2 martin * those cases correctly. (That is, it should do what
1414 1.207.2.2 martin * it would do anyway, that is, just release the
1415 1.207.2.2 martin * searchdir, except not crash if it's null.) This is
1416 1.207.2.2 martin * needed because otherwise opening mountpoints with
1417 1.207.2.2 martin * O_CREAT but not O_EXCL fails... which is a silly
1418 1.207.2.2 martin * thing to do but ought to work. (This whole issue
1419 1.207.2.2 martin * came to light because 3rd party code wanted to open
1420 1.207.2.2 martin * certain procfs nodes with O_CREAT for some 3rd
1421 1.207.2.2 martin * party reason, and it failed.)
1422 1.207.2.2 martin *
1423 1.207.2.2 martin * Note that NONEXCLHACK is properly a different
1424 1.207.2.2 martin * nameiop (it is partway between LOOKUP and CREATE)
1425 1.207.2.2 martin * but it was stuffed in as a flag instead to make the
1426 1.207.2.2 martin * resulting patch less invasive for pullup. Blah.
1427 1.139 dholland */
1428 1.158 dholland if (cnp->cn_nameiop != LOOKUP &&
1429 1.158 dholland (searchdir == NULL ||
1430 1.207.2.2 martin searchdir->v_mount != foundobj->v_mount) &&
1431 1.207.2.2 martin (cnp->cn_flags & NONEXCLHACK) == 0) {
1432 1.170 dholland if (searchdir) {
1433 1.170 dholland vput(searchdir);
1434 1.170 dholland }
1435 1.170 dholland vput(foundobj);
1436 1.170 dholland foundobj = NULL;
1437 1.170 dholland ndp->ni_dvp = NULL;
1438 1.170 dholland ndp->ni_vp = NULL;
1439 1.170 dholland state->attempt_retry = 1;
1440 1.170 dholland
1441 1.139 dholland switch (cnp->cn_nameiop) {
1442 1.139 dholland case CREATE:
1443 1.171 dholland return EEXIST;
1444 1.139 dholland case DELETE:
1445 1.139 dholland case RENAME:
1446 1.171 dholland return EBUSY;
1447 1.171 dholland default:
1448 1.139 dholland break;
1449 1.139 dholland }
1450 1.171 dholland panic("Invalid nameiop\n");
1451 1.139 dholland }
1452 1.139 dholland
1453 1.139 dholland /*
1454 1.139 dholland * Disallow directory write attempts on read-only lookups.
1455 1.139 dholland * Prefers EEXIST over EROFS for the CREATE case.
1456 1.139 dholland */
1457 1.139 dholland if (state->rdonly &&
1458 1.139 dholland (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
1459 1.157 dholland if (searchdir) {
1460 1.170 dholland if (foundobj != searchdir) {
1461 1.170 dholland vput(searchdir);
1462 1.170 dholland } else {
1463 1.170 dholland vrele(searchdir);
1464 1.170 dholland }
1465 1.170 dholland searchdir = NULL;
1466 1.157 dholland }
1467 1.170 dholland vput(foundobj);
1468 1.170 dholland foundobj = NULL;
1469 1.168 dholland ndp->ni_dvp = NULL;
1470 1.139 dholland ndp->ni_vp = NULL;
1471 1.139 dholland state->attempt_retry = 1;
1472 1.171 dholland return EROFS;
1473 1.139 dholland }
1474 1.139 dholland if ((cnp->cn_flags & LOCKLEAF) == 0) {
1475 1.172 dholland /*
1476 1.172 dholland * Note: if LOCKPARENT but not LOCKLEAF is
1477 1.172 dholland * set, and searchdir == foundobj, this code
1478 1.172 dholland * necessarily unlocks the parent as well as
1479 1.172 dholland * the leaf. That is, just because you specify
1480 1.172 dholland * LOCKPARENT doesn't mean you necessarily get
1481 1.172 dholland * a locked parent vnode. The code in
1482 1.172 dholland * vfs_syscalls.c, and possibly elsewhere,
1483 1.172 dholland * that uses this combination "knows" this, so
1484 1.172 dholland * it can't be safely changed. Feh. XXX
1485 1.172 dholland */
1486 1.146 dholland VOP_UNLOCK(foundobj);
1487 1.131 dholland }
1488 1.179 dholland }
1489 1.139 dholland
1490 1.131 dholland /*
1491 1.133 dholland * Done.
1492 1.131 dholland */
1493 1.131 dholland
1494 1.133 dholland /*
1495 1.133 dholland * If LOCKPARENT is not set, the parent directory isn't returned.
1496 1.133 dholland */
1497 1.157 dholland if ((cnp->cn_flags & LOCKPARENT) == 0 && searchdir != NULL) {
1498 1.165 dholland if (searchdir == foundobj) {
1499 1.157 dholland vrele(searchdir);
1500 1.131 dholland } else {
1501 1.157 dholland vput(searchdir);
1502 1.131 dholland }
1503 1.157 dholland searchdir = NULL;
1504 1.131 dholland }
1505 1.131 dholland
1506 1.157 dholland ndp->ni_dvp = searchdir;
1507 1.165 dholland ndp->ni_vp = foundobj;
1508 1.137 dholland return 0;
1509 1.137 dholland }
1510 1.137 dholland
1511 1.173 dholland /*
1512 1.173 dholland * Do namei; wrapper layer that handles TRYEMULROOT.
1513 1.173 dholland */
1514 1.137 dholland static int
1515 1.196 dholland namei_tryemulroot(struct namei_state *state,
1516 1.193 dholland int neverfollow, int inhibitmagic, int isnfsd)
1517 1.137 dholland {
1518 1.137 dholland int error;
1519 1.137 dholland
1520 1.137 dholland struct nameidata *ndp = state->ndp;
1521 1.137 dholland struct componentname *cnp = state->cnp;
1522 1.137 dholland const char *savepath = NULL;
1523 1.137 dholland
1524 1.137 dholland KASSERT(cnp == &ndp->ni_cnd);
1525 1.137 dholland
1526 1.137 dholland if (cnp->cn_flags & TRYEMULROOT) {
1527 1.137 dholland savepath = pathbuf_stringcopy_get(ndp->ni_pathbuf);
1528 1.137 dholland }
1529 1.137 dholland
1530 1.137 dholland emul_retry:
1531 1.137 dholland state->attempt_retry = 0;
1532 1.137 dholland
1533 1.196 dholland error = namei_oneroot(state, neverfollow, inhibitmagic, isnfsd);
1534 1.137 dholland if (error) {
1535 1.137 dholland /*
1536 1.137 dholland * Once namei has started up, the existence of ni_erootdir
1537 1.137 dholland * tells us whether we're working from an emulation root.
1538 1.137 dholland * The TRYEMULROOT flag isn't necessarily authoritative.
1539 1.137 dholland */
1540 1.137 dholland if (ndp->ni_erootdir != NULL && state->attempt_retry) {
1541 1.137 dholland /* Retry the whole thing using the normal root */
1542 1.137 dholland cnp->cn_flags &= ~TRYEMULROOT;
1543 1.137 dholland state->attempt_retry = 0;
1544 1.137 dholland
1545 1.137 dholland /* kinda gross */
1546 1.137 dholland strcpy(ndp->ni_pathbuf->pb_path, savepath);
1547 1.137 dholland pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
1548 1.137 dholland savepath = NULL;
1549 1.137 dholland
1550 1.137 dholland goto emul_retry;
1551 1.137 dholland }
1552 1.137 dholland }
1553 1.131 dholland if (savepath != NULL) {
1554 1.131 dholland pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
1555 1.131 dholland }
1556 1.137 dholland return error;
1557 1.131 dholland }
1558 1.131 dholland
1559 1.173 dholland /*
1560 1.173 dholland * External interface.
1561 1.173 dholland */
1562 1.131 dholland int
1563 1.131 dholland namei(struct nameidata *ndp)
1564 1.131 dholland {
1565 1.131 dholland struct namei_state state;
1566 1.131 dholland int error;
1567 1.131 dholland
1568 1.131 dholland namei_init(&state, ndp);
1569 1.196 dholland error = namei_tryemulroot(&state,
1570 1.193 dholland 0/*!neverfollow*/, 0/*!inhibitmagic*/,
1571 1.193 dholland 0/*isnfsd*/);
1572 1.131 dholland namei_cleanup(&state);
1573 1.131 dholland
1574 1.159 dholland if (error) {
1575 1.159 dholland /* make sure no stray refs leak out */
1576 1.164 dholland KASSERT(ndp->ni_dvp == NULL);
1577 1.164 dholland KASSERT(ndp->ni_vp == NULL);
1578 1.159 dholland }
1579 1.159 dholland
1580 1.131 dholland return error;
1581 1.131 dholland }
1582 1.131 dholland
1583 1.131 dholland ////////////////////////////////////////////////////////////
1584 1.131 dholland
1585 1.12 mycroft /*
1586 1.173 dholland * External interface used by nfsd. This is basically different from
1587 1.173 dholland * namei only in that it has the ability to pass in the "current
1588 1.173 dholland * directory", and uses an extra flag "neverfollow" for which there's
1589 1.173 dholland * no physical flag defined in namei.h. (There used to be a cut&paste
1590 1.173 dholland * copy of about half of namei in nfsd to allow these minor
1591 1.173 dholland * adjustments to exist.)
1592 1.119 dholland *
1593 1.173 dholland * XXX: the namei interface should be adjusted so nfsd can just use
1594 1.173 dholland * ordinary namei().
1595 1.118 dholland */
1596 1.134 dholland int
1597 1.135 dholland lookup_for_nfsd(struct nameidata *ndp, struct vnode *forcecwd, int neverfollow)
1598 1.134 dholland {
1599 1.134 dholland struct namei_state state;
1600 1.134 dholland int error;
1601 1.120 dholland
1602 1.198 dholland KASSERT(ndp->ni_atdir == NULL);
1603 1.198 dholland ndp->ni_atdir = forcecwd;
1604 1.194 dholland
1605 1.134 dholland namei_init(&state, ndp);
1606 1.196 dholland error = namei_tryemulroot(&state,
1607 1.193 dholland neverfollow, 1/*inhibitmagic*/, 1/*isnfsd*/);
1608 1.119 dholland namei_cleanup(&state);
1609 1.119 dholland
1610 1.159 dholland if (error) {
1611 1.159 dholland /* make sure no stray refs leak out */
1612 1.164 dholland KASSERT(ndp->ni_dvp == NULL);
1613 1.164 dholland KASSERT(ndp->ni_vp == NULL);
1614 1.159 dholland }
1615 1.159 dholland
1616 1.119 dholland return error;
1617 1.119 dholland }
1618 1.119 dholland
1619 1.173 dholland /*
1620 1.173 dholland * A second external interface used by nfsd. This turns out to be a
1621 1.173 dholland * single lookup used by the WebNFS code (ha!) to get "index.html" or
1622 1.173 dholland * equivalent when asked for a directory. It should eventually evolve
1623 1.173 dholland * into some kind of namei_once() call; for the time being it's kind
1624 1.173 dholland * of a mess. XXX.
1625 1.173 dholland *
1626 1.173 dholland * dholland 20110109: I don't think it works, and I don't think it
1627 1.173 dholland * worked before I started hacking and slashing either, and I doubt
1628 1.173 dholland * anyone will ever notice.
1629 1.173 dholland */
1630 1.173 dholland
1631 1.173 dholland /*
1632 1.173 dholland * Internals. This calls lookup_once() after setting up the assorted
1633 1.173 dholland * pieces of state the way they ought to be.
1634 1.173 dholland */
1635 1.136 dholland static int
1636 1.196 dholland do_lookup_for_nfsd_index(struct namei_state *state)
1637 1.136 dholland {
1638 1.136 dholland int error = 0;
1639 1.136 dholland
1640 1.136 dholland struct componentname *cnp = state->cnp;
1641 1.136 dholland struct nameidata *ndp = state->ndp;
1642 1.196 dholland struct vnode *startdir;
1643 1.147 dholland struct vnode *foundobj;
1644 1.136 dholland const char *cp; /* pointer into pathname argument */
1645 1.136 dholland
1646 1.136 dholland KASSERT(cnp == &ndp->ni_cnd);
1647 1.136 dholland
1648 1.198 dholland startdir = state->ndp->ni_atdir;
1649 1.196 dholland
1650 1.136 dholland cnp->cn_nameptr = ndp->ni_pnbuf;
1651 1.136 dholland state->docache = 1;
1652 1.136 dholland state->rdonly = cnp->cn_flags & RDONLY;
1653 1.136 dholland ndp->ni_dvp = NULL;
1654 1.136 dholland
1655 1.136 dholland cnp->cn_consume = 0;
1656 1.197 dholland cnp->cn_namelen = namei_getcomponent(cnp->cn_nameptr);
1657 1.197 dholland cp = cnp->cn_nameptr + cnp->cn_namelen;
1658 1.191 christos KASSERT(cnp->cn_namelen <= KERNEL_NAME_MAX);
1659 1.136 dholland ndp->ni_pathlen -= cnp->cn_namelen;
1660 1.136 dholland ndp->ni_next = cp;
1661 1.136 dholland state->slashes = 0;
1662 1.136 dholland cnp->cn_flags &= ~REQUIREDIR;
1663 1.136 dholland cnp->cn_flags |= MAKEENTRY|ISLASTCN;
1664 1.136 dholland
1665 1.136 dholland if (cnp->cn_namelen == 2 &&
1666 1.136 dholland cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
1667 1.136 dholland cnp->cn_flags |= ISDOTDOT;
1668 1.136 dholland else
1669 1.136 dholland cnp->cn_flags &= ~ISDOTDOT;
1670 1.136 dholland
1671 1.160 dholland /*
1672 1.160 dholland * Because lookup_once can change the startdir, we need our
1673 1.160 dholland * own reference to it to avoid consuming the caller's.
1674 1.160 dholland */
1675 1.160 dholland vref(startdir);
1676 1.160 dholland vn_lock(startdir, LK_EXCLUSIVE | LK_RETRY);
1677 1.160 dholland error = lookup_once(state, startdir, &startdir, &foundobj);
1678 1.190 yamt if (error == 0 && startdir == foundobj) {
1679 1.190 yamt vrele(startdir);
1680 1.204 dholland } else if (startdir != NULL) {
1681 1.190 yamt vput(startdir);
1682 1.190 yamt }
1683 1.136 dholland if (error) {
1684 1.136 dholland goto bad;
1685 1.136 dholland }
1686 1.149 dholland ndp->ni_vp = foundobj;
1687 1.162 dholland
1688 1.162 dholland if (foundobj == NULL) {
1689 1.136 dholland return 0;
1690 1.136 dholland }
1691 1.136 dholland
1692 1.160 dholland KASSERT((cnp->cn_flags & LOCKPARENT) == 0);
1693 1.136 dholland if ((cnp->cn_flags & LOCKLEAF) == 0) {
1694 1.147 dholland VOP_UNLOCK(foundobj);
1695 1.136 dholland }
1696 1.136 dholland return (0);
1697 1.136 dholland
1698 1.136 dholland bad:
1699 1.136 dholland ndp->ni_vp = NULL;
1700 1.136 dholland return (error);
1701 1.136 dholland }
1702 1.136 dholland
1703 1.173 dholland /*
1704 1.173 dholland * External interface. The partitioning between this function and the
1705 1.173 dholland * above isn't very clear - the above function exists mostly so code
1706 1.173 dholland * that uses "state->" can be shuffled around without having to change
1707 1.173 dholland * it to "state.".
1708 1.173 dholland */
1709 1.118 dholland int
1710 1.128 dholland lookup_for_nfsd_index(struct nameidata *ndp, struct vnode *startdir)
1711 1.118 dholland {
1712 1.118 dholland struct namei_state state;
1713 1.118 dholland int error;
1714 1.118 dholland
1715 1.198 dholland KASSERT(ndp->ni_atdir == NULL);
1716 1.198 dholland ndp->ni_atdir = startdir;
1717 1.194 dholland
1718 1.133 dholland /*
1719 1.135 dholland * Note: the name sent in here (is not|should not be) allowed
1720 1.135 dholland * to contain a slash.
1721 1.133 dholland */
1722 1.191 christos if (strlen(ndp->ni_pathbuf->pb_path) > KERNEL_NAME_MAX) {
1723 1.136 dholland return ENAMETOOLONG;
1724 1.136 dholland }
1725 1.136 dholland if (strchr(ndp->ni_pathbuf->pb_path, '/')) {
1726 1.136 dholland return EINVAL;
1727 1.136 dholland }
1728 1.133 dholland
1729 1.133 dholland ndp->ni_pathlen = strlen(ndp->ni_pathbuf->pb_path) + 1;
1730 1.133 dholland ndp->ni_pnbuf = NULL;
1731 1.133 dholland ndp->ni_cnd.cn_nameptr = NULL;
1732 1.133 dholland
1733 1.118 dholland namei_init(&state, ndp);
1734 1.196 dholland error = do_lookup_for_nfsd_index(&state);
1735 1.118 dholland namei_cleanup(&state);
1736 1.118 dholland
1737 1.118 dholland return error;
1738 1.118 dholland }
1739 1.118 dholland
1740 1.131 dholland ////////////////////////////////////////////////////////////
1741 1.131 dholland
1742 1.118 dholland /*
1743 1.12 mycroft * Reacquire a path name component.
1744 1.73 chs * dvp is locked on entry and exit.
1745 1.73 chs * *vpp is locked on exit unless it's NULL.
1746 1.12 mycroft */
1747 1.12 mycroft int
1748 1.130 dholland relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int dummy)
1749 1.12 mycroft {
1750 1.12 mycroft int rdonly; /* lookup read-only flag bit */
1751 1.12 mycroft int error = 0;
1752 1.52 yamt #ifdef DEBUG
1753 1.197 dholland size_t newlen; /* DEBUG: check name len */
1754 1.197 dholland const char *cp; /* DEBUG: check name ptr */
1755 1.52 yamt #endif /* DEBUG */
1756 1.12 mycroft
1757 1.130 dholland (void)dummy;
1758 1.130 dholland
1759 1.12 mycroft /*
1760 1.12 mycroft * Setup: break out flag bits into variables.
1761 1.12 mycroft */
1762 1.12 mycroft rdonly = cnp->cn_flags & RDONLY;
1763 1.12 mycroft
1764 1.12 mycroft /*
1765 1.12 mycroft * Search a new directory.
1766 1.12 mycroft *
1767 1.12 mycroft * The cn_hash value is for use by vfs_cache.
1768 1.12 mycroft * The last component of the filename is left accessible via
1769 1.12 mycroft * cnp->cn_nameptr for callers that need the name. Callers needing
1770 1.12 mycroft * the name set the SAVENAME flag. When done, they assume
1771 1.12 mycroft * responsibility for freeing the pathname buffer.
1772 1.12 mycroft */
1773 1.52 yamt #ifdef DEBUG
1774 1.197 dholland #if 0
1775 1.39 lukem cp = NULL;
1776 1.39 lukem newhash = namei_hash(cnp->cn_nameptr, &cp);
1777 1.81 chs if ((uint32_t)newhash != (uint32_t)cnp->cn_hash)
1778 1.12 mycroft panic("relookup: bad hash");
1779 1.197 dholland #endif
1780 1.199 para newlen = namei_getcomponent(cnp->cn_nameptr);
1781 1.197 dholland if (cnp->cn_namelen != newlen)
1782 1.58 christos panic("relookup: bad len");
1783 1.197 dholland cp = cnp->cn_nameptr + cnp->cn_namelen;
1784 1.53 yamt while (*cp == '/')
1785 1.53 yamt cp++;
1786 1.12 mycroft if (*cp != 0)
1787 1.12 mycroft panic("relookup: not last component");
1788 1.52 yamt #endif /* DEBUG */
1789 1.12 mycroft
1790 1.12 mycroft /*
1791 1.12 mycroft * Check for degenerate name (e.g. / or "")
1792 1.12 mycroft * which is a way of talking about a directory,
1793 1.12 mycroft * e.g. like "/." or ".".
1794 1.12 mycroft */
1795 1.23 mycroft if (cnp->cn_nameptr[0] == '\0')
1796 1.23 mycroft panic("relookup: null name");
1797 1.12 mycroft
1798 1.12 mycroft if (cnp->cn_flags & ISDOTDOT)
1799 1.58 christos panic("relookup: lookup on dot-dot");
1800 1.12 mycroft
1801 1.12 mycroft /*
1802 1.12 mycroft * We now have a segment name to search for, and a directory to search.
1803 1.12 mycroft */
1804 1.195 dholland *vpp = NULL;
1805 1.129 dholland error = VOP_LOOKUP(dvp, vpp, cnp);
1806 1.129 dholland if ((error) != 0) {
1807 1.205 riastrad KASSERTMSG((*vpp == NULL),
1808 1.205 riastrad "leaf `%s' should be empty but is %p",
1809 1.205 riastrad cnp->cn_nameptr, *vpp);
1810 1.12 mycroft if (error != EJUSTRETURN)
1811 1.12 mycroft goto bad;
1812 1.12 mycroft }
1813 1.12 mycroft
1814 1.12 mycroft /*
1815 1.12 mycroft * Check for symbolic link
1816 1.12 mycroft */
1817 1.205 riastrad KASSERTMSG((*vpp == NULL || (*vpp)->v_type != VLNK ||
1818 1.205 riastrad (cnp->cn_flags & FOLLOW) == 0),
1819 1.205 riastrad "relookup: symlink found");
1820 1.12 mycroft
1821 1.12 mycroft /*
1822 1.94 pooka * Check for read-only lookups.
1823 1.12 mycroft */
1824 1.81 chs if (rdonly && cnp->cn_nameiop != LOOKUP) {
1825 1.26 fvdl error = EROFS;
1826 1.81 chs if (*vpp) {
1827 1.201 hannken vrele(*vpp);
1828 1.81 chs }
1829 1.73 chs goto bad;
1830 1.12 mycroft }
1831 1.201 hannken /*
1832 1.201 hannken * Lock result.
1833 1.201 hannken */
1834 1.201 hannken if (*vpp && *vpp != dvp) {
1835 1.201 hannken error = vn_lock(*vpp, LK_EXCLUSIVE);
1836 1.201 hannken if (error != 0) {
1837 1.201 hannken vrele(*vpp);
1838 1.201 hannken goto bad;
1839 1.201 hannken }
1840 1.201 hannken }
1841 1.12 mycroft return (0);
1842 1.12 mycroft
1843 1.12 mycroft bad:
1844 1.12 mycroft *vpp = NULL;
1845 1.10 cgd return (error);
1846 1.10 cgd }
1847 1.116 dholland
1848 1.116 dholland /*
1849 1.116 dholland * namei_simple - simple forms of namei.
1850 1.116 dholland *
1851 1.116 dholland * These are wrappers to allow the simple case callers of namei to be
1852 1.116 dholland * left alone while everything else changes under them.
1853 1.116 dholland */
1854 1.116 dholland
1855 1.116 dholland /* Flags */
1856 1.116 dholland struct namei_simple_flags_type {
1857 1.116 dholland int dummy;
1858 1.116 dholland };
1859 1.116 dholland static const struct namei_simple_flags_type ns_nn, ns_nt, ns_fn, ns_ft;
1860 1.116 dholland const namei_simple_flags_t NSM_NOFOLLOW_NOEMULROOT = &ns_nn;
1861 1.116 dholland const namei_simple_flags_t NSM_NOFOLLOW_TRYEMULROOT = &ns_nt;
1862 1.116 dholland const namei_simple_flags_t NSM_FOLLOW_NOEMULROOT = &ns_fn;
1863 1.116 dholland const namei_simple_flags_t NSM_FOLLOW_TRYEMULROOT = &ns_ft;
1864 1.116 dholland
1865 1.116 dholland static
1866 1.116 dholland int
1867 1.116 dholland namei_simple_convert_flags(namei_simple_flags_t sflags)
1868 1.116 dholland {
1869 1.116 dholland if (sflags == NSM_NOFOLLOW_NOEMULROOT)
1870 1.116 dholland return NOFOLLOW | 0;
1871 1.116 dholland if (sflags == NSM_NOFOLLOW_TRYEMULROOT)
1872 1.116 dholland return NOFOLLOW | TRYEMULROOT;
1873 1.116 dholland if (sflags == NSM_FOLLOW_NOEMULROOT)
1874 1.116 dholland return FOLLOW | 0;
1875 1.116 dholland if (sflags == NSM_FOLLOW_TRYEMULROOT)
1876 1.116 dholland return FOLLOW | TRYEMULROOT;
1877 1.116 dholland panic("namei_simple_convert_flags: bogus sflags\n");
1878 1.116 dholland return 0;
1879 1.116 dholland }
1880 1.116 dholland
1881 1.116 dholland int
1882 1.116 dholland namei_simple_kernel(const char *path, namei_simple_flags_t sflags,
1883 1.200 manu struct vnode **vp_ret)
1884 1.200 manu {
1885 1.200 manu return nameiat_simple_kernel(NULL, path, sflags, vp_ret);
1886 1.200 manu }
1887 1.200 manu
1888 1.200 manu int
1889 1.200 manu nameiat_simple_kernel(struct vnode *dvp, const char *path,
1890 1.200 manu namei_simple_flags_t sflags, struct vnode **vp_ret)
1891 1.116 dholland {
1892 1.116 dholland struct nameidata nd;
1893 1.123 dholland struct pathbuf *pb;
1894 1.116 dholland int err;
1895 1.116 dholland
1896 1.123 dholland pb = pathbuf_create(path);
1897 1.123 dholland if (pb == NULL) {
1898 1.123 dholland return ENOMEM;
1899 1.123 dholland }
1900 1.123 dholland
1901 1.116 dholland NDINIT(&nd,
1902 1.116 dholland LOOKUP,
1903 1.116 dholland namei_simple_convert_flags(sflags),
1904 1.123 dholland pb);
1905 1.200 manu
1906 1.200 manu if (dvp != NULL)
1907 1.200 manu NDAT(&nd, dvp);
1908 1.200 manu
1909 1.116 dholland err = namei(&nd);
1910 1.116 dholland if (err != 0) {
1911 1.123 dholland pathbuf_destroy(pb);
1912 1.116 dholland return err;
1913 1.116 dholland }
1914 1.116 dholland *vp_ret = nd.ni_vp;
1915 1.123 dholland pathbuf_destroy(pb);
1916 1.116 dholland return 0;
1917 1.116 dholland }
1918 1.116 dholland
1919 1.116 dholland int
1920 1.116 dholland namei_simple_user(const char *path, namei_simple_flags_t sflags,
1921 1.200 manu struct vnode **vp_ret)
1922 1.200 manu {
1923 1.200 manu return nameiat_simple_user(NULL, path, sflags, vp_ret);
1924 1.200 manu }
1925 1.200 manu
1926 1.200 manu int
1927 1.200 manu nameiat_simple_user(struct vnode *dvp, const char *path,
1928 1.200 manu namei_simple_flags_t sflags, struct vnode **vp_ret)
1929 1.116 dholland {
1930 1.123 dholland struct pathbuf *pb;
1931 1.116 dholland struct nameidata nd;
1932 1.116 dholland int err;
1933 1.116 dholland
1934 1.123 dholland err = pathbuf_copyin(path, &pb);
1935 1.123 dholland if (err) {
1936 1.123 dholland return err;
1937 1.123 dholland }
1938 1.123 dholland
1939 1.116 dholland NDINIT(&nd,
1940 1.116 dholland LOOKUP,
1941 1.116 dholland namei_simple_convert_flags(sflags),
1942 1.123 dholland pb);
1943 1.200 manu
1944 1.200 manu if (dvp != NULL)
1945 1.200 manu NDAT(&nd, dvp);
1946 1.200 manu
1947 1.116 dholland err = namei(&nd);
1948 1.116 dholland if (err != 0) {
1949 1.123 dholland pathbuf_destroy(pb);
1950 1.116 dholland return err;
1951 1.116 dholland }
1952 1.116 dholland *vp_ret = nd.ni_vp;
1953 1.123 dholland pathbuf_destroy(pb);
1954 1.116 dholland return 0;
1955 1.116 dholland }
1956