btrfs-progs: image: remove unused argument from copy_log_trees
[platform/upstream/btrfs-progs.git] / file-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 <stdio.h>
20 #include <stdlib.h>
21 #include "kerncompat.h"
22 #include "radix-tree.h"
23 #include "ctree.h"
24 #include "disk-io.h"
25 #include "transaction.h"
26 #include "print-tree.h"
27 #include "crc32c.h"
28 #include "internal.h"
29
30 #define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
31                                sizeof(struct btrfs_item) * 2) / \
32                                size) - 1))
33 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
34                              struct btrfs_root *root,
35                              u64 objectid, u64 pos, u64 offset,
36                              u64 disk_num_bytes, u64 num_bytes)
37 {
38         int ret = 0;
39         int is_hole = 0;
40         struct btrfs_file_extent_item *item;
41         struct btrfs_key file_key;
42         struct btrfs_path *path;
43         struct extent_buffer *leaf;
44
45         if (offset == 0)
46                 is_hole = 1;
47         /* For NO_HOLES, we don't insert hole file extent */
48         if (btrfs_fs_incompat(root->fs_info, NO_HOLES) && is_hole)
49                 return 0;
50
51         /* For hole, its disk_bytenr and disk_num_bytes must be 0 */
52         if (is_hole)
53                 disk_num_bytes = 0;
54
55         path = btrfs_alloc_path();
56         if (!path)
57                 return -ENOMEM;
58
59         file_key.objectid = objectid;
60         file_key.offset = pos;
61         file_key.type = BTRFS_EXTENT_DATA_KEY;
62
63         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
64                                       sizeof(*item));
65         if (ret < 0)
66                 goto out;
67         BUG_ON(ret);
68         leaf = path->nodes[0];
69         item = btrfs_item_ptr(leaf, path->slots[0],
70                               struct btrfs_file_extent_item);
71         btrfs_set_file_extent_disk_bytenr(leaf, item, offset);
72         btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
73         btrfs_set_file_extent_offset(leaf, item, 0);
74         btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
75         btrfs_set_file_extent_ram_bytes(leaf, item, num_bytes);
76         btrfs_set_file_extent_generation(leaf, item, trans->transid);
77         btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
78         btrfs_set_file_extent_compression(leaf, item, 0);
79         btrfs_set_file_extent_encryption(leaf, item, 0);
80         btrfs_set_file_extent_other_encoding(leaf, item, 0);
81         btrfs_mark_buffer_dirty(leaf);
82 out:
83         btrfs_free_path(path);
84         return ret;
85 }
86
87 int btrfs_insert_inline_extent(struct btrfs_trans_handle *trans,
88                                struct btrfs_root *root, u64 objectid,
89                                u64 offset, char *buffer, size_t size)
90 {
91         struct btrfs_key key;
92         struct btrfs_path *path;
93         struct extent_buffer *leaf;
94         unsigned long ptr;
95         struct btrfs_file_extent_item *ei;
96         u32 datasize;
97         int err = 0;
98         int ret;
99
100         path = btrfs_alloc_path();
101         if (!path)
102                 return -ENOMEM;
103
104         key.objectid = objectid;
105         key.offset = offset;
106         key.type = BTRFS_EXTENT_DATA_KEY;
107
108         datasize = btrfs_file_extent_calc_inline_size(size);
109         ret = btrfs_insert_empty_item(trans, root, path, &key, datasize);
110         if (ret) {
111                 err = ret;
112                 goto fail;
113         }
114
115         leaf = path->nodes[0];
116         ei = btrfs_item_ptr(leaf, path->slots[0],
117                             struct btrfs_file_extent_item);
118         btrfs_set_file_extent_generation(leaf, ei, trans->transid);
119         btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
120         btrfs_set_file_extent_ram_bytes(leaf, ei, size);
121         btrfs_set_file_extent_compression(leaf, ei, 0);
122         btrfs_set_file_extent_encryption(leaf, ei, 0);
123         btrfs_set_file_extent_other_encoding(leaf, ei, 0);
124
125         ptr = btrfs_file_extent_inline_start(ei) + offset - key.offset;
126         write_extent_buffer(leaf, buffer, ptr, size);
127         btrfs_mark_buffer_dirty(leaf);
128 fail:
129         btrfs_free_path(path);
130         return err;
131 }
132
133 static struct btrfs_csum_item *
134 btrfs_lookup_csum(struct btrfs_trans_handle *trans,
135                   struct btrfs_root *root,
136                   struct btrfs_path *path,
137                   u64 bytenr, int cow)
138 {
139         int ret;
140         struct btrfs_key file_key;
141         struct btrfs_key found_key;
142         struct btrfs_csum_item *item;
143         struct extent_buffer *leaf;
144         u64 csum_offset = 0;
145         u16 csum_size =
146                 btrfs_super_csum_size(root->fs_info->super_copy);
147         int csums_in_item;
148
149         file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
150         file_key.offset = bytenr;
151         file_key.type = BTRFS_EXTENT_CSUM_KEY;
152         ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
153         if (ret < 0)
154                 goto fail;
155         leaf = path->nodes[0];
156         if (ret > 0) {
157                 ret = 1;
158                 if (path->slots[0] == 0)
159                         goto fail;
160                 path->slots[0]--;
161                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
162                 if (found_key.type != BTRFS_EXTENT_CSUM_KEY)
163                         goto fail;
164
165                 csum_offset = (bytenr - found_key.offset) / root->sectorsize;
166                 csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
167                 csums_in_item /= csum_size;
168
169                 if (csum_offset >= csums_in_item) {
170                         ret = -EFBIG;
171                         goto fail;
172                 }
173         }
174         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
175         item = (struct btrfs_csum_item *)((unsigned char *)item +
176                                           csum_offset * csum_size);
177         return item;
178 fail:
179         if (ret > 0)
180                 ret = -ENOENT;
181         return ERR_PTR(ret);
182 }
183
184 int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
185                           struct btrfs_root *root, u64 alloc_end,
186                           u64 bytenr, char *data, size_t len)
187 {
188         int ret = 0;
189         struct btrfs_key file_key;
190         struct btrfs_key found_key;
191         u64 next_offset = (u64)-1;
192         int found_next = 0;
193         struct btrfs_path *path;
194         struct btrfs_csum_item *item;
195         struct extent_buffer *leaf = NULL;
196         u64 csum_offset;
197         u32 csum_result = ~(u32)0;
198         u32 nritems;
199         u32 ins_size;
200         u16 csum_size =
201                 btrfs_super_csum_size(root->fs_info->super_copy);
202
203         path = btrfs_alloc_path();
204         if (!path)
205                 return -ENOMEM;
206
207         file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
208         file_key.offset = bytenr;
209         file_key.type = BTRFS_EXTENT_CSUM_KEY;
210
211         item = btrfs_lookup_csum(trans, root, path, bytenr, 1);
212         if (!IS_ERR(item)) {
213                 leaf = path->nodes[0];
214                 ret = 0;
215                 goto found;
216         }
217         ret = PTR_ERR(item);
218         if (ret == -EFBIG) {
219                 u32 item_size;
220                 /* we found one, but it isn't big enough yet */
221                 leaf = path->nodes[0];
222                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
223                 if ((item_size / csum_size) >= MAX_CSUM_ITEMS(root, csum_size)) {
224                         /* already at max size, make a new one */
225                         goto insert;
226                 }
227         } else {
228                 int slot = path->slots[0] + 1;
229                 /* we didn't find a csum item, insert one */
230                 nritems = btrfs_header_nritems(path->nodes[0]);
231                 if (path->slots[0] >= nritems - 1) {
232                         ret = btrfs_next_leaf(root, path);
233                         if (ret == 1)
234                                 found_next = 1;
235                         if (ret != 0)
236                                 goto insert;
237                         slot = 0;
238                 }
239                 btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
240                 if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
241                     found_key.type != BTRFS_EXTENT_CSUM_KEY) {
242                         found_next = 1;
243                         goto insert;
244                 }
245                 next_offset = found_key.offset;
246                 found_next = 1;
247                 goto insert;
248         }
249
250         /*
251          * at this point, we know the tree has an item, but it isn't big
252          * enough yet to put our csum in.  Grow it
253          */
254         btrfs_release_path(path);
255         ret = btrfs_search_slot(trans, root, &file_key, path,
256                                 csum_size, 1);
257         if (ret < 0)
258                 goto fail;
259         if (ret == 0) {
260                 BUG();
261         }
262         if (path->slots[0] == 0) {
263                 goto insert;
264         }
265         path->slots[0]--;
266         leaf = path->nodes[0];
267         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
268         csum_offset = (file_key.offset - found_key.offset) / root->sectorsize;
269         if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
270             found_key.type != BTRFS_EXTENT_CSUM_KEY ||
271             csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) {
272                 goto insert;
273         }
274         if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
275             csum_size) {
276                 u32 diff = (csum_offset + 1) * csum_size;
277                 diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
278                 if (diff != csum_size)
279                         goto insert;
280                 ret = btrfs_extend_item(root, path, diff);
281                 BUG_ON(ret);
282                 goto csum;
283         }
284
285 insert:
286         btrfs_release_path(path);
287         csum_offset = 0;
288         if (found_next) {
289                 u64 tmp = min(alloc_end, next_offset);
290                 tmp -= file_key.offset;
291                 tmp /= root->sectorsize;
292                 tmp = max((u64)1, tmp);
293                 tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size));
294                 ins_size = csum_size * tmp;
295         } else {
296                 ins_size = csum_size;
297         }
298         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
299                                       ins_size);
300         if (ret < 0)
301                 goto fail;
302         if (ret != 0) {
303                 WARN_ON(1);
304                 goto fail;
305         }
306 csum:
307         leaf = path->nodes[0];
308         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
309         ret = 0;
310         item = (struct btrfs_csum_item *)((unsigned char *)item +
311                                           csum_offset * csum_size);
312 found:
313         csum_result = btrfs_csum_data(data, csum_result, len);
314         btrfs_csum_final(csum_result, (u8 *)&csum_result);
315         if (csum_result == 0) {
316                 printk("csum result is 0 for block %llu\n",
317                        (unsigned long long)bytenr);
318         }
319
320         write_extent_buffer(leaf, &csum_result, (unsigned long)item,
321                             csum_size);
322         btrfs_mark_buffer_dirty(path->nodes[0]);
323 fail:
324         btrfs_free_path(path);
325         return ret;
326 }
327
328 /*
329  * helper function for csum removal, this expects the
330  * key to describe the csum pointed to by the path, and it expects
331  * the csum to overlap the range [bytenr, len]
332  *
333  * The csum should not be entirely contained in the range and the
334  * range should not be entirely contained in the csum.
335  *
336  * This calls btrfs_truncate_item with the correct args based on the
337  * overlap, and fixes up the key as required.
338  */
339 static noinline int truncate_one_csum(struct btrfs_root *root,
340                                       struct btrfs_path *path,
341                                       struct btrfs_key *key,
342                                       u64 bytenr, u64 len)
343 {
344         struct extent_buffer *leaf;
345         u16 csum_size =
346                 btrfs_super_csum_size(root->fs_info->super_copy);
347         u64 csum_end;
348         u64 end_byte = bytenr + len;
349         u32 blocksize = root->sectorsize;
350         int ret;
351
352         leaf = path->nodes[0];
353         csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
354         csum_end *= root->sectorsize;
355         csum_end += key->offset;
356
357         if (key->offset < bytenr && csum_end <= end_byte) {
358                 /*
359                  *         [ bytenr - len ]
360                  *         [   ]
361                  *   [csum     ]
362                  *   A simple truncate off the end of the item
363                  */
364                 u32 new_size = (bytenr - key->offset) / blocksize;
365                 new_size *= csum_size;
366                 ret = btrfs_truncate_item(root, path, new_size, 1);
367                 BUG_ON(ret);
368         } else if (key->offset >= bytenr && csum_end > end_byte &&
369                    end_byte > key->offset) {
370                 /*
371                  *         [ bytenr - len ]
372                  *                 [ ]
373                  *                 [csum     ]
374                  * we need to truncate from the beginning of the csum
375                  */
376                 u32 new_size = (csum_end - end_byte) / blocksize;
377                 new_size *= csum_size;
378
379                 ret = btrfs_truncate_item(root, path, new_size, 0);
380                 BUG_ON(ret);
381
382                 key->offset = end_byte;
383                 ret = btrfs_set_item_key_safe(root, path, key);
384                 BUG_ON(ret);
385         } else {
386                 BUG();
387         }
388         return 0;
389 }
390
391 /*
392  * deletes the csum items from the csum tree for a given
393  * range of bytes.
394  */
395 int btrfs_del_csums(struct btrfs_trans_handle *trans,
396                     struct btrfs_root *root, u64 bytenr, u64 len)
397 {
398         struct btrfs_path *path;
399         struct btrfs_key key;
400         u64 end_byte = bytenr + len;
401         u64 csum_end;
402         struct extent_buffer *leaf;
403         int ret;
404         u16 csum_size =
405                 btrfs_super_csum_size(root->fs_info->super_copy);
406         int blocksize = root->sectorsize;
407
408         root = root->fs_info->csum_root;
409
410         path = btrfs_alloc_path();
411         if (!path)
412                 return -ENOMEM;
413
414         while (1) {
415                 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
416                 key.offset = end_byte - 1;
417                 key.type = BTRFS_EXTENT_CSUM_KEY;
418
419                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
420                 if (ret > 0) {
421                         if (path->slots[0] == 0)
422                                 goto out;
423                         path->slots[0]--;
424                 }
425                 leaf = path->nodes[0];
426                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
427
428                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
429                     key.type != BTRFS_EXTENT_CSUM_KEY) {
430                         break;
431                 }
432
433                 if (key.offset >= end_byte)
434                         break;
435
436                 csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
437                 csum_end *= blocksize;
438                 csum_end += key.offset;
439
440                 /* this csum ends before we start, we're done */
441                 if (csum_end <= bytenr)
442                         break;
443
444                 /* delete the entire item, it is inside our range */
445                 if (key.offset >= bytenr && csum_end <= end_byte) {
446                         ret = btrfs_del_item(trans, root, path);
447                         BUG_ON(ret);
448                 } else if (key.offset < bytenr && csum_end > end_byte) {
449                         unsigned long offset;
450                         unsigned long shift_len;
451                         unsigned long item_offset;
452                         /*
453                          *        [ bytenr - len ]
454                          *     [csum                ]
455                          *
456                          * Our bytes are in the middle of the csum,
457                          * we need to split this item and insert a new one.
458                          *
459                          * But we can't drop the path because the
460                          * csum could change, get removed, extended etc.
461                          *
462                          * The trick here is the max size of a csum item leaves
463                          * enough room in the tree block for a single
464                          * item header.  So, we split the item in place,
465                          * adding a new header pointing to the existing
466                          * bytes.  Then we loop around again and we have
467                          * a nicely formed csum item that we can neatly
468                          * truncate.
469                          */
470                         offset = (bytenr - key.offset) / blocksize;
471                         offset *= csum_size;
472
473                         shift_len = (len / blocksize) * csum_size;
474
475                         item_offset = btrfs_item_ptr_offset(leaf,
476                                                             path->slots[0]);
477
478                         memset_extent_buffer(leaf, 0, item_offset + offset,
479                                              shift_len);
480                         key.offset = bytenr;
481
482                         /*
483                          * btrfs_split_item returns -EAGAIN when the
484                          * item changed size or key
485                          */
486                         ret = btrfs_split_item(trans, root, path, &key, offset);
487                         BUG_ON(ret && ret != -EAGAIN);
488
489                         key.offset = end_byte - 1;
490                 } else {
491                         ret = truncate_one_csum(root, path, &key, bytenr, len);
492                         BUG_ON(ret);
493                 }
494                 btrfs_release_path(path);
495         }
496 out:
497         btrfs_free_path(path);
498         return 0;
499 }