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.22 2004/12/29 02:41:26 dillon 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 "nfsproto.h"
  92 #include "rpcv2.h"
  93 #include "nfs.h"
  94 #include "xdr_subs.h"
  95 #include "nfsm_subs.h"
  96 #include "nqnfs.h"
  97
  98 #ifdef NFSRV_DEBUG
  99 #define nfsdbprintf(info)       printf info
 100 #else
 101 #define nfsdbprintf(info)
 102 #endif
 103
 104 #define MAX_COMMIT_COUNT        (1024 * 1024)
 105
 106 #define NUM_HEURISTIC           1017
 107 #define NHUSE_INIT              64
 108 #define NHUSE_INC               16
 109 #define NHUSE_MAX               2048
 110
 111 static struct nfsheur {
 112     struct vnode *nh_vp;        /* vp to match (unreferenced pointer) */
 113     off_t nh_nextr;             /* next offset for sequential detection */
 114     int nh_use;                 /* use count for selection */
 115     int nh_seqcount;            /* heuristic */
 116 } nfsheur[NUM_HEURISTIC];
 117
 118 nfstype nfsv3_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFSOCK,
 119                       NFFIFO, NFNON };
 120 #ifndef NFS_NOSERVER
 121 nfstype nfsv2_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON,
 122                       NFCHR, NFNON };
 123 /* Global vars */
 124 extern u_int32_t nfs_xdrneg1;
 125 extern u_int32_t nfs_false, nfs_true;
 126 extern enum vtype nv3tov_type[8];
 127 extern struct nfsstats nfsstats;
 128
 129 int nfsrvw_procrastinate = NFS_GATHERDELAY * 1000;
 130 int nfsrvw_procrastinate_v3 = 0;
 131
 132 static struct timespec  nfsver;
 133
 134 SYSCTL_DECL(_vfs_nfs);
 135
 136 static int nfs_async;
 137 SYSCTL_INT(_vfs_nfs, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0, "");
 138 static int nfs_commit_blks;
 139 static int nfs_commit_miss;
 140 SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks, 0, "");
 141 SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0, "");
 142
 143 static int nfsrv_access (struct vnode *,int,struct ucred *,int,
 144                 struct thread *, int);
 145 static void nfsrvw_coalesce (struct nfsrv_descript *,
 146                 struct nfsrv_descript *);
 147
 148 /*
 149  * nfs v3 access service
 150  */
 151 int
 152 nfsrv3_access(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 153               struct thread *td, struct mbuf **mrq)
 154 {
 155         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 156         struct sockaddr *nam = nfsd->nd_nam;
 157         caddr_t dpos = nfsd->nd_dpos;
 158         struct ucred *cred = &nfsd->nd_cr;
 159         struct vnode *vp = NULL;
 160         nfsfh_t nfh;
 161         fhandle_t *fhp;
 162         u_int32_t *tl;
 163         int32_t t1;
 164         caddr_t bpos;
 165         int error = 0, rdonly, cache, getret;
 166         char *cp2;
 167         struct mbuf *mb, *mreq, *mb2;
 168         struct vattr vattr, *vap = &vattr;
 169         u_long testmode, nfsmode;
 170         u_quad_t frev;
 171
 172         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 173 #ifndef nolint
 174         cache = 0;
 175 #endif
 176         fhp = &nfh.fh_generic;
 177         nfsm_srvmtofh(fhp);
 178         nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
 179         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly,
 180             (nfsd->nd_flag & ND_KERBAUTH), TRUE);
 181         if (error) {
 182                 nfsm_reply(NFSX_UNSIGNED);
 183                 nfsm_srvpostop_attr(1, (struct vattr *)0);
 184                 error = 0;
 185                 goto nfsmout;
 186         }
 187         nfsmode = fxdr_unsigned(u_int32_t, *tl);
 188         if ((nfsmode & NFSV3ACCESS_READ) &&
 189                 nfsrv_access(vp, VREAD, cred, rdonly, td, 0))
 190                 nfsmode &= ~NFSV3ACCESS_READ;
 191         if (vp->v_type == VDIR)
 192                 testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
 193                         NFSV3ACCESS_DELETE);
 194         else
 195                 testmode = (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
 196         if ((nfsmode & testmode) &&
 197                 nfsrv_access(vp, VWRITE, cred, rdonly, td, 0))
 198                 nfsmode &= ~testmode;
 199         if (vp->v_type == VDIR)
 200                 testmode = NFSV3ACCESS_LOOKUP;
 201         else
 202                 testmode = NFSV3ACCESS_EXECUTE;
 203         if ((nfsmode & testmode) &&
 204                 nfsrv_access(vp, VEXEC, cred, rdonly, td, 0))
 205                 nfsmode &= ~testmode;
 206         getret = VOP_GETATTR(vp, vap, td);
 207         vput(vp);
 208         vp = NULL;
 209         nfsm_reply(NFSX_POSTOPATTR(1) + NFSX_UNSIGNED);
 210         nfsm_srvpostop_attr(getret, vap);
 211         nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
 212         *tl = txdr_unsigned(nfsmode);
 213 nfsmout:
 214         if (vp)
 215                 vput(vp);
 216         return(error);
 217 }
 218
 219 /*
 220  * nfs getattr service
 221  */
 222 int
 223 nfsrv_getattr(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 224               struct thread *td, struct mbuf **mrq)
 225 {
 226         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 227         struct sockaddr *nam = nfsd->nd_nam;
 228         caddr_t dpos = nfsd->nd_dpos;
 229         struct ucred *cred = &nfsd->nd_cr;
 230         struct nfs_fattr *fp;
 231         struct vattr va;
 232         struct vattr *vap = &va;
 233         struct vnode *vp = NULL;
 234         nfsfh_t nfh;
 235         fhandle_t *fhp;
 236         u_int32_t *tl;
 237         int32_t t1;
 238         caddr_t bpos;
 239         int error = 0, rdonly, cache;
 240         char *cp2;
 241         struct mbuf *mb, *mb2, *mreq;
 242         u_quad_t frev;
 243
 244         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 245         fhp = &nfh.fh_generic;
 246         nfsm_srvmtofh(fhp);
 247         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
 248                  &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
 249         if (error) {
 250                 nfsm_reply(0);
 251                 error = 0;
 252                 goto nfsmout;
 253         }
 254         nqsrv_getl(vp, ND_READ);
 255         error = VOP_GETATTR(vp, vap, td);
 256         vput(vp);
 257         vp = NULL;
 258         nfsm_reply(NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
 259         if (error) {
 260                 error = 0;
 261                 goto nfsmout;
 262         }
 263         nfsm_build(fp, struct nfs_fattr *, NFSX_FATTR(nfsd->nd_flag & ND_NFSV3));
 264         nfsm_srvfillattr(vap, fp);
 265         /* fall through */
 266
 267 nfsmout:
 268         if (vp)
 269                 vput(vp);
 270         return(error);
 271 }
 272
 273 /*
 274  * nfs setattr service
 275  */
 276 int
 277 nfsrv_setattr(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 278               struct thread *td, struct mbuf **mrq)
 279 {
 280         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 281         struct sockaddr *nam = nfsd->nd_nam;
 282         caddr_t dpos = nfsd->nd_dpos;
 283         struct ucred *cred = &nfsd->nd_cr;
 284         struct vattr va, preat;
 285         struct vattr *vap = &va;
 286         struct nfsv2_sattr *sp;
 287         struct nfs_fattr *fp;
 288         struct vnode *vp = NULL;
 289         nfsfh_t nfh;
 290         fhandle_t *fhp;
 291         u_int32_t *tl;
 292         int32_t t1;
 293         caddr_t bpos;
 294         int error = 0, rdonly, cache, preat_ret = 1, postat_ret = 1;
 295         int v3 = (nfsd->nd_flag & ND_NFSV3), gcheck = 0;
 296         char *cp2;
 297         struct mbuf *mb, *mb2, *mreq;
 298         u_quad_t frev;
 299         struct timespec guard;
 300
 301         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 302         fhp = &nfh.fh_generic;
 303         nfsm_srvmtofh(fhp);
 304         VATTR_NULL(vap);
 305         if (v3) {
 306                 nfsm_srvsattr(vap);
 307                 nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
 308                 gcheck = fxdr_unsigned(int, *tl);
 309                 if (gcheck) {
 310                         nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 311                         fxdr_nfsv3time(tl, &guard);
 312                 }
 313         } else {
 314                 nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
 315                 /*
 316                  * Nah nah nah nah na nah
 317                  * There is a bug in the Sun client that puts 0xffff in the mode
 318                  * field of sattr when it should put in 0xffffffff. The u_short
 319                  * doesn't sign extend.
 320                  * --> check the low order 2 bytes for 0xffff
 321                  */
 322                 if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff)
 323                         vap->va_mode = nfstov_mode(sp->sa_mode);
 324                 if (sp->sa_uid != nfs_xdrneg1)
 325                         vap->va_uid = fxdr_unsigned(uid_t, sp->sa_uid);
 326                 if (sp->sa_gid != nfs_xdrneg1)
 327                         vap->va_gid = fxdr_unsigned(gid_t, sp->sa_gid);
 328                 if (sp->sa_size != nfs_xdrneg1)
 329                         vap->va_size = fxdr_unsigned(u_quad_t, sp->sa_size);
 330                 if (sp->sa_atime.nfsv2_sec != nfs_xdrneg1) {
 331 #ifdef notyet
 332                         fxdr_nfsv2time(&sp->sa_atime, &vap->va_atime);
 333 #else
 334                         vap->va_atime.tv_sec =
 335                                 fxdr_unsigned(int32_t, sp->sa_atime.nfsv2_sec);
 336                         vap->va_atime.tv_nsec = 0;
 337 #endif
 338                 }
 339                 if (sp->sa_mtime.nfsv2_sec != nfs_xdrneg1)
 340                         fxdr_nfsv2time(&sp->sa_mtime, &vap->va_mtime);
 341
 342         }
 343
 344         /*
 345          * Now that we have all the fields, lets do it.
 346          */
 347         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly,
 348                 (nfsd->nd_flag & ND_KERBAUTH), TRUE);
 349         if (error) {
 350                 nfsm_reply(2 * NFSX_UNSIGNED);
 351                 nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
 352                 error = 0;
 353                 goto nfsmout;
 354         }
 355
 356         /*
 357          * vp now an active resource, pay careful attention to cleanup
 358          */
 359
 360         nqsrv_getl(vp, ND_WRITE);
 361         if (v3) {
 362                 error = preat_ret = VOP_GETATTR(vp, &preat, td);
 363                 if (!error && gcheck &&
 364                         (preat.va_ctime.tv_sec != guard.tv_sec ||
 365                          preat.va_ctime.tv_nsec != guard.tv_nsec))
 366                         error = NFSERR_NOT_SYNC;
 367                 if (error) {
 368                         vput(vp);
 369                         vp = NULL;
 370                         nfsm_reply(NFSX_WCCDATA(v3));
 371                         nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
 372                         error = 0;
 373                         goto nfsmout;
 374                 }
 375         }
 376
 377         /*
 378          * If the size is being changed write acces is required, otherwise
 379          * just check for a read only file system.
 380          */
 381         if (vap->va_size == ((u_quad_t)((quad_t) -1))) {
 382                 if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
 383                         error = EROFS;
 384                         goto out;
 385                 }
 386         } else {
 387                 if (vp->v_type == VDIR) {
 388                         error = EISDIR;
 389                         goto out;
 390                 } else if ((error = nfsrv_access(vp, VWRITE, cred, rdonly,
 391                             td, 0)) != 0){
 392                         goto out;
 393                 }
 394         }
 395         error = VOP_SETATTR(vp, vap, cred, td);
 396         postat_ret = VOP_GETATTR(vp, vap, td);
 397         if (!error)
 398                 error = postat_ret;
 399 out:
 400         vput(vp);
 401         vp = NULL;
 402         nfsm_reply(NFSX_WCCORFATTR(v3));
 403         if (v3) {
 404                 nfsm_srvwcc_data(preat_ret, &preat, postat_ret, vap);
 405                 error = 0;
 406                 goto nfsmout;
 407         } else {
 408                 nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
 409                 nfsm_srvfillattr(vap, fp);
 410         }
 411         /* fall through */
 412
 413 nfsmout:
 414         if (vp)
 415                 vput(vp);
 416         return(error);
 417 }
 418
 419 /*
 420  * nfs lookup rpc
 421  */
 422 int
 423 nfsrv_lookup(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 424              struct thread *td, struct mbuf **mrq)
 425 {
 426         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 427         struct sockaddr *nam = nfsd->nd_nam;
 428         caddr_t dpos = nfsd->nd_dpos;
 429         struct ucred *cred = &nfsd->nd_cr;
 430         struct nfs_fattr *fp;
 431         struct nlookupdata nd;
 432         struct vnode *vp;
 433         struct vnode *dirp;
 434         struct namecache *ncp;
 435         nfsfh_t nfh;
 436         fhandle_t *fhp;
 437         caddr_t cp;
 438         u_int32_t *tl;
 439         int32_t t1;
 440         caddr_t bpos;
 441         int error = 0, cache = 0, len, dirattr_ret = 1;
 442         int v3 = (nfsd->nd_flag & ND_NFSV3), pubflag;
 443         char *cp2;
 444         struct mbuf *mb, *mb2, *mreq;
 445         struct vattr va, dirattr, *vap = &va;
 446         u_quad_t frev;
 447
 448         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 449         nlookup_zero(&nd);
 450         dirp = NULL;
 451         vp = NULL;
 452
 453         fhp = &nfh.fh_generic;
 454         nfsm_srvmtofh(fhp);
 455         nfsm_srvnamesiz(len);
 456
 457         pubflag = nfs_ispublicfh(fhp);
 458
 459         error = nfs_namei(&nd, cred, NAMEI_LOOKUP, NULL, &vp,
 460                 fhp, len, slp, nam, &md, &dpos,
 461                 &dirp, td, (nfsd->nd_flag & ND_KERBAUTH), pubflag);
 462
 463         /*
 464          * namei failure, only dirp to cleanup.  Clear out garbarge from
 465          * structure in case macros jump to nfsmout.
 466          */
 467
 468         if (error) {
 469                 if (dirp) {
 470                         if (v3)
 471                                 dirattr_ret = VOP_GETATTR(dirp, &dirattr, td);
 472                         vrele(dirp);
 473                         dirp = NULL;
 474                 }
 475                 nfsm_reply(NFSX_POSTOPATTR(v3));
 476                 nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 477                 error = 0;
 478                 goto nfsmout;
 479         }
 480
 481         /*
 482          * Locate index file for public filehandle
 483          *
 484          * error is 0 on entry and 0 on exit from this block.
 485          */
 486
 487         if (pubflag) {
 488                 if (vp->v_type == VDIR && nfs_pub.np_index != NULL) {
 489                         /*
 490                          * Setup call to lookup() to see if we can find
 491                          * the index file. Arguably, this doesn't belong
 492                          * in a kernel.. Ugh.  If an error occurs, do not
 493                          * try to install an index file and then clear the
 494                          * error.
 495                          *
 496                          * When we replace nd with ind and redirect ndp,
 497                          * maintenance of ni_startdir and ni_vp shift to
 498                          * ind and we have to clean them up in the old nd.
 499                          * However, the cnd resource continues to be maintained
 500                          * via the original nd.  Confused?  You aren't alone!
 501                          */
 502                         VOP_UNLOCK(vp, 0, td);
 503                         ncp = cache_hold(nd.nl_ncp);
 504                         nlookup_done(&nd);
 505                         error = nlookup_init_raw(&nd, nfs_pub.np_index,
 506                                                 UIO_SYSSPACE, 0, cred, ncp);
 507                         cache_drop(ncp);
 508                         if (error == 0)
 509                                 error = nlookup(&nd);
 510
 511                         if (error == 0) {
 512                                 /*
 513                                  * Found an index file. Get rid of
 514                                  * the old references.  transfer vp and
 515                                  * load up the new vp.  Fortunately we do
 516                                  * not have to deal with dvp, that would be
 517                                  * a huge mess.
 518                                  */
 519                                 if (dirp)
 520                                         vrele(dirp);
 521                                 dirp = vp;
 522                                 vp = NULL;
 523                                 error = cache_vget(nd.nl_ncp, nd.nl_cred,
 524                                                         LK_EXCLUSIVE, &vp);
 525                                 KKASSERT(error == 0);
 526                         }
 527                         error = 0;
 528                 }
 529                 /*
 530                  * If the public filehandle was used, check that this lookup
 531                  * didn't result in a filehandle outside the publicly exported
 532                  * filesystem.  We clear the poor vp here to avoid lockups due
 533                  * to NFS I/O.
 534                  */
 535
 536                 if (vp->v_mount != nfs_pub.np_mount) {
 537                         vput(vp);
 538                         vp = NULL;
 539                         error = EPERM;
 540                 }
 541         }
 542
 543         if (dirp) {
 544                 if (v3)
 545                         dirattr_ret = VOP_GETATTR(dirp, &dirattr, td);
 546                 vrele(dirp);
 547                 dirp = NULL;
 548         }
 549
 550         /*
 551          * Resources at this point:
 552          *      ndp->ni_vp      may not be NULL
 553          *
 554          */
 555
 556         if (error) {
 557                 nfsm_reply(NFSX_POSTOPATTR(v3));
 558                 nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 559                 error = 0;
 560                 goto nfsmout;
 561         }
 562
 563 #if 0
 564         /* XXX not sure how to deal with this */
 565         nqsrv_getl(ndp->ni_startdir, ND_READ);
 566 #endif
 567
 568         /*
 569          * Clear out some resources prior to potentially blocking.  This
 570          * is not as critical as ni_dvp resources in other routines, but
 571          * it helps.
 572          */
 573         nlookup_done(&nd);
 574
 575         /*
 576          * Get underlying attribute, then release remaining resources ( for
 577          * the same potential blocking reason ) and reply.
 578          */
 579         bzero((caddr_t)fhp, sizeof(nfh));
 580         fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid;
 581         error = VFS_VPTOFH(vp, &fhp->fh_fid);
 582         if (!error)
 583                 error = VOP_GETATTR(vp, vap, td);
 584
 585         vput(vp);
 586         vp = NULL;
 587         nfsm_reply(NFSX_SRVFH(v3) + NFSX_POSTOPORFATTR(v3) + NFSX_POSTOPATTR(v3));
 588         if (error) {
 589                 nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 590                 error = 0;
 591                 goto nfsmout;
 592         }
 593         nfsm_srvfhtom(fhp, v3);
 594         if (v3) {
 595                 nfsm_srvpostop_attr(0, vap);
 596                 nfsm_srvpostop_attr(dirattr_ret, &dirattr);
 597         } else {
 598                 nfsm_build(fp, struct nfs_fattr *, NFSX_V2FATTR);
 599                 nfsm_srvfillattr(vap, fp);
 600         }
 601
 602 nfsmout:
 603         if (dirp)
 604                 vrele(dirp);
 605         nlookup_done(&nd);              /* may be called twice */
 606         if (vp)
 607                 vput(vp);
 608         return (error);
 609 }
 610
 611 /*
 612  * nfs readlink service
 613  */
 614 int
 615 nfsrv_readlink(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 616                struct thread *td, struct mbuf **mrq)
 617 {
 618         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 619         struct sockaddr *nam = nfsd->nd_nam;
 620         caddr_t dpos = nfsd->nd_dpos;
 621         struct ucred *cred = &nfsd->nd_cr;
 622         struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN];
 623         struct iovec *ivp = iv;
 624         struct mbuf *mp;
 625         u_int32_t *tl;
 626         int32_t t1;
 627         caddr_t bpos;
 628         int error = 0, rdonly, cache, i, tlen, len, getret;
 629         int v3 = (nfsd->nd_flag & ND_NFSV3);
 630         char *cp2;
 631         struct mbuf *mb, *mb2, *mp2, *mp3, *mreq;
 632         struct vnode *vp = NULL;
 633         struct vattr attr;
 634         nfsfh_t nfh;
 635         fhandle_t *fhp;
 636         struct uio io, *uiop = &io;
 637         u_quad_t frev;
 638
 639         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 640 #ifndef nolint
 641         mp2 = (struct mbuf *)0;
 642 #endif
 643         mp3 = NULL;
 644         fhp = &nfh.fh_generic;
 645         nfsm_srvmtofh(fhp);
 646         len = 0;
 647         i = 0;
 648         while (len < NFS_MAXPATHLEN) {
 649                 MGET(mp, MB_WAIT, MT_DATA);
 650                 MCLGET(mp, MB_WAIT);
 651                 mp->m_len = NFSMSIZ(mp);
 652                 if (len == 0)
 653                         mp3 = mp2 = mp;
 654                 else {
 655                         mp2->m_next = mp;
 656                         mp2 = mp;
 657                 }
 658                 if ((len+mp->m_len) > NFS_MAXPATHLEN) {
 659                         mp->m_len = NFS_MAXPATHLEN-len;
 660                         len = NFS_MAXPATHLEN;
 661                 } else
 662                         len += mp->m_len;
 663                 ivp->iov_base = mtod(mp, caddr_t);
 664                 ivp->iov_len = mp->m_len;
 665                 i++;
 666                 ivp++;
 667         }
 668         uiop->uio_iov = iv;
 669         uiop->uio_iovcnt = i;
 670         uiop->uio_offset = 0;
 671         uiop->uio_resid = len;
 672         uiop->uio_rw = UIO_READ;
 673         uiop->uio_segflg = UIO_SYSSPACE;
 674         uiop->uio_td = NULL;
 675         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
 676                  &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
 677         if (error) {
 678                 nfsm_reply(2 * NFSX_UNSIGNED);
 679                 nfsm_srvpostop_attr(1, (struct vattr *)0);
 680                 error = 0;
 681                 goto nfsmout;
 682         }
 683         if (vp->v_type != VLNK) {
 684                 if (v3)
 685                         error = EINVAL;
 686                 else
 687                         error = ENXIO;
 688                 goto out;
 689         }
 690         nqsrv_getl(vp, ND_READ);
 691         error = VOP_READLINK(vp, uiop, cred);
 692 out:
 693         getret = VOP_GETATTR(vp, &attr, td);
 694         vput(vp);
 695         vp = NULL;
 696         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_UNSIGNED);
 697         if (v3) {
 698                 nfsm_srvpostop_attr(getret, &attr);
 699                 if (error) {
 700                         error = 0;
 701                         goto nfsmout;
 702                 }
 703         }
 704         if (uiop->uio_resid > 0) {
 705                 len -= uiop->uio_resid;
 706                 tlen = nfsm_rndup(len);
 707                 nfsm_adj(mp3, NFS_MAXPATHLEN-tlen, tlen-len);
 708         }
 709         nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
 710         *tl = txdr_unsigned(len);
 711         mb->m_next = mp3;
 712         mp3 = NULL;
 713 nfsmout:
 714         if (mp3)
 715                 m_freem(mp3);
 716         if (vp)
 717                 vput(vp);
 718         return(error);
 719 }
 720
 721 /*
 722  * nfs read service
 723  */
 724 int
 725 nfsrv_read(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 726            struct thread *td, struct mbuf **mrq)
 727 {
 728         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
 729         struct sockaddr *nam = nfsd->nd_nam;
 730         caddr_t dpos = nfsd->nd_dpos;
 731         struct ucred *cred = &nfsd->nd_cr;
 732         struct iovec *iv;
 733         struct iovec *iv2;
 734         struct mbuf *m;
 735         struct nfs_fattr *fp;
 736         u_int32_t *tl;
 737         int32_t t1;
 738         int i;
 739         caddr_t bpos;
 740         int error = 0, rdonly, cache, cnt, len, left, siz, tlen, getret;
 741         int v3 = (nfsd->nd_flag & ND_NFSV3), reqlen;
 742         char *cp2;
 743         struct mbuf *mb, *mb2, *mreq;
 744         struct mbuf *m2;
 745         struct vnode *vp = NULL;
 746         nfsfh_t nfh;
 747         fhandle_t *fhp;
 748         struct uio io, *uiop = &io;
 749         struct vattr va, *vap = &va;
 750         struct nfsheur *nh;
 751         off_t off;
 752         int ioflag = 0;
 753         u_quad_t frev;
 754
 755         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
 756         fhp = &nfh.fh_generic;
 757         nfsm_srvmtofh(fhp);
 758         if (v3) {
 759                 nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 760                 off = fxdr_hyper(tl);
 761         } else {
 762                 nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
 763                 off = (off_t)fxdr_unsigned(u_int32_t, *tl);
 764         }
 765         nfsm_srvstrsiz(reqlen, NFS_SRVMAXDATA(nfsd));
 766
 767         /*
 768          * Reference vp.  If an error occurs, vp will be invalid, but we
 769          * have to NULL it just in case.  The macros might goto nfsmout
 770          * as well.
 771          */
 772
 773         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
 774                  &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
 775         if (error) {
 776                 vp = NULL;
 777                 nfsm_reply(2 * NFSX_UNSIGNED);
 778                 nfsm_srvpostop_attr(1, (struct vattr *)0);
 779                 error = 0;
 780                 goto nfsmout;
 781         }
 782
 783         if (vp->v_type != VREG) {
 784                 if (v3)
 785                         error = EINVAL;
 786                 else
 787                         error = (vp->v_type == VDIR) ? EISDIR : EACCES;
 788         }
 789         if (!error) {
 790             nqsrv_getl(vp, ND_READ);
 791             if ((error = nfsrv_access(vp, VREAD, cred, rdonly, td, 1)) != 0)
 792                 error = nfsrv_access(vp, VEXEC, cred, rdonly, td, 1);
 793         }
 794         getret = VOP_GETATTR(vp, vap, td);
 795         if (!error)
 796                 error = getret;
 797         if (error) {
 798                 vput(vp);
 799                 vp = NULL;
 800                 nfsm_reply(NFSX_POSTOPATTR(v3));
 801                 nfsm_srvpostop_attr(getret, vap);
 802                 error = 0;
 803                 goto nfsmout;
 804         }
 805
 806         /*
 807          * Calculate byte count to read
 808          */
 809
 810         if (off >= vap->va_size)
 811                 cnt = 0;
 812         else if ((off + reqlen) > vap->va_size)
 813                 cnt = vap->va_size - off;
 814         else
 815                 cnt = reqlen;
 816
 817         /*
 818          * Calculate seqcount for heuristic
 819          */
 820
 821         {
 822                 int hi;
 823                 int try = 32;
 824
 825                 /*
 826                  * Locate best candidate
 827                  */
 828
 829                 hi = ((int)(vm_offset_t)vp / sizeof(struct vnode)) % NUM_HEURISTIC;
 830                 nh = &nfsheur[hi];
 831
 832                 while (try--) {
 833                         if (nfsheur[hi].nh_vp == vp) {
 834                                 nh = &nfsheur[hi];
 835                                 break;
 836                         }
 837                         if (nfsheur[hi].nh_use > 0)
 838                                 --nfsheur[hi].nh_use;
 839                         hi = (hi + 1) % NUM_HEURISTIC;
 840                         if (nfsheur[hi].nh_use < nh->nh_use)
 841                                 nh = &nfsheur[hi];
 842                 }
 843
 844                 if (nh->nh_vp != vp) {
 845                         nh->nh_vp = vp;
 846                         nh->nh_nextr = off;
 847                         nh->nh_use = NHUSE_INIT;
 848                         if (off == 0)
 849                                 nh->nh_seqcount = 4;
 850                         else
 851                                 nh->nh_seqcount = 1;
 852                 }
 853
 854                 /*
 855                  * Calculate heuristic
 856                  */
 857
 858                 if ((off == 0 && nh->nh_seqcount > 0) || off == nh->nh_nextr) {
 859                         if (++nh->nh_seqcount > IO_SEQMAX)
 860                                 nh->nh_seqcount = IO_SEQMAX;
 861                 } else if (nh->nh_seqcount > 1) {
 862                         nh->nh_seqcount = 1;
 863                 } else {
 864                         nh->nh_seqcount = 0;
 865                 }
 866                 nh->nh_use += NHUSE_INC;
 867                 if (nh->nh_use > NHUSE_MAX)
 868                         nh->nh_use = NHUSE_MAX;
 869                 ioflag |= nh->nh_seqcount << IO_SEQSHIFT;
 870         }
 871
 872         nfsm_reply(NFSX_POSTOPORFATTR(v3) + 3 * NFSX_UNSIGNED+nfsm_rndup(cnt));
 873         if (v3) {
 874                 nfsm_build(tl, u_int32_t *, NFSX_V3FATTR + 4 * NFSX_UNSIGNED);
 875                 *tl++ = nfs_true;
 876                 fp = (struct nfs_fattr *)tl;
 877                 tl += (NFSX_V3FATTR / sizeof (u_int32_t));
 878         } else {
 879                 nfsm_build(tl, u_int32_t *, NFSX_V2FATTR + NFSX_UNSIGNED);
 880                 fp = (struct nfs_fattr *)tl;
 881                 tl += (NFSX_V2FATTR / sizeof (u_int32_t));
 882         }
 883         len = left = nfsm_rndup(cnt);
 884         if (cnt > 0) {
 885                 /*
 886                  * Generate the mbuf list with the uio_iov ref. to it.
 887                  */
 888                 i = 0;
 889                 m = m2 = mb;
 890                 while (left > 0) {
 891                         siz = min(M_TRAILINGSPACE(m), left);
 892                         if (siz > 0) {
 893                                 left -= siz;
 894                                 i++;
 895                         }
 896                         if (left > 0) {
 897                                 MGET(m, MB_WAIT, MT_DATA);
 898                                 MCLGET(m, MB_WAIT);
 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, s, 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             s = splsoftclock();
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             splx(s);
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         s = splsoftclock();
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                 splx(s);
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                     s = splsoftclock();
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                     splx(s);
1469                 } while (nfsd);
1470                 s = splsoftclock();
1471                 swp->nd_time = 0;
1472                 LIST_INSERT_HEAD(&slp->ns_tq, swp, nd_tq);
1473                 splx(s);
1474                 goto loop1;
1475         }
1476         splx(s);
1477
1478         /*
1479          * Search for a reply to return.
1480          */
1481         s = splsoftclock();
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         splx(s);
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_fileno == 0 || dp->d_type == DT_WHT ||
2988                  ((u_quad_t)(*cookiep)) <= toff)) {
2989                 cpos += dp->d_reclen;
2990                 dp = (struct dirent *)cpos;
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_fileno != 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_fileno);
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                 cpos += dp->d_reclen;
3072                 dp = (struct dirent *)cpos;
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_fileno == 0 || dp->d_type == DT_WHT ||
3261                  ((u_quad_t)(*cookiep)) <= toff)) {
3262                 cpos += dp->d_reclen;
3263                 dp = (struct dirent *)cpos;
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_fileno, &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_fileno != 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_fileno, &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_fileno);
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                 cpos += dp->d_reclen;
3408                 dp = (struct dirent *)cpos;
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                 int s;
3502                 daddr_t lblkno;
3503
3504                 /*
3505                  * Align to iosize boundry, super-align to page boundry.
3506                  */
3507                 if (off & iomask) {
3508                         cnt += off & iomask;
3509                         off &= ~(u_quad_t)iomask;
3510                 }
3511                 if (off & PAGE_MASK) {
3512                         cnt += off & PAGE_MASK;
3513                         off &= ~(u_quad_t)PAGE_MASK;
3514                 }
3515                 lblkno = off / iosize;
3516
3517                 if (vp->v_object &&
3518                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
3519                         vm_object_page_clean(vp->v_object, off / PAGE_SIZE, (cnt + PAGE_MASK) / PAGE_SIZE, OBJPC_SYNC);
3520                 }
3521
3522                 s = splbio();
3523                 while (cnt > 0) {
3524                         struct buf *bp;
3525
3526                         /*
3527                          * If we have a buffer and it is marked B_DELWRI we
3528                          * have to lock and write it.  Otherwise the prior
3529                          * write is assumed to have already been committed.
3530                          */
3531                         if ((bp = gbincore(vp, lblkno)) != NULL && (bp->b_flags & B_DELWRI)) {
3532                                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) {
3533                                         BUF_LOCK(bp, LK_EXCLUSIVE | LK_SLEEPFAIL);
3534                                         continue; /* retry */
3535                                 }
3536                                 bremfree(bp);
3537                                 bp->b_flags &= ~B_ASYNC;
3538                                 VOP_BWRITE(bp->b_vp, bp);
3539                                 ++nfs_commit_miss;
3540                         }
3541                         ++nfs_commit_blks;
3542                         if (cnt < iosize)
3543                                 break;
3544                         cnt -= iosize;
3545                         ++lblkno;
3546                 }
3547                 splx(s);
3548         }
3549
3550         aft_ret = VOP_GETATTR(vp, &aft, td);
3551         vput(vp);
3552         vp = NULL;
3553         nfsm_reply(NFSX_V3WCCDATA + NFSX_V3WRITEVERF);
3554         nfsm_srvwcc_data(for_ret, &bfor, aft_ret, &aft);
3555         if (!error) {
3556                 nfsm_build(tl, u_int32_t *, NFSX_V3WRITEVERF);
3557                 if (nfsver.tv_sec == 0)
3558                         nfsver = boottime;
3559                 *tl++ = txdr_unsigned(nfsver.tv_sec);
3560                 *tl = txdr_unsigned(nfsver.tv_nsec / 1000);
3561         } else {
3562                 error = 0;
3563         }
3564 nfsmout:
3565         if (vp)
3566                 vput(vp);
3567         return(error);
3568 }
3569
3570 /*
3571  * nfs statfs service
3572  */
3573 int
3574 nfsrv_statfs(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3575              struct thread *td, struct mbuf **mrq)
3576 {
3577         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3578         struct sockaddr *nam = nfsd->nd_nam;
3579         caddr_t dpos = nfsd->nd_dpos;
3580         struct ucred *cred = &nfsd->nd_cr;
3581         struct statfs *sf;
3582         struct nfs_statfs *sfp;
3583         u_int32_t *tl;
3584         int32_t t1;
3585         caddr_t bpos;
3586         int error = 0, rdonly, cache, getret = 1;
3587         int v3 = (nfsd->nd_flag & ND_NFSV3);
3588         char *cp2;
3589         struct mbuf *mb, *mb2, *mreq;
3590         struct vnode *vp = NULL;
3591         struct vattr at;
3592         nfsfh_t nfh;
3593         fhandle_t *fhp;
3594         struct statfs statfs;
3595         u_quad_t frev, tval;
3596
3597         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3598 #ifndef nolint
3599         cache = 0;
3600 #endif
3601         fhp = &nfh.fh_generic;
3602         nfsm_srvmtofh(fhp);
3603         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3604                  &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
3605         if (error) {
3606                 nfsm_reply(NFSX_UNSIGNED);
3607                 nfsm_srvpostop_attr(getret, &at);
3608                 error = 0;
3609                 goto nfsmout;
3610         }
3611         sf = &statfs;
3612         error = VFS_STATFS(vp->v_mount, sf, td);
3613         getret = VOP_GETATTR(vp, &at, td);
3614         vput(vp);
3615         vp = NULL;
3616         nfsm_reply(NFSX_POSTOPATTR(v3) + NFSX_STATFS(v3));
3617         if (v3)
3618                 nfsm_srvpostop_attr(getret, &at);
3619         if (error) {
3620                 error = 0;
3621                 goto nfsmout;
3622         }
3623         nfsm_build(sfp, struct nfs_statfs *, NFSX_STATFS(v3));
3624         if (v3) {
3625                 tval = (u_quad_t)sf->f_blocks;
3626                 tval *= (u_quad_t)sf->f_bsize;
3627                 txdr_hyper(tval, &sfp->sf_tbytes);
3628                 tval = (u_quad_t)sf->f_bfree;
3629                 tval *= (u_quad_t)sf->f_bsize;
3630                 txdr_hyper(tval, &sfp->sf_fbytes);
3631                 tval = (u_quad_t)sf->f_bavail;
3632                 tval *= (u_quad_t)sf->f_bsize;
3633                 txdr_hyper(tval, &sfp->sf_abytes);
3634                 sfp->sf_tfiles.nfsuquad[0] = 0;
3635                 sfp->sf_tfiles.nfsuquad[1] = txdr_unsigned(sf->f_files);
3636                 sfp->sf_ffiles.nfsuquad[0] = 0;
3637                 sfp->sf_ffiles.nfsuquad[1] = txdr_unsigned(sf->f_ffree);
3638                 sfp->sf_afiles.nfsuquad[0] = 0;
3639                 sfp->sf_afiles.nfsuquad[1] = txdr_unsigned(sf->f_ffree);
3640                 sfp->sf_invarsec = 0;
3641         } else {
3642                 sfp->sf_tsize = txdr_unsigned(NFS_MAXDGRAMDATA);
3643                 sfp->sf_bsize = txdr_unsigned(sf->f_bsize);
3644                 sfp->sf_blocks = txdr_unsigned(sf->f_blocks);
3645                 sfp->sf_bfree = txdr_unsigned(sf->f_bfree);
3646                 sfp->sf_bavail = txdr_unsigned(sf->f_bavail);
3647         }
3648 nfsmout:
3649         if (vp)
3650                 vput(vp);
3651         return(error);
3652 }
3653
3654 /*
3655  * nfs fsinfo service
3656  */
3657 int
3658 nfsrv_fsinfo(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3659              struct thread *td, struct mbuf **mrq)
3660 {
3661         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3662         struct sockaddr *nam = nfsd->nd_nam;
3663         caddr_t dpos = nfsd->nd_dpos;
3664         struct ucred *cred = &nfsd->nd_cr;
3665         u_int32_t *tl;
3666         struct nfsv3_fsinfo *sip;
3667         int32_t t1;
3668         caddr_t bpos;
3669         int error = 0, rdonly, cache, getret = 1, pref;
3670         char *cp2;
3671         struct mbuf *mb, *mb2, *mreq;
3672         struct vnode *vp = NULL;
3673         struct vattr at;
3674         nfsfh_t nfh;
3675         fhandle_t *fhp;
3676         u_quad_t frev, maxfsize;
3677         struct statfs sb;
3678
3679         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3680 #ifndef nolint
3681         cache = 0;
3682 #endif
3683         fhp = &nfh.fh_generic;
3684         nfsm_srvmtofh(fhp);
3685         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3686                  &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
3687         if (error) {
3688                 nfsm_reply(NFSX_UNSIGNED);
3689                 nfsm_srvpostop_attr(getret, &at);
3690                 error = 0;
3691                 goto nfsmout;
3692         }
3693
3694         /* XXX Try to make a guess on the max file size. */
3695         VFS_STATFS(vp->v_mount, &sb, td);
3696         maxfsize = (u_quad_t)0x80000000 * sb.f_bsize - 1;
3697
3698         getret = VOP_GETATTR(vp, &at, td);
3699         vput(vp);
3700         vp = NULL;
3701         nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3FSINFO);
3702         nfsm_srvpostop_attr(getret, &at);
3703         nfsm_build(sip, struct nfsv3_fsinfo *, NFSX_V3FSINFO);
3704
3705         /*
3706          * XXX
3707          * There should be file system VFS OP(s) to get this information.
3708          * For now, assume ufs.
3709          */
3710         if (slp->ns_so->so_type == SOCK_DGRAM)
3711                 pref = NFS_MAXDGRAMDATA;
3712         else
3713                 pref = NFS_MAXDATA;
3714         sip->fs_rtmax = txdr_unsigned(NFS_MAXDATA);
3715         sip->fs_rtpref = txdr_unsigned(pref);
3716         sip->fs_rtmult = txdr_unsigned(NFS_FABLKSIZE);
3717         sip->fs_wtmax = txdr_unsigned(NFS_MAXDATA);
3718         sip->fs_wtpref = txdr_unsigned(pref);
3719         sip->fs_wtmult = txdr_unsigned(NFS_FABLKSIZE);
3720         sip->fs_dtpref = txdr_unsigned(pref);
3721         txdr_hyper(maxfsize, &sip->fs_maxfilesize);
3722         sip->fs_timedelta.nfsv3_sec = 0;
3723         sip->fs_timedelta.nfsv3_nsec = txdr_unsigned(1);
3724         sip->fs_properties = txdr_unsigned(NFSV3FSINFO_LINK |
3725                 NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
3726                 NFSV3FSINFO_CANSETTIME);
3727 nfsmout:
3728         if (vp)
3729                 vput(vp);
3730         return(error);
3731 }
3732
3733 /*
3734  * nfs pathconf service
3735  */
3736 int
3737 nfsrv_pathconf(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3738                struct thread *td, struct mbuf **mrq)
3739 {
3740         struct mbuf *mrep = nfsd->nd_mrep, *md = nfsd->nd_md;
3741         struct sockaddr *nam = nfsd->nd_nam;
3742         caddr_t dpos = nfsd->nd_dpos;
3743         struct ucred *cred = &nfsd->nd_cr;
3744         u_int32_t *tl;
3745         struct nfsv3_pathconf *pc;
3746         int32_t t1;
3747         caddr_t bpos;
3748         int error = 0, rdonly, cache, getret = 1;
3749         register_t linkmax, namemax, chownres, notrunc;
3750         char *cp2;
3751         struct mbuf *mb, *mb2, *mreq;
3752         struct vnode *vp = NULL;
3753         struct vattr at;
3754         nfsfh_t nfh;
3755         fhandle_t *fhp;
3756         u_quad_t frev;
3757
3758         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3759 #ifndef nolint
3760         cache = 0;
3761 #endif
3762         fhp = &nfh.fh_generic;
3763         nfsm_srvmtofh(fhp);
3764         error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam,
3765                  &rdonly, (nfsd->nd_flag & ND_KERBAUTH), TRUE);
3766         if (error) {
3767                 nfsm_reply(NFSX_UNSIGNED);
3768                 nfsm_srvpostop_attr(getret, &at);
3769                 error = 0;
3770                 goto nfsmout;
3771         }
3772         error = VOP_PATHCONF(vp, _PC_LINK_MAX, &linkmax);
3773         if (!error)
3774                 error = VOP_PATHCONF(vp, _PC_NAME_MAX, &namemax);
3775         if (!error)
3776                 error = VOP_PATHCONF(vp, _PC_CHOWN_RESTRICTED, &chownres);
3777         if (!error)
3778                 error = VOP_PATHCONF(vp, _PC_NO_TRUNC, &notrunc);
3779         getret = VOP_GETATTR(vp, &at, td);
3780         vput(vp);
3781         vp = NULL;
3782         nfsm_reply(NFSX_V3POSTOPATTR + NFSX_V3PATHCONF);
3783         nfsm_srvpostop_attr(getret, &at);
3784         if (error) {
3785                 error = 0;
3786                 goto nfsmout;
3787         }
3788         nfsm_build(pc, struct nfsv3_pathconf *, NFSX_V3PATHCONF);
3789
3790         pc->pc_linkmax = txdr_unsigned(linkmax);
3791         pc->pc_namemax = txdr_unsigned(namemax);
3792         pc->pc_notrunc = txdr_unsigned(notrunc);
3793         pc->pc_chownrestricted = txdr_unsigned(chownres);
3794
3795         /*
3796          * These should probably be supported by VOP_PATHCONF(), but
3797          * until msdosfs is exportable (why would you want to?), the
3798          * Unix defaults should be ok.
3799          */
3800         pc->pc_caseinsensitive = nfs_false;
3801         pc->pc_casepreserving = nfs_true;
3802 nfsmout:
3803         if (vp)
3804                 vput(vp);
3805         return(error);
3806 }
3807
3808 /*
3809  * Null operation, used by clients to ping server
3810  */
3811 /* ARGSUSED */
3812 int
3813 nfsrv_null(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3814            struct thread *td, struct mbuf **mrq)
3815 {
3816         struct mbuf *mrep = nfsd->nd_mrep;
3817         caddr_t bpos;
3818         int error = NFSERR_RETVOID, cache;
3819         struct mbuf *mb, *mreq;
3820         u_quad_t frev;
3821
3822         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3823 #ifndef nolint
3824         cache = 0;
3825 #endif
3826         nfsm_reply(0);
3827         nfsm_srvdone;
3828 }
3829
3830 /*
3831  * No operation, used for obsolete procedures
3832  */
3833 /* ARGSUSED */
3834 int
3835 nfsrv_noop(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
3836            struct thread *td, struct mbuf **mrq)
3837 {
3838         struct mbuf *mrep = nfsd->nd_mrep;
3839         caddr_t bpos;
3840         int error, cache;
3841         struct mbuf *mb, *mreq;
3842         u_quad_t frev;
3843
3844         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3845 #ifndef nolint
3846         cache = 0;
3847 #endif
3848         if (nfsd->nd_repstat)
3849                 error = nfsd->nd_repstat;
3850         else
3851                 error = EPROCUNAVAIL;
3852         nfsm_reply(0);
3853         error = 0;
3854         nfsm_srvdone;
3855 }
3856
3857 /*
3858  * Perform access checking for vnodes obtained from file handles that would
3859  * refer to files already opened by a Unix client. You cannot just use
3860  * vn_writechk() and VOP_ACCESS() for two reasons.
3861  * 1 - You must check for exported rdonly as well as MNT_RDONLY for the write case
3862  * 2 - The owner is to be given access irrespective of mode bits for some
3863  *     operations, so that processes that chmod after opening a file don't
3864  *     break. I don't like this because it opens a security hole, but since
3865  *     the nfs server opens a security hole the size of a barn door anyhow,
3866  *     what the heck.
3867  *
3868  * The exception to rule 2 is EPERM. If a file is IMMUTABLE, VOP_ACCESS()
3869  * will return EPERM instead of EACCESS. EPERM is always an error.
3870  */
3871 static int
3872 nfsrv_access(struct vnode *vp, int flags, struct ucred *cred,
3873              int rdonly, struct thread *td, int override)
3874 {
3875         struct vattr vattr;
3876         int error;
3877
3878         nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
3879         if (flags & VWRITE) {
3880                 /* Just vn_writechk() changed to check rdonly */
3881                 /*
3882                  * Disallow write attempts on read-only file systems;
3883                  * unless the file is a socket or a block or character
3884                  * device resident on the file system.
3885                  */
3886                 if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) {
3887                         switch (vp->v_type) {
3888                         case VREG:
3889                         case VDIR:
3890                         case VLNK:
3891                                 return (EROFS);
3892                         default:
3893                                 break;
3894                         }
3895                 }
3896                 /*
3897                  * If there's shared text associated with
3898                  * the inode, we can't allow writing.
3899                  */
3900                 if (vp->v_flag & VTEXT)
3901                         return (ETXTBSY);
3902         }
3903         error = VOP_GETATTR(vp, &vattr, td);
3904         if (error)
3905                 return (error);
3906         error = VOP_ACCESS(vp, flags, cred, td);
3907         /*
3908          * Allow certain operations for the owner (reads and writes
3909          * on files that are already open).
3910          */
3911         if (override && error == EACCES && cred->cr_uid == vattr.va_uid)
3912                 error = 0;
3913         return error;
3914 }
3915 #endif /* NFS_NOSERVER */
3916