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