lustre/obdclass/mea.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
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  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
  37 #define DEBUG_SUBSYSTEM S_CLASS
  38 #include <obd_class.h>
  39 #ifdef __KERNEL__
  40 #include <linux/kmod.h>   /* for request_module() */
  41 #include <linux/module.h>
  42 #include <linux/random.h>
  43 #include <linux/slab.h>
  44 #include <linux/pagemap.h>
  45 #else
  46 #include <liblustre.h>
  47 #include <obd.h>
  48 #endif
  49 #include <lprocfs_status.h>
  50 #include <lustre/lustre_idl.h>
  51
  52 #ifdef __KERNEL__
  53
  54 #ifdef HAVE_EXT4_LDISKFS
  55 #include <ldiskfs/ldiskfs_jbd2.h>
  56 #else
  57 #include <linux/jbd.h>
  58 #endif
  59
  60 #ifdef HAVE_SERVER_SUPPORT
  61 /* LDISKFS_SB() */
  62
  63 #ifdef HAVE_EXT4_LDISKFS
  64 #include <ldiskfs/ldiskfs.h>
  65 #else
  66 #include <linux/ldiskfs_fs.h>
  67 #endif
  68
  69 #endif
  70 #endif
  71 static int mea_last_char_hash(int count, char *name, int namelen)
  72 {
  73         unsigned int c;
  74
  75         c = name[namelen - 1];
  76         if (c == 0)
  77                 CWARN("looks like wrong len is passed\n");
  78         c = c % count;
  79         return c;
  80 }
  81
  82 static int mea_all_chars_hash(int count, char *name, int namelen)
  83 {
  84         unsigned int c = 0;
  85
  86         while (--namelen >= 0)
  87                 c += name[namelen];
  88         c = c % count;
  89         return c;
  90 }
  91
  92 #ifdef __KERNEL__
  93 /* This hash calculate method must be same as the lvar hash method */
  94
  95 #define LVAR_HASH_SANDWICH  (0)
  96 #define LVAR_HASH_PREFIX    (0)
  97
  98 static __u32 hash_build0(const char *name, int namelen)
  99 {
 100         __u32 result;
 101
 102         if (namelen == 0)
 103                 return 0;
 104         if (strncmp(name, ".", 1) == 0 && namelen == 1)
 105                 return 1;
 106         if (strncmp(name, "..", 2) == 0 && namelen == 2)
 107                 return 2;
 108
 109         if (LVAR_HASH_PREFIX) {
 110                 result = 0;
 111                 strncpy((void *)&result,
 112                         name, min(namelen, (int)sizeof result));
 113         } else {
 114                 struct ldiskfs_dx_hash_info hinfo;
 115
 116                 hinfo.hash_version = LDISKFS_DX_HASH_TEA;
 117                 hinfo.seed = 0;
 118                 ldiskfsfs_dirhash(name, namelen, &hinfo);
 119                 result = hinfo.hash;
 120                 if (LVAR_HASH_SANDWICH) {
 121                         __u32 result2;
 122
 123                         hinfo.hash_version = LDISKFS_DX_HASH_TEA;
 124                         hinfo.seed = 0;
 125                         ldiskfsfs_dirhash(name, namelen, &hinfo);
 126                         result2 = hinfo.hash;
 127                         result = (0xfc000000 & result2) | (0x03ffffff & result);
 128                 }
 129         }
 130
 131         return result;
 132 }
 133
 134 enum {
 135         HASH_GRAY_AREA = 1024
 136 };
 137
 138 static __u32 hash_build(const char *name, int namelen)
 139 {
 140         __u32 hash;
 141
 142         hash = (hash_build0(name, namelen) << 1) & MAX_HASH_SIZE_32;
 143         if (hash > MAX_HASH_SIZE_32 - HASH_GRAY_AREA)
 144                 hash &= HASH_GRAY_AREA - 1;
 145         return hash;
 146 }
 147
 148 static int mea_hash_segment(int count, const char *name, int namelen)
 149 {
 150         __u32 hash;
 151
 152         LASSERT(IS_PO2(MAX_HASH_SIZE_32 + 1));
 153
 154         hash = hash_build(name, namelen) / (MAX_HASH_SIZE_32 / count);
 155         LASSERTF(hash < count, "hash %x count %d \n", hash, count);
 156
 157         return hash;
 158 }
 159 #else
 160 static int mea_hash_segment(int count, char *name, int namelen)
 161 {
 162         return 0;
 163 }
 164 #endif
 165 int raw_name2idx(int hashtype, int count, const char *name, int namelen)
 166 {
 167         unsigned int c = 0;
 168
 169         LASSERT(namelen > 0);
 170         if (count <= 1)
 171                 return 0;
 172
 173         switch (hashtype) {
 174                 case MEA_MAGIC_LAST_CHAR:
 175                         c = mea_last_char_hash(count, (char *)name, namelen);
 176                         break;
 177                 case MEA_MAGIC_ALL_CHARS:
 178                         c = mea_all_chars_hash(count, (char *)name, namelen);
 179                         break;
 180                 case MEA_MAGIC_HASH_SEGMENT:
 181                         c = mea_hash_segment(count, (char *)name, namelen);
 182                         break;
 183                 default:
 184                         CERROR("Unknown hash type 0x%x\n", hashtype);
 185         }
 186
 187         LASSERT(c < count);
 188         return c;
 189 }
 190
 191 int mea_name2idx(struct lmv_stripe_md *mea, const char *name, int namelen)
 192 {
 193         unsigned int c;
 194
 195         LASSERT(mea && mea->mea_count);
 196
 197         c = raw_name2idx(mea->mea_magic, mea->mea_count, name, namelen);
 198
 199         LASSERT(c < mea->mea_count);
 200         return c;
 201 }