Whamcloud - gitweb
LU-9611 lod: allow -1 for default stripe count/offset
[fs/lustre-release.git] / lustre / include / lustre_lmv.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License version 2 for more details.  A copy is
14  * included in the COPYING file that accompanied this code.
15
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2014, 2016, Intel Corporation.
24  */
25 /*
26  * lustre/include/lustre_lmv.h
27  *
28  * Lustre LMV structures and functions.
29  *
30  * Author: Di Wang <di.wang@intel.com>
31  */
32
33 #ifndef _LUSTRE_LMV_H
34 #define _LUSTRE_LMV_H
35 #include <lustre/lustre_idl.h>
36
37 struct lmv_oinfo {
38         struct lu_fid   lmo_fid;
39         u32             lmo_mds;
40         struct inode    *lmo_root;
41 };
42
43 struct lmv_stripe_md {
44         __u32   lsm_md_magic;
45         __u32   lsm_md_stripe_count;
46         __u32   lsm_md_master_mdt_index;
47         __u32   lsm_md_hash_type;
48         __u32   lsm_md_layout_version;
49         __u32   lsm_md_default_count;
50         __u32   lsm_md_default_index;
51         char    lsm_md_pool_name[LOV_MAXPOOLNAME + 1];
52         struct lmv_oinfo lsm_md_oinfo[0];
53 };
54
55 static inline bool
56 lsm_md_eq(const struct lmv_stripe_md *lsm1, const struct lmv_stripe_md *lsm2)
57 {
58         __u32 idx;
59
60         if (lsm1->lsm_md_magic != lsm2->lsm_md_magic ||
61             lsm1->lsm_md_stripe_count != lsm2->lsm_md_stripe_count ||
62             lsm1->lsm_md_master_mdt_index !=
63                                 lsm2->lsm_md_master_mdt_index ||
64             lsm1->lsm_md_hash_type != lsm2->lsm_md_hash_type ||
65             lsm1->lsm_md_layout_version !=
66                                 lsm2->lsm_md_layout_version ||
67             strcmp(lsm1->lsm_md_pool_name,
68                       lsm2->lsm_md_pool_name) != 0)
69                 return false;
70
71         for (idx = 0; idx < lsm1->lsm_md_stripe_count; idx++) {
72                 if (!lu_fid_eq(&lsm1->lsm_md_oinfo[idx].lmo_fid,
73                                &lsm2->lsm_md_oinfo[idx].lmo_fid))
74                         return false;
75         }
76
77         return true;
78 }
79 union lmv_mds_md;
80
81 void lmv_free_memmd(struct lmv_stripe_md *lsm);
82
83 int lmvea_load_shards(const struct lu_env *env, struct dt_object *obj,
84                       struct lu_dirent *ent, struct lu_buf *buf,
85                       bool resize);
86
87 static inline void lmv1_le_to_cpu(struct lmv_mds_md_v1 *lmv_dst,
88                                   const struct lmv_mds_md_v1 *lmv_src)
89 {
90         __u32 i;
91
92         lmv_dst->lmv_magic = le32_to_cpu(lmv_src->lmv_magic);
93         lmv_dst->lmv_stripe_count = le32_to_cpu(lmv_src->lmv_stripe_count);
94         lmv_dst->lmv_master_mdt_index =
95                                 le32_to_cpu(lmv_src->lmv_master_mdt_index);
96         lmv_dst->lmv_hash_type = le32_to_cpu(lmv_src->lmv_hash_type);
97         lmv_dst->lmv_layout_version = le32_to_cpu(lmv_src->lmv_layout_version);
98         for (i = 0; i < lmv_src->lmv_stripe_count; i++)
99                 fid_le_to_cpu(&lmv_dst->lmv_stripe_fids[i],
100                               &lmv_src->lmv_stripe_fids[i]);
101 }
102
103 static inline void lmv_le_to_cpu(union lmv_mds_md *lmv_dst,
104                                  const union lmv_mds_md *lmv_src)
105 {
106         switch (le32_to_cpu(lmv_src->lmv_magic)) {
107         case LMV_MAGIC_V1:
108                 lmv1_le_to_cpu(&lmv_dst->lmv_md_v1, &lmv_src->lmv_md_v1);
109                 break;
110         default:
111                 break;
112         }
113 }
114
115 /* This hash is only for testing purpose */
116 static inline unsigned int
117 lmv_hash_all_chars(unsigned int count, const char *name, int namelen)
118 {
119         unsigned int c = 0;
120         const unsigned char *p = (const unsigned char *)name;
121
122         while (--namelen >= 0)
123                 c += p[namelen];
124
125         c = c % count;
126
127         return c;
128 }
129
130 static inline unsigned int
131 lmv_hash_fnv1a(unsigned int count, const char *name, int namelen)
132 {
133         __u64 hash;
134
135         hash = lustre_hash_fnv_1a_64(name, namelen);
136
137         return do_div(hash, count);
138 }
139
140 static inline int lmv_name_to_stripe_index(__u32 lmv_hash_type,
141                                            unsigned int stripe_count,
142                                            const char *name, int namelen)
143 {
144         int     idx;
145         __u32   hash_type = lmv_hash_type & LMV_HASH_TYPE_MASK;
146
147         LASSERT(namelen > 0);
148         if (stripe_count <= 1)
149                 return 0;
150
151         /* for migrating object, always start from 0 stripe */
152         if (lmv_hash_type & LMV_HASH_FLAG_MIGRATION)
153                 return 0;
154
155         switch (hash_type) {
156         case LMV_HASH_TYPE_ALL_CHARS:
157                 idx = lmv_hash_all_chars(stripe_count, name, namelen);
158                 break;
159         case LMV_HASH_TYPE_FNV_1A_64:
160                 idx = lmv_hash_fnv1a(stripe_count, name, namelen);
161                 break;
162         default:
163                 idx = -EBADFD;
164                 break;
165         }
166
167         CDEBUG(D_INFO, "name %.*s hash_type %d idx %d\n", namelen, name,
168                hash_type, idx);
169
170         return idx;
171 }
172
173 static inline bool lmv_is_known_hash_type(__u32 type)
174 {
175         return (type & LMV_HASH_TYPE_MASK) == LMV_HASH_TYPE_FNV_1A_64 ||
176                (type & LMV_HASH_TYPE_MASK) == LMV_HASH_TYPE_ALL_CHARS;
177 }
178
179 #endif