lustre/obdclass/capa.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see [sun.com URL with a
  20  * copy of GPLv2].
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/obdclass/capa.c
  37  *
  38  * Lustre Capability Hash Management
  39  *
  40  * Author: Lai Siyao<lsy@clusterfs.com>
  41  */
  42
  43 #ifndef EXPORT_SYMTAB
  44 # define EXPORT_SYMTAB
  45 #endif
  46
  47 #define DEBUG_SUBSYSTEM S_SEC
  48
  49 #ifdef __KERNEL__
  50 #include <linux/version.h>
  51 #include <linux/fs.h>
  52 #include <asm/unistd.h>
  53 #include <linux/slab.h>
  54 #include <linux/module.h>
  55 #include <linux/init.h>
  56
  57 #include <obd_class.h>
  58 #include <lustre_debug.h>
  59 #include <lustre/lustre_idl.h>
  60 #else
  61 #include <liblustre.h>
  62 #endif
  63
  64 #include <libcfs/list.h>
  65 #include <lustre_capa.h>
  66
  67 #define NR_CAPAHASH 32
  68 #define CAPA_HASH_SIZE 3000              /* for MDS & OSS */
  69
  70 cfs_mem_cache_t *capa_cachep = NULL;
  71
  72 #ifdef __KERNEL__
  73 /* lock for capa hash/capa_list/fo_capa_keys */
  74 spinlock_t capa_lock = SPIN_LOCK_UNLOCKED;
  75
  76 struct list_head capa_list[CAPA_SITE_MAX];
  77
  78 static struct capa_hmac_alg capa_hmac_algs[] = {
  79         DEF_CAPA_HMAC_ALG("sha1", SHA1, 20, 20),
  80 };
  81 #endif
  82 /* capa count */
  83 int capa_count[CAPA_SITE_MAX] = { 0, };
  84
  85 EXPORT_SYMBOL(capa_cachep);
  86 EXPORT_SYMBOL(capa_list);
  87 EXPORT_SYMBOL(capa_lock);
  88 EXPORT_SYMBOL(capa_count);
  89
  90 struct hlist_head *init_capa_hash(void)
  91 {
  92         struct hlist_head *hash;
  93         int nr_hash, i;
  94
  95         OBD_ALLOC(hash, CFS_PAGE_SIZE);
  96         if (!hash)
  97                 return NULL;
  98
  99         nr_hash = CFS_PAGE_SIZE / sizeof(struct hlist_head);
 100         LASSERT(nr_hash > NR_CAPAHASH);
 101
 102         for (i = 0; i < NR_CAPAHASH; i++)
 103                 INIT_HLIST_HEAD(hash + i);
 104         return hash;
 105 }
 106
 107 #ifdef __KERNEL__
 108 static inline int capa_on_server(struct obd_capa *ocapa)
 109 {
 110         return ocapa->c_site == CAPA_SITE_SERVER;
 111 }
 112
 113 static inline void capa_delete(struct obd_capa *ocapa)
 114 {
 115         LASSERT(capa_on_server(ocapa));
 116         hlist_del(&ocapa->u.tgt.c_hash);
 117         list_del(&ocapa->c_list);
 118         capa_count[ocapa->c_site]--;
 119         free_capa(ocapa);
 120 }
 121
 122 void cleanup_capa_hash(struct hlist_head *hash)
 123 {
 124         int i;
 125         struct hlist_node *pos, *next;
 126         struct obd_capa *oc;
 127
 128         spin_lock(&capa_lock);
 129         for (i = 0; i < NR_CAPAHASH; i++) {
 130                 hlist_for_each_entry_safe(oc, pos, next, hash + i, u.tgt.c_hash)
 131                         capa_delete(oc);
 132         }
 133         spin_unlock(&capa_lock);
 134
 135         OBD_FREE(hash, CFS_PAGE_SIZE);
 136 }
 137
 138 static inline int capa_hashfn(struct lu_fid *fid)
 139 {
 140         return (fid_oid(fid) ^ fid_ver(fid)) *
 141                (unsigned long)(fid_seq(fid) + 1) % NR_CAPAHASH;
 142 }
 143
 144 /* capa renewal time check is earlier than that on client, which is to prevent
 145  * client renew right after obtaining it. */
 146 static inline int capa_is_to_expire(struct obd_capa *oc)
 147 {
 148         return cfs_time_before(cfs_time_sub(oc->c_expiry,
 149                                    cfs_time_seconds(oc->c_capa.lc_timeout)*2/3),
 150                                cfs_time_current());
 151 }
 152
 153 static struct obd_capa *find_capa(struct lustre_capa *capa,
 154                                   struct hlist_head *head, int alive)
 155 {
 156         struct hlist_node *pos;
 157         struct obd_capa *ocapa;
 158         int len = alive ? offsetof(struct lustre_capa, lc_keyid):sizeof(*capa);
 159
 160         hlist_for_each_entry(ocapa, pos, head, u.tgt.c_hash) {
 161                 if (memcmp(&ocapa->c_capa, capa, len))
 162                         continue;
 163                 /* don't return one that will expire soon in this case */
 164                 if (alive && capa_is_to_expire(ocapa))
 165                         continue;
 166
 167                 LASSERT(capa_on_server(ocapa));
 168
 169                 DEBUG_CAPA(D_SEC, &ocapa->c_capa, "found");
 170                 return ocapa;
 171         }
 172
 173         return NULL;
 174 }
 175
 176 #define LRU_CAPA_DELETE_COUNT 12
 177 static inline void capa_delete_lru(struct list_head *head)
 178 {
 179         struct obd_capa *ocapa;
 180         struct list_head *node = head->next;
 181         int count = 0;
 182
 183         /* free LRU_CAPA_DELETE_COUNT unused capa from head */
 184         while (count++ < LRU_CAPA_DELETE_COUNT) {
 185                 ocapa = list_entry(node, struct obd_capa, c_list);
 186                 node = node->next;
 187                 if (atomic_read(&ocapa->c_refc))
 188                         continue;
 189
 190                 DEBUG_CAPA(D_SEC, &ocapa->c_capa, "free lru");
 191                 capa_delete(ocapa);
 192         }
 193 }
 194
 195 /* add or update */
 196 struct obd_capa *capa_add(struct hlist_head *hash, struct lustre_capa *capa)
 197 {
 198         struct hlist_head *head = hash + capa_hashfn(&capa->lc_fid);
 199         struct obd_capa *ocapa, *old = NULL;
 200         struct list_head *list = &capa_list[CAPA_SITE_SERVER];
 201
 202         ocapa = alloc_capa(CAPA_SITE_SERVER);
 203         if (!ocapa)
 204                 return NULL;
 205
 206         spin_lock(&capa_lock);
 207         old = find_capa(capa, head, 0);
 208         if (!old) {
 209                 ocapa->c_capa = *capa;
 210                 set_capa_expiry(ocapa);
 211                 hlist_add_head(&ocapa->u.tgt.c_hash, head);
 212                 list_add_tail(&ocapa->c_list, list);
 213                 capa_count[CAPA_SITE_SERVER]++;
 214                 capa_get(ocapa);
 215
 216                 if (capa_count[CAPA_SITE_SERVER] > CAPA_HASH_SIZE)
 217                         capa_delete_lru(list);
 218
 219                 DEBUG_CAPA(D_SEC, &ocapa->c_capa, "new");
 220
 221                 spin_unlock(&capa_lock);
 222                 return ocapa;
 223         }
 224
 225         capa_get(old);
 226         spin_unlock(&capa_lock);
 227
 228         DEBUG_CAPA(D_SEC, &old->c_capa, "update");
 229
 230         free_capa(ocapa);
 231         return old;
 232 }
 233
 234 struct obd_capa *capa_lookup(struct hlist_head *hash, struct lustre_capa *capa,
 235                              int alive)
 236 {
 237         struct obd_capa *ocapa;
 238
 239         spin_lock(&capa_lock);
 240         ocapa = find_capa(capa, hash + capa_hashfn(&capa->lc_fid), alive);
 241         if (ocapa) {
 242                 list_move_tail(&ocapa->c_list, &capa_list[CAPA_SITE_SERVER]);
 243                 capa_get(ocapa);
 244         }
 245         spin_unlock(&capa_lock);
 246
 247         return ocapa;
 248 }
 249
 250 int capa_hmac(__u8 *hmac, struct lustre_capa *capa, __u8 *key)
 251 {
 252         struct ll_crypto_hash *tfm;
 253         struct capa_hmac_alg  *alg;
 254         int keylen;
 255         struct scatterlist sl = {
 256                 .page   = virt_to_page(capa),
 257                 .offset = (unsigned long)(capa) % CFS_PAGE_SIZE,
 258                 .length = offsetof(struct lustre_capa, lc_hmac),
 259         };
 260
 261         if (capa_alg(capa) != CAPA_HMAC_ALG_SHA1) {
 262                 CERROR("unknown capability hmac algorithm!\n");
 263                 return -EFAULT;
 264         }
 265
 266         alg = &capa_hmac_algs[capa_alg(capa)];
 267
 268         tfm = ll_crypto_alloc_hash(alg->ha_name, 0, 0);
 269         if (!tfm) {
 270                 CERROR("crypto_alloc_tfm failed, check whether your kernel"
 271                        "has crypto support!\n");
 272                 return -ENOMEM;
 273         }
 274         keylen = alg->ha_keylen;
 275
 276         ll_crypto_hmac(tfm, key, &keylen, &sl, sl.length, hmac);
 277         ll_crypto_free_hash(tfm);
 278
 279         return 0;
 280 }
 281 #endif
 282
 283 void capa_cpy(void *capa, struct obd_capa *ocapa)
 284 {
 285         spin_lock(&ocapa->c_lock);
 286         *(struct lustre_capa *)capa = ocapa->c_capa;
 287         spin_unlock(&ocapa->c_lock);
 288 }
 289
 290 char *dump_capa_content(char *buf, char *key, int len)
 291 {
 292         int i, n = 0;
 293
 294         for (i = 0; i < len; i++)
 295                 n += sprintf(buf + n, "%02x", (unsigned char) key[i]);
 296         return buf;
 297 }
 298
 299 EXPORT_SYMBOL(init_capa_hash);
 300 EXPORT_SYMBOL(cleanup_capa_hash);
 301
 302 EXPORT_SYMBOL(capa_add);
 303 EXPORT_SYMBOL(capa_lookup);
 304
 305 EXPORT_SYMBOL(capa_hmac);
 306 EXPORT_SYMBOL(capa_cpy);
 307
 308 EXPORT_SYMBOL(dump_capa_content);