name resolution checking (need kern/kern_malloc.c 7.25.1.1,

[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 866fad6..7fc4eb7 100644 (file)
--- a/usr/src/sys/kern/vfs_lookup.c
+++ b/usr/src/sys/kern/vfs_lookup.c
@@ -2,47 +2,28 @@
  * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
  * All rights reserved.
  *
  * 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.
+ * %sccs.include.redist.c%

  *
  *

- *     @(#)vfs_lookup.c        7.13 (Berkeley) %G%
+ *     @(#)vfs_lookup.c        7.31.1.1 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"

+#include "syslimits.h"

 #include "time.h"
 #include "namei.h"
 #include "vnode.h"
 #include "mount.h"
 #include "errno.h"
 #include "malloc.h"
 #include "time.h"
 #include "namei.h"
 #include "vnode.h"
 #include "mount.h"
 #include "errno.h"
 #include "malloc.h"

+#include "filedesc.h"
+#include "proc.h"

 
 #ifdef KTRACE
 
 #ifdef KTRACE

-#include "user.h"
-#include "proc.h"

 #include "ktrace.h"
 #endif
 
 /*
  * Convert a pathname into a pointer to a locked inode.
 #include "ktrace.h"
 #endif
 
 /*
  * 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.
  *
  * The FOLLOW flag is set when symbolic links are to be followed
  * when they occur at the end of the name translation process.


@@ -56,148 +37,241 @@
  *
  *     copy in name
  *     get starting directory
  *
  *     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.
+ *     while (!done && !error) {
+ *             call lookup to search path.
+ *             if symbolic link, massage name in buffer and continue
+ *     }

  */
  */

-namei(ndp)
+namei(ndp, p)

        register struct nameidata *ndp;
        register struct nameidata *ndp;

+       struct proc *p;

 {
 {

+       register struct filedesc *fdp;  /* pointer to file descriptor state */

        register char *cp;              /* pointer into pathname argument */
        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 error = 0;
+       register struct vnode *dp;      /* the directory we are searching */
+       struct iovec aiov;              /* uio for reading symbolic links */
+       struct uio auio;
+       int error, linklen;
+
+       ndp->ni_cred = p->p_ucred;
+       fdp = p->p_fd;

 
 

-       flag = ndp->ni_nameiop & OPFLAG;
-       wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT);
-       lockparent = ndp->ni_nameiop & LOCKPARENT;
-       docache = (ndp->ni_nameiop & NOCACHE) ^ NOCACHE;
-       if (flag == DELETE || wantparent)
-               docache = 0;

        /*
         * Get a buffer for the name to be translated, and copy the
         * name into the buffer.
         */
        /*
         * Get a buffer for the name to be translated, and copy the
         * name into the buffer.
         */

-       MALLOC(ndp->ni_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
+       if ((ndp->ni_nameiop & HASBUF) == 0)
+               MALLOC(ndp->ni_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);

        if (ndp->ni_segflg == UIO_SYSSPACE)
        if (ndp->ni_segflg == UIO_SYSSPACE)

-               error = copystr(ndp->ni_dirp, ndp->ni_pnbuf, MAXPATHLEN,
-                   &ndp->ni_pathlen);
+               error = copystr(ndp->ni_dirp, ndp->ni_pnbuf,
+                           MAXPATHLEN, &ndp->ni_pathlen);

        else
        else

-               error = copyinstr(ndp->ni_dirp, ndp->ni_pnbuf, MAXPATHLEN,
-                   &ndp->ni_pathlen);
+               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);
        }
        if (error) {
                free(ndp->ni_pnbuf, M_NAMEI);
                ndp->ni_vp = NULL;
                return (error);
        }

-       ndp->ni_ptr = ndp->ni_pnbuf;

        ndp->ni_loopcnt = 0;
        ndp->ni_loopcnt = 0;

-       dp = ndp->ni_cdir;
-       dp->v_count++;

 #ifdef KTRACE
 #ifdef KTRACE

-       if (KTRPOINT(u.u_procp, KTR_NAMEI))
-               ktrnamei(u.u_procp->p_tracep, ndp->ni_pnbuf);
+       if (KTRPOINT(p, KTR_NAMEI))
+               ktrnamei(p->p_tracep, ndp->ni_pnbuf);

 #endif
 
 #endif
 

-start:

        /*
        /*

-        * Get starting directory.
-        * Done at start of translation and after symbolic link.
+        * Get starting point for the translation.

         */
         */

-       if (*ndp->ni_ptr == '/') {
-               vrele(dp);
-               while (*ndp->ni_ptr == '/') {
-                       ndp->ni_ptr++;
-                       ndp->ni_pathlen--;
+       if ((ndp->ni_rootdir = fdp->fd_rdir) == NULL)
+               ndp->ni_rootdir = rootdir;
+       dp = fdp->fd_cdir;
+       VREF(dp);
+       for (;;) {
+               /*
+                * Check if root directory should replace current directory.
+                * Done at start of translation and after symbolic link.
+                */
+               ndp->ni_ptr = ndp->ni_pnbuf;
+               if (*ndp->ni_ptr == '/') {
+                       vrele(dp);
+                       while (*ndp->ni_ptr == '/') {
+                               ndp->ni_ptr++;
+                               ndp->ni_pathlen--;
+                       }
+                       dp = ndp->ni_rootdir;
+                       VREF(dp);
+               }
+               ndp->ni_startdir = dp;
+               if (error = lookup(ndp, p)) {
+                       FREE(ndp->ni_pnbuf, M_NAMEI);
+                       return (error);
+               }
+               /*
+                * Check for symbolic link
+                */
+               if (ndp->ni_more == 0) {
+                       if ((ndp->ni_nameiop & (SAVENAME | SAVESTART)) == 0)
+                               FREE(ndp->ni_pnbuf, M_NAMEI);
+                       else
+                               ndp->ni_nameiop |= HASBUF;
+                       return (0);
+               }
+               if ((ndp->ni_nameiop & LOCKPARENT) && ndp->ni_pathlen == 1)
+                       VOP_UNLOCK(ndp->ni_dvp);
+               if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
+                       error = ELOOP;
+                       break;
+               }
+               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_procp = (struct proc *)0;
+               auio.uio_resid = MAXPATHLEN;
+               if (error = VOP_READLINK(ndp->ni_vp, &auio, p->p_ucred)) {
+                       if (ndp->ni_pathlen > 1)
+                               free(cp, M_NAMEI);
+                       break;

                }
                }

-               if ((dp = ndp->ni_rdir) == NULL)
-                       dp = rootdir;
-               dp->v_count++;
+               linklen = MAXPATHLEN - auio.uio_resid;
+               if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
+                       if (ndp->ni_pathlen > 1)
+                               free(cp, M_NAMEI);
+                       error = ENAMETOOLONG;
+                       break;
+               }
+               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_pathlen += linklen;
+               vput(ndp->ni_vp);
+               dp = ndp->ni_dvp;

        }
        }

-       VOP_LOCK(dp);
-       ndp->ni_endoff = 0;
+       FREE(ndp->ni_pnbuf, M_NAMEI);
+       vrele(ndp->ni_dvp);
+       vput(ndp->ni_vp);
+       ndp->ni_vp = NULL;
+       return (error);
+}
+
+/*
+ * Search a pathname.
+ * This is a very central and rather complicated routine.
+ *
+ * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
+ * The starting directory is taken from ni_startdir. The pathname is
+ * descended until done, or a symbolic link is encountered. The variable
+ * ni_more is clear if the path is completed; it is set to one if a
+ * symbolic link needing interpretation is encountered.
+ *
+ * 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, the parent directory is returned
+ * locked. If flag has WANTPARENT or'ed into it, the parent directory is
+ * returned unlocked. Otherwise the parent directory is not returned. If
+ * the target of the pathname exists and LOCKLEAF is or'ed into the flag
+ * the target is returned locked, otherwise it is returned unlocked.
+ * When creating or renaming and LOCKPARENT is specified, the target may not
+ * be ".".  When deleting and LOCKPARENT is specified, the target may be ".".
+ * NOTE: (LOOKUP | LOCKPARENT) currently returns the parent vnode unlocked.
+ * 
+ * Overall outline of lookup:
+ *
+ * dirloop:
+ *     identify next component of name at ndp->ni_ptr
+ *     handle degenerate case where name is null string
+ *     if .. and crossing mount points and on mounted filesys, find parent
+ *     call VOP_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 result vnode is mounted on and crossing mount points,
+ *         find mounted on vnode
+ *     if more components of name, do next level at dirloop
+ *     return the answer in ni_vp, locked if LOCKLEAF set
+ *         if LOCKPARENT set, return locked parent in ni_dvp
+ *         if WANTPARENT set, return unlocked parent in ni_dvp
+ */
+lookup(ndp, p)
+       register struct nameidata *ndp;
+       struct proc *p;
+{
+       register char *cp;              /* pointer into pathname argument */
+       register struct vnode *dp = 0;  /* the directory we are searching */
+       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 rdonly;                     /* mounted read-only flag bit(s) */
+       int error = 0;

 
        /*
 
        /*

-        * We come to dirloop to search a new directory.
+        * Setup: break out flag bits into variables.

         */
         */

+       flag = ndp->ni_nameiop & OPMASK;
+       wantparent = ndp->ni_nameiop & (LOCKPARENT|WANTPARENT);
+       docache = (ndp->ni_nameiop & NOCACHE) ^ NOCACHE;
+       if (flag == DELETE || (wantparent && flag != CREATE))
+               docache = 0;
+       rdonly = MNT_RDONLY;
+       if (ndp->ni_nameiop & REMOTE)
+               rdonly |= MNT_EXRDONLY;
+       ndp->ni_dvp = NULL;
+       ndp->ni_more = 0;
+       dp = ndp->ni_startdir;
+       ndp->ni_startdir = NULLVP;
+       VOP_LOCK(dp);
+

 dirloop:
        /*
 dirloop:
        /*

-        * 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.
+        * Search a new directory.
+        *
+        * The ni_hash value is for use by vfs_cache.
+        * The last component of the filename is left accessible via
+        * ndp->ptr for callers that need the name. Callers needing
+        * the name set the SAVENAME flag. When done, they assume
+        * responsibility for freeing the pathname buffer.

         */
         */

-#ifdef notdef
+       ndp->ni_hash = 0;

        for (cp = ndp->ni_ptr; *cp != 0 && *cp != '/'; cp++) {
        for (cp = ndp->ni_ptr; *cp != 0 && *cp != '/'; cp++) {

+               ndp->ni_hash += (unsigned char)*cp;

                if ((*cp & 0200) == 0)
                        continue;
                if ((*cp & 0200) == 0)
                        continue;

-               if ((*cp&0377) == ('/'|0200) || flag != DELETE) {
+               if ((*cp & 0377) == ('/' | 0200) || flag != DELETE) {

                        error = EINVAL;
                        goto bad;
                }
        }
        ndp->ni_namelen = cp - ndp->ni_ptr;
                        error = EINVAL;
                        goto bad;
                }
        }
        ndp->ni_namelen = cp - ndp->ni_ptr;

-       if (ndp->ni_namelen >= MAXNAMLEN) {
+       if (ndp->ni_namelen >= NAME_MAX) {

                error = ENAMETOOLONG;
                goto bad;
        }
                error = ENAMETOOLONG;
                goto bad;
        }

-       ndp->ni_pathlen -= ndp->ni_namelen;

 #ifdef NAMEI_DIAGNOSTIC
        { char c = *cp;
        *cp = '\0';
        printf("{%s}: ", ndp->ni_ptr);
        *cp = c; }
 #endif
 #ifdef NAMEI_DIAGNOSTIC
        { char c = *cp;
        *cp = '\0';
        printf("{%s}: ", ndp->ni_ptr);
        *cp = c; }
 #endif

-#else fornow
-       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;
-#ifdef NAMEI_DIAGNOSTIC
-       printf("{%s}: ", ndp->ni_dent.d_name);
-#endif
-#endif fornow
+       ndp->ni_pathlen -= ndp->ni_namelen;

        ndp->ni_next = cp;
        ndp->ni_makeentry = 1;
        if (*cp == '\0' && docache == 0)
                ndp->ni_makeentry = 0;
        ndp->ni_isdotdot = (ndp->ni_namelen == 2 &&
        ndp->ni_next = cp;
        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] == '.');
+               ndp->ni_ptr[1] == '.' && ndp->ni_ptr[0] == '.');

 
        /*
         * Check for degenerate name (e.g. / or "")
 
        /*
         * Check for degenerate name (e.g. / or "")


@@ -209,10 +283,15 @@ dirloop:
                        error = EISDIR;
                        goto bad;
                }
                        error = EISDIR;
                        goto bad;
                }

-               free(ndp->ni_pnbuf, M_NAMEI);
+               if (dp->v_type != VDIR) {
+                       error = ENOTDIR;
+                       goto bad;
+               }

                if (!(ndp->ni_nameiop & LOCKLEAF))
                        VOP_UNLOCK(dp);
                ndp->ni_vp = dp;
                if (!(ndp->ni_nameiop & LOCKLEAF))
                        VOP_UNLOCK(dp);
                ndp->ni_vp = dp;

+               if (ndp->ni_nameiop & SAVESTART)
+                       panic("lookup: SAVESTART");

                return (0);
        }
 
                return (0);
        }
 


@@ -221,108 +300,75 @@ dirloop:
         * 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
         * 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
+        *    filesystem, then replace it with the

         *    vnode which was mounted on so we take the
         *    .. in the other file system.
         */
        if (ndp->ni_isdotdot) {
                for (;;) {
         *    vnode which was mounted on so we take the
         *    .. in the other file system.
         */
        if (ndp->ni_isdotdot) {
                for (;;) {

-                       if (dp == ndp->ni_rdir || dp == rootdir) {
+                       if (dp == ndp->ni_rootdir) {

                                ndp->ni_dvp = dp;
                                ndp->ni_dvp = dp;

-                               dp->v_count++;
+                               ndp->ni_vp = dp;
+                               VREF(dp);

                                goto nextname;
                        }
                                goto nextname;
                        }

-                       if ((dp->v_flag & VROOT) == 0)
+                       if ((dp->v_flag & VROOT) == 0 ||
+                           (ndp->ni_nameiop & NOCROSSMOUNT))

                                break;
                        tdp = dp;
                                break;
                        tdp = dp;

-                       dp = dp->v_mount->m_vnodecovered;
+                       dp = dp->v_mount->mnt_vnodecovered;

                        vput(tdp);
                        vput(tdp);

+                       VREF(dp);

                        VOP_LOCK(dp);
                        VOP_LOCK(dp);

-                       dp->v_count++;

                }
        }
 
        /*
         * We now have a segment name to search for, and a directory to search.
         */
                }
        }
 
        /*
         * We now have a segment name to search for, and a directory to search.
         */

