initial commit
[freebsd-arm:freebsd-arm.git] / cddl / contrib / opensolaris / uts / common / fs / zfs / sys / zap_leaf.h
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25
26 #ifndef _SYS_ZAP_LEAF_H
27 #define _SYS_ZAP_LEAF_H
28
29 #pragma ident   "%Z%%M% %I%     %E% SMI"
30
31 #ifdef  __cplusplus
32 extern "C" {
33 #endif
34
35 struct zap;
36
37 #define ZAP_LEAF_MAGIC 0x2AB1EAF
38
39 /* chunk size = 24 bytes */
40 #define ZAP_LEAF_CHUNKSIZE 24
41
42 /*
43  * The amount of space available for chunks is:
44  * block size (1<<l->l_bs) - hash entry size (2) * number of hash
45  * entries - header space (2*chunksize)
46  */
47 #define ZAP_LEAF_NUMCHUNKS(l) \
48         (((1<<(l)->l_bs) - 2*ZAP_LEAF_HASH_NUMENTRIES(l)) / \
49         ZAP_LEAF_CHUNKSIZE - 2)
50
51 /*
52  * The amount of space within the chunk available for the array is:
53  * chunk size - space for type (1) - space for next pointer (2)
54  */
55 #define ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3)
56
57 #define ZAP_LEAF_ARRAY_NCHUNKS(bytes) \
58         (((bytes)+ZAP_LEAF_ARRAY_BYTES-1)/ZAP_LEAF_ARRAY_BYTES)
59
60 /*
61  * Low water mark:  when there are only this many chunks free, start
62  * growing the ptrtbl.  Ideally, this should be larger than a
63  * "reasonably-sized" entry.  20 chunks is more than enough for the
64  * largest directory entry (MAXNAMELEN (256) byte name, 8-byte value),
65  * while still being only around 3% for 16k blocks.
66  */
67 #define ZAP_LEAF_LOW_WATER (20)
68
69 /*
70  * The leaf hash table has block size / 2^5 (32) number of entries,
71  * which should be more than enough for the maximum number of entries,
72  * which is less than block size / CHUNKSIZE (24) / minimum number of
73  * chunks per entry (3).
74  */
75 #define ZAP_LEAF_HASH_SHIFT(l) ((l)->l_bs - 5)
76 #define ZAP_LEAF_HASH_NUMENTRIES(l) (1 << ZAP_LEAF_HASH_SHIFT(l))
77
78 /*
79  * The chunks start immediately after the hash table.  The end of the
80  * hash table is at l_hash + HASH_NUMENTRIES, which we simply cast to a
81  * chunk_t.
82  */
83 #define ZAP_LEAF_CHUNK(l, idx) \
84         ((zap_leaf_chunk_t *) \
85         ((l)->l_phys->l_hash + ZAP_LEAF_HASH_NUMENTRIES(l)))[idx]
86 #define ZAP_LEAF_ENTRY(l, idx) (&ZAP_LEAF_CHUNK(l, idx).l_entry)
87
88 typedef enum zap_chunk_type {
89         ZAP_CHUNK_FREE = 253,
90         ZAP_CHUNK_ENTRY = 252,
91         ZAP_CHUNK_ARRAY = 251,
92         ZAP_CHUNK_TYPE_MAX = 250
93 } zap_chunk_type_t;
94
95 #define ZLF_ENTRIES_CDSORTED (1<<0)
96
97 /*
98  * TAKE NOTE:
99  * If zap_leaf_phys_t is modified, zap_leaf_byteswap() must be modified.
100  */
101 typedef struct zap_leaf_phys {
102         struct zap_leaf_header {
103                 uint64_t lh_block_type;         /* ZBT_LEAF */
104                 uint64_t lh_pad1;
105                 uint64_t lh_prefix;             /* hash prefix of this leaf */
106                 uint32_t lh_magic;              /* ZAP_LEAF_MAGIC */
107                 uint16_t lh_nfree;              /* number free chunks */
108                 uint16_t lh_nentries;           /* number of entries */
109                 uint16_t lh_prefix_len;         /* num bits used to id this */
110
111 /* above is accessable to zap, below is zap_leaf private */
112
113                 uint16_t lh_freelist;           /* chunk head of free list */
114                 uint8_t lh_flags;               /* ZLF_* flags */
115                 uint8_t lh_pad2[11];
116         } l_hdr; /* 2 24-byte chunks */
117
118         /*
119          * The header is followed by a hash table with
120          * ZAP_LEAF_HASH_NUMENTRIES(zap) entries.  The hash table is
121          * followed by an array of ZAP_LEAF_NUMCHUNKS(zap)
122          * zap_leaf_chunk structures.  These structures are accessed
123          * with the ZAP_LEAF_CHUNK() macro.
124          */
125
126         uint16_t l_hash[1];
127 } zap_leaf_phys_t;
128
129 typedef union zap_leaf_chunk {
130         struct zap_leaf_entry {
131                 uint8_t le_type;                /* always ZAP_CHUNK_ENTRY */
132                 uint8_t le_int_size;            /* size of ints */
133                 uint16_t le_next;               /* next entry in hash chain */
134                 uint16_t le_name_chunk;         /* first chunk of the name */
135                 uint16_t le_name_length;        /* bytes in name, incl null */
136                 uint16_t le_value_chunk;        /* first chunk of the value */
137                 uint16_t le_value_length;       /* value length in ints */
138                 uint32_t le_cd;                 /* collision differentiator */
139                 uint64_t le_hash;               /* hash value of the name */
140         } l_entry;
141         struct zap_leaf_array {
142                 uint8_t la_type;                /* always ZAP_CHUNK_ARRAY */
143                 uint8_t la_array[ZAP_LEAF_ARRAY_BYTES];
144                 uint16_t la_next;               /* next blk or CHAIN_END */
145         } l_array;
146         struct zap_leaf_free {
147                 uint8_t lf_type;                /* always ZAP_CHUNK_FREE */
148                 uint8_t lf_pad[ZAP_LEAF_ARRAY_BYTES];
149                 uint16_t lf_next;       /* next in free list, or CHAIN_END */
150         } l_free;
151 } zap_leaf_chunk_t;
152
153 typedef struct zap_leaf {
154         krwlock_t l_rwlock;
155         uint64_t l_blkid;               /* 1<<ZAP_BLOCK_SHIFT byte block off */
156         int l_bs;                       /* block size shift */
157         dmu_buf_t *l_dbuf;
158         zap_leaf_phys_t *l_phys;
159 } zap_leaf_t;
160
161
162 typedef struct zap_entry_handle {
163         /* below is set by zap_leaf.c and is public to zap.c */
164         uint64_t zeh_num_integers;
165         uint64_t zeh_hash;
166         uint32_t zeh_cd;
167         uint8_t zeh_integer_size;
168
169         /* below is private to zap_leaf.c */
170         uint16_t zeh_fakechunk;
171         uint16_t *zeh_chunkp;
172         zap_leaf_t *zeh_leaf;
173 } zap_entry_handle_t;
174
175 /*
176  * Return a handle to the named entry, or ENOENT if not found.  The hash
177  * value must equal zap_hash(name).
178  */
179 extern int zap_leaf_lookup(zap_leaf_t *l,
180     zap_name_t *zn, zap_entry_handle_t *zeh);
181
182 /*
183  * Return a handle to the entry with this hash+cd, or the entry with the
184  * next closest hash+cd.
185  */
186 extern int zap_leaf_lookup_closest(zap_leaf_t *l,
187     uint64_t hash, uint32_t cd, zap_entry_handle_t *zeh);
188
189 /*
190  * Read the first num_integers in the attribute.  Integer size
191  * conversion will be done without sign extension.  Return EINVAL if
192  * integer_size is too small.  Return EOVERFLOW if there are more than
193  * num_integers in the attribute.
194  */
195 extern int zap_entry_read(const zap_entry_handle_t *zeh,
196         uint8_t integer_size, uint64_t num_integers, void *buf);
197
198 extern int zap_entry_read_name(const zap_entry_handle_t *zeh,
199         uint16_t buflen, char *buf);
200
201 /*
202  * Replace the value of an existing entry.
203  *
204  * zap_entry_update may fail if it runs out of space (ENOSPC).
205  */
206 extern int zap_entry_update(zap_entry_handle_t *zeh,
207         uint8_t integer_size, uint64_t num_integers, const void *buf);
208
209 /*
210  * Remove an entry.
211  */
212 extern void zap_entry_remove(zap_entry_handle_t *zeh);
213
214 /*
215  * Create an entry. An equal entry must not exist, and this entry must
216  * belong in this leaf (according to its hash value).  Fills in the
217  * entry handle on success.  Returns 0 on success or ENOSPC on failure.
218  */
219 extern int zap_entry_create(zap_leaf_t *l,
220         const char *name, uint64_t h, uint32_t cd,
221         uint8_t integer_size, uint64_t num_integers, const void *buf,
222         zap_entry_handle_t *zeh);
223
224 /*
225  * Return true if there are additional entries with the same normalized
226  * form.
227  */
228 extern boolean_t zap_entry_normalization_conflict(zap_entry_handle_t *zeh,
229     zap_name_t *zn, const char *name, zap_t *zap);
230
231 /*
232  * Other stuff.
233  */
234
235 extern void zap_leaf_init(zap_leaf_t *l, boolean_t sort);
236 extern void zap_leaf_byteswap(zap_leaf_phys_t *buf, int len);
237 extern void zap_leaf_split(zap_leaf_t *l, zap_leaf_t *nl, boolean_t sort);
238 extern void zap_leaf_stats(zap_t *zap, zap_leaf_t *l, zap_stats_t *zs);
239
240 #ifdef  __cplusplus
241 }
242 #endif
243
244 #endif /* _SYS_ZAP_LEAF_H */