sys/nfsserver/nfs_serv.c

   1 /*
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Rick Macklem at The University of Guelph.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)nfs_serv.c  8.8 (Berkeley) 7/31/95
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 /*
  43  * nfs version 2 and 3 server calls to vnode ops
  44  * - these routines generally have 3 phases
  45  *   1 - break down and validate rpc request in mbuf list
  46  *   2 - do the vnode ops for the request
  47  *       (surprisingly ?? many are very similar to syscalls in vfs_syscalls.c)
  48  *   3 - build the rpc reply in an mbuf list
  49  *   nb:
  50  *      - do not mix the phases, since the nfsm_?? macros can return failures
  51  *        on a bad rpc or similar and do not do any vrele() or vput()'s
  52  *
  53  *      - the nfsm_reply() macro generates an nfs rpc reply with the nfs
  54  *      error number iff error != 0 whereas
  55  *      returning an error from the server function implies a fatal error
  56  *      such as a badly constructed rpc request that should be dropped without
  57  *      a reply.
  58  *      For nfsm_reply(), the case where error == EBADRPC is treated
  59  *      specially; after constructing a reply, it does an immediate
  60  *      `goto nfsmout' to avoid getting any V3 post-op status appended.
  61  *
  62  * Other notes:
  63  *      Warning: always pay careful attention to resource cleanup on return
  64  *      and note that nfsm_*() macros can terminate a procedure on certain
  65  *      errors.
  66  *
  67  *      lookup() and namei()
  68  *      may return garbage in various structural fields/return elements
  69  *      if an error is returned, and may garbage up nd.ni_dvp even if no
  70  *      error is returned and you did not request LOCKPARENT or WANTPARENT.
  71  *
  72  *      We use the ni_cnd.cn_flags 'HASBUF' flag to track whether the name
  73  *      buffer has been freed or not.
  74  */
  75
  76 #include <sys/param.h>
  77 #include <sys/systm.h>
  78 #include <sys/proc.h>
  79 #include <sys/namei.h>
  80 #include <sys/unistd.h>
  81 #include <sys/vnode.h>
  82 #include <sys/mount.h>
  83 #include <sys/socket.h>
  84 #include <sys/socketvar.h>
  85 #include <sys/malloc.h>
  86 #include <sys/mbuf.h>
  87 #include <sys/dirent.h>
  88 #include <sys/stat.h>
  89 #include <sys/kernel.h>
  90 #include <sys/sysctl.h>
  91 #include <sys/bio.h>
  92 #include <sys/buf.h>
  93
  94 #include <vm/vm.h>
  95 #include <vm/vm_extern.h>
  96 #include <vm/vm_object.h>
  97
  98 #include <nfs/nfsproto.h>
  99 #include <nfs/rpcv2.h>
 100 #include <nfsserver/nfs.h>
 101 #include <nfs/xdr_subs.h>
 102 #include <nfsserver/nfsm_subs.h>
 103
 104 #ifdef NFSRV_DEBUG
 105 #define nfsdbprintf(info)       printf info
 106 #else
 107 #define nfsdbprintf(info)
 108 #endif
 109
 110 #define MAX_COMMIT_COUNT        (1024 * 1024)
 111
 112 #define NUM_HEURISTIC           64
 113 #define NHUSE_INIT              64
 114 #define NHUSE_INC               16
 115 #define NHUSE_MAX               2048
 116
 117 static struct nfsheur {
 118         struct vnode *nh_vp;    /* vp to match (unreferenced pointer) */
 119         off_t nh_nextr;         /* next offset for sequential detection */
 120         int nh_use;             /* use count for selection */
 121         int nh_seqcount;        /* heuristic */
 122 } nfsheur[NUM_HEURISTIC];
 123
 124 /* Global vars */
 125
 126 int nfsrvw_procrastinate = NFS_GATHERDELAY * 1000;
 127 int nfsrvw_procrastinate_v3 = 0;
 128
 129 static struct timeval   nfsver = { 0 };
 130
 131 SYSCTL_NODE(_vfs, OID_AUTO, nfsrv, CTLFLAG_RW, 0, "NFS server");
 132
 133 static int nfs_async;
 134 static int nfs_commit_blks;
 135 static int nfs_commit_miss;
 136 SYSCTL_INT(_vfs_nfsrv, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0, "");
 137 SYSCTL_INT(_vfs_nfsrv, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks, 0, "");
 138 SYSCTL_INT(_vfs_nfsrv, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0, "");
 139
 140 struct nfsrvstats nfsrvstats;
 141 SYSCTL_STRUCT(_vfs_nfsrv, NFS_NFSRVSTATS, nfsrvstats, CTLFLAG_RD,
 142         &nfsrvstats, nfsrvstats, "S,nfsrvstats");
 143
 144 static int      nfsrv_access(struct vnode *, int, struct ucred *, int,
 145                     struct thread *, int);
 146 static void     nfsrvw_coalesce(struct nfsrv_descript *,
 147                     struct nfsrv_descript *);
 148
 149 /*
 150  * Clear nameidata fields that are tested in nsfmout cleanup code prior
 151  * to using first nfsm macro (that might jump to the cleanup code).
 152  */
 153
 154 static __inline void
 155 ndclear(struct nameidata *nd)
 156 {
 157
 158         nd->ni_cnd.cn_flags = 0;
 159         nd->ni_vp = NULL;
 160         nd->ni_dvp = NULL;
 161         nd->ni_startdir = NULL;
 162 }
 163
 164 /*
 165  * nfs v3 access service
 166  */
 167 int
 168 nfsrv3_access(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 169     struct thread *td, struct mbuf **mrq)
 170 {
 171         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 172         struct sockaddr *nam = nfsd->nd_nam;
 173         caddr_t dpos = nfsd->nd_dpos;
 174         struct ucred *cred = &nfsd->nd_cr;
 175         struct vnode *vp = NULL;
 176         nfsfh_t nfh;
 177         fhandle_t *fhp;
 178         u_int32_t *tl;
 179         caddr_t bpos;
 180         int error = 0, rdonly, getret;
 181         struct mbuf *mb, *mreq;
 182         struct vattr vattr, *vap = &vattr;
 183         u_long testmode, nfsmode;
 184         int v3 = (nfsd->nd_flag & ND_NFSV3);
 185
 186         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 187         if (!v3)
 188                 panic("nfsrv3_access: v3 proc called on a v2 connection");
 189         fhp = &nfh.fh_generic;
 190         nfsm_srvmtofh(fhp);
 191         tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
 192         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
 193         if (error) {
 194                 nfsm_reply(NFSX_UNSIGNED);
 195                 nfsm_srvpostop_attr(1, (struct vattr *)0);
 196                 error = 0;
 197                 goto nfsmout;
 198         }
 199         nfsmode = fxdr_unsigned(u_int32_t, *tl);
 200         if ((nfsmode & NFSV3ACCESS_READ) &&
 201                 nfsrv_access(vp, VREAD, cred, rdonly, td, 0))
 202                 nfsmode &= ~NFSV3ACCESS_READ;
 203         if (vp->v_type == VDIR)
 204                 testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
 205                         NFSV3ACCESS_DELETE);
 206         else
 207                 testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
 208         if ((nfsmode & testmode) &&
 209                 nfsrv_access(vp, VWRITE, cred, rdonly, td, 0))
 210                 nfsmode &= ~testmode;
 211         if (vp->v_type == VDIR)
 212                 testmode = NFSV3ACCESS_LOOKUP;
 213         else
 214                 testmode = NFSV3ACCESS_EXECUTE;
 215         if ((nfsmode & testmode) &&
 216                 nfsrv_access(vp, VEXEC, cred, rdonly, td, 0))
 217                 nfsmode &= ~testmode;
 218         getret = VOP_GETATTR(vp, vap, cred, td);
 219         vput(vp);
 220         vp = NULL;
 221         nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED);
 222         nfsm_srvpostop_attr(getret, vap);
 223         tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
 224         *tl = txdr_unsigned(nfsmode);
 225 nfsmout:
 226         if (vp)
 227                 vput(vp);
 228         return(error);
 229 }
 230
 231 /*
 232  * nfs getattr service
 233  */
 234 int
 235 nfsrv_getattr(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 236     struct thread *td, struct mbuf **mrq)
 237 {
 238         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 239         struct sockaddr *nam = nfsd->nd_nam;
 240         caddr_t dpos = nfsd->nd_dpos;
 241         struct ucred *cred = &nfsd->nd_cr;
 242         struct nfs_fattr *fp;
 243         struct vattr va;
 244         struct vattr *vap = &va;
 245         struct vnode *vp = NULL;
 246         nfsfh_t nfh;
 247         fhandle_t *fhp;
 248         caddr_t bpos;
 249         int error = 0, rdonly;
 250         struct mbuf *mb, *mreq;
 251
 252         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 253         fhp = &nfh.fh_generic;
 254         nfsm_srvmtofh(fhp);
 255         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
 256         if (error) {
 257                 nfsm_reply(0);
 258                 error = 0;
 259                 goto nfsmout;
 260         }
 261         error = VOP_GETATTR(vp, vap, cred, td);
 262         vput(vp);
 263         vp = NULL;
 264         nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
 265         if (error) {
 266                 error = 0;
 267                 goto nfsmout;
 268         }
 269         fp = nfsm_build(struct nfs_fattr *,
 270             NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
 271         nfsm_srvfillattr(vap, fp);
 272         /* fall through */
 273
 274 nfsmout:
 275         if (vp)
 276                 vput(vp);
 277         return(error);
 278 }
 279
 280 /*
 281  * nfs setattr service
 282  */
 283 int
 284 nfsrv_setattr(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 285     struct thread *td, struct mbuf **mrq)
 286 {
 287         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 288         struct sockaddr *nam = nfsd->nd_nam;
 289         caddr_t dpos = nfsd->nd_dpos;
 290         struct ucred *cred = &nfsd->nd_cr;
 291         struct vattr va, preat;
 292         struct vattr *vap = &va;
 293         struct nfsv2_sattr *sp;
 294         struct nfs_fattr *fp;
 295         struct vnode *vp = NULL;
 296         nfsfh_t nfh;
 297         fhandle_t *fhp;
 298         u_int32_t *tl;
 299         caddr_t bpos;
 300         int error = 0, rdonly, preat_ret = 1, postat_ret = 1;
 301         int v3 = (nfsd->nd_flag & ND_NFSV3), gcheck = 0;
 302         struct mbuf *mb, *mreq;
 303         struct timespec guard;
 304         struct mount *mp = NULL;
 305
 306         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 307         fhp = &nfh.fh_generic;
 308         nfsm_srvmtofh(fhp);
 309         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
 310                 error = ESTALE;
 311                 goto out;
 312         }
 313         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
 314                 mp = NULL;
 315                 goto out;
 316         }
 317         (void) vn_start_write(vp, &mp, V_WAIT);
 318         vput(vp);
 319         vp = NULL;
 320         VATTR_NULL(vap);
 321         if (v3) {
 322                 nfsm_srvsattr(vap);
 323                 tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
 324                 gcheck = fxdr_unsigned(int, *tl);
 325                 if (gcheck) {
 326                         tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
 327                         fxdr_nfsv3time(tl, &guard);
 328                 }
 329         } else {
 330                 sp = nfsm_dissect(struct nfsv2_sattr *, NFSX_V2SATTR);
 331                 /*
 332                  * Nah nah nah nah na nah
 333                  * There is a bug in the Sun client that puts 0xffff in the mode
 334                  * field of sattr when it should put in 0xffffffff. The u_short
 335                  * doesn't sign extend.
 336                  * --> check the low order 2 bytes for 0xffff
 337                  */
 338                 if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
 339                         vap->va_mode = nfstov_mode(sp->sa_mode);
 340                 if (sp->sa_uid != nfsrv_nfs_xdrneg1)
 341                         vap->va_uid = fxdr_unsigned(uid_t, sp->sa_uid);
 342                 if (sp->sa_gid != nfsrv_nfs_xdrneg1)
 343                         vap->va_gid = fxdr_unsigned(gid_t, sp->sa_gid);
 344                 if (sp->sa_size != nfsrv_nfs_xdrneg1)
 345                         vap->va_size = fxdr_unsigned(u_quad_t, sp->sa_size);
 346                 if (sp->sa_atime.nfsv2_sec != nfsrv_nfs_xdrneg1) {
 347 #ifdef notyet
 348                         fxdr_nfsv2time(&sp->sa_atime, &vap->va_atime);
 349 #else
 350                         vap->va_atime.tv_sec =
 351                                 fxdr_unsigned(int32_t, sp->sa_atime.nfsv2_sec);
 352                         vap->va_atime.tv_nsec = 0;
 353 #endif
 354                 }
 355                 if (sp->sa_mtime.nfsv2_sec != nfsrv_nfs_xdrneg1)
 356                         fxdr_nfsv2time(&sp->sa_mtime, &vap->va_mtime);
 357
 358         }
 359
 360         /*
 361          * Now that we have all the fields, lets do it.
 362          */
 363         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
 364         if (error) {
 365                 nfsm_reply(2 * NFSX_UNSIGNED);
 366                 if (v3)
 367                         nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
 368                 error = 0;
 369                 goto nfsmout;
 370         }
 371
 372         /*
 373          * vp now an active resource, pay careful attention to cleanup
 374          */
 375         if (v3) {
 376                 error = preat_ret = VOP_GETATTR(vp, &preat, cred, td);
 377                 if (!error && gcheck &&
 378                         (preat.va_ctime.tv_sec != guard.tv_sec ||
 379                          preat.va_ctime.tv_nsec != guard.tv_nsec))
 380                         error = NFSERR_NOT_SYNC;
 381                 if (error) {
 382                         vput(vp);
 383                         vp = NULL;
 384                         nfsm_reply(NFSX_WCCDATA(v3));
 385                         if (v3)
 386                                 nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
 387                         error = 0;
 388                         goto nfsmout;
 389                 }
 390         }
 391
 392         /*
 393          * If the size is being changed write acces is required, otherwise
 394          * just check for a read only file system.
 395          */
 396         if (vap->va_size == ((u_quad_t)((quad_t) -1))) {
 397                 if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
 398                         error = EROFS;
 399                         goto out;
 400                 }
 401         } else {
 402                 if (vp->v_type == VDIR) {
 403                         error = EISDIR;
 404                         goto out;
 405                 } else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly,
 406                         td, 0)) != 0)
 407                         goto out;
 408         }
 409         error = VOP_SETATTR(vp, vap, cred, td);
 410         postat_ret = VOP_GETATTR(vp, vap, cred, td);
 411         if (!error)
 412                 error = postat_ret;
 413 out:
 414         if (vp != NULL)
 415                 vput(vp);
 416         vp = NULL;
 417         nfsm_reply(NFSX_WCCORFATTR(v3));
 418         if (v3) {
 419                 nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
 420         } else if (!error) {
 421                 /* v2 non-error case. */
 422                 fp = nfsm_build(struct nfs_fattr *, NFSX_V2FATTR);
 423                 nfsm_srvfillattr(vap, fp);
 424         }
 425         error = 0;
 426         /* fall through */
 427
 428 nfsmout:
 429         if (vp)
 430                 vput(vp);
 431         vn_finished_write(mp);
 432         return(error);
 433 }
 434
 435 /*
 436  * nfs lookup rpc
 437  */
 438 int
 439 nfsrv_lookup(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 440     struct thread *td, struct mbuf **mrq)
 441 {
 442         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 443         struct sockaddr *nam = nfsd->nd_nam;
 444         caddr_t dpos = nfsd->nd_dpos;
 445         struct ucred *cred = &nfsd->nd_cr;
 446         struct nfs_fattr *fp;
 447         struct nameidata nd, ind, *ndp = &nd;
 448         struct vnode *vp, *dirp = NULL;
 449         nfsfh_t nfh;
 450         fhandle_t *fhp;
 451         caddr_t bpos;
 452         int error = 0, len, dirattr_ret = 1;
 453         int v3 = (nfsd->nd_flag & ND_NFSV3), pubflag;
 454         struct mbuf *mb, *mreq;
 455         struct vattr va, dirattr, *vap = &va;
 456
 457         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 458         ndclear(&nd);
 459
 460         fhp = &nfh.fh_generic;
 461         nfsm_srvmtofh(fhp);
 462         nfsm_srvnamesiz(len);
 463
 464         pubflag = nfs_ispublicfh(fhp);
 465
 466         nd.ni_cnd.cn_cred = cred;
 467         nd.ni_cnd.cn_nameiop = LOOKUP;
 468         nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART;
 469         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
 470                 &dirp, td, pubflag);
 471
 472         /*
 473          * namei failure, only dirp to cleanup.  Clear out garbarge from
 474          * structure in case macros jump to nfsmout.
 475          */
 476
 477         if (error) {
 478                 if (dirp) {
 479                         if (v3)
 480                                 dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred,
 481                                         td);
 482                         vrele(dirp);
 483                         dirp = NULL;
 484                 }
 485                 nfsm_reply(NFSX_POSTOPATTR(v3));
 486                 if (v3)
 487                         nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 488                 error = 0;
 489                 goto nfsmout;
 490         }
 491
 492         /*
 493          * Locate index file for public filehandle
 494          *
 495          * error is 0 on entry and 0 on exit from this block.
 496          */
 497
 498         if (pubflag) {
 499                 if (nd.ni_vp->v_type == VDIR && nfs_pub.np_index != NULL) {
 500                         /*
 501                          * Setup call to lookup() to see if we can find
 502                          * the index file. Arguably, this doesn't belong
 503                          * in a kernel.. Ugh.  If an error occurs, do not
 504                          * try to install an index file and then clear the
 505                          * error.
 506                          *
 507                          * When we replace nd with ind and redirect ndp,
 508                          * maintenance of ni_startdir and ni_vp shift to
 509                          * ind and we have to clean them up in the old nd.
 510                          * However, the cnd resource continues to be maintained
 511                          * via the original nd.  Confused?  You aren't alone!
 512                          */
 513                         ind = nd;
 514                         VOP_UNLOCK(nd.ni_vp, 0, td);
 515                         ind.ni_pathlen = strlen(nfs_pub.np_index);
 516                         ind.ni_cnd.cn_nameptr = ind.ni_cnd.cn_pnbuf =
 517                             nfs_pub.np_index;
 518                         ind.ni_startdir = nd.ni_vp;
 519                         VREF(ind.ni_startdir);
 520
 521                         error = lookup(&ind);
 522                         ind.ni_dvp = NULL;
 523
 524                         if (error == 0) {
 525                                 /*
 526                                  * Found an index file. Get rid of
 527                                  * the old references.  transfer nd.ni_vp'
 528                                  */
 529                                 if (dirp)
 530                                         vrele(dirp);
 531                                 dirp = nd.ni_vp;
 532                                 nd.ni_vp = NULL;
 533                                 vrele(nd.ni_startdir);
 534                                 nd.ni_startdir = NULL;
 535                                 ndp = &ind;
 536                         }
 537                         error = 0;
 538                 }
 539                 /*
 540                  * If the public filehandle was used, check that this lookup
 541                  * didn't result in a filehandle outside the publicly exported
 542                  * filesystem.  We clear the poor vp here to avoid lockups due
 543                  * to NFS I/O.
 544                  */
 545
 546                 if (ndp->ni_vp->v_mount != nfs_pub.np_mount) {
 547                         vput(nd.ni_vp);
 548                         nd.ni_vp = NULL;
 549                         error = EPERM;
 550                 }
 551         }
 552
 553         if (dirp) {
 554                 if (v3)
 555                         dirattr_ret = VOP_GETATTR(dirp, &dirattr, cred,
 556                                 td);
 557                 vrele(dirp);
 558                 dirp = NULL;
 559         }
 560
 561         /*
 562          * Resources at this point:
 563          *      ndp->ni_vp      may not be NULL
 564          *
 565          */
 566
 567         if (error) {
 568                 nfsm_reply(NFSX_POSTOPATTR(v3));
 569                 if (v3)
 570                         nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 571                 error = 0;
 572                 goto nfsmout;
 573         }
 574
 575         /*
 576          * Clear out some resources prior to potentially blocking.  This
 577          * is not as critical as ni_dvp resources in other routines, but
 578          * it helps.
 579          */
 580         vrele(ndp->ni_startdir);
 581         ndp->ni_startdir = NULL;
 582         NDFREE(&nd, NDF_ONLY_PNBUF);
 583
 584         /*
 585          * Get underlying attribute, then release remaining resources ( for
 586          * the same potential blocking reason ) and reply.
 587          */
 588         vp = ndp->ni_vp;
 589         bzero((caddr_t)fhp, sizeof(nfh));
 590         fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
 591         error = VFS_VPTOFH(vp, &fhp->fh_fid);
 592         if (!error)
 593                 error = VOP_GETATTR(vp, vap, cred, td);
 594
 595         vput(vp);
 596         ndp->ni_vp = NULL;
 597         nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPORFATTR(v3) + NFSX_POSTOPATTR(v3));
 598         if (error) {
 599                 if (v3)
 600                         nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 601                 error = 0;
 602                 goto nfsmout;
 603         }
 604         nfsm_srvfhtom(fhp, v3);
 605         if (v3) {
 606                 nfsm_srvpostop_attr(0, vap);
 607                 nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 608         } else {
 609                 fp = nfsm_build(struct nfs_fattr *, NFSX_V2FATTR);
 610                 nfsm_srvfillattr(vap, fp);
 611         }
 612
 613 nfsmout:
 614         if (dirp)
 615                 vrele(dirp);
 616         NDFREE(&nd, NDF_ONLY_PNBUF);
 617         if (ndp->ni_startdir)
 618                 vrele(ndp->ni_startdir);
 619         if (ndp->ni_vp)
 620                 vput(ndp->ni_vp);
 621         return (error);
 622 }
 623
 624 /*
 625  * nfs readlink service
 626  */
 627 int
 628 nfsrv_readlink(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 629     struct thread *td, struct mbuf **mrq)
 630 {
 631         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 632         struct sockaddr *nam = nfsd->nd_nam;
 633         caddr_t dpos = nfsd->nd_dpos;
 634         struct ucred *cred = &nfsd->nd_cr;
 635         struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
 636         struct iovec *ivp = iv;
 637         struct mbuf *mp;
 638         u_int32_t *tl;
 639         caddr_t bpos;
 640         int error = 0, rdonly, i, tlen, len, getret;
 641         int v3 = (nfsd->nd_flag & ND_NFSV3);
 642         struct mbuf *mb, *mp3, *nmp, *mreq;
 643         struct vnode *vp = NULL;
 644         struct vattr attr;
 645         nfsfh_t nfh;
 646         fhandle_t *fhp;
 647         struct uio io, *uiop = &io;
 648
 649         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 650 #ifndef nolint
 651         mp = (struct mbuf *)0;
 652 #endif
 653         mp3 = NULL;
 654         fhp = &nfh.fh_generic;
 655         nfsm_srvmtofh(fhp);
 656         len = 0;
 657         i = 0;
 658         while (len < NFS_MAXPATHLEN) {
 659                 MGET(nmp, M_TRYWAIT, MT_DATA);
 660                 MCLGET(nmp, M_TRYWAIT);
 661                 nmp->m_len = NFSMSIZ(nmp);
 662                 if (len == 0)
 663                         mp3 = mp = nmp;
 664                 else {
 665                         mp->m_next = nmp;
 666                         mp = nmp;
 667                 }
 668                 if ((len + mp->m_len) > NFS_MAXPATHLEN) {
 669                         mp->m_len = NFS_MAXPATHLEN - len;
 670                         len = NFS_MAXPATHLEN;
 671                 } else
 672                         len += mp->m_len;
 673                 ivp->iov_base = mtod(mp, caddr_t);
 674                 ivp->iov_len = mp->m_len;
 675                 i++;
 676                 ivp++;
 677         }
 678         uiop->uio_iov = iv;
 679         uiop->uio_iovcnt = i;
 680         uiop->uio_offset = 0;
 681         uiop->uio_resid = len;
 682         uiop->uio_rw = UIO_READ;
 683         uiop->uio_segflg = UIO_SYSSPACE;
 684         uiop->uio_td = (struct thread *)0;
 685         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
 686         if (error) {
 687                 nfsm_reply(2 * NFSX_UNSIGNED);
 688                 if (v3)
 689                         nfsm_srvpostop_attr(1, (struct vattr *)0);
 690                 error = 0;
 691                 goto nfsmout;
 692         }
 693         if (vp->v_type != VLNK) {
 694                 if (v3)
 695                         error = EINVAL;
 696                 else
 697                         error = ENXIO;
 698                 goto out;
 699         }
 700         error = VOP_READLINK(vp, uiop, cred);
 701 out:
 702         getret = VOP_GETATTR(vp, &attr, cred, td);
 703         vput(vp);
 704         vp = NULL;
 705         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED);
 706         if (v3)
 707                 nfsm_srvpostop_attr(getret, &attr);
 708         if (error) {
 709                 error = 0;
 710                 goto nfsmout;
 711         }
 712         if (uiop->uio_resid > 0) {
 713                 len -= uiop->uio_resid;
 714                 tlen = nfsm_rndup(len);
 715                 nfsm_adj(mp3, NFS_MAXPATHLEN-tlen, tlen-len);
 716         }
 717         tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
 718         *tl = txdr_unsigned(len);
 719         mb->m_next = mp3;
 720         mp3 = NULL;
 721 nfsmout:
 722         if (mp3)
 723                 m_freem(mp3);
 724         if (vp)
 725                 vput(vp);
 726         return(error);
 727 }
 728
 729 /*
 730  * nfs read service
 731  */
 732 int
 733 nfsrv_read(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 734     struct thread *td, struct mbuf **mrq)
 735 {
 736         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 737         struct sockaddr *nam = nfsd->nd_nam;
 738         caddr_t dpos = nfsd->nd_dpos;
 739         struct ucred *cred = &nfsd->nd_cr;
 740         struct iovec *iv;
 741         struct iovec *iv2;
 742         struct mbuf *m;
 743         struct nfs_fattr *fp;
 744         u_int32_t *tl;
 745         int i;
 746         caddr_t bpos;
 747         int error = 0, rdonly, cnt, len, left, siz, tlen, getret;
 748         int v3 = (nfsd->nd_flag & ND_NFSV3), reqlen;
 749         struct mbuf *mb, *mreq;
 750         struct mbuf *m2;
 751         struct vnode *vp = NULL;
 752         nfsfh_t nfh;
 753         fhandle_t *fhp;
 754         struct uio io, *uiop = &io;
 755         struct vattr va, *vap = &va;
 756         struct nfsheur *nh;
 757         off_t off;
 758         int ioflag = 0;
 759
 760         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 761         fhp = &nfh.fh_generic;
 762         nfsm_srvmtofh(fhp);
 763         if (v3) {
 764                 tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
 765                 off = fxdr_hyper(tl);
 766         } else {
 767                 tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
 768                 off = (off_t)fxdr_unsigned(u_int32_t, *tl);
 769         }
 770         nfsm_srvstrsiz(reqlen, NFS_SRVMAXDATA(nfsd));
 771
 772         /*
 773          * Reference vp.  If an error occurs, vp will be invalid, but we
 774          * have to NULL it just in case.  The macros might goto nfsmout
 775          * as well.
 776          */
 777
 778         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
 779         if (error) {
 780                 vp = NULL;
 781                 nfsm_reply(2 * NFSX_UNSIGNED);
 782                 if (v3)
 783                         nfsm_srvpostop_attr(1, (struct vattr *)0);
 784                 error = 0;
 785                 goto nfsmout;
 786         }
 787
 788         if (vp->v_type != VREG) {
 789                 if (v3)
 790                         error = EINVAL;
 791                 else
 792                         error = (vp->v_type == VDIR) ? EISDIR : EACCES;
 793         }
 794         if (!error) {
 795                 if ((error = nfsrv_access(vp, VREAD, cred, rdonly, td, 1)) != 0)
 796                         error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 1);
 797         }
 798         getret = VOP_GETATTR(vp, vap, cred, td);
 799         if (!error)
 800                 error = getret;
 801         if (error) {
 802                 vput(vp);
 803                 vp = NULL;
 804                 nfsm_reply(NFSX_POSTOPATTR(v3));
 805                 if (v3)
 806                         nfsm_srvpostop_attr(getret, vap);
 807                 error = 0;
 808                 goto nfsmout;
 809         }
 810
 811         /*
 812          * Calculate byte count to read
 813          */
 814
 815         if (off >= vap->va_size)
 816                 cnt = 0;
 817         else if ((off + reqlen) > vap->va_size)
 818                 cnt = vap->va_size - off;
 819         else
 820                 cnt = reqlen;
 821
 822         /*
 823          * Calculate seqcount for heuristic
 824          */
 825
 826         {
 827                 int hi;
 828                 int try = 4;
 829
 830                 /*
 831                  * Locate best candidate
 832                  */
 833
 834                 hi = ((int)(vm_offset_t)vp / sizeof(struct vnode)) & (NUM_HEURISTIC - 1);
 835                 nh = &nfsheur[hi];
 836
 837                 while (try--) {
 838                         if (nfsheur[hi].nh_vp == vp) {
 839                                 nh = &nfsheur[hi];
 840                                 break;
 841                         }
 842                         if (nfsheur[hi].nh_use > 0)
 843                                 --nfsheur[hi].nh_use;
 844                         hi = (hi + 1) & (NUM_HEURISTIC - 1);
 845                         if (nfsheur[hi].nh_use < nh->nh_use)
 846                                 nh = &nfsheur[hi];
 847                 }
 848
 849                 if (nh->nh_vp != vp) {
 850                         nh->nh_vp = vp;
 851                         nh->nh_nextr = off;
 852                         nh->nh_use = NHUSE_INIT;
 853                         if (off == 0)
 854                                 nh->nh_seqcount = 4;
 855                         else
 856                                 nh->nh_seqcount = 1;
 857                 }
 858
 859                 /*
 860                  * Calculate heuristic
 861                  */
 862
 863                 if ((off == 0 && nh->nh_seqcount > 0) || off == nh->nh_nextr) {
 864                         if (++nh->nh_seqcount > 127)
 865                                 nh->nh_seqcount = 127;
 866                 } else if (nh->nh_seqcount > 1) {
 867                         nh->nh_seqcount = 1;
 868                 } else {
 869                         nh->nh_seqcount = 0;
 870                 }
 871                 nh->nh_use += NHUSE_INC;
 872                 if (nh->nh_use > NHUSE_MAX)
 873                         nh->nh_use = NHUSE_MAX;
 874                 ioflag |= nh->nh_seqcount << 16;
 875         }
 876
 877         nfsm_reply(NFSX_POSTOPORFATTR(v3) + 3 * NFSX_UNSIGNED+nfsm_rndup(cnt));
 878         if (v3) {
 879                 tl = nfsm_build(u_int32_t *, NFSX_V3FATTR + 4 * NFSX_UNSIGNED);
 880                 *tl++ = nfsrv_nfs_true;
 881                 fp = (struct nfs_fattr *)tl;
 882                 tl += (NFSX_V3FATTR / sizeof (u_int32_t));
 883         } else {
 884                 tl = nfsm_build(u_int32_t *, NFSX_V2FATTR + NFSX_UNSIGNED);
 885                 fp = (struct nfs_fattr *)tl;
 886                 tl += (NFSX_V2FATTR / sizeof (u_int32_t));
 887         }
 888         len = left = nfsm_rndup(cnt);
 889         if (cnt > 0) {
 890                 /*
 891                  * Generate the mbuf list with the uio_iov ref. to it.
 892                  */
 893                 i = 0;
 894                 m = m2 = mb;
 895                 while (left > 0) {
 896                         siz = min(M_TRAILINGSPACE(m), left);
 897                         if (siz > 0) {
 898                                 left -= siz;
 899                                 i++;
 900                         }
 901                         if (left > 0) {
 902                                 MGET(m, M_TRYWAIT, MT_DATA);
 903                                 MCLGET(m, M_TRYWAIT);
 904                                 m->m_len = 0;
 905                                 m2->m_next = m;
 906                                 m2 = m;
 907                         }
 908                 }
 909                 MALLOC(iv, struct iovec *, i * sizeof (struct iovec),
 910                        M_TEMP, M_WAITOK);
 911                 uiop->uio_iov = iv2 = iv;
 912                 m = mb;
 913                 left = len;
 914                 i = 0;
 915                 while (left > 0) {
 916                         if (m == NULL)
 917                                 panic("nfsrv_read iov");
 918                         siz = min(M_TRAILINGSPACE(m), left);
 919                         if (siz > 0) {
 920                                 iv->iov_base = mtod(m, caddr_t) + m->m_len;
 921                                 iv->iov_len = siz;
 922                                 m->m_len += siz;
 923                                 left -= siz;
 924                                 iv++;
 925                                 i++;
 926                         }
 927                         m = m->m_next;
 928                 }
 929                 uiop->uio_iovcnt = i;
 930                 uiop->uio_offset = off;
 931                 uiop->uio_resid = len;
 932                 uiop->uio_rw = UIO_READ;
 933                 uiop->uio_segflg = UIO_SYSSPACE;
 934                 error = VOP_READ(vp, uiop, IO_NODELOCKED | ioflag, cred);
 935                 off = uiop->uio_offset;
 936                 nh->nh_nextr = off;
 937                 FREE((caddr_t)iv2, M_TEMP);
 938                 if (error || (getret = VOP_GETATTR(vp, vap, cred, td))) {
 939                         if (!error)
 940                                 error = getret;
 941                         m_freem(mreq);
 942                         vput(vp);
 943                         vp = NULL;
 944                         nfsm_reply(NFSX_POSTOPATTR(v3));
 945                         if (v3)
 946                                 nfsm_srvpostop_attr(getret, vap);
 947                         error = 0;
 948                         goto nfsmout;
 949                 }
 950         } else {
 951                 uiop->uio_resid = 0;
 952         }
 953         vput(vp);
 954         vp = NULL;
 955         nfsm_srvfillattr(vap, fp);
 956         tlen = len - uiop->uio_resid;
 957         cnt = cnt < tlen ? cnt : tlen;
 958         tlen = nfsm_rndup(cnt);
 959         if (len != tlen || tlen != cnt)
 960                 nfsm_adj(mb, len - tlen, tlen - cnt);
 961         if (v3) {
 962                 *tl++ = txdr_unsigned(cnt);
 963                 if (len < reqlen)
 964                         *tl++ = nfsrv_nfs_true;
 965                 else
 966                         *tl++ = nfsrv_nfs_false;
 967         }
 968         *tl = txdr_unsigned(cnt);
 969 nfsmout:
 970         if (vp)
 971                 vput(vp);
 972         return(error);
 973 }
 974
 975 /*
 976  * nfs write service
 977  */
 978 int
 979 nfsrv_write(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 980     struct thread *td, struct mbuf **mrq)
 981 {
 982         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 983         struct sockaddr *nam = nfsd->nd_nam;
 984         caddr_t dpos = nfsd->nd_dpos;
 985         struct ucred *cred = &nfsd->nd_cr;
 986         struct iovec *ivp;
 987         int i, cnt;
 988         struct mbuf *mp;
 989         struct nfs_fattr *fp;
 990         struct iovec *iv;
 991         struct vattr va, forat;
 992         struct vattr *vap = &va;
 993         u_int32_t *tl;
 994         caddr_t bpos;
 995         int error = 0, rdonly, len, forat_ret = 1;
 996         int ioflags, aftat_ret = 1, retlen = 0, zeroing, adjust;
 997         int stable = NFSV3WRITE_FILESYNC;
 998         int v3 = (nfsd->nd_flag & ND_NFSV3);
 999         struct mbuf *mb, *mreq;
1000         struct vnode *vp = NULL;
1001         nfsfh_t nfh;
1002         fhandle_t *fhp;
1003         struct uio io, *uiop = &io;
1004         off_t off;
1005         struct mount *mntp = NULL;
1006
1007         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
1008         if (mrep == NULL) {
1009                 *mrq = NULL;
1010                 error = 0;
1011                 goto nfsmout;
1012         }
1013         fhp = &nfh.fh_generic;
1014         nfsm_srvmtofh(fhp);
1015         if ((mntp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
1016                 error = ESTALE;
1017                 goto ereply;
1018         }
1019         if ((error = VFS_FHTOVP(mntp, &fhp->fh_fid, &vp)) != 0) {
1020                 mntp = NULL;
1021                 goto ereply;
1022         }
1023         (void) vn_start_write(vp, &mntp, V_WAIT);
1024         vput(vp);
1025         vp = NULL;
1026         if (v3) {
1027                 tl = nfsm_dissect(u_int32_t *, 5 * NFSX_UNSIGNED);
1028                 off = fxdr_hyper(tl);
1029                 tl += 3;
1030                 stable = fxdr_unsigned(int, *tl++);
1031         } else {
1032                 tl = nfsm_dissect(u_int32_t *, 4 * NFSX_UNSIGNED);
1033                 off = (off_t)fxdr_unsigned(u_int32_t, *++tl);
1034                 tl += 2;
1035                 if (nfs_async)
1036                         stable = NFSV3WRITE_UNSTABLE;
1037         }
1038         retlen = len = fxdr_unsigned(int32_t, *tl);
1039         cnt = i = 0;
1040
1041         /*
1042          * For NFS Version 2, it is not obvious what a write of zero length
1043          * should do, but I might as well be consistent with Version 3,
1044          * which is to return ok so long as there are no permission problems.
1045          */
1046         if (len > 0) {
1047             zeroing = 1;
1048             mp = mrep;
1049             while (mp) {
1050                 if (mp == md) {
1051                         zeroing = 0;
1052                         adjust = dpos - mtod(mp, caddr_t);
1053                         mp->m_len -= adjust;
1054                         if (mp->m_len > 0 && adjust > 0)
1055                                 mp->m_data += adjust;
1056                 }
1057                 if (zeroing)
1058                         mp->m_len = 0;
1059                 else if (mp->m_len > 0) {
1060                         i += mp->m_len;
1061                         if (i > len) {
1062                                 mp->m_len -= (i - len);
1063                                 zeroing = 1;
1064                         }
1065                         if (mp->m_len > 0)
1066                                 cnt++;
1067                 }
1068                 mp = mp->m_next;
1069             }
1070         }
1071         if (len > NFS_MAXDATA || len < 0 || i < len) {
1072                 error = EIO;
1073                 nfsm_reply(2 * NFSX_UNSIGNED);
1074                 if (v3)
1075                         nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
1076                 error = 0;
1077                 goto nfsmout;
1078         }
1079         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
1080         if (error) {
1081                 vp = NULL;
1082                 nfsm_reply(2 * NFSX_UNSIGNED);
1083                 if (v3)
1084                         nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
1085                 error = 0;
1086                 goto nfsmout;
1087         }
1088         if (v3)
1089                 forat_ret = VOP_GETATTR(vp, &forat, cred, td);
1090         if (vp->v_type != VREG) {
1091                 if (v3)
1092                         error = EINVAL;
1093                 else
1094                         error = (vp->v_type == VDIR) ? EISDIR : EACCES;
1095         }
1096         if (!error)
1097                 error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1);
1098         if (error) {
1099                 vput(vp);
1100                 vp = NULL;
1101                 nfsm_reply(NFSX_WCCDATA(v3));
1102                 if (v3)
1103                         nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
1104                 error = 0;
1105                 goto nfsmout;
1106         }
1107
1108         if (len > 0) {
1109             MALLOC(ivp, struct iovec *, cnt * sizeof (struct iovec), M_TEMP,
1110                 M_WAITOK);
1111             uiop->uio_iov = iv = ivp;
1112             uiop->uio_iovcnt = cnt;
1113             mp = mrep;
1114             while (mp) {
1115                 if (mp->m_len > 0) {
1116                         ivp->iov_base = mtod(mp, caddr_t);
1117                         ivp->iov_len = mp->m_len;
1118                         ivp++;
1119                 }
1120                 mp = mp->m_next;
1121             }
1122
1123             /*
1124              * XXX
1125              * The IO_METASYNC flag indicates that all metadata (and not just
1126              * enough to ensure data integrity) mus be written to stable storage
1127              * synchronously.
1128              * (IO_METASYNC is not yet implemented in 4.4BSD-Lite.)
1129              */
1130             if (stable == NFSV3WRITE_UNSTABLE)
1131                 ioflags = IO_NODELOCKED;
1132             else if (stable == NFSV3WRITE_DATASYNC)
1133                 ioflags = (IO_SYNC | IO_NODELOCKED);
1134             else
1135                 ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
1136             uiop->uio_resid = len;
1137             uiop->uio_rw = UIO_WRITE;
1138             uiop->uio_segflg = UIO_SYSSPACE;
1139             uiop->uio_td = (struct thread *)0;
1140             uiop->uio_offset = off;
1141             error = VOP_WRITE(vp, uiop, ioflags, cred);
1142             nfsrvstats.srvvop_writes++;
1143             FREE((caddr_t)iv, M_TEMP);
1144         }
1145         aftat_ret = VOP_GETATTR(vp, vap, cred, td);
1146         vput(vp);
1147         vp = NULL;
1148         if (!error)
1149                 error = aftat_ret;
1150 ereply:
1151         nfsm_reply(NFSX_PREOPATTR(v3) + NFSX_POSTOPORFATTR(v3) +
1152                 2 * NFSX_UNSIGNED + NFSX_WRITEVERF(v3));
1153         if (v3) {
1154                 nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, vap);
1155                 if (error) {
1156                         error = 0;
1157                         goto nfsmout;
1158                 }
1159                 tl = nfsm_build(u_int32_t *, 4 * NFSX_UNSIGNED);
1160                 *tl++ = txdr_unsigned(retlen);
1161                 /*
1162                  * If nfs_async is set, then pretend the write was FILESYNC.
1163                  */
1164                 if (stable == NFSV3WRITE_UNSTABLE && !nfs_async)
1165                         *tl++ = txdr_unsigned(stable);
1166                 else
1167                         *tl++ = txdr_unsigned(NFSV3WRITE_FILESYNC);
1168                 /*
1169                  * Actually, there is no need to txdr these fields,
1170                  * but it may make the values more human readable,
1171                  * for debugging purposes.
1172                  */
1173                 if (nfsver.tv_sec == 0)
1174                         nfsver = boottime;
1175                 *tl++ = txdr_unsigned(nfsver.tv_sec);
1176                 *tl = txdr_unsigned(nfsver.tv_usec);
1177         } else if (!error) {
1178                 /* v2 non-error case. */
1179                 fp = nfsm_build(struct nfs_fattr *, NFSX_V2FATTR);
1180                 nfsm_srvfillattr(vap, fp);
1181         }
1182         error = 0;
1183 nfsmout:
1184         if (vp)
1185                 vput(vp);
1186         vn_finished_write(mntp);
1187         return(error);
1188 }
1189
1190 /*
1191  * NFS write service with write gathering support. Called when
1192  * nfsrvw_procrastinate > 0.
1193  * See: Chet Juszczak, "Improving the Write Performance of an NFS Server",
1194  * in Proc. of the Winter 1994 Usenix Conference, pg. 247-259, San Franscisco,
1195  * Jan. 1994.
1196  */
1197 int
1198 nfsrv_writegather(struct nfsrv_descript **ndp, struct nfssvc_sock *slp,
1199     struct thread *td, struct mbuf **mrq)
1200 {
1201         struct iovec *ivp;
1202         struct mbuf *mp;
1203         struct nfsrv_descript *wp, *nfsd, *owp, *swp;
1204         struct nfs_fattr *fp;
1205         int i;
1206         struct iovec *iov;
1207         struct nfsrvw_delayhash *wpp;
1208         struct ucred *cred;
1209         struct vattr va, forat;
1210         u_int32_t *tl;
1211         caddr_t bpos, dpos;
1212         int error = 0, rdonly, len, forat_ret = 1;
1213         int ioflags, aftat_ret = 1, s, adjust, v3, zeroing;
1214         struct mbuf *mb, *mreq, *mrep, *md;
1215         struct vnode *vp = NULL;
1216         struct uio io, *uiop = &io;
1217         u_quad_t cur_usec;
1218         struct mount *mntp = NULL;
1219
1220         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
1221 #ifndef nolint
1222         i = 0;
1223         len = 0;
1224 #endif
1225         *mrq = NULL;
1226         if (*ndp) {
1227             nfsd = *ndp;
1228             *ndp = NULL;
1229             mrep = nfsd->nd_mrep;
1230             md = nfsd->nd_md;
1231             dpos = nfsd->nd_dpos;
1232             cred = &nfsd->nd_cr;
1233             v3 = (nfsd->nd_flag & ND_NFSV3);
1234             LIST_INIT(&nfsd->nd_coalesce);
1235             nfsd->nd_mreq = NULL;
1236             nfsd->nd_stable = NFSV3WRITE_FILESYNC;
1237             cur_usec = nfs_curusec();
1238             nfsd->nd_time = cur_usec +
1239                 (v3 ? nfsrvw_procrastinate_v3 : nfsrvw_procrastinate);
1240
1241             /*
1242              * Now, get the write header..
1243              */
1244             nfsm_srvmtofh(&nfsd->nd_fh);
1245             if (v3) {
1246                 tl = nfsm_dissect(u_int32_t *, 5 * NFSX_UNSIGNED);
1247                 nfsd->nd_off = fxdr_hyper(tl);
1248                 tl += 3;
1249                 nfsd->nd_stable = fxdr_unsigned(int, *tl++);
1250             } else {
1251                 tl = nfsm_dissect(u_int32_t *, 4 * NFSX_UNSIGNED);
1252                 nfsd->nd_off = (off_t)fxdr_unsigned(u_int32_t, *++tl);
1253                 tl += 2;
1254                 if (nfs_async)
1255                         nfsd->nd_stable = NFSV3WRITE_UNSTABLE;
1256             }
1257             len = fxdr_unsigned(int32_t, *tl);
1258             nfsd->nd_len = len;
1259             nfsd->nd_eoff = nfsd->nd_off + len;
1260
1261             /*
1262              * Trim the header out of the mbuf list and trim off any trailing
1263              * junk so that the mbuf list has only the write data.
1264              */
1265             zeroing = 1;
1266             i = 0;
1267             mp = mrep;
1268             while (mp) {
1269                 if (mp == md) {
1270                     zeroing = 0;
1271                     adjust = dpos - mtod(mp, caddr_t);
1272                     mp->m_len -= adjust;
1273                     if (mp->m_len > 0 && adjust > 0)
1274                         mp->m_data += adjust;
1275                 }
1276                 if (zeroing)
1277                     mp->m_len = 0;
1278                 else {
1279                     i += mp->m_len;
1280                     if (i > len) {
1281                         mp->m_len -= (i - len);
1282                         zeroing = 1;
1283                     }
1284                 }
1285                 mp = mp->m_next;
1286             }
1287             if (len > NFS_MAXDATA || len < 0  || i < len) {
1288 nfsmout:
1289                 m_freem(mrep);
1290                 error = EIO;
1291                 nfsm_writereply(2 * NFSX_UNSIGNED);
1292                 if (v3)
1293                     nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1294                 nfsd->nd_mreq = mreq;
1295                 nfsd->nd_mrep = NULL;
1296                 nfsd->nd_time = 0;
1297             }
1298
1299             /*
1300              * Add this entry to the hash and time queues.
1301              */
1302             s = splsoftclock();
1303             owp = NULL;
1304             wp = LIST_FIRST(&slp->ns_tq);
1305             while (wp && wp->nd_time < nfsd->nd_time) {
1306                 owp = wp;
1307                 wp = LIST_NEXT(wp, nd_tq);
1308             }
1309             NFS_DPF(WG, ("Q%03x", nfsd->nd_retxid & 0xfff));
1310             if (owp) {
1311                 LIST_INSERT_AFTER(owp, nfsd, nd_tq);
1312             } else {
1313                 LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
1314             }
1315             if (nfsd->nd_mrep) {
1316                 wpp = NWDELAYHASH(slp, nfsd->nd_fh.fh_fid.fid_data);
1317                 owp = NULL;
1318                 wp = LIST_FIRST(wpp);
1319                 while (wp &&
1320                     bcmp((caddr_t)&nfsd->nd_fh,(caddr_t)&wp->nd_fh, NFSX_V3FH)){
1321                     owp = wp;
1322                     wp = LIST_NEXT(wp, nd_hash);
1323                 }
1324                 while (wp && wp->nd_off < nfsd->nd_off &&
1325                     !bcmp((caddr_t)&nfsd->nd_fh,(caddr_t)&wp->nd_fh, NFSX_V3FH)) {
1326                     owp = wp;
1327                     wp = LIST_NEXT(wp, nd_hash);
1328                 }
1329                 if (owp) {
1330                     LIST_INSERT_AFTER(owp, nfsd, nd_hash);
1331
1332                     /*
1333                      * Search the hash list for overlapping entries and
1334                      * coalesce.
1335                      */
1336                     for(; nfsd && NFSW_CONTIG(owp, nfsd); nfsd = wp) {
1337                         wp = LIST_NEXT(nfsd, nd_hash);
1338                         if (NFSW_SAMECRED(owp, nfsd))
1339                             nfsrvw_coalesce(owp, nfsd);
1340                     }
1341                 } else {
1342                     LIST_INSERT_HEAD(wpp, nfsd, nd_hash);
1343                 }
1344             }
1345             splx(s);
1346         }
1347
1348         /*
1349          * Now, do VOP_WRITE()s for any one(s) that need to be done now
1350          * and generate the associated reply mbuf list(s).
1351          */
1352 loop1:
1353         cur_usec = nfs_curusec();
1354         s = splsoftclock();
1355         for (nfsd = LIST_FIRST(&slp->ns_tq); nfsd; nfsd = owp) {
1356                 owp = LIST_NEXT(nfsd, nd_tq);
1357                 if (nfsd->nd_time > cur_usec)
1358                     break;
1359                 if (nfsd->nd_mreq)
1360                     continue;
1361                 NFS_DPF(WG, ("P%03x", nfsd->nd_retxid & 0xfff));
1362                 LIST_REMOVE(nfsd, nd_tq);
1363                 LIST_REMOVE(nfsd, nd_hash);
1364                 splx(s);
1365                 mrep = nfsd->nd_mrep;
1366                 nfsd->nd_mrep = NULL;
1367                 cred = &nfsd->nd_cr;
1368                 v3 = (nfsd->nd_flag & ND_NFSV3);
1369                 forat_ret = aftat_ret = 1;
1370                 error = nfsrv_fhtovp(&nfsd->nd_fh, 1, &vp, cred, slp,
1371                     nfsd->nd_nam, &rdonly, TRUE);
1372                 if (!error) {
1373                     if (v3)
1374                         forat_ret = VOP_GETATTR(vp, &forat, cred, td);
1375                     if (vp->v_type != VREG) {
1376                         if (v3)
1377                             error = EINVAL;
1378                         else
1379                             error = (vp->v_type == VDIR) ? EISDIR : EACCES;
1380                     }
1381                 } else {
1382                     vp = NULL;
1383                 }
1384                 if (!error)
1385                     error = nfsrv_access(vp, VWRITE, cred, rdonly, td, 1);
1386                 if (nfsd->nd_stable == NFSV3WRITE_UNSTABLE)
1387                     ioflags = IO_NODELOCKED;
1388                 else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC)
1389                     ioflags = (IO_SYNC | IO_NODELOCKED);
1390                 else
1391                     ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
1392                 uiop->uio_rw = UIO_WRITE;
1393                 uiop->uio_segflg = UIO_SYSSPACE;
1394                 uiop->uio_td = (struct thread *)0;
1395                 uiop->uio_offset = nfsd->nd_off;
1396                 uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
1397                 if (uiop->uio_resid > 0) {
1398                     mp = mrep;
1399                     i = 0;
1400                     while (mp) {
1401                         if (mp->m_len > 0)
1402                             i++;
1403                         mp = mp->m_next;
1404                     }
1405                     uiop->uio_iovcnt = i;
1406                     MALLOC(iov, struct iovec *, i * sizeof (struct iovec),
1407                         M_TEMP, M_WAITOK);
1408                     uiop->uio_iov = ivp = iov;
1409                     mp = mrep;
1410                     while (mp) {
1411                         if (mp->m_len > 0) {
1412                             ivp->iov_base = mtod(mp, caddr_t);
1413                             ivp->iov_len = mp->m_len;
1414                             ivp++;
1415                         }
1416                         mp = mp->m_next;
1417                     }
1418                     if (!error) {
1419                         if (vn_start_write(vp, &mntp, V_NOWAIT) != 0) {
1420                             VOP_UNLOCK(vp, 0, td);
1421                             error = vn_start_write(NULL, &mntp, V_WAIT);
1422                             vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
1423                         }
1424                     }
1425                     if (!error) {
1426                         error = VOP_WRITE(vp, uiop, ioflags, cred);
1427                         nfsrvstats.srvvop_writes++;
1428                         vn_finished_write(mntp);
1429                     }
1430                     FREE((caddr_t)iov, M_TEMP);
1431                 }
1432                 m_freem(mrep);
1433                 if (vp) {
1434                     aftat_ret = VOP_GETATTR(vp, &va, cred, td);
1435                     vput(vp);
1436                     vp = NULL;
1437                 }
1438
1439                 /*
1440                  * Loop around generating replies for all write rpcs that have
1441                  * now been completed.
1442                  */
1443                 swp = nfsd;
1444                 do {
1445                     NFS_DPF(WG, ("R%03x", nfsd->nd_retxid & 0xfff));
1446                     if (error) {
1447                         nfsm_writereply(NFSX_WCCDATA(v3));
1448                         if (v3) {
1449                             nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1450                         }
1451                     } else {
1452                         nfsm_writereply(NFSX_PREOPATTR(v3) +
1453                             NFSX_POSTOPORFATTR(v3) + 2 * NFSX_UNSIGNED +
1454                             NFSX_WRITEVERF(v3));
1455                         if (v3) {
1456                             nfsm_srvwcc_data(forat_ret, &forat, aftat_ret, &va);
1457                             tl = nfsm_build(u_int32_t *, 4 * NFSX_UNSIGNED);
1458                             *tl++ = txdr_unsigned(nfsd->nd_len);
1459                             *tl++ = txdr_unsigned(swp->nd_stable);
1460                             /*
1461                              * Actually, there is no need to txdr these fields,
1462                              * but it may make the values more human readable,
1463                              * for debugging purposes.
1464                              */
1465                             if (nfsver.tv_sec == 0)
1466                                     nfsver = boottime;
1467                             *tl++ = txdr_unsigned(nfsver.tv_sec);
1468                             *tl = txdr_unsigned(nfsver.tv_usec);
1469                         } else {
1470                             fp = nfsm_build(struct nfs_fattr *, NFSX_V2FATTR);
1471                             nfsm_srvfillattr(&va, fp);
1472                         }
1473                     }
1474                     nfsd->nd_mreq = mreq;
1475                     if (nfsd->nd_mrep)
1476                         panic("nfsrv_write: nd_mrep not free");
1477
1478                     /*
1479                      * Done. Put it at the head of the timer queue so that
1480                      * the final phase can return the reply.
1481                      */
1482                     s = splsoftclock();
1483                     if (nfsd != swp) {
1484                         nfsd->nd_time = 0;
1485                         LIST_INSERT_HEAD(&slp->ns_tq, nfsd, nd_tq);
1486                     }
1487                     nfsd = LIST_FIRST(&swp->nd_coalesce);
1488                     if (nfsd) {
1489                         LIST_REMOVE(nfsd, nd_tq);
1490                     }
1491                     splx(s);
1492                 } while (nfsd);
1493                 s = splsoftclock();
1494                 swp->nd_time = 0;
1495                 LIST_INSERT_HEAD(&slp->ns_tq, swp, nd_tq);
1496                 splx(s);
1497                 goto loop1;
1498         }
1499         splx(s);
1500
1501         /*
1502          * Search for a reply to return.
1503          */
1504         s = splsoftclock();
1505         LIST_FOREACH(nfsd, &slp->ns_tq, nd_tq)
1506                 if (nfsd->nd_mreq) {
1507                     NFS_DPF(WG, ("X%03x", nfsd->nd_retxid & 0xfff));
1508                     LIST_REMOVE(nfsd, nd_tq);
1509                     *mrq = nfsd->nd_mreq;
1510                     *ndp = nfsd;
1511                     break;
1512                 }
1513         splx(s);
1514         return (0);
1515 }
1516
1517 /*
1518  * Coalesce the write request nfsd into owp. To do this we must:
1519  * - remove nfsd from the queues
1520  * - merge nfsd->nd_mrep into owp->nd_mrep
1521  * - update the nd_eoff and nd_stable for owp
1522  * - put nfsd on owp's nd_coalesce list
1523  * NB: Must be called at splsoftclock().
1524  */
1525 static void
1526 nfsrvw_coalesce(struct nfsrv_descript *owp, struct nfsrv_descript *nfsd)
1527 {
1528         int overlap;
1529         struct mbuf *mp;
1530         struct nfsrv_descript *p;
1531
1532         NFS_DPF(WG, ("C%03x-%03x",
1533                      nfsd->nd_retxid & 0xfff, owp->nd_retxid & 0xfff));
1534         LIST_REMOVE(nfsd, nd_hash);
1535         LIST_REMOVE(nfsd, nd_tq);
1536         if (owp->nd_eoff < nfsd->nd_eoff) {
1537             overlap = owp->nd_eoff - nfsd->nd_off;
1538             if (overlap < 0)
1539                 panic("nfsrv_coalesce: bad off");
1540             if (overlap > 0)
1541                 m_adj(nfsd->nd_mrep, overlap);
1542             mp = owp->nd_mrep;
1543             while (mp->m_next)
1544                 mp = mp->m_next;
1545             mp->m_next = nfsd->nd_mrep;
1546             owp->nd_eoff = nfsd->nd_eoff;
1547         } else
1548             m_freem(nfsd->nd_mrep);
1549         nfsd->nd_mrep = NULL;
1550         if (nfsd->nd_stable == NFSV3WRITE_FILESYNC)
1551             owp->nd_stable = NFSV3WRITE_FILESYNC;
1552         else if (nfsd->nd_stable == NFSV3WRITE_DATASYNC &&
1553             owp->nd_stable == NFSV3WRITE_UNSTABLE)
1554             owp->nd_stable = NFSV3WRITE_DATASYNC;
1555         LIST_INSERT_HEAD(&owp->nd_coalesce, nfsd, nd_tq);
1556
1557         /*
1558          * If nfsd had anything else coalesced into it, transfer them
1559          * to owp, otherwise their replies will never get sent.
1560          */
1561         for (p = LIST_FIRST(&nfsd->nd_coalesce); p;
1562              p = LIST_FIRST(&nfsd->nd_coalesce)) {
1563             LIST_REMOVE(p, nd_tq);
1564             LIST_INSERT_HEAD(&owp->nd_coalesce, p, nd_tq);
1565         }
1566 }
1567
1568 /*
1569  * nfs create service
1570  * now does a truncate to 0 length via. setattr if it already exists
1571  */
1572 int
1573 nfsrv_create(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
1574     struct thread *td, struct mbuf **mrq)
1575 {
1576         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1577         struct sockaddr *nam = nfsd->nd_nam;
1578         caddr_t dpos = nfsd->nd_dpos;
1579         struct ucred *cred = &nfsd->nd_cr;
1580         struct nfs_fattr *fp;
1581         struct vattr va, dirfor, diraft;
1582         struct vattr *vap = &va;
1583         struct nfsv2_sattr *sp;
1584         u_int32_t *tl;
1585         struct nameidata nd;
1586         caddr_t bpos;
1587         int error = 0, rdev, len, tsize, dirfor_ret = 1, diraft_ret = 1;
1588         int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
1589         caddr_t cp;
1590         struct mbuf *mb, *mreq;
1591         struct vnode *dirp = (struct vnode *)0;
1592         nfsfh_t nfh;
1593         fhandle_t *fhp;
1594         u_quad_t tempsize;
1595         u_char cverf[NFSX_V3CREATEVERF];
1596         struct mount *mp = NULL;
1597         struct vnode *vp;
1598
1599         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
1600 #ifndef nolint
1601         rdev = 0;
1602 #endif
1603         ndclear(&nd);
1604
1605         fhp = &nfh.fh_generic;
1606         nfsm_srvmtofh(fhp);
1607         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
1608                 error = ESTALE;
1609                 goto ereply;
1610         }
1611         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
1612                 mp = NULL;
1613                 goto ereply;
1614         }
1615         (void) vn_start_write(vp, &mp, V_WAIT);
1616         vput(vp);
1617         nfsm_srvnamesiz(len);
1618
1619         nd.ni_cnd.cn_cred = cred;
1620         nd.ni_cnd.cn_nameiop = CREATE;
1621         nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | SAVESTART;
1622
1623         /*
1624          * Call namei and do initial cleanup to get a few things
1625          * out of the way.  If we get an initial error we cleanup
1626          * and return here to avoid special-casing the invalid nd
1627          * structure through the rest of the case.  dirp may be
1628          * set even if an error occurs, but the nd structure will not
1629          * be valid at all if an error occurs so we have to invalidate it
1630          * prior to calling nfsm_reply ( which might goto nfsmout ).
1631          */
1632         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
1633                 &dirp, td, FALSE);
1634         if (dirp) {
1635                 if (v3) {
1636                         dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
1637                                 td);
1638                 } else {
1639                         vrele(dirp);
1640                         dirp = NULL;
1641                 }
1642         }
1643         if (error) {
1644                 nfsm_reply(NFSX_WCCDATA(v3));
1645                 if (v3)
1646                         nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1647                 error = 0;
1648                 goto nfsmout;
1649         }
1650
1651         /*
1652          * No error.  Continue.  State:
1653          *
1654          *      startdir        is valid ( we release this immediately )
1655          *      dirp            may be valid
1656          *      nd.ni_vp        may be valid
1657          *      nd.ni_dvp       is valid
1658          *
1659          * The error state is set through the code and we may also do some
1660          * opportunistic releasing of vnodes to avoid holding locks through
1661          * NFS I/O.  The cleanup at the end is a catch-all
1662          */
1663
1664         VATTR_NULL(vap);
1665         if (v3) {
1666                 tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
1667                 how = fxdr_unsigned(int, *tl);
1668                 switch (how) {
1669                 case NFSV3CREATE_GUARDED:
1670                         if (nd.ni_vp) {
1671                                 error = EEXIST;
1672                                 break;
1673                         }
1674                         /* fall through */
1675                 case NFSV3CREATE_UNCHECKED:
1676                         nfsm_srvsattr(vap);
1677                         break;
1678                 case NFSV3CREATE_EXCLUSIVE:
1679                         cp = nfsm_dissect(caddr_t, NFSX_V3CREATEVERF);
1680                         bcopy(cp, cverf, NFSX_V3CREATEVERF);
1681                         exclusive_flag = 1;
1682                         break;
1683                 };
1684                 vap->va_type = VREG;
1685         } else {
1686                 sp = nfsm_dissect(struct nfsv2_sattr *, NFSX_V2SATTR);
1687                 vap->va_type = IFTOVT(fxdr_unsigned(u_int32_t, sp->sa_mode));
1688                 if (vap->va_type == VNON)
1689                         vap->va_type = VREG;
1690                 vap->va_mode = nfstov_mode(sp->sa_mode);
1691                 switch (vap->va_type) {
1692                 case VREG:
1693                         tsize = fxdr_unsigned(int32_t, sp->sa_size);
1694                         if (tsize != -1)
1695                                 vap->va_size = (u_quad_t)tsize;
1696                         break;
1697                 case VCHR:
1698                 case VBLK:
1699                 case VFIFO:
1700                         rdev = fxdr_unsigned(long, sp->sa_size);
1701                         break;
1702                 default:
1703                         break;
1704                 };
1705         }
1706
1707         /*
1708          * Iff doesn't exist, create it
1709          * otherwise just truncate to 0 length
1710          *   should I set the mode too ?
1711          *
1712          * The only possible error we can have at this point is EEXIST.
1713          * nd.ni_vp will also be non-NULL in that case.
1714          */
1715         if (nd.ni_vp == NULL) {
1716                 if (vap->va_mode == (mode_t)VNOVAL)
1717                         vap->va_mode = 0;
1718                 if (vap->va_type == VREG || vap->va_type == VSOCK) {
1719                         error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1720                         if (error)
1721                                 NDFREE(&nd, NDF_ONLY_PNBUF);
1722                         else {
1723                                 nfsrv_object_create(nd.ni_vp);
1724                                 if (exclusive_flag) {
1725                                         exclusive_flag = 0;
1726                                         VATTR_NULL(vap);
1727                                         bcopy(cverf, (caddr_t)&vap->va_atime,
1728                                                 NFSX_V3CREATEVERF);
1729                                         error = VOP_SETATTR(nd.ni_vp, vap, cred,
1730                                                 td);
1731                                 }
1732                         }
1733                 } else if (vap->va_type == VCHR || vap->va_type == VBLK ||
1734                     vap->va_type == VFIFO) {
1735                         /*
1736                          * NFSv2-specific code for creating device nodes
1737                          * and fifos.
1738                          *
1739                          * Handle SysV FIFO node special cases.  All other
1740                          * devices require super user to access.
1741                          */
1742                         if (vap->va_type == VCHR && rdev == 0xffffffff)
1743                                 vap->va_type = VFIFO;
1744                         if (vap->va_type != VFIFO &&
1745                             (error = suser_xxx(cred, 0, 0))) {
1746                                 goto ereply;
1747                         }
1748                         vap->va_rdev = rdev;
1749                         error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1750                         if (error) {
1751                                 NDFREE(&nd, NDF_ONLY_PNBUF);
1752                                 goto ereply;
1753                         }
1754                         vput(nd.ni_vp);
1755                         nd.ni_vp = NULL;
1756
1757                         /*
1758                          * release dvp prior to lookup
1759                          */
1760                         vput(nd.ni_dvp);
1761                         nd.ni_dvp = NULL;
1762
1763                         /*
1764                          * Setup for lookup.
1765                          *
1766                          * Even though LOCKPARENT was cleared, ni_dvp may
1767                          * be garbage.
1768                          */
1769                         nd.ni_cnd.cn_nameiop = LOOKUP;
1770                         nd.ni_cnd.cn_flags &= ~(LOCKPARENT);
1771                         nd.ni_cnd.cn_thread = td;
1772                         nd.ni_cnd.cn_cred = cred;
1773
1774                         error = lookup(&nd);
1775                         nd.ni_dvp = NULL;
1776                         if (error)
1777                                 goto ereply;
1778
1779                         nfsrv_object_create(nd.ni_vp);
1780                         if (nd.ni_cnd.cn_flags & ISSYMLINK) {
1781                                 error = EINVAL;
1782                                 goto ereply;
1783                         }
1784                 } else {
1785                         error = ENXIO;
1786                 }
1787         } else {
1788                 if (vap->va_size != -1) {
1789                         error = nfsrv_access(nd.ni_vp, VWRITE, cred,
1790                             (nd.ni_cnd.cn_flags & RDONLY), td, 0);
1791                         if (!error) {
1792                                 tempsize = vap->va_size;
1793                                 VATTR_NULL(vap);
1794                                 vap->va_size = tempsize;
1795                                 error = VOP_SETATTR(nd.ni_vp, vap, cred,
1796                                          td);
1797                         }
1798                 }
1799         }
1800
1801         if (!error) {
1802                 bzero((caddr_t)fhp, sizeof(nfh));
1803                 fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
1804                 error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
1805                 if (!error)
1806                         error = VOP_GETATTR(nd.ni_vp, vap, cred, td);
1807         }
1808         if (v3) {
1809                 if (exclusive_flag && !error &&
1810                         bcmp(cverf, (caddr_t)&vap->va_atime, NFSX_V3CREATEVERF))
1811                         error = EEXIST;
1812                 diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
1813                 vrele(dirp);
1814                 dirp = NULL;
1815         }
1816 ereply:
1817         nfsm_reply(NFSX_SRVFH(v3) + NFSX_FATTR(v3) + NFSX_WCCDATA(v3));
1818         if (v3) {
1819                 if (!error) {
1820                         nfsm_srvpostop_fh(fhp);
1821                         nfsm_srvpostop_attr(0, vap);
1822                 }
1823                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1824         } else if (!error) {
1825                 /* v2 non-error case. */
1826                 nfsm_srvfhtom(fhp, v3);
1827                 fp = nfsm_build(struct nfs_fattr *, NFSX_V2FATTR);
1828                 nfsm_srvfillattr(vap, fp);
1829         }
1830         error = 0;
1831
1832 nfsmout:
1833         if (nd.ni_startdir) {
1834                 vrele(nd.ni_startdir);
1835                 nd.ni_startdir = NULL;
1836         }
1837         if (dirp)
1838                 vrele(dirp);
1839         NDFREE(&nd, NDF_ONLY_PNBUF);
1840         if (nd.ni_dvp) {
1841                 if (nd.ni_dvp == nd.ni_vp)
1842                         vrele(nd.ni_dvp);
1843                 else
1844                         vput(nd.ni_dvp);
1845         }
1846         if (nd.ni_vp)
1847                 vput(nd.ni_vp);
1848         vn_finished_write(mp);
1849         return (error);
1850 }
1851
1852 /*
1853  * nfs v3 mknod service
1854  */
1855 int
1856 nfsrv_mknod(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
1857     struct thread *td, struct mbuf **mrq)
1858 {
1859         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
1860         struct sockaddr *nam = nfsd->nd_nam;
1861         caddr_t dpos = nfsd->nd_dpos;
1862         struct ucred *cred = &nfsd->nd_cr;
1863         struct vattr va, dirfor, diraft;
1864         struct vattr *vap = &va;
1865         u_int32_t *tl;
1866         struct nameidata nd;
1867         caddr_t bpos;
1868         int error = 0, len, dirfor_ret = 1, diraft_ret = 1;
1869         u_int32_t major, minor;
1870         enum vtype vtyp;
1871         struct mbuf *mb, *mreq;
1872         struct vnode *vp, *dirp = (struct vnode *)0;
1873         nfsfh_t nfh;
1874         fhandle_t *fhp;
1875         struct mount *mp = NULL;
1876         int v3 = (nfsd->nd_flag & ND_NFSV3);
1877
1878         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
1879         if (!v3)
1880                 panic("nfsrv_mknod: v3 proc called on a v2 connection");
1881         ndclear(&nd);
1882
1883         fhp = &nfh.fh_generic;
1884         nfsm_srvmtofh(fhp);
1885         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
1886                 error = ESTALE;
1887                 goto ereply;
1888         }
1889         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
1890                 mp = NULL;
1891                 goto ereply;
1892         }
1893         (void) vn_start_write(vp, &mp, V_WAIT);
1894         vput(vp);
1895         vp = NULL;
1896         nfsm_srvnamesiz(len);
1897
1898         nd.ni_cnd.cn_cred = cred;
1899         nd.ni_cnd.cn_nameiop = CREATE;
1900         nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | SAVESTART;
1901
1902         /*
1903          * Handle nfs_namei() call.  If an error occurs, the nd structure
1904          * is not valid.  However, nfsm_*() routines may still jump to
1905          * nfsmout.
1906          */
1907
1908         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
1909                 &dirp, td, FALSE);
1910         if (dirp)
1911                 dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred, td);
1912         if (error) {
1913                 nfsm_reply(NFSX_WCCDATA(1));
1914                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
1915                 error = 0;
1916                 goto nfsmout;
1917         }
1918         tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
1919         vtyp = nfsv3tov_type(*tl);
1920         if (vtyp != VCHR && vtyp != VBLK && vtyp != VSOCK && vtyp != VFIFO) {
1921                 error = NFSERR_BADTYPE;
1922                 goto out;
1923         }
1924         VATTR_NULL(vap);
1925         nfsm_srvsattr(vap);
1926         if (vtyp == VCHR || vtyp == VBLK) {
1927                 tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
1928                 major = fxdr_unsigned(u_int32_t, *tl++);
1929                 minor = fxdr_unsigned(u_int32_t, *tl);
1930                 vap->va_rdev = makeudev(major, minor);
1931         }
1932
1933         /*
1934          * Iff doesn't exist, create it.
1935          */
1936         if (nd.ni_vp) {
1937                 error = EEXIST;
1938                 goto out;
1939         }
1940         vap->va_type = vtyp;
1941         if (vap->va_mode == (mode_t)VNOVAL)
1942                 vap->va_mode = 0;
1943         if (vtyp == VSOCK) {
1944                 vrele(nd.ni_startdir);
1945                 nd.ni_startdir = NULL;
1946                 error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1947                 if (error)
1948                         NDFREE(&nd, NDF_ONLY_PNBUF);
1949         } else {
1950                 if (vtyp != VFIFO && (error = suser_xxx(cred, 0, 0)))
1951                         goto out;
1952                 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
1953                 if (error) {
1954                         NDFREE(&nd, NDF_ONLY_PNBUF);
1955                         goto out;
1956                 }
1957                 vput(nd.ni_vp);
1958                 nd.ni_vp = NULL;
1959
1960                 /*
1961                  * Release dvp prior to lookup
1962                  */
1963                 vput(nd.ni_dvp);
1964                 nd.ni_dvp = NULL;
1965
1966                 nd.ni_cnd.cn_nameiop = LOOKUP;
1967                 nd.ni_cnd.cn_flags &= ~(LOCKPARENT);
1968                 nd.ni_cnd.cn_thread = td;
1969                 nd.ni_cnd.cn_cred = td->td_proc->p_ucred;
1970
1971                 error = lookup(&nd);
1972                 nd.ni_dvp = NULL;
1973
1974                 if (error)
1975                         goto out;
1976                 if (nd.ni_cnd.cn_flags & ISSYMLINK)
1977                         error = EINVAL;
1978         }
1979
1980         /*
1981          * send response, cleanup, return.
1982          */
1983 out:
1984         if (nd.ni_startdir) {
1985                 vrele(nd.ni_startdir);
1986                 nd.ni_startdir = NULL;
1987         }
1988         NDFREE(&nd, NDF_ONLY_PNBUF);
1989         if (nd.ni_dvp) {
1990                 if (nd.ni_dvp == nd.ni_vp)
1991                         vrele(nd.ni_dvp);
1992                 else
1993                         vput(nd.ni_dvp);
1994                 nd.ni_dvp = NULL;
1995         }
1996         vp = nd.ni_vp;
1997         if (!error) {
1998                 bzero((caddr_t)fhp, sizeof(nfh));
1999                 fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
2000                 error = VFS_VPTOFH(vp, &fhp->fh_fid);
2001                 if (!error)
2002                         error = VOP_GETATTR(vp, vap, cred, td);
2003         }
2004         if (vp) {
2005                 vput(vp);
2006                 vp = NULL;
2007                 nd.ni_vp = NULL;
2008         }
2009         diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
2010         if (dirp) {
2011                 vrele(dirp);
2012                 dirp = NULL;
2013         }
2014 ereply:
2015         nfsm_reply(NFSX_SRVFH(1) + NFSX_POSTOPATTR(1) + NFSX_WCCDATA(1));
2016         if (v3) {
2017                 if (!error) {
2018                         nfsm_srvpostop_fh(fhp);
2019                         nfsm_srvpostop_attr(0, vap);
2020                 }
2021                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2022         }
2023         vn_finished_write(mp);
2024         return (0);
2025 nfsmout:
2026         if (dirp)
2027                 vrele(dirp);
2028         if (nd.ni_startdir)
2029                 vrele(nd.ni_startdir);
2030         NDFREE(&nd, NDF_ONLY_PNBUF);
2031         if (nd.ni_dvp) {
2032                 if (nd.ni_dvp == nd.ni_vp)
2033                         vrele(nd.ni_dvp);
2034                 else
2035                         vput(nd.ni_dvp);
2036         }
2037         if (nd.ni_vp)
2038                 vput(nd.ni_vp);
2039         vn_finished_write(mp);
2040         return (error);
2041 }
2042
2043 /*
2044  * nfs remove service
2045  */
2046 int
2047 nfsrv_remove(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2048     struct thread *td, struct mbuf **mrq)
2049 {
2050         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2051         struct sockaddr *nam = nfsd->nd_nam;
2052         caddr_t dpos = nfsd->nd_dpos;
2053         struct ucred *cred = &nfsd->nd_cr;
2054         struct nameidata nd;
2055         caddr_t bpos;
2056         int error = 0, len, dirfor_ret = 1, diraft_ret = 1;
2057         int v3 = (nfsd->nd_flag & ND_NFSV3);
2058         struct mbuf *mb, *mreq;
2059         struct vnode *dirp;
2060         struct vattr dirfor, diraft;
2061         nfsfh_t nfh;
2062         fhandle_t *fhp;
2063         struct mount *mp = NULL;
2064         struct vnode *vp;
2065
2066         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2067         ndclear(&nd);
2068
2069         fhp = &nfh.fh_generic;
2070         nfsm_srvmtofh(fhp);
2071         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
2072                 error = ESTALE;
2073                 goto ereply;
2074         }
2075         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
2076                 mp = NULL;
2077                 goto ereply;
2078         }
2079         (void) vn_start_write(vp, &mp, V_WAIT);
2080         vput(vp);
2081         vp = NULL;
2082         nfsm_srvnamesiz(len);
2083
2084         nd.ni_cnd.cn_cred = cred;
2085         nd.ni_cnd.cn_nameiop = DELETE;
2086         nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
2087         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2088                 &dirp, td, FALSE);
2089         if (dirp) {
2090                 if (v3) {
2091                         dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2092                                 td);
2093                 } else {
2094                         vrele(dirp);
2095                         dirp = NULL;
2096                 }
2097         }
2098         if (error == 0) {
2099                 if (nd.ni_vp->v_type == VDIR) {
2100                         error = EPERM;          /* POSIX */
2101                         goto out;
2102                 }
2103                 /*
2104                  * The root of a mounted filesystem cannot be deleted.
2105                  */
2106                 if (nd.ni_vp->v_flag & VROOT) {
2107                         error = EBUSY;
2108                         goto out;
2109                 }
2110 out:
2111                 if (!error) {
2112                         error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
2113                         NDFREE(&nd, NDF_ONLY_PNBUF);
2114                 }
2115         }
2116         if (dirp && v3) {
2117                 diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
2118                 vrele(dirp);
2119                 dirp = NULL;
2120         }
2121 ereply:
2122         nfsm_reply(NFSX_WCCDATA(v3));
2123         if (v3) {
2124                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2125                 error = 0;
2126         }
2127 nfsmout:
2128         NDFREE(&nd, NDF_ONLY_PNBUF);
2129         if (nd.ni_dvp) {
2130                 if (nd.ni_dvp == nd.ni_vp)
2131                         vrele(nd.ni_dvp);
2132                 else
2133                         vput(nd.ni_dvp);
2134         }
2135         if (nd.ni_vp)
2136                 vput(nd.ni_vp);
2137         vn_finished_write(mp);
2138         return(error);
2139 }
2140
2141 /*
2142  * nfs rename service
2143  */
2144 int
2145 nfsrv_rename(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2146     struct thread *td, struct mbuf **mrq)
2147 {
2148         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2149         struct sockaddr *nam = nfsd->nd_nam;
2150         caddr_t dpos = nfsd->nd_dpos;
2151         struct ucred *cred = &nfsd->nd_cr;
2152         caddr_t bpos;
2153         int error = 0, len, len2, fdirfor_ret = 1, fdiraft_ret = 1;
2154         int tdirfor_ret = 1, tdiraft_ret = 1;
2155         int v3 = (nfsd->nd_flag & ND_NFSV3);
2156         struct mbuf *mb, *mreq;
2157         struct nameidata fromnd, tond;
2158         struct vnode *fvp, *tvp, *tdvp, *fdirp = (struct vnode *)0;
2159         struct vnode *tdirp = (struct vnode *)0;
2160         struct vattr fdirfor, fdiraft, tdirfor, tdiraft;
2161         nfsfh_t fnfh, tnfh;
2162         fhandle_t *ffhp, *tfhp;
2163         uid_t saved_uid;
2164         struct mount *mp = NULL;
2165         struct vnode *vp;
2166
2167         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2168 #ifndef nolint
2169         fvp = (struct vnode *)0;
2170 #endif
2171         ffhp = &fnfh.fh_generic;
2172         tfhp = &tnfh.fh_generic;
2173
2174         /*
2175          * Clear fields incase goto nfsmout occurs from macro.
2176          */
2177
2178         ndclear(&fromnd);
2179         ndclear(&tond);
2180
2181         nfsm_srvmtofh(ffhp);
2182         if ((mp = vfs_getvfs(&ffhp->fh_fsid)) == NULL) {
2183                 error = ESTALE;
2184                 goto out1;
2185         }
2186         if ((error = VFS_FHTOVP(mp, &ffhp->fh_fid, &vp)) != 0) {
2187                 mp = NULL;
2188                 goto out1;
2189         }
2190         (void) vn_start_write(vp, &mp, V_WAIT);
2191         vput(vp);
2192         vp = NULL;
2193         nfsm_srvnamesiz(len);
2194         /*
2195          * Remember our original uid so that we can reset cr_uid before
2196          * the second nfs_namei() call, in case it is remapped.
2197          */
2198         saved_uid = cred->cr_uid;
2199         fromnd.ni_cnd.cn_cred = cred;
2200         fromnd.ni_cnd.cn_nameiop = DELETE;
2201         fromnd.ni_cnd.cn_flags = WANTPARENT | SAVESTART;
2202         error = nfs_namei(&fromnd, ffhp, len, slp, nam, &md,
2203                 &dpos, &fdirp, td, FALSE);
2204         if (fdirp) {
2205                 if (v3) {
2206                         fdirfor_ret = VOP_GETATTR(fdirp, &fdirfor, cred,
2207                                 td);
2208                 } else {
2209                         vrele(fdirp);
2210                         fdirp = NULL;
2211                 }
2212         }
2213         if (error) {
2214                 nfsm_reply(2 * NFSX_WCCDATA(v3));
2215                 if (v3) {
2216                         nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
2217                         nfsm_srvwcc_data(tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
2218                 }
2219                 error = 0;
2220                 goto nfsmout;
2221         }
2222         fvp = fromnd.ni_vp;
2223         nfsm_srvmtofh(tfhp);
2224         nfsm_strsiz(len2, NFS_MAXNAMLEN);
2225         cred->cr_uid = saved_uid;
2226         tond.ni_cnd.cn_cred = cred;
2227         tond.ni_cnd.cn_nameiop = RENAME;
2228         tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART;
2229         error = nfs_namei(&tond, tfhp, len2, slp, nam, &md,
2230                 &dpos, &tdirp, td, FALSE);
2231         if (tdirp) {
2232                 if (v3) {
2233                         tdirfor_ret = VOP_GETATTR(tdirp, &tdirfor, cred,
2234                                 td);
2235                 } else {
2236                         vrele(tdirp);
2237                         tdirp = NULL;
2238                 }
2239         }
2240         if (error)
2241                 goto out1;
2242
2243         tdvp = tond.ni_dvp;
2244         tvp = tond.ni_vp;
2245         if (tvp != NULL) {
2246                 if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
2247                         if (v3)
2248                                 error = EEXIST;
2249                         else
2250                                 error = EISDIR;
2251                         goto out;
2252                 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
2253                         if (v3)
2254                                 error = EEXIST;
2255                         else
2256                                 error = ENOTDIR;
2257                         goto out;
2258                 }
2259                 if (tvp->v_type == VDIR && tvp->v_mountedhere) {
2260                         if (v3)
2261                                 error = EXDEV;
2262                         else
2263                                 error = ENOTEMPTY;
2264                         goto out;
2265                 }
2266         }
2267         if (fvp->v_type == VDIR && fvp->v_mountedhere) {
2268                 if (v3)
2269                         error = EXDEV;
2270                 else
2271                         error = ENOTEMPTY;
2272                 goto out;
2273         }
2274         if (fvp->v_mount != tdvp->v_mount) {
2275                 if (v3)
2276                         error = EXDEV;
2277                 else
2278                         error = ENOTEMPTY;
2279                 goto out;
2280         }
2281         if (fvp == tdvp) {
2282                 if (v3)
2283                         error = EINVAL;
2284                 else
2285                         error = ENOTEMPTY;
2286         }
2287         /*
2288          * If source is the same as the destination (that is the
2289          * same vnode with the same name in the same directory),
2290          * then there is nothing to do.
2291          */
2292         if (fvp == tvp && fromnd.ni_dvp == tdvp &&
2293             fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen &&
2294             !bcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr,
2295               fromnd.ni_cnd.cn_namelen))
2296                 error = -1;
2297 out:
2298         if (!error) {
2299                 /*
2300                  * The VOP_RENAME function releases all vnode references &
2301                  * locks prior to returning so we need to clear the pointers
2302                  * to bypass cleanup code later on.
2303                  */
2304                 error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd,
2305                                    tond.ni_dvp, tond.ni_vp, &tond.ni_cnd);
2306                 fromnd.ni_dvp = NULL;
2307                 fromnd.ni_vp = NULL;
2308                 tond.ni_dvp = NULL;
2309                 tond.ni_vp = NULL;
2310                 if (error) {
2311                         fromnd.ni_cnd.cn_flags &= ~HASBUF;
2312                         tond.ni_cnd.cn_flags &= ~HASBUF;
2313                 }
2314         } else {
2315                 if (error == -1)
2316                         error = 0;
2317         }
2318         /* fall through */
2319
2320 out1:
2321         if (fdirp)
2322                 fdiraft_ret = VOP_GETATTR(fdirp, &fdiraft, cred, td);
2323         if (tdirp)
2324                 tdiraft_ret = VOP_GETATTR(tdirp, &tdiraft, cred, td);
2325         nfsm_reply(2 * NFSX_WCCDATA(v3));
2326         if (v3) {
2327                 nfsm_srvwcc_data(fdirfor_ret, &fdirfor, fdiraft_ret, &fdiraft);
2328                 nfsm_srvwcc_data(tdirfor_ret, &tdirfor, tdiraft_ret, &tdiraft);
2329         }
2330         error = 0;
2331         /* fall through */
2332
2333 nfsmout:
2334         /*
2335          * Clear out tond related fields
2336          */
2337         if (tdirp)
2338                 vrele(tdirp);
2339         if (tond.ni_startdir)
2340                 vrele(tond.ni_startdir);
2341         NDFREE(&tond, NDF_ONLY_PNBUF);
2342         if (tond.ni_dvp) {
2343                 if (tond.ni_dvp == tond.ni_vp)
2344                         vrele(tond.ni_dvp);
2345                 else
2346                         vput(tond.ni_dvp);
2347         }
2348         if (tond.ni_vp)
2349                 vput(tond.ni_vp);
2350
2351         /*
2352          * Clear out fromnd related fields
2353          */
2354         if (fdirp)
2355                 vrele(fdirp);
2356         if (fromnd.ni_startdir)
2357                 vrele(fromnd.ni_startdir);
2358         NDFREE(&fromnd, NDF_ONLY_PNBUF);
2359         if (fromnd.ni_dvp)
2360                 vrele(fromnd.ni_dvp);
2361         if (fromnd.ni_vp)
2362                 vrele(fromnd.ni_vp);
2363
2364         vn_finished_write(mp);
2365         return (error);
2366 }
2367
2368 /*
2369  * nfs link service
2370  */
2371 int
2372 nfsrv_link(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2373     struct thread *td, struct mbuf **mrq)
2374 {
2375         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2376         struct sockaddr *nam = nfsd->nd_nam;
2377         caddr_t dpos = nfsd->nd_dpos;
2378         struct ucred *cred = &nfsd->nd_cr;
2379         struct nameidata nd;
2380         caddr_t bpos;
2381         int error = 0, rdonly, len, dirfor_ret = 1, diraft_ret = 1;
2382         int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);
2383         struct mbuf *mb, *mreq;
2384         struct vnode *vp = NULL, *xp, *dirp = (struct vnode *)0;
2385         struct vattr dirfor, diraft, at;
2386         nfsfh_t nfh, dnfh;
2387         fhandle_t *fhp, *dfhp;
2388         struct mount *mp = NULL;
2389
2390         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2391         ndclear(&nd);
2392
2393         fhp = &nfh.fh_generic;
2394         dfhp = &dnfh.fh_generic;
2395         nfsm_srvmtofh(fhp);
2396         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
2397                 error = ESTALE;
2398                 goto ereply;
2399         }
2400         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
2401                 mp = NULL;
2402                 goto ereply;
2403         }
2404         (void) vn_start_write(vp, &mp, V_WAIT);
2405         vput(vp);
2406         vp = NULL;
2407         nfsm_srvmtofh(dfhp);
2408         nfsm_srvnamesiz(len);
2409
2410         error = nfsrv_fhtovp(fhp, FALSE, &vp, cred, slp, nam, &rdonly, TRUE);
2411         if (error) {
2412                 nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2413                 if (v3) {
2414                         nfsm_srvpostop_attr(getret, &at);
2415                         nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2416                 }
2417                 vp = NULL;
2418                 error = 0;
2419                 goto nfsmout;
2420         }
2421         if (vp->v_type == VDIR) {
2422                 error = EPERM;          /* POSIX */
2423                 goto out1;
2424         }
2425         nd.ni_cnd.cn_cred = cred;
2426         nd.ni_cnd.cn_nameiop = CREATE;
2427         nd.ni_cnd.cn_flags = LOCKPARENT;
2428         error = nfs_namei(&nd, dfhp, len, slp, nam, &md, &dpos,
2429                 &dirp, td, FALSE);
2430         if (dirp) {
2431                 if (v3) {
2432                         dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2433                                 td);
2434                 } else {
2435                         vrele(dirp);
2436                         dirp = NULL;
2437                 }
2438         }
2439         if (error)
2440                 goto out1;
2441
2442         xp = nd.ni_vp;
2443         if (xp != NULL) {
2444                 error = EEXIST;
2445                 goto out;
2446         }
2447         xp = nd.ni_dvp;
2448         if (vp->v_mount != xp->v_mount)
2449                 error = EXDEV;
2450 out:
2451         if (!error) {
2452                 error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd);
2453                 NDFREE(&nd, NDF_ONLY_PNBUF);
2454         }
2455         /* fall through */
2456
2457 out1:
2458         if (v3)
2459                 getret = VOP_GETATTR(vp, &at, cred, td);
2460         if (dirp)
2461                 diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
2462 ereply:
2463         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2464         if (v3) {
2465                 nfsm_srvpostop_attr(getret, &at);
2466                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2467                 error = 0;
2468         }
2469         /* fall through */
2470
2471 nfsmout:
2472         NDFREE(&nd, NDF_ONLY_PNBUF);
2473         if (dirp)
2474                 vrele(dirp);
2475         if (vp)
2476                 vrele(vp);
2477         if (nd.ni_dvp) {
2478                 if (nd.ni_dvp == nd.ni_vp)
2479                         vrele(nd.ni_dvp);
2480                 else
2481                         vput(nd.ni_dvp);
2482         }
2483         if (nd.ni_vp)
2484                 vrele(nd.ni_vp);
2485         vn_finished_write(mp);
2486         return(error);
2487 }
2488
2489 /*
2490  * nfs symbolic link service
2491  */
2492 int
2493 nfsrv_symlink(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2494     struct thread *td, struct mbuf **mrq)
2495 {
2496         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2497         struct sockaddr *nam = nfsd->nd_nam;
2498         caddr_t dpos = nfsd->nd_dpos;
2499         struct ucred *cred = &nfsd->nd_cr;
2500         struct vattr va, dirfor, diraft;
2501         struct nameidata nd;
2502         struct vattr *vap = &va;
2503         struct nfsv2_sattr *sp;
2504         char *bpos, *pathcp = (char *)0;
2505         struct uio io;
2506         struct iovec iv;
2507         int error = 0, len, len2, dirfor_ret = 1, diraft_ret = 1;
2508         int v3 = (nfsd->nd_flag & ND_NFSV3);
2509         struct mbuf *mb, *mreq;
2510         struct vnode *dirp = (struct vnode *)0;
2511         nfsfh_t nfh;
2512         fhandle_t *fhp;
2513         struct mount *mp = NULL;
2514         struct vnode *vp;
2515
2516         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2517         ndclear(&nd);
2518
2519         fhp = &nfh.fh_generic;
2520         nfsm_srvmtofh(fhp);
2521         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
2522                 error = ESTALE;
2523                 goto out;
2524         }
2525         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
2526                 mp = NULL;
2527                 goto out;
2528         }
2529         (void) vn_start_write(vp, &mp, V_WAIT);
2530         vput(vp);
2531         vp = NULL;
2532         nfsm_srvnamesiz(len);
2533         nd.ni_cnd.cn_cred = cred;
2534         nd.ni_cnd.cn_nameiop = CREATE;
2535         nd.ni_cnd.cn_flags = LOCKPARENT | SAVESTART;
2536         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2537                 &dirp, td, FALSE);
2538         if (dirp) {
2539                 if (v3) {
2540                         dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2541                                 td);
2542                 } else {
2543                         vrele(dirp);
2544                         dirp = NULL;
2545                 }
2546         }
2547         if (error)
2548                 goto out;
2549
2550         VATTR_NULL(vap);
2551         if (v3)
2552                 nfsm_srvsattr(vap);
2553         nfsm_strsiz(len2, NFS_MAXPATHLEN);
2554         MALLOC(pathcp, caddr_t, len2 + 1, M_TEMP, M_WAITOK);
2555         iv.iov_base = pathcp;
2556         iv.iov_len = len2;
2557         io.uio_resid = len2;
2558         io.uio_offset = 0;
2559         io.uio_iov = &iv;
2560         io.uio_iovcnt = 1;
2561         io.uio_segflg = UIO_SYSSPACE;
2562         io.uio_rw = UIO_READ;
2563         io.uio_td = (struct thread *)0;
2564         nfsm_mtouio(&io, len2);
2565         if (!v3) {
2566                 sp = nfsm_dissect(struct nfsv2_sattr *, NFSX_V2SATTR);
2567                 vap->va_mode = nfstov_mode(sp->sa_mode);
2568         }
2569         *(pathcp + len2) = '\0';
2570         if (nd.ni_vp) {
2571                 error = EEXIST;
2572                 goto out;
2573         }
2574
2575         /*
2576          * issue symlink op.  SAVESTART is set so the underlying path component
2577          * is only freed by the VOP if an error occurs.
2578          */
2579         if (vap->va_mode == (mode_t)VNOVAL)
2580                 vap->va_mode = 0;
2581         error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap, pathcp);
2582         if (error)
2583                 NDFREE(&nd, NDF_ONLY_PNBUF);
2584         else
2585                 vput(nd.ni_vp);
2586         nd.ni_vp = NULL;
2587         /*
2588          * releases directory prior to potential lookup op.
2589          */
2590         vput(nd.ni_dvp);
2591         nd.ni_dvp = NULL;
2592
2593         if (error == 0) {
2594             if (v3) {
2595                 /*
2596                  * Issue lookup.  Leave SAVESTART set so we can easily free
2597                  * the name buffer later on.
2598                  *
2599                  * since LOCKPARENT is not set, ni_dvp will be garbage on
2600                  * return whether an error occurs or not.
2601                  */
2602                 nd.ni_cnd.cn_nameiop = LOOKUP;
2603                 nd.ni_cnd.cn_flags &= ~(LOCKPARENT | FOLLOW);
2604                 nd.ni_cnd.cn_flags |= (NOFOLLOW | LOCKLEAF);
2605                 nd.ni_cnd.cn_thread = td;
2606                 nd.ni_cnd.cn_cred = cred;
2607
2608                 error = lookup(&nd);
2609                 nd.ni_dvp = NULL;
2610
2611                 if (error == 0) {
2612                         bzero((caddr_t)fhp, sizeof(nfh));
2613                         fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
2614                         error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
2615                         if (!error)
2616                                 error = VOP_GETATTR(nd.ni_vp, vap, cred,
2617                                         td);
2618                         vput(nd.ni_vp);
2619                         nd.ni_vp = NULL;
2620                 }
2621             }
2622         }
2623 out:
2624         /*
2625          * These releases aren't strictly required, does even doing them
2626          * make any sense? XXX can nfsm_reply() block?
2627          */
2628         if (pathcp) {
2629                 FREE(pathcp, M_TEMP);
2630                 pathcp = NULL;
2631         }
2632         if (dirp) {
2633                 diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
2634                 vrele(dirp);
2635                 dirp = NULL;
2636         }
2637         if (nd.ni_startdir) {
2638                 vrele(nd.ni_startdir);
2639                 nd.ni_startdir = NULL;
2640         }
2641         nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2642         if (v3) {
2643                 if (!error) {
2644                         nfsm_srvpostop_fh(fhp);
2645                         nfsm_srvpostop_attr(0, vap);
2646                 }
2647                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2648         }
2649         error = 0;
2650         /* fall through */
2651
2652 nfsmout:
2653         NDFREE(&nd, NDF_ONLY_PNBUF);
2654         if (nd.ni_dvp) {
2655                 if (nd.ni_dvp == nd.ni_vp)
2656                         vrele(nd.ni_dvp);
2657                 else
2658                         vput(nd.ni_dvp);
2659         }
2660         if (nd.ni_vp)
2661                 vrele(nd.ni_vp);
2662         if (nd.ni_startdir)
2663                 vrele(nd.ni_startdir);
2664         if (dirp)
2665                 vrele(dirp);
2666         if (pathcp)
2667                 FREE(pathcp, M_TEMP);
2668
2669         vn_finished_write(mp);
2670         return (error);
2671 }
2672
2673 /*
2674  * nfs mkdir service
2675  */
2676 int
2677 nfsrv_mkdir(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2678     struct thread *td, struct mbuf **mrq)
2679 {
2680         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2681         struct sockaddr *nam = nfsd->nd_nam;
2682         caddr_t dpos = nfsd->nd_dpos;
2683         struct ucred *cred = &nfsd->nd_cr;
2684         struct vattr va, dirfor, diraft;
2685         struct vattr *vap = &va;
2686         struct nfs_fattr *fp;
2687         struct nameidata nd;
2688         u_int32_t *tl;
2689         caddr_t bpos;
2690         int error = 0, len, dirfor_ret = 1, diraft_ret = 1;
2691         int v3 = (nfsd->nd_flag & ND_NFSV3);
2692         struct mbuf *mb, *mreq;
2693         struct vnode *dirp = NULL;
2694         int vpexcl = 0;
2695         nfsfh_t nfh;
2696         fhandle_t *fhp;
2697         struct mount *mp = NULL;
2698         struct vnode *vp;
2699
2700         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2701         ndclear(&nd);
2702
2703         fhp = &nfh.fh_generic;
2704         nfsm_srvmtofh(fhp);
2705         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
2706                 error = ESTALE;
2707                 goto out;
2708         }
2709         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
2710                 mp = NULL;
2711                 goto out;
2712         }
2713         (void) vn_start_write(vp, &mp, V_WAIT);
2714         vput(vp);
2715         vp = NULL;
2716         nfsm_srvnamesiz(len);
2717         nd.ni_cnd.cn_cred = cred;
2718         nd.ni_cnd.cn_nameiop = CREATE;
2719         nd.ni_cnd.cn_flags = LOCKPARENT;
2720
2721         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2722                 &dirp, td, FALSE);
2723         if (dirp) {
2724                 if (v3) {
2725                         dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2726                                 td);
2727                 } else {
2728                         vrele(dirp);
2729                         dirp = NULL;
2730                 }
2731         }
2732         if (error) {
2733                 nfsm_reply(NFSX_WCCDATA(v3));
2734                 if (v3)
2735                         nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2736                 error = 0;
2737                 goto nfsmout;
2738         }
2739         VATTR_NULL(vap);
2740         if (v3) {
2741                 nfsm_srvsattr(vap);
2742         } else {
2743                 tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
2744                 vap->va_mode = nfstov_mode(*tl++);
2745         }
2746
2747         /*
2748          * At this point nd.ni_dvp is referenced and exclusively locked and
2749          * nd.ni_vp, if it exists, is referenced but not locked.
2750          */
2751
2752         vap->va_type = VDIR;
2753         if (nd.ni_vp != NULL) {
2754                 NDFREE(&nd, NDF_ONLY_PNBUF);
2755                 error = EEXIST;
2756                 goto out;
2757         }
2758
2759         /*
2760          * Issue mkdir op.  Since SAVESTART is not set, the pathname
2761          * component is freed by the VOP call.  This will fill-in
2762          * nd.ni_vp, reference, and exclusively lock it.
2763          */
2764         if (vap->va_mode == (mode_t)VNOVAL)
2765                 vap->va_mode = 0;
2766         error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap);
2767         NDFREE(&nd, NDF_ONLY_PNBUF);
2768         vpexcl = 1;
2769
2770         vput(nd.ni_dvp);
2771         nd.ni_dvp = NULL;
2772
2773         if (!error) {
2774                 bzero((caddr_t)fhp, sizeof(nfh));
2775                 fhp->fh_fsid = nd.ni_vp->v_mount->mnt_stat.f_fsid;
2776                 error = VFS_VPTOFH(nd.ni_vp, &fhp->fh_fid);
2777                 if (!error)
2778                         error = VOP_GETATTR(nd.ni_vp, vap, cred, td);
2779         }
2780 out:
2781         if (dirp)
2782                 diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
2783         nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPATTR(v3) + NFSX_WCCDATA(v3));
2784         if (v3) {
2785                 if (!error) {
2786                         nfsm_srvpostop_fh(fhp);
2787                         nfsm_srvpostop_attr(0, vap);
2788                 }
2789                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2790         } else if (!error) {
2791                 /* v2 non-error case. */
2792                 nfsm_srvfhtom(fhp, v3);
2793                 fp = nfsm_build(struct nfs_fattr *, NFSX_V2FATTR);
2794                 nfsm_srvfillattr(vap, fp);
2795         }
2796         error = 0;
2797         /* fall through */
2798
2799 nfsmout:
2800         if (dirp)
2801                 vrele(dirp);
2802         if (nd.ni_dvp) {
2803                 NDFREE(&nd, NDF_ONLY_PNBUF);
2804                 if (nd.ni_dvp == nd.ni_vp && vpexcl)
2805                         vrele(nd.ni_dvp);
2806                 else
2807                         vput(nd.ni_dvp);
2808         }
2809         if (nd.ni_vp) {
2810                 if (vpexcl)
2811                         vput(nd.ni_vp);
2812                 else
2813                         vrele(nd.ni_vp);
2814         }
2815         vn_finished_write(mp);
2816         return (error);
2817 }
2818
2819 /*
2820  * nfs rmdir service
2821  */
2822 int
2823 nfsrv_rmdir(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2824     struct thread *td, struct mbuf **mrq)
2825 {
2826         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2827         struct sockaddr *nam = nfsd->nd_nam;
2828         caddr_t dpos = nfsd->nd_dpos;
2829         struct ucred *cred = &nfsd->nd_cr;
2830         caddr_t bpos;
2831         int error = 0, len, dirfor_ret = 1, diraft_ret = 1;
2832         int v3 = (nfsd->nd_flag & ND_NFSV3);
2833         struct mbuf *mb, *mreq;
2834         struct vnode *vp, *dirp = (struct vnode *)0;
2835         struct vattr dirfor, diraft;
2836         nfsfh_t nfh;
2837         fhandle_t *fhp;
2838         struct nameidata nd;
2839         struct mount *mp = NULL;
2840
2841         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2842         ndclear(&nd);
2843
2844         fhp = &nfh.fh_generic;
2845         nfsm_srvmtofh(fhp);
2846         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
2847                 error = ESTALE;
2848                 goto out;
2849         }
2850         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
2851                 mp = NULL;
2852                 goto out;
2853         }
2854         (void) vn_start_write(vp, &mp, V_WAIT);
2855         vput(vp);
2856         vp = NULL;
2857         nfsm_srvnamesiz(len);
2858         nd.ni_cnd.cn_cred = cred;
2859         nd.ni_cnd.cn_nameiop = DELETE;
2860         nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
2861         error = nfs_namei(&nd, fhp, len, slp, nam, &md, &dpos,
2862                 &dirp, td, FALSE);
2863         if (dirp) {
2864                 if (v3) {
2865                         dirfor_ret = VOP_GETATTR(dirp, &dirfor, cred,
2866                                 td);
2867                 } else {
2868                         vrele(dirp);
2869                         dirp = NULL;
2870                 }
2871         }
2872         if (error) {
2873                 nfsm_reply(NFSX_WCCDATA(v3));
2874                 if (v3)
2875                         nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2876                 error = 0;
2877                 goto nfsmout;
2878         }
2879         vp = nd.ni_vp;
2880         if (vp->v_type != VDIR) {
2881                 error = ENOTDIR;
2882                 goto out;
2883         }
2884         /*
2885          * No rmdir "." please.
2886          */
2887         if (nd.ni_dvp == vp) {
2888                 error = EINVAL;
2889                 goto out;
2890         }
2891         /*
2892          * The root of a mounted filesystem cannot be deleted.
2893          */
2894         if (vp->v_flag & VROOT)
2895                 error = EBUSY;
2896 out:
2897         /*
2898          * Issue or abort op.  Since SAVESTART is not set, path name
2899          * component is freed by the VOP after either.
2900          */
2901         if (!error)
2902                 error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd);
2903         NDFREE(&nd, NDF_ONLY_PNBUF);
2904
2905         if (dirp)
2906                 diraft_ret = VOP_GETATTR(dirp, &diraft, cred, td);
2907         nfsm_reply(NFSX_WCCDATA(v3));
2908         if (v3) {
2909                 nfsm_srvwcc_data(dirfor_ret, &dirfor, diraft_ret, &diraft);
2910                 error = 0;
2911         }
2912         /* fall through */
2913
2914 nfsmout:
2915         NDFREE(&nd, NDF_ONLY_PNBUF);
2916         if (dirp)
2917                 vrele(dirp);
2918         if (nd.ni_dvp) {
2919                 if (nd.ni_dvp == nd.ni_vp)
2920                         vrele(nd.ni_dvp);
2921                 else
2922                         vput(nd.ni_dvp);
2923         }
2924         if (nd.ni_vp)
2925                 vput(nd.ni_vp);
2926
2927         vn_finished_write(mp);
2928         return(error);
2929 }
2930
2931 /*
2932  * nfs readdir service
2933  * - mallocs what it thinks is enough to read
2934  *      count rounded up to a multiple of NFS_DIRBLKSIZ <= NFS_MAXREADDIR
2935  * - calls VOP_READDIR()
2936  * - loops around building the reply
2937  *      if the output generated exceeds count break out of loop
2938  *      The nfsm_clget macro is used here so that the reply will be packed
2939  *      tightly in mbuf clusters.
2940  * - it only knows that it has encountered eof when the VOP_READDIR()
2941  *      reads nothing
2942  * - as such one readdir rpc will return eof false although you are there
2943  *      and then the next will return eof
2944  * - it trims out records with d_fileno == 0
2945  *      this doesn't matter for Unix clients, but they might confuse clients
2946  *      for other os'.
2947  * NB: It is tempting to set eof to true if the VOP_READDIR() reads less
2948  *      than requested, but this may not apply to all filesystems. For
2949  *      example, client NFS does not { although it is never remote mounted
2950  *      anyhow }
2951  *     The alternate call nfsrv_readdirplus() does lookups as well.
2952  * PS: The NFS protocol spec. does not clarify what the "count" byte
2953  *      argument is a count of.. just name strings and file id's or the
2954  *      entire reply rpc or ...
2955  *      I tried just file name and id sizes and it confused the Sun client,
2956  *      so I am using the full rpc size now. The "paranoia.." comment refers
2957  *      to including the status longwords that are not a part of the dir.
2958  *      "entry" structures, but are in the rpc.
2959  */
2960 struct flrep {
2961         nfsuint64       fl_off;
2962         u_int32_t       fl_postopok;
2963         u_int32_t       fl_fattr[NFSX_V3FATTR / sizeof (u_int32_t)];
2964         u_int32_t       fl_fhok;
2965         u_int32_t       fl_fhsize;
2966         u_int32_t       fl_nfh[NFSX_V3FH / sizeof (u_int32_t)];
2967 };
2968
2969 int
2970 nfsrv_readdir(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
2971     struct thread *td, struct mbuf **mrq)
2972 {
2973         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
2974         struct sockaddr *nam = nfsd->nd_nam;
2975         caddr_t dpos = nfsd->nd_dpos;
2976         struct ucred *cred = &nfsd->nd_cr;
2977         char *bp, *be;
2978         struct mbuf *mp;
2979         struct dirent *dp;
2980         caddr_t cp;
2981         u_int32_t *tl;
2982         caddr_t bpos;
2983         struct mbuf *mb, *mreq;
2984         char *cpos, *cend, *rbuf;
2985         struct vnode *vp = NULL;
2986         struct vattr at;
2987         nfsfh_t nfh;
2988         fhandle_t *fhp;
2989         struct uio io;
2990         struct iovec iv;
2991         int len, nlen, rem, xfer, tsiz, i, error = 0, getret = 1;
2992         int siz, cnt, fullsiz, eofflag, rdonly, ncookies;
2993         int v3 = (nfsd->nd_flag & ND_NFSV3);
2994         u_quad_t off, toff, verf;
2995         u_long *cookies = NULL, *cookiep; /* needs to be int64_t or off_t */
2996
2997         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2998         fhp = &nfh.fh_generic;
2999         nfsm_srvmtofh(fhp);
3000         if (v3) {
3001                 tl = nfsm_dissect(u_int32_t *, 5 * NFSX_UNSIGNED);
3002                 toff = fxdr_hyper(tl);
3003                 tl += 2;
3004                 verf = fxdr_hyper(tl);
3005                 tl += 2;
3006         } else {
3007                 tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
3008                 toff = fxdr_unsigned(u_quad_t, *tl++);
3009                 verf = 0;       /* shut up gcc */
3010         }
3011         off = toff;
3012         cnt = fxdr_unsigned(int, *tl);
3013         siz = ((cnt + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
3014         xfer = NFS_SRVMAXDATA(nfsd);
3015         if (siz > xfer)
3016                 siz = xfer;
3017         fullsiz = siz;
3018         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
3019         if (!error && vp->v_type != VDIR) {
3020                 error = ENOTDIR;
3021                 vput(vp);
3022                 vp = NULL;
3023         }
3024         if (error) {
3025                 nfsm_reply(NFSX_UNSIGNED);
3026                 if (v3)
3027                         nfsm_srvpostop_attr(getret, &at);
3028                 error = 0;
3029                 goto nfsmout;
3030         }
3031
3032         /*
3033          * Obtain lock on vnode for this section of the code
3034          */
3035         if (v3) {
3036                 error = getret = VOP_GETATTR(vp, &at, cred, td);
3037 #if 0
3038                 /*
3039                  * XXX This check may be too strict for Solaris 2.5 clients.
3040                  */
3041                 if (!error && toff && verf && verf != at.va_filerev)
3042                         error = NFSERR_BAD_COOKIE;
3043 #endif
3044         }
3045         if (!error)
3046                 error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0);
3047         if (error) {
3048                 vput(vp);
3049                 vp = NULL;
3050                 nfsm_reply(NFSX_POSTOPATTR(v3));
3051                 if (v3)
3052                         nfsm_srvpostop_attr(getret, &at);
3053                 error = 0;
3054                 goto nfsmout;
3055         }
3056         VOP_UNLOCK(vp, 0, td);
3057
3058         /*
3059          * end section.  Allocate rbuf and continue
3060          */
3061         MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK);
3062 again:
3063         iv.iov_base = rbuf;
3064         iv.iov_len = fullsiz;
3065         io.uio_iov = &iv;
3066         io.uio_iovcnt = 1;
3067         io.uio_offset = (off_t)off;
3068         io.uio_resid = fullsiz;
3069         io.uio_segflg = UIO_SYSSPACE;
3070         io.uio_rw = UIO_READ;
3071         io.uio_td = (struct thread *)0;
3072         eofflag = 0;
3073         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3074         if (cookies) {
3075                 free((caddr_t)cookies, M_TEMP);
3076                 cookies = NULL;
3077         }
3078         error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies);
3079         off = (off_t)io.uio_offset;
3080         if (!cookies && !error)
3081                 error = NFSERR_PERM;
3082         if (v3) {
3083                 getret = VOP_GETATTR(vp, &at, cred, td);
3084                 if (!error)
3085                         error = getret;
3086         }
3087         VOP_UNLOCK(vp, 0, td);
3088         if (error) {
3089                 vrele(vp);
3090                 vp = NULL;
3091                 free((caddr_t)rbuf, M_TEMP);
3092                 if (cookies)
3093                         free((caddr_t)cookies, M_TEMP);
3094                 nfsm_reply(NFSX_POSTOPATTR(v3));
3095                 if (v3)
3096                         nfsm_srvpostop_attr(getret, &at);
3097                 error = 0;
3098                 goto nfsmout;
3099         }
3100         if (io.uio_resid) {
3101                 siz -= io.uio_resid;
3102
3103                 /*
3104                  * If nothing read, return eof
3105                  * rpc reply
3106                  */
3107                 if (siz == 0) {
3108                         vrele(vp);
3109                         vp = NULL;
3110                         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_COOKIEVERF(v3) +
3111                                 2 * NFSX_UNSIGNED);
3112                         if (v3) {
3113                                 nfsm_srvpostop_attr(getret, &at);
3114                                 tl = nfsm_build(u_int32_t *, 4 * NFSX_UNSIGNED);
3115                                 txdr_hyper(at.va_filerev, tl);
3116                                 tl += 2;
3117                         } else
3118                                 tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
3119                         *tl++ = nfsrv_nfs_false;
3120                         *tl = nfsrv_nfs_true;
3121                         FREE((caddr_t)rbuf, M_TEMP);
3122                         FREE((caddr_t)cookies, M_TEMP);
3123                         error = 0;
3124                         goto nfsmout;
3125                 }
3126         }
3127
3128         /*
3129          * Check for degenerate cases of nothing useful read.
3130          * If so go try again
3131          */
3132         cpos = rbuf;
3133         cend = rbuf + siz;
3134         dp = (struct dirent *)cpos;
3135         cookiep = cookies;
3136         /*
3137          * For some reason FreeBSD's ufs_readdir() chooses to back the
3138          * directory offset up to a block boundary, so it is necessary to
3139          * skip over the records that precede the requested offset. This
3140          * requires the assumption that file offset cookies monotonically
3141          * increase.
3142          */
3143         while (cpos < cend && ncookies > 0 &&
3144                 (dp->d_fileno == 0 || dp->d_type == DT_WHT ||
3145                  ((u_quad_t)(*cookiep)) <= toff)) {
3146                 cpos += dp->d_reclen;
3147                 dp = (struct dirent *)cpos;
3148                 cookiep++;
3149                 ncookies--;
3150         }
3151         if (cpos >= cend || ncookies == 0) {
3152                 toff = off;
3153                 siz = fullsiz;
3154                 goto again;
3155         }
3156
3157         len = 3 * NFSX_UNSIGNED;        /* paranoia, probably can be 0 */
3158         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_COOKIEVERF(v3) + siz);
3159         if (v3) {
3160                 nfsm_srvpostop_attr(getret, &at);
3161                 tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
3162                 txdr_hyper(at.va_filerev, tl);
3163         }
3164         mp = mb;
3165         bp = bpos;
3166         be = bp + M_TRAILINGSPACE(mp);
3167
3168         /* Loop through the records and build reply */
3169         while (cpos < cend && ncookies > 0) {
3170                 if (dp->d_fileno != 0 && dp->d_type != DT_WHT) {
3171                         nlen = dp->d_namlen;
3172                         rem = nfsm_rndup(nlen) - nlen;
3173                         len += (4 * NFSX_UNSIGNED + nlen + rem);
3174                         if (v3)
3175                                 len += 2 * NFSX_UNSIGNED;
3176                         if (len > cnt) {
3177                                 eofflag = 0;
3178                                 break;
3179                         }
3180                         /*
3181                          * Build the directory record xdr from
3182                          * the dirent entry.
3183                          */
3184                         nfsm_clget;
3185                         *tl = nfsrv_nfs_true;
3186                         bp += NFSX_UNSIGNED;
3187                         if (v3) {
3188                                 nfsm_clget;
3189                                 *tl = 0;
3190                                 bp += NFSX_UNSIGNED;
3191                         }
3192                         nfsm_clget;
3193                         *tl = txdr_unsigned(dp->d_fileno);
3194                         bp += NFSX_UNSIGNED;
3195                         nfsm_clget;
3196                         *tl = txdr_unsigned(nlen);
3197                         bp += NFSX_UNSIGNED;
3198
3199                         /* And loop around copying the name */
3200                         xfer = nlen;
3201                         cp = dp->d_name;
3202                         while (xfer > 0) {
3203                                 nfsm_clget;
3204                                 if ((bp+xfer) > be)
3205                                         tsiz = be-bp;
3206                                 else
3207                                         tsiz = xfer;
3208                                 bcopy(cp, bp, tsiz);
3209                                 bp += tsiz;
3210                                 xfer -= tsiz;
3211                                 if (xfer > 0)
3212                                         cp += tsiz;
3213                         }
3214                         /* And null pad to a int32_t boundary */
3215                         for (i = 0; i < rem; i++)
3216                                 *bp++ = '\0';
3217                         nfsm_clget;
3218
3219                         /* Finish off the record */
3220                         if (v3) {
3221                                 *tl = 0;
3222                                 bp += NFSX_UNSIGNED;
3223                                 nfsm_clget;
3224                         }
3225                         *tl = txdr_unsigned(*cookiep);
3226                         bp += NFSX_UNSIGNED;
3227                 }
3228                 cpos += dp->d_reclen;
3229                 dp = (struct dirent *)cpos;
3230                 cookiep++;
3231                 ncookies--;
3232         }
3233         vrele(vp);
3234         vp = NULL;
3235         nfsm_clget;
3236         *tl = nfsrv_nfs_false;
3237         bp += NFSX_UNSIGNED;
3238         nfsm_clget;
3239         if (eofflag)
3240                 *tl = nfsrv_nfs_true;
3241         else
3242                 *tl = nfsrv_nfs_false;
3243         bp += NFSX_UNSIGNED;
3244         if (mp != mb) {
3245                 if (bp < be)
3246                         mp->m_len = bp - mtod(mp, caddr_t);
3247         } else
3248                 mp->m_len += bp - bpos;
3249         FREE((caddr_t)rbuf, M_TEMP);
3250         FREE((caddr_t)cookies, M_TEMP);
3251
3252 nfsmout:
3253         if (vp)
3254                 vrele(vp);
3255         return(error);
3256 }
3257
3258 int
3259 nfsrv_readdirplus(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3260     struct thread *td, struct mbuf **mrq)
3261 {
3262         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3263         struct sockaddr *nam = nfsd->nd_nam;
3264         caddr_t dpos = nfsd->nd_dpos;
3265         struct ucred *cred = &nfsd->nd_cr;
3266         char *bp, *be;
3267         struct mbuf *mp;
3268         struct dirent *dp;
3269         caddr_t cp;
3270         u_int32_t *tl;
3271         caddr_t bpos;
3272         struct mbuf *mb, *mreq;
3273         char *cpos, *cend, *rbuf;
3274         struct vnode *vp = NULL, *nvp;
3275         struct flrep fl;
3276         nfsfh_t nfh;
3277         fhandle_t *fhp, *nfhp = (fhandle_t *)fl.fl_nfh;
3278         struct uio io;
3279         struct iovec iv;
3280         struct vattr va, at, *vap = &va;
3281         struct nfs_fattr *fp;
3282         int len, nlen, rem, xfer, tsiz, i, error = 0, getret = 1;
3283         int siz, cnt, fullsiz, eofflag, rdonly, dirlen, ncookies;
3284         u_quad_t off, toff, verf;
3285         u_long *cookies = NULL, *cookiep; /* needs to be int64_t or off_t */
3286         int v3 = (nfsd->nd_flag & ND_NFSV3);
3287
3288         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3289         if (!v3)
3290                 panic("nfsrv_readdirplus: v3 proc called on a v2 connection");
3291         fhp = &nfh.fh_generic;
3292         nfsm_srvmtofh(fhp);
3293         tl = nfsm_dissect(u_int32_t *, 6 * NFSX_UNSIGNED);
3294         toff = fxdr_hyper(tl);
3295         tl += 2;
3296         verf = fxdr_hyper(tl);
3297         tl += 2;
3298         siz = fxdr_unsigned(int, *tl++);
3299         cnt = fxdr_unsigned(int, *tl);
3300         off = toff;
3301         siz = ((siz + DIRBLKSIZ - 1) & ~(DIRBLKSIZ - 1));
3302         xfer = NFS_SRVMAXDATA(nfsd);
3303         if (siz > xfer)
3304                 siz = xfer;
3305         fullsiz = siz;
3306         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
3307         if (!error && vp->v_type != VDIR) {
3308                 error = ENOTDIR;
3309                 vput(vp);
3310                 vp = NULL;
3311         }
3312         if (error) {
3313                 nfsm_reply(NFSX_UNSIGNED);
3314                 nfsm_srvpostop_attr(getret, &at);
3315                 error = 0;
3316                 goto nfsmout;
3317         }
3318         error = getret = VOP_GETATTR(vp, &at, cred, td);
3319 #if 0
3320         /*
3321          * XXX This check may be too strict for Solaris 2.5 clients.
3322          */
3323         if (!error && toff && verf && verf != at.va_filerev)
3324                 error = NFSERR_BAD_COOKIE;
3325 #endif
3326         if (!error)
3327                 error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 0);
3328         if (error) {
3329                 vput(vp);
3330                 vp = NULL;
3331                 nfsm_reply(NFSX_V3POSTOPATTR);
3332                 nfsm_srvpostop_attr(getret, &at);
3333                 error = 0;
3334                 goto nfsmout;
3335         }
3336         VOP_UNLOCK(vp, 0, td);
3337         MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK);
3338 again:
3339         iv.iov_base = rbuf;
3340         iv.iov_len = fullsiz;
3341         io.uio_iov = &iv;
3342         io.uio_iovcnt = 1;
3343         io.uio_offset = (off_t)off;
3344         io.uio_resid = fullsiz;
3345         io.uio_segflg = UIO_SYSSPACE;
3346         io.uio_rw = UIO_READ;
3347         io.uio_td = (struct thread *)0;
3348         eofflag = 0;
3349         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
3350         if (cookies) {
3351                 free((caddr_t)cookies, M_TEMP);
3352                 cookies = NULL;
3353         }
3354         error = VOP_READDIR(vp, &io, cred, &eofflag, &ncookies, &cookies);
3355         off = (u_quad_t)io.uio_offset;
3356         getret = VOP_GETATTR(vp, &at, cred, td);
3357         VOP_UNLOCK(vp, 0, td);
3358         if (!cookies && !error)
3359                 error = NFSERR_PERM;
3360         if (!error)
3361                 error = getret;
3362         if (error) {
3363                 vrele(vp);
3364                 vp = NULL;
3365                 if (cookies)
3366                         free((caddr_t)cookies, M_TEMP);
3367                 free((caddr_t)rbuf, M_TEMP);
3368                 nfsm_reply(NFSX_V3POSTOPATTR);
3369                 nfsm_srvpostop_attr(getret, &at);
3370                 error = 0;
3371                 goto nfsmout;
3372         }
3373         if (io.uio_resid) {
3374                 siz -= io.uio_resid;
3375
3376                 /*
3377                  * If nothing read, return eof
3378                  * rpc reply
3379                  */
3380                 if (siz == 0) {
3381                         vrele(vp);
3382                         vp = NULL;
3383                         nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3COOKIEVERF +
3384                                 2 * NFSX_UNSIGNED);
3385                         nfsm_srvpostop_attr(getret, &at);
3386                         tl = nfsm_build(u_int32_t *, 4 * NFSX_UNSIGNED);
3387                         txdr_hyper(at.va_filerev, tl);
3388                         tl += 2;
3389                         *tl++ = nfsrv_nfs_false;
3390                         *tl = nfsrv_nfs_true;
3391                         FREE((caddr_t)cookies, M_TEMP);
3392                         FREE((caddr_t)rbuf, M_TEMP);
3393                         error = 0;
3394                         goto nfsmout;
3395                 }
3396         }
3397
3398         /*
3399          * Check for degenerate cases of nothing useful read.
3400          * If so go try again
3401          */
3402         cpos = rbuf;
3403         cend = rbuf + siz;
3404         dp = (struct dirent *)cpos;
3405         cookiep = cookies;
3406         /*
3407          * For some reason FreeBSD's ufs_readdir() chooses to back the
3408          * directory offset up to a block boundary, so it is necessary to
3409          * skip over the records that precede the requested offset. This
3410          * requires the assumption that file offset cookies monotonically
3411          * increase.
3412          */
3413         while (cpos < cend && ncookies > 0 &&
3414                 (dp->d_fileno == 0 || dp->d_type == DT_WHT ||
3415                  ((u_quad_t)(*cookiep)) <= toff)) {
3416                 cpos += dp->d_reclen;
3417                 dp = (struct dirent *)cpos;
3418                 cookiep++;
3419                 ncookies--;
3420         }
3421         if (cpos >= cend || ncookies == 0) {
3422                 toff = off;
3423                 siz = fullsiz;
3424                 goto again;
3425         }
3426
3427         /*
3428          * Probe one of the directory entries to see if the filesystem
3429          * supports VGET.
3430          */
3431         if (VFS_VGET(vp->v_mount, dp->d_fileno, &nvp) == EOPNOTSUPP) {
3432                 error = NFSERR_NOTSUPP;
3433                 vrele(vp);
3434                 vp = NULL;
3435                 free((caddr_t)cookies, M_TEMP);
3436                 free((caddr_t)rbuf, M_TEMP);
3437                 nfsm_reply(NFSX_V3POSTOPATTR);
3438                 nfsm_srvpostop_attr(getret, &at);
3439                 error = 0;
3440                 goto nfsmout;
3441         }
3442         vput(nvp);
3443         nvp = NULL;
3444
3445         dirlen = len = NFSX_V3POSTOPATTR + NFSX_V3COOKIEVERF +
3446             2 * NFSX_UNSIGNED;
3447         nfsm_reply(cnt);
3448         nfsm_srvpostop_attr(getret, &at);
3449         tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
3450         txdr_hyper(at.va_filerev, tl);
3451         mp = mb;
3452         bp = bpos;
3453         be = bp + M_TRAILINGSPACE(mp);
3454
3455         /* Loop through the records and build reply */
3456         while (cpos < cend && ncookies > 0) {
3457                 if (dp->d_fileno != 0 && dp->d_type != DT_WHT) {
3458                         nlen = dp->d_namlen;
3459                         rem = nfsm_rndup(nlen)-nlen;
3460
3461                         /*
3462                          * For readdir_and_lookup get the vnode using
3463                          * the file number.
3464                          */
3465                         if (VFS_VGET(vp->v_mount, dp->d_fileno, &nvp))
3466                                 goto invalid;
3467                         bzero((caddr_t)nfhp, NFSX_V3FH);
3468                         nfhp->fh_fsid =
3469                                 nvp->v_mount->mnt_stat.f_fsid;
3470                         if (VFS_VPTOFH(nvp, &nfhp->fh_fid)) {
3471                                 vput(nvp);
3472                                 nvp = NULL;
3473                                 goto invalid;
3474                         }
3475                         if (VOP_GETATTR(nvp, vap, cred, td)) {
3476                                 vput(nvp);
3477                                 nvp = NULL;
3478                                 goto invalid;
3479                         }
3480                         vput(nvp);
3481                         nvp = NULL;
3482
3483                         /*
3484                          * If either the dircount or maxcount will be
3485                          * exceeded, get out now. Both of these lengths
3486                          * are calculated conservatively, including all
3487                          * XDR overheads.
3488                          */
3489                         len += (8 * NFSX_UNSIGNED + nlen + rem + NFSX_V3FH +
3490                                 NFSX_V3POSTOPATTR);
3491                         dirlen += (6 * NFSX_UNSIGNED + nlen + rem);
3492                         if (len > cnt || dirlen > fullsiz) {
3493                                 eofflag = 0;
3494                                 break;
3495                         }
3496
3497                         /*
3498                          * Build the directory record xdr from
3499                          * the dirent entry.
3500                          */
3501                         fp = (struct nfs_fattr *)&fl.fl_fattr;
3502                         nfsm_srvfillattr(vap, fp);
3503                         fl.fl_fhsize = txdr_unsigned(NFSX_V3FH);
3504                         fl.fl_fhok = nfsrv_nfs_true;
3505                         fl.fl_postopok = nfsrv_nfs_true;
3506                         fl.fl_off.nfsuquad[0] = 0;
3507                         fl.fl_off.nfsuquad[1] = txdr_unsigned(*cookiep);
3508
3509                         nfsm_clget;
3510                         *tl = nfsrv_nfs_true;
3511                         bp += NFSX_UNSIGNED;
3512                         nfsm_clget;
3513                         *tl = 0;
3514                         bp += NFSX_UNSIGNED;
3515                         nfsm_clget;
3516                         *tl = txdr_unsigned(dp->d_fileno);
3517                         bp += NFSX_UNSIGNED;
3518                         nfsm_clget;
3519                         *tl = txdr_unsigned(nlen);
3520                         bp += NFSX_UNSIGNED;
3521
3522                         /* And loop around copying the name */
3523                         xfer = nlen;
3524                         cp = dp->d_name;
3525                         while (xfer > 0) {
3526                                 nfsm_clget;
3527                                 if ((bp + xfer) > be)
3528                                         tsiz = be - bp;
3529                                 else
3530                                         tsiz = xfer;
3531                                 bcopy(cp, bp, tsiz);
3532                                 bp += tsiz;
3533                                 xfer -= tsiz;
3534                                 if (xfer > 0)
3535                                         cp += tsiz;
3536                         }
3537                         /* And null pad to a int32_t boundary */
3538                         for (i = 0; i < rem; i++)
3539                                 *bp++ = '\0';
3540
3541                         /*
3542                          * Now copy the flrep structure out.
3543                          */
3544                         xfer = sizeof (struct flrep);
3545                         cp = (caddr_t)&fl;
3546                         while (xfer > 0) {
3547                                 nfsm_clget;
3548                                 if ((bp + xfer) > be)
3549                                         tsiz = be - bp;
3550                                 else
3551                                         tsiz = xfer;
3552                                 bcopy(cp, bp, tsiz);
3553                                 bp += tsiz;
3554                                 xfer -= tsiz;
3555                                 if (xfer > 0)
3556                                         cp += tsiz;
3557                         }
3558                 }
3559 invalid:
3560                 cpos += dp->d_reclen;
3561                 dp = (struct dirent *)cpos;
3562                 cookiep++;
3563                 ncookies--;
3564         }
3565         vrele(vp);
3566         vp = NULL;
3567         nfsm_clget;
3568         *tl = nfsrv_nfs_false;
3569         bp += NFSX_UNSIGNED;
3570         nfsm_clget;
3571         if (eofflag)
3572                 *tl = nfsrv_nfs_true;
3573         else
3574                 *tl = nfsrv_nfs_false;
3575         bp += NFSX_UNSIGNED;
3576         if (mp != mb) {
3577                 if (bp < be)
3578                         mp->m_len = bp - mtod(mp, caddr_t);
3579         } else
3580                 mp->m_len += bp - bpos;
3581         FREE((caddr_t)cookies, M_TEMP);
3582         FREE((caddr_t)rbuf, M_TEMP);
3583 nfsmout:
3584         if (vp)
3585                 vrele(vp);
3586         return(error);
3587 }
3588
3589 /*
3590  * nfs commit service
3591  */
3592 int
3593 nfsrv_commit(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3594     struct thread *td, struct mbuf **mrq)
3595 {
3596         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3597         struct sockaddr *nam = nfsd->nd_nam;
3598         caddr_t dpos = nfsd->nd_dpos;
3599         struct ucred *cred = &nfsd->nd_cr;
3600         struct vattr bfor, aft;
3601         struct vnode *vp = NULL;
3602         nfsfh_t nfh;
3603         fhandle_t *fhp;
3604         u_int32_t *tl;
3605         caddr_t bpos;
3606         int error = 0, rdonly, for_ret = 1, aft_ret = 1, cnt;
3607         struct mbuf *mb, *mreq;
3608         u_quad_t off;
3609         struct mount *mp = NULL;
3610         int v3 = (nfsd->nd_flag & ND_NFSV3);
3611
3612         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3613         if (!v3)
3614                 panic("nfsrv_commit: v3 proc called on a v2 connection");
3615         fhp = &nfh.fh_generic;
3616         nfsm_srvmtofh(fhp);
3617         if ((mp = vfs_getvfs(&fhp->fh_fsid)) == NULL) {
3618                 error = ESTALE;
3619                 goto ereply;
3620         }
3621         if ((error = VFS_FHTOVP(mp, &fhp->fh_fid, &vp)) != 0) {
3622                 mp = NULL;
3623                 goto ereply;
3624         }
3625         (void) vn_start_write(vp, &mp, V_WAIT);
3626         vput(vp);
3627         vp = NULL;
3628         tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
3629
3630         /*
3631          * XXX At this time VOP_FSYNC() does not accept offset and byte
3632          * count parameters, so these arguments are useless (someday maybe).
3633          */
3634         off = fxdr_hyper(tl);
3635         tl += 2;
3636         cnt = fxdr_unsigned(int, *tl);
3637         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
3638         if (error) {
3639                 nfsm_reply(2 * NFSX_UNSIGNED);
3640                 nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
3641                 error = 0;
3642                 goto nfsmout;
3643         }
3644         for_ret = VOP_GETATTR(vp, &bfor, cred, td);
3645
3646         if (cnt > MAX_COMMIT_COUNT) {
3647                 /*
3648                  * Give up and do the whole thing
3649                  */
3650                 if (vp->v_object &&
3651                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
3652                         vm_object_page_clean(vp->v_object, 0, 0, OBJPC_SYNC);
3653                 }
3654                 error = VOP_FSYNC(vp, cred, MNT_WAIT, td);
3655         } else {
3656                 /*
3657                  * Locate and synchronously write any buffers that fall
3658                  * into the requested range.  Note:  we are assuming that
3659                  * f_iosize is a power of 2.
3660                  */
3661                 int iosize = vp->v_mount->mnt_stat.f_iosize;
3662                 int iomask = iosize - 1;
3663                 int s;
3664                 daddr_t lblkno;
3665
3666                 /*
3667                  * Align to iosize boundry, super-align to page boundry.
3668                  */
3669                 if (off & iomask) {
3670                         cnt += off & iomask;
3671                         off &= ~(u_quad_t)iomask;
3672                 }
3673                 if (off & PAGE_MASK) {
3674                         cnt += off & PAGE_MASK;
3675                         off &= ~(u_quad_t)PAGE_MASK;
3676                 }
3677                 lblkno = off / iosize;
3678
3679                 if (vp->v_object &&
3680                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
3681                         vm_object_page_clean(vp->v_object, off / PAGE_SIZE, (cnt + PAGE_MASK) / PAGE_SIZE, OBJPC_SYNC);
3682                 }
3683
3684                 s = splbio();
3685                 while (cnt > 0) {
3686                         struct buf *bp;
3687
3688                         /*
3689                          * If we have a buffer and it is marked B_DELWRI we
3690                          * have to lock and write it.  Otherwise the prior
3691                          * write is assumed to have already been committed.
3692                          */
3693                         if ((bp = gbincore(vp, lblkno)) != NULL && (bp->b_flags & B_DELWRI)) {
3694                                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
3695                                         BUF_LOCK(bp, LK_EXCLUSIVE | LK_SLEEPFAIL);
3696                                         continue; /* retry */
3697                                 }
3698                                 bremfree(bp);
3699                                 bp->b_flags &= ~B_ASYNC;
3700                                 BUF_WRITE(bp);
3701                                 ++nfs_commit_miss;
3702                         }
3703                         ++nfs_commit_blks;
3704                         if (cnt < iosize)
3705                                 break;
3706                         cnt -= iosize;
3707                         ++lblkno;
3708                 }
3709                 splx(s);
3710         }
3711
3712         aft_ret = VOP_GETATTR(vp, &aft, cred, td);
3713         vput(vp);
3714         vp = NULL;
3715 ereply:
3716         nfsm_reply(NFSX_V3WCCDATA + NFSX_V3WRITEVERF);
3717         nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
3718         if (!error) {
3719                 tl = nfsm_build(u_int32_t *, NFSX_V3WRITEVERF);
3720                 if (nfsver.tv_sec == 0)
3721                         nfsver = boottime;
3722                 *tl++ = txdr_unsigned(nfsver.tv_sec);
3723                 *tl = txdr_unsigned(nfsver.tv_usec);
3724         } else {
3725                 error = 0;
3726         }
3727 nfsmout:
3728         if (vp)
3729                 vput(vp);
3730         vn_finished_write(mp);
3731         return(error);
3732 }
3733
3734 /*
3735  * nfs statfs service
3736  */
3737 int
3738 nfsrv_statfs(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3739     struct thread *td, struct mbuf **mrq)
3740 {
3741         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3742         struct sockaddr *nam = nfsd->nd_nam;
3743         caddr_t dpos = nfsd->nd_dpos;
3744         struct ucred *cred = &nfsd->nd_cr;
3745         struct statfs *sf;
3746         struct nfs_statfs *sfp;
3747         caddr_t bpos;
3748         int error = 0, rdonly, getret = 1;
3749         int v3 = (nfsd->nd_flag & ND_NFSV3);
3750         struct mbuf *mb, *mreq;
3751         struct vnode *vp = NULL;
3752         struct vattr at;
3753         nfsfh_t nfh;
3754         fhandle_t *fhp;
3755         struct statfs statfs;
3756         u_quad_t tval;
3757
3758         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3759         fhp = &nfh.fh_generic;
3760         nfsm_srvmtofh(fhp);
3761         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
3762         if (error) {
3763                 nfsm_reply(NFSX_UNSIGNED);
3764                 if (v3)
3765                         nfsm_srvpostop_attr(getret, &at);
3766                 error = 0;
3767                 goto nfsmout;
3768         }
3769         sf = &statfs;
3770         error = VFS_STATFS(vp->v_mount, sf, td);
3771         getret = VOP_GETATTR(vp, &at, cred, td);
3772         vput(vp);
3773         vp = NULL;
3774         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3));
3775         if (v3)
3776                 nfsm_srvpostop_attr(getret, &at);
3777         if (error) {
3778                 error = 0;
3779                 goto nfsmout;
3780         }
3781         sfp = nfsm_build(struct nfs_statfs *, NFSX_STATFS(v3));
3782         if (v3) {
3783                 tval = (u_quad_t)sf->f_blocks;
3784                 tval *= (u_quad_t)sf->f_bsize;
3785                 txdr_hyper(tval, &sfp->sf_tbytes);
3786                 tval = (u_quad_t)sf->f_bfree;
3787                 tval *= (u_quad_t)sf->f_bsize;
3788                 txdr_hyper(tval, &sfp->sf_fbytes);
3789                 tval = (u_quad_t)sf->f_bavail;
3790                 tval *= (u_quad_t)sf->f_bsize;
3791                 txdr_hyper(tval, &sfp->sf_abytes);
3792                 sfp->sf_tfiles.nfsuquad[0] = 0;
3793                 sfp->sf_tfiles.nfsuquad[1] = txdr_unsigned(sf->f_files);
3794                 sfp->sf_ffiles.nfsuquad[0] = 0;
3795                 sfp->sf_ffiles.nfsuquad[1] = txdr_unsigned(sf->f_ffree);
3796                 sfp->sf_afiles.nfsuquad[0] = 0;
3797                 sfp->sf_afiles.nfsuquad[1] = txdr_unsigned(sf->f_ffree);
3798                 sfp->sf_invarsec = 0;
3799         } else {
3800                 sfp->sf_tsize = txdr_unsigned(NFS_MAXDGRAMDATA);
3801                 sfp->sf_bsize = txdr_unsigned(sf->f_bsize);
3802                 sfp->sf_blocks = txdr_unsigned(sf->f_blocks);
3803                 sfp->sf_bfree = txdr_unsigned(sf->f_bfree);
3804                 sfp->sf_bavail = txdr_unsigned(sf->f_bavail);
3805         }
3806 nfsmout:
3807         if (vp)
3808                 vput(vp);
3809         return(error);
3810 }
3811
3812 /*
3813  * nfs fsinfo service
3814  */
3815 int
3816 nfsrv_fsinfo(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3817     struct thread *td, struct mbuf **mrq)
3818 {
3819         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3820         struct sockaddr *nam = nfsd->nd_nam;
3821         caddr_t dpos = nfsd->nd_dpos;
3822         struct ucred *cred = &nfsd->nd_cr;
3823         struct nfsv3_fsinfo *sip;
3824         caddr_t bpos;
3825         int error = 0, rdonly, getret = 1, pref;
3826         struct mbuf *mb, *mreq;
3827         struct vnode *vp = NULL;
3828         struct vattr at;
3829         nfsfh_t nfh;
3830         fhandle_t *fhp;
3831         u_quad_t maxfsize;
3832         struct statfs sb;
3833         int v3 = (nfsd->nd_flag & ND_NFSV3);
3834
3835         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3836         if (!v3)
3837                 panic("nfsrv_fsinfo: v3 proc called on a v2 connection");
3838         fhp = &nfh.fh_generic;
3839         nfsm_srvmtofh(fhp);
3840         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
3841         if (error) {
3842                 nfsm_reply(NFSX_UNSIGNED);
3843                 nfsm_srvpostop_attr(getret, &at);
3844                 error = 0;
3845                 goto nfsmout;
3846         }
3847
3848         /* XXX Try to make a guess on the max file size. */
3849         VFS_STATFS(vp->v_mount, &sb, td);
3850         maxfsize = (u_quad_t)0x80000000 * sb.f_bsize - 1;
3851
3852         getret = VOP_GETATTR(vp, &at, cred, td);
3853         vput(vp);
3854         vp = NULL;
3855         nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO);
3856         nfsm_srvpostop_attr(getret, &at);
3857         sip = nfsm_build(struct nfsv3_fsinfo *, NFSX_V3FSINFO);
3858
3859         /*
3860          * XXX
3861          * There should be file system VFS OP(s) to get this information.
3862          * For now, assume ufs.
3863          */
3864         if (slp->ns_so->so_type == SOCK_DGRAM)
3865                 pref = NFS_MAXDGRAMDATA;
3866         else
3867                 pref = NFS_MAXDATA;
3868         sip->fs_rtmax = txdr_unsigned(NFS_MAXDATA);
3869         sip->fs_rtpref = txdr_unsigned(pref);
3870         sip->fs_rtmult = txdr_unsigned(NFS_FABLKSIZE);
3871         sip->fs_wtmax = txdr_unsigned(NFS_MAXDATA);
3872         sip->fs_wtpref = txdr_unsigned(pref);
3873         sip->fs_wtmult = txdr_unsigned(NFS_FABLKSIZE);
3874         sip->fs_dtpref = txdr_unsigned(pref);
3875         txdr_hyper(maxfsize, &sip->fs_maxfilesize);
3876         sip->fs_timedelta.nfsv3_sec = 0;
3877         sip->fs_timedelta.nfsv3_nsec = txdr_unsigned(1);
3878         sip->fs_properties = txdr_unsigned(NFSV3FSINFO_LINK |
3879                 NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
3880                 NFSV3FSINFO_CANSETTIME);
3881 nfsmout:
3882         if (vp)
3883                 vput(vp);
3884         return(error);
3885 }
3886
3887 /*
3888  * nfs pathconf service
3889  */
3890 int
3891 nfsrv_pathconf(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3892     struct thread *td, struct mbuf **mrq)
3893 {
3894         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3895         struct sockaddr *nam = nfsd->nd_nam;
3896         caddr_t dpos = nfsd->nd_dpos;
3897         struct ucred *cred = &nfsd->nd_cr;
3898         struct nfsv3_pathconf *pc;
3899         caddr_t bpos;
3900         int error = 0, rdonly, getret = 1;
3901         register_t linkmax, namemax, chownres, notrunc;
3902         struct mbuf *mb, *mreq;
3903         struct vnode *vp = NULL;
3904         struct vattr at;
3905         nfsfh_t nfh;
3906         fhandle_t *fhp;
3907         int v3 = (nfsd->nd_flag & ND_NFSV3);
3908
3909         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3910         if (!v3)
3911                 panic("nfsrv_pathconf: v3 proc called on a v2 connection");
3912         fhp = &nfh.fh_generic;
3913         nfsm_srvmtofh(fhp);
3914         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
3915         if (error) {
3916                 nfsm_reply(NFSX_UNSIGNED);
3917                 nfsm_srvpostop_attr(getret, &at);
3918                 error = 0;
3919                 goto nfsmout;
3920         }
3921         error = VOP_PATHCONF(vp, _PC_LINK_MAX, &linkmax);
3922         if (!error)
3923                 error = VOP_PATHCONF(vp, _PC_NAME_MAX, &namemax);
3924         if (!error)
3925                 error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres);
3926         if (!error)
3927                 error = VOP_PATHCONF(vp, _PC_NO_TRUNC, &notrunc);
3928         getret = VOP_GETATTR(vp, &at, cred, td);
3929         vput(vp);
3930         vp = NULL;
3931         nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF);
3932         nfsm_srvpostop_attr(getret, &at);
3933         if (error) {
3934                 error = 0;
3935                 goto nfsmout;
3936         }
3937         pc = nfsm_build(struct nfsv3_pathconf *, NFSX_V3PATHCONF);
3938
3939         pc->pc_linkmax = txdr_unsigned(linkmax);
3940         pc->pc_namemax = txdr_unsigned(namemax);
3941         pc->pc_notrunc = txdr_unsigned(notrunc);
3942         pc->pc_chownrestricted = txdr_unsigned(chownres);
3943
3944         /*
3945          * These should probably be supported by VOP_PATHCONF(), but
3946          * until msdosfs is exportable (why would you want to?), the
3947          * Unix defaults should be ok.
3948          */
3949         pc->pc_caseinsensitive = nfsrv_nfs_false;
3950         pc->pc_casepreserving = nfsrv_nfs_true;
3951 nfsmout:
3952         if (vp)
3953                 vput(vp);
3954         return(error);
3955 }
3956
3957 /*
3958  * Null operation, used by clients to ping server
3959  */
3960 /* ARGSUSED */
3961 int
3962 nfsrv_null(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3963     struct thread *td, struct mbuf **mrq)
3964 {
3965         struct mbuf *mrep = nfsd->nd_mrep;
3966         caddr_t bpos;
3967         int error = NFSERR_RETVOID;
3968         struct mbuf *mb, *mreq;
3969
3970         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3971         nfsm_reply(0);
3972 nfsmout:
3973         return (error);
3974 }
3975
3976 /*
3977  * No operation, used for obsolete procedures
3978  */
3979 /* ARGSUSED */
3980 int
3981 nfsrv_noop(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3982     struct thread *td, struct mbuf **mrq)
3983 {
3984         struct mbuf *mrep = nfsd->nd_mrep;
3985         caddr_t bpos;
3986         int error;
3987         struct mbuf *mb, *mreq;
3988
3989         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3990         if (nfsd->nd_repstat)
3991                 error = nfsd->nd_repstat;
3992         else
3993                 error = EPROCUNAVAIL;
3994         nfsm_reply(0);
3995         error = 0;
3996 nfsmout:
3997         return (error);
3998 }
3999
4000 /*
4001  * Perform access checking for vnodes obtained from file handles that would
4002  * refer to files already opened by a Unix client. You cannot just use
4003  * vn_writechk() and VOP_ACCESS() for two reasons.
4004  * 1 - You must check for exported rdonly as well as MNT_RDONLY for the write case
4005  * 2 - The owner is to be given access irrespective of mode bits for some
4006  *     operations, so that processes that chmod after opening a file don't
4007  *     break. I don't like this because it opens a security hole, but since
4008  *     the nfs server opens a security hole the size of a barn door anyhow,
4009  *     what the heck.
4010  *
4011  * The exception to rule 2 is EPERM. If a file is IMMUTABLE, VOP_ACCESS()
4012  * will return EPERM instead of EACCESS. EPERM is always an error.
4013  */
4014 static int
4015 nfsrv_access(struct vnode *vp, int flags, struct ucred *cred, int rdonly,
4016     struct thread *td, int override)
4017 {
4018         struct vattr vattr;
4019         int error;
4020
4021         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
4022         if (flags & VWRITE) {
4023                 /* Just vn_writechk() changed to check rdonly */
4024                 /*
4025                  * Disallow write attempts on read-only file systems;
4026                  * unless the file is a socket or a block or character
4027                  * device resident on the file system.
4028                  */
4029                 if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
4030                         switch (vp->v_type) {
4031                         case VREG:
4032                         case VDIR:
4033                         case VLNK:
4034                                 return (EROFS);
4035                         default:
4036                                 break;
4037                         }
4038                 }
4039                 /*
4040                  * If there's shared text associated with
4041                  * the inode, we can't allow writing.
4042                  */
4043                 if (vp->v_flag & VTEXT)
4044                         return (ETXTBSY);
4045         }
4046         error = VOP_GETATTR(vp, &vattr, cred, td);
4047         if (error)
4048                 return (error);
4049         error = VOP_ACCESS(vp, flags, cred, td);
4050         /*
4051          * Allow certain operations for the owner (reads and writes
4052          * on files that are already open).
4053          */
4054         if (override && error == EACCES && cred->cr_uid == vattr.va_uid)
4055                 error = 0;
4056         return error;
4057 }