-       if (error = VOP_LOOKUP(dp, ndp)) {
+       if (error = VOP_LOOKUP(dp, ndp, p)) {
+#ifdef DIAGNOSTIC

                if (ndp->ni_vp != NULL)
                        panic("leaf should be empty");
                if (ndp->ni_vp != NULL)
                        panic("leaf should be empty");

+#endif

 #ifdef NAMEI_DIAGNOSTIC
                printf("not found\n");
 #endif
 #ifdef NAMEI_DIAGNOSTIC
                printf("not found\n");
 #endif

+               if (flag == LOOKUP || flag == DELETE ||
+                   error != ENOENT || *cp != 0)
+                       goto bad;

                /*
                 * If creating and at end of pathname, then can consider
                 * allowing file to be created.
                 */
                /*
                 * If creating and at end of pathname, then can consider
                 * allowing file to be created.
                 */

-               if (ndp->ni_dvp->v_mount->m_flag & M_RDONLY)
+               if (ndp->ni_dvp->v_mount->mnt_flag & rdonly) {

                        error = EROFS;
                        error = EROFS;

-               if (flag == LOOKUP || flag == DELETE ||
-                   error != ENOENT || *cp != 0)

                        goto bad;
                        goto bad;

+               }

                /*
                 * 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.
                 */
                /*
                 * 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.
                 */

-               FREE(ndp->ni_pnbuf, M_NAMEI);
-               return (0);     /* should this be ENOENT? */
+               if (ndp->ni_nameiop & SAVESTART) {
+                       ndp->ni_startdir = ndp->ni_dvp;
+                       VREF(ndp->ni_startdir);
+                       p->p_spare[1]++;
+               }
+               return (0);

        }
 #ifdef NAMEI_DIAGNOSTIC
        printf("found\n");
 #endif
 
        }
 #ifdef NAMEI_DIAGNOSTIC
        printf("found\n");
 #endif
 

