bsd/nfs/nfs_srvcache.c

   1 /*
   2  * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  23 /*
  24  * Copyright (c) 1989, 1993
  25  *      The Regents of the University of California.  All rights reserved.
  26  *
  27  * This code is derived from software contributed to Berkeley by
  28  * Rick Macklem at The University of Guelph.
  29  *
  30  * Redistribution and use in source and binary forms, with or without
  31  * modification, are permitted provided that the following conditions
  32  * are met:
  33  * 1. Redistributions of source code must retain the above copyright
  34  *    notice, this list of conditions and the following disclaimer.
  35  * 2. Redistributions in binary form must reproduce the above copyright
  36  *    notice, this list of conditions and the following disclaimer in the
  37  *    documentation and/or other materials provided with the distribution.
  38  * 3. All advertising materials mentioning features or use of this software
  39  *    must display the following acknowledgement:
  40  *      This product includes software developed by the University of
  41  *      California, Berkeley and its contributors.
  42  * 4. Neither the name of the University nor the names of its contributors
  43  *    may be used to endorse or promote products derived from this software
  44  *    without specific prior written permission.
  45  *
  46  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  47  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  48  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  49  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  50  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  51  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  52  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  53  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  54  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  55  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  56  * SUCH DAMAGE.
  57  *
  58  *      @(#)nfs_srvcache.c      8.3 (Berkeley) 3/30/95
  59  * FreeBSD-Id: nfs_srvcache.c,v 1.15 1997/10/12 20:25:46 phk Exp $
  60  */
  61
  62 #ifndef NFS_NOSERVER
  63 /*
  64  * Reference: Chet Juszczak, "Improving the Performance and Correctness
  65  *              of an NFS Server", in Proc. Winter 1989 USENIX Conference,
  66  *              pages 53-63. San Diego, February 1989.
  67  */
  68 #include <sys/param.h>
  69 #include <sys/vnode.h>
  70 #include <sys/mount_internal.h>
  71 #include <sys/kernel.h>
  72 #include <sys/systm.h>
  73 #include <sys/proc.h>
  74 #include <sys/kpi_mbuf.h>
  75 #include <sys/malloc.h>
  76 #include <sys/socket.h>
  77 #include <sys/socketvar.h>      /* for dup_sockaddr */
  78 #include <libkern/OSAtomic.h>
  79
  80 #include <netinet/in.h>
  81 #if ISO
  82 #include <netiso/iso.h>
  83 #endif
  84 #include <nfs/rpcv2.h>
  85 #include <nfs/nfsproto.h>
  86 #include <nfs/nfs.h>
  87 #include <nfs/nfsrvcache.h>
  88
  89 extern struct nfsstats nfsstats;
  90 extern int nfsv2_procid[NFS_NPROCS];
  91 long numnfsrvcache;
  92 static long desirednfsrvcache = NFSRVCACHESIZ;
  93
  94 #define NFSRCHASH(xid) \
  95         (&nfsrvhashtbl[((xid) + ((xid) >> 24)) & nfsrvhash])
  96 LIST_HEAD(nfsrvhash, nfsrvcache) *nfsrvhashtbl;
  97 TAILQ_HEAD(nfsrvlru, nfsrvcache) nfsrvlruhead;
  98 u_long nfsrvhash;
  99
 100 lck_grp_t *nfsrv_reqcache_lck_grp;
 101 lck_grp_attr_t *nfsrv_reqcache_lck_grp_attr;
 102 lck_attr_t *nfsrv_reqcache_lck_attr;
 103 lck_mtx_t *nfsrv_reqcache_mutex;
 104
 105 #define NETFAMILY(rp) \
 106                 (((rp)->rc_flag & RC_INETADDR) ? AF_INET : AF_ISO)
 107
 108 /*
 109  * Static array that defines which nfs rpc's are nonidempotent
 110  */
 111 static int nonidempotent[NFS_NPROCS] = {
 112         FALSE,
 113         FALSE,
 114         TRUE,
 115         FALSE,
 116         FALSE,
 117         FALSE,
 118         FALSE,
 119         TRUE,
 120         TRUE,
 121         TRUE,
 122         TRUE,
 123         TRUE,
 124         TRUE,
 125         TRUE,
 126         TRUE,
 127         TRUE,
 128         FALSE,
 129         FALSE,
 130         FALSE,
 131         FALSE,
 132         FALSE,
 133         FALSE,
 134         FALSE,
 135 };
 136
 137 /* True iff the rpc reply is an nfs status ONLY! */
 138 static int nfsv2_repstat[NFS_NPROCS] = {
 139         FALSE,
 140         FALSE,
 141         FALSE,
 142         FALSE,
 143         FALSE,
 144         FALSE,
 145         FALSE,
 146         FALSE,
 147         FALSE,
 148         FALSE,
 149         TRUE,
 150         TRUE,
 151         TRUE,
 152         TRUE,
 153         FALSE,
 154         TRUE,
 155         FALSE,
 156         FALSE,
 157 };
 158
 159 /*
 160  * Initialize the server request cache list
 161  */
 162 void
 163 nfsrv_initcache()
 164 {
 165         /* init nfs server request cache mutex */
 166         nfsrv_reqcache_lck_grp_attr = lck_grp_attr_alloc_init();
 167         lck_grp_attr_setstat(nfsrv_reqcache_lck_grp_attr);
 168         nfsrv_reqcache_lck_grp = lck_grp_alloc_init("nfsrv_reqcache", nfsrv_reqcache_lck_grp_attr);
 169         nfsrv_reqcache_lck_attr = lck_attr_alloc_init();
 170         nfsrv_reqcache_mutex = lck_mtx_alloc_init(nfsrv_reqcache_lck_grp, nfsrv_reqcache_lck_attr);
 171
 172         nfsrvhashtbl = hashinit(desirednfsrvcache, M_NFSD, &nfsrvhash);
 173         TAILQ_INIT(&nfsrvlruhead);
 174 }
 175
 176 /*
 177  * Look for the request in the cache
 178  * If found then
 179  *    return action and optionally reply
 180  * else
 181  *    insert it in the cache
 182  *
 183  * The rules are as follows:
 184  * - if in progress, return DROP request
 185  * - if completed within DELAY of the current time, return DROP it
 186  * - if completed a longer time ago return REPLY if the reply was cached or
 187  *   return DOIT
 188  * Update/add new request at end of lru list
 189  */
 190 int
 191 nfsrv_getcache(nd, slp, repp)
 192         struct nfsrv_descript *nd;
 193         struct nfssvc_sock *slp;
 194         mbuf_t *repp;
 195 {
 196         struct nfsrvcache *rp;
 197         mbuf_t mb;
 198         struct sockaddr_in *saddr;
 199         caddr_t bpos;
 200         int ret, error;
 201
 202         /*
 203          * Don't cache recent requests for reliable transport protocols.
 204          * (Maybe we should for the case of a reconnect, but..)
 205          */
 206         if (!nd->nd_nam2)
 207                 return (RC_DOIT);
 208         lck_mtx_lock(nfsrv_reqcache_mutex);
 209 loop:
 210         for (rp = NFSRCHASH(nd->nd_retxid)->lh_first; rp != 0;
 211             rp = rp->rc_hash.le_next) {
 212             if (nd->nd_retxid == rp->rc_xid && nd->nd_procnum == rp->rc_proc &&
 213                 netaddr_match(NETFAMILY(rp), &rp->rc_haddr, nd->nd_nam)) {
 214                         if ((rp->rc_flag & RC_LOCKED) != 0) {
 215                                 rp->rc_flag |= RC_WANTED;
 216                                 (void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
 217                                 goto loop;
 218                         }
 219                         rp->rc_flag |= RC_LOCKED;
 220                         /* If not at end of LRU chain, move it there */
 221                         if (rp->rc_lru.tqe_next) {
 222                                 TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
 223                                 TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);
 224                         }
 225                         if (rp->rc_state == RC_UNUSED)
 226                                 panic("nfsrv cache");
 227                         if (rp->rc_state == RC_INPROG) {
 228                                 OSAddAtomic(1, (SInt32*)&nfsstats.srvcache_inproghits);
 229                                 ret = RC_DROPIT;
 230                         } else if (rp->rc_flag & RC_REPSTATUS) {
 231                                 OSAddAtomic(1, (SInt32*)&nfsstats.srvcache_nonidemdonehits);
 232                                 nfs_rephead(0, nd, slp, rp->rc_status, repp, &mb, &bpos);
 233                                 ret = RC_REPLY;
 234                         } else if (rp->rc_flag & RC_REPMBUF) {
 235                                 OSAddAtomic(1, (SInt32*)&nfsstats.srvcache_nonidemdonehits);
 236                                 error = mbuf_copym(rp->rc_reply, 0, MBUF_COPYALL, MBUF_WAITOK, repp);
 237                                 if (error) {
 238                                         printf("nfsrv cache: reply copym failed for nonidem request hit\n");
 239                                         ret = RC_DROPIT;
 240                                 } else {
 241                                         ret = RC_REPLY;
 242                                 }
 243                         } else {
 244                                 OSAddAtomic(1, (SInt32*)&nfsstats.srvcache_idemdonehits);
 245                                 rp->rc_state = RC_INPROG;
 246                                 ret = RC_DOIT;
 247                         }
 248                         rp->rc_flag &= ~RC_LOCKED;
 249                         if (rp->rc_flag & RC_WANTED) {
 250                                 rp->rc_flag &= ~RC_WANTED;
 251                                 wakeup((caddr_t)rp);
 252                         }
 253                         lck_mtx_unlock(nfsrv_reqcache_mutex);
 254                         return (ret);
 255                 }
 256         }
 257         OSAddAtomic(1, (SInt32*)&nfsstats.srvcache_misses);
 258         if (numnfsrvcache < desirednfsrvcache) {
 259                 /* try to allocate a new entry */
 260                 MALLOC(rp, struct nfsrvcache *, sizeof *rp, M_NFSD, M_WAITOK);
 261                 if (rp) {
 262                         bzero((char *)rp, sizeof *rp);
 263                         numnfsrvcache++;
 264                         rp->rc_flag = RC_LOCKED;
 265                 }
 266         } else {
 267                 rp = NULL;
 268         }
 269         if (!rp) {
 270                 /* try to reuse the least recently used entry */
 271                 rp = nfsrvlruhead.tqh_first;
 272                 if (!rp) {
 273                         /* no entry to reuse? */
 274                         /* OK, we just won't be able to cache this request */
 275                         lck_mtx_unlock(nfsrv_reqcache_mutex);
 276                         return (RC_DOIT);
 277                 }
 278                 while ((rp->rc_flag & RC_LOCKED) != 0) {
 279                         rp->rc_flag |= RC_WANTED;
 280                         (void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
 281                         rp = nfsrvlruhead.tqh_first;
 282                 }
 283                 rp->rc_flag |= RC_LOCKED;
 284                 LIST_REMOVE(rp, rc_hash);
 285                 TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
 286                 if (rp->rc_flag & RC_REPMBUF)
 287                         mbuf_freem(rp->rc_reply);
 288                 if (rp->rc_flag & RC_NAM)
 289                         mbuf_freem(rp->rc_nam);
 290                 rp->rc_flag &= (RC_LOCKED | RC_WANTED);
 291         }
 292         TAILQ_INSERT_TAIL(&nfsrvlruhead, rp, rc_lru);
 293         rp->rc_state = RC_INPROG;
 294         rp->rc_xid = nd->nd_retxid;
 295         saddr = mbuf_data(nd->nd_nam);
 296         switch (saddr->sin_family) {
 297         case AF_INET:
 298                 rp->rc_flag |= RC_INETADDR;
 299                 rp->rc_inetaddr = saddr->sin_addr.s_addr;
 300                 break;
 301         case AF_ISO:
 302         default:
 303                 error = mbuf_copym(nd->nd_nam, 0, MBUF_COPYALL, MBUF_WAITOK, &rp->rc_nam);
 304                 if (error)
 305                         printf("nfsrv cache: nam copym failed\n");
 306                 else
 307                         rp->rc_flag |= RC_NAM;
 308                 break;
 309         };
 310         rp->rc_proc = nd->nd_procnum;
 311         LIST_INSERT_HEAD(NFSRCHASH(nd->nd_retxid), rp, rc_hash);
 312         rp->rc_flag &= ~RC_LOCKED;
 313         if (rp->rc_flag & RC_WANTED) {
 314                 rp->rc_flag &= ~RC_WANTED;
 315                 wakeup((caddr_t)rp);
 316         }
 317         lck_mtx_unlock(nfsrv_reqcache_mutex);
 318         return (RC_DOIT);
 319 }
 320
 321 /*
 322  * Update a request cache entry after the rpc has been done
 323  */
 324 void
 325 nfsrv_updatecache(nd, repvalid, repmbuf)
 326         struct nfsrv_descript *nd;
 327         int repvalid;
 328         mbuf_t repmbuf;
 329 {
 330         struct nfsrvcache *rp;
 331         int error;
 332
 333         if (!nd->nd_nam2)
 334                 return;
 335         lck_mtx_lock(nfsrv_reqcache_mutex);
 336 loop:
 337         for (rp = NFSRCHASH(nd->nd_retxid)->lh_first; rp != 0;
 338             rp = rp->rc_hash.le_next) {
 339             if (nd->nd_retxid == rp->rc_xid && nd->nd_procnum == rp->rc_proc &&
 340                 netaddr_match(NETFAMILY(rp), &rp->rc_haddr, nd->nd_nam)) {
 341                         if ((rp->rc_flag & RC_LOCKED) != 0) {
 342                                 rp->rc_flag |= RC_WANTED;
 343                                 (void) tsleep((caddr_t)rp, PZERO-1, "nfsrc", 0);
 344                                 goto loop;
 345                         }
 346                         rp->rc_flag |= RC_LOCKED;
 347                         rp->rc_state = RC_DONE;
 348                         /*
 349                          * If we have a valid reply update status and save
 350                          * the reply for non-idempotent rpc's.
 351                          */
 352                         if (repvalid && nonidempotent[nd->nd_procnum]) {
 353                                 if ((nd->nd_flag & ND_NFSV3) == 0 &&
 354                                   nfsv2_repstat[nfsv2_procid[nd->nd_procnum]]) {
 355                                         rp->rc_status = nd->nd_repstat;
 356                                         rp->rc_flag |= RC_REPSTATUS;
 357                                 } else {
 358                                         error = mbuf_copym(repmbuf, 0, MBUF_COPYALL, MBUF_WAITOK, &rp->rc_reply);
 359                                         if (!error)
 360                                                 rp->rc_flag |= RC_REPMBUF;
 361                                 }
 362                         }
 363                         rp->rc_flag &= ~RC_LOCKED;
 364                         if (rp->rc_flag & RC_WANTED) {
 365                                 rp->rc_flag &= ~RC_WANTED;
 366                                 wakeup((caddr_t)rp);
 367                         }
 368                         lck_mtx_unlock(nfsrv_reqcache_mutex);
 369                         return;
 370                 }
 371         }
 372         lck_mtx_unlock(nfsrv_reqcache_mutex);
 373 }
 374
 375 /*
 376  * Clean out the cache. Called when the last nfsd terminates.
 377  */
 378 void
 379 nfsrv_cleancache()
 380 {
 381         struct nfsrvcache *rp, *nextrp;
 382
 383         lck_mtx_lock(nfsrv_reqcache_mutex);
 384         for (rp = nfsrvlruhead.tqh_first; rp != 0; rp = nextrp) {
 385                 nextrp = rp->rc_lru.tqe_next;
 386                 LIST_REMOVE(rp, rc_hash);
 387                 TAILQ_REMOVE(&nfsrvlruhead, rp, rc_lru);
 388                 _FREE(rp, M_NFSD);
 389         }
 390         numnfsrvcache = 0;
 391         lck_mtx_unlock(nfsrv_reqcache_mutex);
 392 }
 393
 394 #endif /* NFS_NOSERVER */