Merge drm/drm-next into drm-intel-next-queued
[linux-2.6-microblaze.git] / fs / btrfs / inode-item.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2007 Oracle.  All rights reserved.
4  */
5
6 #include "ctree.h"
7 #include "disk-io.h"
8 #include "transaction.h"
9 #include "print-tree.h"
10
11 int btrfs_find_name_in_backref(struct extent_buffer *leaf, int slot,
12                                const char *name,
13                                int name_len, struct btrfs_inode_ref **ref_ret)
14 {
15         struct btrfs_inode_ref *ref;
16         unsigned long ptr;
17         unsigned long name_ptr;
18         u32 item_size;
19         u32 cur_offset = 0;
20         int len;
21
22         item_size = btrfs_item_size_nr(leaf, slot);
23         ptr = btrfs_item_ptr_offset(leaf, slot);
24         while (cur_offset < item_size) {
25                 ref = (struct btrfs_inode_ref *)(ptr + cur_offset);
26                 len = btrfs_inode_ref_name_len(leaf, ref);
27                 name_ptr = (unsigned long)(ref + 1);
28                 cur_offset += len + sizeof(*ref);
29                 if (len != name_len)
30                         continue;
31                 if (memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0) {
32                         if (ref_ret)
33                                 *ref_ret = ref;
34                         return 1;
35                 }
36         }
37         return 0;
38 }
39
40 int btrfs_find_name_in_ext_backref(struct extent_buffer *leaf, int slot,
41                                    u64 ref_objectid,
42                                    const char *name, int name_len,
43                                    struct btrfs_inode_extref **extref_ret)
44 {
45         struct btrfs_inode_extref *extref;
46         unsigned long ptr;
47         unsigned long name_ptr;
48         u32 item_size;
49         u32 cur_offset = 0;
50         int ref_name_len;
51
52         item_size = btrfs_item_size_nr(leaf, slot);
53         ptr = btrfs_item_ptr_offset(leaf, slot);
54
55         /*
56          * Search all extended backrefs in this item. We're only
57          * looking through any collisions so most of the time this is
58          * just going to compare against one buffer. If all is well,
59          * we'll return success and the inode ref object.
60          */
61         while (cur_offset < item_size) {
62                 extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
63                 name_ptr = (unsigned long)(&extref->name);
64                 ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
65
66                 if (ref_name_len == name_len &&
67                     btrfs_inode_extref_parent(leaf, extref) == ref_objectid &&
68                     (memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)) {
69                         if (extref_ret)
70                                 *extref_ret = extref;
71                         return 1;
72                 }
73
74                 cur_offset += ref_name_len + sizeof(*extref);
75         }
76         return 0;
77 }
78
79 /* Returns NULL if no extref found */
80 struct btrfs_inode_extref *
81 btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
82                           struct btrfs_root *root,
83                           struct btrfs_path *path,
84                           const char *name, int name_len,
85                           u64 inode_objectid, u64 ref_objectid, int ins_len,
86                           int cow)
87 {
88         int ret;
89         struct btrfs_key key;
90         struct btrfs_inode_extref *extref;
91
92         key.objectid = inode_objectid;
93         key.type = BTRFS_INODE_EXTREF_KEY;
94         key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
95
96         ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
97         if (ret < 0)
98                 return ERR_PTR(ret);
99         if (ret > 0)
100                 return NULL;
101         if (!btrfs_find_name_in_ext_backref(path->nodes[0], path->slots[0],
102                                             ref_objectid, name, name_len,
103                                             &extref))
104                 return NULL;
105         return extref;
106 }
107
108 static int btrfs_del_inode_extref(struct btrfs_trans_handle *trans,
109                                   struct btrfs_root *root,
110                                   const char *name, int name_len,
111                                   u64 inode_objectid, u64 ref_objectid,
112                                   u64 *index)
113 {
114         struct btrfs_path *path;
115         struct btrfs_key key;
116         struct btrfs_inode_extref *extref;
117         struct extent_buffer *leaf;
118         int ret;
119         int del_len = name_len + sizeof(*extref);
120         unsigned long ptr;
121         unsigned long item_start;
122         u32 item_size;
123
124         key.objectid = inode_objectid;
125         key.type = BTRFS_INODE_EXTREF_KEY;
126         key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
127
128         path = btrfs_alloc_path();
129         if (!path)
130                 return -ENOMEM;
131
132         path->leave_spinning = 1;
133
134         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
135         if (ret > 0)
136                 ret = -ENOENT;
137         if (ret < 0)
138                 goto out;
139
140         /*
141          * Sanity check - did we find the right item for this name?
142          * This should always succeed so error here will make the FS
143          * readonly.
144          */
145         if (!btrfs_find_name_in_ext_backref(path->nodes[0], path->slots[0],
146                                             ref_objectid,
147                                             name, name_len, &extref)) {
148                 btrfs_handle_fs_error(root->fs_info, -ENOENT, NULL);
149                 ret = -EROFS;
150                 goto out;
151         }
152
153         leaf = path->nodes[0];
154         item_size = btrfs_item_size_nr(leaf, path->slots[0]);
155         if (index)
156                 *index = btrfs_inode_extref_index(leaf, extref);
157
158         if (del_len == item_size) {
159                 /*
160                  * Common case only one ref in the item, remove the
161                  * whole item.
162                  */
163                 ret = btrfs_del_item(trans, root, path);
164                 goto out;
165         }
166
167         ptr = (unsigned long)extref;
168         item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
169
170         memmove_extent_buffer(leaf, ptr, ptr + del_len,
171                               item_size - (ptr + del_len - item_start));
172
173         btrfs_truncate_item(path, item_size - del_len, 1);
174
175 out:
176         btrfs_free_path(path);
177
178         return ret;
179 }
180
181 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
182                         struct btrfs_root *root,
183                         const char *name, int name_len,
184                         u64 inode_objectid, u64 ref_objectid, u64 *index)
185 {
186         struct btrfs_path *path;
187         struct btrfs_key key;
188         struct btrfs_inode_ref *ref;
189         struct extent_buffer *leaf;
190         unsigned long ptr;
191         unsigned long item_start;
192         u32 item_size;
193         u32 sub_item_len;
194         int ret;
195         int search_ext_refs = 0;
196         int del_len = name_len + sizeof(*ref);
197
198         key.objectid = inode_objectid;
199         key.offset = ref_objectid;
200         key.type = BTRFS_INODE_REF_KEY;
201
202         path = btrfs_alloc_path();
203         if (!path)
204                 return -ENOMEM;
205
206         path->leave_spinning = 1;
207
208         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
209         if (ret > 0) {
210                 ret = -ENOENT;
211                 search_ext_refs = 1;
212                 goto out;
213         } else if (ret < 0) {
214                 goto out;
215         }
216         if (!btrfs_find_name_in_backref(path->nodes[0], path->slots[0],
217                                         name, name_len, &ref)) {
218                 ret = -ENOENT;
219                 search_ext_refs = 1;
220                 goto out;
221         }
222         leaf = path->nodes[0];
223         item_size = btrfs_item_size_nr(leaf, path->slots[0]);
224
225         if (index)
226                 *index = btrfs_inode_ref_index(leaf, ref);
227
228         if (del_len == item_size) {
229                 ret = btrfs_del_item(trans, root, path);
230                 goto out;
231         }
232         ptr = (unsigned long)ref;
233         sub_item_len = name_len + sizeof(*ref);
234         item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
235         memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
236                               item_size - (ptr + sub_item_len - item_start));
237         btrfs_truncate_item(path, item_size - sub_item_len, 1);
238 out:
239         btrfs_free_path(path);
240
241         if (search_ext_refs) {
242                 /*
243                  * No refs were found, or we could not find the
244                  * name in our ref array. Find and remove the extended
245                  * inode ref then.
246                  */
247                 return btrfs_del_inode_extref(trans, root, name, name_len,
248                                               inode_objectid, ref_objectid, index);
249         }
250
251         return ret;
252 }
253
254 /*
255  * btrfs_insert_inode_extref() - Inserts an extended inode ref into a tree.
256  *
257  * The caller must have checked against BTRFS_LINK_MAX already.
258  */
259 static int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
260                                      struct btrfs_root *root,
261                                      const char *name, int name_len,
262                                      u64 inode_objectid, u64 ref_objectid, u64 index)
263 {
264         struct btrfs_inode_extref *extref;
265         int ret;
266         int ins_len = name_len + sizeof(*extref);
267         unsigned long ptr;
268         struct btrfs_path *path;
269         struct btrfs_key key;
270         struct extent_buffer *leaf;
271         struct btrfs_item *item;
272
273         key.objectid = inode_objectid;
274         key.type = BTRFS_INODE_EXTREF_KEY;
275         key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
276
277         path = btrfs_alloc_path();
278         if (!path)
279                 return -ENOMEM;
280
281         path->leave_spinning = 1;
282         ret = btrfs_insert_empty_item(trans, root, path, &key,
283                                       ins_len);
284         if (ret == -EEXIST) {
285                 if (btrfs_find_name_in_ext_backref(path->nodes[0],
286                                                    path->slots[0],
287                                                    ref_objectid,
288                                                    name, name_len, NULL))
289                         goto out;
290
291                 btrfs_extend_item(path, ins_len);
292                 ret = 0;
293         }
294         if (ret < 0)
295                 goto out;
296
297         leaf = path->nodes[0];
298         item = btrfs_item_nr(path->slots[0]);
299         ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
300         ptr += btrfs_item_size(leaf, item) - ins_len;
301         extref = (struct btrfs_inode_extref *)ptr;
302
303         btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len);
304         btrfs_set_inode_extref_index(path->nodes[0], extref, index);
305         btrfs_set_inode_extref_parent(path->nodes[0], extref, ref_objectid);
306
307         ptr = (unsigned long)&extref->name;
308         write_extent_buffer(path->nodes[0], name, ptr, name_len);
309         btrfs_mark_buffer_dirty(path->nodes[0]);
310
311 out:
312         btrfs_free_path(path);
313         return ret;
314 }
315
316 /* Will return 0, -ENOMEM, -EMLINK, or -EEXIST or anything from the CoW path */
317 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
318                            struct btrfs_root *root,
319                            const char *name, int name_len,
320                            u64 inode_objectid, u64 ref_objectid, u64 index)
321 {
322         struct btrfs_fs_info *fs_info = root->fs_info;
323         struct btrfs_path *path;
324         struct btrfs_key key;
325         struct btrfs_inode_ref *ref;
326         unsigned long ptr;
327         int ret;
328         int ins_len = name_len + sizeof(*ref);
329
330         key.objectid = inode_objectid;
331         key.offset = ref_objectid;
332         key.type = BTRFS_INODE_REF_KEY;
333
334         path = btrfs_alloc_path();
335         if (!path)
336                 return -ENOMEM;
337
338         path->leave_spinning = 1;
339         path->skip_release_on_error = 1;
340         ret = btrfs_insert_empty_item(trans, root, path, &key,
341                                       ins_len);
342         if (ret == -EEXIST) {
343                 u32 old_size;
344
345                 if (btrfs_find_name_in_backref(path->nodes[0], path->slots[0],
346                                                name, name_len, &ref))
347                         goto out;
348
349                 old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
350                 btrfs_extend_item(path, ins_len);
351                 ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
352                                      struct btrfs_inode_ref);
353                 ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size);
354                 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
355                 btrfs_set_inode_ref_index(path->nodes[0], ref, index);
356                 ptr = (unsigned long)(ref + 1);
357                 ret = 0;
358         } else if (ret < 0) {
359                 if (ret == -EOVERFLOW) {
360                         if (btrfs_find_name_in_backref(path->nodes[0],
361                                                        path->slots[0],
362                                                        name, name_len, &ref))
363                                 ret = -EEXIST;
364                         else
365                                 ret = -EMLINK;
366                 }
367                 goto out;
368         } else {
369                 ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
370                                      struct btrfs_inode_ref);
371                 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
372                 btrfs_set_inode_ref_index(path->nodes[0], ref, index);
373                 ptr = (unsigned long)(ref + 1);
374         }
375         write_extent_buffer(path->nodes[0], name, ptr, name_len);
376         btrfs_mark_buffer_dirty(path->nodes[0]);
377
378 out:
379         btrfs_free_path(path);
380
381         if (ret == -EMLINK) {
382                 struct btrfs_super_block *disk_super = fs_info->super_copy;
383                 /* We ran out of space in the ref array. Need to
384                  * add an extended ref. */
385                 if (btrfs_super_incompat_flags(disk_super)
386                     & BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
387                         ret = btrfs_insert_inode_extref(trans, root, name,
388                                                         name_len,
389                                                         inode_objectid,
390                                                         ref_objectid, index);
391         }
392
393         return ret;
394 }
395
396 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
397                              struct btrfs_root *root,
398                              struct btrfs_path *path, u64 objectid)
399 {
400         struct btrfs_key key;
401         int ret;
402         key.objectid = objectid;
403         key.type = BTRFS_INODE_ITEM_KEY;
404         key.offset = 0;
405
406         ret = btrfs_insert_empty_item(trans, root, path, &key,
407                                       sizeof(struct btrfs_inode_item));
408         return ret;
409 }
410
411 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
412                        *root, struct btrfs_path *path,
413                        struct btrfs_key *location, int mod)
414 {
415         int ins_len = mod < 0 ? -1 : 0;
416         int cow = mod != 0;
417         int ret;
418         int slot;
419         struct extent_buffer *leaf;
420         struct btrfs_key found_key;
421
422         ret = btrfs_search_slot(trans, root, location, path, ins_len, cow);
423         if (ret > 0 && location->type == BTRFS_ROOT_ITEM_KEY &&
424             location->offset == (u64)-1 && path->slots[0] != 0) {
425                 slot = path->slots[0] - 1;
426                 leaf = path->nodes[0];
427                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
428                 if (found_key.objectid == location->objectid &&
429                     found_key.type == location->type) {
430                         path->slots[0]--;
431                         return 0;
432                 }
433         }
434         return ret;
435 }