Whamcloud - gitweb
LU-812 compat: clean up mutex lock to use kernel mutex primitive
[fs/lustre-release.git] / lustre / include / lustre_fid.h
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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
30  * Use is subject to license terms.
31  *
32  * Copyright (c) 2011, 2012, Whamcloud, Inc.
33  */
34 /*
35  * This file is part of Lustre, http://www.lustre.org/
36  * Lustre is a trademark of Sun Microsystems, Inc.
37  *
38  * lustre/include/lustre_fid.h
39  *
40  * Author: Yury Umanets <umka@clusterfs.com>
41  */
42
43 #ifndef __LINUX_FID_H
44 #define __LINUX_FID_H
45
46 /** \defgroup fid fid
47  *
48  * @{
49  */
50
51 /*
52  * struct lu_fid
53  */
54 #include <libcfs/libcfs.h>
55 #include <lustre/lustre_idl.h>
56 #include <lustre_req_layout.h>
57 #include <lustre_mdt.h>
58
59
60 struct lu_site;
61 struct lu_context;
62
63 /* Whole sequences space range and zero range definitions */
64 extern const struct lu_seq_range LUSTRE_SEQ_SPACE_RANGE;
65 extern const struct lu_seq_range LUSTRE_SEQ_ZERO_RANGE;
66 extern const struct lu_fid LUSTRE_BFL_FID;
67 extern const struct lu_fid LU_OBF_FID;
68 extern const struct lu_fid LU_DOT_LUSTRE_FID;
69
70 enum {
71         /*
72          * This is how may FIDs may be allocated in one sequence(128k)
73          */
74         LUSTRE_SEQ_MAX_WIDTH = 0x0000000000020000ULL,
75
76         /*
77          * How many sequences to allocate to a client at once.
78          */
79         LUSTRE_SEQ_META_WIDTH = 0x0000000000000001ULL,
80
81          /*
82           * seq allocation pool size.
83           */
84         LUSTRE_SEQ_BATCH_WIDTH = LUSTRE_SEQ_META_WIDTH * 1000,
85
86         /*
87          * This is how many sequences may be in one super-sequence allocated to
88          * MDTs.
89          */
90         LUSTRE_SEQ_SUPER_WIDTH = ((1ULL << 30ULL) * LUSTRE_SEQ_META_WIDTH)
91 };
92
93 enum {
94         /** 2^6 FIDs for OI containers */
95         OSD_OI_FID_OID_BITS     = 6,
96         /** reserve enough FIDs in case we want more in the future */
97         OSD_OI_FID_OID_BITS_MAX = 10,
98 };
99
100 /** special OID for local objects */
101 enum local_oid {
102         /** \see fld_mod_init */
103         FLD_INDEX_OID           = 3UL,
104         /** \see fid_mod_init */
105         FID_SEQ_CTL_OID         = 4UL,
106         FID_SEQ_SRV_OID         = 5UL,
107         /** \see mdd_mod_init */
108         MDD_ROOT_INDEX_OID      = 6UL,
109         MDD_ORPHAN_OID          = 7UL,
110         MDD_LOV_OBJ_OID         = 8UL,
111         MDD_CAPA_KEYS_OID       = 9UL,
112         MDD_OBJECTS_OID         = 10UL,
113         /** \see mdt_mod_init */
114         MDT_LAST_RECV_OID       = 11UL,
115         /** \see osd_mod_init */
116         OSD_REM_OBJ_DIR_OID     = 12UL,
117         OSD_FS_ROOT_OID         = 13UL,
118         ACCT_USER_OID           = 15UL,
119         ACCT_GROUP_OID          = 16UL,
120         OFD_LAST_RECV_OID       = 19UL,
121         OFD_GROUP0_LAST_OID     = 20UL,
122         OFD_GROUP4K_LAST_OID    = 20UL+4096,
123         OFD_LAST_GROUP_OID      = 4117UL,
124         LLOG_CATALOGS_OID       = 4118UL,
125         MGS_CONFIGS_OID         = 4119UL,
126         OFD_HEALTH_CHECK_OID    = 4120UL,
127 };
128
129 static inline void lu_local_obj_fid(struct lu_fid *fid, __u32 oid)
130 {
131         fid->f_seq = FID_SEQ_LOCAL_FILE;
132         fid->f_oid = oid;
133         fid->f_ver = 0;
134 }
135
136 enum lu_mgr_type {
137         LUSTRE_SEQ_SERVER,
138         LUSTRE_SEQ_CONTROLLER
139 };
140
141 enum lu_cli_type {
142         LUSTRE_SEQ_METADATA,
143         LUSTRE_SEQ_DATA
144 };
145
146 struct lu_server_seq;
147
148 /* Client sequence manager interface. */
149 struct lu_client_seq {
150         /* Sequence-controller export. */
151         struct obd_export      *lcs_exp;
152         cfs_mutex_t             lcs_mutex;
153
154         /*
155          * Range of allowed for allocation sequeces. When using lu_client_seq on
156          * clients, this contains meta-sequence range. And for servers this
157          * contains super-sequence range.
158          */
159         struct lu_seq_range         lcs_space;
160
161         /* Seq related proc */
162         cfs_proc_dir_entry_t   *lcs_proc_dir;
163
164         /* This holds last allocated fid in last obtained seq */
165         struct lu_fid           lcs_fid;
166
167         /* LUSTRE_SEQ_METADATA or LUSTRE_SEQ_DATA */
168         enum lu_cli_type        lcs_type;
169
170         /*
171          * Service uuid, passed from MDT + seq name to form unique seq name to
172          * use it with procfs.
173          */
174         char                    lcs_name[80];
175
176         /*
177          * Sequence width, that is how many objects may be allocated in one
178          * sequence. Default value for it is LUSTRE_SEQ_MAX_WIDTH.
179          */
180         __u64                   lcs_width;
181
182         /* Seq-server for direct talking */
183         struct lu_server_seq   *lcs_srv;
184
185         /* wait queue for fid allocation and update indicator */
186         cfs_waitq_t             lcs_waitq;
187         int                     lcs_update;
188 };
189
190 /* server sequence manager interface */
191 struct lu_server_seq {
192         /* Available sequences space */
193         struct lu_seq_range         lss_space;
194
195         /* keeps highwater in lsr_end for seq allocation algorithm */
196         struct lu_seq_range         lss_lowater_set;
197         struct lu_seq_range         lss_hiwater_set;
198
199         /*
200          * Device for server side seq manager needs (saving sequences to backing
201          * store).
202          */
203         struct dt_device       *lss_dev;
204
205         /* /seq file object device */
206         struct dt_object       *lss_obj;
207
208         /* Seq related proc */
209         cfs_proc_dir_entry_t   *lss_proc_dir;
210
211         /* LUSTRE_SEQ_SERVER or LUSTRE_SEQ_CONTROLLER */
212         enum lu_mgr_type       lss_type;
213
214         /* Client interafce to request controller */
215         struct lu_client_seq   *lss_cli;
216
217         /* Mutex for protecting allocation */
218         cfs_mutex_t             lss_mutex;
219
220         /*
221          * Service uuid, passed from MDT + seq name to form unique seq name to
222          * use it with procfs.
223          */
224         char                    lss_name[80];
225
226         /*
227          * Allocation chunks for super and meta sequences. Default values are
228          * LUSTRE_SEQ_SUPER_WIDTH and LUSTRE_SEQ_META_WIDTH.
229          */
230         __u64                   lss_width;
231
232         /*
233          * minimum lss_alloc_set size that should be allocated from
234          * lss_space
235          */
236         __u64                   lss_set_width;
237
238         /* sync is needed for update operation */
239         __u32                   lss_need_sync;
240         /**
241          * Pointer to site object, required to access site fld.
242          */
243         struct md_site         *lss_site;
244 };
245
246 int seq_query(struct com_thread_info *info);
247
248 /* Server methods */
249 int seq_server_init(struct lu_server_seq *seq,
250                     struct dt_device *dev,
251                     const char *prefix,
252                     enum lu_mgr_type type,
253                     struct md_site *ls,
254                     const struct lu_env *env);
255
256 void seq_server_fini(struct lu_server_seq *seq,
257                      const struct lu_env *env);
258
259 int seq_server_alloc_super(struct lu_server_seq *seq,
260                            struct lu_seq_range *out,
261                            const struct lu_env *env);
262
263 int seq_server_alloc_meta(struct lu_server_seq *seq,
264                           struct lu_seq_range *out,
265                           const struct lu_env *env);
266
267 int seq_server_set_cli(struct lu_server_seq *seq,
268                        struct lu_client_seq *cli,
269                        const struct lu_env *env);
270
271 /* Client methods */
272 int seq_client_init(struct lu_client_seq *seq,
273                     struct obd_export *exp,
274                     enum lu_cli_type type,
275                     const char *prefix,
276                     struct lu_server_seq *srv);
277
278 void seq_client_fini(struct lu_client_seq *seq);
279
280 void seq_client_flush(struct lu_client_seq *seq);
281
282 int seq_client_alloc_fid(const struct lu_env *env, struct lu_client_seq *seq,
283                          struct lu_fid *fid);
284 int seq_client_get_seq(const struct lu_env *env, struct lu_client_seq *seq,
285                        seqno_t *seqnr);
286
287 /* Fids common stuff */
288 int fid_is_local(const struct lu_env *env,
289                  struct lu_site *site, const struct lu_fid *fid);
290
291 /* fid locking */
292
293 struct ldlm_namespace;
294
295 /*
296  * Build (DLM) resource name from FID.
297  *
298  * NOTE: until Lustre 1.8.7/2.1.1 the fid_ver() was packed into name[2],
299  * but was moved into name[1] along with the OID to avoid consuming the
300  * renaming name[2,3] fields that need to be used for the quota identifier.
301  */
302 static inline struct ldlm_res_id *
303 fid_build_reg_res_name(const struct lu_fid *f,
304                        struct ldlm_res_id *name)
305 {
306         memset(name, 0, sizeof *name);
307         name->name[LUSTRE_RES_ID_SEQ_OFF] = fid_seq(f);
308         name->name[LUSTRE_RES_ID_VER_OID_OFF] = fid_ver_oid(f);
309         return name;
310 }
311
312 /*
313  * Return true if resource is for object identified by fid.
314  */
315 static inline int fid_res_name_eq(const struct lu_fid *f,
316                                   const struct ldlm_res_id *name)
317 {
318         return name->name[LUSTRE_RES_ID_SEQ_OFF] == fid_seq(f) &&
319                name->name[LUSTRE_RES_ID_VER_OID_OFF] == fid_ver_oid(f);
320 }
321
322
323 static inline struct ldlm_res_id *
324 fid_build_pdo_res_name(const struct lu_fid *f,
325                        unsigned int hash,
326                        struct ldlm_res_id *name)
327 {
328         fid_build_reg_res_name(f, name);
329         name->name[LUSTRE_RES_ID_HSH_OFF] = hash;
330         return name;
331 }
332
333
334 /**
335  * Flatten 128-bit FID values into a 64-bit value for use as an inode number.
336  * For non-IGIF FIDs this starts just over 2^32, and continues without
337  * conflict until 2^64, at which point we wrap the high 24 bits of the SEQ
338  * into the range where there may not be many OID values in use, to minimize
339  * the risk of conflict.
340  *
341  * Suppose LUSTRE_SEQ_MAX_WIDTH less than (1 << 24) which is currently true,
342  * the time between re-used inode numbers is very long - 2^40 SEQ numbers,
343  * or about 2^40 client mounts, if clients create less than 2^24 files/mount.
344  */
345 static inline __u64 fid_flatten(const struct lu_fid *fid)
346 {
347         __u64 ino;
348         __u64 seq;
349
350         if (fid_is_igif(fid)) {
351                 ino = lu_igif_ino(fid);
352                 RETURN(ino);
353         }
354
355         seq = fid_seq(fid);
356
357         ino = (seq << 24) + ((seq >> 24) & 0xffffff0000ULL) + fid_oid(fid);
358
359         RETURN(ino ? ino : fid_oid(fid));
360 }
361
362 static inline __u32 fid_hash(const struct lu_fid *f, int bits)
363 {
364         /* all objects with same id and different versions will belong to same
365          * collisions list. */
366         return cfs_hash_long(fid_flatten(f), bits);
367 }
368
369 /**
370  * map fid to 32 bit value for ino on 32bit systems. */
371 static inline __u32 fid_flatten32(const struct lu_fid *fid)
372 {
373         __u32 ino;
374         __u64 seq;
375
376         if (fid_is_igif(fid)) {
377                 ino = lu_igif_ino(fid);
378                 RETURN(ino);
379         }
380
381         seq = fid_seq(fid) - FID_SEQ_START;
382
383         /* Map the high bits of the OID into higher bits of the inode number so
384          * that inodes generated at about the same time have a reduced chance
385          * of collisions. This will give a period of 2^12 = 1024 unique clients
386          * (from SEQ) and up to min(LUSTRE_SEQ_MAX_WIDTH, 2^20) = 128k objects
387          * (from OID), or up to 128M inodes without collisions for new files. */
388         ino = ((seq & 0x000fffffULL) << 12) + ((seq >> 8) & 0xfffff000) +
389                (seq >> (64 - (40-8)) & 0xffffff00) +
390                (fid_oid(fid) & 0xff000fff) + ((fid_oid(fid) & 0x00fff000) << 8);
391
392         RETURN(ino ? ino : fid_oid(fid));
393 }
394
395 #define LUSTRE_SEQ_SRV_NAME "seq_srv"
396 #define LUSTRE_SEQ_CTL_NAME "seq_ctl"
397
398 /* Range common stuff */
399 static inline void range_cpu_to_le(struct lu_seq_range *dst, const struct lu_seq_range *src)
400 {
401         dst->lsr_start = cpu_to_le64(src->lsr_start);
402         dst->lsr_end = cpu_to_le64(src->lsr_end);
403         dst->lsr_index = cpu_to_le32(src->lsr_index);
404         dst->lsr_flags = cpu_to_le32(src->lsr_flags);
405 }
406
407 static inline void range_le_to_cpu(struct lu_seq_range *dst, const struct lu_seq_range *src)
408 {
409         dst->lsr_start = le64_to_cpu(src->lsr_start);
410         dst->lsr_end = le64_to_cpu(src->lsr_end);
411         dst->lsr_index = le32_to_cpu(src->lsr_index);
412         dst->lsr_flags = le32_to_cpu(src->lsr_flags);
413 }
414
415 static inline void range_cpu_to_be(struct lu_seq_range *dst, const struct lu_seq_range *src)
416 {
417         dst->lsr_start = cpu_to_be64(src->lsr_start);
418         dst->lsr_end = cpu_to_be64(src->lsr_end);
419         dst->lsr_index = cpu_to_be32(src->lsr_index);
420         dst->lsr_flags = cpu_to_be32(src->lsr_flags);
421 }
422
423 static inline void range_be_to_cpu(struct lu_seq_range *dst, const struct lu_seq_range *src)
424 {
425         dst->lsr_start = be64_to_cpu(src->lsr_start);
426         dst->lsr_end = be64_to_cpu(src->lsr_end);
427         dst->lsr_index = be32_to_cpu(src->lsr_index);
428         dst->lsr_flags = be32_to_cpu(src->lsr_flags);
429 }
430
431 /** @} fid */
432
433 #endif /* __LINUX_FID_H */