The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/nfs/nfs_subs.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: nfs_subs.c,v 1.132.2.5 2005/03/16 11:54:49 tron Exp $  */
    2 
    3 /*
    4  * Copyright (c) 1989, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * This code is derived from software contributed to Berkeley by
    8  * Rick Macklem at The University of Guelph.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)nfs_subs.c  8.8 (Berkeley) 5/22/95
   35  */
   36 
   37 /*
   38  * Copyright 2000 Wasabi Systems, Inc.
   39  * All rights reserved.
   40  *
   41  * Written by Frank van der Linden for Wasabi Systems, Inc.
   42  *
   43  * Redistribution and use in source and binary forms, with or without
   44  * modification, are permitted provided that the following conditions
   45  * are met:
   46  * 1. Redistributions of source code must retain the above copyright
   47  *    notice, this list of conditions and the following disclaimer.
   48  * 2. Redistributions in binary form must reproduce the above copyright
   49  *    notice, this list of conditions and the following disclaimer in the
   50  *    documentation and/or other materials provided with the distribution.
   51  * 3. All advertising materials mentioning features or use of this software
   52  *    must display the following acknowledgement:
   53  *      This product includes software developed for the NetBSD Project by
   54  *      Wasabi Systems, Inc.
   55  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
   56  *    or promote products derived from this software without specific prior
   57  *    written permission.
   58  *
   59  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
   60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   61  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   62  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
   63  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   64  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   65  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   66  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   67  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   68  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   69  * POSSIBILITY OF SUCH DAMAGE.
   70  */
   71 
   72 #include <sys/cdefs.h>
   73 __KERNEL_RCSID(0, "$NetBSD: nfs_subs.c,v 1.132.2.5 2005/03/16 11:54:49 tron Exp $");
   74 
   75 #include "fs_nfs.h"
   76 #include "opt_nfs.h"
   77 #include "opt_nfsserver.h"
   78 #include "opt_iso.h"
   79 #include "opt_inet.h"
   80 
   81 /*
   82  * These functions support the macros and help fiddle mbuf chains for
   83  * the nfs op functions. They do things like create the rpc header and
   84  * copy data between mbuf chains and uio lists.
   85  */
   86 #include <sys/param.h>
   87 #include <sys/proc.h>
   88 #include <sys/systm.h>
   89 #include <sys/kernel.h>
   90 #include <sys/mount.h>
   91 #include <sys/vnode.h>
   92 #include <sys/namei.h>
   93 #include <sys/mbuf.h>
   94 #include <sys/socket.h>
   95 #include <sys/stat.h>
   96 #include <sys/malloc.h>
   97 #include <sys/filedesc.h>
   98 #include <sys/time.h>
   99 #include <sys/dirent.h>
  100 
  101 #include <uvm/uvm_extern.h>
  102 
  103 #include <nfs/rpcv2.h>
  104 #include <nfs/nfsproto.h>
  105 #include <nfs/nfsnode.h>
  106 #include <nfs/nfs.h>
  107 #include <nfs/xdr_subs.h>
  108 #include <nfs/nfsm_subs.h>
  109 #include <nfs/nfsmount.h>
  110 #include <nfs/nqnfs.h>
  111 #include <nfs/nfsrtt.h>
  112 #include <nfs/nfs_var.h>
  113 
  114 #include <miscfs/specfs/specdev.h>
  115 
  116 #include <netinet/in.h>
  117 #ifdef ISO
  118 #include <netiso/iso.h>
  119 #endif
  120 
  121 /*
  122  * Data items converted to xdr at startup, since they are constant
  123  * This is kinda hokey, but may save a little time doing byte swaps
  124  */
  125 u_int32_t nfs_xdrneg1;
  126 u_int32_t rpc_call, rpc_vers, rpc_reply, rpc_msgdenied, rpc_autherr,
  127         rpc_mismatch, rpc_auth_unix, rpc_msgaccepted,
  128         rpc_auth_kerb;
  129 u_int32_t nfs_prog, nqnfs_prog, nfs_true, nfs_false;
  130 
  131 /* And other global data */
  132 const nfstype nfsv2_type[9] =
  133         { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON, NFCHR, NFNON };
  134 const nfstype nfsv3_type[9] =
  135         { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFSOCK, NFFIFO, NFNON };
  136 const enum vtype nv2tov_type[8] =
  137         { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON, VNON };
  138 const enum vtype nv3tov_type[8] =
  139         { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO };
  140 int nfs_ticks;
  141 int nfs_commitsize;
  142 
  143 MALLOC_DEFINE(M_NFSDIROFF, "NFS diroff", "NFS directory cookies");
  144 
  145 /* NFS client/server stats. */
  146 struct nfsstats nfsstats;
  147 
  148 /*
  149  * Mapping of old NFS Version 2 RPC numbers to generic numbers.
  150  */
  151 const int nfsv3_procid[NFS_NPROCS] = {
  152         NFSPROC_NULL,
  153         NFSPROC_GETATTR,
  154         NFSPROC_SETATTR,
  155         NFSPROC_NOOP,
  156         NFSPROC_LOOKUP,
  157         NFSPROC_READLINK,
  158         NFSPROC_READ,
  159         NFSPROC_NOOP,
  160         NFSPROC_WRITE,
  161         NFSPROC_CREATE,
  162         NFSPROC_REMOVE,
  163         NFSPROC_RENAME,
  164         NFSPROC_LINK,
  165         NFSPROC_SYMLINK,
  166         NFSPROC_MKDIR,
  167         NFSPROC_RMDIR,
  168         NFSPROC_READDIR,
  169         NFSPROC_FSSTAT,
  170         NFSPROC_NOOP,
  171         NFSPROC_NOOP,
  172         NFSPROC_NOOP,
  173         NFSPROC_NOOP,
  174         NFSPROC_NOOP,
  175         NFSPROC_NOOP,
  176         NFSPROC_NOOP,
  177         NFSPROC_NOOP
  178 };
  179 
  180 /*
  181  * and the reverse mapping from generic to Version 2 procedure numbers
  182  */
  183 const int nfsv2_procid[NFS_NPROCS] = {
  184         NFSV2PROC_NULL,
  185         NFSV2PROC_GETATTR,
  186         NFSV2PROC_SETATTR,
  187         NFSV2PROC_LOOKUP,
  188         NFSV2PROC_NOOP,
  189         NFSV2PROC_READLINK,
  190         NFSV2PROC_READ,
  191         NFSV2PROC_WRITE,
  192         NFSV2PROC_CREATE,
  193         NFSV2PROC_MKDIR,
  194         NFSV2PROC_SYMLINK,
  195         NFSV2PROC_CREATE,
  196         NFSV2PROC_REMOVE,
  197         NFSV2PROC_RMDIR,
  198         NFSV2PROC_RENAME,
  199         NFSV2PROC_LINK,
  200         NFSV2PROC_READDIR,
  201         NFSV2PROC_NOOP,
  202         NFSV2PROC_STATFS,
  203         NFSV2PROC_NOOP,
  204         NFSV2PROC_NOOP,
  205         NFSV2PROC_NOOP,
  206         NFSV2PROC_NOOP,
  207         NFSV2PROC_NOOP,
  208         NFSV2PROC_NOOP,
  209         NFSV2PROC_NOOP,
  210 };
  211 
  212 /*
  213  * Maps errno values to nfs error numbers.
  214  * Use NFSERR_IO as the catch all for ones not specifically defined in
  215  * RFC 1094.
  216  */
  217 static const u_char nfsrv_v2errmap[ELAST] = {
  218   NFSERR_PERM,  NFSERR_NOENT,   NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  219   NFSERR_NXIO,  NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  220   NFSERR_IO,    NFSERR_IO,      NFSERR_ACCES,   NFSERR_IO,      NFSERR_IO,
  221   NFSERR_IO,    NFSERR_EXIST,   NFSERR_IO,      NFSERR_NODEV,   NFSERR_NOTDIR,
  222   NFSERR_ISDIR, NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  223   NFSERR_IO,    NFSERR_FBIG,    NFSERR_NOSPC,   NFSERR_IO,      NFSERR_ROFS,
  224   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  225   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  226   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  227   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  228   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  229   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  230   NFSERR_IO,    NFSERR_IO,      NFSERR_NAMETOL, NFSERR_IO,      NFSERR_IO,
  231   NFSERR_NOTEMPTY, NFSERR_IO,   NFSERR_IO,      NFSERR_DQUOT,   NFSERR_STALE,
  232   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  233   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
  234   NFSERR_IO,    NFSERR_IO,
  235 };
  236 
  237 /*
  238  * Maps errno values to nfs error numbers.
  239  * Although it is not obvious whether or not NFS clients really care if
  240  * a returned error value is in the specified list for the procedure, the
  241  * safest thing to do is filter them appropriately. For Version 2, the
  242  * X/Open XNFS document is the only specification that defines error values
  243  * for each RPC (The RFC simply lists all possible error values for all RPCs),
  244  * so I have decided to not do this for Version 2.
  245  * The first entry is the default error return and the rest are the valid
  246  * errors for that RPC in increasing numeric order.
  247  */
  248 static const short nfsv3err_null[] = {
  249         0,
  250         0,
  251 };
  252 
  253 static const short nfsv3err_getattr[] = {
  254         NFSERR_IO,
  255         NFSERR_IO,
  256         NFSERR_STALE,
  257         NFSERR_BADHANDLE,
  258         NFSERR_SERVERFAULT,
  259         0,
  260 };
  261 
  262 static const short nfsv3err_setattr[] = {
  263         NFSERR_IO,
  264         NFSERR_PERM,
  265         NFSERR_IO,
  266         NFSERR_ACCES,
  267         NFSERR_INVAL,
  268         NFSERR_NOSPC,
  269         NFSERR_ROFS,
  270         NFSERR_DQUOT,
  271         NFSERR_STALE,
  272         NFSERR_BADHANDLE,
  273         NFSERR_NOT_SYNC,
  274         NFSERR_SERVERFAULT,
  275         0,
  276 };
  277 
  278 static const short nfsv3err_lookup[] = {
  279         NFSERR_IO,
  280         NFSERR_NOENT,
  281         NFSERR_IO,
  282         NFSERR_ACCES,
  283         NFSERR_NOTDIR,
  284         NFSERR_NAMETOL,
  285         NFSERR_STALE,
  286         NFSERR_BADHANDLE,
  287         NFSERR_SERVERFAULT,
  288         0,
  289 };
  290 
  291 static const short nfsv3err_access[] = {
  292         NFSERR_IO,
  293         NFSERR_IO,
  294         NFSERR_STALE,
  295         NFSERR_BADHANDLE,
  296         NFSERR_SERVERFAULT,
  297         0,
  298 };
  299 
  300 static const short nfsv3err_readlink[] = {
  301         NFSERR_IO,
  302         NFSERR_IO,
  303         NFSERR_ACCES,
  304         NFSERR_INVAL,
  305         NFSERR_STALE,
  306         NFSERR_BADHANDLE,
  307         NFSERR_NOTSUPP,
  308         NFSERR_SERVERFAULT,
  309         0,
  310 };
  311 
  312 static const short nfsv3err_read[] = {
  313         NFSERR_IO,
  314         NFSERR_IO,
  315         NFSERR_NXIO,
  316         NFSERR_ACCES,
  317         NFSERR_INVAL,
  318         NFSERR_STALE,
  319         NFSERR_BADHANDLE,
  320         NFSERR_SERVERFAULT,
  321         NFSERR_JUKEBOX,
  322         0,
  323 };
  324 
  325 static const short nfsv3err_write[] = {
  326         NFSERR_IO,
  327         NFSERR_IO,
  328         NFSERR_ACCES,
  329         NFSERR_INVAL,
  330         NFSERR_FBIG,
  331         NFSERR_NOSPC,
  332         NFSERR_ROFS,
  333         NFSERR_DQUOT,
  334         NFSERR_STALE,
  335         NFSERR_BADHANDLE,
  336         NFSERR_SERVERFAULT,
  337         NFSERR_JUKEBOX,
  338         0,
  339 };
  340 
  341 static const short nfsv3err_create[] = {
  342         NFSERR_IO,
  343         NFSERR_IO,
  344         NFSERR_ACCES,
  345         NFSERR_EXIST,
  346         NFSERR_NOTDIR,
  347         NFSERR_NOSPC,
  348         NFSERR_ROFS,
  349         NFSERR_NAMETOL,
  350         NFSERR_DQUOT,
  351         NFSERR_STALE,
  352         NFSERR_BADHANDLE,
  353         NFSERR_NOTSUPP,
  354         NFSERR_SERVERFAULT,
  355         0,
  356 };
  357 
  358 static const short nfsv3err_mkdir[] = {
  359         NFSERR_IO,
  360         NFSERR_IO,
  361         NFSERR_ACCES,
  362         NFSERR_EXIST,
  363         NFSERR_NOTDIR,
  364         NFSERR_NOSPC,
  365         NFSERR_ROFS,
  366         NFSERR_NAMETOL,
  367         NFSERR_DQUOT,
  368         NFSERR_STALE,
  369         NFSERR_BADHANDLE,
  370         NFSERR_NOTSUPP,
  371         NFSERR_SERVERFAULT,
  372         0,
  373 };
  374 
  375 static const short nfsv3err_symlink[] = {
  376         NFSERR_IO,
  377         NFSERR_IO,
  378         NFSERR_ACCES,
  379         NFSERR_EXIST,
  380         NFSERR_NOTDIR,
  381         NFSERR_NOSPC,
  382         NFSERR_ROFS,
  383         NFSERR_NAMETOL,
  384         NFSERR_DQUOT,
  385         NFSERR_STALE,
  386         NFSERR_BADHANDLE,
  387         NFSERR_NOTSUPP,
  388         NFSERR_SERVERFAULT,
  389         0,
  390 };
  391 
  392 static const short nfsv3err_mknod[] = {
  393         NFSERR_IO,
  394         NFSERR_IO,
  395         NFSERR_ACCES,
  396         NFSERR_EXIST,
  397         NFSERR_NOTDIR,
  398         NFSERR_NOSPC,
  399         NFSERR_ROFS,
  400         NFSERR_NAMETOL,
  401         NFSERR_DQUOT,
  402         NFSERR_STALE,
  403         NFSERR_BADHANDLE,
  404         NFSERR_NOTSUPP,
  405         NFSERR_SERVERFAULT,
  406         NFSERR_BADTYPE,
  407         0,
  408 };
  409 
  410 static const short nfsv3err_remove[] = {
  411         NFSERR_IO,
  412         NFSERR_NOENT,
  413         NFSERR_IO,
  414         NFSERR_ACCES,
  415         NFSERR_NOTDIR,
  416         NFSERR_ROFS,
  417         NFSERR_NAMETOL,
  418         NFSERR_STALE,
  419         NFSERR_BADHANDLE,
  420         NFSERR_SERVERFAULT,
  421         0,
  422 };
  423 
  424 static const short nfsv3err_rmdir[] = {
  425         NFSERR_IO,
  426         NFSERR_NOENT,
  427         NFSERR_IO,
  428         NFSERR_ACCES,
  429         NFSERR_EXIST,
  430         NFSERR_NOTDIR,
  431         NFSERR_INVAL,
  432         NFSERR_ROFS,
  433         NFSERR_NAMETOL,
  434         NFSERR_NOTEMPTY,
  435         NFSERR_STALE,
  436         NFSERR_BADHANDLE,
  437         NFSERR_NOTSUPP,
  438         NFSERR_SERVERFAULT,
  439         0,
  440 };
  441 
  442 static const short nfsv3err_rename[] = {
  443         NFSERR_IO,
  444         NFSERR_NOENT,
  445         NFSERR_IO,
  446         NFSERR_ACCES,
  447         NFSERR_EXIST,
  448         NFSERR_XDEV,
  449         NFSERR_NOTDIR,
  450         NFSERR_ISDIR,
  451         NFSERR_INVAL,
  452         NFSERR_NOSPC,
  453         NFSERR_ROFS,
  454         NFSERR_MLINK,
  455         NFSERR_NAMETOL,
  456         NFSERR_NOTEMPTY,
  457         NFSERR_DQUOT,
  458         NFSERR_STALE,
  459         NFSERR_BADHANDLE,
  460         NFSERR_NOTSUPP,
  461         NFSERR_SERVERFAULT,
  462         0,
  463 };
  464 
  465 static const short nfsv3err_link[] = {
  466         NFSERR_IO,
  467         NFSERR_IO,
  468         NFSERR_ACCES,
  469         NFSERR_EXIST,
  470         NFSERR_XDEV,
  471         NFSERR_NOTDIR,
  472         NFSERR_INVAL,
  473         NFSERR_NOSPC,
  474         NFSERR_ROFS,
  475         NFSERR_MLINK,
  476         NFSERR_NAMETOL,
  477         NFSERR_DQUOT,
  478         NFSERR_STALE,
  479         NFSERR_BADHANDLE,
  480         NFSERR_NOTSUPP,
  481         NFSERR_SERVERFAULT,
  482         0,
  483 };
  484 
  485 static const short nfsv3err_readdir[] = {
  486         NFSERR_IO,
  487         NFSERR_IO,
  488         NFSERR_ACCES,
  489         NFSERR_NOTDIR,
  490         NFSERR_STALE,
  491         NFSERR_BADHANDLE,
  492         NFSERR_BAD_COOKIE,
  493         NFSERR_TOOSMALL,
  494         NFSERR_SERVERFAULT,
  495         0,
  496 };
  497 
  498 static const short nfsv3err_readdirplus[] = {
  499         NFSERR_IO,
  500         NFSERR_IO,
  501         NFSERR_ACCES,
  502         NFSERR_NOTDIR,
  503         NFSERR_STALE,
  504         NFSERR_BADHANDLE,
  505         NFSERR_BAD_COOKIE,
  506         NFSERR_NOTSUPP,
  507         NFSERR_TOOSMALL,
  508         NFSERR_SERVERFAULT,
  509         0,
  510 };
  511 
  512 static const short nfsv3err_fsstat[] = {
  513         NFSERR_IO,
  514         NFSERR_IO,
  515         NFSERR_STALE,
  516         NFSERR_BADHANDLE,
  517         NFSERR_SERVERFAULT,
  518         0,
  519 };
  520 
  521 static const short nfsv3err_fsinfo[] = {
  522         NFSERR_STALE,
  523         NFSERR_STALE,
  524         NFSERR_BADHANDLE,
  525         NFSERR_SERVERFAULT,
  526         0,
  527 };
  528 
  529 static const short nfsv3err_pathconf[] = {
  530         NFSERR_STALE,
  531         NFSERR_STALE,
  532         NFSERR_BADHANDLE,
  533         NFSERR_SERVERFAULT,
  534         0,
  535 };
  536 
  537 static const short nfsv3err_commit[] = {
  538         NFSERR_IO,
  539         NFSERR_IO,
  540         NFSERR_STALE,
  541         NFSERR_BADHANDLE,
  542         NFSERR_SERVERFAULT,
  543         0,
  544 };
  545 
  546 static const short * const nfsrv_v3errmap[] = {
  547         nfsv3err_null,
  548         nfsv3err_getattr,
  549         nfsv3err_setattr,
  550         nfsv3err_lookup,
  551         nfsv3err_access,
  552         nfsv3err_readlink,
  553         nfsv3err_read,
  554         nfsv3err_write,
  555         nfsv3err_create,
  556         nfsv3err_mkdir,
  557         nfsv3err_symlink,
  558         nfsv3err_mknod,
  559         nfsv3err_remove,
  560         nfsv3err_rmdir,
  561         nfsv3err_rename,
  562         nfsv3err_link,
  563         nfsv3err_readdir,
  564         nfsv3err_readdirplus,
  565         nfsv3err_fsstat,
  566         nfsv3err_fsinfo,
  567         nfsv3err_pathconf,
  568         nfsv3err_commit,
  569 };
  570 
  571 extern struct nfsrtt nfsrtt;
  572 extern time_t nqnfsstarttime;
  573 extern int nqsrv_clockskew;
  574 extern int nqsrv_writeslack;
  575 extern int nqsrv_maxlease;
  576 extern const int nqnfs_piggy[NFS_NPROCS];
  577 extern struct nfsnodehashhead *nfsnodehashtbl;
  578 extern u_long nfsnodehash;
  579 
  580 u_long nfsdirhashmask;
  581 
  582 int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *));
  583 
  584 /*
  585  * Create the header for an rpc request packet
  586  * The hsiz is the size of the rest of the nfs request header.
  587  * (just used to decide if a cluster is a good idea)
  588  */
  589 struct mbuf *
  590 nfsm_reqh(np, procid, hsiz, bposp)
  591         struct nfsnode *np;
  592         u_long procid;
  593         int hsiz;
  594         caddr_t *bposp;
  595 {
  596         struct mbuf *mb;
  597         caddr_t bpos;
  598 #ifndef NFS_V2_ONLY
  599         struct nfsmount *nmp;
  600         u_int32_t *tl;
  601         int nqflag;
  602 #endif
  603 
  604         mb = m_get(M_WAIT, MT_DATA);
  605         MCLAIM(mb, &nfs_mowner);
  606         if (hsiz >= MINCLSIZE)
  607                 m_clget(mb, M_WAIT);
  608         mb->m_len = 0;
  609         bpos = mtod(mb, caddr_t);
  610         
  611 #ifndef NFS_V2_ONLY
  612         /*
  613          * For NQNFS, add lease request.
  614          */
  615         if (np) {
  616                 nmp = VFSTONFS(np->n_vnode->v_mount);
  617                 if (nmp->nm_flag & NFSMNT_NQNFS) {
  618                         nqflag = NQNFS_NEEDLEASE(np, procid);
  619                         if (nqflag) {
  620                                 nfsm_build(tl, u_int32_t *, 2*NFSX_UNSIGNED);
  621                                 *tl++ = txdr_unsigned(nqflag);
  622                                 *tl = txdr_unsigned(nmp->nm_leaseterm);
  623                         } else {
  624                                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
  625                                 *tl = 0;
  626                         }
  627                 }
  628         }
  629 #endif
  630         /* Finally, return values */
  631         *bposp = bpos;
  632         return (mb);
  633 }
  634 
  635 /*
  636  * Build the RPC header and fill in the authorization info.
  637  * The authorization string argument is only used when the credentials
  638  * come from outside of the kernel.
  639  * Returns the head of the mbuf list.
  640  */
  641 struct mbuf *
  642 nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len,
  643         verf_str, mrest, mrest_len, mbp, xidp)
  644         struct ucred *cr;
  645         int nmflag;
  646         int procid;
  647         int auth_type;
  648         int auth_len;
  649         char *auth_str;
  650         int verf_len;
  651         char *verf_str;
  652         struct mbuf *mrest;
  653         int mrest_len;
  654         struct mbuf **mbp;
  655         u_int32_t *xidp;
  656 {
  657         struct mbuf *mb;
  658         u_int32_t *tl;
  659         caddr_t bpos;
  660         int i;
  661         struct mbuf *mreq;
  662         int siz, grpsiz, authsiz;
  663 
  664         authsiz = nfsm_rndup(auth_len);
  665         mb = m_gethdr(M_WAIT, MT_DATA);
  666         MCLAIM(mb, &nfs_mowner);
  667         if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) {
  668                 m_clget(mb, M_WAIT);
  669         } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) {
  670                 MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED);
  671         } else {
  672                 MH_ALIGN(mb, 8 * NFSX_UNSIGNED);
  673         }
  674         mb->m_len = 0;
  675         mreq = mb;
  676         bpos = mtod(mb, caddr_t);
  677 
  678         /*
  679          * First the RPC header.
  680          */
  681         nfsm_build(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
  682 
  683         *tl++ = *xidp = nfs_getxid();
  684         *tl++ = rpc_call;
  685         *tl++ = rpc_vers;
  686         if (nmflag & NFSMNT_NQNFS) {
  687                 *tl++ = txdr_unsigned(NQNFS_PROG);
  688                 *tl++ = txdr_unsigned(NQNFS_VER3);
  689         } else {
  690                 *tl++ = txdr_unsigned(NFS_PROG);
  691                 if (nmflag & NFSMNT_NFSV3)
  692                         *tl++ = txdr_unsigned(NFS_VER3);
  693                 else
  694                         *tl++ = txdr_unsigned(NFS_VER2);
  695         }
  696         if (nmflag & NFSMNT_NFSV3)
  697                 *tl++ = txdr_unsigned(procid);
  698         else
  699                 *tl++ = txdr_unsigned(nfsv2_procid[procid]);
  700 
  701         /*
  702          * And then the authorization cred.
  703          */
  704         *tl++ = txdr_unsigned(auth_type);
  705         *tl = txdr_unsigned(authsiz);
  706         switch (auth_type) {
  707         case RPCAUTH_UNIX:
  708                 nfsm_build(tl, u_int32_t *, auth_len);
  709                 *tl++ = 0;              /* stamp ?? */
  710                 *tl++ = 0;              /* NULL hostname */
  711                 *tl++ = txdr_unsigned(cr->cr_uid);
  712                 *tl++ = txdr_unsigned(cr->cr_gid);
  713                 grpsiz = (auth_len >> 2) - 5;
  714                 *tl++ = txdr_unsigned(grpsiz);
  715                 for (i = 0; i < grpsiz; i++)
  716                         *tl++ = txdr_unsigned(cr->cr_groups[i]);
  717                 break;
  718         case RPCAUTH_KERB4:
  719                 siz = auth_len;
  720                 while (siz > 0) {
  721                         if (M_TRAILINGSPACE(mb) == 0) {
  722                                 struct mbuf *mb2;
  723                                 mb2 = m_get(M_WAIT, MT_DATA);
  724                                 MCLAIM(mb2, &nfs_mowner);
  725                                 if (siz >= MINCLSIZE)
  726                                         m_clget(mb2, M_WAIT);
  727                                 mb->m_next = mb2;
  728                                 mb = mb2;
  729                                 mb->m_len = 0;
  730                                 bpos = mtod(mb, caddr_t);
  731                         }
  732                         i = min(siz, M_TRAILINGSPACE(mb));
  733                         memcpy(bpos, auth_str, i);
  734                         mb->m_len += i;
  735                         auth_str += i;
  736                         bpos += i;
  737                         siz -= i;
  738                 }
  739                 if ((siz = (nfsm_rndup(auth_len) - auth_len)) > 0) {
  740                         for (i = 0; i < siz; i++)
  741                                 *bpos++ = '\0';
  742                         mb->m_len += siz;
  743                 }
  744                 break;
  745         };
  746 
  747         /*
  748          * And the verifier...
  749          */
  750         nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
  751         if (verf_str) {
  752                 *tl++ = txdr_unsigned(RPCAUTH_KERB4);
  753                 *tl = txdr_unsigned(verf_len);
  754                 siz = verf_len;
  755                 while (siz > 0) {
  756                         if (M_TRAILINGSPACE(mb) == 0) {
  757                                 struct mbuf *mb2;
  758                                 mb2 = m_get(M_WAIT, MT_DATA);
  759                                 MCLAIM(mb2, &nfs_mowner);
  760                                 if (siz >= MINCLSIZE)
  761                                         m_clget(mb2, M_WAIT);
  762                                 mb->m_next = mb2;
  763                                 mb = mb2;
  764                                 mb->m_len = 0;
  765                                 bpos = mtod(mb, caddr_t);
  766                         }
  767                         i = min(siz, M_TRAILINGSPACE(mb));
  768                         memcpy(bpos, verf_str, i);
  769                         mb->m_len += i;
  770                         verf_str += i;
  771                         bpos += i;
  772                         siz -= i;
  773                 }
  774                 if ((siz = (nfsm_rndup(verf_len) - verf_len)) > 0) {
  775                         for (i = 0; i < siz; i++)
  776                                 *bpos++ = '\0';
  777                         mb->m_len += siz;
  778                 }
  779         } else {
  780                 *tl++ = txdr_unsigned(RPCAUTH_NULL);
  781                 *tl = 0;
  782         }
  783         mb->m_next = mrest;
  784         mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
  785         mreq->m_pkthdr.rcvif = (struct ifnet *)0;
  786         *mbp = mb;
  787         return (mreq);
  788 }
  789 
  790 /*
  791  * copies mbuf chain to the uio scatter/gather list
  792  */
  793 int
  794 nfsm_mbuftouio(mrep, uiop, siz, dpos)
  795         struct mbuf **mrep;
  796         struct uio *uiop;
  797         int siz;
  798         caddr_t *dpos;
  799 {
  800         char *mbufcp, *uiocp;
  801         int xfer, left, len;
  802         struct mbuf *mp;
  803         long uiosiz, rem;
  804         int error = 0;
  805 
  806         mp = *mrep;
  807         mbufcp = *dpos;
  808         len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
  809         rem = nfsm_rndup(siz)-siz;
  810         while (siz > 0) {
  811                 if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
  812                         return (EFBIG);
  813                 left = uiop->uio_iov->iov_len;
  814                 uiocp = uiop->uio_iov->iov_base;
  815                 if (left > siz)
  816                         left = siz;
  817                 uiosiz = left;
  818                 while (left > 0) {
  819                         while (len == 0) {
  820                                 mp = mp->m_next;
  821                                 if (mp == NULL)
  822                                         return (EBADRPC);
  823                                 mbufcp = mtod(mp, caddr_t);
  824                                 len = mp->m_len;
  825                         }
  826                         xfer = (left > len) ? len : left;
  827 #ifdef notdef
  828                         /* Not Yet.. */
  829                         if (uiop->uio_iov->iov_op != NULL)
  830                                 (*(uiop->uio_iov->iov_op))
  831                                 (mbufcp, uiocp, xfer);
  832                         else
  833 #endif
  834                         if (uiop->uio_segflg == UIO_SYSSPACE)
  835                                 memcpy(uiocp, mbufcp, xfer);
  836                         else
  837                                 copyout(mbufcp, uiocp, xfer);
  838                         left -= xfer;
  839                         len -= xfer;
  840                         mbufcp += xfer;
  841                         uiocp += xfer;
  842                         uiop->uio_offset += xfer;
  843                         uiop->uio_resid -= xfer;
  844                 }
  845                 if (uiop->uio_iov->iov_len <= siz) {
  846                         uiop->uio_iovcnt--;
  847                         uiop->uio_iov++;
  848                 } else {
  849                         uiop->uio_iov->iov_base =
  850                             (caddr_t)uiop->uio_iov->iov_base + uiosiz;
  851                         uiop->uio_iov->iov_len -= uiosiz;
  852                 }
  853                 siz -= uiosiz;
  854         }
  855         *dpos = mbufcp;
  856         *mrep = mp;
  857         if (rem > 0) {
  858                 if (len < rem)
  859                         error = nfs_adv(mrep, dpos, rem, len);
  860                 else
  861                         *dpos += rem;
  862         }
  863         return (error);
  864 }
  865 
  866 /*
  867  * copies a uio scatter/gather list to an mbuf chain.
  868  * NOTE: can ony handle iovcnt == 1
  869  */
  870 int
  871 nfsm_uiotombuf(uiop, mq, siz, bpos)
  872         struct uio *uiop;
  873         struct mbuf **mq;
  874         int siz;
  875         caddr_t *bpos;
  876 {
  877         char *uiocp;
  878         struct mbuf *mp, *mp2;
  879         int xfer, left, mlen;
  880         int uiosiz, clflg, rem;
  881         char *cp;
  882 
  883 #ifdef DIAGNOSTIC
  884         if (uiop->uio_iovcnt != 1)
  885                 panic("nfsm_uiotombuf: iovcnt != 1");
  886 #endif
  887 
  888         if (siz > MLEN)         /* or should it >= MCLBYTES ?? */
  889                 clflg = 1;
  890         else
  891                 clflg = 0;
  892         rem = nfsm_rndup(siz)-siz;
  893         mp = mp2 = *mq;
  894         while (siz > 0) {
  895                 left = uiop->uio_iov->iov_len;
  896                 uiocp = uiop->uio_iov->iov_base;
  897                 if (left > siz)
  898                         left = siz;
  899                 uiosiz = left;
  900                 while (left > 0) {
  901                         mlen = M_TRAILINGSPACE(mp);
  902                         if (mlen == 0) {
  903                                 mp = m_get(M_WAIT, MT_DATA);
  904                                 MCLAIM(mp, &nfs_mowner);
  905                                 if (clflg)
  906                                         m_clget(mp, M_WAIT);
  907                                 mp->m_len = 0;
  908                                 mp2->m_next = mp;
  909                                 mp2 = mp;
  910                                 mlen = M_TRAILINGSPACE(mp);
  911                         }
  912                         xfer = (left > mlen) ? mlen : left;
  913 #ifdef notdef
  914                         /* Not Yet.. */
  915                         if (uiop->uio_iov->iov_op != NULL)
  916                                 (*(uiop->uio_iov->iov_op))
  917                                 (uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
  918                         else
  919 #endif
  920                         if (uiop->uio_segflg == UIO_SYSSPACE)
  921                                 memcpy(mtod(mp, caddr_t)+mp->m_len, uiocp, xfer);
  922                         else
  923                                 copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
  924                         mp->m_len += xfer;
  925                         left -= xfer;
  926                         uiocp += xfer;
  927                         uiop->uio_offset += xfer;
  928                         uiop->uio_resid -= xfer;
  929                 }
  930                 uiop->uio_iov->iov_base = (caddr_t)uiop->uio_iov->iov_base +
  931                     uiosiz;
  932                 uiop->uio_iov->iov_len -= uiosiz;
  933                 siz -= uiosiz;
  934         }
  935         if (rem > 0) {
  936                 if (rem > M_TRAILINGSPACE(mp)) {
  937                         mp = m_get(M_WAIT, MT_DATA);
  938                         MCLAIM(mp, &nfs_mowner);
  939                         mp->m_len = 0;
  940                         mp2->m_next = mp;
  941                 }
  942                 cp = mtod(mp, caddr_t)+mp->m_len;
  943                 for (left = 0; left < rem; left++)
  944                         *cp++ = '\0';
  945                 mp->m_len += rem;
  946                 *bpos = cp;
  947         } else
  948                 *bpos = mtod(mp, caddr_t)+mp->m_len;
  949         *mq = mp;
  950         return (0);
  951 }
  952 
  953 /*
  954  * Get at least "siz" bytes of correctly aligned data.
  955  * When called the mbuf pointers are not necessarily correct,
  956  * dsosp points to what ought to be in m_data and left contains
  957  * what ought to be in m_len. 
  958  * This is used by the macros nfsm_dissect and nfsm_dissecton for tough
  959  * cases. (The macros use the vars. dpos and dpos2)
  960  */
  961 int
  962 nfsm_disct(mdp, dposp, siz, left, cp2)
  963         struct mbuf **mdp;
  964         caddr_t *dposp;
  965         int siz;
  966         int left;
  967         caddr_t *cp2;
  968 {
  969         struct mbuf *m1, *m2;
  970         struct mbuf *havebuf = NULL;
  971         caddr_t src = *dposp;
  972         caddr_t dst;
  973         int len;
  974 
  975 #ifdef DEBUG
  976         if (left < 0)
  977                 panic("nfsm_disct: left < 0"); 
  978 #endif
  979         m1 = *mdp;
  980         /*
  981          * Skip through the mbuf chain looking for an mbuf with
  982          * some data. If the first mbuf found has enough data
  983          * and it is correctly aligned return it.
  984          */
  985         while (left == 0) {
  986                 havebuf = m1;
  987                 *mdp = m1 = m1->m_next;
  988                 if (m1 == NULL)
  989                         return (EBADRPC);
  990                 src = mtod(m1, caddr_t);
  991                 left = m1->m_len;
  992                 /*
  993                  * If we start a new mbuf and it is big enough
  994                  * and correctly aligned just return it, don't
  995                  * do any pull up.
  996                  */
  997                 if (left >= siz && nfsm_aligned(src)) {
  998                         *cp2 = src;
  999                         *dposp = src + siz;
 1000                         return (0);
 1001                 }
 1002         }
 1003         if (m1->m_flags & M_EXT) {
 1004                 if (havebuf) {
 1005                         /* If the first mbuf with data has external data
 1006                          * and there is a previous empty mbuf use it
 1007                          * to move the data into.
 1008                          */
 1009                         m2 = m1;
 1010                         *mdp = m1 = havebuf;
 1011                         if (m1->m_flags & M_EXT) {
 1012                                 MEXTREMOVE(m1);
 1013                         }
 1014                 } else {
 1015                         /*
 1016                          * If the first mbuf has a external data
 1017                          * and there is no previous empty mbuf
 1018                          * allocate a new mbuf and move the external
 1019                          * data to the new mbuf. Also make the first 
 1020                          * mbuf look empty.
 1021                          */
 1022                         m2 = m_get(M_WAIT, MT_DATA);
 1023                         m2->m_ext = m1->m_ext;
 1024                         m2->m_data = src;
 1025                         m2->m_len = left;
 1026                         MCLADDREFERENCE(m1, m2);
 1027                         MEXTREMOVE(m1);
 1028                         m2->m_next = m1->m_next;
 1029                         m1->m_next = m2;
 1030                 }
 1031                 m1->m_len = 0;
 1032                 if (m1->m_flags & M_PKTHDR)
 1033                         dst = m1->m_pktdat;
 1034                 else
 1035                         dst = m1->m_dat;
 1036                 m1->m_data = dst;
 1037         } else {
 1038                 /*
 1039                  * If the first mbuf has no external data
 1040                  * move the data to the front of the mbuf.
 1041                  */
 1042                 if (m1->m_flags & M_PKTHDR)
 1043                         dst = m1->m_pktdat;
 1044                 else
 1045                         dst = m1->m_dat;
 1046                 m1->m_data = dst;
 1047                 if (dst != src)
 1048                         memmove(dst, src, left);
 1049                 dst += left; 
 1050                 m1->m_len = left;
 1051                 m2 = m1->m_next;
 1052         }
 1053         *cp2 = m1->m_data;
 1054         *dposp = mtod(m1, caddr_t) + siz;
 1055         /*
 1056          * Loop through mbufs pulling data up into first mbuf until
 1057          * the first mbuf is full or there is no more data to
 1058          * pullup.
 1059          */
 1060         while ((len = M_TRAILINGSPACE(m1)) != 0 && m2) {
 1061                 if ((len = min(len, m2->m_len)) != 0)
 1062                         memcpy(dst, m2->m_data, len);
 1063                 m1->m_len += len;
 1064                 dst += len;
 1065                 m2->m_data += len;
 1066                 m2->m_len -= len;
 1067                 m2 = m2->m_next;
 1068         }
 1069         if (m1->m_len < siz)
 1070                 return (EBADRPC);
 1071         return (0);
 1072 }
 1073 
 1074 /*
 1075  * Advance the position in the mbuf chain.
 1076  */
 1077 int
 1078 nfs_adv(mdp, dposp, offs, left)
 1079         struct mbuf **mdp;
 1080         caddr_t *dposp;
 1081         int offs;
 1082         int left;
 1083 {
 1084         struct mbuf *m;
 1085         int s;
 1086 
 1087         m = *mdp;
 1088         s = left;
 1089         while (s < offs) {
 1090                 offs -= s;
 1091                 m = m->m_next;
 1092                 if (m == NULL)
 1093                         return (EBADRPC);
 1094                 s = m->m_len;
 1095         }
 1096         *mdp = m;
 1097         *dposp = mtod(m, caddr_t)+offs;
 1098         return (0);
 1099 }
 1100 
 1101 /*
 1102  * Copy a string into mbufs for the hard cases...
 1103  */
 1104 int
 1105 nfsm_strtmbuf(mb, bpos, cp, siz)
 1106         struct mbuf **mb;
 1107         char **bpos;
 1108         const char *cp;
 1109         long siz;
 1110 {
 1111         struct mbuf *m1 = NULL, *m2;
 1112         long left, xfer, len, tlen;
 1113         u_int32_t *tl;
 1114         int putsize;
 1115 
 1116         putsize = 1;
 1117         m2 = *mb;
 1118         left = M_TRAILINGSPACE(m2);
 1119         if (left > 0) {
 1120                 tl = ((u_int32_t *)(*bpos));
 1121                 *tl++ = txdr_unsigned(siz);
 1122                 putsize = 0;
 1123                 left -= NFSX_UNSIGNED;
 1124                 m2->m_len += NFSX_UNSIGNED;
 1125                 if (left > 0) {
 1126                         memcpy((caddr_t) tl, cp, left);
 1127                         siz -= left;
 1128                         cp += left;
 1129                         m2->m_len += left;
 1130                         left = 0;
 1131                 }
 1132         }
 1133         /* Loop around adding mbufs */
 1134         while (siz > 0) {
 1135                 m1 = m_get(M_WAIT, MT_DATA);
 1136                 MCLAIM(m1, &nfs_mowner);
 1137                 if (siz > MLEN)
 1138                         m_clget(m1, M_WAIT);
 1139                 m1->m_len = NFSMSIZ(m1);
 1140                 m2->m_next = m1;
 1141                 m2 = m1;
 1142                 tl = mtod(m1, u_int32_t *);
 1143                 tlen = 0;
 1144                 if (putsize) {
 1145                         *tl++ = txdr_unsigned(siz);
 1146                         m1->m_len -= NFSX_UNSIGNED;
 1147                         tlen = NFSX_UNSIGNED;
 1148                         putsize = 0;
 1149                 }
 1150                 if (siz < m1->m_len) {
 1151                         len = nfsm_rndup(siz);
 1152                         xfer = siz;
 1153                         if (xfer < len)
 1154                                 *(tl+(xfer>>2)) = 0;
 1155                 } else {
 1156                         xfer = len = m1->m_len;
 1157                 }
 1158                 memcpy((caddr_t) tl, cp, xfer);
 1159                 m1->m_len = len+tlen;
 1160                 siz -= xfer;
 1161                 cp += xfer;
 1162         }
 1163         *mb = m1;
 1164         *bpos = mtod(m1, caddr_t)+m1->m_len;
 1165         return (0);
 1166 }
 1167 
 1168 /*
 1169  * Directory caching routines. They work as follows:
 1170  * - a cache is maintained per VDIR nfsnode.
 1171  * - for each offset cookie that is exported to userspace, and can
 1172  *   thus be thrown back at us as an offset to VOP_READDIR, store
 1173  *   information in the cache.
 1174  * - cached are:
 1175  *   - cookie itself
 1176  *   - blocknumber (essentially just a search key in the buffer cache)
 1177  *   - entry number in block.
 1178  *   - offset cookie of block in which this entry is stored
 1179  *   - 32 bit cookie if NFSMNT_XLATECOOKIE is used.
 1180  * - entries are looked up in a hash table
 1181  * - also maintained is an LRU list of entries, used to determine
 1182  *   which ones to delete if the cache grows too large.
 1183  * - if 32 <-> 64 translation mode is requested for a filesystem,
 1184  *   the cache also functions as a translation table
 1185  * - in the translation case, invalidating the cache does not mean
 1186  *   flushing it, but just marking entries as invalid, except for
 1187  *   the <64bit cookie, 32bitcookie> pair which is still valid, to
 1188  *   still be able to use the cache as a translation table.
 1189  * - 32 bit cookies are uniquely created by combining the hash table
 1190  *   entry value, and one generation count per hash table entry,
 1191  *   incremented each time an entry is appended to the chain.
 1192  * - the cache is invalidated each time a direcory is modified
 1193  * - sanity checks are also done; if an entry in a block turns
 1194  *   out not to have a matching cookie, the cache is invalidated
 1195  *   and a new block starting from the wanted offset is fetched from
 1196  *   the server.
 1197  * - directory entries as read from the server are extended to contain
 1198  *   the 64bit and, optionally, the 32bit cookies, for sanity checking
 1199  *   the cache and exporting them to userspace through the cookie
 1200  *   argument to VOP_READDIR.
 1201  */
 1202 
 1203 u_long
 1204 nfs_dirhash(off)
 1205         off_t off;
 1206 {
 1207         int i;
 1208         char *cp = (char *)&off;
 1209         u_long sum = 0L;
 1210 
 1211         for (i = 0 ; i < sizeof (off); i++)
 1212                 sum += *cp++;
 1213 
 1214         return sum;
 1215 }
 1216 
 1217 #define _NFSDC_MTX(np)          (&NFSTOV(np)->v_interlock)
 1218 #define NFSDC_LOCK(np)          simple_lock(_NFSDC_MTX(np))
 1219 #define NFSDC_UNLOCK(np)        simple_unlock(_NFSDC_MTX(np))
 1220 #define NFSDC_ASSERT_LOCKED(np) LOCK_ASSERT(simple_lock_held(_NFSDC_MTX(np)))
 1221 
 1222 void
 1223 nfs_initdircache(vp)
 1224         struct vnode *vp;
 1225 {
 1226         struct nfsnode *np = VTONFS(vp);
 1227         struct nfsdirhashhead *dircache;
 1228 
 1229         dircache = hashinit(NFS_DIRHASHSIZ, HASH_LIST, M_NFSDIROFF,
 1230             M_WAITOK, &nfsdirhashmask);
 1231 
 1232         NFSDC_LOCK(np);
 1233         if (np->n_dircache == NULL) {
 1234                 np->n_dircachesize = 0;
 1235                 np->n_dblkno = 1;
 1236                 np->n_dircache = dircache;
 1237                 dircache = NULL;
 1238                 TAILQ_INIT(&np->n_dirchain);
 1239         }
 1240         NFSDC_UNLOCK(np);
 1241         if (dircache)
 1242                 hashdone(dircache, M_NFSDIROFF);
 1243 }
 1244 
 1245 void
 1246 nfs_initdirxlatecookie(vp)
 1247         struct vnode *vp;
 1248 {
 1249         struct nfsnode *np = VTONFS(vp);
 1250         unsigned *dirgens;
 1251 
 1252         KASSERT(VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_XLATECOOKIE);
 1253 
 1254         dirgens = malloc(NFS_DIRHASHSIZ * sizeof (unsigned), M_NFSDIROFF,
 1255             M_WAITOK|M_ZERO);
 1256         NFSDC_LOCK(np);
 1257         if (np->n_dirgens == NULL) {
 1258                 np->n_dirgens = dirgens;
 1259                 dirgens = NULL;
 1260         }
 1261         NFSDC_UNLOCK(np);
 1262         if (dirgens)
 1263                 free(dirgens, M_NFSDIROFF);
 1264 }
 1265 
 1266 static const struct nfsdircache dzero;
 1267 
 1268 static void nfs_unlinkdircache __P((struct nfsnode *np, struct nfsdircache *));
 1269 static void nfs_putdircache_unlocked __P((struct nfsnode *,
 1270     struct nfsdircache *));
 1271 
 1272 static void
 1273 nfs_unlinkdircache(np, ndp)
 1274         struct nfsnode *np;
 1275         struct nfsdircache *ndp;
 1276 {
 1277 
 1278         NFSDC_ASSERT_LOCKED(np);
 1279         KASSERT(ndp != &dzero);
 1280 
 1281         if (LIST_NEXT(ndp, dc_hash) == (void *)-1)
 1282                 return;
 1283 
 1284         TAILQ_REMOVE(&np->n_dirchain, ndp, dc_chain);
 1285         LIST_REMOVE(ndp, dc_hash);
 1286         LIST_NEXT(ndp, dc_hash) = (void *)-1; /* mark as unlinked */
 1287 
 1288         nfs_putdircache_unlocked(np, ndp);
 1289 }
 1290 
 1291 void
 1292 nfs_putdircache(np, ndp)
 1293         struct nfsnode *np;
 1294         struct nfsdircache *ndp;
 1295 {
 1296         int ref;
 1297 
 1298         if (ndp == &dzero)
 1299                 return;
 1300 
 1301         KASSERT(ndp->dc_refcnt > 0);
 1302         NFSDC_LOCK(np);
 1303         ref = --ndp->dc_refcnt;
 1304         NFSDC_UNLOCK(np);
 1305 
 1306         if (ref == 0)
 1307                 free(ndp, M_NFSDIROFF);
 1308 }
 1309 
 1310 static void
 1311 nfs_putdircache_unlocked(np, ndp)
 1312         struct nfsnode *np;
 1313         struct nfsdircache *ndp;
 1314 {
 1315         int ref;
 1316 
 1317         NFSDC_ASSERT_LOCKED(np);
 1318 
 1319         if (ndp == &dzero)
 1320                 return;
 1321 
 1322         KASSERT(ndp->dc_refcnt > 0);
 1323         ref = --ndp->dc_refcnt;
 1324         if (ref == 0)
 1325                 free(ndp, M_NFSDIROFF);
 1326 }
 1327 
 1328 struct nfsdircache *
 1329 nfs_searchdircache(vp, off, do32, hashent)
 1330         struct vnode *vp;
 1331         off_t off;
 1332         int do32;
 1333         int *hashent;
 1334 {
 1335         struct nfsdirhashhead *ndhp;
 1336         struct nfsdircache *ndp = NULL;
 1337         struct nfsnode *np = VTONFS(vp);
 1338         unsigned ent;
 1339 
 1340         /*
 1341          * Zero is always a valid cookie.
 1342          */
 1343         if (off == 0)
 1344                 /* LINTED const cast away */
 1345                 return (struct nfsdircache *)&dzero;
 1346 
 1347         if (!np->n_dircache)
 1348                 return NULL;
 1349 
 1350         /*
 1351          * We use a 32bit cookie as search key, directly reconstruct
 1352          * the hashentry. Else use the hashfunction.
 1353          */
 1354         if (do32) {
 1355                 ent = (u_int32_t)off >> 24;
 1356                 if (ent >= NFS_DIRHASHSIZ)
 1357                         return NULL;
 1358                 ndhp = &np->n_dircache[ent];
 1359         } else {
 1360                 ndhp = NFSDIRHASH(np, off);
 1361         }
 1362 
 1363         if (hashent)
 1364                 *hashent = (int)(ndhp - np->n_dircache);
 1365 
 1366         NFSDC_LOCK(np);
 1367         if (do32) {
 1368                 LIST_FOREACH(ndp, ndhp, dc_hash) {
 1369                         if (ndp->dc_cookie32 == (u_int32_t)off) {
 1370                                 /*
 1371                                  * An invalidated entry will become the
 1372                                  * start of a new block fetched from
 1373                                  * the server.
 1374                                  */
 1375                                 if (ndp->dc_flags & NFSDC_INVALID) {
 1376                                         ndp->dc_blkcookie = ndp->dc_cookie;
 1377                                         ndp->dc_blkno = np->n_dblkno++;
 1378                                         ndp->dc_entry = 0;
 1379                                         ndp->dc_flags &= ~NFSDC_INVALID;
 1380                                 }
 1381                                 break;
 1382                         }
 1383                 }
 1384         } else {
 1385                 LIST_FOREACH(ndp, ndhp, dc_hash) {
 1386                         if (ndp->dc_cookie == off)
 1387                                 break;
 1388                 }
 1389         }
 1390         if (ndp != NULL)
 1391                 ndp->dc_refcnt++;
 1392         NFSDC_UNLOCK(np);
 1393         return ndp;
 1394 }
 1395 
 1396 
 1397 struct nfsdircache *
 1398 nfs_enterdircache(vp, off, blkoff, en, blkno)
 1399         struct vnode *vp;
 1400         off_t off, blkoff;
 1401         int en;
 1402         daddr_t blkno;
 1403 {
 1404         struct nfsnode *np = VTONFS(vp);
 1405         struct nfsdirhashhead *ndhp;
 1406         struct nfsdircache *ndp = NULL;
 1407         struct nfsdircache *newndp = NULL;
 1408         struct nfsmount *nmp = VFSTONFS(vp->v_mount);
 1409         int hashent, gen, overwrite;
 1410 
 1411         /*
 1412          * XXX refuse entries for offset 0. amd(8) erroneously sets
 1413          * cookie 0 for the '.' entry, making this necessary. This
 1414          * isn't so bad, as 0 is a special case anyway.
 1415          */
 1416         if (off == 0)
 1417                 /* LINTED const cast away */
 1418                 return (struct nfsdircache *)&dzero;
 1419 
 1420         if (!np->n_dircache)
 1421                 /*
 1422                  * XXX would like to do this in nfs_nget but vtype
 1423                  * isn't known at that time.
 1424                  */
 1425                 nfs_initdircache(vp);
 1426 
 1427         if ((nmp->nm_flag & NFSMNT_XLATECOOKIE) && !np->n_dirgens)
 1428                 nfs_initdirxlatecookie(vp);
 1429 
 1430 retry:
 1431         ndp = nfs_searchdircache(vp, off, 0, &hashent);
 1432 
 1433         NFSDC_LOCK(np);
 1434         if (ndp && (ndp->dc_flags & NFSDC_INVALID) == 0) {
 1435                 /*
 1436                  * Overwriting an old entry. Check if it's the same.
 1437                  * If so, just return. If not, remove the old entry.
 1438                  */
 1439                 if (ndp->dc_blkcookie == blkoff && ndp->dc_entry == en)
 1440                         goto done;
 1441                 nfs_unlinkdircache(np, ndp);
 1442                 nfs_putdircache_unlocked(np, ndp);
 1443                 ndp = NULL;
 1444         }
 1445 
 1446         ndhp = &np->n_dircache[hashent];
 1447 
 1448         if (!ndp) {
 1449                 if (newndp == NULL) {
 1450                         NFSDC_UNLOCK(np);
 1451                         newndp = malloc(sizeof(*ndp), M_NFSDIROFF, M_WAITOK);
 1452                         newndp->dc_refcnt = 1;
 1453                         LIST_NEXT(newndp, dc_hash) = (void *)-1;
 1454                         goto retry;
 1455                 }
 1456                 ndp = newndp;
 1457                 newndp = NULL;
 1458                 overwrite = 0;
 1459                 if (nmp->nm_flag & NFSMNT_XLATECOOKIE) {
 1460                         /*
 1461                          * We're allocating a new entry, so bump the
 1462                          * generation number.
 1463                          */
 1464                         gen = ++np->n_dirgens[hashent];
 1465                         if (gen == 0) {
 1466                                 np->n_dirgens[hashent]++;
 1467                                 gen++;
 1468                         }
 1469                         ndp->dc_cookie32 = (hashent << 24) | (gen & 0xffffff);
 1470                 }
 1471         } else
 1472                 overwrite = 1;
 1473 
 1474         /*
 1475          * If the entry number is 0, we are at the start of a new block, so
 1476          * allocate a new blocknumber.
 1477          */
 1478         if (en == 0)
 1479                 ndp->dc_blkno = np->n_dblkno++;
 1480         else
 1481                 ndp->dc_blkno = blkno;
 1482 
 1483         ndp->dc_cookie = off;
 1484         ndp->dc_blkcookie = blkoff;
 1485         ndp->dc_entry = en;
 1486         ndp->dc_flags = 0;
 1487 
 1488         if (overwrite)
 1489                 goto done;
 1490 
 1491         /*
 1492          * If the maximum directory cookie cache size has been reached
 1493          * for this node, take one off the front. The idea is that
 1494          * directories are typically read front-to-back once, so that
 1495          * the oldest entries can be thrown away without much performance
 1496          * loss.
 1497          */
 1498         if (np->n_dircachesize == NFS_MAXDIRCACHE) {
 1499                 nfs_unlinkdircache(np, TAILQ_FIRST(&np->n_dirchain));
 1500         } else
 1501                 np->n_dircachesize++;
 1502                 
 1503         KASSERT(ndp->dc_refcnt == 1);
 1504         LIST_INSERT_HEAD(ndhp, ndp, dc_hash);
 1505         TAILQ_INSERT_TAIL(&np->n_dirchain, ndp, dc_chain);
 1506         ndp->dc_refcnt++;
 1507 done:
 1508         KASSERT(ndp->dc_refcnt > 0);
 1509         NFSDC_UNLOCK(np);
 1510         if (newndp)
 1511                 nfs_putdircache(np, newndp);
 1512         return ndp;
 1513 }
 1514 
 1515 void
 1516 nfs_invaldircache(vp, forcefree)
 1517         struct vnode *vp;
 1518         int forcefree;
 1519 {
 1520         struct nfsnode *np = VTONFS(vp);
 1521         struct nfsdircache *ndp = NULL;
 1522         struct nfsmount *nmp = VFSTONFS(vp->v_mount);
 1523 
 1524 #ifdef DIAGNOSTIC
 1525         if (vp->v_type != VDIR)
 1526                 panic("nfs: invaldircache: not dir");
 1527 #endif
 1528 
 1529         if (!np->n_dircache)
 1530                 return;
 1531 
 1532         NFSDC_LOCK(np);
 1533         if (!(nmp->nm_flag & NFSMNT_XLATECOOKIE) || forcefree) {
 1534                 while ((ndp = TAILQ_FIRST(&np->n_dirchain)) != NULL) {
 1535                         KASSERT(!forcefree || ndp->dc_refcnt == 1);
 1536                         nfs_unlinkdircache(np, ndp);
 1537                 }
 1538                 np->n_dircachesize = 0;
 1539                 if (forcefree && np->n_dirgens) {
 1540                         FREE(np->n_dirgens, M_NFSDIROFF);
 1541                         np->n_dirgens = NULL;
 1542                 }
 1543         } else {
 1544                 TAILQ_FOREACH(ndp, &np->n_dirchain, dc_chain)
 1545                         ndp->dc_flags |= NFSDC_INVALID;
 1546         }
 1547 
 1548         np->n_dblkno = 1;
 1549         NFSDC_UNLOCK(np);
 1550 }
 1551 
 1552 /*
 1553  * Called once before VFS init to initialize shared and
 1554  * server-specific data structures.
 1555  */
 1556 void
 1557 nfs_init()
 1558 {
 1559         nfsrtt.pos = 0;
 1560         rpc_vers = txdr_unsigned(RPC_VER2);
 1561         rpc_call = txdr_unsigned(RPC_CALL);
 1562         rpc_reply = txdr_unsigned(RPC_REPLY);
 1563         rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
 1564         rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
 1565         rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
 1566         rpc_autherr = txdr_unsigned(RPC_AUTHERR);
 1567         rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
 1568         rpc_auth_kerb = txdr_unsigned(RPCAUTH_KERB4);
 1569         nfs_prog = txdr_unsigned(NFS_PROG);
 1570         nqnfs_prog = txdr_unsigned(NQNFS_PROG);
 1571         nfs_true = txdr_unsigned(TRUE);
 1572         nfs_false = txdr_unsigned(FALSE);
 1573         nfs_xdrneg1 = txdr_unsigned(-1);
 1574         nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000;
 1575         if (nfs_ticks < 1)
 1576                 nfs_ticks = 1;
 1577 #ifdef NFSSERVER
 1578         nfsrv_init(0);                  /* Init server data structures */
 1579         nfsrv_initcache();              /* Init the server request cache */
 1580         pool_init(&nfs_srvdesc_pool, sizeof(struct nfsrv_descript),
 1581             0, 0, 0, "nfsrvdescpl", &pool_allocator_nointr);
 1582 #endif /* NFSSERVER */
 1583 
 1584 #if defined(NFSSERVER) || !defined(NFS_V2_ONLY)
 1585         /*
 1586          * Initialize the nqnfs data structures.
 1587          */
 1588         if (nqnfsstarttime == 0) {
 1589                 nqnfsstarttime = boottime.tv_sec + nqsrv_maxlease
 1590                         + nqsrv_clockskew + nqsrv_writeslack;
 1591                 NQLOADNOVRAM(nqnfsstarttime);
 1592                 CIRCLEQ_INIT(&nqtimerhead);
 1593                 nqfhhashtbl = hashinit(NQLCHSZ, HASH_LIST, M_NQLEASE,
 1594                     M_WAITOK, &nqfhhash);
 1595         }
 1596 #endif
 1597 
 1598         exithook_establish(nfs_exit, NULL);
 1599 
 1600         /*
 1601          * Initialize reply list and start timer
 1602          */
 1603         TAILQ_INIT(&nfs_reqq);
 1604         nfs_timer(NULL);
 1605         MOWNER_ATTACH(&nfs_mowner);
 1606 
 1607 #ifdef NFS
 1608         /* Initialize the kqueue structures */
 1609         nfs_kqinit();
 1610         /* Initialize the iod structures */
 1611         nfs_iodinit();
 1612 #endif
 1613 }
 1614 
 1615 #ifdef NFS
 1616 /*
 1617  * Called once at VFS init to initialize client-specific data structures.
 1618  */
 1619 void
 1620 nfs_vfs_init()
 1621 {
 1622         nfs_nhinit();                   /* Init the nfsnode table */
 1623         nfs_commitsize = uvmexp.npages << (PAGE_SHIFT - 4);
 1624 }
 1625 
 1626 void
 1627 nfs_vfs_reinit()
 1628 {
 1629         nfs_nhreinit();
 1630 }
 1631 
 1632 void
 1633 nfs_vfs_done()
 1634 {
 1635         nfs_nhdone();
 1636 }
 1637 
 1638 /*
 1639  * Attribute cache routines.
 1640  * nfs_loadattrcache() - loads or updates the cache contents from attributes
 1641  *      that are on the mbuf list
 1642  * nfs_getattrcache() - returns valid attributes if found in cache, returns
 1643  *      error otherwise
 1644  */
 1645 
 1646 /*
 1647  * Load the attribute cache (that lives in the nfsnode entry) with
 1648  * the values on the mbuf list and
 1649  * Iff vap not NULL
 1650  *    copy the attributes to *vaper
 1651  */
 1652 int
 1653 nfsm_loadattrcache(vpp, mdp, dposp, vaper, flags)
 1654         struct vnode **vpp;
 1655         struct mbuf **mdp;
 1656         caddr_t *dposp;
 1657         struct vattr *vaper;
 1658         int flags;
 1659 {
 1660         int32_t t1;
 1661         caddr_t cp2;
 1662         int error = 0;
 1663         struct mbuf *md;
 1664         int v3 = NFS_ISV3(*vpp);
 1665 
 1666         md = *mdp;
 1667         t1 = (mtod(md, caddr_t) + md->m_len) - *dposp;
 1668         error = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, &cp2);
 1669         if (error)
 1670                 return (error);
 1671         return nfs_loadattrcache(vpp, (struct nfs_fattr *)cp2, vaper, flags);
 1672 }
 1673 
 1674 int
 1675 nfs_loadattrcache(vpp, fp, vaper, flags)
 1676         struct vnode **vpp;
 1677         struct nfs_fattr *fp;
 1678         struct vattr *vaper;
 1679         int flags;
 1680 {
 1681         struct vnode *vp = *vpp;
 1682         struct vattr *vap;
 1683         int v3 = NFS_ISV3(vp);
 1684         enum vtype vtyp;
 1685         u_short vmode;
 1686         struct timespec mtime;
 1687         struct vnode *nvp;
 1688         int32_t rdev;
 1689         struct nfsnode *np;
 1690         extern int (**spec_nfsv2nodeop_p) __P((void *));
 1691         uid_t uid;
 1692         gid_t gid;
 1693 
 1694         if (v3) {
 1695                 vtyp = nfsv3tov_type(fp->fa_type);
 1696                 vmode = fxdr_unsigned(u_short, fp->fa_mode);
 1697                 rdev = makedev(fxdr_unsigned(u_int32_t, fp->fa3_rdev.specdata1),
 1698                         fxdr_unsigned(u_int32_t, fp->fa3_rdev.specdata2));
 1699                 fxdr_nfsv3time(&fp->fa3_mtime, &mtime);
 1700         } else {
 1701                 vtyp = nfsv2tov_type(fp->fa_type);
 1702                 vmode = fxdr_unsigned(u_short, fp->fa_mode);
 1703                 if (vtyp == VNON || vtyp == VREG)
 1704                         vtyp = IFTOVT(vmode);
 1705                 rdev = fxdr_unsigned(int32_t, fp->fa2_rdev);
 1706                 fxdr_nfsv2time(&fp->fa2_mtime, &mtime);
 1707 
 1708                 /*
 1709                  * Really ugly NFSv2 kludge.
 1710                  */
 1711                 if (vtyp == VCHR && rdev == 0xffffffff)
 1712                         vtyp = VFIFO;
 1713         }
 1714 
 1715         vmode &= ALLPERMS;
 1716 
 1717         /*
 1718          * If v_type == VNON it is a new node, so fill in the v_type,
 1719          * n_mtime fields. Check to see if it represents a special 
 1720          * device, and if so, check for a possible alias. Once the
 1721          * correct vnode has been obtained, fill in the rest of the
 1722          * information.
 1723          */
 1724         np = VTONFS(vp);
 1725         if (vp->v_type == VNON) {
 1726                 vp->v_type = vtyp;
 1727                 if (vp->v_type == VFIFO) {
 1728                         extern int (**fifo_nfsv2nodeop_p) __P((void *));
 1729                         vp->v_op = fifo_nfsv2nodeop_p;
 1730                 } else if (vp->v_type == VREG) {
 1731                         lockinit(&np->n_commitlock, PINOD, "nfsclock", 0, 0);
 1732                 } else if (vp->v_type == VCHR || vp->v_type == VBLK) {
 1733                         vp->v_op = spec_nfsv2nodeop_p;
 1734                         nvp = checkalias(vp, (dev_t)rdev, vp->v_mount);
 1735                         if (nvp) {
 1736                                 /*
 1737                                  * Discard unneeded vnode, but save its nfsnode.
 1738                                  * Since the nfsnode does not have a lock, its
 1739                                  * vnode lock has to be carried over.
 1740                                  */
 1741                                 /*
 1742                                  * XXX is the old node sure to be locked here?
 1743                                  */
 1744                                 KASSERT(lockstatus(&vp->v_lock) ==
 1745                                     LK_EXCLUSIVE);
 1746                                 nvp->v_data = vp->v_data;
 1747                                 vp->v_data = NULL;
 1748                                 VOP_UNLOCK(vp, 0);
 1749                                 vp->v_op = spec_vnodeop_p;
 1750                                 vrele(vp);
 1751                                 vgone(vp);
 1752                                 lockmgr(&nvp->v_lock, LK_EXCLUSIVE,
 1753                                     &nvp->v_interlock);
 1754                                 /*
 1755                                  * Reinitialize aliased node.
 1756                                  */
 1757                                 np->n_vnode = nvp;
 1758                                 *vpp = vp = nvp;
 1759                         }
 1760                 }
 1761                 np->n_mtime = mtime;
 1762         }
 1763         uid = fxdr_unsigned(uid_t, fp->fa_uid);
 1764         gid = fxdr_unsigned(gid_t, fp->fa_gid);
 1765         vap = np->n_vattr;
 1766 
 1767         /*
 1768          * Invalidate access cache if uid, gid or mode changed.
 1769          */
 1770         if (np->n_accstamp != -1 &&
 1771             (gid != vap->va_gid || uid != vap->va_uid || vmode != vap->va_mode))
 1772                 np->n_accstamp = -1;
 1773 
 1774         vap->va_type = vtyp;
 1775         vap->va_mode = vmode;
 1776         vap->va_rdev = (dev_t)rdev;
 1777         vap->va_mtime = mtime;
 1778         vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
 1779         switch (vtyp) {
 1780         case VDIR:
 1781                 vap->va_blocksize = NFS_DIRFRAGSIZ;
 1782                 break;
 1783         case VBLK:
 1784                 vap->va_blocksize = BLKDEV_IOSIZE;
 1785                 break;
 1786         case VCHR:
 1787                 vap->va_blocksize = MAXBSIZE;
 1788                 break;
 1789         default:
 1790                 vap->va_blocksize = v3 ? vp->v_mount->mnt_stat.f_iosize :
 1791                     fxdr_unsigned(int32_t, fp->fa2_blocksize);
 1792                 break;
 1793         }
 1794         if (v3) {
 1795                 vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
 1796                 vap->va_uid = uid;
 1797                 vap->va_gid = gid;
 1798                 vap->va_size = fxdr_hyper(&fp->fa3_size);
 1799                 vap->va_bytes = fxdr_hyper(&fp->fa3_used);
 1800                 vap->va_fileid = fxdr_unsigned(int32_t,
 1801                     fp->fa3_fileid.nfsuquad[1]);
 1802                 fxdr_nfsv3time(&fp->fa3_atime, &vap->va_atime);
 1803                 fxdr_nfsv3time(&fp->fa3_ctime, &vap->va_ctime);
 1804                 vap->va_flags = 0;
 1805                 vap->va_filerev = 0;
 1806         } else {
 1807                 vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
 1808                 vap->va_uid = uid;
 1809                 vap->va_gid = gid;
 1810                 vap->va_size = fxdr_unsigned(u_int32_t, fp->fa2_size);
 1811                 vap->va_bytes = fxdr_unsigned(int32_t, fp->fa2_blocks)
 1812                     * NFS_FABLKSIZE;
 1813                 vap->va_fileid = fxdr_unsigned(int32_t, fp->fa2_fileid);
 1814                 fxdr_nfsv2time(&fp->fa2_atime, &vap->va_atime);
 1815                 vap->va_flags = 0;
 1816                 vap->va_ctime.tv_sec = fxdr_unsigned(u_int32_t,
 1817                     fp->fa2_ctime.nfsv2_sec);
 1818                 vap->va_ctime.tv_nsec = 0;
 1819                 vap->va_gen = fxdr_unsigned(u_int32_t,fp->fa2_ctime.nfsv2_usec);
 1820                 vap->va_filerev = 0;
 1821         }
 1822         if (vap->va_size != np->n_size) {
 1823                 if ((np->n_flag & NMODIFIED) && vap->va_size < np->n_size) {
 1824                         vap->va_size = np->n_size;
 1825                 } else {
 1826                         np->n_size = vap->va_size;
 1827                         if (vap->va_type == VREG) {
 1828                                 /*
 1829                                  * we can't free pages if NAC_NOTRUNC because
 1830                                  * the pages can be owned by ourselves.
 1831                                  */
 1832                                 if (flags & NAC_NOTRUNC) {
 1833                                         np->n_flag |= NTRUNCDELAYED;
 1834                                 } else {
 1835                                         simple_lock(&vp->v_interlock);
 1836                                         (void)VOP_PUTPAGES(vp, 0,
 1837                                             0, PGO_SYNCIO | PGO_CLEANIT |
 1838                                             PGO_FREE | PGO_ALLPAGES);
 1839                                         uvm_vnp_setsize(vp, np->n_size);
 1840                                 }
 1841                         }
 1842                 }
 1843         }
 1844         np->n_attrstamp = time.tv_sec;
 1845         if (vaper != NULL) {
 1846                 memcpy((caddr_t)vaper, (caddr_t)vap, sizeof(*vap));
 1847                 if (np->n_flag & NCHG) {
 1848                         if (np->n_flag & NACC)
 1849                                 vaper->va_atime = np->n_atim;
 1850                         if (np->n_flag & NUPD)
 1851                                 vaper->va_mtime = np->n_mtim;
 1852                 }
 1853         }
 1854         return (0);
 1855 }
 1856 
 1857 /*
 1858  * Check the time stamp
 1859  * If the cache is valid, copy contents to *vap and return 0
 1860  * otherwise return an error
 1861  */
 1862 int
 1863 nfs_getattrcache(vp, vaper)
 1864         struct vnode *vp;
 1865         struct vattr *vaper;
 1866 {
 1867         struct nfsnode *np = VTONFS(vp);
 1868         struct vattr *vap;
 1869 
 1870         if (np->n_attrstamp == 0 ||
 1871             (time.tv_sec - np->n_attrstamp) >= NFS_ATTRTIMEO(np)) {
 1872                 nfsstats.attrcache_misses++;
 1873                 return (ENOENT);
 1874         }
 1875         nfsstats.attrcache_hits++;
 1876         vap = np->n_vattr;
 1877         if (vap->va_size != np->n_size) {
 1878                 if (vap->va_type == VREG) {
 1879                         if (np->n_flag & NMODIFIED) {
 1880                                 if (vap->va_size < np->n_size)
 1881                                         vap->va_size = np->n_size;
 1882                                 else
 1883                                         np->n_size = vap->va_size;
 1884                         } else
 1885                                 np->n_size = vap->va_size;
 1886                         uvm_vnp_setsize(vp, np->n_size);
 1887                 } else
 1888                         np->n_size = vap->va_size;
 1889         }
 1890         memcpy((caddr_t)vaper, (caddr_t)vap, sizeof(struct vattr));
 1891         if (np->n_flag & NCHG) {
 1892                 if (np->n_flag & NACC)
 1893                         vaper->va_atime = np->n_atim;
 1894                 if (np->n_flag & NUPD)
 1895                         vaper->va_mtime = np->n_mtim;
 1896         }
 1897         return (0);
 1898 }
 1899 
 1900 void
 1901 nfs_delayedtruncate(vp)
 1902         struct vnode *vp;
 1903 {
 1904         struct nfsnode *np = VTONFS(vp);
 1905 
 1906         if (np->n_flag & NTRUNCDELAYED) {
 1907                 np->n_flag &= ~NTRUNCDELAYED;
 1908                 simple_lock(&vp->v_interlock);
 1909                 (void)VOP_PUTPAGES(vp, 0,
 1910                     0, PGO_SYNCIO | PGO_CLEANIT | PGO_FREE | PGO_ALLPAGES);
 1911                 uvm_vnp_setsize(vp, np->n_size);
 1912         }
 1913 }
 1914 
 1915 /*
 1916  * Heuristic to see if the server XDR encodes directory cookies or not.
 1917  * it is not supposed to, but a lot of servers may do this. Also, since
 1918  * most/all servers will implement V2 as well, it is expected that they
 1919  * may return just 32 bits worth of cookie information, so we need to
 1920  * find out in which 32 bits this information is available. We do this
 1921  * to avoid trouble with emulated binaries that can't handle 64 bit
 1922  * directory offsets.
 1923  */
 1924 
 1925 void
 1926 nfs_cookieheuristic(vp, flagp, p, cred)
 1927         struct vnode *vp;
 1928         int *flagp;
 1929         struct proc *p;
 1930         struct ucred *cred;
 1931 {
 1932         struct uio auio;
 1933         struct iovec aiov;
 1934         caddr_t buf, cp;
 1935         struct dirent *dp;
 1936         off_t *cookies = NULL, *cop;
 1937         int error, eof, nc, len;
 1938 
 1939         MALLOC(buf, caddr_t, NFS_DIRFRAGSIZ, M_TEMP, M_WAITOK);
 1940 
 1941         aiov.iov_base = buf;
 1942         aiov.iov_len = NFS_DIRFRAGSIZ;
 1943         auio.uio_iov = &aiov;
 1944         auio.uio_iovcnt = 1;
 1945         auio.uio_rw = UIO_READ;
 1946         auio.uio_segflg = UIO_SYSSPACE;
 1947         auio.uio_procp = p;
 1948         auio.uio_resid = NFS_DIRFRAGSIZ;
 1949         auio.uio_offset = 0;
 1950 
 1951         error = VOP_READDIR(vp, &auio, cred, &eof, &cookies, &nc);
 1952 
 1953         len = NFS_DIRFRAGSIZ - auio.uio_resid;
 1954         if (error || len == 0) {
 1955                 FREE(buf, M_TEMP);
 1956                 if (cookies)
 1957                         free(cookies, M_TEMP);
 1958                 return;
 1959         }
 1960 
 1961         /*
 1962          * Find the first valid entry and look at its offset cookie.
 1963          */
 1964 
 1965         cp = buf;
 1966         for (cop = cookies; len > 0; len -= dp->d_reclen) {
 1967                 dp = (struct dirent *)cp;
 1968                 if (dp->d_fileno != 0 && len >= dp->d_reclen) {
 1969                         if ((*cop >> 32) != 0 && (*cop & 0xffffffffLL) == 0) {
 1970                                 *flagp |= NFSMNT_SWAPCOOKIE;
 1971                                 nfs_invaldircache(vp, 0);
 1972                                 nfs_vinvalbuf(vp, 0, cred, p, 1);
 1973                         }
 1974                         break;
 1975                 }
 1976                 cop++;
 1977                 cp += dp->d_reclen;
 1978         }
 1979 
 1980         FREE(buf, M_TEMP);
 1981         free(cookies, M_TEMP);
 1982 }
 1983 #endif /* NFS */
 1984 
 1985 /*
 1986  * Set up nameidata for a lookup() call and do it.
 1987  *
 1988  * If pubflag is set, this call is done for a lookup operation on the
 1989  * public filehandle. In that case we allow crossing mountpoints and
 1990  * absolute pathnames. However, the caller is expected to check that
 1991  * the lookup result is within the public fs, and deny access if
 1992  * it is not.
 1993  */
 1994 int
 1995 nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag)
 1996         struct nameidata *ndp;
 1997         fhandle_t *fhp;
 1998         uint32_t len;
 1999         struct nfssvc_sock *slp;
 2000         struct mbuf *nam;
 2001         struct mbuf **mdp;
 2002         caddr_t *dposp;
 2003         struct vnode **retdirp;
 2004         struct proc *p;
 2005         int kerbflag, pubflag;
 2006 {
 2007         int i, rem;
 2008         struct mbuf *md;
 2009         char *fromcp, *tocp, *cp;
 2010         struct iovec aiov;
 2011         struct uio auio;
 2012         struct vnode *dp;
 2013         int error, rdonly, linklen;
 2014         struct componentname *cnp = &ndp->ni_cnd;
 2015 
 2016         *retdirp = (struct vnode *)0;
 2017 
 2018         if ((len + 1) > MAXPATHLEN)
 2019                 return (ENAMETOOLONG);
 2020         cnp->cn_pnbuf = PNBUF_GET();
 2021 
 2022         /*
 2023          * Copy the name from the mbuf list to ndp->ni_pnbuf
 2024          * and set the various ndp fields appropriately.
 2025          */
 2026         fromcp = *dposp;
 2027         tocp = cnp->cn_pnbuf;
 2028         md = *mdp;
 2029         rem = mtod(md, caddr_t) + md->m_len - fromcp;
 2030         for (i = 0; i < len; i++) {
 2031                 while (rem == 0) {
 2032                         md = md->m_next;
 2033                         if (md == NULL) {
 2034                                 error = EBADRPC;
 2035                                 goto out;
 2036                         }
 2037                         fromcp = mtod(md, caddr_t);
 2038                         rem = md->m_len;
 2039                 }
 2040                 if (*fromcp == '\0' || (!pubflag && *fromcp == '/')) {
 2041                         error = EACCES;
 2042                         goto out;
 2043                 }
 2044                 *tocp++ = *fromcp++;
 2045                 rem--;
 2046         }
 2047         *tocp = '\0';
 2048         *mdp = md;
 2049         *dposp = fromcp;
 2050         len = nfsm_rndup(len)-len;
 2051         if (len > 0) {
 2052                 if (rem >= len)
 2053                         *dposp += len;
 2054                 else if ((error = nfs_adv(mdp, dposp, len, rem)) != 0)
 2055                         goto out;
 2056         }
 2057 
 2058         /*
 2059          * Extract and set starting directory.
 2060          */
 2061         error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cnd.cn_cred, slp,
 2062             nam, &rdonly, kerbflag, pubflag);
 2063         if (error)
 2064                 goto out;
 2065         if (dp->v_type != VDIR) {
 2066                 vrele(dp);
 2067                 error = ENOTDIR;
 2068                 goto out;
 2069         }
 2070 
 2071         if (rdonly)
 2072                 cnp->cn_flags |= RDONLY;
 2073 
 2074         *retdirp = dp;
 2075 
 2076         if (pubflag) {
 2077                 /*
 2078                  * Oh joy. For WebNFS, handle those pesky '%' escapes,
 2079                  * and the 'native path' indicator.
 2080                  */
 2081                 cp = PNBUF_GET();
 2082                 fromcp = cnp->cn_pnbuf;
 2083                 tocp = cp;
 2084                 if ((unsigned char)*fromcp >= WEBNFS_SPECCHAR_START) {
 2085                         switch ((unsigned char)*fromcp) {
 2086                         case WEBNFS_NATIVE_CHAR:
 2087                                 /*
 2088                                  * 'Native' path for us is the same
 2089                                  * as a path according to the NFS spec,
 2090                                  * just skip the escape char.
 2091                                  */
 2092                                 fromcp++;
 2093                                 break;
 2094                         /*
 2095                          * More may be added in the future, range 0x80-0xff
 2096                          */
 2097                         default:
 2098                                 error = EIO;
 2099                                 PNBUF_PUT(cp);
 2100                                 goto out;
 2101                         }
 2102                 }
 2103                 /*
 2104                  * Translate the '%' escapes, URL-style.
 2105                  */
 2106                 while (*fromcp != '\0') {
 2107                         if (*fromcp == WEBNFS_ESC_CHAR) {
 2108                                 if (fromcp[1] != '\0' && fromcp[2] != '\0') {
 2109                                         fromcp++;
 2110                                         *tocp++ = HEXSTRTOI(fromcp);
 2111                                         fromcp += 2;
 2112                                         continue;
 2113                                 } else {
 2114                                         error = ENOENT;
 2115                                         PNBUF_PUT(cp);
 2116                                         goto out;
 2117                                 }
 2118                         } else
 2119                                 *tocp++ = *fromcp++;
 2120                 }
 2121                 *tocp = '\0';
 2122                 PNBUF_PUT(cnp->cn_pnbuf);
 2123                 cnp->cn_pnbuf = cp;
 2124         }
 2125 
 2126         ndp->ni_pathlen = (tocp - cnp->cn_pnbuf) + 1;
 2127         ndp->ni_segflg = UIO_SYSSPACE;
 2128         ndp->ni_rootdir = rootvnode;
 2129 
 2130         if (pubflag) {
 2131                 ndp->ni_loopcnt = 0;
 2132                 if (cnp->cn_pnbuf[0] == '/')
 2133                         dp = rootvnode;
 2134         } else {
 2135                 cnp->cn_flags |= NOCROSSMOUNT;
 2136         }
 2137 
 2138         cnp->cn_proc = p;
 2139         VREF(dp);
 2140 
 2141     for (;;) {
 2142         cnp->cn_nameptr = cnp->cn_pnbuf;
 2143         ndp->ni_startdir = dp;
 2144         /*
 2145          * And call lookup() to do the real work
 2146          */
 2147         error = lookup(ndp);
 2148         if (error) {
 2149                 PNBUF_PUT(cnp->cn_pnbuf);
 2150                 return (error);
 2151         }
 2152         /*
 2153          * Check for encountering a symbolic link
 2154          */
 2155         if ((cnp->cn_flags & ISSYMLINK) == 0) {
 2156                 if (cnp->cn_flags & (SAVENAME | SAVESTART))
 2157                         cnp->cn_flags |= HASBUF;
 2158                 else
 2159                         PNBUF_PUT(cnp->cn_pnbuf);
 2160                 return (0);
 2161         } else {
 2162                 if ((cnp->cn_flags & LOCKPARENT) && (cnp->cn_flags & ISLASTCN))
 2163                         VOP_UNLOCK(ndp->ni_dvp, 0);
 2164                 if (!pubflag) {
 2165                         error = EINVAL;
 2166                         break;
 2167                 }
 2168 
 2169                 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
 2170                         error = ELOOP;
 2171                         break;
 2172                 }
 2173                 if (ndp->ni_vp->v_mount->mnt_flag & MNT_SYMPERM) {
 2174                         error = VOP_ACCESS(ndp->ni_vp, VEXEC, cnp->cn_cred,
 2175                             cnp->cn_proc);
 2176                         if (error != 0)
 2177                                 break;
 2178                 }
 2179                 if (ndp->ni_pathlen > 1)
 2180                         cp = PNBUF_GET();
 2181                 else
 2182                         cp = cnp->cn_pnbuf;
 2183                 aiov.iov_base = cp;
 2184                 aiov.iov_len = MAXPATHLEN;
 2185                 auio.uio_iov = &aiov;
 2186                 auio.uio_iovcnt = 1;
 2187                 auio.uio_offset = 0;
 2188                 auio.uio_rw = UIO_READ;
 2189                 auio.uio_segflg = UIO_SYSSPACE;
 2190                 auio.uio_procp = (struct proc *)0;
 2191                 auio.uio_resid = MAXPATHLEN;
 2192                 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
 2193                 if (error) {
 2194                 badlink:
 2195                         if (ndp->ni_pathlen > 1)
 2196                                 PNBUF_PUT(cp);
 2197                         break;
 2198                 }
 2199                 linklen = MAXPATHLEN - auio.uio_resid;
 2200                 if (linklen == 0) {
 2201                         error = ENOENT;
 2202                         goto badlink;
 2203                 }
 2204                 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
 2205                         error = ENAMETOOLONG;
 2206                         goto badlink;
 2207                 }
 2208                 if (ndp->ni_pathlen > 1) {
 2209                         memcpy(cp + linklen, ndp->ni_next, ndp->ni_pathlen);
 2210                         PNBUF_PUT(cnp->cn_pnbuf);
 2211                         cnp->cn_pnbuf = cp;
 2212                 } else
 2213                         cnp->cn_pnbuf[linklen] = '\0';
 2214                 ndp->ni_pathlen += linklen;
 2215                 vput(ndp->ni_vp);
 2216                 dp = ndp->ni_dvp;
 2217                 /*
 2218                  * Check if root directory should replace current directory.
 2219                  */
 2220                 if (cnp->cn_pnbuf[0] == '/') {
 2221                         vrele(dp);
 2222                         dp = ndp->ni_rootdir;
 2223                         VREF(dp);
 2224                 }
 2225         }
 2226    }
 2227         vrele(ndp->ni_dvp);
 2228         vput(ndp->ni_vp);
 2229         ndp->ni_vp = NULL;
 2230 out:
 2231         PNBUF_PUT(cnp->cn_pnbuf);
 2232         return (error);
 2233 }
 2234 
 2235 /*
 2236  * A fiddled version of m_adj() that ensures null fill to a 32-bit
 2237  * boundary and only trims off the back end
 2238  *
 2239  * 1. trim off 'len' bytes as m_adj(mp, -len).
 2240  * 2. add zero-padding 'nul' bytes at the end of the mbuf chain.
 2241  */
 2242 void
 2243 nfs_zeropad(mp, len, nul)
 2244         struct mbuf *mp;
 2245         int len;
 2246         int nul;
 2247 {
 2248         struct mbuf *m;
 2249         int count;
 2250 
 2251         /*
 2252          * Trim from tail.  Scan the mbuf chain,
 2253          * calculating its length and finding the last mbuf.
 2254          * If the adjustment only affects this mbuf, then just
 2255          * adjust and return.  Otherwise, rescan and truncate
 2256          * after the remaining size.
 2257          */
 2258         count = 0;
 2259         m = mp;
 2260         for (;;) {
 2261                 count += m->m_len;
 2262                 if (m->m_next == NULL)
 2263                         break;
 2264                 m = m->m_next;
 2265         }
 2266 
 2267         KDASSERT(count >= len);
 2268 
 2269         if (m->m_len >= len) {
 2270                 m->m_len -= len;
 2271         } else {
 2272                 count -= len;
 2273                 /*
 2274                  * Correct length for chain is "count".
 2275                  * Find the mbuf with last data, adjust its length,
 2276                  * and toss data from remaining mbufs on chain.
 2277                  */
 2278                 for (m = mp; m; m = m->m_next) {
 2279                         if (m->m_len >= count) {
 2280                                 m->m_len = count;
 2281                                 break;
 2282                         }
 2283                         count -= m->m_len;
 2284                 }
 2285                 m_freem(m->m_next);
 2286                 m->m_next = NULL;
 2287         }
 2288 
 2289         KDASSERT(m->m_next == NULL);
 2290 
 2291         /*
 2292          * zero-padding.
 2293          */
 2294         if (nul > 0) {
 2295                 char *cp;
 2296                 int i;
 2297 
 2298                 if (M_ROMAP(m) || M_TRAILINGSPACE(m) < nul) {
 2299                         struct mbuf *n;
 2300 
 2301                         KDASSERT(MLEN >= nul);
 2302                         n = m_get(M_WAIT, MT_DATA);
 2303                         MCLAIM(n, &nfs_mowner);
 2304                         n->m_len = nul;
 2305                         n->m_next = NULL;
 2306                         m->m_next = n;
 2307                         cp = mtod(n, caddr_t);
 2308                 } else {
 2309                         cp = mtod(m, caddr_t) + m->m_len;
 2310                         m->m_len += nul;
 2311                 }
 2312                 for (i = 0; i < nul; i++)
 2313                         *cp++ = '\0';
 2314         }
 2315         return;
 2316 }
 2317 
 2318 /*
 2319  * Make these functions instead of macros, so that the kernel text size
 2320  * doesn't get too big...
 2321  */
 2322 void
 2323 nfsm_srvwcc(nfsd, before_ret, before_vap, after_ret, after_vap, mbp, bposp)
 2324         struct nfsrv_descript *nfsd;
 2325         int before_ret;
 2326         struct vattr *before_vap;
 2327         int after_ret;
 2328         struct vattr *after_vap;
 2329         struct mbuf **mbp;
 2330         char **bposp;
 2331 {
 2332         struct mbuf *mb = *mbp;
 2333         char *bpos = *bposp;
 2334         u_int32_t *tl;
 2335 
 2336         if (before_ret) {
 2337                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
 2338                 *tl = nfs_false;
 2339         } else {
 2340                 nfsm_build(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
 2341                 *tl++ = nfs_true;
 2342                 txdr_hyper(before_vap->va_size, tl);
 2343                 tl += 2;
 2344                 txdr_nfsv3time(&(before_vap->va_mtime), tl);
 2345                 tl += 2;
 2346                 txdr_nfsv3time(&(before_vap->va_ctime), tl);
 2347         }
 2348         *bposp = bpos;
 2349         *mbp = mb;
 2350         nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp);
 2351 }
 2352 
 2353 void
 2354 nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp)
 2355         struct nfsrv_descript *nfsd;
 2356         int after_ret;
 2357         struct vattr *after_vap;
 2358         struct mbuf **mbp;
 2359         char **bposp;
 2360 {
 2361         struct mbuf *mb = *mbp;
 2362         char *bpos = *bposp;
 2363         u_int32_t *tl;
 2364         struct nfs_fattr *fp;
 2365 
 2366         if (after_ret) {
 2367                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
 2368                 *tl = nfs_false;
 2369         } else {
 2370                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_V3FATTR);
 2371                 *tl++ = nfs_true;
 2372                 fp = (struct nfs_fattr *)tl;
 2373                 nfsm_srvfattr(nfsd, after_vap, fp);
 2374         }
 2375         *mbp = mb;
 2376         *bposp = bpos;
 2377 }
 2378 
 2379 void
 2380 nfsm_srvfattr(nfsd, vap, fp)
 2381         struct nfsrv_descript *nfsd;
 2382         struct vattr *vap;
 2383         struct nfs_fattr *fp;
 2384 {
 2385 
 2386         fp->fa_nlink = txdr_unsigned(vap->va_nlink);
 2387         fp->fa_uid = txdr_unsigned(vap->va_uid);
 2388         fp->fa_gid = txdr_unsigned(vap->va_gid);
 2389         if (nfsd->nd_flag & ND_NFSV3) {
 2390                 fp->fa_type = vtonfsv3_type(vap->va_type);
 2391                 fp->fa_mode = vtonfsv3_mode(vap->va_mode);
 2392                 txdr_hyper(vap->va_size, &fp->fa3_size);
 2393                 txdr_hyper(vap->va_bytes, &fp->fa3_used);
 2394                 fp->fa3_rdev.specdata1 = txdr_unsigned(major(vap->va_rdev));
 2395                 fp->fa3_rdev.specdata2 = txdr_unsigned(minor(vap->va_rdev));
 2396                 fp->fa3_fsid.nfsuquad[0] = 0;
 2397                 fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
 2398                 fp->fa3_fileid.nfsuquad[0] = 0;
 2399                 fp->fa3_fileid.nfsuquad[1] = txdr_unsigned(vap->va_fileid);
 2400                 txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
 2401                 txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
 2402                 txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
 2403         } else {
 2404                 fp->fa_type = vtonfsv2_type(vap->va_type);
 2405                 fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
 2406                 fp->fa2_size = txdr_unsigned(vap->va_size);
 2407                 fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
 2408                 if (vap->va_type == VFIFO)
 2409                         fp->fa2_rdev = 0xffffffff;
 2410                 else
 2411                         fp->fa2_rdev = txdr_unsigned(vap->va_rdev);
 2412                 fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
 2413                 fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
 2414                 fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
 2415                 txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
 2416                 txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
 2417                 txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
 2418         }
 2419 }
 2420 
 2421 /*
 2422  * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked)
 2423  *      - look up fsid in mount list (if not found ret error)
 2424  *      - get vp and export rights by calling VFS_FHTOVP()
 2425  *      - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon
 2426  *      - if not lockflag unlock it with VOP_UNLOCK()
 2427  */
 2428 int
 2429 nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag)
 2430         fhandle_t *fhp;
 2431         int lockflag;
 2432         struct vnode **vpp;
 2433         struct ucred *cred;
 2434         struct nfssvc_sock *slp;
 2435         struct mbuf *nam;
 2436         int *rdonlyp;
 2437         int kerbflag;
 2438 {
 2439         struct mount *mp;
 2440         int i;
 2441         struct ucred *credanon;
 2442         int error, exflags;
 2443         struct sockaddr_in *saddr;
 2444 
 2445         *vpp = (struct vnode *)0;
 2446 
 2447         if (nfs_ispublicfh(fhp)) {
 2448                 if (!pubflag || !nfs_pub.np_valid)
 2449                         return (ESTALE);
 2450                 fhp = &nfs_pub.np_handle;
 2451         }
 2452 
 2453         mp = vfs_getvfs(&fhp->fh_fsid);
 2454         if (!mp)
 2455                 return (ESTALE);
 2456         error = VFS_CHECKEXP(mp, nam, &exflags, &credanon);
 2457         if (error)
 2458                 return (error);
 2459         error = VFS_FHTOVP(mp, &fhp->fh_fid, vpp);
 2460         if (error)
 2461                 return (error);
 2462 
 2463         if (!(exflags & (MNT_EXNORESPORT|MNT_EXPUBLIC))) {
 2464                 saddr = mtod(nam, struct sockaddr_in *);
 2465                 if ((saddr->sin_family == AF_INET) &&
 2466                     ntohs(saddr->sin_port) >= IPPORT_RESERVED) {
 2467                         vput(*vpp);
 2468                         return (NFSERR_AUTHERR | AUTH_TOOWEAK);
 2469                 }
 2470 #ifdef INET6
 2471                 if ((saddr->sin_family == AF_INET6) &&
 2472                     ntohs(saddr->sin_port) >= IPV6PORT_RESERVED) {
 2473                         vput(*vpp);
 2474                         return (NFSERR_AUTHERR | AUTH_TOOWEAK);
 2475                 }
 2476 #endif
 2477         }
 2478         /*
 2479          * Check/setup credentials.
 2480          */
 2481         if (exflags & MNT_EXKERB) {
 2482                 if (!kerbflag) {
 2483                         vput(*vpp);
 2484                         return (NFSERR_AUTHERR | AUTH_TOOWEAK);
 2485                 }
 2486         } else if (kerbflag) {
 2487                 vput(*vpp);
 2488                 return (NFSERR_AUTHERR | AUTH_TOOWEAK);
 2489         } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
 2490                 cred->cr_uid = credanon->cr_uid;
 2491                 cred->cr_gid = credanon->cr_gid;
 2492                 for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++)
 2493                         cred->cr_groups[i] = credanon->cr_groups[i];
 2494                 cred->cr_ngroups = i;
 2495         }
 2496         if (exflags & MNT_EXRDONLY)
 2497                 *rdonlyp = 1;
 2498         else
 2499                 *rdonlyp = 0;
 2500         if (!lockflag)
 2501                 VOP_UNLOCK(*vpp, 0);
 2502         return (0);
 2503 }
 2504 
 2505 /*
 2506  * WebNFS: check if a filehandle is a public filehandle. For v3, this
 2507  * means a length of 0, for v2 it means all zeroes. nfsm_srvmtofh has
 2508  * transformed this to all zeroes in both cases, so check for it.
 2509  */
 2510 int
 2511 nfs_ispublicfh(fhp)
 2512         fhandle_t *fhp;
 2513 {
 2514         char *cp = (char *)fhp;
 2515         int i;
 2516 
 2517         for (i = 0; i < NFSX_V3FH; i++)
 2518                 if (*cp++ != 0)
 2519                         return (FALSE);
 2520         return (TRUE);
 2521 }
 2522 
 2523 /*
 2524  * This function compares two net addresses by family and returns TRUE
 2525  * if they are the same host.
 2526  * If there is any doubt, return FALSE.
 2527  * The AF_INET family is handled as a special case so that address mbufs
 2528  * don't need to be saved to store "struct in_addr", which is only 4 bytes.
 2529  */
 2530 int
 2531 netaddr_match(family, haddr, nam)
 2532         int family;
 2533         union nethostaddr *haddr;
 2534         struct mbuf *nam;
 2535 {
 2536         struct sockaddr_in *inetaddr;
 2537 
 2538         switch (family) {
 2539         case AF_INET:
 2540                 inetaddr = mtod(nam, struct sockaddr_in *);
 2541                 if (inetaddr->sin_family == AF_INET &&
 2542                     inetaddr->sin_addr.s_addr == haddr->had_inetaddr)
 2543                         return (1);
 2544                 break;
 2545 #ifdef INET6
 2546         case AF_INET6:
 2547             {
 2548                 struct sockaddr_in6 *sin6_1, *sin6_2;
 2549 
 2550                 sin6_1 = mtod(nam, struct sockaddr_in6 *);
 2551                 sin6_2 = mtod(haddr->had_nam, struct sockaddr_in6 *);
 2552                 if (sin6_1->sin6_family == AF_INET6 &&
 2553                     IN6_ARE_ADDR_EQUAL(&sin6_1->sin6_addr, &sin6_2->sin6_addr))
 2554                         return 1;
 2555             }
 2556 #endif
 2557 #ifdef ISO
 2558         case AF_ISO:
 2559             {
 2560                 struct sockaddr_iso *isoaddr1, *isoaddr2;
 2561 
 2562                 isoaddr1 = mtod(nam, struct sockaddr_iso *);
 2563                 isoaddr2 = mtod(haddr->had_nam, struct sockaddr_iso *);
 2564                 if (isoaddr1->siso_family == AF_ISO &&
 2565                     isoaddr1->siso_nlen > 0 &&
 2566                     isoaddr1->siso_nlen == isoaddr2->siso_nlen &&
 2567                     SAME_ISOADDR(isoaddr1, isoaddr2))
 2568                         return (1);
 2569                 break;
 2570             }
 2571 #endif  /* ISO */
 2572         default:
 2573                 break;
 2574         };
 2575         return (0);
 2576 }
 2577 
 2578 /*
 2579  * The write verifier has changed (probably due to a server reboot), so all
 2580  * PG_NEEDCOMMIT pages will have to be written again. Since they are marked
 2581  * as dirty or are being written out just now, all this takes is clearing
 2582  * the PG_NEEDCOMMIT flag. Once done the new write verifier can be set for
 2583  * the mount point.
 2584  */
 2585 void
 2586 nfs_clearcommit(mp)
 2587         struct mount *mp;
 2588 {
 2589         struct vnode *vp;
 2590         struct nfsnode *np;
 2591         struct vm_page *pg;
 2592         struct nfsmount *nmp = VFSTONFS(mp);
 2593 
 2594         lockmgr(&nmp->nm_writeverflock, LK_EXCLUSIVE, NULL);
 2595 
 2596         LIST_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
 2597                 KASSERT(vp->v_mount == mp);
 2598                 if (vp->v_type != VREG)
 2599                         continue;
 2600                 np = VTONFS(vp);
 2601                 np->n_pushlo = np->n_pushhi = np->n_pushedlo =
 2602                     np->n_pushedhi = 0;
 2603                 np->n_commitflags &=
 2604                     ~(NFS_COMMIT_PUSH_VALID | NFS_COMMIT_PUSHED_VALID);
 2605                 simple_lock(&vp->v_uobj.vmobjlock);
 2606                 TAILQ_FOREACH(pg, &vp->v_uobj.memq, listq) {
 2607                         pg->flags &= ~PG_NEEDCOMMIT;
 2608                 }
 2609                 simple_unlock(&vp->v_uobj.vmobjlock);
 2610         }
 2611         simple_lock(&nmp->nm_slock);
 2612         nmp->nm_iflag &= ~NFSMNT_STALEWRITEVERF;
 2613         simple_unlock(&nmp->nm_slock);
 2614         lockmgr(&nmp->nm_writeverflock, LK_RELEASE, NULL);
 2615 }
 2616 
 2617 void
 2618 nfs_merge_commit_ranges(vp)
 2619         struct vnode *vp;
 2620 {
 2621         struct nfsnode *np = VTONFS(vp);
 2622 
 2623         KASSERT(np->n_commitflags & NFS_COMMIT_PUSH_VALID);
 2624 
 2625         if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID)) {
 2626                 np->n_pushedlo = np->n_pushlo;
 2627                 np->n_pushedhi = np->n_pushhi;
 2628                 np->n_commitflags |= NFS_COMMIT_PUSHED_VALID;
 2629         } else {
 2630                 if (np->n_pushlo < np->n_pushedlo)
 2631                         np->n_pushedlo = np->n_pushlo;
 2632                 if (np->n_pushhi > np->n_pushedhi)
 2633                         np->n_pushedhi = np->n_pushhi;
 2634         }
 2635 
 2636         np->n_pushlo = np->n_pushhi = 0;
 2637         np->n_commitflags &= ~NFS_COMMIT_PUSH_VALID;
 2638 
 2639 #ifdef NFS_DEBUG_COMMIT
 2640         printf("merge: committed: %u - %u\n", (unsigned)np->n_pushedlo,
 2641             (unsigned)np->n_pushedhi);
 2642 #endif
 2643 }
 2644 
 2645 int
 2646 nfs_in_committed_range(vp, off, len)
 2647         struct vnode *vp;
 2648         off_t off, len;
 2649 {
 2650         struct nfsnode *np = VTONFS(vp);
 2651         off_t lo, hi;
 2652 
 2653         if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID))
 2654                 return 0;
 2655         lo = off;
 2656         hi = lo + len;
 2657 
 2658         return (lo >= np->n_pushedlo && hi <= np->n_pushedhi);
 2659 }
 2660 
 2661 int
 2662 nfs_in_tobecommitted_range(vp, off, len)
 2663         struct vnode *vp;
 2664         off_t off, len;
 2665 {
 2666         struct nfsnode *np = VTONFS(vp);
 2667         off_t lo, hi;
 2668 
 2669         if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID))
 2670                 return 0;
 2671         lo = off;
 2672         hi = lo + len;
 2673 
 2674         return (lo >= np->n_pushlo && hi <= np->n_pushhi);
 2675 }
 2676 
 2677 void
 2678 nfs_add_committed_range(vp, off, len)
 2679         struct vnode *vp;
 2680         off_t off, len;
 2681 {
 2682         struct nfsnode *np = VTONFS(vp);
 2683         off_t lo, hi;
 2684 
 2685         lo = off;
 2686         hi = lo + len;
 2687 
 2688         if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID)) {
 2689                 np->n_pushedlo = lo;
 2690                 np->n_pushedhi = hi;
 2691                 np->n_commitflags |= NFS_COMMIT_PUSHED_VALID;
 2692         } else {
 2693                 if (hi > np->n_pushedhi)
 2694                         np->n_pushedhi = hi;
 2695                 if (lo < np->n_pushedlo)
 2696                         np->n_pushedlo = lo;
 2697         }
 2698 #ifdef NFS_DEBUG_COMMIT
 2699         printf("add: committed: %u - %u\n", (unsigned)np->n_pushedlo,
 2700             (unsigned)np->n_pushedhi);
 2701 #endif
 2702 }
 2703 
 2704 void
 2705 nfs_del_committed_range(vp, off, len)
 2706         struct vnode *vp;
 2707         off_t off, len;
 2708 {
 2709         struct nfsnode *np = VTONFS(vp);
 2710         off_t lo, hi;
 2711 
 2712         if (!(np->n_commitflags & NFS_COMMIT_PUSHED_VALID))
 2713                 return;
 2714 
 2715         lo = off;
 2716         hi = lo + len;
 2717 
 2718         if (lo > np->n_pushedhi || hi < np->n_pushedlo)
 2719                 return;
 2720         if (lo <= np->n_pushedlo)
 2721                 np->n_pushedlo = hi;
 2722         else if (hi >= np->n_pushedhi)
 2723                 np->n_pushedhi = lo;
 2724         else {
 2725                 /*
 2726                  * XXX There's only one range. If the deleted range
 2727                  * is in the middle, pick the largest of the
 2728                  * contiguous ranges that it leaves.
 2729                  */
 2730                 if ((np->n_pushedlo - lo) > (hi - np->n_pushedhi))
 2731                         np->n_pushedhi = lo;
 2732                 else
 2733                         np->n_pushedlo = hi;
 2734         }
 2735 #ifdef NFS_DEBUG_COMMIT
 2736         printf("del: committed: %u - %u\n", (unsigned)np->n_pushedlo,
 2737             (unsigned)np->n_pushedhi);
 2738 #endif
 2739 }
 2740 
 2741 void
 2742 nfs_add_tobecommitted_range(vp, off, len)
 2743         struct vnode *vp;
 2744         off_t off, len;
 2745 {
 2746         struct nfsnode *np = VTONFS(vp);
 2747         off_t lo, hi;
 2748 
 2749         lo = off;
 2750         hi = lo + len;
 2751 
 2752         if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID)) {
 2753                 np->n_pushlo = lo;
 2754                 np->n_pushhi = hi;
 2755                 np->n_commitflags |= NFS_COMMIT_PUSH_VALID;
 2756         } else {
 2757                 if (lo < np->n_pushlo)
 2758                         np->n_pushlo = lo;
 2759                 if (hi > np->n_pushhi)
 2760                         np->n_pushhi = hi;
 2761         }
 2762 #ifdef NFS_DEBUG_COMMIT
 2763         printf("add: tobecommitted: %u - %u\n", (unsigned)np->n_pushlo,
 2764             (unsigned)np->n_pushhi);
 2765 #endif
 2766 }
 2767 
 2768 void
 2769 nfs_del_tobecommitted_range(vp, off, len)
 2770         struct vnode *vp;
 2771         off_t off, len;
 2772 {
 2773         struct nfsnode *np = VTONFS(vp);
 2774         off_t lo, hi;
 2775 
 2776         if (!(np->n_commitflags & NFS_COMMIT_PUSH_VALID))
 2777                 return;
 2778 
 2779         lo = off;
 2780         hi = lo + len;
 2781 
 2782         if (lo > np->n_pushhi || hi < np->n_pushlo)
 2783                 return;
 2784 
 2785         if (lo <= np->n_pushlo)
 2786                 np->n_pushlo = hi;
 2787         else if (hi >= np->n_pushhi)
 2788                 np->n_pushhi = lo;
 2789         else {
 2790                 /*
 2791                  * XXX There's only one range. If the deleted range
 2792                  * is in the middle, pick the largest of the
 2793                  * contiguous ranges that it leaves.
 2794                  */
 2795                 if ((np->n_pushlo - lo) > (hi - np->n_pushhi))
 2796                         np->n_pushhi = lo;
 2797                 else
 2798                         np->n_pushlo = hi;
 2799         }
 2800 #ifdef NFS_DEBUG_COMMIT
 2801         printf("del: tobecommitted: %u - %u\n", (unsigned)np->n_pushlo,
 2802             (unsigned)np->n_pushhi);
 2803 #endif
 2804 }
 2805 
 2806 /*
 2807  * Map errnos to NFS error numbers. For Version 3 also filter out error
 2808  * numbers not specified for the associated procedure.
 2809  */
 2810 int
 2811 nfsrv_errmap(nd, err)
 2812         struct nfsrv_descript *nd;
 2813         int err;
 2814 {
 2815         const short *defaulterrp, *errp;
 2816 
 2817         if (nd->nd_flag & ND_NFSV3) {
 2818             if (nd->nd_procnum <= NFSPROC_COMMIT) {
 2819                 errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
 2820                 while (*++errp) {
 2821                         if (*errp == err)
 2822                                 return (err);
 2823                         else if (*errp > err)
 2824                                 break;
 2825                 }
 2826                 return ((int)*defaulterrp);
 2827             } else
 2828                 return (err & 0xffff);
 2829         }
 2830         if (err <= ELAST)
 2831                 return ((int)nfsrv_v2errmap[err - 1]);
 2832         return (NFSERR_IO);
 2833 }
 2834 
 2835 /*
 2836  * Sort the group list in increasing numerical order.
 2837  * (Insertion sort by Chris Torek, who was grossed out by the bubble sort
 2838  *  that used to be here.)
 2839  */
 2840 void
 2841 nfsrvw_sort(list, num)
 2842         gid_t *list;
 2843         int num;
 2844 {
 2845         int i, j;
 2846         gid_t v;
 2847 
 2848         /* Insertion sort. */
 2849         for (i = 1; i < num; i++) {
 2850                 v = list[i];
 2851                 /* find correct slot for value v, moving others up */
 2852                 for (j = i; --j >= 0 && v < list[j];)
 2853                         list[j + 1] = list[j];
 2854                 list[j + 1] = v;
 2855         }
 2856 }
 2857 
 2858 /*
 2859  * copy credentials making sure that the result can be compared with memcmp().
 2860  */
 2861 void
 2862 nfsrv_setcred(incred, outcred)
 2863         struct ucred *incred, *outcred;
 2864 {
 2865         int i;
 2866 
 2867         memset((caddr_t)outcred, 0, sizeof (struct ucred));
 2868         outcred->cr_ref = 1;
 2869         outcred->cr_uid = incred->cr_uid;
 2870         outcred->cr_gid = incred->cr_gid;
 2871         outcred->cr_ngroups = incred->cr_ngroups;
 2872         for (i = 0; i < incred->cr_ngroups; i++)
 2873                 outcred->cr_groups[i] = incred->cr_groups[i];
 2874         nfsrvw_sort(outcred->cr_groups, outcred->cr_ngroups);
 2875 }
 2876 
 2877 u_int32_t
 2878 nfs_getxid()
 2879 {
 2880         static u_int32_t base;
 2881         static u_int32_t nfs_xid = 0;
 2882         static struct simplelock nfs_xidlock = SIMPLELOCK_INITIALIZER;
 2883         u_int32_t newxid;
 2884 
 2885         simple_lock(&nfs_xidlock);
 2886         /*
 2887          * derive initial xid from system time
 2888          * XXX time is invalid if root not yet mounted
 2889          */
 2890         if (__predict_false(!base && (rootvp))) {
 2891                 struct timeval tv;
 2892 
 2893                 microtime(&tv);
 2894                 base = tv.tv_sec << 12;
 2895                 nfs_xid = base;
 2896         }
 2897 
 2898         /*
 2899          * Skip zero xid if it should ever happen.
 2900          */
 2901         if (__predict_false(++nfs_xid == 0))
 2902                 nfs_xid++;
 2903         newxid = nfs_xid;
 2904         simple_unlock(&nfs_xidlock);
 2905 
 2906         return txdr_unsigned(newxid);
 2907 }
 2908 
 2909 /*
 2910  * assign a new xid for existing request.
 2911  * used for NFSERR_JUKEBOX handling.
 2912  */
 2913 void
 2914 nfs_renewxid(struct nfsreq *req)
 2915 {
 2916         u_int32_t xid;
 2917         int off;
 2918 
 2919         xid = nfs_getxid();
 2920         if (req->r_nmp->nm_sotype == SOCK_STREAM)
 2921                 off = sizeof(u_int32_t); /* RPC record mark */
 2922         else
 2923                 off = 0;
 2924 
 2925         m_copyback(req->r_mreq, off, sizeof(xid), (void *)&xid);
 2926         req->r_xid = xid;
 2927 }

Cache object: 2d3709e2bdd51603d47db6861da062a5


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.