+       dp = ndp->ni_vp;

        /*
         * Check for symbolic link
         */
        /*
         * Check for symbolic link
         */

-       dp = ndp->ni_vp;

        if ((dp->v_type == VLNK) &&
            ((ndp->ni_nameiop & FOLLOW) || *ndp->ni_next == '/')) {
        if ((dp->v_type == VLNK) &&
            ((ndp->ni_nameiop & FOLLOW) || *ndp->ni_next == '/')) {

-               struct iovec aiov;
-               struct uio auio;
-               int linklen;
-
-               if (++ndp->ni_loopcnt > MAXSYMLINKS) {
-                       error = ELOOP;
-                       goto bad2;
-               }
-               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;
-               }
-               linklen = MAXPATHLEN - auio.uio_resid;
-               if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
-                       if (ndp->ni_pathlen > 1)
-                               free(cp, M_NAMEI);
-                       error = ENAMETOOLONG;
-                       goto bad2;
-               }
-               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;
-               ndp->ni_pathlen += linklen;
-               vput(dp);
-               dp = ndp->ni_dvp;
-               if (lockparent && *ndp->ni_next == '\0')
-                       VOP_UNLOCK(dp);
-               goto start;
+               ndp->ni_more = 1;
+               return (0);

        }
 
        /*
        }
 
        /*


@@ -330,14 +376,14 @@ dirloop:
         * if so find the root of the mounted file system.
         */
 mntloop:
         * if so find the root of the mounted file system.
         */
 mntloop:

