4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see [sun.com URL with a
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2015, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
37 * Top-level entry points into osd module
39 * Author: Wang Di <wangdi@clusterfs.com>
40 * Author: Nikita Danilov <nikita@clusterfs.com>
43 #ifndef __LINUX_LUSTRE_IAM_H__
44 #define __LINUX_LUSTRE_IAM_H__
46 #include <linux/module.h>
47 #include <asm/unaligned.h>
49 #include "osd_dynlocks.h"
54 #define CLASSERT(cond) do {switch(42) {case (cond): case 0: break;}} while (0)
57 #define ergo(a, b) (!(a) || (b))
58 /* logical equivalence */
59 #define equi(a, b) (!!(a) == !!(b))
63 * Maximal number of non-leaf levels in htree. In the stock ldiskfs this
67 * XXX reduced back to 2 to make per-node locking work.
69 DX_MAX_TREE_HEIGHT = 5,
71 * Scratch keys used by generic code for temporaries.
75 * [0] reserved for assertions and as a staging area for
76 * record keys immediately used for key comparisons.
78 * [1] reserved for record key, stored during iteration over
79 * node records (see dx_node_check()).
81 * [2] reserved for leaf node operations.
83 * [3] reserved for index operations.
85 * [4] reserved for path->ip_ikey_target
90 * Maximal format name length.
99 * Various debugging levels.
104 * Following macros are defined in config.h and are tunable through
105 * appropriate configure switches (indicated below).
109 * Compile basic assertions in. You want this most of the time.
111 * --{enable,disable}-ldiskfs-assert (on by default).
113 #define LDISKFS_ASSERT (1)
116 * Compile heavier correctness checks in. You want this during development
119 * --{enable,disable}-ldiskfs-correctness (off by default).
121 #define LDISKFS_CORRECTNESS (1)
124 * Compile heavy invariant checking in. You want this early during development
125 * or when chasing a bug.
127 * --{enable,disable}-ldiskfs-invariant (off by default).
129 #define LDISKFS_INVARIANT (1)
132 #if defined(LDISKFS_ASSERT)
133 #define LDISKFS_ASSERT_ON (1)
135 #define LDISKFS_ASSERT_ON (0)
138 #if defined(LDISKFS_CORRECTNESS)
139 #define LDISKFS_CORRECTNESS_ON (1)
141 #define LDISKFS_CORRECTNESS_ON (0)
144 #if defined(LDISKFS_INVARIANT)
145 #define LDISKFS_INVARIANT_ON (1)
147 #define LDISKFS_INVARIANT_ON (0)
151 #if LDISKFS_ASSERT_ON
152 #define assert(test) J_ASSERT(test)
154 #define assert(test) ((void)(test))
158 #if LDISKFS_CORRECTNESS_ON
159 #define assert_corr(test) J_ASSERT(test)
160 #define do_corr(exp) exp
162 #define assert_corr(test) do {;} while (0)
163 #define do_corr(exp) do {;} while (0)
166 #if LDISKFS_INVARIANT_ON
167 #define assert_inv(test) J_ASSERT(test)
169 #define assert_inv(test) do {;} while (0)
173 * Entry within index tree node. Consists of a key immediately followed
174 * (without padding) by a pointer to the child node.
176 * Both key and pointer are of variable size, hence incomplete type.
180 struct iam_entry_compat {
186 * Incomplete type used to refer to keys in iam container.
188 * As key size can be different from container to container, iam has to use
189 * incomplete type. Clients cast pointer to iam_key to real key type and back.
194 * Incomplete type use to refer to the records stored in iam containers.
199 * Key in index node. Possibly compressed. Fixed size.
204 * Scalar type into which certain iam_key's can be uniquely mapped. Used to
205 * support interfaces like readdir(), where iteration over index has to be
208 typedef __u32 iam_ptr_t;
211 * Index node traversed during tree lookup.
214 struct buffer_head *bh; /* buffer holding node data */
215 struct iam_entry *entries; /* array of entries */
216 struct iam_entry *at; /* target entry, found by binary search */
217 iam_ptr_t leaf; /* (logical) offset of child node found by
219 iam_ptr_t curidx; /* (logical) offset of this node. Used to
220 * per-node locking to detect concurrent
222 unsigned int at_shifted:1; /* The "at" entry has moved to next
223 * because of shrinking index node
224 * for recycling empty leaf node. */
228 * Opaque entry in the leaf node.
233 struct iam_container;
236 /* leaf node reached by tree lookup */
238 struct iam_path *il_path;
239 struct buffer_head *il_bh;
240 struct iam_lentry *il_entries;
241 struct iam_lentry *il_at;
243 * Lock on a leaf node.
245 struct dynlock_handle *il_lock;
246 iam_ptr_t il_curidx; /* logical offset of leaf node. */
251 * Return values of ->lookup() operation from struct iam_leaf_operations.
255 * lookup found a record with the key requested
257 IAM_LOOKUP_EXACT = 0,
259 * lookup positioned leaf on some record
265 IAM_LOOKUP_EMPTY = 2,
267 * lookup positioned leaf before first record
269 IAM_LOOKUP_BEFORE = 3,
271 * Found hash may have a continuation in the next leaf.
273 IAM_LOOKUP_LAST = 0x100
277 * Format-specific container operations. These are called by generic iam code.
279 struct iam_operations {
281 * Returns pointer (in the same sense as pointer in index entry) to
284 __u32 (*id_root_ptr)(struct iam_container *c);
287 * Check validity and consistency of index node.
289 int (*id_node_check)(struct iam_path *path, struct iam_frame *frame);
291 * Copy some data from node header into frame. This is called when
292 * new node is loaded into frame.
294 int (*id_node_load)(struct iam_path *path, struct iam_frame *frame);
296 * Initialize new node (stored in @bh) that is going to be added into
299 int (*id_node_init)(struct iam_container *c,
300 struct buffer_head *bh, int root);
301 int (*id_node_read)(struct iam_container *c, iam_ptr_t ptr,
302 handle_t *h, struct buffer_head **bh);
304 * Key comparison functions. Returns -1, 0, +1.
306 int (*id_ikeycmp)(const struct iam_container *c,
307 const struct iam_ikey *k1,
308 const struct iam_ikey *k2);
310 * Modify root node when tree height increases.
312 struct iam_entry *(*id_root_inc)(struct iam_container *c,
313 struct iam_path *path,
314 struct iam_frame *frame);
316 struct iam_path_descr *(*id_ipd_alloc)(const struct iam_container *c,
318 void (*id_ipd_free)(struct iam_path_descr *ipd);
322 char id_name[DX_FMT_NAME_LEN];
326 * Another format-specific operation vector, consisting of methods to access
327 * leaf nodes. This is separated from struct iam_operations, because it is
328 * assumed that there will be many formats with different format of leaf
329 * nodes, yes the same struct iam_operations.
331 struct iam_leaf_operations {
337 * initialize just loaded leaf node.
339 int (*init)(struct iam_leaf *p);
343 void (*init_new)(struct iam_container *c, struct buffer_head *bh);
347 void (*fini)(struct iam_leaf *l);
349 * returns true iff leaf is positioned at the last entry.
351 int (*at_end)(const struct iam_leaf *l);
352 /* position leaf at the first entry */
353 void (*start)(struct iam_leaf *l);
354 /* more leaf to the next entry. */
355 void (*next)(struct iam_leaf *l);
357 * return key of current leaf record. This method may return
358 * either pointer to the key stored in node, or copy key into
359 * @k buffer supplied by caller and return pointer to this
360 * buffer. The latter approach is used when keys in nodes are
361 * not stored in plain form (e.g., htree doesn't store keys at
364 * Caller should assume that returned pointer is only valid
365 * while leaf node is pinned and locked.
367 struct iam_ikey *(*ikey)(const struct iam_leaf *l, struct iam_ikey *k);
368 struct iam_key *(*key)(const struct iam_leaf *l);
369 /* return pointer to entry body. Pointer is valid while
370 corresponding leaf node is locked and pinned. */
371 struct iam_rec *(*rec)(const struct iam_leaf *l);
373 void (*key_set)(struct iam_leaf *l, const struct iam_key *k);
374 void (*rec_set)(struct iam_leaf *l, const struct iam_rec *r);
375 void (*rec_get)(const struct iam_leaf *l, struct iam_rec *r);
377 int (*key_cmp)(const struct iam_leaf *l, const struct iam_key *k);
378 int (*key_eq)(const struct iam_leaf *l, const struct iam_key *k);
380 int (*rec_eq)(const struct iam_leaf *l, const struct iam_rec *r);
382 int (*key_size)(const struct iam_leaf *l);
384 * Search leaf @l for a record with key @k or for a place
385 * where such record is to be inserted.
387 * Scratch keys from @path can be used.
389 int (*lookup)(struct iam_leaf *l, const struct iam_key *k);
390 int (*ilookup)(struct iam_leaf *l, const struct iam_ikey *ik);
392 int (*can_add)(const struct iam_leaf *l,
393 const struct iam_key *k, const struct iam_rec *r);
397 void (*rec_add)(struct iam_leaf *l,
398 const struct iam_key *k, const struct iam_rec *r);
400 * remove rec for a leaf
402 void (*rec_del)(struct iam_leaf *l, int shift);
404 * split leaf node, moving some entries into @bh (the latter currently
405 * is assumed to be empty).
407 void (*split)(struct iam_leaf *l, struct buffer_head **bh,
412 int (*leaf_empty)(struct iam_leaf *l);
416 * Parameters, describing a flavor of iam container.
420 * Size of a key in this container, in bytes.
424 * Size of a key in index nodes, in bytes.
428 * Size of a pointer to the next level (stored in index nodes), in
433 * Size of a record (stored in leaf nodes), in bytes.
437 * Size of unused (by iam) space at the beginning of every non-root
438 * node, in bytes. Used for compatibility with ldiskfs.
442 * Size of unused (by iam) space at the beginning of root node, in
443 * bytes. Used for compatibility with ldiskfs.
447 struct iam_operations *id_ops;
448 struct iam_leaf_operations *id_leaf_ops;
452 IAM_IDLE_HEADER_MAGIC = 0x7903,
456 * Header structure to record idle blocks.
458 struct iam_idle_head {
460 __le16 iih_count; /* how many idle blocks in this head */
461 __le32 iih_next; /* next head for idle blocks */
466 * An instance of iam container.
468 struct iam_container {
470 * Underlying flat file. IO against this object is issued to
473 struct inode *ic_object;
477 struct buffer_head *ic_root_bh;
481 struct iam_descr *ic_descr;
483 * read-write lock protecting index consistency.
485 struct rw_semaphore ic_sem;
486 struct dynlock ic_tree_lock;
487 /* Protect ic_idle_bh */
488 struct mutex ic_idle_mutex;
492 struct buffer_head *ic_idle_bh;
493 unsigned int ic_idle_failed:1; /* Idle block mechanism failed */
497 * description-specific part of iam_path. This is usually embedded into larger
500 struct iam_path_descr {
502 * Scratch-pad area for temporary keys.
504 struct iam_ikey *ipd_key_scratch[DX_SCRATCH_KEYS];
508 * Structure to keep track of a path drilled through htree.
514 struct iam_container *ip_container;
516 * Number of index levels minus one.
520 * Nodes that top-to-bottom traversal passed through.
522 struct iam_frame ip_frames[DX_MAX_TREE_HEIGHT];
524 * Last filled frame in ->ip_frames. Refers to the 'twig' node (one
525 * immediately above leaf).
527 struct iam_frame *ip_frame;
529 * Leaf node: a child of ->ip_frame.
531 struct iam_leaf ip_leaf;
535 const struct iam_key *ip_key_target;
536 const struct iam_ikey *ip_ikey_target;
538 * Description-specific data.
540 struct iam_path_descr *ip_data;
543 struct ldiskfs_dx_hash_info;
546 * Helper structure for legacy htrees.
548 struct iam_path_compat {
549 struct iam_path ipc_path;
550 struct iam_container ipc_container;
551 __u32 ipc_scratch[DX_SCRATCH_KEYS];
552 struct ldiskfs_dx_hash_info *ipc_hinfo;
553 struct qstr *ipc_qstr;
554 struct iam_path_descr ipc_descr;
555 struct ldiskfs_dx_hash_info ipc_hinfo_area;
558 #define const_max(p, q) ((p > q) ? p : q)
561 DX_MAX_IKEY_SIZE = 32, /* be generous */
563 * Hack to avoid dynamic allocation and freeing of ipd.
565 DX_IPD_MAX_SIZE = const_max(sizeof(struct iam_path_compat),
566 DX_MAX_IKEY_SIZE * DX_SCRATCH_KEYS +
567 sizeof(struct iam_path_descr))
571 * iam cursor (iterator) api.
575 * States of iterator state machine.
580 /* iterator is above particular record in the container */
582 /* iterator is positioned before record */
587 * Flags controlling iterator functionality.
591 * this iterator will move (iam_it_next() will be called on it)
593 IAM_IT_MOVE = (1 << 0),
595 * tree can be updated through this iterator.
597 IAM_IT_WRITE = (1 << 1)
603 * Immediately after call to iam_it_init() iterator is in "detached"
604 * (IAM_IT_DETACHED) state: it is associated with given parent container, but
605 * doesn't point to any particular record in this container.
607 * After successful call to iam_it_get() and until corresponding call to
608 * iam_it_put() iterator is in one of "active" states: IAM_IT_ATTACHED or
611 * Active iterator can move through records in a container (provided
612 * IAM_IT_MOVE permission) in a key order, can get record and key values as it
613 * passes over them, and can modify container (provided IAM_IT_WRITE
616 * Iteration may reach the end of container, at which point iterator switches
617 * into IAM_IT_DETACHED state.
619 * Concurrency: iterators are supposed to be local to thread. Interfaces below
620 * do no internal serialization of access to the iterator fields.
622 * When in non-detached state, iterator keeps some container nodes pinned in
623 * memory and locked (that locking may be implemented at the container
624 * granularity though). In particular, clients may assume that pointers to
625 * records and keys obtained through iterator interface as valid until
626 * iterator is detached (except that they may be invalidated by sub-sequent
627 * operations done through the same iterator).
630 struct iam_iterator {
632 * iterator flags, taken from enum iam_it_flags.
635 enum iam_it_state ii_state;
637 * path to the record. Valid in IAM_IT_ATTACHED, and IAM_IT_SKEWED
640 struct iam_path ii_path;
643 void iam_path_init(struct iam_path *path, struct iam_container *c,
644 struct iam_path_descr *pd);
645 void iam_path_fini(struct iam_path *path);
646 void iam_path_release(struct iam_path *path);
648 void iam_path_compat_init(struct iam_path_compat *path, struct inode *inode);
649 void iam_path_compat_fini(struct iam_path_compat *path);
651 struct iam_path_descr *iam_ipd_alloc(void *area, int keysize);
652 void iam_ipd_free(struct iam_path_descr *ipd);
654 int iam_it_init(struct iam_iterator *it, struct iam_container *c, __u32 flags,
655 struct iam_path_descr *pd);
656 void iam_it_fini(struct iam_iterator *it);
657 int iam_it_get(struct iam_iterator *it, const struct iam_key *k);
658 int iam_it_get_at(struct iam_iterator *it, const struct iam_key *k);
659 void iam_it_dup(struct iam_iterator *dst, const struct iam_iterator *src);
660 void iam_it_put(struct iam_iterator *it);
661 int iam_it_next(struct iam_iterator *it);
662 struct iam_rec *iam_it_rec_get(const struct iam_iterator *it);
663 int iam_it_rec_set(handle_t *h,
664 struct iam_iterator *it, const struct iam_rec *r);
665 struct iam_key *iam_it_key_get(const struct iam_iterator *it);
666 int iam_it_key_size(const struct iam_iterator *it);
667 int iam_it_rec_insert(handle_t *h, struct iam_iterator *it,
668 const struct iam_key *k, const struct iam_rec *r);
669 int iam_it_rec_delete(handle_t *h, struct iam_iterator *it);
671 typedef __u64 iam_pos_t;
673 iam_pos_t iam_it_store(const struct iam_iterator *it);
674 int iam_it_load(struct iam_iterator *it, iam_pos_t pos);
676 int iam_lookup(struct iam_container *c, const struct iam_key *k,
677 struct iam_rec *r, struct iam_path_descr *pd);
678 int iam_delete(handle_t *h, struct iam_container *c, const struct iam_key *k,
679 struct iam_path_descr *pd);
680 int iam_update(handle_t *h, struct iam_container *c, const struct iam_key *k,
681 const struct iam_rec *r, struct iam_path_descr *pd);
682 int iam_insert(handle_t *handle, struct iam_container *c,
683 const struct iam_key *k,
684 const struct iam_rec *r, struct iam_path_descr *pd);
686 * Initialize container @c.
688 int iam_container_init(struct iam_container *c,
689 struct iam_descr *descr, struct inode *inode);
691 * Finalize container @c, release all resources.
693 void iam_container_fini(struct iam_container *c);
696 * Determine container format.
698 int iam_container_setup(struct iam_container *c);
700 static inline struct iam_descr *iam_container_descr(struct iam_container *c)
705 static inline struct iam_descr *iam_path_descr(const struct iam_path *p)
707 return p->ip_container->ic_descr;
710 static inline struct inode *iam_path_obj(struct iam_path *p)
712 return p->ip_container->ic_object;
715 static inline void iam_ikeycpy(const struct iam_container *c,
716 struct iam_ikey *k1, const struct iam_ikey *k2)
718 memcpy(k1, k2, c->ic_descr->id_ikey_size);
721 static inline size_t iam_entry_size(struct iam_path *p)
723 return iam_path_descr(p)->id_ikey_size + iam_path_descr(p)->id_ptr_size;
726 static inline struct iam_entry *iam_entry_shift(struct iam_path *p,
727 struct iam_entry *entry,
731 return e + shift * iam_entry_size(p);
734 static inline struct iam_ikey *dx_get_ikey(struct iam_path *p,
735 struct iam_entry *entry,
736 struct iam_ikey *key)
738 return memcpy(key, entry, iam_path_descr(p)->id_ikey_size);
741 static inline struct iam_ikey *iam_ikey_at(struct iam_path *p,
742 struct iam_entry *entry)
744 return (struct iam_ikey *)entry;
747 static inline ptrdiff_t iam_entry_diff(struct iam_path *p,
748 struct iam_entry *e1,
749 struct iam_entry *e2)
753 diff = (void *)e1 - (void *)e2;
754 assert_corr(diff / iam_entry_size(p) * iam_entry_size(p) == diff);
755 return diff / iam_entry_size(p);
759 * Helper for the frequent case, where key was already placed into @k1 by
762 static inline void iam_ikeycpy0(const struct iam_container *c,
763 struct iam_ikey *k1, const struct iam_ikey *k2)
766 iam_ikeycpy(c, k1, k2);
769 static inline int iam_ikeycmp(const struct iam_container *c,
770 const struct iam_ikey *k1,
771 const struct iam_ikey *k2)
773 return c->ic_descr->id_ops->id_ikeycmp(c, k1, k2);
776 static inline void *iam_entry_off(struct iam_entry *entry, size_t off)
778 return (void *)((char *)entry + off);
785 static inline struct iam_path *iam_leaf_path(const struct iam_leaf *leaf)
787 return leaf->il_path;
790 static inline struct iam_container *
791 iam_leaf_container(const struct iam_leaf *leaf)
793 return iam_leaf_path(leaf)->ip_container;
796 static inline struct iam_descr *iam_leaf_descr(const struct iam_leaf *leaf)
798 return iam_leaf_container(leaf)->ic_descr;
801 static inline struct iam_leaf_operations *
802 iam_leaf_ops(const struct iam_leaf *leaf)
804 return iam_leaf_descr(leaf)->id_leaf_ops;
807 static inline void iam_reccpy(const struct iam_leaf *leaf,
808 struct iam_rec *rec_dst)
810 iam_leaf_ops(leaf)->rec_get(leaf, rec_dst);
813 /*XXX These stuff put here, just because they are used by iam.c */
814 static inline unsigned dx_get_block(struct iam_path *p, struct iam_entry *entry)
818 addr = iam_entry_off(entry, iam_path_descr(p)->id_ikey_size);
819 return le32_to_cpu(get_unaligned(addr));
822 static inline void dx_set_block(struct iam_path *p,
823 struct iam_entry *entry, unsigned value)
827 addr = iam_entry_off(entry, iam_path_descr(p)->id_ikey_size);
828 put_unaligned(cpu_to_le32(value), addr);
831 static inline void dx_set_ikey(struct iam_path *p, struct iam_entry *entry,
832 const struct iam_ikey *key)
834 iam_ikeycpy(p->ip_container, iam_entry_off(entry, 0), key);
850 struct dx_countlimit {
856 * dx_root_info is laid out so that if it should somehow get overlaid by a
857 * dirent the two low bits of the hash version will be zero. Therefore, the
858 * hash version mod 4 should never be 0. Sincerely, the paranoia department.
862 struct fake_dirent dot;
864 struct fake_dirent dotdot;
868 __le32 reserved_zero;
870 u8 info_length; /* 8 */
875 struct {} entries[0];
880 struct fake_dirent fake;
881 struct {} entries[0];
885 static inline unsigned dx_get_count(struct iam_entry *entries)
887 return le16_to_cpu(((struct dx_countlimit *) entries)->count);
890 static inline unsigned dx_get_limit(struct iam_entry *entries)
892 return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
895 static inline void dx_set_count(struct iam_entry *entries, unsigned value)
897 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
900 static inline unsigned dx_node_limit(struct iam_path *p)
902 struct iam_descr *param = iam_path_descr(p);
903 unsigned entry_space = iam_path_obj(p)->i_sb->s_blocksize -
905 return entry_space / (param->id_ikey_size + param->id_ptr_size);
908 static inline unsigned dx_root_limit(struct iam_path *p)
910 struct iam_descr *param = iam_path_descr(p);
911 unsigned limit = iam_path_obj(p)->i_sb->s_blocksize -
913 limit /= (param->id_ikey_size + param->id_ptr_size);
914 if (limit == dx_node_limit(p))
920 static inline struct iam_entry *dx_get_entries(struct iam_path *path,
921 void *data, int root)
923 struct iam_descr *param = iam_path_descr(path);
924 return data + (root ? param->id_root_gap : param->id_node_gap);
928 static inline struct iam_entry *dx_node_get_entries(struct iam_path *path,
929 struct iam_frame *frame)
931 return dx_get_entries(path,
932 frame->bh->b_data, frame == path->ip_frames);
935 static inline struct iam_ikey *iam_path_ikey(const struct iam_path *path,
938 LASSERT(0 <= nr && nr < ARRAY_SIZE(path->ip_data->ipd_key_scratch));
939 return path->ip_data->ipd_key_scratch[nr];
942 static inline int iam_leaf_is_locked(const struct iam_leaf *leaf)
946 result = dynlock_is_locked(&iam_leaf_container(leaf)->ic_tree_lock,
953 static inline int iam_frame_is_locked(struct iam_path *path,
954 const struct iam_frame *frame)
958 result = dynlock_is_locked(&path->ip_container->ic_tree_lock,
965 int dx_lookup_lock(struct iam_path *path,
966 struct dynlock_handle **dl, enum dynlock_type lt);
968 void dx_insert_block(struct iam_path *path, struct iam_frame *frame,
969 u32 hash, u32 block);
970 int dx_index_is_compat(struct iam_path *path);
972 int ldiskfs_htree_next_block(struct inode *dir, __u32 hash,
973 struct iam_path *path, __u32 *start_hash);
975 int split_index_node(handle_t *handle, struct iam_path *path,
976 struct dynlock_handle **lh);
977 struct ldiskfs_dir_entry_2 *split_entry(struct inode *dir,
978 struct ldiskfs_dir_entry_2 *de,
979 unsigned long ino, mode_t mode,
980 const char *name, int namelen);
981 struct ldiskfs_dir_entry_2 *find_insertion_point(struct inode *dir,
982 struct buffer_head *bh,
983 const char *name, int namelen);
984 struct ldiskfs_dir_entry_2 *move_entries(struct inode *dir,
985 struct ldiskfs_dx_hash_info *hinfo,
986 struct buffer_head **bh1,
987 struct buffer_head **bh2,
990 extern struct iam_descr iam_htree_compat_param;
992 struct dynlock_handle *dx_lock_htree(struct inode *dir, unsigned long value,
993 enum dynlock_type lt);
994 void dx_unlock_htree(struct inode *dir, struct dynlock_handle *lh);
999 void iam_container_write_lock(struct iam_container *c);
1000 void iam_container_write_unlock(struct iam_container *c);
1002 void iam_container_read_lock(struct iam_container *c);
1003 void iam_container_read_unlock(struct iam_container *c);
1005 int iam_index_next(struct iam_container *c, struct iam_path *p);
1006 int iam_read_leaf(struct iam_path *p);
1008 int iam_node_read(struct iam_container *c, iam_ptr_t ptr,
1009 handle_t *handle, struct buffer_head **bh);
1010 int iam_lvar_create(struct inode *obj,
1011 int keysize, int ptrsize, int recsize, handle_t *handle);
1014 #define swap(x, y) do { typeof(x) z = x; x = y; y = z; } while (0)
1018 #define dxtrace(command) command
1020 #define dxtrace(command)
1023 #define BH_DXLock (BH_BITMAP_UPTODATE + 1)
1024 #define DX_DEBUG (0)
1026 static struct iam_lock_stats {
1027 unsigned dls_bh_lock;
1028 unsigned dls_bh_busy;
1029 unsigned dls_bh_again;
1030 unsigned dls_bh_full_again;
1031 } iam_lock_stats = { 0, };
1032 #define DX_DEVAL(x) x
1037 static inline void iam_lock_bh(struct buffer_head volatile *bh)
1039 DX_DEVAL(iam_lock_stats.dls_bh_lock++);
1041 while (test_and_set_bit(BH_DXLock, &bh->b_state)) {
1042 DX_DEVAL(iam_lock_stats.dls_bh_busy++);
1043 while (test_bit(BH_DXLock, &bh->b_state))
1049 static inline void iam_unlock_bh(struct buffer_head *bh)
1052 smp_mb__before_clear_bit();
1053 clear_bit(BH_DXLock, &bh->b_state);
1058 void iam_insert_key(struct iam_path *path, struct iam_frame *frame,
1059 const struct iam_ikey *key, iam_ptr_t ptr);
1061 void iam_insert_key_lock(struct iam_path *path, struct iam_frame *frame,
1062 const struct iam_ikey *key, iam_ptr_t ptr);
1065 int iam_leaf_at_end(const struct iam_leaf *l);
1066 void iam_leaf_next(struct iam_leaf *folio);
1067 int iam_leaf_can_add(const struct iam_leaf *l,
1068 const struct iam_key *k, const struct iam_rec *r);
1070 struct iam_path *iam_leaf_path(const struct iam_leaf *leaf);
1071 struct iam_container *iam_leaf_container(const struct iam_leaf *leaf);
1072 struct iam_descr *iam_leaf_descr(const struct iam_leaf *leaf);
1073 struct iam_leaf_operations *iam_leaf_ops(const struct iam_leaf *leaf);
1076 int iam_node_read(struct iam_container *c, iam_ptr_t ptr,
1077 handle_t *h, struct buffer_head **bh);
1084 * Method called to recognize container format. Should return true iff
1085 * container @c conforms to this format. This method may do IO to read
1088 * If container is recognized, this method sets operation vectors
1089 * ->id_ops and ->id_leaf_ops in container description (c->ic_descr),
1090 * and fills other description fields.
1092 int (*if_guess)(struct iam_container *c);
1094 * Linkage into global list of container formats.
1096 struct list_head if_linkage;
1099 void iam_format_register(struct iam_format *fmt);
1100 int iam_root_limit(int rootgap, int blocksize, int size);
1102 void iam_lfix_format_init(void);
1103 void iam_lvar_format_init(void);
1104 void iam_htree_format_init(void);
1106 int iam_lfix_create(struct inode *obj,
1107 int keysize, int ptrsize, int recsize, handle_t *handle);
1108 struct iam_private_info;
1110 void ldiskfs_iam_release(struct file *filp, struct inode *inode);
1112 int iam_uapi_ioctl(struct inode * inode, struct file * filp, unsigned int cmd,
1116 #if LDISKFS_INVARIANT_ON
1117 extern int ldiskfs_check_dir_entry(const char *, struct inode *,
1118 struct ldiskfs_dir_entry_2 *,
1119 struct buffer_head *, unsigned long);
1121 static inline int ldiskfs_check_dir_entry(const char * function,
1123 struct ldiskfs_dir_entry_2 * de,
1124 struct buffer_head * bh,
1125 unsigned long offset)
1135 * User level API. Copy exists in lustre/lustre/tests/iam_ut.c
1138 struct iam_uapi_info {
1143 char iui_fmt_name[DX_FMT_NAME_LEN];
1146 struct iam_uapi_op {
1151 struct iam_uapi_it {
1152 struct iam_uapi_op iui_op;
1156 enum iam_ioctl_cmd {
1157 IAM_IOC_INIT = _IOW('i', 1, struct iam_uapi_info),
1158 IAM_IOC_GETINFO = _IOR('i', 2, struct iam_uapi_info),
1159 IAM_IOC_INSERT = _IOR('i', 3, struct iam_uapi_op),
1160 IAM_IOC_LOOKUP = _IOWR('i', 4, struct iam_uapi_op),
1161 IAM_IOC_DELETE = _IOR('i', 5, struct iam_uapi_op),
1162 IAM_IOC_IT_START = _IOR('i', 6, struct iam_uapi_it),
1163 IAM_IOC_IT_NEXT = _IOW('i', 7, struct iam_uapi_it),
1164 IAM_IOC_IT_STOP = _IOR('i', 8, struct iam_uapi_it),
1166 IAM_IOC_POLYMORPH = _IOR('i', 9, unsigned long)
1169 /* __LINUX_LUSTRE_IAM_H__ */