kernel/fs/nfs/nfs4_acache.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <nfs/nfs.h>
  30 #include <nfs/nfs4.h>
  31 #include <nfs/rnode4.h>
  32 #include <nfs/nfs4_clnt.h>
  33 #include <sys/bitmap.h>
  34
  35 /*
  36  * Access cache
  37  */
  38 static acache4_hash_t *acache4;
  39 static long nacache;    /* used strictly to size the number of hash queues */
  40
  41 static int acache4size;
  42 static int acache4mask;
  43 static struct kmem_cache *acache4_cache;
  44 static int acache4_hashlen = 4;
  45
  46 /*
  47  * This probably needs to be larger than or equal to
  48  * log2(sizeof (struct rnode)) due to the way that rnodes are
  49  * allocated.
  50  */
  51 #define ACACHE4_SHIFT_BITS      9
  52
  53 static int
  54 acache4hash(rnode4_t *rp, cred_t *cred)
  55 {
  56         return ((((intptr_t)rp >> ACACHE4_SHIFT_BITS) + crgetuid(cred)) &
  57             acache4mask);
  58 }
  59
  60 #ifdef DEBUG
  61 static long nfs4_access_cache_hits = 0;
  62 static long nfs4_access_cache_misses = 0;
  63 #endif
  64
  65 nfs4_access_type_t
  66 nfs4_access_check(rnode4_t *rp, uint32_t acc, cred_t *cr)
  67 {
  68         acache4_t *ap;
  69         acache4_hash_t *hp;
  70         nfs4_access_type_t all;
  71         vnode_t *vp;
  72
  73         vp = RTOV4(rp);
  74         if (!ATTRCACHE4_VALID(vp) || nfs4_waitfor_purge_complete(vp))
  75                 return (NFS4_ACCESS_UNKNOWN);
  76
  77         if (rp->r_acache != NULL) {
  78                 hp = &acache4[acache4hash(rp, cr)];
  79                 rw_enter(&hp->lock, RW_READER);
  80                 ap = hp->next;
  81                 while (ap != (acache4_t *)hp) {
  82                         if (crcmp(ap->cred, cr) == 0 && ap->rnode == rp) {
  83                                 if ((ap->known & acc) == acc) {
  84 #ifdef DEBUG
  85                                         nfs4_access_cache_hits++;
  86 #endif
  87                                         if ((ap->allowed & acc) == acc)
  88                                                 all = NFS4_ACCESS_ALLOWED;
  89                                         else
  90                                                 all = NFS4_ACCESS_DENIED;
  91                                 } else {
  92 #ifdef DEBUG
  93                                         nfs4_access_cache_misses++;
  94 #endif
  95                                         all = NFS4_ACCESS_UNKNOWN;
  96                                 }
  97                                 rw_exit(&hp->lock);
  98                                 return (all);
  99                         }
 100                         ap = ap->next;
 101                 }
 102                 rw_exit(&hp->lock);
 103         }
 104
 105 #ifdef DEBUG
 106         nfs4_access_cache_misses++;
 107 #endif
 108         return (NFS4_ACCESS_UNKNOWN);
 109 }
 110
 111 void
 112 nfs4_access_cache(rnode4_t *rp, uint32_t acc, uint32_t resacc, cred_t *cr)
 113 {
 114         acache4_t *ap;
 115         acache4_t *nap;
 116         acache4_hash_t *hp;
 117
 118         hp = &acache4[acache4hash(rp, cr)];
 119
 120         /*
 121          * Allocate now assuming that mostly an allocation will be
 122          * required.  This allows the allocation to happen without
 123          * holding the hash bucket locked.
 124          */
 125         nap = kmem_cache_alloc(acache4_cache, KM_NOSLEEP);
 126         if (nap != NULL) {
 127                 nap->known = acc;
 128                 nap->allowed = resacc;
 129                 nap->rnode = rp;
 130                 crhold(cr);
 131                 nap->cred = cr;
 132                 nap->hashq = hp;
 133         }
 134
 135         rw_enter(&hp->lock, RW_WRITER);
 136
 137         if (rp->r_acache != NULL) {
 138                 ap = hp->next;
 139                 while (ap != (acache4_t *)hp) {
 140                         if (crcmp(ap->cred, cr) == 0 && ap->rnode == rp) {
 141                                 ap->known |= acc;
 142                                 ap->allowed &= ~acc;
 143                                 ap->allowed |= resacc;
 144                                 rw_exit(&hp->lock);
 145                                 if (nap != NULL) {
 146                                         crfree(nap->cred);
 147                                         kmem_cache_free(acache4_cache, nap);
 148                                 }
 149                                 return;
 150                         }
 151                         ap = ap->next;
 152                 }
 153         }
 154
 155         if (nap != NULL) {
 156 #ifdef DEBUG
 157                 clstat4_debug.access.value.ui64++;
 158 #endif
 159                 nap->next = hp->next;
 160                 hp->next = nap;
 161                 nap->next->prev = nap;
 162                 nap->prev = (acache4_t *)hp;
 163
 164                 mutex_enter(&rp->r_statelock);
 165                 nap->list = rp->r_acache;
 166                 rp->r_acache = nap;
 167                 mutex_exit(&rp->r_statelock);
 168         }
 169
 170         rw_exit(&hp->lock);
 171 }
 172
 173 int
 174 nfs4_access_purge_rp(rnode4_t *rp)
 175 {
 176         acache4_t *ap, *tmpap, *rplist;
 177
 178         /*
 179          * If there aren't any cached entries, then there is nothing
 180          * to free.
 181          */
 182         if (rp->r_acache == NULL)
 183                 return (0);
 184
 185         mutex_enter(&rp->r_statelock);
 186         rplist = rp->r_acache;
 187         rp->r_acache = NULL;
 188         mutex_exit(&rp->r_statelock);
 189
 190         /*
 191          * Loop through each entry in the list pointed to in the
 192          * rnode.  Remove each of these entries from the hash
 193          * queue that it is on and remove it from the list in
 194          * the rnode.
 195          */
 196         for (ap = rplist; ap != NULL; ap = tmpap) {
 197                 rw_enter(&ap->hashq->lock, RW_WRITER);
 198                 ap->prev->next = ap->next;
 199                 ap->next->prev = ap->prev;
 200                 rw_exit(&ap->hashq->lock);
 201
 202                 tmpap = ap->list;
 203                 crfree(ap->cred);
 204                 kmem_cache_free(acache4_cache, ap);
 205 #ifdef DEBUG
 206                 clstat4_debug.access.value.ui64--;
 207 #endif
 208         }
 209
 210         return (1);
 211 }
 212
 213 int
 214 nfs4_acache_init(void)
 215 {
 216         extern int rtable4size;
 217         int i;
 218
 219         /*
 220          * Initial guess is one access cache entry per rnode unless
 221          * nacache is set to a non-zero value and then it is used to
 222          * indicate a guess at the number of access cache entries.
 223          */
 224         if (nacache > 0)
 225                 acache4size = 1 << highbit(nacache / acache4_hashlen);
 226         else
 227                 acache4size = rtable4size;
 228         acache4mask = acache4size - 1;
 229         acache4 = kmem_alloc(acache4size * sizeof (*acache4), KM_SLEEP);
 230         for (i = 0; i < acache4size; i++) {
 231                 acache4[i].next = (acache4_t *)&acache4[i];
 232                 acache4[i].prev = (acache4_t *)&acache4[i];
 233                 rw_init(&acache4[i].lock, NULL, RW_DEFAULT, NULL);
 234         }
 235         acache4_cache = kmem_cache_create("nfs4_access_cache",
 236             sizeof (acache4_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
 237
 238         return (0);
 239 }
 240
 241 int
 242 nfs4_acache_fini(void)
 243 {
 244         int i;
 245
 246         /*
 247          * Deallocated the access cache
 248          */
 249         kmem_cache_destroy(acache4_cache);
 250
 251         for (i = 0; i < acache4size; i++)
 252                 rw_destroy(&acache4[i].lock);
 253         kmem_free(acache4, acache4size * sizeof (*acache4));
 254
 255         return (0);
 256 }