keep track of pending selects

[unix-history] / usr / src / sys / kern / vfs_lookup.c

diff --git a/usr/src/sys/kern/vfs_lookup.c b/usr/src/sys/kern/vfs_lookup.c
index c861d1a..ec47d44 100644 (file)
--- a/usr/src/sys/kern/vfs_lookup.c
+++ b/usr/src/sys/kern/vfs_lookup.c
@@ -1,433 +1,394 @@
-/*     vfs_lookup.c    4.15    82/04/19        */
+/*
+ * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *     @(#)vfs_lookup.c        7.21 (Berkeley) %G%
+ */

 
 

-/* merged into kernel: @(#)nami.c 2.3 4/8/82 */
+#include "param.h"
+#include "time.h"
+#include "namei.h"
+#include "vnode.h"
+#include "mount.h"
+#include "errno.h"
+#include "malloc.h"

 
 

-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/inode.h"
-#include "../h/fs.h"
-#include "../h/mount.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/buf.h"
-#include "../h/conf.h"
+#ifdef KTRACE
+#include "user.h"
+#include "proc.h"
+#include "ktrace.h"
+#endif

 
 /*
 
 /*

- * Convert a pathname into a pointer to
- * a locked inode.
+ * Convert a pathname into a pointer to a locked inode.
+ * This is a very central and rather complicated routine.
+ *
+ * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
+ * whether the name is to be looked up, created, renamed, or deleted.
+ * When CREATE, RENAME, or DELETE is specified, information usable in
+ * creating, renaming, or deleting a directory entry may be calculated.
+ * If flag has LOCKPARENT or'ed into it and the target of the pathname
+ * exists, namei returns both the target and its parent directory locked.
+ * When creating or renaming and LOCKPARENT is specified, the target may not
+ * be ".".  When deleting and LOCKPARENT is specified, the target may be ".".
+ *
+ * The FOLLOW flag is set when symbolic links are to be followed
+ * when they occur at the end of the name translation process.
+ * Symbolic links are always followed for all other pathname
+ * components other than the last.

  *
  *

- * func = function called to get next char of name
- *     &uchar if name is in user space
- *     &schar if name is in system space
- * flag = 0 if name is sought
- *     1 if name is to be created
- *     2 if name is to be deleted
- * follow = 1 if links are to be followed at the end of the name
+ * The segflg defines whether the name is to be copied from user
+ * space or kernel space.
+ *
+ * Overall outline of namei:
+ *
+ *     copy in name
+ *     get starting directory
+ * dirloop:
+ *     copy next component of name to ndp->ni_dent
+ *     handle degenerate case where name is null string
+ *     if .. and on mounted filesys, find parent
+ *     call lookup routine for next component name
+ *       directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
+ *       component vnode returned in ni_vp (if it exists), locked.
+ *     if symbolic link, massage name in buffer and continue at dirloop
+ *     if result inode is mounted on, find mounted on vnode
+ *     if more components of name, do next level at dirloop
+ *     return the answer in ni_vp as locked vnode;
+ *       if LOCKPARENT set, return locked parent in ni_dvp
+ *
+ * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent vnode unlocked.

  */
  */

