Btrfs: cleanup xattr code
[linux-2.6] / fs / btrfs / dir-item.c
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18
19 #include "ctree.h"
20 #include "disk-io.h"
21 #include "hash.h"
22 #include "transaction.h"
23
24 /*
25  * insert a name into a directory, doing overflow properly if there is a hash
26  * collision.  data_size indicates how big the item inserted should be.  On
27  * success a struct btrfs_dir_item pointer is returned, otherwise it is
28  * an ERR_PTR.
29  *
30  * The name is not copied into the dir item, you have to do that yourself.
31  */
32 static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
33                                                    *trans,
34                                                    struct btrfs_root *root,
35                                                    struct btrfs_path *path,
36                                                    struct btrfs_key *cpu_key,
37                                                    u32 data_size,
38                                                    const char *name,
39                                                    int name_len)
40 {
41         int ret;
42         char *ptr;
43         struct btrfs_item *item;
44         struct extent_buffer *leaf;
45
46         ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
47         if (ret == -EEXIST) {
48                 struct btrfs_dir_item *di;
49                 di = btrfs_match_dir_item_name(root, path, name, name_len);
50                 if (di)
51                         return ERR_PTR(-EEXIST);
52                 ret = btrfs_extend_item(trans, root, path, data_size);
53                 WARN_ON(ret > 0);
54         }
55         if (ret < 0)
56                 return ERR_PTR(ret);
57         WARN_ON(ret > 0);
58         leaf = path->nodes[0];
59         item = btrfs_item_nr(leaf, path->slots[0]);
60         ptr = btrfs_item_ptr(leaf, path->slots[0], char);
61         BUG_ON(data_size > btrfs_item_size(leaf, item));
62         ptr += btrfs_item_size(leaf, item) - data_size;
63         return (struct btrfs_dir_item *)ptr;
64 }
65
66 /*
67  * xattrs work a lot like directories, this inserts an xattr item
68  * into the tree
69  */
70 int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
71                             struct btrfs_root *root, const char *name,
72                             u16 name_len, const void *data, u16 data_len,
73                             u64 dir)
74 {
75         int ret = 0;
76         struct btrfs_path *path;
77         struct btrfs_dir_item *dir_item;
78         unsigned long name_ptr, data_ptr;
79         struct btrfs_key key, location;
80         struct btrfs_disk_key disk_key;
81         struct extent_buffer *leaf;
82         u32 data_size;
83
84         key.objectid = dir;
85         btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
86         key.offset = btrfs_name_hash(name, name_len);
87         path = btrfs_alloc_path();
88         if (!path)
89                 return -ENOMEM;
90         if (name_len + data_len + sizeof(struct btrfs_dir_item) >
91             BTRFS_LEAF_DATA_SIZE(root) - sizeof(struct btrfs_item))
92                 return -ENOSPC;
93
94         data_size = sizeof(*dir_item) + name_len + data_len;
95         dir_item = insert_with_overflow(trans, root, path, &key, data_size,
96                                         name, name_len);
97         /*
98          * FIXME: at some point we should handle xattr's that are larger than
99          * what we can fit in our leaf.  We set location to NULL b/c we arent
100          * pointing at anything else, that will change if we store the xattr
101          * data in a separate inode.
102          */
103         BUG_ON(IS_ERR(dir_item));
104         memset(&location, 0, sizeof(location));
105
106         leaf = path->nodes[0];
107         btrfs_cpu_key_to_disk(&disk_key, &location);
108         btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
109         btrfs_set_dir_type(leaf, dir_item, BTRFS_FT_XATTR);
110         btrfs_set_dir_name_len(leaf, dir_item, name_len);
111         btrfs_set_dir_transid(leaf, dir_item, trans->transid);
112         btrfs_set_dir_data_len(leaf, dir_item, data_len);
113         name_ptr = (unsigned long)(dir_item + 1);
114         data_ptr = (unsigned long)((char *)name_ptr + name_len);
115
116         write_extent_buffer(leaf, name, name_ptr, name_len);
117         write_extent_buffer(leaf, data, data_ptr, data_len);
118         btrfs_mark_buffer_dirty(path->nodes[0]);
119
120         btrfs_free_path(path);
121         return ret;
122 }
123
124 /*
125  * insert a directory item in the tree, doing all the magic for
126  * both indexes. 'dir' indicates which objectid to insert it into,
127  * 'location' is the key to stuff into the directory item, 'type' is the
128  * type of the inode we're pointing to, and 'index' is the sequence number
129  * to use for the second index (if one is created).
130  */
131 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
132                           *root, const char *name, int name_len, u64 dir,
133                           struct btrfs_key *location, u8 type, u64 index)
134 {
135         int ret = 0;
136         int ret2 = 0;
137         struct btrfs_path *path;
138         struct btrfs_dir_item *dir_item;
139         struct extent_buffer *leaf;
140         unsigned long name_ptr;
141         struct btrfs_key key;
142         struct btrfs_disk_key disk_key;
143         u32 data_size;
144
145         key.objectid = dir;
146         btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
147         key.offset = btrfs_name_hash(name, name_len);
148         path = btrfs_alloc_path();
149         data_size = sizeof(*dir_item) + name_len;
150         dir_item = insert_with_overflow(trans, root, path, &key, data_size,
151                                         name, name_len);
152         if (IS_ERR(dir_item)) {
153                 ret = PTR_ERR(dir_item);
154                 if (ret == -EEXIST)
155                         goto second_insert;
156                 goto out;
157         }
158
159         leaf = path->nodes[0];
160         btrfs_cpu_key_to_disk(&disk_key, location);
161         btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
162         btrfs_set_dir_type(leaf, dir_item, type);
163         btrfs_set_dir_data_len(leaf, dir_item, 0);
164         btrfs_set_dir_name_len(leaf, dir_item, name_len);
165         btrfs_set_dir_transid(leaf, dir_item, trans->transid);
166         name_ptr = (unsigned long)(dir_item + 1);
167
168         write_extent_buffer(leaf, name, name_ptr, name_len);
169         btrfs_mark_buffer_dirty(leaf);
170
171 second_insert:
172         /* FIXME, use some real flag for selecting the extra index */
173         if (root == root->fs_info->tree_root) {
174                 ret = 0;
175                 goto out;
176         }
177         btrfs_release_path(root, path);
178
179         btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
180         key.offset = index;
181         dir_item = insert_with_overflow(trans, root, path, &key, data_size,
182                                         name, name_len);
183         if (IS_ERR(dir_item)) {
184                 ret2 = PTR_ERR(dir_item);
185                 goto out;
186         }
187         leaf = path->nodes[0];
188         btrfs_cpu_key_to_disk(&disk_key, location);
189         btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
190         btrfs_set_dir_type(leaf, dir_item, type);
191         btrfs_set_dir_data_len(leaf, dir_item, 0);
192         btrfs_set_dir_name_len(leaf, dir_item, name_len);
193         btrfs_set_dir_transid(leaf, dir_item, trans->transid);
194         name_ptr = (unsigned long)(dir_item + 1);
195         write_extent_buffer(leaf, name, name_ptr, name_len);
196         btrfs_mark_buffer_dirty(leaf);
197 out:
198         btrfs_free_path(path);
199         if (ret)
200                 return ret;
201         if (ret2)
202                 return ret2;
203         return 0;
204 }
205
206 /*
207  * lookup a directory item based on name.  'dir' is the objectid
208  * we're searching in, and 'mod' tells us if you plan on deleting the
209  * item (use mod < 0) or changing the options (use mod > 0)
210  */
211 struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
212                                              struct btrfs_root *root,
213                                              struct btrfs_path *path, u64 dir,
214                                              const char *name, int name_len,
215                                              int mod)
216 {
217         int ret;
218         struct btrfs_key key;
219         int ins_len = mod < 0 ? -1 : 0;
220         int cow = mod != 0;
221         struct btrfs_key found_key;
222         struct extent_buffer *leaf;
223
224         key.objectid = dir;
225         btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
226
227         key.offset = btrfs_name_hash(name, name_len);
228
229         ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
230         if (ret < 0)
231                 return ERR_PTR(ret);
232         if (ret > 0) {
233                 if (path->slots[0] == 0)
234                         return NULL;
235                 path->slots[0]--;
236         }
237
238         leaf = path->nodes[0];
239         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
240
241         if (found_key.objectid != dir ||
242             btrfs_key_type(&found_key) != BTRFS_DIR_ITEM_KEY ||
243             found_key.offset != key.offset)
244                 return NULL;
245
246         return btrfs_match_dir_item_name(root, path, name, name_len);
247 }
248
249 /*
250  * lookup a directory item based on index.  'dir' is the objectid
251  * we're searching in, and 'mod' tells us if you plan on deleting the
252  * item (use mod < 0) or changing the options (use mod > 0)
253  *
254  * The name is used to make sure the index really points to the name you were
255  * looking for.
256  */
257 struct btrfs_dir_item *
258 btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
259                             struct btrfs_root *root,
260                             struct btrfs_path *path, u64 dir,
261                             u64 objectid, const char *name, int name_len,
262                             int mod)
263 {
264         int ret;
265         struct btrfs_key key;
266         int ins_len = mod < 0 ? -1 : 0;
267         int cow = mod != 0;
268
269         key.objectid = dir;
270         btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
271         key.offset = objectid;
272
273         ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
274         if (ret < 0)
275                 return ERR_PTR(ret);
276         if (ret > 0)
277                 return ERR_PTR(-ENOENT);
278         return btrfs_match_dir_item_name(root, path, name, name_len);
279 }
280
281 struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
282                                           struct btrfs_root *root,
283                                           struct btrfs_path *path, u64 dir,
284                                           const char *name, u16 name_len,
285                                           int mod)
286 {
287         int ret;
288         struct btrfs_key key;
289         int ins_len = mod < 0 ? -1 : 0;
290         int cow = mod != 0;
291         struct btrfs_key found_key;
292         struct extent_buffer *leaf;
293
294         key.objectid = dir;
295         btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
296         key.offset = btrfs_name_hash(name, name_len);
297         ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
298         if (ret < 0)
299                 return ERR_PTR(ret);
300         if (ret > 0) {
301                 if (path->slots[0] == 0)
302                         return NULL;
303                 path->slots[0]--;
304         }
305
306         leaf = path->nodes[0];
307         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
308
309         if (found_key.objectid != dir ||
310             btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY ||
311             found_key.offset != key.offset)
312                 return NULL;
313
314         return btrfs_match_dir_item_name(root, path, name, name_len);
315 }
316
317 /*
318  * helper function to look at the directory item pointed to by 'path'
319  * this walks through all the entries in a dir item and finds one
320  * for a specific name.
321  */
322 struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
323                               struct btrfs_path *path,
324                               const char *name, int name_len)
325 {
326         struct btrfs_dir_item *dir_item;
327         unsigned long name_ptr;
328         u32 total_len;
329         u32 cur = 0;
330         u32 this_len;
331         struct extent_buffer *leaf;
332
333         leaf = path->nodes[0];
334         dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
335         total_len = btrfs_item_size_nr(leaf, path->slots[0]);
336         while (cur < total_len) {
337                 this_len = sizeof(*dir_item) +
338                         btrfs_dir_name_len(leaf, dir_item) +
339                         btrfs_dir_data_len(leaf, dir_item);
340                 name_ptr = (unsigned long)(dir_item + 1);
341
342                 if (btrfs_dir_name_len(leaf, dir_item) == name_len &&
343                     memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)
344                         return dir_item;
345
346                 cur += this_len;
347                 dir_item = (struct btrfs_dir_item *)((char *)dir_item +
348                                                      this_len);
349         }
350         return NULL;
351 }
352
353 /*
354  * given a pointer into a directory item, delete it.  This
355  * handles items that have more than one entry in them.
356  */
357 int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
358                               struct btrfs_root *root,
359                               struct btrfs_path *path,
360                               struct btrfs_dir_item *di)
361 {
362
363         struct extent_buffer *leaf;
364         u32 sub_item_len;
365         u32 item_len;
366         int ret = 0;
367
368         leaf = path->nodes[0];
369         sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) +
370                 btrfs_dir_data_len(leaf, di);
371         item_len = btrfs_item_size_nr(leaf, path->slots[0]);
372         if (sub_item_len == item_len) {
373                 ret = btrfs_del_item(trans, root, path);
374         } else {
375                 /* MARKER */
376                 unsigned long ptr = (unsigned long)di;
377                 unsigned long start;
378
379                 start = btrfs_item_ptr_offset(leaf, path->slots[0]);
380                 memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
381                         item_len - (ptr + sub_item_len - start));
382                 ret = btrfs_truncate_item(trans, root, path,
383                                           item_len - sub_item_len, 1);
384         }
385         return 0;
386 }