namecache work stage 1: namespace cleanups. Add a NAMEI_ prefix to
[dragonfly.git] / sys / kern / vfs_lookup.c
1 /*
2  * Copyright (c) 1982, 1986, 1989, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *      @(#)vfs_lookup.c        8.4 (Berkeley) 2/16/94
39  * $FreeBSD: src/sys/kern/vfs_lookup.c,v 1.38.2.3 2001/08/31 19:36:49 dillon Exp $
40  * $DragonFly: src/sys/kern/vfs_lookup.c,v 1.6 2003/09/23 05:03:51 dillon Exp $
41  */
42
43 #include "opt_ktrace.h"
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/vnode.h>
48 #include <sys/mount.h>
49 #include <sys/filedesc.h>
50 #include <sys/proc.h>
51 #include <sys/namei.h>
52
53 #ifdef KTRACE
54 #include <sys/ktrace.h>
55 #endif
56
57 #include <vm/vm_zone.h>
58
59 /*
60  * Convert a pathname into a pointer to a locked inode.
61  *
62  * The CNP_FOLLOW flag is set when symbolic links are to be followed
63  * when they occur at the end of the name translation process.
64  * Symbolic links are always followed for all other pathname
65  * components other than the last.
66  *
67  * The segflg defines whether the name is to be copied from user
68  * space or kernel space.
69  *
70  * Overall outline of namei:
71  *
72  *      copy in name
73  *      get starting directory
74  *      while (!done && !error) {
75  *              call lookup to search path.
76  *              if symbolic link, massage name in buffer and continue
77  *      }
78  */
79 int
80 namei(struct nameidata *ndp)
81 {
82         struct filedesc *fdp;   /* pointer to file descriptor state */
83         char *cp;               /* pointer into pathname argument */
84         struct vnode *dp;       /* the directory we are searching */
85         struct iovec aiov;              /* uio for reading symbolic links */
86         struct uio auio;
87         int error, linklen;
88         struct componentname *cnp = &ndp->ni_cnd;
89         struct proc *p;
90
91         KKASSERT(ndp->ni_cnd.cn_td != NULL);
92         p = cnp->cn_td->td_proc;
93         KKASSERT(p != NULL);
94         KASSERT(cnp->cn_cred, ("namei: bad cred/proc"));
95         KKASSERT(cnp->cn_cred == p->p_ucred); /* YYY */
96         KASSERT((cnp->cn_nameiop & (~NAMEI_OPMASK)) == 0,
97             ("namei: nameiop contaminated with flags"));
98         KASSERT((cnp->cn_flags & NAMEI_OPMASK) == 0,
99             ("namei: flags contaminated with nameiops"));
100         fdp = p->p_fd;
101
102         /*
103          * Get a buffer for the name to be translated, and copy the
104          * name into the buffer.
105          */
106         if ((cnp->cn_flags & CNP_HASBUF) == 0)
107                 cnp->cn_pnbuf = zalloc(namei_zone);
108         if (ndp->ni_segflg == UIO_SYSSPACE)
109                 error = copystr(ndp->ni_dirp, cnp->cn_pnbuf,
110                             MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
111         else
112                 error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf,
113                             MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
114
115         /*
116          * Don't allow empty pathnames.
117          */
118         if (!error && *cnp->cn_pnbuf == '\0')
119                 error = ENOENT;
120
121         if (error) {
122                 zfree(namei_zone, cnp->cn_pnbuf);
123                 ndp->ni_vp = NULL;
124                 return (error);
125         }
126         ndp->ni_loopcnt = 0;
127 #ifdef KTRACE
128         if (KTRPOINT(cnp->cn_td, KTR_NAMEI))
129                 ktrnamei(cnp->cn_td->td_proc->p_tracep, cnp->cn_pnbuf);
130 #endif
131
132         /*
133          * Get starting point for the translation.
134          */
135         ndp->ni_rootdir = fdp->fd_rdir;
136         ndp->ni_topdir = fdp->fd_jdir;
137
138         dp = fdp->fd_cdir;
139         VREF(dp);
140         for (;;) {
141                 /*
142                  * Check if root directory should replace current directory.
143                  * Done at start of translation and after symbolic link.
144                  */
145                 cnp->cn_nameptr = cnp->cn_pnbuf;
146                 if (*(cnp->cn_nameptr) == '/') {
147                         vrele(dp);
148                         while (*(cnp->cn_nameptr) == '/') {
149                                 cnp->cn_nameptr++;
150                                 ndp->ni_pathlen--;
151                         }
152                         dp = ndp->ni_rootdir;
153                         VREF(dp);
154                 }
155                 ndp->ni_startdir = dp;
156                 error = lookup(ndp);
157                 if (error) {
158                         zfree(namei_zone, cnp->cn_pnbuf);
159                         return (error);
160                 }
161                 /*
162                  * Check for symbolic link
163                  */
164                 if ((cnp->cn_flags & CNP_ISSYMLINK) == 0) {
165                         if ((cnp->cn_flags & (CNP_SAVENAME | CNP_SAVESTART)) == 0)
166                                 zfree(namei_zone, cnp->cn_pnbuf);
167                         else
168                                 cnp->cn_flags |= CNP_HASBUF;
169
170                         if (vn_canvmio(ndp->ni_vp) == TRUE &&
171                                 (cnp->cn_nameiop != NAMEI_DELETE) &&
172                                 ((cnp->cn_flags & (CNP_NOOBJ|CNP_LOCKLEAF)) ==
173                                  CNP_LOCKLEAF))
174                                 vfs_object_create(ndp->ni_vp, ndp->ni_cnd.cn_td);
175
176                         return (0);
177                 }
178                 if ((cnp->cn_flags & CNP_LOCKPARENT) && ndp->ni_pathlen == 1)
179                         VOP_UNLOCK(ndp->ni_dvp, 0, cnp->cn_td);
180                 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
181                         error = ELOOP;
182                         break;
183                 }
184                 if (ndp->ni_pathlen > 1)
185                         cp = zalloc(namei_zone);
186                 else
187                         cp = cnp->cn_pnbuf;
188                 aiov.iov_base = cp;
189                 aiov.iov_len = MAXPATHLEN;
190                 auio.uio_iov = &aiov;
191                 auio.uio_iovcnt = 1;
192                 auio.uio_offset = 0;
193                 auio.uio_rw = UIO_READ;
194                 auio.uio_segflg = UIO_SYSSPACE;
195                 auio.uio_td = NULL;
196                 auio.uio_resid = MAXPATHLEN;
197                 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
198                 if (error) {
199                         if (ndp->ni_pathlen > 1)
200                                 zfree(namei_zone, cp);
201                         break;
202                 }
203                 linklen = MAXPATHLEN - auio.uio_resid;
204                 if (linklen == 0) {
205                         if (ndp->ni_pathlen > 1)
206                                 zfree(namei_zone, cp);
207                         error = ENOENT;
208                         break;
209                 }
210                 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
211                         if (ndp->ni_pathlen > 1)
212                                 zfree(namei_zone, cp);
213                         error = ENAMETOOLONG;
214                         break;
215                 }
216                 if (ndp->ni_pathlen > 1) {
217                         bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
218                         zfree(namei_zone, cnp->cn_pnbuf);
219                         cnp->cn_pnbuf = cp;
220                 } else
221                         cnp->cn_pnbuf[linklen] = '\0';
222                 ndp->ni_pathlen += linklen;
223                 vput(ndp->ni_vp);
224                 dp = ndp->ni_dvp;
225         }
226         zfree(namei_zone, cnp->cn_pnbuf);
227         vrele(ndp->ni_dvp);
228         vput(ndp->ni_vp);
229         ndp->ni_vp = NULL;
230         return (error);
231 }
232
233 /*
234  * Search a pathname.
235  * This is a very central and rather complicated routine.
236  *
237  * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
238  * The starting directory is taken from ni_startdir. The pathname is
239  * descended until done, or a symbolic link is encountered. The variable
240  * ni_more is clear if the path is completed; it is set to one if a
241  * symbolic link needing interpretation is encountered.
242  *
243  * The flag argument is NAMEI_LOOKUP, CREATE, RENAME, or DELETE depending on
244  * whether the name is to be looked up, created, renamed, or deleted.
245  * When CREATE, RENAME, or DELETE is specified, information usable in
246  * creating, renaming, or deleting a directory entry may be calculated.
247  * If flag has LOCKPARENT or'ed into it, the parent directory is returned
248  * locked. If flag has WANTPARENT or'ed into it, the parent directory is
249  * returned unlocked. Otherwise the parent directory is not returned. If
250  * the target of the pathname exists and LOCKLEAF is or'ed into the flag
251  * the target is returned locked, otherwise it is returned unlocked.
252  * When creating or renaming and LOCKPARENT is specified, the target may not
253  * be ".".  When deleting and LOCKPARENT is specified, the target may be ".".
254  *
255  * Overall outline of lookup:
256  *
257  * dirloop:
258  *      identify next component of name at ndp->ni_ptr
259  *      handle degenerate case where name is null string
260  *      if .. and crossing mount points and on mounted filesys, find parent
261  *      call VOP_LOOKUP routine for next component name
262  *          directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
263  *          component vnode returned in ni_vp (if it exists), locked.
264  *      if result vnode is mounted on and crossing mount points,
265  *          find mounted on vnode
266  *      if more components of name, do next level at dirloop
267  *      return the answer in ni_vp, locked if LOCKLEAF set
268  *          if LOCKPARENT set, return locked parent in ni_dvp
269  *          if WANTPARENT set, return unlocked parent in ni_dvp
270  */
271 int
272 lookup(ndp)
273         struct nameidata *ndp;
274 {
275         char *cp;               /* pointer into pathname argument */
276         struct vnode *dp = 0;   /* the directory we are searching */
277         struct vnode *tdp;              /* saved dp */
278         struct mount *mp;               /* mount table entry */
279         int docache;                    /* == 0 do not cache last component */
280         int wantparent;                 /* 1 => wantparent or lockparent flag */
281         int rdonly;                     /* lookup read-only flag bit */
282         int trailing_slash;
283         int error = 0;
284         int dpunlocked = 0;             /* dp has already been unlocked */
285         struct componentname *cnp = &ndp->ni_cnd;
286         struct thread *td = cnp->cn_td;
287
288         /*
289          * Setup: break out flag bits into variables.
290          */
291         wantparent = cnp->cn_flags & (CNP_LOCKPARENT | CNP_WANTPARENT);
292         docache = (cnp->cn_flags & CNP_NOCACHE) ^ CNP_NOCACHE;
293         if (cnp->cn_nameiop == NAMEI_DELETE ||
294             (wantparent && cnp->cn_nameiop != NAMEI_CREATE &&
295              cnp->cn_nameiop != NAMEI_LOOKUP))
296                 docache = 0;
297         rdonly = cnp->cn_flags & CNP_RDONLY;
298         ndp->ni_dvp = NULL;
299         cnp->cn_flags &= ~CNP_ISSYMLINK;
300         dp = ndp->ni_startdir;
301         ndp->ni_startdir = NULLVP;
302         vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
303
304 dirloop:
305         /*
306          * Search a new directory.
307          *
308          * The last component of the filename is left accessible via
309          * cnp->cn_nameptr for callers that need the name. Callers needing
310          * the name set the CNP_SAVENAME flag. When done, they assume
311          * responsibility for freeing the pathname buffer.
312          */
313         cnp->cn_consume = 0;
314         for (cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++)
315                 continue;
316         cnp->cn_namelen = cp - cnp->cn_nameptr;
317         if (cnp->cn_namelen > NAME_MAX) {
318                 error = ENAMETOOLONG;
319                 goto bad;
320         }
321 #ifdef NAMEI_DIAGNOSTIC
322         { char c = *cp;
323         *cp = '\0';
324         printf("{%s}: ", cnp->cn_nameptr);
325         *cp = c; }
326 #endif
327         ndp->ni_pathlen -= cnp->cn_namelen;
328         ndp->ni_next = cp;
329
330         /*
331          * Replace multiple slashes by a single slash and trailing slashes
332          * by a null.  This must be done before VOP_LOOKUP() because some
333          * fs's don't know about trailing slashes.  Remember if there were
334          * trailing slashes to handle symlinks, existing non-directories
335          * and non-existing files that won't be directories specially later.
336          */
337         trailing_slash = 0;
338         while (*cp == '/' && (cp[1] == '/' || cp[1] == '\0')) {
339                 cp++;
340                 ndp->ni_pathlen--;
341                 if (*cp == '\0') {
342                         trailing_slash = 1;
343                         *ndp->ni_next = '\0';   /* XXX for direnter() ... */
344                 }
345         }
346         ndp->ni_next = cp;
347
348         cnp->cn_flags |= CNP_MAKEENTRY;
349         if (*cp == '\0' && docache == 0)
350                 cnp->cn_flags &= ~CNP_MAKEENTRY;
351         if (cnp->cn_namelen == 2 &&
352             cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
353                 cnp->cn_flags |= CNP_ISDOTDOT;
354         else
355                 cnp->cn_flags &= ~CNP_ISDOTDOT;
356         if (*ndp->ni_next == 0)
357                 cnp->cn_flags |= CNP_ISLASTCN;
358         else
359                 cnp->cn_flags &= ~CNP_ISLASTCN;
360
361
362         /*
363          * Check for degenerate name (e.g. / or "")
364          * which is a way of talking about a directory,
365          * e.g. like "/." or ".".
366          */
367         if (cnp->cn_nameptr[0] == '\0') {
368                 if (dp->v_type != VDIR) {
369                         error = ENOTDIR;
370                         goto bad;
371                 }
372                 if (cnp->cn_nameiop != NAMEI_LOOKUP) {
373                         error = EISDIR;
374                         goto bad;
375                 }
376                 if (wantparent) {
377                         ndp->ni_dvp = dp;
378                         VREF(dp);
379                 }
380                 ndp->ni_vp = dp;
381                 if (!(cnp->cn_flags & (CNP_LOCKPARENT | CNP_LOCKLEAF)))
382                         VOP_UNLOCK(dp, 0, cnp->cn_td);
383                 /* XXX This should probably move to the top of function. */
384                 if (cnp->cn_flags & CNP_SAVESTART)
385                         panic("lookup: CNP_SAVESTART");
386                 return (0);
387         }
388
389         /*
390          * Handle "..": two special cases.
391          * 1. If at root directory (e.g. after chroot)
392          *    or at absolute root directory
393          *    then ignore it so can't get out.
394          * 2. If this vnode is the root of a mounted
395          *    filesystem, then replace it with the
396          *    vnode which was mounted on so we take the
397          *    .. in the other file system.
398          * 3. If the vnode is the top directory of
399          *    the jail or chroot, don't let them out.
400          */
401         if (cnp->cn_flags & CNP_ISDOTDOT) {
402                 for (;;) {
403                         if (dp == ndp->ni_rootdir || 
404                             dp == ndp->ni_topdir || 
405                             dp == rootvnode) {
406                                 ndp->ni_dvp = dp;
407                                 ndp->ni_vp = dp;
408                                 VREF(dp);
409                                 goto nextname;
410                         }
411                         if ((dp->v_flag & VROOT) == 0 ||
412                             (cnp->cn_flags & CNP_NOCROSSMOUNT))
413                                 break;
414                         if (dp->v_mount == NULL) {      /* forced unmount */
415                                 error = EBADF;
416                                 goto bad;
417                         }
418                         tdp = dp;
419                         dp = dp->v_mount->mnt_vnodecovered;
420                         vput(tdp);
421                         VREF(dp);
422                         vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
423                 }
424         }
425
426         /*
427          * We now have a segment name to search for, and a directory to search.
428          */
429 unionlookup:
430         ndp->ni_dvp = dp;
431         ndp->ni_vp = NULL;
432         cnp->cn_flags &= ~CNP_PDIRUNLOCK;
433         ASSERT_VOP_LOCKED(dp, "lookup");
434         if ((error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) != 0) {
435                 KASSERT(ndp->ni_vp == NULL, ("leaf should be empty"));
436 #ifdef NAMEI_DIAGNOSTIC
437                 printf("not found\n");
438 #endif
439                 if ((error == ENOENT) &&
440                     (dp->v_flag & VROOT) && (dp->v_mount != NULL) &&
441                     (dp->v_mount->mnt_flag & MNT_UNION)) {
442                         tdp = dp;
443                         dp = dp->v_mount->mnt_vnodecovered;
444                         if (cnp->cn_flags & CNP_PDIRUNLOCK)
445                                 vrele(tdp);
446                         else
447                                 vput(tdp);
448                         VREF(dp);
449                         vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
450                         goto unionlookup;
451                 }
452
453                 if (error != EJUSTRETURN)
454                         goto bad;
455                 /*
456                  * If creating and at end of pathname, then can consider
457                  * allowing file to be created.
458                  */
459                 if (rdonly) {
460                         error = EROFS;
461                         goto bad;
462                 }
463                 if (*cp == '\0' && trailing_slash &&
464                      !(cnp->cn_flags & CNP_WILLBEDIR)) {
465                         error = ENOENT;
466                         goto bad;
467                 }
468                 /*
469                  * We return with ni_vp NULL to indicate that the entry
470                  * doesn't currently exist, leaving a pointer to the
471                  * (possibly locked) directory inode in ndp->ni_dvp.
472                  */
473                 if (cnp->cn_flags & CNP_SAVESTART) {
474                         ndp->ni_startdir = ndp->ni_dvp;
475                         VREF(ndp->ni_startdir);
476                 }
477                 return (0);
478         }
479 #ifdef NAMEI_DIAGNOSTIC
480         printf("found\n");
481 #endif
482
483         ASSERT_VOP_LOCKED(ndp->ni_vp, "lookup");
484
485         /*
486          * Take into account any additional components consumed by
487          * the underlying filesystem.
488          */
489         if (cnp->cn_consume > 0) {
490                 cnp->cn_nameptr += cnp->cn_consume;
491                 ndp->ni_next += cnp->cn_consume;
492                 ndp->ni_pathlen -= cnp->cn_consume;
493                 cnp->cn_consume = 0;
494         }
495
496         dp = ndp->ni_vp;
497
498         /*
499          * Check to see if the vnode has been mounted on;
500          * if so find the root of the mounted file system.
501          */
502         while (dp->v_type == VDIR && (mp = dp->v_mountedhere) &&
503                (cnp->cn_flags & CNP_NOCROSSMOUNT) == 0) {
504                 if (vfs_busy(mp, 0, 0, td))
505                         continue;
506                 VOP_UNLOCK(dp, 0, td);
507                 error = VFS_ROOT(mp, &tdp);
508                 vfs_unbusy(mp, td);
509                 if (error) {
510                         dpunlocked = 1;
511                         goto bad2;
512                 }
513                 vrele(dp);
514                 ndp->ni_vp = dp = tdp;
515         }
516
517         /*
518          * Check for symbolic link
519          */
520         if ((dp->v_type == VLNK) &&
521             ((cnp->cn_flags & CNP_FOLLOW) || trailing_slash ||
522              *ndp->ni_next == '/')) {
523                 cnp->cn_flags |= CNP_ISSYMLINK;
524                 if (dp->v_mount == NULL) {
525                         /* We can't know whether the directory was mounted with
526                          * NOSYMFOLLOW, so we can't follow safely. */
527                         error = EBADF;
528                         goto bad2;
529                 }
530                 if (dp->v_mount->mnt_flag & MNT_NOSYMFOLLOW) {
531                         error = EACCES;
532                         goto bad2;
533                 }
534                 return (0);
535         }
536
537         /*
538          * Check for bogus trailing slashes.
539          */
540         if (trailing_slash && dp->v_type != VDIR) {
541                 error = ENOTDIR;
542                 goto bad2;
543         }
544
545 nextname:
546         /*
547          * Not a symbolic link.  If more pathname,
548          * continue at next component, else return.
549          */
550         if (*ndp->ni_next == '/') {
551                 cnp->cn_nameptr = ndp->ni_next;
552                 while (*cnp->cn_nameptr == '/') {
553                         cnp->cn_nameptr++;
554                         ndp->ni_pathlen--;
555                 }
556                 if (ndp->ni_dvp != ndp->ni_vp)
557                         ASSERT_VOP_UNLOCKED(ndp->ni_dvp, "lookup");
558                 vrele(ndp->ni_dvp);
559                 goto dirloop;
560         }
561         /*
562          * Disallow directory write attempts on read-only file systems.
563          */
564         if (rdonly &&
565             (cnp->cn_nameiop == NAMEI_DELETE || cnp->cn_nameiop == NAMEI_RENAME)) {
566                 error = EROFS;
567                 goto bad2;
568         }
569         if (cnp->cn_flags & CNP_SAVESTART) {
570                 ndp->ni_startdir = ndp->ni_dvp;
571                 VREF(ndp->ni_startdir);
572         }
573         if (!wantparent)
574                 vrele(ndp->ni_dvp);
575
576         if ((cnp->cn_flags & CNP_LOCKLEAF) == 0)
577                 VOP_UNLOCK(dp, 0, td);
578         return (0);
579
580 bad2:
581         if ((cnp->cn_flags & (CNP_LOCKPARENT | CNP_PDIRUNLOCK)) == CNP_LOCKPARENT &&
582             *ndp->ni_next == '\0')
583                 VOP_UNLOCK(ndp->ni_dvp, 0, td);
584         vrele(ndp->ni_dvp);
585 bad:
586         if (dpunlocked)
587                 vrele(dp);
588         else
589                 vput(dp);
590         ndp->ni_vp = NULL;
591         return (error);
592 }
593
594 /*
595  * relookup - lookup a path name component
596  *    Used by lookup to re-aquire things.
597  */
598 int
599 relookup(dvp, vpp, cnp)
600         struct vnode *dvp, **vpp;
601         struct componentname *cnp;
602 {
603         struct thread *td = cnp->cn_td;
604         struct vnode *dp = 0;           /* the directory we are searching */
605         int docache;                    /* == 0 do not cache last component */
606         int wantparent;                 /* 1 => wantparent or lockparent flag */
607         int rdonly;                     /* lookup read-only flag bit */
608         int error = 0;
609 #ifdef NAMEI_DIAGNOSTIC
610         int newhash;                    /* DEBUG: check name hash */
611         char *cp;                       /* DEBUG: check name ptr/len */
612 #endif
613
614         /*
615          * Setup: break out flag bits into variables.
616          */
617         wantparent = cnp->cn_flags & (CNP_LOCKPARENT|CNP_WANTPARENT);
618         docache = (cnp->cn_flags & CNP_NOCACHE) ^ CNP_NOCACHE;
619         if (cnp->cn_nameiop == NAMEI_DELETE ||
620             (wantparent && cnp->cn_nameiop != NAMEI_CREATE))
621                 docache = 0;
622         rdonly = cnp->cn_flags & CNP_RDONLY;
623         cnp->cn_flags &= ~CNP_ISSYMLINK;
624         dp = dvp;
625         vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
626
627 /* dirloop: */
628         /*
629          * Search a new directory.
630          *
631          * The last component of the filename is left accessible via
632          * cnp->cn_nameptr for callers that need the name. Callers needing
633          * the name set the CNP_SAVENAME flag. When done, they assume
634          * responsibility for freeing the pathname buffer.
635          */
636 #ifdef NAMEI_DIAGNOSTIC
637         if (cnp->cn_namelen != cp - cnp->cn_nameptr)
638                 panic ("relookup: bad len");
639         if (*cp != 0)
640                 panic("relookup: not last component");
641         printf("{%s}: ", cnp->cn_nameptr);
642 #endif
643
644         /*
645          * Check for degenerate name (e.g. / or "")
646          * which is a way of talking about a directory,
647          * e.g. like "/." or ".".
648          */
649         if (cnp->cn_nameptr[0] == '\0') {
650                 if (cnp->cn_nameiop != NAMEI_LOOKUP || wantparent) {
651                         error = EISDIR;
652                         goto bad;
653                 }
654                 if (dp->v_type != VDIR) {
655                         error = ENOTDIR;
656                         goto bad;
657                 }
658                 if (!(cnp->cn_flags & CNP_LOCKLEAF))
659                         VOP_UNLOCK(dp, 0, td);
660                 *vpp = dp;
661                 /* XXX This should probably move to the top of function. */
662                 if (cnp->cn_flags & CNP_SAVESTART)
663                         panic("lookup: CNP_SAVESTART");
664                 return (0);
665         }
666
667         if (cnp->cn_flags & CNP_ISDOTDOT)
668                 panic ("relookup: lookup on dot-dot");
669
670         /*
671          * We now have a segment name to search for, and a directory to search.
672          */
673         if ((error = VOP_LOOKUP(dp, vpp, cnp)) != 0) {
674                 KASSERT(*vpp == NULL, ("leaf should be empty"));
675                 if (error != EJUSTRETURN)
676                         goto bad;
677                 /*
678                  * If creating and at end of pathname, then can consider
679                  * allowing file to be created.
680                  */
681                 if (rdonly) {
682                         error = EROFS;
683                         goto bad;
684                 }
685                 /* ASSERT(dvp == ndp->ni_startdir) */
686                 if (cnp->cn_flags & CNP_SAVESTART)
687                         VREF(dvp);
688                 /*
689                  * We return with ni_vp NULL to indicate that the entry
690                  * doesn't currently exist, leaving a pointer to the
691                  * (possibly locked) directory inode in ndp->ni_dvp.
692                  */
693                 return (0);
694         }
695         dp = *vpp;
696
697         /*
698          * Check for symbolic link
699          */
700         KASSERT(dp->v_type != VLNK || !(cnp->cn_flags & CNP_FOLLOW),
701             ("relookup: symlink found.\n"));
702
703         /*
704          * Disallow directory write attempts on read-only file systems.
705          */
706         if (rdonly &&
707             (cnp->cn_nameiop == NAMEI_DELETE || cnp->cn_nameiop == NAMEI_RENAME)) {
708                 error = EROFS;
709                 goto bad2;
710         }
711         /* ASSERT(dvp == ndp->ni_startdir) */
712         if (cnp->cn_flags & CNP_SAVESTART)
713                 VREF(dvp);
714         
715         if (!wantparent)
716                 vrele(dvp);
717
718         if (vn_canvmio(dp) == TRUE &&
719                 ((cnp->cn_flags & (CNP_NOOBJ|CNP_LOCKLEAF)) == CNP_LOCKLEAF))
720                 vfs_object_create(dp, cnp->cn_td);
721
722         if ((cnp->cn_flags & CNP_LOCKLEAF) == 0)
723                 VOP_UNLOCK(dp, 0, td);
724         return (0);
725
726 bad2:
727         if ((cnp->cn_flags & CNP_LOCKPARENT) && (cnp->cn_flags & CNP_ISLASTCN))
728                 VOP_UNLOCK(dvp, 0, td);
729         vrele(dvp);
730 bad:
731         vput(dp);
732         *vpp = NULL;
733         return (error);
734 }