-       while (dp->v_type == VDIR && (mp = dp->v_mountedhere)) {
-               while(mp->m_flag & M_MLOCK) {
-                       mp->m_flag |= M_MWAIT;
+       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;
                }
                        sleep((caddr_t)mp, PVFS);
                        goto mntloop;
                }

-               error = VFS_ROOT(dp->v_mountedhere, &tdp);
-               if (error)
+               if (error = VFS_ROOT(dp->v_mountedhere, &tdp))

                        goto bad2;
                vput(dp);
                ndp->ni_vp = dp = tdp;
                        goto bad2;
                vput(dp);
                ndp->ni_vp = dp = tdp;


@@ -348,8 +394,8 @@ nextname:
         * Not a symbolic link.  If more pathname,
         * continue at next component, else return.
         */
         * Not a symbolic link.  If more pathname,
         * continue at next component, else return.
         */

-       ndp->ni_ptr = ndp->ni_next;
-       if (*ndp->ni_ptr == '/') {
+       if (*ndp->ni_next == '/') {
+               ndp->ni_ptr = ndp->ni_next;

                while (*ndp->ni_ptr == '/') {
                        ndp->ni_ptr++;
                        ndp->ni_pathlen--;
                while (*ndp->ni_ptr == '/') {
                        ndp->ni_ptr++;
                        ndp->ni_pathlen--;


@@ -358,52 +404,36 @@ nextname:
                goto dirloop;
        }
        /*
                goto dirloop;
        }
        /*

-        * Check for read-only file systems and executing texts
+        * Check for read-only file systems.

         */
         */

-       if (flag != LOOKUP) {
+       if (flag == DELETE || flag == RENAME) {

                /*
                /*

-                * Disallow write attempts on read-only file systems;
-                * unless the file is a socket or a block or character
-                * device resident on the file system.
+                * Disallow directory write attempts on read-only
+                * file systems.

                 */
                 */

-               if ((dp->v_mount->m_flag & M_RDONLY) &&
-                   dp->v_type != VCHR &&
-                   dp->v_type != VBLK &&
-                   dp->v_type != VSOCK) {
-                       error = EROFS;
-                       goto bad2;
-               }
-               /*
-                * If there's shared text associated with
-                * the inode, try to free it up once.  If
-                * we fail, we can't allow writing.
-                */
-               if (dp->v_flag & VTEXT)
-                       xrele(dp);
-               if (dp->v_flag & VTEXT) {
-                       error = ETXTBSY;
-                       goto bad2;
-               }
-               if (wantparent && flag != CREATE &&
-                   (ndp->ni_dvp->v_mount->m_flag & M_RDONLY)) {
+               if ((dp->v_mount->mnt_flag & rdonly) ||
+                   (wantparent && (ndp->ni_dvp->v_mount->mnt_flag & rdonly))) {

                        error = EROFS;
                        goto bad2;
                }
        }
                        error = EROFS;
                        goto bad2;
                }
        }

+       if (ndp->ni_nameiop & SAVESTART) {
+               ndp->ni_startdir = ndp->ni_dvp;
+               p->p_spare[1]++;
+               VREF(ndp->ni_startdir);
+       }

        if (!wantparent)
                vrele(ndp->ni_dvp);
        if ((ndp->ni_nameiop & LOCKLEAF) == 0)
                VOP_UNLOCK(dp);
        if (!wantparent)
                vrele(ndp->ni_dvp);
        if ((ndp->ni_nameiop & LOCKLEAF) == 0)
                VOP_UNLOCK(dp);

-       FREE(ndp->ni_pnbuf, M_NAMEI);

        return (0);
 
 bad2:
        return (0);
 
 bad2:

-       if (lockparent && *ndp->ni_next == '\0')
+       if ((ndp->ni_nameiop & LOCKPARENT) && *ndp->ni_next == '\0')

                VOP_UNLOCK(ndp->ni_dvp);
        vrele(ndp->ni_dvp);
 bad:
        vput(dp);
        ndp->ni_vp = NULL;
                VOP_UNLOCK(ndp->ni_dvp);
        vrele(ndp->ni_dvp);
 bad:
        vput(dp);
        ndp->ni_vp = NULL;

-       FREE(ndp->ni_pnbuf, M_NAMEI);

        return (error);
 }
        return (error);
 }