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/nfsserver/nfs_srvsubs.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 /*-
    2  * Copyright (c) 1989, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * This code is derived from software contributed to Berkeley by
    6  * Rick Macklem at The University of Guelph.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 4. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      @(#)nfs_subs.c  8.8 (Berkeley) 5/22/95
   33  */
   34 
   35 #include <sys/cdefs.h>
   36 __FBSDID("$FreeBSD$");
   37 
   38 /*
   39  * These functions support the macros and help fiddle mbuf chains for
   40  * the nfs op functions. They do things like create the rpc header and
   41  * copy data between mbuf chains and uio lists.
   42  */
   43 
   44 #include "opt_inet6.h"
   45 
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/kernel.h>
   49 #include <sys/bio.h>
   50 #include <sys/buf.h>
   51 #include <sys/proc.h>
   52 #include <sys/mount.h>
   53 #include <sys/vnode.h>
   54 #include <sys/namei.h>
   55 #include <sys/mbuf.h>
   56 #include <sys/refcount.h>
   57 #include <sys/socket.h>
   58 #include <sys/stat.h>
   59 #include <sys/malloc.h>
   60 #include <sys/module.h>
   61 #include <sys/sysent.h>
   62 #include <sys/syscall.h>
   63 #include <sys/sysproto.h>
   64 
   65 #include <vm/vm.h>
   66 #include <vm/vm_object.h>
   67 #include <vm/vm_extern.h>
   68 #include <vm/uma.h>
   69 
   70 #include <nfs/rpcv2.h>
   71 #include <nfs/nfsproto.h>
   72 #include <nfsserver/nfs.h>
   73 #include <nfs/xdr_subs.h>
   74 #include <nfsserver/nfsm_subs.h>
   75 
   76 #include <netinet/in.h>
   77 
   78 /*
   79  * Data items converted to xdr at startup, since they are constant
   80  * This is kinda hokey, but may save a little time doing byte swaps
   81  */
   82 u_int32_t nfsrv_nfs_xdrneg1;
   83 u_int32_t nfsrv_rpc_call, nfsrv_rpc_vers, nfsrv_rpc_reply,
   84         nfsrv_rpc_msgdenied, nfsrv_rpc_autherr,
   85         nfsrv_rpc_mismatch, nfsrv_rpc_auth_unix, nfsrv_rpc_msgaccepted;
   86 u_int32_t nfsrv_nfs_prog, nfsrv_nfs_true, nfsrv_nfs_false;
   87 
   88 /* And other global data */
   89 static const nfstype nfsv2_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR,
   90                                        NFLNK, NFNON, NFCHR, NFNON };
   91 #define vtonfsv2_type(a)        txdr_unsigned(nfsv2_type[((int32_t)(a))])
   92 #define vtonfsv3_mode(m)        txdr_unsigned((m) & ALLPERMS)
   93 
   94 int nfsrv_ticks;
   95 
   96 struct nfssvc_sockhead nfssvc_sockhead;
   97 int nfssvc_sockhead_flag;
   98 struct nfsd_head nfsd_head;
   99 int nfsd_head_flag;
  100 
  101 static int nfssvc_offset = SYS_nfssvc;
  102 static struct sysent nfssvc_prev_sysent;
  103 MAKE_SYSENT(nfssvc);
  104 
  105 struct mtx nfsd_mtx;
  106 
  107 /*
  108  * Mapping of old NFS Version 2 RPC numbers to generic numbers.
  109  */
  110 const int nfsrv_nfsv3_procid[NFS_NPROCS] = {
  111         NFSPROC_NULL,
  112         NFSPROC_GETATTR,
  113         NFSPROC_SETATTR,
  114         NFSPROC_NOOP,
  115         NFSPROC_LOOKUP,
  116         NFSPROC_READLINK,
  117         NFSPROC_READ,
  118         NFSPROC_NOOP,
  119         NFSPROC_WRITE,
  120         NFSPROC_CREATE,
  121         NFSPROC_REMOVE,
  122         NFSPROC_RENAME,
  123         NFSPROC_LINK,
  124         NFSPROC_SYMLINK,
  125         NFSPROC_MKDIR,
  126         NFSPROC_RMDIR,
  127         NFSPROC_READDIR,
  128         NFSPROC_FSSTAT,
  129         NFSPROC_NOOP,
  130         NFSPROC_NOOP,
  131         NFSPROC_NOOP,
  132         NFSPROC_NOOP,
  133         NFSPROC_NOOP,
  134 };
  135 
  136 /*
  137  * and the reverse mapping from generic to Version 2 procedure numbers
  138  */
  139 const int nfsrvv2_procid[NFS_NPROCS] = {
  140         NFSV2PROC_NULL,
  141         NFSV2PROC_GETATTR,
  142         NFSV2PROC_SETATTR,
  143         NFSV2PROC_LOOKUP,
  144         NFSV2PROC_NOOP,
  145         NFSV2PROC_READLINK,
  146         NFSV2PROC_READ,
  147         NFSV2PROC_WRITE,
  148         NFSV2PROC_CREATE,
  149         NFSV2PROC_MKDIR,
  150         NFSV2PROC_SYMLINK,
  151         NFSV2PROC_CREATE,
  152         NFSV2PROC_REMOVE,
  153         NFSV2PROC_RMDIR,
  154         NFSV2PROC_RENAME,
  155         NFSV2PROC_LINK,
  156         NFSV2PROC_READDIR,
  157         NFSV2PROC_NOOP,
  158         NFSV2PROC_STATFS,
  159         NFSV2PROC_NOOP,
  160         NFSV2PROC_NOOP,
  161         NFSV2PROC_NOOP,
  162         NFSV2PROC_NOOP,
  163 };
  164 
  165 /*
  166  * Maps errno values to nfs error numbers.
  167  * Use 0 (which gets converted to NFSERR_IO) as the catch all for ones not
  168  * specifically defined in RFC 1094.
  169  */
  170 static const u_char nfsrv_v2errmap[ELAST] = {
  171   NFSERR_PERM,  NFSERR_NOENT,   0,              0,              0,      
  172   NFSERR_NXIO,  0,              0,              0,              0,      
  173   0,            0,              NFSERR_ACCES,   0,              0,      
  174   0,            NFSERR_EXIST,   0,              NFSERR_NODEV,   NFSERR_NOTDIR,
  175   NFSERR_ISDIR, 0,              0,              0,              0,      
  176   0,            NFSERR_FBIG,    NFSERR_NOSPC,   0,              NFSERR_ROFS,
  177   0,            0,              0,              0,              0,      
  178   0,            0,              0,              0,              0,      
  179   0,            0,              0,              0,              0,      
  180   0,            0,              0,              0,              0,      
  181   0,            0,              0,              0,              0,      
  182   0,            0,              0,              0,              0,      
  183   0,            0,              NFSERR_NAMETOL, 0,              0,      
  184   NFSERR_NOTEMPTY, 0,           0,              NFSERR_DQUOT,   NFSERR_STALE,
  185   0
  186 };
  187 
  188 /*
  189  * Maps errno values to nfs error numbers.
  190  * Although it is not obvious whether or not NFS clients really care if
  191  * a returned error value is in the specified list for the procedure, the
  192  * safest thing to do is filter them appropriately. For Version 2, the
  193  * X/Open XNFS document is the only specification that defines error values
  194  * for each RPC (The RFC simply lists all possible error values for all RPCs),
  195  * so I have decided to not do this for Version 2.
  196  * The first entry is the default error return and the rest are the valid
  197  * errors for that RPC in increasing numeric order.
  198  */
  199 static const short nfsv3err_null[] = {
  200         0,
  201         0,
  202 };
  203 
  204 static const short nfsv3err_getattr[] = {
  205         NFSERR_IO,
  206         NFSERR_IO,
  207         NFSERR_STALE,
  208         NFSERR_BADHANDLE,
  209         NFSERR_SERVERFAULT,
  210         0,
  211 };
  212 
  213 static const short nfsv3err_setattr[] = {
  214         NFSERR_IO,
  215         NFSERR_PERM,
  216         NFSERR_IO,
  217         NFSERR_ACCES,
  218         NFSERR_INVAL,
  219         NFSERR_NOSPC,
  220         NFSERR_ROFS,
  221         NFSERR_DQUOT,
  222         NFSERR_STALE,
  223         NFSERR_BADHANDLE,
  224         NFSERR_NOT_SYNC,
  225         NFSERR_SERVERFAULT,
  226         0,
  227 };
  228 
  229 static const short nfsv3err_lookup[] = {
  230         NFSERR_IO,
  231         NFSERR_NOENT,
  232         NFSERR_IO,
  233         NFSERR_ACCES,
  234         NFSERR_NOTDIR,
  235         NFSERR_NAMETOL,
  236         NFSERR_STALE,
  237         NFSERR_BADHANDLE,
  238         NFSERR_SERVERFAULT,
  239         0,
  240 };
  241 
  242 static const short nfsv3err_access[] = {
  243         NFSERR_IO,
  244         NFSERR_IO,
  245         NFSERR_STALE,
  246         NFSERR_BADHANDLE,
  247         NFSERR_SERVERFAULT,
  248         0,
  249 };
  250 
  251 static const short nfsv3err_readlink[] = {
  252         NFSERR_IO,
  253         NFSERR_IO,
  254         NFSERR_ACCES,
  255         NFSERR_INVAL,
  256         NFSERR_STALE,
  257         NFSERR_BADHANDLE,
  258         NFSERR_NOTSUPP,
  259         NFSERR_SERVERFAULT,
  260         0,
  261 };
  262 
  263 static const short nfsv3err_read[] = {
  264         NFSERR_IO,
  265         NFSERR_IO,
  266         NFSERR_NXIO,
  267         NFSERR_ACCES,
  268         NFSERR_INVAL,
  269         NFSERR_STALE,
  270         NFSERR_BADHANDLE,
  271         NFSERR_SERVERFAULT,
  272         0,
  273 };
  274 
  275 static const short nfsv3err_write[] = {
  276         NFSERR_IO,
  277         NFSERR_IO,
  278         NFSERR_ACCES,
  279         NFSERR_INVAL,
  280         NFSERR_FBIG,
  281         NFSERR_NOSPC,
  282         NFSERR_ROFS,
  283         NFSERR_DQUOT,
  284         NFSERR_STALE,
  285         NFSERR_BADHANDLE,
  286         NFSERR_SERVERFAULT,
  287         0,
  288 };
  289 
  290 static const short nfsv3err_create[] = {
  291         NFSERR_IO,
  292         NFSERR_IO,
  293         NFSERR_ACCES,
  294         NFSERR_EXIST,
  295         NFSERR_NOTDIR,
  296         NFSERR_NOSPC,
  297         NFSERR_ROFS,
  298         NFSERR_NAMETOL,
  299         NFSERR_DQUOT,
  300         NFSERR_STALE,
  301         NFSERR_BADHANDLE,
  302         NFSERR_NOTSUPP,
  303         NFSERR_SERVERFAULT,
  304         0,
  305 };
  306 
  307 static const short nfsv3err_mkdir[] = {
  308         NFSERR_IO,
  309         NFSERR_IO,
  310         NFSERR_ACCES,
  311         NFSERR_EXIST,
  312         NFSERR_NOTDIR,
  313         NFSERR_NOSPC,
  314         NFSERR_ROFS,
  315         NFSERR_NAMETOL,
  316         NFSERR_DQUOT,
  317         NFSERR_STALE,
  318         NFSERR_BADHANDLE,
  319         NFSERR_NOTSUPP,
  320         NFSERR_SERVERFAULT,
  321         0,
  322 };
  323 
  324 static const short nfsv3err_symlink[] = {
  325         NFSERR_IO,
  326         NFSERR_IO,
  327         NFSERR_ACCES,
  328         NFSERR_EXIST,
  329         NFSERR_NOTDIR,
  330         NFSERR_NOSPC,
  331         NFSERR_ROFS,
  332         NFSERR_NAMETOL,
  333         NFSERR_DQUOT,
  334         NFSERR_STALE,
  335         NFSERR_BADHANDLE,
  336         NFSERR_NOTSUPP,
  337         NFSERR_SERVERFAULT,
  338         0,
  339 };
  340 
  341 static const short nfsv3err_mknod[] = {
  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         NFSERR_BADTYPE,
  356         0,
  357 };
  358 
  359 static const short nfsv3err_remove[] = {
  360         NFSERR_IO,
  361         NFSERR_NOENT,
  362         NFSERR_IO,
  363         NFSERR_ACCES,
  364         NFSERR_NOTDIR,
  365         NFSERR_ROFS,
  366         NFSERR_NAMETOL,
  367         NFSERR_STALE,
  368         NFSERR_BADHANDLE,
  369         NFSERR_SERVERFAULT,
  370         0,
  371 };
  372 
  373 static const short nfsv3err_rmdir[] = {
  374         NFSERR_IO,
  375         NFSERR_NOENT,
  376         NFSERR_IO,
  377         NFSERR_ACCES,
  378         NFSERR_EXIST,
  379         NFSERR_NOTDIR,
  380         NFSERR_INVAL,
  381         NFSERR_ROFS,
  382         NFSERR_NAMETOL,
  383         NFSERR_NOTEMPTY,
  384         NFSERR_STALE,
  385         NFSERR_BADHANDLE,
  386         NFSERR_NOTSUPP,
  387         NFSERR_SERVERFAULT,
  388         0,
  389 };
  390 
  391 static const short nfsv3err_rename[] = {
  392         NFSERR_IO,
  393         NFSERR_NOENT,
  394         NFSERR_IO,
  395         NFSERR_ACCES,
  396         NFSERR_EXIST,
  397         NFSERR_XDEV,
  398         NFSERR_NOTDIR,
  399         NFSERR_ISDIR,
  400         NFSERR_INVAL,
  401         NFSERR_NOSPC,
  402         NFSERR_ROFS,
  403         NFSERR_MLINK,
  404         NFSERR_NAMETOL,
  405         NFSERR_NOTEMPTY,
  406         NFSERR_DQUOT,
  407         NFSERR_STALE,
  408         NFSERR_BADHANDLE,
  409         NFSERR_NOTSUPP,
  410         NFSERR_SERVERFAULT,
  411         0,
  412 };
  413 
  414 static const short nfsv3err_link[] = {
  415         NFSERR_IO,
  416         NFSERR_IO,
  417         NFSERR_ACCES,
  418         NFSERR_EXIST,
  419         NFSERR_XDEV,
  420         NFSERR_NOTDIR,
  421         NFSERR_INVAL,
  422         NFSERR_NOSPC,
  423         NFSERR_ROFS,
  424         NFSERR_MLINK,
  425         NFSERR_NAMETOL,
  426         NFSERR_DQUOT,
  427         NFSERR_STALE,
  428         NFSERR_BADHANDLE,
  429         NFSERR_NOTSUPP,
  430         NFSERR_SERVERFAULT,
  431         0,
  432 };
  433 
  434 static const short nfsv3err_readdir[] = {
  435         NFSERR_IO,
  436         NFSERR_IO,
  437         NFSERR_ACCES,
  438         NFSERR_NOTDIR,
  439         NFSERR_STALE,
  440         NFSERR_BADHANDLE,
  441         NFSERR_BAD_COOKIE,
  442         NFSERR_TOOSMALL,
  443         NFSERR_SERVERFAULT,
  444         0,
  445 };
  446 
  447 static const short nfsv3err_readdirplus[] = {
  448         NFSERR_IO,
  449         NFSERR_IO,
  450         NFSERR_ACCES,
  451         NFSERR_NOTDIR,
  452         NFSERR_STALE,
  453         NFSERR_BADHANDLE,
  454         NFSERR_BAD_COOKIE,
  455         NFSERR_NOTSUPP,
  456         NFSERR_TOOSMALL,
  457         NFSERR_SERVERFAULT,
  458         0,
  459 };
  460 
  461 static const short nfsv3err_fsstat[] = {
  462         NFSERR_IO,
  463         NFSERR_IO,
  464         NFSERR_STALE,
  465         NFSERR_BADHANDLE,
  466         NFSERR_SERVERFAULT,
  467         0,
  468 };
  469 
  470 static const short nfsv3err_fsinfo[] = {
  471         NFSERR_STALE,
  472         NFSERR_STALE,
  473         NFSERR_BADHANDLE,
  474         NFSERR_SERVERFAULT,
  475         0,
  476 };
  477 
  478 static const short nfsv3err_pathconf[] = {
  479         NFSERR_STALE,
  480         NFSERR_STALE,
  481         NFSERR_BADHANDLE,
  482         NFSERR_SERVERFAULT,
  483         0,
  484 };
  485 
  486 static const short nfsv3err_commit[] = {
  487         NFSERR_IO,
  488         NFSERR_IO,
  489         NFSERR_STALE,
  490         NFSERR_BADHANDLE,
  491         NFSERR_SERVERFAULT,
  492         0,
  493 };
  494 
  495 static const short *nfsrv_v3errmap[] = {
  496         nfsv3err_null,
  497         nfsv3err_getattr,
  498         nfsv3err_setattr,
  499         nfsv3err_lookup,
  500         nfsv3err_access,
  501         nfsv3err_readlink,
  502         nfsv3err_read,
  503         nfsv3err_write,
  504         nfsv3err_create,
  505         nfsv3err_mkdir,
  506         nfsv3err_symlink,
  507         nfsv3err_mknod,
  508         nfsv3err_remove,
  509         nfsv3err_rmdir,
  510         nfsv3err_rename,
  511         nfsv3err_link,
  512         nfsv3err_readdir,
  513         nfsv3err_readdirplus,
  514         nfsv3err_fsstat,
  515         nfsv3err_fsinfo,
  516         nfsv3err_pathconf,
  517         nfsv3err_commit,
  518 };
  519 
  520 /*
  521  * Called once to initialize data structures...
  522  */
  523 static int
  524 nfsrv_modevent(module_t mod, int type, void *data)
  525 {
  526         static int registered;
  527         int error = 0;
  528 
  529         switch (type) {
  530         case MOD_LOAD:
  531                 mtx_init(&nfsd_mtx, "nfsd_mtx", NULL, MTX_DEF);
  532                 nfsrv_rpc_vers = txdr_unsigned(RPC_VER2);
  533                 nfsrv_rpc_call = txdr_unsigned(RPC_CALL);
  534                 nfsrv_rpc_reply = txdr_unsigned(RPC_REPLY);
  535                 nfsrv_rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
  536                 nfsrv_rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
  537                 nfsrv_rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
  538                 nfsrv_rpc_autherr = txdr_unsigned(RPC_AUTHERR);
  539                 nfsrv_rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
  540                 nfsrv_nfs_prog = txdr_unsigned(NFS_PROG);
  541                 nfsrv_nfs_true = txdr_unsigned(TRUE);
  542                 nfsrv_nfs_false = txdr_unsigned(FALSE);
  543                 nfsrv_nfs_xdrneg1 = txdr_unsigned(-1);
  544                 nfsrv_ticks = (hz * NFS_TICKINTVL + 500) / 1000;
  545                 if (nfsrv_ticks < 1)
  546                         nfsrv_ticks = 1;
  547 
  548                 nfsrv_initcache();      /* Init the server request cache */
  549                 NFSD_LOCK();
  550                 nfsrv_init(0);          /* Init server data structures */
  551                 callout_init(&nfsrv_callout, CALLOUT_MPSAFE);
  552                 NFSD_UNLOCK();
  553                 nfsrv_timer(0);
  554 
  555                 error = syscall_register(&nfssvc_offset, &nfssvc_sysent,
  556                     &nfssvc_prev_sysent);
  557                 if (error)
  558                         break;
  559                 registered = 1;
  560                 break;
  561 
  562         case MOD_UNLOAD:
  563                 if (nfsrv_numnfsd != 0) {
  564                         error = EBUSY;
  565                         break;
  566                 }
  567 
  568                 if (registered)
  569                         syscall_deregister(&nfssvc_offset, &nfssvc_prev_sysent);
  570                 callout_drain(&nfsrv_callout);
  571                 nfsrv_destroycache();   /* Free the server request cache */
  572                 mtx_destroy(&nfsd_mtx);
  573                 break;
  574         default:
  575                 error = EOPNOTSUPP;
  576                 break;
  577         }
  578         return error;
  579 }
  580 static moduledata_t nfsserver_mod = {
  581         "nfsserver",
  582         nfsrv_modevent,
  583         NULL,
  584 };
  585 DECLARE_MODULE(nfsserver, nfsserver_mod, SI_SUB_VFS, SI_ORDER_ANY);
  586 
  587 /* So that loader and kldload(2) can find us, wherever we are.. */
  588 MODULE_VERSION(nfsserver, 1);
  589 
  590 /*
  591  * Set up nameidata for a lookup() call and do it.
  592  *
  593  * If pubflag is set, this call is done for a lookup operation on the
  594  * public filehandle. In that case we allow crossing mountpoints and
  595  * absolute pathnames. However, the caller is expected to check that
  596  * the lookup result is within the public fs, and deny access if
  597  * it is not.
  598  *
  599  * nfs_namei() clears out garbage fields that namei() might leave garbage.
  600  * This is mainly ni_vp and ni_dvp when an error occurs, and ni_dvp when no
  601  * error occurs but the parent was not requested.
  602  *
  603  * dirp may be set whether an error is returned or not, and must be
  604  * released by the caller.
  605  */
  606 int
  607 nfs_namei(struct nameidata *ndp, fhandle_t *fhp, int len,
  608     struct nfssvc_sock *slp, struct sockaddr *nam, struct mbuf **mdp,
  609     caddr_t *dposp, struct vnode **retdirp, int v3, struct vattr *retdirattrp,
  610     int *retdirattr_retp, struct thread *td, int pubflag)
  611 {
  612         int i, rem;
  613         struct mbuf *md;
  614         char *fromcp, *tocp, *cp;
  615         struct iovec aiov;
  616         struct uio auio;
  617         struct vnode *dp;
  618         int error, rdonly, linklen;
  619         struct componentname *cnp = &ndp->ni_cnd;
  620         int lockleaf = (cnp->cn_flags & LOCKLEAF) != 0;
  621         int dvfslocked;
  622         int vfslocked;
  623 
  624         vfslocked = 0;
  625         dvfslocked = 0;
  626         *retdirp = NULL;
  627         cnp->cn_flags |= NOMACCHECK;
  628         cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
  629 
  630         /*
  631          * Copy the name from the mbuf list to ndp->ni_pnbuf
  632          * and set the various ndp fields appropriately.
  633          */
  634         fromcp = *dposp;
  635         tocp = cnp->cn_pnbuf;
  636         md = *mdp;
  637         rem = mtod(md, caddr_t) + md->m_len - fromcp;
  638         for (i = 0; i < len; i++) {
  639                 while (rem == 0) {
  640                         md = md->m_next;
  641                         if (md == NULL) {
  642                                 error = EBADRPC;
  643                                 goto out;
  644                         }
  645                         fromcp = mtod(md, caddr_t);
  646                         rem = md->m_len;
  647                 }
  648                 if (*fromcp == '\0' || (!pubflag && *fromcp == '/')) {
  649                         error = EACCES;
  650                         goto out;
  651                 }
  652                 *tocp++ = *fromcp++;
  653                 rem--;
  654         }
  655         *tocp = '\0';
  656         *mdp = md;
  657         *dposp = fromcp;
  658         len = nfsm_rndup(len)-len;
  659         if (len > 0) {
  660                 if (rem >= len)
  661                         *dposp += len;
  662                 else if ((error = nfs_adv(mdp, dposp, len, rem)) != 0)
  663                         goto out;
  664         }
  665 
  666         /*
  667          * Extract and set starting directory.
  668          */
  669         error = nfsrv_fhtovp(fhp, FALSE, &dp, &dvfslocked,
  670             ndp->ni_cnd.cn_cred, slp, nam, &rdonly, pubflag);
  671         if (error)
  672                 goto out;
  673         vfslocked = VFS_LOCK_GIANT(dp->v_mount);
  674         if (dp->v_type != VDIR) {
  675                 vrele(dp);
  676                 error = ENOTDIR;
  677                 goto out;
  678         }
  679 
  680         if (rdonly)
  681                 cnp->cn_flags |= RDONLY;
  682 
  683         /*
  684          * Set return directory.  Reference to dp is implicitly transfered
  685          * to the returned pointer
  686          */
  687         *retdirp = dp;
  688         if (v3) {
  689                 vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td);
  690                 *retdirattr_retp = VOP_GETATTR(dp, retdirattrp,
  691                         ndp->ni_cnd.cn_cred, td);
  692                 VOP_UNLOCK(dp, 0, td);
  693         }
  694 
  695         if (pubflag) {
  696                 /*
  697                  * Oh joy. For WebNFS, handle those pesky '%' escapes,
  698                  * and the 'native path' indicator.
  699                  */
  700                 cp = uma_zalloc(namei_zone, M_WAITOK);
  701                 fromcp = cnp->cn_pnbuf;
  702                 tocp = cp;
  703                 if ((unsigned char)*fromcp >= WEBNFS_SPECCHAR_START) {
  704                         switch ((unsigned char)*fromcp) {
  705                         case WEBNFS_NATIVE_CHAR:
  706                                 /*
  707                                  * 'Native' path for us is the same
  708                                  * as a path according to the NFS spec,
  709                                  * just skip the escape char.
  710                                  */
  711                                 fromcp++;
  712                                 break;
  713                         /*
  714                          * More may be added in the future, range 0x80-0xff
  715                          */
  716                         default:
  717                                 error = EIO;
  718                                 uma_zfree(namei_zone, cp);
  719                                 goto out;
  720                         }
  721                 }
  722                 /*
  723                  * Translate the '%' escapes, URL-style.
  724                  */
  725                 while (*fromcp != '\0') {
  726                         if (*fromcp == WEBNFS_ESC_CHAR) {
  727                                 if (fromcp[1] != '\0' && fromcp[2] != '\0') {
  728                                         fromcp++;
  729                                         *tocp++ = HEXSTRTOI(fromcp);
  730                                         fromcp += 2;
  731                                         continue;
  732                                 } else {
  733                                         error = ENOENT;
  734                                         uma_zfree(namei_zone, cp);
  735                                         goto out;
  736                                 }
  737                         } else
  738                                 *tocp++ = *fromcp++;
  739                 }
  740                 *tocp = '\0';
  741                 uma_zfree(namei_zone, cnp->cn_pnbuf);
  742                 cnp->cn_pnbuf = cp;
  743         }
  744 
  745         ndp->ni_pathlen = (tocp - cnp->cn_pnbuf) + 1;
  746         ndp->ni_segflg = UIO_SYSSPACE;
  747 
  748         if (pubflag) {
  749                 ndp->ni_rootdir = rootvnode;
  750                 ndp->ni_loopcnt = 0;
  751                 if (cnp->cn_pnbuf[0] == '/') {
  752                         int tvfslocked;
  753 
  754                         tvfslocked = VFS_LOCK_GIANT(rootvnode->v_mount);
  755                         VFS_UNLOCK_GIANT(vfslocked);
  756                         dp = rootvnode;
  757                         vfslocked = tvfslocked;
  758                 }
  759         } else {
  760                 cnp->cn_flags |= NOCROSSMOUNT;
  761         }
  762 
  763         /*
  764          * Initialize for scan, set ni_startdir and bump ref on dp again
  765          * because lookup() will dereference ni_startdir.
  766          */
  767 
  768         cnp->cn_thread = td;
  769         VREF(dp);
  770         ndp->ni_startdir = dp;
  771 
  772         if (!lockleaf)
  773                 cnp->cn_flags |= LOCKLEAF;
  774         for (;;) {
  775                 cnp->cn_nameptr = cnp->cn_pnbuf;
  776                 /*
  777                  * Call lookup() to do the real work.  If an error occurs,
  778                  * ndp->ni_vp and ni_dvp are left uninitialized or NULL and
  779                  * we do not have to dereference anything before returning.
  780                  * In either case ni_startdir will be dereferenced and NULLed
  781                  * out.
  782                  */
  783                 if (vfslocked)
  784                         ndp->ni_cnd.cn_flags |= GIANTHELD;
  785                 error = lookup(ndp);
  786                 vfslocked = (ndp->ni_cnd.cn_flags & GIANTHELD) != 0;
  787                 ndp->ni_cnd.cn_flags &= ~GIANTHELD;
  788                 if (error)
  789                         break;
  790 
  791                 /*
  792                  * Check for encountering a symbolic link.  Trivial
  793                  * termination occurs if no symlink encountered.
  794                  * Note: zfree is safe because error is 0, so we will
  795                  * not zfree it again when we break.
  796                  */
  797                 if ((cnp->cn_flags & ISSYMLINK) == 0) {
  798                         if (cnp->cn_flags & (SAVENAME | SAVESTART))
  799                                 cnp->cn_flags |= HASBUF;
  800                         else
  801                                 uma_zfree(namei_zone, cnp->cn_pnbuf);
  802                         if (ndp->ni_vp && !lockleaf)
  803                                 VOP_UNLOCK(ndp->ni_vp, 0, td);
  804                         break;
  805                 }
  806 
  807                 /*
  808                  * Validate symlink
  809                  */
  810                 if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1)
  811                         VOP_UNLOCK(ndp->ni_dvp, 0, td);
  812                 if (!pubflag) {
  813                         error = EINVAL;
  814                         goto badlink2;
  815                 }
  816 
  817                 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
  818                         error = ELOOP;
  819                         goto badlink2;
  820                 }
  821                 if (ndp->ni_pathlen > 1)
  822                         cp = uma_zalloc(namei_zone, M_WAITOK);
  823                 else
  824                         cp = cnp->cn_pnbuf;
  825                 aiov.iov_base = cp;
  826                 aiov.iov_len = MAXPATHLEN;
  827                 auio.uio_iov = &aiov;
  828                 auio.uio_iovcnt = 1;
  829                 auio.uio_offset = 0;
  830                 auio.uio_rw = UIO_READ;
  831                 auio.uio_segflg = UIO_SYSSPACE;
  832                 auio.uio_td = NULL;
  833                 auio.uio_resid = MAXPATHLEN;
  834                 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
  835                 if (error) {
  836                 badlink1:
  837                         if (ndp->ni_pathlen > 1)
  838                                 uma_zfree(namei_zone, cp);
  839                 badlink2:
  840                         vput(ndp->ni_vp);
  841                         vrele(ndp->ni_dvp);
  842                         break;
  843                 }
  844                 linklen = MAXPATHLEN - auio.uio_resid;
  845                 if (linklen == 0) {
  846                         error = ENOENT;
  847                         goto badlink1;
  848                 }
  849                 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
  850                         error = ENAMETOOLONG;
  851                         goto badlink1;
  852                 }
  853 
  854                 /*
  855                  * Adjust or replace path
  856                  */
  857                 if (ndp->ni_pathlen > 1) {
  858                         bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
  859                         uma_zfree(namei_zone, cnp->cn_pnbuf);
  860                         cnp->cn_pnbuf = cp;
  861                 } else
  862                         cnp->cn_pnbuf[linklen] = '\0';
  863                 ndp->ni_pathlen += linklen;
  864 
  865                 /*
  866                  * Cleanup refs for next loop and check if root directory
  867                  * should replace current directory.  Normally ni_dvp
  868                  * becomes the new base directory and is cleaned up when
  869                  * we loop.  Explicitly null pointers after invalidation
  870                  * to clarify operation.
  871                  */
  872                 vput(ndp->ni_vp);
  873                 ndp->ni_vp = NULL;
  874 
  875                 if (cnp->cn_pnbuf[0] == '/') {
  876                         vrele(ndp->ni_dvp);
  877                         ndp->ni_dvp = ndp->ni_rootdir;
  878                         VREF(ndp->ni_dvp);
  879                 }
  880                 ndp->ni_startdir = ndp->ni_dvp;
  881                 ndp->ni_dvp = NULL;
  882         }
  883         if (!lockleaf)
  884                 cnp->cn_flags &= ~LOCKLEAF;
  885         if (cnp->cn_flags & GIANTHELD) {
  886                 mtx_unlock(&Giant);
  887                 cnp->cn_flags &= ~GIANTHELD;
  888         }
  889 
  890         /*
  891          * nfs_namei() guarentees that fields will not contain garbage
  892          * whether an error occurs or not.  This allows the caller to track
  893          * cleanup state trivially.
  894          */
  895 out:
  896         if (error) {
  897                 uma_zfree(namei_zone, cnp->cn_pnbuf);
  898                 ndp->ni_vp = NULL;
  899                 ndp->ni_dvp = NULL;
  900                 ndp->ni_startdir = NULL;
  901                 cnp->cn_flags &= ~HASBUF;
  902                 VFS_UNLOCK_GIANT(vfslocked);
  903                 vfslocked = 0;
  904         } else if ((ndp->ni_cnd.cn_flags & (WANTPARENT|LOCKPARENT)) == 0) {
  905                 ndp->ni_dvp = NULL;
  906         }
  907         /*
  908          * This differs from normal namei() in that even on failure we may
  909          * return with Giant held due to the dirp return.  Make sure we only
  910          * have not recursed however.  The calling code only expects to drop
  911          * one acquire.
  912          */
  913         if (vfslocked || dvfslocked)
  914                 ndp->ni_cnd.cn_flags |= GIANTHELD;
  915         if (vfslocked && dvfslocked)
  916                 VFS_UNLOCK_GIANT(vfslocked);
  917         return (error);
  918 }
  919 
  920 /*
  921  * A fiddled version of m_adj() that ensures null fill to a long
  922  * boundary and only trims off the back end
  923  */
  924 void
  925 nfsm_adj(struct mbuf *mp, int len, int nul)
  926 {
  927         struct mbuf *m;
  928         int count, i;
  929         char *cp;
  930 
  931         /*
  932          * Trim from tail.  Scan the mbuf chain,
  933          * calculating its length and finding the last mbuf.
  934          * If the adjustment only affects this mbuf, then just
  935          * adjust and return.  Otherwise, rescan and truncate
  936          * after the remaining size.
  937          */
  938         count = 0;
  939         m = mp;
  940         for (;;) {
  941                 count += m->m_len;
  942                 if (m->m_next == NULL)
  943                         break;
  944                 m = m->m_next;
  945         }
  946         if (m->m_len > len) {
  947                 m->m_len -= len;
  948                 if (nul > 0) {
  949                         cp = mtod(m, caddr_t)+m->m_len-nul;
  950                         for (i = 0; i < nul; i++)
  951                                 *cp++ = '\0';
  952                 }
  953                 return;
  954         }
  955         count -= len;
  956         if (count < 0)
  957                 count = 0;
  958         /*
  959          * Correct length for chain is "count".
  960          * Find the mbuf with last data, adjust its length,
  961          * and toss data from remaining mbufs on chain.
  962          */
  963         for (m = mp; m; m = m->m_next) {
  964                 if (m->m_len >= count) {
  965                         m->m_len = count;
  966                         if (nul > 0) {
  967                                 cp = mtod(m, caddr_t)+m->m_len-nul;
  968                                 for (i = 0; i < nul; i++)
  969                                         *cp++ = '\0';
  970                         }
  971                         if (m->m_next != NULL) {
  972                                 m_freem(m->m_next);
  973                                 m->m_next = NULL;
  974                         }
  975                         break;
  976                 }
  977                 count -= m->m_len;
  978         }
  979 }
  980 
  981 /*
  982  * Make these functions instead of macros, so that the kernel text size
  983  * doesn't get too big...
  984  */
  985 void
  986 nfsm_srvwcc(struct nfsrv_descript *nfsd, int before_ret,
  987     struct vattr *before_vap, int after_ret, struct vattr *after_vap,
  988     struct mbuf **mbp, char **bposp)
  989 {
  990         struct mbuf *mb = *mbp;
  991         char *bpos = *bposp;
  992         u_int32_t *tl;
  993 
  994         if (before_ret) {
  995                 tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
  996                 *tl = nfsrv_nfs_false;
  997         } else {
  998                 tl = nfsm_build(u_int32_t *, 7 * NFSX_UNSIGNED);
  999                 *tl++ = nfsrv_nfs_true;
 1000                 txdr_hyper(before_vap->va_size, tl);
 1001                 tl += 2;
 1002                 txdr_nfsv3time(&(before_vap->va_mtime), tl);
 1003                 tl += 2;
 1004                 txdr_nfsv3time(&(before_vap->va_ctime), tl);
 1005         }
 1006         *bposp = bpos;
 1007         *mbp = mb;
 1008         nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp);
 1009 }
 1010 
 1011 void
 1012 nfsm_srvpostopattr(struct nfsrv_descript *nfsd, int after_ret,
 1013     struct vattr *after_vap, struct mbuf **mbp, char **bposp)
 1014 {
 1015         struct mbuf *mb = *mbp;
 1016         char *bpos = *bposp;
 1017         u_int32_t *tl;
 1018         struct nfs_fattr *fp;
 1019 
 1020         if (after_ret) {
 1021                 tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
 1022                 *tl = nfsrv_nfs_false;
 1023         } else {
 1024                 tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED + NFSX_V3FATTR);
 1025                 *tl++ = nfsrv_nfs_true;
 1026                 fp = (struct nfs_fattr *)tl;
 1027                 nfsm_srvfattr(nfsd, after_vap, fp);
 1028         }
 1029         *mbp = mb;
 1030         *bposp = bpos;
 1031 }
 1032 
 1033 void
 1034 nfsm_srvfattr(struct nfsrv_descript *nfsd, struct vattr *vap,
 1035     struct nfs_fattr *fp)
 1036 {
 1037 
 1038         fp->fa_nlink = txdr_unsigned(vap->va_nlink);
 1039         fp->fa_uid = txdr_unsigned(vap->va_uid);
 1040         fp->fa_gid = txdr_unsigned(vap->va_gid);
 1041         if (nfsd->nd_flag & ND_NFSV3) {
 1042                 fp->fa_type = vtonfsv3_type(vap->va_type);
 1043                 fp->fa_mode = vtonfsv3_mode(vap->va_mode);
 1044                 txdr_hyper(vap->va_size, &fp->fa3_size);
 1045                 txdr_hyper(vap->va_bytes, &fp->fa3_used);
 1046                 fp->fa3_rdev.specdata1 = txdr_unsigned(umajor(vap->va_rdev));
 1047                 fp->fa3_rdev.specdata2 = txdr_unsigned(uminor(vap->va_rdev));
 1048                 fp->fa3_fsid.nfsuquad[0] = 0;
 1049                 fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
 1050                 fp->fa3_fileid.nfsuquad[0] = 0;
 1051                 fp->fa3_fileid.nfsuquad[1] = txdr_unsigned(vap->va_fileid);
 1052                 txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
 1053                 txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
 1054                 txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
 1055         } else {
 1056                 fp->fa_type = vtonfsv2_type(vap->va_type);
 1057                 fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
 1058                 fp->fa2_size = txdr_unsigned(vap->va_size);
 1059                 fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
 1060                 if (vap->va_type == VFIFO)
 1061                         fp->fa2_rdev = 0xffffffff;
 1062                 else
 1063                         fp->fa2_rdev = txdr_unsigned(vap->va_rdev);
 1064                 fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
 1065                 fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
 1066                 fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
 1067                 txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
 1068                 txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
 1069                 txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
 1070         }
 1071 }
 1072 
 1073 /*
 1074  * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked)
 1075  *      - look up fsid in mount list (if not found ret error)
 1076  *      - get vp and export rights by calling VFS_FHTOVP()
 1077  *      - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon
 1078  *      - if not lockflag unlock it with VOP_UNLOCK()
 1079  */
 1080 int
 1081 nfsrv_fhtovp(fhandle_t *fhp, int lockflag, struct vnode **vpp, int *vfslockedp,
 1082     struct ucred *cred, struct nfssvc_sock *slp, struct sockaddr *nam,
 1083     int *rdonlyp, int pubflag)
 1084 {
 1085         struct thread *td = curthread; /* XXX */
 1086         struct mount *mp;
 1087         int i;
 1088         struct ucred *credanon;
 1089         int error, exflags;
 1090 #ifdef MNT_EXNORESPORT          /* XXX needs mountd and /etc/exports help yet */
 1091         struct sockaddr_int *saddr;
 1092 #endif
 1093         int vfslocked;
 1094 
 1095         *vfslockedp = 0;
 1096         *vpp = NULL;
 1097 
 1098         if (nfs_ispublicfh(fhp)) {
 1099                 if (!pubflag || !nfs_pub.np_valid)
 1100                         return (ESTALE);
 1101                 fhp = &nfs_pub.np_handle;
 1102         }
 1103 
 1104         mp = vfs_getvfs(&fhp->fh_fsid);
 1105         if (!mp)
 1106                 return (ESTALE);
 1107         vfslocked = VFS_LOCK_GIANT(mp);
 1108         error = VFS_CHECKEXP(mp, nam, &exflags, &credanon);
 1109         if (error)
 1110                 goto out;
 1111         error = VFS_FHTOVP(mp, &fhp->fh_fid, vpp);
 1112         if (error)
 1113                 goto out;
 1114 #ifdef MNT_EXNORESPORT
 1115         if (!(exflags & (MNT_EXNORESPORT|MNT_EXPUBLIC))) {
 1116                 saddr = (struct sockaddr_in *)nam;
 1117                 if ((saddr->sin_family == AF_INET ||
 1118                      saddr->sin_family == AF_INET6) &&
 1119         /* same code for INET and INET6: sin*_port at same offet */
 1120                     ntohs(saddr->sin_port) >= IPPORT_RESERVED) {
 1121                         vput(*vpp);
 1122                         *vpp = NULL;
 1123                         error = NFSERR_AUTHERR | AUTH_TOOWEAK;
 1124                 }
 1125         }
 1126 #endif
 1127         /*
 1128          * Check/setup credentials.
 1129          */
 1130         if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
 1131                 cred->cr_uid = credanon->cr_uid;
 1132                 for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++)
 1133                         cred->cr_groups[i] = credanon->cr_groups[i];
 1134                 cred->cr_ngroups = i;
 1135         }
 1136         if (exflags & MNT_EXRDONLY)
 1137                 *rdonlyp = 1;
 1138         else
 1139                 *rdonlyp = 0;
 1140 
 1141         if (!lockflag)
 1142                 VOP_UNLOCK(*vpp, 0, td);
 1143 out:
 1144         vfs_rel(mp);
 1145         if (error) {
 1146                 VFS_UNLOCK_GIANT(vfslocked);
 1147         } else
 1148                 *vfslockedp = vfslocked;
 1149         return (error);
 1150 }
 1151 
 1152 
 1153 /*
 1154  * WebNFS: check if a filehandle is a public filehandle. For v3, this
 1155  * means a length of 0, for v2 it means all zeroes. nfsm_srvmtofh has
 1156  * transformed this to all zeroes in both cases, so check for it.
 1157  */
 1158 int
 1159 nfs_ispublicfh(fhandle_t *fhp)
 1160 {
 1161         char *cp = (char *)fhp;
 1162         int i;
 1163 
 1164         NFSD_LOCK_DONTCARE();
 1165 
 1166         for (i = 0; i < NFSX_V3FH; i++)
 1167                 if (*cp++ != 0)
 1168                         return (FALSE);
 1169         return (TRUE);
 1170 }
 1171 
 1172 /*
 1173  * This function compares two net addresses by family and returns TRUE
 1174  * if they are the same host.
 1175  * If there is any doubt, return FALSE.
 1176  * The AF_INET family is handled as a special case so that address mbufs
 1177  * don't need to be saved to store "struct in_addr", which is only 4 bytes.
 1178  */
 1179 int
 1180 netaddr_match(int family, union nethostaddr *haddr, struct sockaddr *nam)
 1181 {
 1182         struct sockaddr_in *inetaddr;
 1183 
 1184         NFSD_LOCK_DONTCARE();
 1185 
 1186         switch (family) {
 1187         case AF_INET:
 1188                 inetaddr = (struct sockaddr_in *)nam;
 1189                 if (inetaddr->sin_family == AF_INET &&
 1190                     inetaddr->sin_addr.s_addr == haddr->had_inetaddr)
 1191                         return (1);
 1192                 break;
 1193 #ifdef INET6
 1194         case AF_INET6:
 1195         {
 1196                 register struct sockaddr_in6 *inet6addr1, *inet6addr2;
 1197 
 1198                 inet6addr1 = (struct sockaddr_in6 *)nam;
 1199                 inet6addr2 = (struct sockaddr_in6 *)haddr->had_nam;
 1200         /* XXX - should test sin6_scope_id ? */
 1201                 if (inet6addr1->sin6_family == AF_INET6 &&
 1202                     IN6_ARE_ADDR_EQUAL(&inet6addr1->sin6_addr,
 1203                                        &inet6addr2->sin6_addr))
 1204                         return (1);
 1205                 break;
 1206         }
 1207 #endif
 1208         default:
 1209                 break;
 1210         };
 1211         return (0);
 1212 }
 1213 
 1214 /*
 1215  * Map errnos to NFS error numbers. For Version 3 also filter out error
 1216  * numbers not specified for the associated procedure.
 1217  */
 1218 int
 1219 nfsrv_errmap(struct nfsrv_descript *nd, int err)
 1220 {
 1221         const short *defaulterrp, *errp;
 1222         int e;
 1223 
 1224 
 1225         if (nd->nd_flag & ND_NFSV3) {
 1226             if (nd->nd_procnum <= NFSPROC_COMMIT) {
 1227                 errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
 1228                 while (*++errp) {
 1229                         if (*errp == err)
 1230                                 return (err);
 1231                         else if (*errp > err)
 1232                                 break;
 1233                 }
 1234                 return ((int)*defaulterrp);
 1235             } else
 1236                 return (err & 0xffff);
 1237         }
 1238         e = 0;
 1239         if (err <= ELAST)
 1240                 e = nfsrv_v2errmap[err - 1];
 1241         if (e != 0)
 1242                 return (e);
 1243         return (NFSERR_IO);
 1244 }
 1245 
 1246 /*
 1247  * Sort the group list in increasing numerical order.
 1248  * (Insertion sort by Chris Torek, who was grossed out by the bubble sort
 1249  *  that used to be here.)
 1250  */
 1251 void
 1252 nfsrvw_sort(gid_t *list, int num)
 1253 {
 1254         int i, j;
 1255         gid_t v;
 1256 
 1257         /* Insertion sort. */
 1258         for (i = 1; i < num; i++) {
 1259                 v = list[i];
 1260                 /* find correct slot for value v, moving others up */
 1261                 for (j = i; --j >= 0 && v < list[j];)
 1262                         list[j + 1] = list[j];
 1263                 list[j + 1] = v;
 1264         }
 1265 }
 1266 
 1267 /*
 1268  * Helper functions for macros.
 1269  */
 1270 
 1271 void
 1272 nfsm_srvfhtom_xx(fhandle_t *f, int v3, struct mbuf **mb, caddr_t *bpos)
 1273 {
 1274         u_int32_t *tl;
 1275 
 1276         if (v3) {
 1277                 tl = nfsm_build_xx(NFSX_UNSIGNED + NFSX_V3FH, mb, bpos);
 1278                 *tl++ = txdr_unsigned(NFSX_V3FH);
 1279                 bcopy(f, tl, NFSX_V3FH);
 1280         } else {
 1281                 tl = nfsm_build_xx(NFSX_V2FH, mb, bpos);
 1282                 bcopy(f, tl, NFSX_V2FH);
 1283         }
 1284 }
 1285 
 1286 void
 1287 nfsm_srvpostop_fh_xx(fhandle_t *f, struct mbuf **mb, caddr_t *bpos)
 1288 {
 1289         u_int32_t *tl;
 1290 
 1291         tl = nfsm_build_xx(2 * NFSX_UNSIGNED + NFSX_V3FH, mb, bpos);
 1292         *tl++ = nfsrv_nfs_true;
 1293         *tl++ = txdr_unsigned(NFSX_V3FH);
 1294         bcopy(f, tl, NFSX_V3FH);
 1295 }
 1296 
 1297 int
 1298 nfsm_srvstrsiz_xx(int *s, int m, struct mbuf **md, caddr_t *dpos)
 1299 {
 1300         u_int32_t *tl;
 1301 
 1302         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1303         if (tl == NULL)
 1304                 return EBADRPC;
 1305         *s = fxdr_unsigned(int32_t, *tl);
 1306         if (*s > m || *s <= 0)
 1307                 return EBADRPC;
 1308         return 0;
 1309 }
 1310 
 1311 int
 1312 nfsm_srvnamesiz_xx(int *s, int m, struct mbuf **md, caddr_t *dpos)
 1313 {
 1314         u_int32_t *tl;
 1315 
 1316         NFSD_LOCK_DONTCARE();
 1317 
 1318         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1319         if (tl == NULL)
 1320                 return EBADRPC;
 1321         *s = fxdr_unsigned(int32_t, *tl);
 1322         if (*s > m)
 1323                 return NFSERR_NAMETOL;
 1324         if (*s <= 0)
 1325                 return EBADRPC;
 1326         return 0;
 1327 }
 1328 
 1329 int
 1330 nfsm_srvnamesiz0_xx(int *s, int m, struct mbuf **md, caddr_t *dpos)
 1331 {
 1332         u_int32_t *tl;
 1333 
 1334         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1335         if (tl == NULL)
 1336                 return EBADRPC;
 1337         *s = fxdr_unsigned(int32_t, *tl);
 1338         if (*s > m)
 1339                 return NFSERR_NAMETOL;
 1340         if (*s < 0)
 1341                 return EBADRPC;
 1342         return 0;
 1343 }
 1344 
 1345 void
 1346 nfsm_clget_xx(u_int32_t **tl, struct mbuf *mb, struct mbuf **mp,
 1347     char **bp, char **be, caddr_t bpos)
 1348 {
 1349         struct mbuf *nmp;
 1350 
 1351         NFSD_UNLOCK_ASSERT();
 1352 
 1353         if (*bp >= *be) {
 1354                 if (*mp == mb)
 1355                         (*mp)->m_len += *bp - bpos;
 1356                 MGET(nmp, M_TRYWAIT, MT_DATA);
 1357                 MCLGET(nmp, M_TRYWAIT);
 1358                 nmp->m_len = NFSMSIZ(nmp);
 1359                 (*mp)->m_next = nmp;
 1360                 *mp = nmp;
 1361                 *bp = mtod(*mp, caddr_t);
 1362                 *be = *bp + (*mp)->m_len;
 1363         }
 1364         *tl = (u_int32_t *)*bp;
 1365 }
 1366 
 1367 int
 1368 nfsm_srvmtofh_xx(fhandle_t *f, struct nfsrv_descript *nfsd, struct mbuf **md,
 1369     caddr_t *dpos)
 1370 {
 1371         u_int32_t *tl;
 1372         int fhlen;
 1373 
 1374         if (nfsd->nd_flag & ND_NFSV3) {
 1375                 tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1376                 if (tl == NULL)
 1377                         return EBADRPC;
 1378                 fhlen = fxdr_unsigned(int, *tl);
 1379                 if (fhlen != 0 && fhlen != NFSX_V3FH)
 1380                         return EBADRPC;
 1381         } else {
 1382                 fhlen = NFSX_V2FH;
 1383         }
 1384         if (fhlen != 0) {
 1385                 tl = nfsm_dissect_xx_nonblock(fhlen, md, dpos);
 1386                 if (tl == NULL)
 1387                         return EBADRPC;
 1388                 bcopy((caddr_t)tl, (caddr_t)(f), fhlen);
 1389         } else {
 1390                 bzero((caddr_t)(f), NFSX_V3FH);
 1391         }
 1392         return 0;
 1393 }
 1394 
 1395 int
 1396 nfsm_srvsattr_xx(struct vattr *a, struct mbuf **md, caddr_t *dpos)
 1397 {
 1398         u_int32_t *tl;
 1399         int toclient = 0;
 1400 
 1401         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1402         if (tl == NULL)
 1403                 return EBADRPC;
 1404         if (*tl == nfsrv_nfs_true) {
 1405                 tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1406                 if (tl == NULL)
 1407                         return EBADRPC;
 1408                 (a)->va_mode = nfstov_mode(*tl);
 1409         }
 1410         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1411         if (tl == NULL)
 1412                 return EBADRPC;
 1413         if (*tl == nfsrv_nfs_true) {
 1414                 tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1415                 if (tl == NULL)
 1416                         return EBADRPC;
 1417                 (a)->va_uid = fxdr_unsigned(uid_t, *tl);
 1418         }
 1419         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1420         if (tl == NULL)
 1421                 return EBADRPC;
 1422         if (*tl == nfsrv_nfs_true) {
 1423                 tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1424                 if (tl == NULL)
 1425                         return EBADRPC;
 1426                 (a)->va_gid = fxdr_unsigned(gid_t, *tl);
 1427         }
 1428         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1429         if (tl == NULL)
 1430                 return EBADRPC;
 1431         if (*tl == nfsrv_nfs_true) {
 1432                 tl = nfsm_dissect_xx_nonblock(2 * NFSX_UNSIGNED, md, dpos);
 1433                 if (tl == NULL)
 1434                         return EBADRPC;
 1435                 (a)->va_size = fxdr_hyper(tl);
 1436         }
 1437         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1438         if (tl == NULL)
 1439                 return EBADRPC;
 1440         switch (fxdr_unsigned(int, *tl)) {
 1441         case NFSV3SATTRTIME_TOCLIENT:
 1442                 tl = nfsm_dissect_xx_nonblock(2 * NFSX_UNSIGNED, md, dpos);
 1443                 if (tl == NULL)
 1444                         return EBADRPC;
 1445                 fxdr_nfsv3time(tl, &(a)->va_atime);
 1446                 toclient = 1;
 1447                 break;
 1448         case NFSV3SATTRTIME_TOSERVER:
 1449                 getnanotime(&(a)->va_atime);
 1450                 a->va_vaflags |= VA_UTIMES_NULL;
 1451                 break;
 1452         }
 1453         tl = nfsm_dissect_xx_nonblock(NFSX_UNSIGNED, md, dpos);
 1454         if (tl == NULL)
 1455                 return EBADRPC;
 1456         switch (fxdr_unsigned(int, *tl)) {
 1457         case NFSV3SATTRTIME_TOCLIENT:
 1458                 tl = nfsm_dissect_xx_nonblock(2 * NFSX_UNSIGNED, md, dpos);
 1459                 if (tl == NULL)
 1460                         return EBADRPC;
 1461                 fxdr_nfsv3time(tl, &(a)->va_mtime);
 1462                 a->va_vaflags &= ~VA_UTIMES_NULL;
 1463                 break;
 1464         case NFSV3SATTRTIME_TOSERVER:
 1465                 getnanotime(&(a)->va_mtime);
 1466                 if (toclient == 0)
 1467                         a->va_vaflags |= VA_UTIMES_NULL;
 1468                 break;
 1469         }
 1470         return 0;
 1471 }

Cache object: 7bced4a9524d3edfaaf60449596ec1be


[ 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.