-struct inode *
-namei(func, flag, follow)
-       int (*func)(), flag, follow;
+namei(ndp)
+       register struct nameidata *ndp;

 {
 {

-       register struct inode *dp;
-       register char *cp;
-       register struct buf *bp, *nbp;
-       register struct direct *ep;
-       register struct fs *fs;
-       struct inode *pdp;
-       enum {NONE, COMPACT, FOUND} slot;
-       int entryfree, entrysize;
-       int spccnt, size, newsize;
-       int loc, prevoff, curoff;
-       int i, nlink, bsize;
-       unsigned pathlen;
-       daddr_t lbn, bn;
-       dev_t d;
+       register char *cp;              /* pointer into pathname argument */
+       register struct vnode *dp = 0;  /* the directory we are searching */
+       register int i;                 /* Temp counter */
+       struct vnode *tdp;              /* saved dp */
+       struct mount *mp;               /* mount table entry */
+       int docache;                    /* == 0 do not cache last component */
+       int flag;                       /* LOOKUP, CREATE, RENAME or DELETE */
+       int wantparent;                 /* 1 => wantparent or lockparent flag */
+       int lockparent;                 /* 1 => lockparent flag */
+       int getbuf;                     /* 1 => Malloc a pathname buffer */
+       int rdonly;                     /* mounted read-only flag bit(s) */
+       int error = 0;

 
        /*
 
        /*

-        * allocate name buffer; copy name
+        * Setup: break out flag bits into variables.

         */
         */

-       nbp = geteblk(MAXPATHLEN);
-       nlink = 0;
-       for (i = 0, cp = nbp->b_un.b_addr; *cp = (*func)(); i++) {
-               if ((*cp & 0377) == ('/'|0200)) {
-                       u.u_error = EPERM;
-                       break;
-               }
-#ifdef notdef
-               if (*cp++ & 0200 && flag == 1 ||
-                   cp >= nbp->b_un.b_addr + MAXPATHLEN) {
-#else
-               cp++;
-               if (cp >= nbp->b_un.b_addr + MAXPATHLEN) {
-#endif
-                       u.u_error = ENOENT;
-                       break;
+       ndp->ni_dvp = NULL;
+       flag = ndp->ni_nameiop & OPFLAG;
+       wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT);
+       lockparent = ndp->ni_nameiop & LOCKPARENT;
+       docache = (ndp->ni_nameiop & NOCACHE) ^ NOCACHE;
+       getbuf = (ndp->ni_nameiop & HASBUF) ^ HASBUF;
+       if (flag == DELETE || wantparent)
+               docache = 0;
+       rdonly = MNT_RDONLY;
+       if (ndp->ni_nameiop & REMOTE)
+               rdonly |= MNT_EXRDONLY;
+       /*
+        * Get a buffer for the name to be translated, and copy the
+        * name into the buffer.
+        */
+       if (getbuf) {
+               MALLOC(ndp->ni_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
+               if (ndp->ni_segflg == UIO_SYSSPACE)
+                       error = copystr(ndp->ni_dirp, ndp->ni_pnbuf,
+                                   MAXPATHLEN, &ndp->ni_pathlen);
+               else
+                       error = copyinstr(ndp->ni_dirp, ndp->ni_pnbuf,
+                                   MAXPATHLEN, &ndp->ni_pathlen);
+               if (error) {
+                       free(ndp->ni_pnbuf, M_NAMEI);
+                       ndp->ni_vp = NULL;
+                       return (error);

                }
                }

+               ndp->ni_ptr = ndp->ni_pnbuf;

        }
        }

-       if (u.u_error) {
-               brelse(nbp);
-               return (NULL);
-       }
-       cp = nbp->b_un.b_addr;
+       ndp->ni_loopcnt = 0;
+       dp = ndp->ni_cdir;
+       VREF(dp);
+#ifdef KTRACE
+       if (KTRPOINT(u.u_procp, KTR_NAMEI))
+               ktrnamei(u.u_procp->p_tracep, ndp->ni_pnbuf);
+#endif
+
+start:

        /*
        /*

-        * If name starts with '/' start from
-        * root; otherwise start from current dir.
+        * Get starting directory.
+        * Done at start of translation and after symbolic link.

         */
         */

-       dp = u.u_cdir;
-       if (*cp == '/') {
-               while (*cp == '/')
-                       cp++;
-               if ((dp = u.u_rdir) == NULL)
+       if (*ndp->ni_ptr == '/') {
+               vrele(dp);
+               while (*ndp->ni_ptr == '/') {
+                       ndp->ni_ptr++;
+                       ndp->ni_pathlen--;
+               }
+               if ((dp = ndp->ni_rdir) == NULL)

                        dp = rootdir;
                        dp = rootdir;

+               VREF(dp);

        }
        }

-       ilock(dp);
-       dp->i_count++;
-       fs = dp->i_fs;
-       newsize = 0;
+       VOP_LOCK(dp);
+       ndp->ni_endoff = 0;
+
+       /*
+        * We come to dirloop to search a new directory.
+        */

 dirloop:
        /*
 dirloop:
        /*

-        * dp must be a directory and
-        * must have X permission.
-        * cp is a path name relative to that directory.
+        * Copy next component of name to ndp->ni_dent.
+        * XXX kern_exec looks at d_name
+        * ??? The ni_hash value may be useful for vfs_cache
+        * XXX There must be the last component of the filename left
+        * somewhere accessible via. ndp for NFS (and any other stateless file
+        * systems) in case they are doing a CREATE. The "Towards a..." noted
+        * that ni_ptr would be left pointing to the last component, but since
+        * the ni_pnbuf gets free'd, that is not a good idea.

         */
         */

-       if ((dp->i_mode&IFMT) != IFDIR)
-               u.u_error = ENOTDIR;
-       (void) access(dp, IEXEC);
-dirloop2:
-       for (i = 0; *cp != '\0' && *cp != '/'; cp++) {
-#ifdef notdef
-               if (i >= MAXNAMLEN) {
-                       u.u_error = ENOENT;
-                       break;
-               }
-               u.u_dent.d_name[i] = *cp;
-#else
-               if (i < MAXNAMLEN) {
-                       u.u_dent.d_name[i] = *cp;
-                       i++;
+       if (getbuf) {
+               ndp->ni_hash = 0;
+               for (cp = ndp->ni_ptr, i = 0; *cp != 0 && *cp != '/'; cp++) {
+                       if (i >= MAXNAMLEN) {
+                               error = ENAMETOOLONG;
+                               goto bad;
+                       }
+                       if (*cp & 0200)
+                               if ((*cp&0377) == ('/'|0200) ||
+                                   flag != DELETE) {
+                                       error = EINVAL;
+                                       goto bad;
+                               }
+                       ndp->ni_dent.d_name[i++] = *cp;
+                       ndp->ni_hash += (unsigned char)*cp * i;

                }
                }

+               ndp->ni_namelen = i;
+               ndp->ni_dent.d_namlen = i;
+               ndp->ni_dent.d_name[i] = '\0';
+               ndp->ni_pathlen -= i;
+               ndp->ni_next = cp;
+#ifdef NAMEI_DIAGNOSTIC
+               printf("{%s}: ", ndp->ni_dent.d_name);

 #endif
        }
 #endif
        }

-       if (u.u_error) {
-               iput(dp);
-               brelse(nbp);
-               return (NULL);
-       }
-       u.u_dent.d_namlen = i;
-       u.u_dent.d_name[i] = '\0';
-       newsize = DIRSIZ(&u.u_dent);
-       u.u_pdir = dp;
-       if (u.u_dent.d_name[0] == '\0') {       /* null name, e.g. "/" or "" */
-               if (flag != 0) {
-                       u.u_error = ENOENT;
-                       iput(dp);
-                       dp = NULL;
+       cp = ndp->ni_next;
+       ndp->ni_makeentry = 1;
+       if (*cp == '\0' && docache == 0)
+               ndp->ni_makeentry = 0;
+       ndp->ni_isdotdot = (ndp->ni_namelen == 2 &&
+               ndp->ni_dent.d_name[1] == '.' && ndp->ni_dent.d_name[0] == '.');
+
+       /*
+        * Check for degenerate name (e.g. / or "")
+        * which is a way of talking about a directory,
+        * e.g. like "/." or ".".
+        */
+       if (ndp->ni_ptr[0] == '\0') {
+               if (flag != LOOKUP || wantparent) {
+                       error = EISDIR;
+                       goto bad;

                }
                }

-               u.u_offset = 0;
-               u.u_count = newsize;
-               brelse(nbp);
-               return (dp);
+               if (getbuf)
+                       free(ndp->ni_pnbuf, M_NAMEI);
+               if (!(ndp->ni_nameiop & LOCKLEAF))
+                       VOP_UNLOCK(dp);
+               ndp->ni_vp = dp;
+               return (0);

        }
        }

+

        /*
        /*

-        * set up to search a directory
+        * Handle "..": two special cases.
+        * 1. If at root directory (e.g. after chroot)
+        *    then ignore it so can't get out.
+        * 2. If this vnode is the root of a mounted
+        *    file system, then replace it with the
+        *    vnode which was mounted on so we take the
+        *    .. in the other file system.

         */
         */

-       if (flag == 1)
-               slot = NONE;
-       else
-               slot = FOUND;
-       u.u_offset = 0;
-       u.u_segflg = 1;
-       bp = NULL;
-       spccnt = 0;
-       loc = 0;
-       while (u.u_offset < dp->i_size) {
-               /*
-                * check to see if enough space has been accumulated to make
-                * an entry by compaction. Reset the free space counter each
-                * time a directory block is crossed.
-                */
-               if (slot == NONE) {
-                       if (spccnt >= newsize) {
-                               slot = COMPACT;
-                               entrysize = u.u_offset - entryfree;
-                       } else if (loc % DIRBLKSIZ == 0) {
-                               entryfree = NULL;
-                               spccnt = 0;
+       if (ndp->ni_isdotdot) {
+               for (;;) {
+                       if (dp == ndp->ni_rdir || dp == rootdir) {
+                               ndp->ni_dvp = dp;
+                               ndp->ni_vp = dp;
+                               VREF(dp);
+                               goto nextname;

                        }
                        }

+                       if ((dp->v_flag & VROOT) == 0 ||
+                               (ndp->ni_nameiop & NOCROSSMOUNT))
+                               break;
+                       tdp = dp;
+                       dp = dp->v_mount->mnt_vnodecovered;
+                       vput(tdp);
+                       VREF(dp);
+                       VOP_LOCK(dp);

                }
                }

+       }
+
+       /*
+        * We now have a segment name to search for, and a directory to search.
+        */
+       if (error = VOP_LOOKUP(dp, ndp)) {
+               if (ndp->ni_vp != NULL)
+                       panic("leaf should be empty");
+#ifdef NAMEI_DIAGNOSTIC
+               printf("not found\n");
+#endif
+               if (flag == LOOKUP || flag == DELETE ||
+                   error != ENOENT || *cp != 0)
+                       goto bad;

                /*
                /*

-                * If offset is on a block boundary,
-                * read the next directory block.
-                * Release previous if it exists.
-                */
-               if (blkoff(fs, u.u_offset) == 0) {
-                       if (bp != NULL)
-                               brelse(bp);
-                       lbn = (daddr_t)lblkno(fs, u.u_offset);
-                       bsize = blksize(fs, dp, lbn);
-                       if ((bn = bmap(dp, lbn, B_READ)) < 0) {
-                               printf("hole in dir: %s i = %d\n",
-                                   fs->fs_fsmnt, dp->i_number);
-                               if (fs->fs_ronly != 0 ||
-                                   (bn = bmap(dp, lbn, B_WRITE, bsize)) < 0) {
-                                       u.u_offset += bsize;
-                                       bp = NULL;
-                                       continue;
-                               }
-                       }
-                       bp = bread(dp->i_dev, fsbtodb(fs, bn), bsize);
-                       if (bp->b_flags & B_ERROR) {
-                               brelse(bp);
-                               iput(dp);
-                               brelse(nbp);
-                               return (NULL);
-                       }
-                       loc = 0;
-               } else {
-                       loc += ep->d_reclen;
-               }
-               /*
-                * calculate the next directory entry and run
-                * some rudimentary bounds checks to make sure
-                * that it is reasonable. If the check fails
-                * resync at the beginning of the next directory
-                * block.
-                */
-               ep = (struct direct *)(bp->b_un.b_addr + loc);
-               i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1));
-               if (ep->d_reclen <= 0 || ep->d_reclen > i) {
-                       loc += i;
-                       u.u_offset += i;
-                       continue;
-               }
-               /*
-                * If an appropriate sized hole has not yet been found,
-                * check to see if one is available. Also accumulate space
-                * in the current block so that we can determine if
-                * compaction is viable.
-                */
-               if (slot != FOUND) {
-                       size = ep->d_reclen;
-                       if (ep->d_ino != 0)
-                               size -= DIRSIZ(ep);
-                       if (size > 0) {
-                               if (size >= newsize) {
-                                       slot = FOUND;
-                                       entryfree = u.u_offset;
-                                       entrysize = DIRSIZ(ep) + newsize;
-                               }
-                               if (entryfree == NULL)
-                                       entryfree = u.u_offset;
-                               spccnt += size;
-                       }
-               }
-               /*
-                * String compare the directory entry
-                * and the current component.
-                * If they do not match, continue to the next entry.
-                */
-               prevoff = curoff;
-               curoff = u.u_offset;
-               u.u_offset += ep->d_reclen;
-               if (ep->d_ino == 0)
-                       continue;
-               if (ep->d_namlen != u.u_dent.d_namlen)
-                       continue;
-               if (bcmp(u.u_dent.d_name, ep->d_name, ep->d_namlen))
-                       continue;
-               /*
-                * Here a component matched in a directory.
-                * If there is more pathname, go back to
-                * dirloop, otherwise return.
+                * If creating and at end of pathname, then can consider
+                * allowing file to be created.

                 */
                 */

-               bcopy((caddr_t)ep, (caddr_t)&u.u_dent, DIRSIZ(ep));
-               brelse(bp);
-               if (flag == 2 && *cp == '\0') {
-                       brelse(nbp);
-                       if (access(dp, IWRITE)) {
-                               iput(dp);
-                               return (NULL);
-                       }
-                       if (curoff % DIRBLKSIZ == 0) {
-                               u.u_offset = curoff;
-                               u.u_count = 0;
-                               return (dp);
-                       }
-                       u.u_offset = prevoff;
-                       u.u_count = DIRSIZ((struct direct *)
-                           (bp->b_un.b_addr + blkoff(fs, prevoff)));
-                       return (dp);
+               if (ndp->ni_dvp->v_mount->mnt_flag & rdonly) {
+                       error = EROFS;
+                       goto bad;

                }
                /*
                }
                /*

-                * Special handling for ".."
+                * We return with ni_vp NULL to indicate that the entry
+                * doesn't currently exist, leaving a pointer to the
+                * (possibly locked) directory inode in ndp->ni_dvp.

                 */
                 */

-               if (u.u_dent.d_name[0] == '.' && u.u_dent.d_name[1] == '.' &&
-                   u.u_dent.d_name[2] == '\0') {
-                       if (dp == u.u_rdir)
-                               u.u_dent.d_ino = dp->i_number;
-                       else if (u.u_dent.d_ino == ROOTINO &&
-                          dp->i_number == ROOTINO) {
-                               for (i = 1; i < NMOUNT; i++)
-                                       if (mount[i].m_bufp != NULL &&
-                                          mount[i].m_dev == dp->i_dev) {
-                                               iput(dp);
-                                               dp = mount[i].m_inodp;
-                                               ilock(dp);
-                                               dp->i_count++;
-                                               fs = dp->i_fs;
-                                               cp -= 2;     /* back over .. */
-                                               goto dirloop2;
-                                       }
-                       }
+               if (getbuf)
+                       FREE(ndp->ni_pnbuf, M_NAMEI);
+               return (0);     /* should this be ENOENT? */
+       }
+#ifdef NAMEI_DIAGNOSTIC
+       printf("found\n");
+#endif
+
+       /*
+        * Check for symbolic link
+        */
+       dp = ndp->ni_vp;
+       if ((dp->v_type == VLNK) &&
+           ((ndp->ni_nameiop & FOLLOW) || *ndp->ni_next == '/')) {
+               struct iovec aiov;
+               struct uio auio;
+               int linklen;
+
+               if (!getbuf)
+                       panic("namei: unexpected symlink");
+               if (++ndp->ni_loopcnt > MAXSYMLINKS) {
+                       error = ELOOP;
+                       goto bad2;

                }
                }

-               d = dp->i_dev;
-               irele(dp);
-               pdp = dp;
-               dp = iget(d, fs, u.u_dent.d_ino);
-               if (dp == NULL)  {
-                       iput(pdp);
-                       brelse(nbp);
-                       return (NULL);
+               if (ndp->ni_pathlen > 1)
+                       MALLOC(cp, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
+               else
+                       cp = ndp->ni_pnbuf;
+               aiov.iov_base = cp;
+               aiov.iov_len = MAXPATHLEN;
+               auio.uio_iov = &aiov;
+               auio.uio_iovcnt = 1;
+               auio.uio_offset = 0;
+               auio.uio_rw = UIO_READ;
+               auio.uio_segflg = UIO_SYSSPACE;
+               auio.uio_resid = MAXPATHLEN;
+               if (error = VOP_READLINK(dp, &auio, ndp->ni_cred)) {
+                       if (ndp->ni_pathlen > 1)
+                               free(cp, M_NAMEI);
+                       goto bad2;

                }
                }

-               fs = dp->i_fs;
-               /*
-                * Check for symbolic link
-                */
-               if ((dp->i_mode & IFMT) == IFLNK && (follow || *cp == '/')) {
-                       pathlen = strlen(cp) + 1;
-                       if (dp->i_size + pathlen >= MAXPATHLEN - 1 ||
-                           ++nlink > MAXSYMLINKS) {
-                               u.u_error = ELOOP;
-                               iput(pdp);
-                               iput(dp);
-                               brelse(nbp);
-                               return (NULL);
-                       }
-                       bcopy(cp, nbp->b_un.b_addr + dp->i_size, pathlen);
-                       bn =  bmap(dp, (daddr_t)0, B_READ);
-                       if (bn < 0) {
-                               printf("hole in symlink: %s i = %d\n",
-                                   fs->fs_fsmnt, dp->i_number);
-                               iput(pdp);
-                               iput(dp);
-                               brelse(nbp);
-                               return (NULL);
-                       }
-                       bp = bread(dp->i_dev, fsbtodb(fs, bn),
-                                  (int)blksize(fs, dp, (daddr_t)0));
-                       if (bp->b_flags & B_ERROR) {
-                               brelse(bp);
-                               iput(pdp);
-                               iput(dp);
-                               brelse(nbp);
-                               return (NULL);
-                       }
-                       bcopy(bp->b_un.b_addr, nbp->b_un.b_addr,
-                         (unsigned)dp->i_size);
-                       brelse(bp);
-                       cp = nbp->b_un.b_addr;
-                       iput(dp);
-                       if (*cp == '/') {
-                               iput(pdp);
-                               while (*cp == '/')
-                                       cp++;
-                               if ((dp = u.u_rdir) == NULL)
-                                       dp = rootdir;
-                               ilock(dp);
-                               dp->i_count++;
-                       } else {
-                               dp = pdp;
-                               ilock(dp);
-                       }
-                       fs = dp->i_fs;
-                       goto dirloop;
-               }
-               iput(pdp);
-               if (*cp == '/') {
-                       while (*cp == '/')
-                               cp++;
-                       goto dirloop;
+               linklen = MAXPATHLEN - auio.uio_resid;
+               if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
+                       if (ndp->ni_pathlen > 1)
+                               free(cp, M_NAMEI);
+                       error = ENAMETOOLONG;
+                       goto bad2;

                }
                }

-               /*
-                * End of path, so return name matched.
-                */
-               u.u_offset -= ep->d_reclen;
-               u.u_count = newsize;
-               brelse(nbp);
-               return (dp);
+               if (ndp->ni_pathlen > 1) {
+                       bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
+                       FREE(ndp->ni_pnbuf, M_NAMEI);
+                       ndp->ni_pnbuf = cp;
+               } else
+                       ndp->ni_pnbuf[linklen] = '\0';
+               ndp->ni_ptr = cp;
+               vput(dp);
+               dp = ndp->ni_dvp;
+               if (lockparent && ndp->ni_pathlen == 1)
+                       VOP_UNLOCK(dp);
+               ndp->ni_pathlen += linklen;
+               goto start;

        }
        }

+

        /*
        /*

-        * Search failed.
-        * Report what is appropriate as per flag.
+        * Check to see if the vnode has been mounted on;
+        * if so find the root of the mounted file system.

         */
         */

-       if (bp != NULL)
-               brelse(bp);
-       if (flag == 1 && *cp == '\0' && dp->i_nlink != 0) {
-               brelse(nbp);
-               if (access(dp, IWRITE)) {
-                       iput(dp);
-                       return (NULL);
-               }
-               if (slot == NONE) {
-                       u.u_count = 0;
-               } else {
-                       u.u_offset = entryfree;
-                       u.u_count = entrysize;
+mntloop:
+       while (dp->v_type == VDIR && (mp = dp->v_mountedhere) &&
+              (ndp->ni_nameiop & NOCROSSMOUNT) == 0) {
+               while(mp->mnt_flag & MNT_MLOCK) {
+                       mp->mnt_flag |= MNT_MWAIT;
+                       sleep((caddr_t)mp, PVFS);
+                       goto mntloop;

                }
                }

-               dp->i_flag |= IUPD|ICHG;
-               return (NULL);
+               error = VFS_ROOT(dp->v_mountedhere, &tdp);
+               if (error)
+                       goto bad2;
+               vput(dp);
+               ndp->ni_vp = dp = tdp;

        }
        }

-       u.u_error = ENOENT;
-       iput(dp);
-       brelse(nbp);
-       return (NULL);
-}
-
-/*
- * Return the next character from the
- * kernel string pointed at by dirp.
- */
-schar()
-{
-
-       return (*u.u_dirp++ & 0377);
-}

 
 

-/*
- * Return the next character from the
- * user string pointed at by dirp.
- */
-uchar()
-{
-       register c;
-
-       c = fubyte(u.u_dirp++);
-       if (c == -1) {
-               u.u_error = EFAULT;
-               c = 0;
+nextname:
+       /*
+        * Not a symbolic link.  If more pathname,
+        * continue at next component, else return.
+        */
+       ndp->ni_ptr = ndp->ni_next;
+       if (*ndp->ni_ptr == '/') {
+               while (*ndp->ni_ptr == '/') {
+                       ndp->ni_ptr++;
+                       ndp->ni_pathlen--;
+               }
+               vrele(ndp->ni_dvp);
+               goto dirloop;

        }
        }

-       return (c);
-}
-
-#ifndef vax
-bcmp(s1, s2, len)
-       register char *s1, *s2;
-       register int len;
-{
-
-       while (--len)
-               if (*s1++ != *s2++)
-                       return (1);
+       /*
+        * Check for read-only file systems.
+        */
+       if (flag == DELETE || flag == RENAME) {
+               /*
+                * Disallow directory write attempts on read-only
+                * file systems.
+                */
+               if ((dp->v_mount->mnt_flag & rdonly) ||
+                   (wantparent && (ndp->ni_dvp->v_mount->mnt_flag & rdonly))) {
+                       error = EROFS;
+                       goto bad2;
+               }
+       }
+       if (!wantparent)
+               vrele(ndp->ni_dvp);
+       if ((ndp->ni_nameiop & LOCKLEAF) == 0)
+               VOP_UNLOCK(dp);
+       if (getbuf)
+               FREE(ndp->ni_pnbuf, M_NAMEI);

        return (0);
        return (0);

-}

 
 

-strlen(s1)
-       register char *s1;
-{
-       register int len;
-
-       for (len = 0; *s1++ != '\0'; len++)
-               /* void */;
-       return (len);
+bad2:
+       if (lockparent && *ndp->ni_next == '\0')
+               VOP_UNLOCK(ndp->ni_dvp);
+       vrele(ndp->ni_dvp);
+bad:
+       vput(dp);
+       ndp->ni_vp = NULL;
+       if (getbuf)
+               FREE(ndp->ni_pnbuf, M_NAMEI);
+       return (error);

 }
 }

-#endif