1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/kernel.h>
20#include <linux/bio.h>
21#include <linux/buffer_head.h>
22#include <linux/file.h>
23#include <linux/fs.h>
24#include <linux/pagemap.h>
25#include <linux/highmem.h>
26#include <linux/time.h>
27#include <linux/init.h>
28#include <linux/string.h>
29#include <linux/backing-dev.h>
30#include <linux/mpage.h>
31#include <linux/swap.h>
32#include <linux/writeback.h>
33#include <linux/statfs.h>
34#include <linux/compat.h>
35#include <linux/aio.h>
36#include <linux/bit_spinlock.h>
37#include <linux/xattr.h>
38#include <linux/posix_acl.h>
39#include <linux/falloc.h>
40#include <linux/slab.h>
41#include <linux/ratelimit.h>
42#include <linux/mount.h>
43#include <linux/btrfs.h>
44#include <linux/blkdev.h>
45#include "compat.h"
46#include "ctree.h"
47#include "disk-io.h"
48#include "transaction.h"
49#include "btrfs_inode.h"
50#include "print-tree.h"
51#include "ordered-data.h"
52#include "xattr.h"
53#include "tree-log.h"
54#include "volumes.h"
55#include "compression.h"
56#include "locking.h"
57#include "free-space-cache.h"
58#include "inode-map.h"
59#include "backref.h"
60
61struct btrfs_iget_args {
62 u64 ino;
63 struct btrfs_root *root;
64};
65
66static const struct inode_operations btrfs_dir_inode_operations;
67static const struct inode_operations btrfs_symlink_inode_operations;
68static const struct inode_operations btrfs_dir_ro_inode_operations;
69static const struct inode_operations btrfs_special_inode_operations;
70static const struct inode_operations btrfs_file_inode_operations;
71static const struct address_space_operations btrfs_aops;
72static const struct address_space_operations btrfs_symlink_aops;
73static const struct file_operations btrfs_dir_file_operations;
74static struct extent_io_ops btrfs_extent_io_ops;
75
76static struct kmem_cache *btrfs_inode_cachep;
77static struct kmem_cache *btrfs_delalloc_work_cachep;
78struct kmem_cache *btrfs_trans_handle_cachep;
79struct kmem_cache *btrfs_transaction_cachep;
80struct kmem_cache *btrfs_path_cachep;
81struct kmem_cache *btrfs_free_space_cachep;
82
83#define S_SHIFT 12
84static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
85 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
86 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
87 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
88 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
89 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
90 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
91 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
92};
93
94static int btrfs_setsize(struct inode *inode, struct iattr *attr);
95static int btrfs_truncate(struct inode *inode);
96static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
97static noinline int cow_file_range(struct inode *inode,
98 struct page *locked_page,
99 u64 start, u64 end, int *page_started,
100 unsigned long *nr_written, int unlock);
101static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
102 u64 len, u64 orig_start,
103 u64 block_start, u64 block_len,
104 u64 orig_block_len, u64 ram_bytes,
105 int type);
106
107static int btrfs_dirty_inode(struct inode *inode);
108
109static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
110 struct inode *inode, struct inode *dir,
111 const struct qstr *qstr)
112{
113 int err;
114
115 err = btrfs_init_acl(trans, inode, dir);
116 if (!err)
117 err = btrfs_xattr_security_init(trans, inode, dir, qstr);
118 return err;
119}
120
121
122
123
124
125
126static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
127 struct btrfs_root *root, struct inode *inode,
128 u64 start, size_t size, size_t compressed_size,
129 int compress_type,
130 struct page **compressed_pages)
131{
132 struct btrfs_key key;
133 struct btrfs_path *path;
134 struct extent_buffer *leaf;
135 struct page *page = NULL;
136 char *kaddr;
137 unsigned long ptr;
138 struct btrfs_file_extent_item *ei;
139 int err = 0;
140 int ret;
141 size_t cur_size = size;
142 size_t datasize;
143 unsigned long offset;
144
145 if (compressed_size && compressed_pages)
146 cur_size = compressed_size;
147
148 path = btrfs_alloc_path();
149 if (!path)
150 return -ENOMEM;
151
152 path->leave_spinning = 1;
153
154 key.objectid = btrfs_ino(inode);
155 key.offset = start;
156 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
157 datasize = btrfs_file_extent_calc_inline_size(cur_size);
158
159 inode_add_bytes(inode, size);
160 ret = btrfs_insert_empty_item(trans, root, path, &key,
161 datasize);
162 if (ret) {
163 err = ret;
164 goto fail;
165 }
166 leaf = path->nodes[0];
167 ei = btrfs_item_ptr(leaf, path->slots[0],
168 struct btrfs_file_extent_item);
169 btrfs_set_file_extent_generation(leaf, ei, trans->transid);
170 btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
171 btrfs_set_file_extent_encryption(leaf, ei, 0);
172 btrfs_set_file_extent_other_encoding(leaf, ei, 0);
173 btrfs_set_file_extent_ram_bytes(leaf, ei, size);
174 ptr = btrfs_file_extent_inline_start(ei);
175
176 if (compress_type != BTRFS_COMPRESS_NONE) {
177 struct page *cpage;
178 int i = 0;
179 while (compressed_size > 0) {
180 cpage = compressed_pages[i];
181 cur_size = min_t(unsigned long, compressed_size,
182 PAGE_CACHE_SIZE);
183
184 kaddr = kmap_atomic(cpage);
185 write_extent_buffer(leaf, kaddr, ptr, cur_size);
186 kunmap_atomic(kaddr);
187
188 i++;
189 ptr += cur_size;
190 compressed_size -= cur_size;
191 }
192 btrfs_set_file_extent_compression(leaf, ei,
193 compress_type);
194 } else {
195 page = find_get_page(inode->i_mapping,
196 start >> PAGE_CACHE_SHIFT);
197 btrfs_set_file_extent_compression(leaf, ei, 0);
198 kaddr = kmap_atomic(page);
199 offset = start & (PAGE_CACHE_SIZE - 1);
200 write_extent_buffer(leaf, kaddr + offset, ptr, size);
201 kunmap_atomic(kaddr);
202 page_cache_release(page);
203 }
204 btrfs_mark_buffer_dirty(leaf);
205 btrfs_free_path(path);
206
207
208
209
210
211
212
213
214
215
216 BTRFS_I(inode)->disk_i_size = inode->i_size;
217 ret = btrfs_update_inode(trans, root, inode);
218
219 return ret;
220fail:
221 btrfs_free_path(path);
222 return err;
223}
224
225
226
227
228
229
230
231static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
232 struct btrfs_root *root,
233 struct inode *inode, u64 start, u64 end,
234 size_t compressed_size, int compress_type,
235 struct page **compressed_pages)
236{
237 u64 isize = i_size_read(inode);
238 u64 actual_end = min(end + 1, isize);
239 u64 inline_len = actual_end - start;
240 u64 aligned_end = ALIGN(end, root->sectorsize);
241 u64 data_len = inline_len;
242 int ret;
243
244 if (compressed_size)
245 data_len = compressed_size;
246
247 if (start > 0 ||
248 actual_end >= PAGE_CACHE_SIZE ||
249 data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
250 (!compressed_size &&
251 (actual_end & (root->sectorsize - 1)) == 0) ||
252 end + 1 < isize ||
253 data_len > root->fs_info->max_inline) {
254 return 1;
255 }
256
257 ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
258 if (ret)
259 return ret;
260
261 if (isize > actual_end)
262 inline_len = min_t(u64, isize, actual_end);
263 ret = insert_inline_extent(trans, root, inode, start,
264 inline_len, compressed_size,
265 compress_type, compressed_pages);
266 if (ret && ret != -ENOSPC) {
267 btrfs_abort_transaction(trans, root, ret);
268 return ret;
269 } else if (ret == -ENOSPC) {
270 return 1;
271 }
272
273 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
274 btrfs_delalloc_release_metadata(inode, end + 1 - start);
275 btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
276 return 0;
277}
278
279struct async_extent {
280 u64 start;
281 u64 ram_size;
282 u64 compressed_size;
283 struct page **pages;
284 unsigned long nr_pages;
285 int compress_type;
286 struct list_head list;
287};
288
289struct async_cow {
290 struct inode *inode;
291 struct btrfs_root *root;
292 struct page *locked_page;
293 u64 start;
294 u64 end;
295 struct list_head extents;
296 struct btrfs_work work;
297};
298
299static noinline int add_async_extent(struct async_cow *cow,
300 u64 start, u64 ram_size,
301 u64 compressed_size,
302 struct page **pages,
303 unsigned long nr_pages,
304 int compress_type)
305{
306 struct async_extent *async_extent;
307
308 async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
309 BUG_ON(!async_extent);
310 async_extent->start = start;
311 async_extent->ram_size = ram_size;
312 async_extent->compressed_size = compressed_size;
313 async_extent->pages = pages;
314 async_extent->nr_pages = nr_pages;
315 async_extent->compress_type = compress_type;
316 list_add_tail(&async_extent->list, &cow->extents);
317 return 0;
318}
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337static noinline int compress_file_range(struct inode *inode,
338 struct page *locked_page,
339 u64 start, u64 end,
340 struct async_cow *async_cow,
341 int *num_added)
342{
343 struct btrfs_root *root = BTRFS_I(inode)->root;
344 struct btrfs_trans_handle *trans;
345 u64 num_bytes;
346 u64 blocksize = root->sectorsize;
347 u64 actual_end;
348 u64 isize = i_size_read(inode);
349 int ret = 0;
350 struct page **pages = NULL;
351 unsigned long nr_pages;
352 unsigned long nr_pages_ret = 0;
353 unsigned long total_compressed = 0;
354 unsigned long total_in = 0;
355 unsigned long max_compressed = 128 * 1024;
356 unsigned long max_uncompressed = 128 * 1024;
357 int i;
358 int will_compress;
359 int compress_type = root->fs_info->compress_type;
360 int redirty = 0;
361
362
363 if ((end - start + 1) < 16 * 1024 &&
364 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
365 btrfs_add_inode_defrag(NULL, inode);
366
367 actual_end = min_t(u64, isize, end + 1);
368again:
369 will_compress = 0;
370 nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
371 nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
372
373
374
375
376
377
378
379
380
381
382
383 if (actual_end <= start)
384 goto cleanup_and_bail_uncompressed;
385
386 total_compressed = actual_end - start;
387
388
389
390
391
392
393
394
395
396
397
398 total_compressed = min(total_compressed, max_uncompressed);
399 num_bytes = ALIGN(end - start + 1, blocksize);
400 num_bytes = max(blocksize, num_bytes);
401 total_in = 0;
402 ret = 0;
403
404
405
406
407
408
409 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
410 (btrfs_test_opt(root, COMPRESS) ||
411 (BTRFS_I(inode)->force_compress) ||
412 (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
413 WARN_ON(pages);
414 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
415 if (!pages) {
416
417 goto cont;
418 }
419
420 if (BTRFS_I(inode)->force_compress)
421 compress_type = BTRFS_I(inode)->force_compress;
422
423
424
425
426
427
428
429
430
431
432 extent_range_clear_dirty_for_io(inode, start, end);
433 redirty = 1;
434 ret = btrfs_compress_pages(compress_type,
435 inode->i_mapping, start,
436 total_compressed, pages,
437 nr_pages, &nr_pages_ret,
438 &total_in,
439 &total_compressed,
440 max_compressed);
441
442 if (!ret) {
443 unsigned long offset = total_compressed &
444 (PAGE_CACHE_SIZE - 1);
445 struct page *page = pages[nr_pages_ret - 1];
446 char *kaddr;
447
448
449
450
451 if (offset) {
452 kaddr = kmap_atomic(page);
453 memset(kaddr + offset, 0,
454 PAGE_CACHE_SIZE - offset);
455 kunmap_atomic(kaddr);
456 }
457 will_compress = 1;
458 }
459 }
460cont:
461 if (start == 0) {
462 trans = btrfs_join_transaction(root);
463 if (IS_ERR(trans)) {
464 ret = PTR_ERR(trans);
465 trans = NULL;
466 goto cleanup_and_out;
467 }
468 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
469
470
471 if (ret || total_in < (actual_end - start)) {
472
473
474
475 ret = cow_file_range_inline(trans, root, inode,
476 start, end, 0, 0, NULL);
477 } else {
478
479 ret = cow_file_range_inline(trans, root, inode,
480 start, end,
481 total_compressed,
482 compress_type, pages);
483 }
484 if (ret <= 0) {
485
486
487
488
489
490 extent_clear_unlock_delalloc(inode,
491 &BTRFS_I(inode)->io_tree,
492 start, end, NULL,
493 EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
494 EXTENT_CLEAR_DELALLOC |
495 EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
496
497 btrfs_end_transaction(trans, root);
498 goto free_pages_out;
499 }
500 btrfs_end_transaction(trans, root);
501 }
502
503 if (will_compress) {
504
505
506
507
508
509 total_compressed = ALIGN(total_compressed, blocksize);
510
511
512
513
514
515 total_in = ALIGN(total_in, PAGE_CACHE_SIZE);
516 if (total_compressed >= total_in) {
517 will_compress = 0;
518 } else {
519 num_bytes = total_in;
520 }
521 }
522 if (!will_compress && pages) {
523
524
525
526
527 for (i = 0; i < nr_pages_ret; i++) {
528 WARN_ON(pages[i]->mapping);
529 page_cache_release(pages[i]);
530 }
531 kfree(pages);
532 pages = NULL;
533 total_compressed = 0;
534 nr_pages_ret = 0;
535
536
537 if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
538 !(BTRFS_I(inode)->force_compress)) {
539 BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;
540 }
541 }
542 if (will_compress) {
543 *num_added += 1;
544
545
546
547
548
549 add_async_extent(async_cow, start, num_bytes,
550 total_compressed, pages, nr_pages_ret,
551 compress_type);
552
553 if (start + num_bytes < end) {
554 start += num_bytes;
555 pages = NULL;
556 cond_resched();
557 goto again;
558 }
559 } else {
560cleanup_and_bail_uncompressed:
561
562
563
564
565
566
567
568 if (page_offset(locked_page) >= start &&
569 page_offset(locked_page) <= end) {
570 __set_page_dirty_nobuffers(locked_page);
571
572 }
573 if (redirty)
574 extent_range_redirty_for_io(inode, start, end);
575 add_async_extent(async_cow, start, end - start + 1,
576 0, NULL, 0, BTRFS_COMPRESS_NONE);
577 *num_added += 1;
578 }
579
580out:
581 return ret;
582
583free_pages_out:
584 for (i = 0; i < nr_pages_ret; i++) {
585 WARN_ON(pages[i]->mapping);
586 page_cache_release(pages[i]);
587 }
588 kfree(pages);
589
590 goto out;
591
592cleanup_and_out:
593 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
594 start, end, NULL,
595 EXTENT_CLEAR_UNLOCK_PAGE |
596 EXTENT_CLEAR_DIRTY |
597 EXTENT_CLEAR_DELALLOC |
598 EXTENT_SET_WRITEBACK |
599 EXTENT_END_WRITEBACK);
600 if (!trans || IS_ERR(trans))
601 btrfs_error(root->fs_info, ret, "Failed to join transaction");
602 else
603 btrfs_abort_transaction(trans, root, ret);
604 goto free_pages_out;
605}
606
607
608
609
610
611
612
613static noinline int submit_compressed_extents(struct inode *inode,
614 struct async_cow *async_cow)
615{
616 struct async_extent *async_extent;
617 u64 alloc_hint = 0;
618 struct btrfs_trans_handle *trans;
619 struct btrfs_key ins;
620 struct extent_map *em;
621 struct btrfs_root *root = BTRFS_I(inode)->root;
622 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
623 struct extent_io_tree *io_tree;
624 int ret = 0;
625
626 if (list_empty(&async_cow->extents))
627 return 0;
628
629again:
630 while (!list_empty(&async_cow->extents)) {
631 async_extent = list_entry(async_cow->extents.next,
632 struct async_extent, list);
633 list_del(&async_extent->list);
634
635 io_tree = &BTRFS_I(inode)->io_tree;
636
637retry:
638
639 if (!async_extent->pages) {
640 int page_started = 0;
641 unsigned long nr_written = 0;
642
643 lock_extent(io_tree, async_extent->start,
644 async_extent->start +
645 async_extent->ram_size - 1);
646
647
648 ret = cow_file_range(inode, async_cow->locked_page,
649 async_extent->start,
650 async_extent->start +
651 async_extent->ram_size - 1,
652 &page_started, &nr_written, 0);
653
654
655
656
657
658
659
660
661
662 if (!page_started && !ret)
663 extent_write_locked_range(io_tree,
664 inode, async_extent->start,
665 async_extent->start +
666 async_extent->ram_size - 1,
667 btrfs_get_extent,
668 WB_SYNC_ALL);
669 else if (ret)
670 unlock_page(async_cow->locked_page);
671 kfree(async_extent);
672 cond_resched();
673 continue;
674 }
675
676 lock_extent(io_tree, async_extent->start,
677 async_extent->start + async_extent->ram_size - 1);
678
679 trans = btrfs_join_transaction(root);
680 if (IS_ERR(trans)) {
681 ret = PTR_ERR(trans);
682 } else {
683 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
684 ret = btrfs_reserve_extent(trans, root,
685 async_extent->compressed_size,
686 async_extent->compressed_size,
687 0, alloc_hint, &ins, 1);
688 if (ret && ret != -ENOSPC)
689 btrfs_abort_transaction(trans, root, ret);
690 btrfs_end_transaction(trans, root);
691 }
692
693 if (ret) {
694 int i;
695
696 for (i = 0; i < async_extent->nr_pages; i++) {
697 WARN_ON(async_extent->pages[i]->mapping);
698 page_cache_release(async_extent->pages[i]);
699 }
700 kfree(async_extent->pages);
701 async_extent->nr_pages = 0;
702 async_extent->pages = NULL;
703
704 if (ret == -ENOSPC)
705 goto retry;
706 goto out_free;
707 }
708
709
710
711
712
713 btrfs_drop_extent_cache(inode, async_extent->start,
714 async_extent->start +
715 async_extent->ram_size - 1, 0);
716
717 em = alloc_extent_map();
718 if (!em) {
719 ret = -ENOMEM;
720 goto out_free_reserve;
721 }
722 em->start = async_extent->start;
723 em->len = async_extent->ram_size;
724 em->orig_start = em->start;
725 em->mod_start = em->start;
726 em->mod_len = em->len;
727
728 em->block_start = ins.objectid;
729 em->block_len = ins.offset;
730 em->orig_block_len = ins.offset;
731 em->ram_bytes = async_extent->ram_size;
732 em->bdev = root->fs_info->fs_devices->latest_bdev;
733 em->compress_type = async_extent->compress_type;
734 set_bit(EXTENT_FLAG_PINNED, &em->flags);
735 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
736 em->generation = -1;
737
738 while (1) {
739 write_lock(&em_tree->lock);
740 ret = add_extent_mapping(em_tree, em, 1);
741 write_unlock(&em_tree->lock);
742 if (ret != -EEXIST) {
743 free_extent_map(em);
744 break;
745 }
746 btrfs_drop_extent_cache(inode, async_extent->start,
747 async_extent->start +
748 async_extent->ram_size - 1, 0);
749 }
750
751 if (ret)
752 goto out_free_reserve;
753
754 ret = btrfs_add_ordered_extent_compress(inode,
755 async_extent->start,
756 ins.objectid,
757 async_extent->ram_size,
758 ins.offset,
759 BTRFS_ORDERED_COMPRESSED,
760 async_extent->compress_type);
761 if (ret)
762 goto out_free_reserve;
763
764
765
766
767 extent_clear_unlock_delalloc(inode,
768 &BTRFS_I(inode)->io_tree,
769 async_extent->start,
770 async_extent->start +
771 async_extent->ram_size - 1,
772 NULL, EXTENT_CLEAR_UNLOCK_PAGE |
773 EXTENT_CLEAR_UNLOCK |
774 EXTENT_CLEAR_DELALLOC |
775 EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
776
777 ret = btrfs_submit_compressed_write(inode,
778 async_extent->start,
779 async_extent->ram_size,
780 ins.objectid,
781 ins.offset, async_extent->pages,
782 async_extent->nr_pages);
783 alloc_hint = ins.objectid + ins.offset;
784 kfree(async_extent);
785 if (ret)
786 goto out;
787 cond_resched();
788 }
789 ret = 0;
790out:
791 return ret;
792out_free_reserve:
793 btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
794out_free:
795 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
796 async_extent->start,
797 async_extent->start +
798 async_extent->ram_size - 1,
799 NULL, EXTENT_CLEAR_UNLOCK_PAGE |
800 EXTENT_CLEAR_UNLOCK |
801 EXTENT_CLEAR_DELALLOC |
802 EXTENT_CLEAR_DIRTY |
803 EXTENT_SET_WRITEBACK |
804 EXTENT_END_WRITEBACK);
805 kfree(async_extent);
806 goto again;
807}
808
809static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
810 u64 num_bytes)
811{
812 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
813 struct extent_map *em;
814 u64 alloc_hint = 0;
815
816 read_lock(&em_tree->lock);
817 em = search_extent_mapping(em_tree, start, num_bytes);
818 if (em) {
819
820
821
822
823
824 if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
825 free_extent_map(em);
826 em = search_extent_mapping(em_tree, 0, 0);
827 if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
828 alloc_hint = em->block_start;
829 if (em)
830 free_extent_map(em);
831 } else {
832 alloc_hint = em->block_start;
833 free_extent_map(em);
834 }
835 }
836 read_unlock(&em_tree->lock);
837
838 return alloc_hint;
839}
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
855 struct inode *inode,
856 struct btrfs_root *root,
857 struct page *locked_page,
858 u64 start, u64 end, int *page_started,
859 unsigned long *nr_written,
860 int unlock)
861{
862 u64 alloc_hint = 0;
863 u64 num_bytes;
864 unsigned long ram_size;
865 u64 disk_num_bytes;
866 u64 cur_alloc_size;
867 u64 blocksize = root->sectorsize;
868 struct btrfs_key ins;
869 struct extent_map *em;
870 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
871 int ret = 0;
872
873 BUG_ON(btrfs_is_free_space_inode(inode));
874
875 num_bytes = ALIGN(end - start + 1, blocksize);
876 num_bytes = max(blocksize, num_bytes);
877 disk_num_bytes = num_bytes;
878
879
880 if (num_bytes < 64 * 1024 &&
881 (start > 0 || end + 1 < BTRFS_I(inode)->disk_i_size))
882 btrfs_add_inode_defrag(trans, inode);
883
884 if (start == 0) {
885
886 ret = cow_file_range_inline(trans, root, inode,
887 start, end, 0, 0, NULL);
888 if (ret == 0) {
889 extent_clear_unlock_delalloc(inode,
890 &BTRFS_I(inode)->io_tree,
891 start, end, NULL,
892 EXTENT_CLEAR_UNLOCK_PAGE |
893 EXTENT_CLEAR_UNLOCK |
894 EXTENT_CLEAR_DELALLOC |
895 EXTENT_CLEAR_DIRTY |
896 EXTENT_SET_WRITEBACK |
897 EXTENT_END_WRITEBACK);
898
899 *nr_written = *nr_written +
900 (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
901 *page_started = 1;
902 goto out;
903 } else if (ret < 0) {
904 btrfs_abort_transaction(trans, root, ret);
905 goto out_unlock;
906 }
907 }
908
909 BUG_ON(disk_num_bytes >
910 btrfs_super_total_bytes(root->fs_info->super_copy));
911
912 alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
913 btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
914
915 while (disk_num_bytes > 0) {
916 unsigned long op;
917
918 cur_alloc_size = disk_num_bytes;
919 ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
920 root->sectorsize, 0, alloc_hint,
921 &ins, 1);
922 if (ret < 0) {
923 btrfs_abort_transaction(trans, root, ret);
924 goto out_unlock;
925 }
926
927 em = alloc_extent_map();
928 if (!em) {
929 ret = -ENOMEM;
930 goto out_reserve;
931 }
932 em->start = start;
933 em->orig_start = em->start;
934 ram_size = ins.offset;
935 em->len = ins.offset;
936 em->mod_start = em->start;
937 em->mod_len = em->len;
938
939 em->block_start = ins.objectid;
940 em->block_len = ins.offset;
941 em->orig_block_len = ins.offset;
942 em->ram_bytes = ram_size;
943 em->bdev = root->fs_info->fs_devices->latest_bdev;
944 set_bit(EXTENT_FLAG_PINNED, &em->flags);
945 em->generation = -1;
946
947 while (1) {
948 write_lock(&em_tree->lock);
949 ret = add_extent_mapping(em_tree, em, 1);
950 write_unlock(&em_tree->lock);
951 if (ret != -EEXIST) {
952 free_extent_map(em);
953 break;
954 }
955 btrfs_drop_extent_cache(inode, start,
956 start + ram_size - 1, 0);
957 }
958 if (ret)
959 goto out_reserve;
960
961 cur_alloc_size = ins.offset;
962 ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
963 ram_size, cur_alloc_size, 0);
964 if (ret)
965 goto out_reserve;
966
967 if (root->root_key.objectid ==
968 BTRFS_DATA_RELOC_TREE_OBJECTID) {
969 ret = btrfs_reloc_clone_csums(inode, start,
970 cur_alloc_size);
971 if (ret) {
972 btrfs_abort_transaction(trans, root, ret);
973 goto out_reserve;
974 }
975 }
976
977 if (disk_num_bytes < cur_alloc_size)
978 break;
979
980
981
982
983
984
985
986
987 op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
988 op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
989 EXTENT_SET_PRIVATE2;
990
991 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
992 start, start + ram_size - 1,
993 locked_page, op);
994 disk_num_bytes -= cur_alloc_size;
995 num_bytes -= cur_alloc_size;
996 alloc_hint = ins.objectid + ins.offset;
997 start += cur_alloc_size;
998 }
999out:
1000 return ret;
1001
1002out_reserve:
1003 btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
1004out_unlock:
1005 extent_clear_unlock_delalloc(inode,
1006 &BTRFS_I(inode)->io_tree,
1007 start, end, locked_page,
1008 EXTENT_CLEAR_UNLOCK_PAGE |
1009 EXTENT_CLEAR_UNLOCK |
1010 EXTENT_CLEAR_DELALLOC |
1011 EXTENT_CLEAR_DIRTY |
1012 EXTENT_SET_WRITEBACK |
1013 EXTENT_END_WRITEBACK);
1014
1015 goto out;
1016}
1017
1018static noinline int cow_file_range(struct inode *inode,
1019 struct page *locked_page,
1020 u64 start, u64 end, int *page_started,
1021 unsigned long *nr_written,
1022 int unlock)
1023{
1024 struct btrfs_trans_handle *trans;
1025 struct btrfs_root *root = BTRFS_I(inode)->root;
1026 int ret;
1027
1028 trans = btrfs_join_transaction(root);
1029 if (IS_ERR(trans)) {
1030 extent_clear_unlock_delalloc(inode,
1031 &BTRFS_I(inode)->io_tree,
1032 start, end, locked_page,
1033 EXTENT_CLEAR_UNLOCK_PAGE |
1034 EXTENT_CLEAR_UNLOCK |
1035 EXTENT_CLEAR_DELALLOC |
1036 EXTENT_CLEAR_DIRTY |
1037 EXTENT_SET_WRITEBACK |
1038 EXTENT_END_WRITEBACK);
1039 return PTR_ERR(trans);
1040 }
1041 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1042
1043 ret = __cow_file_range(trans, inode, root, locked_page, start, end,
1044 page_started, nr_written, unlock);
1045
1046 btrfs_end_transaction(trans, root);
1047
1048 return ret;
1049}
1050
1051
1052
1053
1054static noinline void async_cow_start(struct btrfs_work *work)
1055{
1056 struct async_cow *async_cow;
1057 int num_added = 0;
1058 async_cow = container_of(work, struct async_cow, work);
1059
1060 compress_file_range(async_cow->inode, async_cow->locked_page,
1061 async_cow->start, async_cow->end, async_cow,
1062 &num_added);
1063 if (num_added == 0) {
1064 btrfs_add_delayed_iput(async_cow->inode);
1065 async_cow->inode = NULL;
1066 }
1067}
1068
1069
1070
1071
1072static noinline void async_cow_submit(struct btrfs_work *work)
1073{
1074 struct async_cow *async_cow;
1075 struct btrfs_root *root;
1076 unsigned long nr_pages;
1077
1078 async_cow = container_of(work, struct async_cow, work);
1079
1080 root = async_cow->root;
1081 nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
1082 PAGE_CACHE_SHIFT;
1083
1084 if (atomic_sub_return(nr_pages, &root->fs_info->async_delalloc_pages) <
1085 5 * 1024 * 1024 &&
1086 waitqueue_active(&root->fs_info->async_submit_wait))
1087 wake_up(&root->fs_info->async_submit_wait);
1088
1089 if (async_cow->inode)
1090 submit_compressed_extents(async_cow->inode, async_cow);
1091}
1092
1093static noinline void async_cow_free(struct btrfs_work *work)
1094{
1095 struct async_cow *async_cow;
1096 async_cow = container_of(work, struct async_cow, work);
1097 if (async_cow->inode)
1098 btrfs_add_delayed_iput(async_cow->inode);
1099 kfree(async_cow);
1100}
1101
1102static int cow_file_range_async(struct inode *inode, struct page *locked_page,
1103 u64 start, u64 end, int *page_started,
1104 unsigned long *nr_written)
1105{
1106 struct async_cow *async_cow;
1107 struct btrfs_root *root = BTRFS_I(inode)->root;
1108 unsigned long nr_pages;
1109 u64 cur_end;
1110 int limit = 10 * 1024 * 1024;
1111
1112 clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
1113 1, 0, NULL, GFP_NOFS);
1114 while (start < end) {
1115 async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
1116 BUG_ON(!async_cow);
1117 async_cow->inode = igrab(inode);
1118 async_cow->root = root;
1119 async_cow->locked_page = locked_page;
1120 async_cow->start = start;
1121
1122 if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)
1123 cur_end = end;
1124 else
1125 cur_end = min(end, start + 512 * 1024 - 1);
1126
1127 async_cow->end = cur_end;
1128 INIT_LIST_HEAD(&async_cow->extents);
1129
1130 async_cow->work.func = async_cow_start;
1131 async_cow->work.ordered_func = async_cow_submit;
1132 async_cow->work.ordered_free = async_cow_free;
1133 async_cow->work.flags = 0;
1134
1135 nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
1136 PAGE_CACHE_SHIFT;
1137 atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);
1138
1139 btrfs_queue_worker(&root->fs_info->delalloc_workers,
1140 &async_cow->work);
1141
1142 if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
1143 wait_event(root->fs_info->async_submit_wait,
1144 (atomic_read(&root->fs_info->async_delalloc_pages) <
1145 limit));
1146 }
1147
1148 while (atomic_read(&root->fs_info->async_submit_draining) &&
1149 atomic_read(&root->fs_info->async_delalloc_pages)) {
1150 wait_event(root->fs_info->async_submit_wait,
1151 (atomic_read(&root->fs_info->async_delalloc_pages) ==
1152 0));
1153 }
1154
1155 *nr_written += nr_pages;
1156 start = cur_end + 1;
1157 }
1158 *page_started = 1;
1159 return 0;
1160}
1161
1162static noinline int csum_exist_in_range(struct btrfs_root *root,
1163 u64 bytenr, u64 num_bytes)
1164{
1165 int ret;
1166 struct btrfs_ordered_sum *sums;
1167 LIST_HEAD(list);
1168
1169 ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
1170 bytenr + num_bytes - 1, &list, 0);
1171 if (ret == 0 && list_empty(&list))
1172 return 0;
1173
1174 while (!list_empty(&list)) {
1175 sums = list_entry(list.next, struct btrfs_ordered_sum, list);
1176 list_del(&sums->list);
1177 kfree(sums);
1178 }
1179 return 1;
1180}
1181
1182
1183
1184
1185
1186
1187
1188
1189static noinline int run_delalloc_nocow(struct inode *inode,
1190 struct page *locked_page,
1191 u64 start, u64 end, int *page_started, int force,
1192 unsigned long *nr_written)
1193{
1194 struct btrfs_root *root = BTRFS_I(inode)->root;
1195 struct btrfs_trans_handle *trans;
1196 struct extent_buffer *leaf;
1197 struct btrfs_path *path;
1198 struct btrfs_file_extent_item *fi;
1199 struct btrfs_key found_key;
1200 u64 cow_start;
1201 u64 cur_offset;
1202 u64 extent_end;
1203 u64 extent_offset;
1204 u64 disk_bytenr;
1205 u64 num_bytes;
1206 u64 disk_num_bytes;
1207 u64 ram_bytes;
1208 int extent_type;
1209 int ret, err;
1210 int type;
1211 int nocow;
1212 int check_prev = 1;
1213 bool nolock;
1214 u64 ino = btrfs_ino(inode);
1215
1216 path = btrfs_alloc_path();
1217 if (!path) {
1218 extent_clear_unlock_delalloc(inode,
1219 &BTRFS_I(inode)->io_tree,
1220 start, end, locked_page,
1221 EXTENT_CLEAR_UNLOCK_PAGE |
1222 EXTENT_CLEAR_UNLOCK |
1223 EXTENT_CLEAR_DELALLOC |
1224 EXTENT_CLEAR_DIRTY |
1225 EXTENT_SET_WRITEBACK |
1226 EXTENT_END_WRITEBACK);
1227 return -ENOMEM;
1228 }
1229
1230 nolock = btrfs_is_free_space_inode(inode);
1231
1232 if (nolock)
1233 trans = btrfs_join_transaction_nolock(root);
1234 else
1235 trans = btrfs_join_transaction(root);
1236
1237 if (IS_ERR(trans)) {
1238 extent_clear_unlock_delalloc(inode,
1239 &BTRFS_I(inode)->io_tree,
1240 start, end, locked_page,
1241 EXTENT_CLEAR_UNLOCK_PAGE |
1242 EXTENT_CLEAR_UNLOCK |
1243 EXTENT_CLEAR_DELALLOC |
1244 EXTENT_CLEAR_DIRTY |
1245 EXTENT_SET_WRITEBACK |
1246 EXTENT_END_WRITEBACK);
1247 btrfs_free_path(path);
1248 return PTR_ERR(trans);
1249 }
1250
1251 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
1252
1253 cow_start = (u64)-1;
1254 cur_offset = start;
1255 while (1) {
1256 ret = btrfs_lookup_file_extent(trans, root, path, ino,
1257 cur_offset, 0);
1258 if (ret < 0) {
1259 btrfs_abort_transaction(trans, root, ret);
1260 goto error;
1261 }
1262 if (ret > 0 && path->slots[0] > 0 && check_prev) {
1263 leaf = path->nodes[0];
1264 btrfs_item_key_to_cpu(leaf, &found_key,
1265 path->slots[0] - 1);
1266 if (found_key.objectid == ino &&
1267 found_key.type == BTRFS_EXTENT_DATA_KEY)
1268 path->slots[0]--;
1269 }
1270 check_prev = 0;
1271next_slot:
1272 leaf = path->nodes[0];
1273 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1274 ret = btrfs_next_leaf(root, path);
1275 if (ret < 0) {
1276 btrfs_abort_transaction(trans, root, ret);
1277 goto error;
1278 }
1279 if (ret > 0)
1280 break;
1281 leaf = path->nodes[0];
1282 }
1283
1284 nocow = 0;
1285 disk_bytenr = 0;
1286 num_bytes = 0;
1287 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1288
1289 if (found_key.objectid > ino ||
1290 found_key.type > BTRFS_EXTENT_DATA_KEY ||
1291 found_key.offset > end)
1292 break;
1293
1294 if (found_key.offset > cur_offset) {
1295 extent_end = found_key.offset;
1296 extent_type = 0;
1297 goto out_check;
1298 }
1299
1300 fi = btrfs_item_ptr(leaf, path->slots[0],
1301 struct btrfs_file_extent_item);
1302 extent_type = btrfs_file_extent_type(leaf, fi);
1303
1304 ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
1305 if (extent_type == BTRFS_FILE_EXTENT_REG ||
1306 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1307 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1308 extent_offset = btrfs_file_extent_offset(leaf, fi);
1309 extent_end = found_key.offset +
1310 btrfs_file_extent_num_bytes(leaf, fi);
1311 disk_num_bytes =
1312 btrfs_file_extent_disk_num_bytes(leaf, fi);
1313 if (extent_end <= start) {
1314 path->slots[0]++;
1315 goto next_slot;
1316 }
1317 if (disk_bytenr == 0)
1318 goto out_check;
1319 if (btrfs_file_extent_compression(leaf, fi) ||
1320 btrfs_file_extent_encryption(leaf, fi) ||
1321 btrfs_file_extent_other_encoding(leaf, fi))
1322 goto out_check;
1323 if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
1324 goto out_check;
1325 if (btrfs_extent_readonly(root, disk_bytenr))
1326 goto out_check;
1327 if (btrfs_cross_ref_exist(trans, root, ino,
1328 found_key.offset -
1329 extent_offset, disk_bytenr))
1330 goto out_check;
1331 disk_bytenr += extent_offset;
1332 disk_bytenr += cur_offset - found_key.offset;
1333 num_bytes = min(end + 1, extent_end) - cur_offset;
1334
1335
1336
1337
1338
1339 if (csum_exist_in_range(root, disk_bytenr, num_bytes))
1340 goto out_check;
1341 nocow = 1;
1342 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1343 extent_end = found_key.offset +
1344 btrfs_file_extent_inline_len(leaf, fi);
1345 extent_end = ALIGN(extent_end, root->sectorsize);
1346 } else {
1347 BUG_ON(1);
1348 }
1349out_check:
1350 if (extent_end <= start) {
1351 path->slots[0]++;
1352 goto next_slot;
1353 }
1354 if (!nocow) {
1355 if (cow_start == (u64)-1)
1356 cow_start = cur_offset;
1357 cur_offset = extent_end;
1358 if (cur_offset > end)
1359 break;
1360 path->slots[0]++;
1361 goto next_slot;
1362 }
1363
1364 btrfs_release_path(path);
1365 if (cow_start != (u64)-1) {
1366 ret = __cow_file_range(trans, inode, root, locked_page,
1367 cow_start, found_key.offset - 1,
1368 page_started, nr_written, 1);
1369 if (ret) {
1370 btrfs_abort_transaction(trans, root, ret);
1371 goto error;
1372 }
1373 cow_start = (u64)-1;
1374 }
1375
1376 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1377 struct extent_map *em;
1378 struct extent_map_tree *em_tree;
1379 em_tree = &BTRFS_I(inode)->extent_tree;
1380 em = alloc_extent_map();
1381 BUG_ON(!em);
1382 em->start = cur_offset;
1383 em->orig_start = found_key.offset - extent_offset;
1384 em->len = num_bytes;
1385 em->block_len = num_bytes;
1386 em->block_start = disk_bytenr;
1387 em->orig_block_len = disk_num_bytes;
1388 em->ram_bytes = ram_bytes;
1389 em->bdev = root->fs_info->fs_devices->latest_bdev;
1390 em->mod_start = em->start;
1391 em->mod_len = em->len;
1392 set_bit(EXTENT_FLAG_PINNED, &em->flags);
1393 set_bit(EXTENT_FLAG_FILLING, &em->flags);
1394 em->generation = -1;
1395 while (1) {
1396 write_lock(&em_tree->lock);
1397 ret = add_extent_mapping(em_tree, em, 1);
1398 write_unlock(&em_tree->lock);
1399 if (ret != -EEXIST) {
1400 free_extent_map(em);
1401 break;
1402 }
1403 btrfs_drop_extent_cache(inode, em->start,
1404 em->start + em->len - 1, 0);
1405 }
1406 type = BTRFS_ORDERED_PREALLOC;
1407 } else {
1408 type = BTRFS_ORDERED_NOCOW;
1409 }
1410
1411 ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,
1412 num_bytes, num_bytes, type);
1413 BUG_ON(ret);
1414
1415 if (root->root_key.objectid ==
1416 BTRFS_DATA_RELOC_TREE_OBJECTID) {
1417 ret = btrfs_reloc_clone_csums(inode, cur_offset,
1418 num_bytes);
1419 if (ret) {
1420 btrfs_abort_transaction(trans, root, ret);
1421 goto error;
1422 }
1423 }
1424
1425 extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
1426 cur_offset, cur_offset + num_bytes - 1,
1427 locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
1428 EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
1429 EXTENT_SET_PRIVATE2);
1430 cur_offset = extent_end;
1431 if (cur_offset > end)
1432 break;
1433 }
1434 btrfs_release_path(path);
1435
1436 if (cur_offset <= end && cow_start == (u64)-1) {
1437 cow_start = cur_offset;
1438 cur_offset = end;
1439 }
1440
1441 if (cow_start != (u64)-1) {
1442 ret = __cow_file_range(trans, inode, root, locked_page,
1443 cow_start, end,
1444 page_started, nr_written, 1);
1445 if (ret) {
1446 btrfs_abort_transaction(trans, root, ret);
1447 goto error;
1448 }
1449 }
1450
1451error:
1452 err = btrfs_end_transaction(trans, root);
1453 if (!ret)
1454 ret = err;
1455
1456 if (ret && cur_offset < end)
1457 extent_clear_unlock_delalloc(inode,
1458 &BTRFS_I(inode)->io_tree,
1459 cur_offset, end, locked_page,
1460 EXTENT_CLEAR_UNLOCK_PAGE |
1461 EXTENT_CLEAR_UNLOCK |
1462 EXTENT_CLEAR_DELALLOC |
1463 EXTENT_CLEAR_DIRTY |
1464 EXTENT_SET_WRITEBACK |
1465 EXTENT_END_WRITEBACK);
1466
1467 btrfs_free_path(path);
1468 return ret;
1469}
1470
1471
1472
1473
1474static int run_delalloc_range(struct inode *inode, struct page *locked_page,
1475 u64 start, u64 end, int *page_started,
1476 unsigned long *nr_written)
1477{
1478 int ret;
1479 struct btrfs_root *root = BTRFS_I(inode)->root;
1480
1481 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) {
1482 ret = run_delalloc_nocow(inode, locked_page, start, end,
1483 page_started, 1, nr_written);
1484 } else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC) {
1485 ret = run_delalloc_nocow(inode, locked_page, start, end,
1486 page_started, 0, nr_written);
1487 } else if (!btrfs_test_opt(root, COMPRESS) &&
1488 !(BTRFS_I(inode)->force_compress) &&
1489 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS)) {
1490 ret = cow_file_range(inode, locked_page, start, end,
1491 page_started, nr_written, 1);
1492 } else {
1493 set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
1494 &BTRFS_I(inode)->runtime_flags);
1495 ret = cow_file_range_async(inode, locked_page, start, end,
1496 page_started, nr_written);
1497 }
1498 return ret;
1499}
1500
1501static void btrfs_split_extent_hook(struct inode *inode,
1502 struct extent_state *orig, u64 split)
1503{
1504
1505 if (!(orig->state & EXTENT_DELALLOC))
1506 return;
1507
1508 spin_lock(&BTRFS_I(inode)->lock);
1509 BTRFS_I(inode)->outstanding_extents++;
1510 spin_unlock(&BTRFS_I(inode)->lock);
1511}
1512
1513
1514
1515
1516
1517
1518
1519static void btrfs_merge_extent_hook(struct inode *inode,
1520 struct extent_state *new,
1521 struct extent_state *other)
1522{
1523
1524 if (!(other->state & EXTENT_DELALLOC))
1525 return;
1526
1527 spin_lock(&BTRFS_I(inode)->lock);
1528 BTRFS_I(inode)->outstanding_extents--;
1529 spin_unlock(&BTRFS_I(inode)->lock);
1530}
1531
1532
1533
1534
1535
1536
1537static void btrfs_set_bit_hook(struct inode *inode,
1538 struct extent_state *state, unsigned long *bits)
1539{
1540
1541
1542
1543
1544
1545
1546 if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1547 struct btrfs_root *root = BTRFS_I(inode)->root;
1548 u64 len = state->end + 1 - state->start;
1549 bool do_list = !btrfs_is_free_space_inode(inode);
1550
1551 if (*bits & EXTENT_FIRST_DELALLOC) {
1552 *bits &= ~EXTENT_FIRST_DELALLOC;
1553 } else {
1554 spin_lock(&BTRFS_I(inode)->lock);
1555 BTRFS_I(inode)->outstanding_extents++;
1556 spin_unlock(&BTRFS_I(inode)->lock);
1557 }
1558
1559 __percpu_counter_add(&root->fs_info->delalloc_bytes, len,
1560 root->fs_info->delalloc_batch);
1561 spin_lock(&BTRFS_I(inode)->lock);
1562 BTRFS_I(inode)->delalloc_bytes += len;
1563 if (do_list && !test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1564 &BTRFS_I(inode)->runtime_flags)) {
1565 spin_lock(&root->fs_info->delalloc_lock);
1566 if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1567 list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
1568 &root->fs_info->delalloc_inodes);
1569 set_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1570 &BTRFS_I(inode)->runtime_flags);
1571 }
1572 spin_unlock(&root->fs_info->delalloc_lock);
1573 }
1574 spin_unlock(&BTRFS_I(inode)->lock);
1575 }
1576}
1577
1578
1579
1580
1581static void btrfs_clear_bit_hook(struct inode *inode,
1582 struct extent_state *state,
1583 unsigned long *bits)
1584{
1585
1586
1587
1588
1589
1590 if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
1591 struct btrfs_root *root = BTRFS_I(inode)->root;
1592 u64 len = state->end + 1 - state->start;
1593 bool do_list = !btrfs_is_free_space_inode(inode);
1594
1595 if (*bits & EXTENT_FIRST_DELALLOC) {
1596 *bits &= ~EXTENT_FIRST_DELALLOC;
1597 } else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
1598 spin_lock(&BTRFS_I(inode)->lock);
1599 BTRFS_I(inode)->outstanding_extents--;
1600 spin_unlock(&BTRFS_I(inode)->lock);
1601 }
1602
1603 if (*bits & EXTENT_DO_ACCOUNTING)
1604 btrfs_delalloc_release_metadata(inode, len);
1605
1606 if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
1607 && do_list)
1608 btrfs_free_reserved_data_space(inode, len);
1609
1610 __percpu_counter_add(&root->fs_info->delalloc_bytes, -len,
1611 root->fs_info->delalloc_batch);
1612 spin_lock(&BTRFS_I(inode)->lock);
1613 BTRFS_I(inode)->delalloc_bytes -= len;
1614 if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
1615 test_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1616 &BTRFS_I(inode)->runtime_flags)) {
1617 spin_lock(&root->fs_info->delalloc_lock);
1618 if (!list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
1619 list_del_init(&BTRFS_I(inode)->delalloc_inodes);
1620 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
1621 &BTRFS_I(inode)->runtime_flags);
1622 }
1623 spin_unlock(&root->fs_info->delalloc_lock);
1624 }
1625 spin_unlock(&BTRFS_I(inode)->lock);
1626 }
1627}
1628
1629
1630
1631
1632
1633int btrfs_merge_bio_hook(int rw, struct page *page, unsigned long offset,
1634 size_t size, struct bio *bio,
1635 unsigned long bio_flags)
1636{
1637 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
1638 u64 logical = (u64)bio->bi_sector << 9;
1639 u64 length = 0;
1640 u64 map_length;
1641 int ret;
1642
1643 if (bio_flags & EXTENT_BIO_COMPRESSED)
1644 return 0;
1645
1646 length = bio->bi_size;
1647 map_length = length;
1648 ret = btrfs_map_block(root->fs_info, rw, logical,
1649 &map_length, NULL, 0);
1650
1651 BUG_ON(ret < 0);
1652 if (map_length < length + size)
1653 return 1;
1654 return 0;
1655}
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665static int __btrfs_submit_bio_start(struct inode *inode, int rw,
1666 struct bio *bio, int mirror_num,
1667 unsigned long bio_flags,
1668 u64 bio_offset)
1669{
1670 struct btrfs_root *root = BTRFS_I(inode)->root;
1671 int ret = 0;
1672
1673 ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1674 BUG_ON(ret);
1675 return 0;
1676}
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
1687 int mirror_num, unsigned long bio_flags,
1688 u64 bio_offset)
1689{
1690 struct btrfs_root *root = BTRFS_I(inode)->root;
1691 int ret;
1692
1693 ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
1694 if (ret)
1695 bio_endio(bio, ret);
1696 return ret;
1697}
1698
1699
1700
1701
1702
1703static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
1704 int mirror_num, unsigned long bio_flags,
1705 u64 bio_offset)
1706{
1707 struct btrfs_root *root = BTRFS_I(inode)->root;
1708 int ret = 0;
1709 int skip_sum;
1710 int metadata = 0;
1711 int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
1712
1713 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
1714
1715 if (btrfs_is_free_space_inode(inode))
1716 metadata = 2;
1717
1718 if (!(rw & REQ_WRITE)) {
1719 ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
1720 if (ret)
1721 goto out;
1722
1723 if (bio_flags & EXTENT_BIO_COMPRESSED) {
1724 ret = btrfs_submit_compressed_read(inode, bio,
1725 mirror_num,
1726 bio_flags);
1727 goto out;
1728 } else if (!skip_sum) {
1729 ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
1730 if (ret)
1731 goto out;
1732 }
1733 goto mapit;
1734 } else if (async && !skip_sum) {
1735
1736 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
1737 goto mapit;
1738
1739 ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
1740 inode, rw, bio, mirror_num,
1741 bio_flags, bio_offset,
1742 __btrfs_submit_bio_start,
1743 __btrfs_submit_bio_done);
1744 goto out;
1745 } else if (!skip_sum) {
1746 ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
1747 if (ret)
1748 goto out;
1749 }
1750
1751mapit:
1752 ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
1753
1754out:
1755 if (ret < 0)
1756 bio_endio(bio, ret);
1757 return ret;
1758}
1759
1760
1761
1762
1763
1764static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
1765 struct inode *inode, u64 file_offset,
1766 struct list_head *list)
1767{
1768 struct btrfs_ordered_sum *sum;
1769
1770 list_for_each_entry(sum, list, list) {
1771 trans->adding_csums = 1;
1772 btrfs_csum_file_blocks(trans,
1773 BTRFS_I(inode)->root->fs_info->csum_root, sum);
1774 trans->adding_csums = 0;
1775 }
1776 return 0;
1777}
1778
1779int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
1780 struct extent_state **cached_state)
1781{
1782 WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
1783 return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
1784 cached_state, GFP_NOFS);
1785}
1786
1787
1788struct btrfs_writepage_fixup {
1789 struct page *page;
1790 struct btrfs_work work;
1791};
1792
1793static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
1794{
1795 struct btrfs_writepage_fixup *fixup;
1796 struct btrfs_ordered_extent *ordered;
1797 struct extent_state *cached_state = NULL;
1798 struct page *page;
1799 struct inode *inode;
1800 u64 page_start;
1801 u64 page_end;
1802 int ret;
1803
1804 fixup = container_of(work, struct btrfs_writepage_fixup, work);
1805 page = fixup->page;
1806again:
1807 lock_page(page);
1808 if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
1809 ClearPageChecked(page);
1810 goto out_page;
1811 }
1812
1813 inode = page->mapping->host;
1814 page_start = page_offset(page);
1815 page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;
1816
1817 lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
1818 &cached_state);
1819
1820
1821 if (PagePrivate2(page))
1822 goto out;
1823
1824 ordered = btrfs_lookup_ordered_extent(inode, page_start);
1825 if (ordered) {
1826 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
1827 page_end, &cached_state, GFP_NOFS);
1828 unlock_page(page);
1829 btrfs_start_ordered_extent(inode, ordered, 1);
1830 btrfs_put_ordered_extent(ordered);
1831 goto again;
1832 }
1833
1834 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
1835 if (ret) {
1836 mapping_set_error(page->mapping, ret);
1837 end_extent_writepage(page, ret, page_start, page_end);
1838 ClearPageChecked(page);
1839 goto out;
1840 }
1841
1842 btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);
1843 ClearPageChecked(page);
1844 set_page_dirty(page);
1845out:
1846 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
1847 &cached_state, GFP_NOFS);
1848out_page:
1849 unlock_page(page);
1850 page_cache_release(page);
1851 kfree(fixup);
1852}
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)
1866{
1867 struct inode *inode = page->mapping->host;
1868 struct btrfs_writepage_fixup *fixup;
1869 struct btrfs_root *root = BTRFS_I(inode)->root;
1870
1871
1872 if (TestClearPagePrivate2(page))
1873 return 0;
1874
1875 if (PageChecked(page))
1876 return -EAGAIN;
1877
1878 fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
1879 if (!fixup)
1880 return -EAGAIN;
1881
1882 SetPageChecked(page);
1883 page_cache_get(page);
1884 fixup->work.func = btrfs_writepage_fixup_worker;
1885 fixup->page = page;
1886 btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work);
1887 return -EBUSY;
1888}
1889
1890static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
1891 struct inode *inode, u64 file_pos,
1892 u64 disk_bytenr, u64 disk_num_bytes,
1893 u64 num_bytes, u64 ram_bytes,
1894 u8 compression, u8 encryption,
1895 u16 other_encoding, int extent_type)
1896{
1897 struct btrfs_root *root = BTRFS_I(inode)->root;
1898 struct btrfs_file_extent_item *fi;
1899 struct btrfs_path *path;
1900 struct extent_buffer *leaf;
1901 struct btrfs_key ins;
1902 int ret;
1903
1904 path = btrfs_alloc_path();
1905 if (!path)
1906 return -ENOMEM;
1907
1908 path->leave_spinning = 1;
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919 ret = btrfs_drop_extents(trans, root, inode, file_pos,
1920 file_pos + num_bytes, 0);
1921 if (ret)
1922 goto out;
1923
1924 ins.objectid = btrfs_ino(inode);
1925 ins.offset = file_pos;
1926 ins.type = BTRFS_EXTENT_DATA_KEY;
1927 ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
1928 if (ret)
1929 goto out;
1930 leaf = path->nodes[0];
1931 fi = btrfs_item_ptr(leaf, path->slots[0],
1932 struct btrfs_file_extent_item);
1933 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1934 btrfs_set_file_extent_type(leaf, fi, extent_type);
1935 btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
1936 btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
1937 btrfs_set_file_extent_offset(leaf, fi, 0);
1938 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
1939 btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
1940 btrfs_set_file_extent_compression(leaf, fi, compression);
1941 btrfs_set_file_extent_encryption(leaf, fi, encryption);
1942 btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
1943
1944 btrfs_mark_buffer_dirty(leaf);
1945 btrfs_release_path(path);
1946
1947 inode_add_bytes(inode, num_bytes);
1948
1949 ins.objectid = disk_bytenr;
1950 ins.offset = disk_num_bytes;
1951 ins.type = BTRFS_EXTENT_ITEM_KEY;
1952 ret = btrfs_alloc_reserved_file_extent(trans, root,
1953 root->root_key.objectid,
1954 btrfs_ino(inode), file_pos, &ins);
1955out:
1956 btrfs_free_path(path);
1957
1958 return ret;
1959}
1960
1961
1962struct sa_defrag_extent_backref {
1963 struct rb_node node;
1964 struct old_sa_defrag_extent *old;
1965 u64 root_id;
1966 u64 inum;
1967 u64 file_pos;
1968 u64 extent_offset;
1969 u64 num_bytes;
1970 u64 generation;
1971};
1972
1973struct old_sa_defrag_extent {
1974 struct list_head list;
1975 struct new_sa_defrag_extent *new;
1976
1977 u64 extent_offset;
1978 u64 bytenr;
1979 u64 offset;
1980 u64 len;
1981 int count;
1982};
1983
1984struct new_sa_defrag_extent {
1985 struct rb_root root;
1986 struct list_head head;
1987 struct btrfs_path *path;
1988 struct inode *inode;
1989 u64 file_pos;
1990 u64 len;
1991 u64 bytenr;
1992 u64 disk_len;
1993 u8 compress_type;
1994};
1995
1996static int backref_comp(struct sa_defrag_extent_backref *b1,
1997 struct sa_defrag_extent_backref *b2)
1998{
1999 if (b1->root_id < b2->root_id)
2000 return -1;
2001 else if (b1->root_id > b2->root_id)
2002 return 1;
2003
2004 if (b1->inum < b2->inum)
2005 return -1;
2006 else if (b1->inum > b2->inum)
2007 return 1;
2008
2009 if (b1->file_pos < b2->file_pos)
2010 return -1;
2011 else if (b1->file_pos > b2->file_pos)
2012 return 1;
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026 return 0;
2027}
2028
2029static void backref_insert(struct rb_root *root,
2030 struct sa_defrag_extent_backref *backref)
2031{
2032 struct rb_node **p = &root->rb_node;
2033 struct rb_node *parent = NULL;
2034 struct sa_defrag_extent_backref *entry;
2035 int ret;
2036
2037 while (*p) {
2038 parent = *p;
2039 entry = rb_entry(parent, struct sa_defrag_extent_backref, node);
2040
2041 ret = backref_comp(backref, entry);
2042 if (ret < 0)
2043 p = &(*p)->rb_left;
2044 else
2045 p = &(*p)->rb_right;
2046 }
2047
2048 rb_link_node(&backref->node, parent, p);
2049 rb_insert_color(&backref->node, root);
2050}
2051
2052
2053
2054
2055static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
2056 void *ctx)
2057{
2058 struct btrfs_file_extent_item *extent;
2059 struct btrfs_fs_info *fs_info;
2060 struct old_sa_defrag_extent *old = ctx;
2061 struct new_sa_defrag_extent *new = old->new;
2062 struct btrfs_path *path = new->path;
2063 struct btrfs_key key;
2064 struct btrfs_root *root;
2065 struct sa_defrag_extent_backref *backref;
2066 struct extent_buffer *leaf;
2067 struct inode *inode = new->inode;
2068 int slot;
2069 int ret;
2070 u64 extent_offset;
2071 u64 num_bytes;
2072
2073 if (BTRFS_I(inode)->root->root_key.objectid == root_id &&
2074 inum == btrfs_ino(inode))
2075 return 0;
2076
2077 key.objectid = root_id;
2078 key.type = BTRFS_ROOT_ITEM_KEY;
2079 key.offset = (u64)-1;
2080
2081 fs_info = BTRFS_I(inode)->root->fs_info;
2082 root = btrfs_read_fs_root_no_name(fs_info, &key);
2083 if (IS_ERR(root)) {
2084 if (PTR_ERR(root) == -ENOENT)
2085 return 0;
2086 WARN_ON(1);
2087 pr_debug("inum=%llu, offset=%llu, root_id=%llu\n",
2088 inum, offset, root_id);
2089 return PTR_ERR(root);
2090 }
2091
2092 key.objectid = inum;
2093 key.type = BTRFS_EXTENT_DATA_KEY;
2094 if (offset > (u64)-1 << 32)
2095 key.offset = 0;
2096 else
2097 key.offset = offset;
2098
2099 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2100 if (ret < 0) {
2101 WARN_ON(1);
2102 return ret;
2103 }
2104
2105 while (1) {
2106 cond_resched();
2107
2108 leaf = path->nodes[0];
2109 slot = path->slots[0];
2110
2111 if (slot >= btrfs_header_nritems(leaf)) {
2112 ret = btrfs_next_leaf(root, path);
2113 if (ret < 0) {
2114 goto out;
2115 } else if (ret > 0) {
2116 ret = 0;
2117 goto out;
2118 }
2119 continue;
2120 }
2121
2122 path->slots[0]++;
2123
2124 btrfs_item_key_to_cpu(leaf, &key, slot);
2125
2126 if (key.objectid > inum)
2127 goto out;
2128
2129 if (key.objectid < inum || key.type != BTRFS_EXTENT_DATA_KEY)
2130 continue;
2131
2132 extent = btrfs_item_ptr(leaf, slot,
2133 struct btrfs_file_extent_item);
2134
2135 if (btrfs_file_extent_disk_bytenr(leaf, extent) != old->bytenr)
2136 continue;
2137
2138 extent_offset = btrfs_file_extent_offset(leaf, extent);
2139 if (key.offset - extent_offset != offset)
2140 continue;
2141
2142 num_bytes = btrfs_file_extent_num_bytes(leaf, extent);
2143 if (extent_offset >= old->extent_offset + old->offset +
2144 old->len || extent_offset + num_bytes <=
2145 old->extent_offset + old->offset)
2146 continue;
2147
2148 break;
2149 }
2150
2151 backref = kmalloc(sizeof(*backref), GFP_NOFS);
2152 if (!backref) {
2153 ret = -ENOENT;
2154 goto out;
2155 }
2156
2157 backref->root_id = root_id;
2158 backref->inum = inum;
2159 backref->file_pos = offset + extent_offset;
2160 backref->num_bytes = num_bytes;
2161 backref->extent_offset = extent_offset;
2162 backref->generation = btrfs_file_extent_generation(leaf, extent);
2163 backref->old = old;
2164 backref_insert(&new->root, backref);
2165 old->count++;
2166out:
2167 btrfs_release_path(path);
2168 WARN_ON(ret);
2169 return ret;
2170}
2171
2172static noinline bool record_extent_backrefs(struct btrfs_path *path,
2173 struct new_sa_defrag_extent *new)
2174{
2175 struct btrfs_fs_info *fs_info = BTRFS_I(new->inode)->root->fs_info;
2176 struct old_sa_defrag_extent *old, *tmp;
2177 int ret;
2178
2179 new->path = path;
2180
2181 list_for_each_entry_safe(old, tmp, &new->head, list) {
2182 ret = iterate_inodes_from_logical(old->bytenr, fs_info,
2183 path, record_one_backref,
2184 old);
2185 BUG_ON(ret < 0 && ret != -ENOENT);
2186
2187
2188 if (!old->count) {
2189 list_del(&old->list);
2190 kfree(old);
2191 }
2192 }
2193
2194 if (list_empty(&new->head))
2195 return false;
2196
2197 return true;
2198}
2199
2200static int relink_is_mergable(struct extent_buffer *leaf,
2201 struct btrfs_file_extent_item *fi,
2202 u64 disk_bytenr)
2203{
2204 if (btrfs_file_extent_disk_bytenr(leaf, fi) != disk_bytenr)
2205 return 0;
2206
2207 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2208 return 0;
2209
2210 if (btrfs_file_extent_compression(leaf, fi) ||
2211 btrfs_file_extent_encryption(leaf, fi) ||
2212 btrfs_file_extent_other_encoding(leaf, fi))
2213 return 0;
2214
2215 return 1;
2216}
2217
2218
2219
2220
2221static noinline int relink_extent_backref(struct btrfs_path *path,
2222 struct sa_defrag_extent_backref *prev,
2223 struct sa_defrag_extent_backref *backref)
2224{
2225 struct btrfs_file_extent_item *extent;
2226 struct btrfs_file_extent_item *item;
2227 struct btrfs_ordered_extent *ordered;
2228 struct btrfs_trans_handle *trans;
2229 struct btrfs_fs_info *fs_info;
2230 struct btrfs_root *root;
2231 struct btrfs_key key;
2232 struct extent_buffer *leaf;
2233 struct old_sa_defrag_extent *old = backref->old;
2234 struct new_sa_defrag_extent *new = old->new;
2235 struct inode *src_inode = new->inode;
2236 struct inode *inode;
2237 struct extent_state *cached = NULL;
2238 int ret = 0;
2239 u64 start;
2240 u64 len;
2241 u64 lock_start;
2242 u64 lock_end;
2243 bool merge = false;
2244 int index;
2245
2246 if (prev && prev->root_id == backref->root_id &&
2247 prev->inum == backref->inum &&
2248 prev->file_pos + prev->num_bytes == backref->file_pos)
2249 merge = true;
2250
2251
2252 key.objectid = backref->root_id;
2253 key.type = BTRFS_ROOT_ITEM_KEY;
2254 key.offset = (u64)-1;
2255
2256 fs_info = BTRFS_I(src_inode)->root->fs_info;
2257 index = srcu_read_lock(&fs_info->subvol_srcu);
2258
2259 root = btrfs_read_fs_root_no_name(fs_info, &key);
2260 if (IS_ERR(root)) {
2261 srcu_read_unlock(&fs_info->subvol_srcu, index);
2262 if (PTR_ERR(root) == -ENOENT)
2263 return 0;
2264 return PTR_ERR(root);
2265 }
2266 if (btrfs_root_refs(&root->root_item) == 0) {
2267 srcu_read_unlock(&fs_info->subvol_srcu, index);
2268
2269 return 0;
2270 }
2271
2272
2273 key.objectid = backref->inum;
2274 key.type = BTRFS_INODE_ITEM_KEY;
2275 key.offset = 0;
2276
2277 inode = btrfs_iget(fs_info->sb, &key, root, NULL);
2278 if (IS_ERR(inode)) {
2279 srcu_read_unlock(&fs_info->subvol_srcu, index);
2280 return 0;
2281 }
2282
2283 srcu_read_unlock(&fs_info->subvol_srcu, index);
2284
2285
2286 lock_start = backref->file_pos;
2287 lock_end = backref->file_pos + backref->num_bytes - 1;
2288 lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
2289 0, &cached);
2290
2291 ordered = btrfs_lookup_first_ordered_extent(inode, lock_end);
2292 if (ordered) {
2293 btrfs_put_ordered_extent(ordered);
2294 goto out_unlock;
2295 }
2296
2297 trans = btrfs_join_transaction(root);
2298 if (IS_ERR(trans)) {
2299 ret = PTR_ERR(trans);
2300 goto out_unlock;
2301 }
2302
2303 key.objectid = backref->inum;
2304 key.type = BTRFS_EXTENT_DATA_KEY;
2305 key.offset = backref->file_pos;
2306
2307 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2308 if (ret < 0) {
2309 goto out_free_path;
2310 } else if (ret > 0) {
2311 ret = 0;
2312 goto out_free_path;
2313 }
2314
2315 extent = btrfs_item_ptr(path->nodes[0], path->slots[0],
2316 struct btrfs_file_extent_item);
2317
2318 if (btrfs_file_extent_generation(path->nodes[0], extent) !=
2319 backref->generation)
2320 goto out_free_path;
2321
2322 btrfs_release_path(path);
2323
2324 start = backref->file_pos;
2325 if (backref->extent_offset < old->extent_offset + old->offset)
2326 start += old->extent_offset + old->offset -
2327 backref->extent_offset;
2328
2329 len = min(backref->extent_offset + backref->num_bytes,
2330 old->extent_offset + old->offset + old->len);
2331 len -= max(backref->extent_offset, old->extent_offset + old->offset);
2332
2333 ret = btrfs_drop_extents(trans, root, inode, start,
2334 start + len, 1);
2335 if (ret)
2336 goto out_free_path;
2337again:
2338 key.objectid = btrfs_ino(inode);
2339 key.type = BTRFS_EXTENT_DATA_KEY;
2340 key.offset = start;
2341
2342 path->leave_spinning = 1;
2343 if (merge) {
2344 struct btrfs_file_extent_item *fi;
2345 u64 extent_len;
2346 struct btrfs_key found_key;
2347
2348 ret = btrfs_search_slot(trans, root, &key, path, 1, 1);
2349 if (ret < 0)
2350 goto out_free_path;
2351
2352 path->slots[0]--;
2353 leaf = path->nodes[0];
2354 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2355
2356 fi = btrfs_item_ptr(leaf, path->slots[0],
2357 struct btrfs_file_extent_item);
2358 extent_len = btrfs_file_extent_num_bytes(leaf, fi);
2359
2360 if (relink_is_mergable(leaf, fi, new->bytenr) &&
2361 extent_len + found_key.offset == start) {
2362 btrfs_set_file_extent_num_bytes(leaf, fi,
2363 extent_len + len);
2364 btrfs_mark_buffer_dirty(leaf);
2365 inode_add_bytes(inode, len);
2366
2367 ret = 1;
2368 goto out_free_path;
2369 } else {
2370 merge = false;
2371 btrfs_release_path(path);
2372 goto again;
2373 }
2374 }
2375
2376 ret = btrfs_insert_empty_item(trans, root, path, &key,
2377 sizeof(*extent));
2378 if (ret) {
2379 btrfs_abort_transaction(trans, root, ret);
2380 goto out_free_path;
2381 }
2382
2383 leaf = path->nodes[0];
2384 item = btrfs_item_ptr(leaf, path->slots[0],
2385 struct btrfs_file_extent_item);
2386 btrfs_set_file_extent_disk_bytenr(leaf, item, new->bytenr);
2387 btrfs_set_file_extent_disk_num_bytes(leaf, item, new->disk_len);
2388 btrfs_set_file_extent_offset(leaf, item, start - new->file_pos);
2389 btrfs_set_file_extent_num_bytes(leaf, item, len);
2390 btrfs_set_file_extent_ram_bytes(leaf, item, new->len);
2391 btrfs_set_file_extent_generation(leaf, item, trans->transid);
2392 btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
2393 btrfs_set_file_extent_compression(leaf, item, new->compress_type);
2394 btrfs_set_file_extent_encryption(leaf, item, 0);
2395 btrfs_set_file_extent_other_encoding(leaf, item, 0);
2396
2397 btrfs_mark_buffer_dirty(leaf);
2398 inode_add_bytes(inode, len);
2399 btrfs_release_path(path);
2400
2401 ret = btrfs_inc_extent_ref(trans, root, new->bytenr,
2402 new->disk_len, 0,
2403 backref->root_id, backref->inum,
2404 new->file_pos, 0);
2405 if (ret) {
2406 btrfs_abort_transaction(trans, root, ret);
2407 goto out_free_path;
2408 }
2409
2410 ret = 1;
2411out_free_path:
2412 btrfs_release_path(path);
2413 path->leave_spinning = 0;
2414 btrfs_end_transaction(trans, root);
2415out_unlock:
2416 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
2417 &cached, GFP_NOFS);
2418 iput(inode);
2419 return ret;
2420}
2421
2422static void relink_file_extents(struct new_sa_defrag_extent *new)
2423{
2424 struct btrfs_path *path;
2425 struct old_sa_defrag_extent *old, *tmp;
2426 struct sa_defrag_extent_backref *backref;
2427 struct sa_defrag_extent_backref *prev = NULL;
2428 struct inode *inode;
2429 struct btrfs_root *root;
2430 struct rb_node *node;
2431 int ret;
2432
2433 inode = new->inode;
2434 root = BTRFS_I(inode)->root;
2435
2436 path = btrfs_alloc_path();
2437 if (!path)
2438 return;
2439
2440 if (!record_extent_backrefs(path, new)) {
2441 btrfs_free_path(path);
2442 goto out;
2443 }
2444 btrfs_release_path(path);
2445
2446 while (1) {
2447 node = rb_first(&new->root);
2448 if (!node)
2449 break;
2450 rb_erase(node, &new->root);
2451
2452 backref = rb_entry(node, struct sa_defrag_extent_backref, node);
2453
2454 ret = relink_extent_backref(path, prev, backref);
2455 WARN_ON(ret < 0);
2456
2457 kfree(prev);
2458
2459 if (ret == 1)
2460 prev = backref;
2461 else
2462 prev = NULL;
2463 cond_resched();
2464 }
2465 kfree(prev);
2466
2467 btrfs_free_path(path);
2468
2469 list_for_each_entry_safe(old, tmp, &new->head, list) {
2470 list_del(&old->list);
2471 kfree(old);
2472 }
2473out:
2474 atomic_dec(&root->fs_info->defrag_running);
2475 wake_up(&root->fs_info->transaction_wait);
2476
2477 kfree(new);
2478}
2479
2480static struct new_sa_defrag_extent *
2481record_old_file_extents(struct inode *inode,
2482 struct btrfs_ordered_extent *ordered)
2483{
2484 struct btrfs_root *root = BTRFS_I(inode)->root;
2485 struct btrfs_path *path;
2486 struct btrfs_key key;
2487 struct old_sa_defrag_extent *old, *tmp;
2488 struct new_sa_defrag_extent *new;
2489 int ret;
2490
2491 new = kmalloc(sizeof(*new), GFP_NOFS);
2492 if (!new)
2493 return NULL;
2494
2495 new->inode = inode;
2496 new->file_pos = ordered->file_offset;
2497 new->len = ordered->len;
2498 new->bytenr = ordered->start;
2499 new->disk_len = ordered->disk_len;
2500 new->compress_type = ordered->compress_type;
2501 new->root = RB_ROOT;
2502 INIT_LIST_HEAD(&new->head);
2503
2504 path = btrfs_alloc_path();
2505 if (!path)
2506 goto out_kfree;
2507
2508 key.objectid = btrfs_ino(inode);
2509 key.type = BTRFS_EXTENT_DATA_KEY;
2510 key.offset = new->file_pos;
2511
2512 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2513 if (ret < 0)
2514 goto out_free_path;
2515 if (ret > 0 && path->slots[0] > 0)
2516 path->slots[0]--;
2517
2518
2519 while (1) {
2520 struct btrfs_file_extent_item *extent;
2521 struct extent_buffer *l;
2522 int slot;
2523 u64 num_bytes;
2524 u64 offset;
2525 u64 end;
2526 u64 disk_bytenr;
2527 u64 extent_offset;
2528
2529 l = path->nodes[0];
2530 slot = path->slots[0];
2531
2532 if (slot >= btrfs_header_nritems(l)) {
2533 ret = btrfs_next_leaf(root, path);
2534 if (ret < 0)
2535 goto out_free_list;
2536 else if (ret > 0)
2537 break;
2538 continue;
2539 }
2540
2541 btrfs_item_key_to_cpu(l, &key, slot);
2542
2543 if (key.objectid != btrfs_ino(inode))
2544 break;
2545 if (key.type != BTRFS_EXTENT_DATA_KEY)
2546 break;
2547 if (key.offset >= new->file_pos + new->len)
2548 break;
2549
2550 extent = btrfs_item_ptr(l, slot, struct btrfs_file_extent_item);
2551
2552 num_bytes = btrfs_file_extent_num_bytes(l, extent);
2553 if (key.offset + num_bytes < new->file_pos)
2554 goto next;
2555
2556 disk_bytenr = btrfs_file_extent_disk_bytenr(l, extent);
2557 if (!disk_bytenr)
2558 goto next;
2559
2560 extent_offset = btrfs_file_extent_offset(l, extent);
2561
2562 old = kmalloc(sizeof(*old), GFP_NOFS);
2563 if (!old)
2564 goto out_free_list;
2565
2566 offset = max(new->file_pos, key.offset);
2567 end = min(new->file_pos + new->len, key.offset + num_bytes);
2568
2569 old->bytenr = disk_bytenr;
2570 old->extent_offset = extent_offset;
2571 old->offset = offset - key.offset;
2572 old->len = end - offset;
2573 old->new = new;
2574 old->count = 0;
2575 list_add_tail(&old->list, &new->head);
2576next:
2577 path->slots[0]++;
2578 cond_resched();
2579 }
2580
2581 btrfs_free_path(path);
2582 atomic_inc(&root->fs_info->defrag_running);
2583
2584 return new;
2585
2586out_free_list:
2587 list_for_each_entry_safe(old, tmp, &new->head, list) {
2588 list_del(&old->list);
2589 kfree(old);
2590 }
2591out_free_path:
2592 btrfs_free_path(path);
2593out_kfree:
2594 kfree(new);
2595 return NULL;
2596}
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
2609{
2610 struct inode *inode = ordered_extent->inode;
2611 struct btrfs_root *root = BTRFS_I(inode)->root;
2612 struct btrfs_trans_handle *trans = NULL;
2613 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2614 struct extent_state *cached_state = NULL;
2615 struct new_sa_defrag_extent *new = NULL;
2616 int compress_type = 0;
2617 int ret;
2618 bool nolock;
2619
2620 nolock = btrfs_is_free_space_inode(inode);
2621
2622 if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
2623 ret = -EIO;
2624 goto out;
2625 }
2626
2627 if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
2628 BUG_ON(!list_empty(&ordered_extent->list));
2629 btrfs_ordered_update_i_size(inode, 0, ordered_extent);
2630 if (nolock)
2631 trans = btrfs_join_transaction_nolock(root);
2632 else
2633 trans = btrfs_join_transaction(root);
2634 if (IS_ERR(trans)) {
2635 ret = PTR_ERR(trans);
2636 trans = NULL;
2637 goto out;
2638 }
2639 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
2640 ret = btrfs_update_inode_fallback(trans, root, inode);
2641 if (ret)
2642 btrfs_abort_transaction(trans, root, ret);
2643 goto out;
2644 }
2645
2646 lock_extent_bits(io_tree, ordered_extent->file_offset,
2647 ordered_extent->file_offset + ordered_extent->len - 1,
2648 0, &cached_state);
2649
2650 ret = test_range_bit(io_tree, ordered_extent->file_offset,
2651 ordered_extent->file_offset + ordered_extent->len - 1,
2652 EXTENT_DEFRAG, 1, cached_state);
2653 if (ret) {
2654 u64 last_snapshot = btrfs_root_last_snapshot(&root->root_item);
2655 if (last_snapshot >= BTRFS_I(inode)->generation)
2656
2657 new = record_old_file_extents(inode, ordered_extent);
2658
2659 clear_extent_bit(io_tree, ordered_extent->file_offset,
2660 ordered_extent->file_offset + ordered_extent->len - 1,
2661 EXTENT_DEFRAG, 0, 0, &cached_state, GFP_NOFS);
2662 }
2663
2664 if (nolock)
2665 trans = btrfs_join_transaction_nolock(root);
2666 else
2667 trans = btrfs_join_transaction(root);
2668 if (IS_ERR(trans)) {
2669 ret = PTR_ERR(trans);
2670 trans = NULL;
2671 goto out_unlock;
2672 }
2673 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
2674
2675 if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
2676 compress_type = ordered_extent->compress_type;
2677 if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
2678 BUG_ON(compress_type);
2679 ret = btrfs_mark_extent_written(trans, inode,
2680 ordered_extent->file_offset,
2681 ordered_extent->file_offset +
2682 ordered_extent->len);
2683 } else {
2684 BUG_ON(root == root->fs_info->tree_root);
2685 ret = insert_reserved_file_extent(trans, inode,
2686 ordered_extent->file_offset,
2687 ordered_extent->start,
2688 ordered_extent->disk_len,
2689 ordered_extent->len,
2690 ordered_extent->len,
2691 compress_type, 0, 0,
2692 BTRFS_FILE_EXTENT_REG);
2693 }
2694 unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
2695 ordered_extent->file_offset, ordered_extent->len,
2696 trans->transid);
2697 if (ret < 0) {
2698 btrfs_abort_transaction(trans, root, ret);
2699 goto out_unlock;
2700 }
2701
2702 add_pending_csums(trans, inode, ordered_extent->file_offset,
2703 &ordered_extent->list);
2704
2705 btrfs_ordered_update_i_size(inode, 0, ordered_extent);
2706 ret = btrfs_update_inode_fallback(trans, root, inode);
2707 if (ret) {
2708 btrfs_abort_transaction(trans, root, ret);
2709 goto out_unlock;
2710 }
2711 ret = 0;
2712out_unlock:
2713 unlock_extent_cached(io_tree, ordered_extent->file_offset,
2714 ordered_extent->file_offset +
2715 ordered_extent->len - 1, &cached_state, GFP_NOFS);
2716out:
2717 if (root != root->fs_info->tree_root)
2718 btrfs_delalloc_release_metadata(inode, ordered_extent->len);
2719 if (trans)
2720 btrfs_end_transaction(trans, root);
2721
2722 if (ret) {
2723 clear_extent_uptodate(io_tree, ordered_extent->file_offset,
2724 ordered_extent->file_offset +
2725 ordered_extent->len - 1, NULL, GFP_NOFS);
2726
2727
2728
2729
2730
2731
2732 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags) &&
2733 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags))
2734 btrfs_free_reserved_extent(root, ordered_extent->start,
2735 ordered_extent->disk_len);
2736 }
2737
2738
2739
2740
2741
2742
2743 btrfs_remove_ordered_extent(inode, ordered_extent);
2744
2745
2746 if (new)
2747 relink_file_extents(new);
2748
2749
2750 btrfs_put_ordered_extent(ordered_extent);
2751
2752 btrfs_put_ordered_extent(ordered_extent);
2753
2754 return ret;
2755}
2756
2757static void finish_ordered_fn(struct btrfs_work *work)
2758{
2759 struct btrfs_ordered_extent *ordered_extent;
2760 ordered_extent = container_of(work, struct btrfs_ordered_extent, work);
2761 btrfs_finish_ordered_io(ordered_extent);
2762}
2763
2764static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
2765 struct extent_state *state, int uptodate)
2766{
2767 struct inode *inode = page->mapping->host;
2768 struct btrfs_root *root = BTRFS_I(inode)->root;
2769 struct btrfs_ordered_extent *ordered_extent = NULL;
2770 struct btrfs_workers *workers;
2771
2772 trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
2773
2774 ClearPagePrivate2(page);
2775 if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
2776 end - start + 1, uptodate))
2777 return 0;
2778
2779 ordered_extent->work.func = finish_ordered_fn;
2780 ordered_extent->work.flags = 0;
2781
2782 if (btrfs_is_free_space_inode(inode))
2783 workers = &root->fs_info->endio_freespace_worker;
2784 else
2785 workers = &root->fs_info->endio_write_workers;
2786 btrfs_queue_worker(workers, &ordered_extent->work);
2787
2788 return 0;
2789}
2790
2791
2792
2793
2794
2795
2796static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
2797 struct extent_state *state, int mirror)
2798{
2799 size_t offset = start - page_offset(page);
2800 struct inode *inode = page->mapping->host;
2801 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
2802 char *kaddr;
2803 u64 private = ~(u32)0;
2804 int ret;
2805 struct btrfs_root *root = BTRFS_I(inode)->root;
2806 u32 csum = ~(u32)0;
2807 static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL,
2808 DEFAULT_RATELIMIT_BURST);
2809
2810 if (PageChecked(page)) {
2811 ClearPageChecked(page);
2812 goto good;
2813 }
2814
2815 if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
2816 goto good;
2817
2818 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
2819 test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
2820 clear_extent_bits(io_tree, start, end, EXTENT_NODATASUM,
2821 GFP_NOFS);
2822 return 0;
2823 }
2824
2825 if (state && state->start == start) {
2826 private = state->private;
2827 ret = 0;
2828 } else {
2829 ret = get_state_private(io_tree, start, &private);
2830 }
2831 kaddr = kmap_atomic(page);
2832 if (ret)
2833 goto zeroit;
2834
2835 csum = btrfs_csum_data(kaddr + offset, csum, end - start + 1);
2836 btrfs_csum_final(csum, (char *)&csum);
2837 if (csum != private)
2838 goto zeroit;
2839
2840 kunmap_atomic(kaddr);
2841good:
2842 return 0;
2843
2844zeroit:
2845 if (__ratelimit(&_rs))
2846 btrfs_info(root->fs_info, "csum failed ino %llu off %llu csum %u private %llu",
2847 (unsigned long long)btrfs_ino(page->mapping->host),
2848 (unsigned long long)start, csum,
2849 (unsigned long long)private);
2850 memset(kaddr + offset, 1, end - start + 1);
2851 flush_dcache_page(page);
2852 kunmap_atomic(kaddr);
2853 if (private == 0)
2854 return 0;
2855 return -EIO;
2856}
2857
2858struct delayed_iput {
2859 struct list_head list;
2860 struct inode *inode;
2861};
2862
2863
2864
2865void btrfs_add_delayed_iput(struct inode *inode)
2866{
2867 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
2868 struct delayed_iput *delayed;
2869
2870 if (atomic_add_unless(&inode->i_count, -1, 1))
2871 return;
2872
2873 delayed = kmalloc(sizeof(*delayed), GFP_NOFS | __GFP_NOFAIL);
2874 delayed->inode = inode;
2875
2876 spin_lock(&fs_info->delayed_iput_lock);
2877 list_add_tail(&delayed->list, &fs_info->delayed_iputs);
2878 spin_unlock(&fs_info->delayed_iput_lock);
2879}
2880
2881void btrfs_run_delayed_iputs(struct btrfs_root *root)
2882{
2883 LIST_HEAD(list);
2884 struct btrfs_fs_info *fs_info = root->fs_info;
2885 struct delayed_iput *delayed;
2886 int empty;
2887
2888 spin_lock(&fs_info->delayed_iput_lock);
2889 empty = list_empty(&fs_info->delayed_iputs);
2890 spin_unlock(&fs_info->delayed_iput_lock);
2891 if (empty)
2892 return;
2893
2894 spin_lock(&fs_info->delayed_iput_lock);
2895 list_splice_init(&fs_info->delayed_iputs, &list);
2896 spin_unlock(&fs_info->delayed_iput_lock);
2897
2898 while (!list_empty(&list)) {
2899 delayed = list_entry(list.next, struct delayed_iput, list);
2900 list_del(&delayed->list);
2901 iput(delayed->inode);
2902 kfree(delayed);
2903 }
2904}
2905
2906
2907
2908
2909
2910
2911void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
2912 struct btrfs_root *root)
2913{
2914 struct btrfs_block_rsv *block_rsv;
2915 int ret;
2916
2917 if (atomic_read(&root->orphan_inodes) ||
2918 root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
2919 return;
2920
2921 spin_lock(&root->orphan_lock);
2922 if (atomic_read(&root->orphan_inodes)) {
2923 spin_unlock(&root->orphan_lock);
2924 return;
2925 }
2926
2927 if (root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE) {
2928 spin_unlock(&root->orphan_lock);
2929 return;
2930 }
2931
2932 block_rsv = root->orphan_block_rsv;
2933 root->orphan_block_rsv = NULL;
2934 spin_unlock(&root->orphan_lock);
2935
2936 if (root->orphan_item_inserted &&
2937 btrfs_root_refs(&root->root_item) > 0) {
2938 ret = btrfs_del_orphan_item(trans, root->fs_info->tree_root,
2939 root->root_key.objectid);
2940 BUG_ON(ret);
2941 root->orphan_item_inserted = 0;
2942 }
2943
2944 if (block_rsv) {
2945 WARN_ON(block_rsv->size > 0);
2946 btrfs_free_block_rsv(root, block_rsv);
2947 }
2948}
2949
2950
2951
2952
2953
2954
2955
2956
2957int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
2958{
2959 struct btrfs_root *root = BTRFS_I(inode)->root;
2960 struct btrfs_block_rsv *block_rsv = NULL;
2961 int reserve = 0;
2962 int insert = 0;
2963 int ret;
2964
2965 if (!root->orphan_block_rsv) {
2966 block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
2967 if (!block_rsv)
2968 return -ENOMEM;
2969 }
2970
2971 spin_lock(&root->orphan_lock);
2972 if (!root->orphan_block_rsv) {
2973 root->orphan_block_rsv = block_rsv;
2974 } else if (block_rsv) {
2975 btrfs_free_block_rsv(root, block_rsv);
2976 block_rsv = NULL;
2977 }
2978
2979 if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
2980 &BTRFS_I(inode)->runtime_flags)) {
2981#if 0
2982
2983
2984
2985
2986
2987 if (!xchg(&root->orphan_item_inserted, 1))
2988 insert = 2;
2989 else
2990 insert = 1;
2991#endif
2992 insert = 1;
2993 atomic_inc(&root->orphan_inodes);
2994 }
2995
2996 if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
2997 &BTRFS_I(inode)->runtime_flags))
2998 reserve = 1;
2999 spin_unlock(&root->orphan_lock);
3000
3001
3002 if (reserve) {
3003 ret = btrfs_orphan_reserve_metadata(trans, inode);
3004 BUG_ON(ret);
3005 }
3006
3007
3008 if (insert >= 1) {
3009 ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
3010 if (ret && ret != -EEXIST) {
3011 clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3012 &BTRFS_I(inode)->runtime_flags);
3013 btrfs_abort_transaction(trans, root, ret);
3014 return ret;
3015 }
3016 ret = 0;
3017 }
3018
3019
3020 if (insert >= 2) {
3021 ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root,
3022 root->root_key.objectid);
3023 if (ret && ret != -EEXIST) {
3024 btrfs_abort_transaction(trans, root, ret);
3025 return ret;
3026 }
3027 }
3028 return 0;
3029}
3030
3031
3032
3033
3034
3035static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
3036 struct inode *inode)
3037{
3038 struct btrfs_root *root = BTRFS_I(inode)->root;
3039 int delete_item = 0;
3040 int release_rsv = 0;
3041 int ret = 0;
3042
3043 spin_lock(&root->orphan_lock);
3044 if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3045 &BTRFS_I(inode)->runtime_flags))
3046 delete_item = 1;
3047
3048 if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
3049 &BTRFS_I(inode)->runtime_flags))
3050 release_rsv = 1;
3051 spin_unlock(&root->orphan_lock);
3052
3053 if (trans && delete_item) {
3054 ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
3055 BUG_ON(ret);
3056 }
3057
3058 if (release_rsv) {
3059 btrfs_orphan_release_metadata(inode);
3060 atomic_dec(&root->orphan_inodes);
3061 }
3062
3063 return 0;
3064}
3065
3066
3067
3068
3069
3070int btrfs_orphan_cleanup(struct btrfs_root *root)
3071{
3072 struct btrfs_path *path;
3073 struct extent_buffer *leaf;
3074 struct btrfs_key key, found_key;
3075 struct btrfs_trans_handle *trans;
3076 struct inode *inode;
3077 u64 last_objectid = 0;
3078 int ret = 0, nr_unlink = 0, nr_truncate = 0;
3079
3080 if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
3081 return 0;
3082
3083 path = btrfs_alloc_path();
3084 if (!path) {
3085 ret = -ENOMEM;
3086 goto out;
3087 }
3088 path->reada = -1;
3089
3090 key.objectid = BTRFS_ORPHAN_OBJECTID;
3091 btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
3092 key.offset = (u64)-1;
3093
3094 while (1) {
3095 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3096 if (ret < 0)
3097 goto out;
3098
3099
3100
3101
3102
3103
3104 if (ret > 0) {
3105 ret = 0;
3106 if (path->slots[0] == 0)
3107 break;
3108 path->slots[0]--;
3109 }
3110
3111
3112 leaf = path->nodes[0];
3113 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
3114
3115
3116 if (found_key.objectid != BTRFS_ORPHAN_OBJECTID)
3117 break;
3118 if (btrfs_key_type(&found_key) != BTRFS_ORPHAN_ITEM_KEY)
3119 break;
3120
3121
3122 btrfs_release_path(path);
3123
3124
3125
3126
3127
3128
3129
3130 if (found_key.offset == last_objectid) {
3131 btrfs_err(root->fs_info,
3132 "Error removing orphan entry, stopping orphan cleanup");
3133 ret = -EINVAL;
3134 goto out;
3135 }
3136
3137 last_objectid = found_key.offset;
3138
3139 found_key.objectid = found_key.offset;
3140 found_key.type = BTRFS_INODE_ITEM_KEY;
3141 found_key.offset = 0;
3142 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
3143 ret = PTR_RET(inode);
3144 if (ret && ret != -ESTALE)
3145 goto out;
3146
3147 if (ret == -ESTALE && root == root->fs_info->tree_root) {
3148 struct btrfs_root *dead_root;
3149 struct btrfs_fs_info *fs_info = root->fs_info;
3150 int is_dead_root = 0;
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163 spin_lock(&fs_info->trans_lock);
3164 list_for_each_entry(dead_root, &fs_info->dead_roots,
3165 root_list) {
3166 if (dead_root->root_key.objectid ==
3167 found_key.objectid) {
3168 is_dead_root = 1;
3169 break;
3170 }
3171 }
3172 spin_unlock(&fs_info->trans_lock);
3173 if (is_dead_root) {
3174
3175 key.offset = found_key.objectid - 1;
3176 continue;
3177 }
3178 }
3179
3180
3181
3182
3183 if (ret == -ESTALE) {
3184 trans = btrfs_start_transaction(root, 1);
3185 if (IS_ERR(trans)) {
3186 ret = PTR_ERR(trans);
3187 goto out;
3188 }
3189 btrfs_debug(root->fs_info, "auto deleting %Lu",
3190 found_key.objectid);
3191 ret = btrfs_del_orphan_item(trans, root,
3192 found_key.objectid);
3193 BUG_ON(ret);
3194 btrfs_end_transaction(trans, root);
3195 continue;
3196 }
3197
3198
3199
3200
3201
3202 set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
3203 &BTRFS_I(inode)->runtime_flags);
3204 atomic_inc(&root->orphan_inodes);
3205
3206
3207 if (inode->i_nlink) {
3208 if (!S_ISREG(inode->i_mode)) {
3209 WARN_ON(1);
3210 iput(inode);
3211 continue;
3212 }
3213 nr_truncate++;
3214
3215
3216 trans = btrfs_start_transaction(root, 1);
3217 if (IS_ERR(trans)) {
3218 ret = PTR_ERR(trans);
3219 goto out;
3220 }
3221 ret = btrfs_orphan_add(trans, inode);
3222 btrfs_end_transaction(trans, root);
3223 if (ret)
3224 goto out;
3225
3226 ret = btrfs_truncate(inode);
3227 if (ret)
3228 btrfs_orphan_del(NULL, inode);
3229 } else {
3230 nr_unlink++;
3231 }
3232
3233
3234 iput(inode);
3235 if (ret)
3236 goto out;
3237 }
3238
3239 btrfs_release_path(path);
3240
3241 root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
3242
3243 if (root->orphan_block_rsv)
3244 btrfs_block_rsv_release(root, root->orphan_block_rsv,
3245 (u64)-1);
3246
3247 if (root->orphan_block_rsv || root->orphan_item_inserted) {
3248 trans = btrfs_join_transaction(root);
3249 if (!IS_ERR(trans))
3250 btrfs_end_transaction(trans, root);
3251 }
3252
3253 if (nr_unlink)
3254 btrfs_debug(root->fs_info, "unlinked %d orphans", nr_unlink);
3255 if (nr_truncate)
3256 btrfs_debug(root->fs_info, "truncated %d orphans", nr_truncate);
3257
3258out:
3259 if (ret)
3260 btrfs_crit(root->fs_info,
3261 "could not do orphan cleanup %d", ret);
3262 btrfs_free_path(path);
3263 return ret;
3264}
3265
3266
3267
3268
3269
3270
3271
3272static noinline int acls_after_inode_item(struct extent_buffer *leaf,
3273 int slot, u64 objectid)
3274{
3275 u32 nritems = btrfs_header_nritems(leaf);
3276 struct btrfs_key found_key;
3277 int scanned = 0;
3278
3279 slot++;
3280 while (slot < nritems) {
3281 btrfs_item_key_to_cpu(leaf, &found_key, slot);
3282
3283
3284 if (found_key.objectid != objectid)
3285 return 0;
3286
3287
3288 if (found_key.type == BTRFS_XATTR_ITEM_KEY)
3289 return 1;
3290
3291
3292
3293
3294
3295 if (found_key.type > BTRFS_XATTR_ITEM_KEY)
3296 return 0;
3297
3298 slot++;
3299 scanned++;
3300
3301
3302
3303
3304
3305
3306
3307 if (scanned >= 8)
3308 break;
3309 }
3310
3311
3312
3313
3314 return 1;
3315}
3316
3317
3318
3319
3320static void btrfs_read_locked_inode(struct inode *inode)
3321{
3322 struct btrfs_path *path;
3323 struct extent_buffer *leaf;
3324 struct btrfs_inode_item *inode_item;
3325 struct btrfs_timespec *tspec;
3326 struct btrfs_root *root = BTRFS_I(inode)->root;
3327 struct btrfs_key location;
3328 int maybe_acls;
3329 u32 rdev;
3330 int ret;
3331 bool filled = false;
3332
3333 ret = btrfs_fill_inode(inode, &rdev);
3334 if (!ret)
3335 filled = true;
3336
3337 path = btrfs_alloc_path();
3338 if (!path)
3339 goto make_bad;
3340
3341 path->leave_spinning = 1;
3342 memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
3343
3344 ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
3345 if (ret)
3346 goto make_bad;
3347
3348 leaf = path->nodes[0];
3349
3350 if (filled)
3351 goto cache_acl;
3352
3353 inode_item = btrfs_item_ptr(leaf, path->slots[0],
3354 struct btrfs_inode_item);
3355 inode->i_mode = btrfs_inode_mode(leaf, inode_item);
3356 set_nlink(inode, btrfs_inode_nlink(leaf, inode_item));
3357 i_uid_write(inode, btrfs_inode_uid(leaf, inode_item));
3358 i_gid_write(inode, btrfs_inode_gid(leaf, inode_item));
3359 btrfs_i_size_write(inode, btrfs_inode_size(leaf, inode_item));
3360
3361 tspec = btrfs_inode_atime(inode_item);
3362 inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, tspec);
3363 inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
3364
3365 tspec = btrfs_inode_mtime(inode_item);
3366 inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, tspec);
3367 inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
3368
3369 tspec = btrfs_inode_ctime(inode_item);
3370 inode->i_ctime.tv_sec = btrfs_timespec_sec(leaf, tspec);
3371 inode->i_ctime.tv_nsec = btrfs_timespec_nsec(leaf, tspec);
3372
3373 inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
3374 BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
3375 BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);
3376
3377
3378
3379
3380
3381
3382
3383 if (BTRFS_I(inode)->last_trans == root->fs_info->generation)
3384 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3385 &BTRFS_I(inode)->runtime_flags);
3386
3387 inode->i_version = btrfs_inode_sequence(leaf, inode_item);
3388 inode->i_generation = BTRFS_I(inode)->generation;
3389 inode->i_rdev = 0;
3390 rdev = btrfs_inode_rdev(leaf, inode_item);
3391
3392 BTRFS_I(inode)->index_cnt = (u64)-1;
3393 BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
3394cache_acl:
3395
3396
3397
3398
3399 maybe_acls = acls_after_inode_item(leaf, path->slots[0],
3400 btrfs_ino(inode));
3401 if (!maybe_acls)
3402 cache_no_acl(inode);
3403
3404 btrfs_free_path(path);
3405
3406 switch (inode->i_mode & S_IFMT) {
3407 case S_IFREG:
3408 inode->i_mapping->a_ops = &btrfs_aops;
3409 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
3410 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
3411 inode->i_fop = &btrfs_file_operations;
3412 inode->i_op = &btrfs_file_inode_operations;
3413 break;
3414 case S_IFDIR:
3415 inode->i_fop = &btrfs_dir_file_operations;
3416 if (root == root->fs_info->tree_root)
3417 inode->i_op = &btrfs_dir_ro_inode_operations;
3418 else
3419 inode->i_op = &btrfs_dir_inode_operations;
3420 break;
3421 case S_IFLNK:
3422 inode->i_op = &btrfs_symlink_inode_operations;
3423 inode->i_mapping->a_ops = &btrfs_symlink_aops;
3424 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
3425 break;
3426 default:
3427 inode->i_op = &btrfs_special_inode_operations;
3428 init_special_inode(inode, inode->i_mode, rdev);
3429 break;
3430 }
3431
3432 btrfs_update_iflags(inode);
3433 return;
3434
3435make_bad:
3436 btrfs_free_path(path);
3437 make_bad_inode(inode);
3438}
3439
3440
3441
3442
3443static void fill_inode_item(struct btrfs_trans_handle *trans,
3444 struct extent_buffer *leaf,
3445 struct btrfs_inode_item *item,
3446 struct inode *inode)
3447{
3448 struct btrfs_map_token token;
3449
3450 btrfs_init_map_token(&token);
3451
3452 btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
3453 btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
3454 btrfs_set_token_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size,
3455 &token);
3456 btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
3457 btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
3458
3459 btrfs_set_token_timespec_sec(leaf, btrfs_inode_atime(item),
3460 inode->i_atime.tv_sec, &token);
3461 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_atime(item),
3462 inode->i_atime.tv_nsec, &token);
3463
3464 btrfs_set_token_timespec_sec(leaf, btrfs_inode_mtime(item),
3465 inode->i_mtime.tv_sec, &token);
3466 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_mtime(item),
3467 inode->i_mtime.tv_nsec, &token);
3468
3469 btrfs_set_token_timespec_sec(leaf, btrfs_inode_ctime(item),
3470 inode->i_ctime.tv_sec, &token);
3471 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_ctime(item),
3472 inode->i_ctime.tv_nsec, &token);
3473
3474 btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
3475 &token);
3476 btrfs_set_token_inode_generation(leaf, item, BTRFS_I(inode)->generation,
3477 &token);
3478 btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
3479 btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
3480 btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
3481 btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
3482 btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3483}
3484
3485
3486
3487
3488static noinline int btrfs_update_inode_item(struct btrfs_trans_handle *trans,
3489 struct btrfs_root *root, struct inode *inode)
3490{
3491 struct btrfs_inode_item *inode_item;
3492 struct btrfs_path *path;
3493 struct extent_buffer *leaf;
3494 int ret;
3495
3496 path = btrfs_alloc_path();
3497 if (!path)
3498 return -ENOMEM;
3499
3500 path->leave_spinning = 1;
3501 ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
3502 1);
3503 if (ret) {
3504 if (ret > 0)
3505 ret = -ENOENT;
3506 goto failed;
3507 }
3508
3509 btrfs_unlock_up_safe(path, 1);
3510 leaf = path->nodes[0];
3511 inode_item = btrfs_item_ptr(leaf, path->slots[0],
3512 struct btrfs_inode_item);
3513
3514 fill_inode_item(trans, leaf, inode_item, inode);
3515 btrfs_mark_buffer_dirty(leaf);
3516 btrfs_set_inode_last_trans(trans, inode);
3517 ret = 0;
3518failed:
3519 btrfs_free_path(path);
3520 return ret;
3521}
3522
3523
3524
3525
3526noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
3527 struct btrfs_root *root, struct inode *inode)
3528{
3529 int ret;
3530
3531
3532
3533
3534
3535
3536
3537
3538 if (!btrfs_is_free_space_inode(inode)
3539 && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
3540 btrfs_update_root_times(trans, root);
3541
3542 ret = btrfs_delayed_update_inode(trans, root, inode);
3543 if (!ret)
3544 btrfs_set_inode_last_trans(trans, inode);
3545 return ret;
3546 }
3547
3548 return btrfs_update_inode_item(trans, root, inode);
3549}
3550
3551noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
3552 struct btrfs_root *root,
3553 struct inode *inode)
3554{
3555 int ret;
3556
3557 ret = btrfs_update_inode(trans, root, inode);
3558 if (ret == -ENOSPC)
3559 return btrfs_update_inode_item(trans, root, inode);
3560 return ret;
3561}
3562
3563
3564
3565
3566
3567
3568static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3569 struct btrfs_root *root,
3570 struct inode *dir, struct inode *inode,
3571 const char *name, int name_len)
3572{
3573 struct btrfs_path *path;
3574 int ret = 0;
3575 struct extent_buffer *leaf;
3576 struct btrfs_dir_item *di;
3577 struct btrfs_key key;
3578 u64 index;
3579 u64 ino = btrfs_ino(inode);
3580 u64 dir_ino = btrfs_ino(dir);
3581
3582 path = btrfs_alloc_path();
3583 if (!path) {
3584 ret = -ENOMEM;
3585 goto out;
3586 }
3587
3588 path->leave_spinning = 1;
3589 di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3590 name, name_len, -1);
3591 if (IS_ERR(di)) {
3592 ret = PTR_ERR(di);
3593 goto err;
3594 }
3595 if (!di) {
3596 ret = -ENOENT;
3597 goto err;
3598 }
3599 leaf = path->nodes[0];
3600 btrfs_dir_item_key_to_cpu(leaf, di, &key);
3601 ret = btrfs_delete_one_dir_name(trans, root, path, di);
3602 if (ret)
3603 goto err;
3604 btrfs_release_path(path);
3605
3606 ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
3607 dir_ino, &index);
3608 if (ret) {
3609 btrfs_info(root->fs_info,
3610 "failed to delete reference to %.*s, inode %llu parent %llu",
3611 name_len, name,
3612 (unsigned long long)ino, (unsigned long long)dir_ino);
3613 btrfs_abort_transaction(trans, root, ret);
3614 goto err;
3615 }
3616
3617 ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3618 if (ret) {
3619 btrfs_abort_transaction(trans, root, ret);
3620 goto err;
3621 }
3622
3623 ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
3624 inode, dir_ino);
3625 if (ret != 0 && ret != -ENOENT) {
3626 btrfs_abort_transaction(trans, root, ret);
3627 goto err;
3628 }
3629
3630 ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
3631 dir, index);
3632 if (ret == -ENOENT)
3633 ret = 0;
3634 else if (ret)
3635 btrfs_abort_transaction(trans, root, ret);
3636err:
3637 btrfs_free_path(path);
3638 if (ret)
3639 goto out;
3640
3641 btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3642 inode_inc_iversion(inode);
3643 inode_inc_iversion(dir);
3644 inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3645 ret = btrfs_update_inode(trans, root, dir);
3646out:
3647 return ret;
3648}
3649
3650int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
3651 struct btrfs_root *root,
3652 struct inode *dir, struct inode *inode,
3653 const char *name, int name_len)
3654{
3655 int ret;
3656 ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
3657 if (!ret) {
3658 btrfs_drop_nlink(inode);
3659 ret = btrfs_update_inode(trans, root, inode);
3660 }
3661 return ret;
3662}
3663
3664
3665
3666static int check_path_shared(struct btrfs_root *root,
3667 struct btrfs_path *path)
3668{
3669 struct extent_buffer *eb;
3670 int level;
3671 u64 refs = 1;
3672
3673 for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
3674 int ret;
3675
3676 if (!path->nodes[level])
3677 break;
3678 eb = path->nodes[level];
3679 if (!btrfs_block_can_be_shared(root, eb))
3680 continue;
3681 ret = btrfs_lookup_extent_info(NULL, root, eb->start, level, 1,
3682 &refs, NULL);
3683 if (refs > 1)
3684 return 1;
3685 }
3686 return 0;
3687}
3688
3689
3690
3691
3692
3693
3694
3695
3696static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
3697 struct dentry *dentry)
3698{
3699 struct btrfs_trans_handle *trans;
3700 struct btrfs_root *root = BTRFS_I(dir)->root;
3701 struct btrfs_path *path;
3702 struct btrfs_dir_item *di;
3703 struct inode *inode = dentry->d_inode;
3704 u64 index;
3705 int check_link = 1;
3706 int err = -ENOSPC;
3707 int ret;
3708 u64 ino = btrfs_ino(inode);
3709 u64 dir_ino = btrfs_ino(dir);
3710
3711
3712
3713
3714
3715
3716
3717
3718 trans = btrfs_start_transaction(root, 5);
3719 if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
3720 return trans;
3721
3722 if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
3723 return ERR_PTR(-ENOSPC);
3724
3725
3726 if (S_ISDIR(inode->i_mode) && atomic_read(&inode->i_count) > 1)
3727 return ERR_PTR(-ENOSPC);
3728
3729 if (atomic_read(&inode->i_count) > 2)
3730 return ERR_PTR(-ENOSPC);
3731
3732 if (xchg(&root->fs_info->enospc_unlink, 1))
3733 return ERR_PTR(-ENOSPC);
3734
3735 path = btrfs_alloc_path();
3736 if (!path) {
3737 root->fs_info->enospc_unlink = 0;
3738 return ERR_PTR(-ENOMEM);
3739 }
3740
3741
3742 trans = btrfs_start_transaction(root, 1);
3743 if (IS_ERR(trans)) {
3744 btrfs_free_path(path);
3745 root->fs_info->enospc_unlink = 0;
3746 return trans;
3747 }
3748
3749 path->skip_locking = 1;
3750 path->search_commit_root = 1;
3751
3752 ret = btrfs_lookup_inode(trans, root, path,
3753 &BTRFS_I(dir)->location, 0);
3754 if (ret < 0) {
3755 err = ret;
3756 goto out;
3757 }
3758 if (ret == 0) {
3759 if (check_path_shared(root, path))
3760 goto out;
3761 } else {
3762 check_link = 0;
3763 }
3764 btrfs_release_path(path);
3765
3766 ret = btrfs_lookup_inode(trans, root, path,
3767 &BTRFS_I(inode)->location, 0);
3768 if (ret < 0) {
3769 err = ret;
3770 goto out;
3771 }
3772 if (ret == 0) {
3773 if (check_path_shared(root, path))
3774 goto out;
3775 } else {
3776 check_link = 0;
3777 }
3778 btrfs_release_path(path);
3779
3780 if (ret == 0 && S_ISREG(inode->i_mode)) {
3781 ret = btrfs_lookup_file_extent(trans, root, path,
3782 ino, (u64)-1, 0);
3783 if (ret < 0) {
3784 err = ret;
3785 goto out;
3786 }
3787 BUG_ON(ret == 0);
3788 if (check_path_shared(root, path))
3789 goto out;
3790 btrfs_release_path(path);
3791 }
3792
3793 if (!check_link) {
3794 err = 0;
3795 goto out;
3796 }
3797
3798 di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3799 dentry->d_name.name, dentry->d_name.len, 0);
3800 if (IS_ERR(di)) {
3801 err = PTR_ERR(di);
3802 goto out;
3803 }
3804 if (di) {
3805 if (check_path_shared(root, path))
3806 goto out;
3807 } else {
3808 err = 0;
3809 goto out;
3810 }
3811 btrfs_release_path(path);
3812
3813 ret = btrfs_get_inode_ref_index(trans, root, path, dentry->d_name.name,
3814 dentry->d_name.len, ino, dir_ino, 0,
3815 &index);
3816 if (ret) {
3817 err = ret;
3818 goto out;
3819 }
3820
3821 if (check_path_shared(root, path))
3822 goto out;
3823
3824 btrfs_release_path(path);
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834 di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
3835 dentry->d_name.name, dentry->d_name.len, 0);
3836 if (IS_ERR(di)) {
3837 err = PTR_ERR(di);
3838 goto out;
3839 }
3840 BUG_ON(ret == -ENOENT);
3841 if (check_path_shared(root, path))
3842 goto out;
3843
3844 err = 0;
3845out:
3846 btrfs_free_path(path);
3847
3848 if (!err)
3849 err = btrfs_block_rsv_migrate(trans->block_rsv,
3850 &root->fs_info->global_block_rsv,
3851 trans->bytes_reserved);
3852
3853 if (err) {
3854 btrfs_end_transaction(trans, root);
3855 root->fs_info->enospc_unlink = 0;
3856 return ERR_PTR(err);
3857 }
3858
3859 trans->block_rsv = &root->fs_info->global_block_rsv;
3860 return trans;
3861}
3862
3863static void __unlink_end_trans(struct btrfs_trans_handle *trans,
3864 struct btrfs_root *root)
3865{
3866 if (trans->block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL) {
3867 btrfs_block_rsv_release(root, trans->block_rsv,
3868 trans->bytes_reserved);
3869 trans->block_rsv = &root->fs_info->trans_block_rsv;
3870 BUG_ON(!root->fs_info->enospc_unlink);
3871 root->fs_info->enospc_unlink = 0;
3872 }
3873 btrfs_end_transaction(trans, root);
3874}
3875
3876static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
3877{
3878 struct btrfs_root *root = BTRFS_I(dir)->root;
3879 struct btrfs_trans_handle *trans;
3880 struct inode *inode = dentry->d_inode;
3881 int ret;
3882
3883 trans = __unlink_start_trans(dir, dentry);
3884 if (IS_ERR(trans))
3885 return PTR_ERR(trans);
3886
3887 btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
3888
3889 ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
3890 dentry->d_name.name, dentry->d_name.len);
3891 if (ret)
3892 goto out;
3893
3894 if (inode->i_nlink == 0) {
3895 ret = btrfs_orphan_add(trans, inode);
3896 if (ret)
3897 goto out;
3898 }
3899
3900out:
3901 __unlink_end_trans(trans, root);
3902 btrfs_btree_balance_dirty(root);
3903 return ret;
3904}
3905
3906int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
3907 struct btrfs_root *root,
3908 struct inode *dir, u64 objectid,
3909 const char *name, int name_len)
3910{
3911 struct btrfs_path *path;
3912 struct extent_buffer *leaf;
3913 struct btrfs_dir_item *di;
3914 struct btrfs_key key;
3915 u64 index;
3916 int ret;
3917 u64 dir_ino = btrfs_ino(dir);
3918
3919 path = btrfs_alloc_path();
3920 if (!path)
3921 return -ENOMEM;
3922
3923 di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
3924 name, name_len, -1);
3925 if (IS_ERR_OR_NULL(di)) {
3926 if (!di)
3927 ret = -ENOENT;
3928 else
3929 ret = PTR_ERR(di);
3930 goto out;
3931 }
3932
3933 leaf = path->nodes[0];
3934 btrfs_dir_item_key_to_cpu(leaf, di, &key);
3935 WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
3936 ret = btrfs_delete_one_dir_name(trans, root, path, di);
3937 if (ret) {
3938 btrfs_abort_transaction(trans, root, ret);
3939 goto out;
3940 }
3941 btrfs_release_path(path);
3942
3943 ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
3944 objectid, root->root_key.objectid,
3945 dir_ino, &index, name, name_len);
3946 if (ret < 0) {
3947 if (ret != -ENOENT) {
3948 btrfs_abort_transaction(trans, root, ret);
3949 goto out;
3950 }
3951 di = btrfs_search_dir_index_item(root, path, dir_ino,
3952 name, name_len);
3953 if (IS_ERR_OR_NULL(di)) {
3954 if (!di)
3955 ret = -ENOENT;
3956 else
3957 ret = PTR_ERR(di);
3958 btrfs_abort_transaction(trans, root, ret);
3959 goto out;
3960 }
3961
3962 leaf = path->nodes[0];
3963 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
3964 btrfs_release_path(path);
3965 index = key.offset;
3966 }
3967 btrfs_release_path(path);
3968
3969 ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
3970 if (ret) {
3971 btrfs_abort_transaction(trans, root, ret);
3972 goto out;
3973 }
3974
3975 btrfs_i_size_write(dir, dir->i_size - name_len * 2);
3976 inode_inc_iversion(dir);
3977 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
3978 ret = btrfs_update_inode_fallback(trans, root, dir);
3979 if (ret)
3980 btrfs_abort_transaction(trans, root, ret);
3981out:
3982 btrfs_free_path(path);
3983 return ret;
3984}
3985
3986static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
3987{
3988 struct inode *inode = dentry->d_inode;
3989 int err = 0;
3990 struct btrfs_root *root = BTRFS_I(dir)->root;
3991 struct btrfs_trans_handle *trans;
3992
3993 if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
3994 return -ENOTEMPTY;
3995 if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
3996 return -EPERM;
3997
3998 trans = __unlink_start_trans(dir, dentry);
3999 if (IS_ERR(trans))
4000 return PTR_ERR(trans);
4001
4002 if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
4003 err = btrfs_unlink_subvol(trans, root, dir,
4004 BTRFS_I(inode)->location.objectid,
4005 dentry->d_name.name,
4006 dentry->d_name.len);
4007 goto out;
4008 }
4009
4010 err = btrfs_orphan_add(trans, inode);
4011 if (err)
4012 goto out;
4013
4014
4015 err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
4016 dentry->d_name.name, dentry->d_name.len);
4017 if (!err)
4018 btrfs_i_size_write(inode, 0);
4019out:
4020 __unlink_end_trans(trans, root);
4021 btrfs_btree_balance_dirty(root);
4022
4023 return err;
4024}
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
4038 struct btrfs_root *root,
4039 struct inode *inode,
4040 u64 new_size, u32 min_type)
4041{
4042 struct btrfs_path *path;
4043 struct extent_buffer *leaf;
4044 struct btrfs_file_extent_item *fi;
4045 struct btrfs_key key;
4046 struct btrfs_key found_key;
4047 u64 extent_start = 0;
4048 u64 extent_num_bytes = 0;
4049 u64 extent_offset = 0;
4050 u64 item_end = 0;
4051 u32 found_type = (u8)-1;
4052 int found_extent;
4053 int del_item;
4054 int pending_del_nr = 0;
4055 int pending_del_slot = 0;
4056 int extent_type = -1;
4057 int ret;
4058 int err = 0;
4059 u64 ino = btrfs_ino(inode);
4060
4061 BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
4062
4063 path = btrfs_alloc_path();
4064 if (!path)
4065 return -ENOMEM;
4066 path->reada = -1;
4067
4068
4069
4070
4071
4072
4073 if (root->ref_cows || root == root->fs_info->tree_root)
4074 btrfs_drop_extent_cache(inode, ALIGN(new_size,
4075 root->sectorsize), (u64)-1, 0);
4076
4077
4078
4079
4080
4081
4082
4083 if (min_type == 0 && root == BTRFS_I(inode)->root)
4084 btrfs_kill_delayed_inode_items(inode);
4085
4086 key.objectid = ino;
4087 key.offset = (u64)-1;
4088 key.type = (u8)-1;
4089
4090search_again:
4091 path->leave_spinning = 1;
4092 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
4093 if (ret < 0) {
4094 err = ret;
4095 goto out;
4096 }
4097
4098 if (ret > 0) {
4099
4100
4101
4102 if (path->slots[0] == 0)
4103 goto out;
4104 path->slots[0]--;
4105 }
4106
4107 while (1) {
4108 fi = NULL;
4109 leaf = path->nodes[0];
4110 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
4111 found_type = btrfs_key_type(&found_key);
4112
4113 if (found_key.objectid != ino)
4114 break;
4115
4116 if (found_type < min_type)
4117 break;
4118
4119 item_end = found_key.offset;
4120 if (found_type == BTRFS_EXTENT_DATA_KEY) {
4121 fi = btrfs_item_ptr(leaf, path->slots[0],
4122 struct btrfs_file_extent_item);
4123 extent_type = btrfs_file_extent_type(leaf, fi);
4124 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
4125 item_end +=
4126 btrfs_file_extent_num_bytes(leaf, fi);
4127 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4128 item_end += btrfs_file_extent_inline_len(leaf,
4129 fi);
4130 }
4131 item_end--;
4132 }
4133 if (found_type > min_type) {
4134 del_item = 1;
4135 } else {
4136 if (item_end < new_size)
4137 break;
4138 if (found_key.offset >= new_size)
4139 del_item = 1;
4140 else
4141 del_item = 0;
4142 }
4143 found_extent = 0;
4144
4145 if (found_type != BTRFS_EXTENT_DATA_KEY)
4146 goto delete;
4147
4148 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
4149 u64 num_dec;
4150 extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
4151 if (!del_item) {
4152 u64 orig_num_bytes =
4153 btrfs_file_extent_num_bytes(leaf, fi);
4154 extent_num_bytes = ALIGN(new_size -
4155 found_key.offset,
4156 root->sectorsize);
4157 btrfs_set_file_extent_num_bytes(leaf, fi,
4158 extent_num_bytes);
4159 num_dec = (orig_num_bytes -
4160 extent_num_bytes);
4161 if (root->ref_cows && extent_start != 0)
4162 inode_sub_bytes(inode, num_dec);
4163 btrfs_mark_buffer_dirty(leaf);
4164 } else {
4165 extent_num_bytes =
4166 btrfs_file_extent_disk_num_bytes(leaf,
4167 fi);
4168 extent_offset = found_key.offset -
4169 btrfs_file_extent_offset(leaf, fi);
4170
4171
4172 num_dec = btrfs_file_extent_num_bytes(leaf, fi);
4173 if (extent_start != 0) {
4174 found_extent = 1;
4175 if (root->ref_cows)
4176 inode_sub_bytes(inode, num_dec);
4177 }
4178 }
4179 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4180
4181
4182
4183
4184 if (!del_item &&
4185 btrfs_file_extent_compression(leaf, fi) == 0 &&
4186 btrfs_file_extent_encryption(leaf, fi) == 0 &&
4187 btrfs_file_extent_other_encoding(leaf, fi) == 0) {
4188 u32 size = new_size - found_key.offset;
4189
4190 if (root->ref_cows) {
4191 inode_sub_bytes(inode, item_end + 1 -
4192 new_size);
4193 }
4194 size =
4195 btrfs_file_extent_calc_inline_size(size);
4196 btrfs_truncate_item(root, path, size, 1);
4197 } else if (root->ref_cows) {
4198 inode_sub_bytes(inode, item_end + 1 -
4199 found_key.offset);
4200 }
4201 }
4202delete:
4203 if (del_item) {
4204 if (!pending_del_nr) {
4205
4206 pending_del_slot = path->slots[0];
4207 pending_del_nr = 1;
4208 } else if (pending_del_nr &&
4209 path->slots[0] + 1 == pending_del_slot) {
4210
4211 pending_del_nr++;
4212 pending_del_slot = path->slots[0];
4213 } else {
4214 BUG();
4215 }
4216 } else {
4217 break;
4218 }
4219 if (found_extent && (root->ref_cows ||
4220 root == root->fs_info->tree_root)) {
4221 btrfs_set_path_blocking(path);
4222 ret = btrfs_free_extent(trans, root, extent_start,
4223 extent_num_bytes, 0,
4224 btrfs_header_owner(leaf),
4225 ino, extent_offset, 0);
4226 BUG_ON(ret);
4227 }
4228
4229 if (found_type == BTRFS_INODE_ITEM_KEY)
4230 break;
4231
4232 if (path->slots[0] == 0 ||
4233 path->slots[0] != pending_del_slot) {
4234 if (pending_del_nr) {
4235 ret = btrfs_del_items(trans, root, path,
4236 pending_del_slot,
4237 pending_del_nr);
4238 if (ret) {
4239 btrfs_abort_transaction(trans,
4240 root, ret);
4241 goto error;
4242 }
4243 pending_del_nr = 0;
4244 }
4245 btrfs_release_path(path);
4246 goto search_again;
4247 } else {
4248 path->slots[0]--;
4249 }
4250 }
4251out:
4252 if (pending_del_nr) {
4253 ret = btrfs_del_items(trans, root, path, pending_del_slot,
4254 pending_del_nr);
4255 if (ret)
4256 btrfs_abort_transaction(trans, root, ret);
4257 }
4258error:
4259 btrfs_free_path(path);
4260 return err;
4261}
4262
4263
4264
4265
4266
4267
4268
4269
4270
4271
4272
4273
4274int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
4275 int front)
4276{
4277 struct address_space *mapping = inode->i_mapping;
4278 struct btrfs_root *root = BTRFS_I(inode)->root;
4279 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4280 struct btrfs_ordered_extent *ordered;
4281 struct extent_state *cached_state = NULL;
4282 char *kaddr;
4283 u32 blocksize = root->sectorsize;
4284 pgoff_t index = from >> PAGE_CACHE_SHIFT;
4285 unsigned offset = from & (PAGE_CACHE_SIZE-1);
4286 struct page *page;
4287 gfp_t mask = btrfs_alloc_write_mask(mapping);
4288 int ret = 0;
4289 u64 page_start;
4290 u64 page_end;
4291
4292 if ((offset & (blocksize - 1)) == 0 &&
4293 (!len || ((len & (blocksize - 1)) == 0)))
4294 goto out;
4295 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
4296 if (ret)
4297 goto out;
4298
4299again:
4300 page = find_or_create_page(mapping, index, mask);
4301 if (!page) {
4302 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
4303 ret = -ENOMEM;
4304 goto out;
4305 }
4306
4307 page_start = page_offset(page);
4308 page_end = page_start + PAGE_CACHE_SIZE - 1;
4309
4310 if (!PageUptodate(page)) {
4311 ret = btrfs_readpage(NULL, page);
4312 lock_page(page);
4313 if (page->mapping != mapping) {
4314 unlock_page(page);
4315 page_cache_release(page);
4316 goto again;
4317 }
4318 if (!PageUptodate(page)) {
4319 ret = -EIO;
4320 goto out_unlock;
4321 }
4322 }
4323 wait_on_page_writeback(page);
4324
4325 lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
4326 set_page_extent_mapped(page);
4327
4328 ordered = btrfs_lookup_ordered_extent(inode, page_start);
4329 if (ordered) {
4330 unlock_extent_cached(io_tree, page_start, page_end,
4331 &cached_state, GFP_NOFS);
4332 unlock_page(page);
4333 page_cache_release(page);
4334 btrfs_start_ordered_extent(inode, ordered, 1);
4335 btrfs_put_ordered_extent(ordered);
4336 goto again;
4337 }
4338
4339 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
4340 EXTENT_DIRTY | EXTENT_DELALLOC |
4341 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
4342 0, 0, &cached_state, GFP_NOFS);
4343
4344 ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
4345 &cached_state);
4346 if (ret) {
4347 unlock_extent_cached(io_tree, page_start, page_end,
4348 &cached_state, GFP_NOFS);
4349 goto out_unlock;
4350 }
4351
4352 if (offset != PAGE_CACHE_SIZE) {
4353 if (!len)
4354 len = PAGE_CACHE_SIZE - offset;
4355 kaddr = kmap(page);
4356 if (front)
4357 memset(kaddr, 0, offset);
4358 else
4359 memset(kaddr + offset, 0, len);
4360 flush_dcache_page(page);
4361 kunmap(page);
4362 }
4363 ClearPageChecked(page);
4364 set_page_dirty(page);
4365 unlock_extent_cached(io_tree, page_start, page_end, &cached_state,
4366 GFP_NOFS);
4367
4368out_unlock:
4369 if (ret)
4370 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
4371 unlock_page(page);
4372 page_cache_release(page);
4373out:
4374 return ret;
4375}
4376
4377
4378
4379
4380
4381
4382
4383int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
4384{
4385 struct btrfs_trans_handle *trans;
4386 struct btrfs_root *root = BTRFS_I(inode)->root;
4387 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
4388 struct extent_map *em = NULL;
4389 struct extent_state *cached_state = NULL;
4390 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4391 u64 hole_start = ALIGN(oldsize, root->sectorsize);
4392 u64 block_end = ALIGN(size, root->sectorsize);
4393 u64 last_byte;
4394 u64 cur_offset;
4395 u64 hole_size;
4396 int err = 0;
4397
4398 if (size <= hole_start)
4399 return 0;
4400
4401 while (1) {
4402 struct btrfs_ordered_extent *ordered;
4403 btrfs_wait_ordered_range(inode, hole_start,
4404 block_end - hole_start);
4405 lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
4406 &cached_state);
4407 ordered = btrfs_lookup_ordered_extent(inode, hole_start);
4408 if (!ordered)
4409 break;
4410 unlock_extent_cached(io_tree, hole_start, block_end - 1,
4411 &cached_state, GFP_NOFS);
4412 btrfs_put_ordered_extent(ordered);
4413 }
4414
4415 cur_offset = hole_start;
4416 while (1) {
4417 em = btrfs_get_extent(inode, NULL, 0, cur_offset,
4418 block_end - cur_offset, 0);
4419 if (IS_ERR(em)) {
4420 err = PTR_ERR(em);
4421 em = NULL;
4422 break;
4423 }
4424 last_byte = min(extent_map_end(em), block_end);
4425 last_byte = ALIGN(last_byte , root->sectorsize);
4426 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
4427 struct extent_map *hole_em;
4428 hole_size = last_byte - cur_offset;
4429
4430 trans = btrfs_start_transaction(root, 3);
4431 if (IS_ERR(trans)) {
4432 err = PTR_ERR(trans);
4433 break;
4434 }
4435
4436 err = btrfs_drop_extents(trans, root, inode,
4437 cur_offset,
4438 cur_offset + hole_size, 1);
4439 if (err) {
4440 btrfs_abort_transaction(trans, root, err);
4441 btrfs_end_transaction(trans, root);
4442 break;
4443 }
4444
4445 err = btrfs_insert_file_extent(trans, root,
4446 btrfs_ino(inode), cur_offset, 0,
4447 0, hole_size, 0, hole_size,
4448 0, 0, 0);
4449 if (err) {
4450 btrfs_abort_transaction(trans, root, err);
4451 btrfs_end_transaction(trans, root);
4452 break;
4453 }
4454
4455 btrfs_drop_extent_cache(inode, cur_offset,
4456 cur_offset + hole_size - 1, 0);
4457 hole_em = alloc_extent_map();
4458 if (!hole_em) {
4459 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
4460 &BTRFS_I(inode)->runtime_flags);
4461 goto next;
4462 }
4463 hole_em->start = cur_offset;
4464 hole_em->len = hole_size;
4465 hole_em->orig_start = cur_offset;
4466
4467 hole_em->block_start = EXTENT_MAP_HOLE;
4468 hole_em->block_len = 0;
4469 hole_em->orig_block_len = 0;
4470 hole_em->ram_bytes = hole_size;
4471 hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
4472 hole_em->compress_type = BTRFS_COMPRESS_NONE;
4473 hole_em->generation = trans->transid;
4474
4475 while (1) {
4476 write_lock(&em_tree->lock);
4477 err = add_extent_mapping(em_tree, hole_em, 1);
4478 write_unlock(&em_tree->lock);
4479 if (err != -EEXIST)
4480 break;
4481 btrfs_drop_extent_cache(inode, cur_offset,
4482 cur_offset +
4483 hole_size - 1, 0);
4484 }
4485 free_extent_map(hole_em);
4486next:
4487 btrfs_update_inode(trans, root, inode);
4488 btrfs_end_transaction(trans, root);
4489 }
4490 free_extent_map(em);
4491 em = NULL;
4492 cur_offset = last_byte;
4493 if (cur_offset >= block_end)
4494 break;
4495 }
4496
4497 free_extent_map(em);
4498 unlock_extent_cached(io_tree, hole_start, block_end - 1, &cached_state,
4499 GFP_NOFS);
4500 return err;
4501}
4502
4503static int btrfs_setsize(struct inode *inode, struct iattr *attr)
4504{
4505 struct btrfs_root *root = BTRFS_I(inode)->root;
4506 struct btrfs_trans_handle *trans;
4507 loff_t oldsize = i_size_read(inode);
4508 loff_t newsize = attr->ia_size;
4509 int mask = attr->ia_valid;
4510 int ret;
4511
4512 if (newsize == oldsize)
4513 return 0;
4514
4515
4516
4517
4518
4519
4520
4521 if (newsize != oldsize && (!(mask & (ATTR_CTIME | ATTR_MTIME))))
4522 inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
4523
4524 if (newsize > oldsize) {
4525 truncate_pagecache(inode, oldsize, newsize);
4526 ret = btrfs_cont_expand(inode, oldsize, newsize);
4527 if (ret)
4528 return ret;
4529
4530 trans = btrfs_start_transaction(root, 1);
4531 if (IS_ERR(trans))
4532 return PTR_ERR(trans);
4533
4534 i_size_write(inode, newsize);
4535 btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
4536 ret = btrfs_update_inode(trans, root, inode);
4537 btrfs_end_transaction(trans, root);
4538 } else {
4539
4540
4541
4542
4543
4544
4545 if (newsize == 0)
4546 set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
4547 &BTRFS_I(inode)->runtime_flags);
4548
4549
4550
4551
4552
4553 trans = btrfs_start_transaction(root, 2);
4554 if (IS_ERR(trans))
4555 return PTR_ERR(trans);
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567 ret = btrfs_orphan_add(trans, inode);
4568 btrfs_end_transaction(trans, root);
4569 if (ret)
4570 return ret;
4571
4572
4573 truncate_setsize(inode, newsize);
4574
4575
4576 btrfs_inode_block_unlocked_dio(inode);
4577 inode_dio_wait(inode);
4578 btrfs_inode_resume_unlocked_dio(inode);
4579
4580 ret = btrfs_truncate(inode);
4581 if (ret && inode->i_nlink)
4582 btrfs_orphan_del(NULL, inode);
4583 }
4584
4585 return ret;
4586}
4587
4588static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
4589{
4590 struct inode *inode = dentry->d_inode;
4591 struct btrfs_root *root = BTRFS_I(inode)->root;
4592 int err;
4593
4594 if (btrfs_root_readonly(root))
4595 return -EROFS;
4596
4597 err = inode_change_ok(inode, attr);
4598 if (err)
4599 return err;
4600
4601 if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
4602 err = btrfs_setsize(inode, attr);
4603 if (err)
4604 return err;
4605 }
4606
4607 if (attr->ia_valid) {
4608 setattr_copy(inode, attr);
4609 inode_inc_iversion(inode);
4610 err = btrfs_dirty_inode(inode);
4611
4612 if (!err && attr->ia_valid & ATTR_MODE)
4613 err = btrfs_acl_chmod(inode);
4614 }
4615
4616 return err;
4617}
4618
4619void btrfs_evict_inode(struct inode *inode)
4620{
4621 struct btrfs_trans_handle *trans;
4622 struct btrfs_root *root = BTRFS_I(inode)->root;
4623 struct btrfs_block_rsv *rsv, *global_rsv;
4624 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
4625 int ret;
4626
4627 trace_btrfs_inode_evict(inode);
4628
4629 truncate_inode_pages(&inode->i_data, 0);
4630 if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
4631 btrfs_is_free_space_inode(inode)))
4632 goto no_delete;
4633
4634 if (is_bad_inode(inode)) {
4635 btrfs_orphan_del(NULL, inode);
4636 goto no_delete;
4637 }
4638
4639 btrfs_wait_ordered_range(inode, 0, (u64)-1);
4640
4641 if (root->fs_info->log_root_recovering) {
4642 BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
4643 &BTRFS_I(inode)->runtime_flags));
4644 goto no_delete;
4645 }
4646
4647 if (inode->i_nlink > 0) {
4648 BUG_ON(btrfs_root_refs(&root->root_item) != 0);
4649 goto no_delete;
4650 }
4651
4652 ret = btrfs_commit_inode_delayed_inode(inode);
4653 if (ret) {
4654 btrfs_orphan_del(NULL, inode);
4655 goto no_delete;
4656 }
4657
4658 rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
4659 if (!rsv) {
4660 btrfs_orphan_del(NULL, inode);
4661 goto no_delete;
4662 }
4663 rsv->size = min_size;
4664 rsv->failfast = 1;
4665 global_rsv = &root->fs_info->global_block_rsv;
4666
4667 btrfs_i_size_write(inode, 0);
4668
4669
4670
4671
4672
4673
4674
4675 while (1) {
4676 ret = btrfs_block_rsv_refill(root, rsv, min_size,
4677 BTRFS_RESERVE_FLUSH_LIMIT);
4678
4679
4680
4681
4682
4683
4684 if (ret)
4685 ret = btrfs_block_rsv_migrate(global_rsv, rsv, min_size);
4686
4687 if (ret) {
4688 btrfs_warn(root->fs_info,
4689 "Could not get space for a delete, will truncate on mount %d",
4690 ret);
4691 btrfs_orphan_del(NULL, inode);
4692 btrfs_free_block_rsv(root, rsv);
4693 goto no_delete;
4694 }
4695
4696 trans = btrfs_join_transaction(root);
4697 if (IS_ERR(trans)) {
4698 btrfs_orphan_del(NULL, inode);
4699 btrfs_free_block_rsv(root, rsv);
4700 goto no_delete;
4701 }
4702
4703 trans->block_rsv = rsv;
4704
4705 ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
4706 if (ret != -ENOSPC)
4707 break;
4708
4709 trans->block_rsv = &root->fs_info->trans_block_rsv;
4710 btrfs_end_transaction(trans, root);
4711 trans = NULL;
4712 btrfs_btree_balance_dirty(root);
4713 }
4714
4715 btrfs_free_block_rsv(root, rsv);
4716
4717 if (ret == 0) {
4718 trans->block_rsv = root->orphan_block_rsv;
4719 ret = btrfs_orphan_del(trans, inode);
4720 BUG_ON(ret);
4721 }
4722
4723 trans->block_rsv = &root->fs_info->trans_block_rsv;
4724 if (!(root == root->fs_info->tree_root ||
4725 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
4726 btrfs_return_ino(root, btrfs_ino(inode));
4727
4728 btrfs_end_transaction(trans, root);
4729 btrfs_btree_balance_dirty(root);
4730no_delete:
4731 btrfs_remove_delayed_node(inode);
4732 clear_inode(inode);
4733 return;
4734}
4735
4736
4737
4738
4739
4740static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
4741 struct btrfs_key *location)
4742{
4743 const char *name = dentry->d_name.name;
4744 int namelen = dentry->d_name.len;
4745 struct btrfs_dir_item *di;
4746 struct btrfs_path *path;
4747 struct btrfs_root *root = BTRFS_I(dir)->root;
4748 int ret = 0;
4749
4750 path = btrfs_alloc_path();
4751 if (!path)
4752 return -ENOMEM;
4753
4754 di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
4755 namelen, 0);
4756 if (IS_ERR(di))
4757 ret = PTR_ERR(di);
4758
4759 if (IS_ERR_OR_NULL(di))
4760 goto out_err;
4761
4762 btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
4763out:
4764 btrfs_free_path(path);
4765 return ret;
4766out_err:
4767 location->objectid = 0;
4768 goto out;
4769}
4770
4771
4772
4773
4774
4775
4776static int fixup_tree_root_location(struct btrfs_root *root,
4777 struct inode *dir,
4778 struct dentry *dentry,
4779 struct btrfs_key *location,
4780 struct btrfs_root **sub_root)
4781{
4782 struct btrfs_path *path;
4783 struct btrfs_root *new_root;
4784 struct btrfs_root_ref *ref;
4785 struct extent_buffer *leaf;
4786 int ret;
4787 int err = 0;
4788
4789 path = btrfs_alloc_path();
4790 if (!path) {
4791 err = -ENOMEM;
4792 goto out;
4793 }
4794
4795 err = -ENOENT;
4796 ret = btrfs_find_root_ref(root->fs_info->tree_root, path,
4797 BTRFS_I(dir)->root->root_key.objectid,
4798 location->objectid);
4799 if (ret) {
4800 if (ret < 0)
4801 err = ret;
4802 goto out;
4803 }
4804
4805 leaf = path->nodes[0];
4806 ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
4807 if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
4808 btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
4809 goto out;
4810
4811 ret = memcmp_extent_buffer(leaf, dentry->d_name.name,
4812 (unsigned long)(ref + 1),
4813 dentry->d_name.len);
4814 if (ret)
4815 goto out;
4816
4817 btrfs_release_path(path);
4818
4819 new_root = btrfs_read_fs_root_no_name(root->fs_info, location);
4820 if (IS_ERR(new_root)) {
4821 err = PTR_ERR(new_root);
4822 goto out;
4823 }
4824
4825 if (btrfs_root_refs(&new_root->root_item) == 0) {
4826 err = -ENOENT;
4827 goto out;
4828 }
4829
4830 *sub_root = new_root;
4831 location->objectid = btrfs_root_dirid(&new_root->root_item);
4832 location->type = BTRFS_INODE_ITEM_KEY;
4833 location->offset = 0;
4834 err = 0;
4835out:
4836 btrfs_free_path(path);
4837 return err;
4838}
4839
4840static void inode_tree_add(struct inode *inode)
4841{
4842 struct btrfs_root *root = BTRFS_I(inode)->root;
4843 struct btrfs_inode *entry;
4844 struct rb_node **p;
4845 struct rb_node *parent;
4846 u64 ino = btrfs_ino(inode);
4847
4848 if (inode_unhashed(inode))
4849 return;
4850again:
4851 parent = NULL;
4852 spin_lock(&root->inode_lock);
4853 p = &root->inode_tree.rb_node;
4854 while (*p) {
4855 parent = *p;
4856 entry = rb_entry(parent, struct btrfs_inode, rb_node);
4857
4858 if (ino < btrfs_ino(&entry->vfs_inode))
4859 p = &parent->rb_left;
4860 else if (ino > btrfs_ino(&entry->vfs_inode))
4861 p = &parent->rb_right;
4862 else {
4863 WARN_ON(!(entry->vfs_inode.i_state &
4864 (I_WILL_FREE | I_FREEING)));
4865 rb_erase(parent, &root->inode_tree);
4866 RB_CLEAR_NODE(parent);
4867 spin_unlock(&root->inode_lock);
4868 goto again;
4869 }
4870 }
4871 rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
4872 rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
4873 spin_unlock(&root->inode_lock);
4874}
4875
4876static void inode_tree_del(struct inode *inode)
4877{
4878 struct btrfs_root *root = BTRFS_I(inode)->root;
4879 int empty = 0;
4880
4881 spin_lock(&root->inode_lock);
4882 if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
4883 rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
4884 RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
4885 empty = RB_EMPTY_ROOT(&root->inode_tree);
4886 }
4887 spin_unlock(&root->inode_lock);
4888
4889
4890
4891
4892
4893
4894
4895 if (empty && btrfs_root_refs(&root->root_item) == 0 &&
4896 root != root->fs_info->tree_root) {
4897 synchronize_srcu(&root->fs_info->subvol_srcu);
4898 spin_lock(&root->inode_lock);
4899 empty = RB_EMPTY_ROOT(&root->inode_tree);
4900 spin_unlock(&root->inode_lock);
4901 if (empty)
4902 btrfs_add_dead_root(root);
4903 }
4904}
4905
4906void btrfs_invalidate_inodes(struct btrfs_root *root)
4907{
4908 struct rb_node *node;
4909 struct rb_node *prev;
4910 struct btrfs_inode *entry;
4911 struct inode *inode;
4912 u64 objectid = 0;
4913
4914 WARN_ON(btrfs_root_refs(&root->root_item) != 0);
4915
4916 spin_lock(&root->inode_lock);
4917again:
4918 node = root->inode_tree.rb_node;
4919 prev = NULL;
4920 while (node) {
4921 prev = node;
4922 entry = rb_entry(node, struct btrfs_inode, rb_node);
4923
4924 if (objectid < btrfs_ino(&entry->vfs_inode))
4925 node = node->rb_left;
4926 else if (objectid > btrfs_ino(&entry->vfs_inode))
4927 node = node->rb_right;
4928 else
4929 break;
4930 }
4931 if (!node) {
4932 while (prev) {
4933 entry = rb_entry(prev, struct btrfs_inode, rb_node);
4934 if (objectid <= btrfs_ino(&entry->vfs_inode)) {
4935 node = prev;
4936 break;
4937 }
4938 prev = rb_next(prev);
4939 }
4940 }
4941 while (node) {
4942 entry = rb_entry(node, struct btrfs_inode, rb_node);
4943 objectid = btrfs_ino(&entry->vfs_inode) + 1;
4944 inode = igrab(&entry->vfs_inode);
4945 if (inode) {
4946 spin_unlock(&root->inode_lock);
4947 if (atomic_read(&inode->i_count) > 1)
4948 d_prune_aliases(inode);
4949
4950
4951
4952
4953
4954 iput(inode);
4955 cond_resched();
4956 spin_lock(&root->inode_lock);
4957 goto again;
4958 }
4959
4960 if (cond_resched_lock(&root->inode_lock))
4961 goto again;
4962
4963 node = rb_next(node);
4964 }
4965 spin_unlock(&root->inode_lock);
4966}
4967
4968static int btrfs_init_locked_inode(struct inode *inode, void *p)
4969{
4970 struct btrfs_iget_args *args = p;
4971 inode->i_ino = args->ino;
4972 BTRFS_I(inode)->root = args->root;
4973 return 0;
4974}
4975
4976static int btrfs_find_actor(struct inode *inode, void *opaque)
4977{
4978 struct btrfs_iget_args *args = opaque;
4979 return args->ino == btrfs_ino(inode) &&
4980 args->root == BTRFS_I(inode)->root;
4981}
4982
4983static struct inode *btrfs_iget_locked(struct super_block *s,
4984 u64 objectid,
4985 struct btrfs_root *root)
4986{
4987 struct inode *inode;
4988 struct btrfs_iget_args args;
4989 args.ino = objectid;
4990 args.root = root;
4991
4992 inode = iget5_locked(s, objectid, btrfs_find_actor,
4993 btrfs_init_locked_inode,
4994 (void *)&args);
4995 return inode;
4996}
4997
4998
4999
5000
5001struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
5002 struct btrfs_root *root, int *new)
5003{
5004 struct inode *inode;
5005
5006 inode = btrfs_iget_locked(s, location->objectid, root);
5007 if (!inode)
5008 return ERR_PTR(-ENOMEM);
5009
5010 if (inode->i_state & I_NEW) {
5011 BTRFS_I(inode)->root = root;
5012 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
5013 btrfs_read_locked_inode(inode);
5014 if (!is_bad_inode(inode)) {
5015 inode_tree_add(inode);
5016 unlock_new_inode(inode);
5017 if (new)
5018 *new = 1;
5019 } else {
5020 unlock_new_inode(inode);
5021 iput(inode);
5022 inode = ERR_PTR(-ESTALE);
5023 }
5024 }
5025
5026 return inode;
5027}
5028
5029static struct inode *new_simple_dir(struct super_block *s,
5030 struct btrfs_key *key,
5031 struct btrfs_root *root)
5032{
5033 struct inode *inode = new_inode(s);
5034
5035 if (!inode)
5036 return ERR_PTR(-ENOMEM);
5037
5038 BTRFS_I(inode)->root = root;
5039 memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));
5040 set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
5041
5042 inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
5043 inode->i_op = &btrfs_dir_ro_inode_operations;
5044 inode->i_fop = &simple_dir_operations;
5045 inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
5046 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
5047
5048 return inode;
5049}
5050
5051struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
5052{
5053 struct inode *inode;
5054 struct btrfs_root *root = BTRFS_I(dir)->root;
5055 struct btrfs_root *sub_root = root;
5056 struct btrfs_key location;
5057 int index;
5058 int ret = 0;
5059
5060 if (dentry->d_name.len > BTRFS_NAME_LEN)
5061 return ERR_PTR(-ENAMETOOLONG);
5062
5063 ret = btrfs_inode_by_name(dir, dentry, &location);
5064 if (ret < 0)
5065 return ERR_PTR(ret);
5066
5067 if (location.objectid == 0)
5068 return NULL;
5069
5070 if (location.type == BTRFS_INODE_ITEM_KEY) {
5071 inode = btrfs_iget(dir->i_sb, &location, root, NULL);
5072 return inode;
5073 }
5074
5075 BUG_ON(location.type != BTRFS_ROOT_ITEM_KEY);
5076
5077 index = srcu_read_lock(&root->fs_info->subvol_srcu);
5078 ret = fixup_tree_root_location(root, dir, dentry,
5079 &location, &sub_root);
5080 if (ret < 0) {
5081 if (ret != -ENOENT)
5082 inode = ERR_PTR(ret);
5083 else
5084 inode = new_simple_dir(dir->i_sb, &location, sub_root);
5085 } else {
5086 inode = btrfs_iget(dir->i_sb, &location, sub_root, NULL);
5087 }
5088 srcu_read_unlock(&root->fs_info->subvol_srcu, index);
5089
5090 if (!IS_ERR(inode) && root != sub_root) {
5091 down_read(&root->fs_info->cleanup_work_sem);
5092 if (!(inode->i_sb->s_flags & MS_RDONLY))
5093 ret = btrfs_orphan_cleanup(sub_root);
5094 up_read(&root->fs_info->cleanup_work_sem);
5095 if (ret)
5096 inode = ERR_PTR(ret);
5097 }
5098
5099 return inode;
5100}
5101
5102static int btrfs_dentry_delete(const struct dentry *dentry)
5103{
5104 struct btrfs_root *root;
5105 struct inode *inode = dentry->d_inode;
5106
5107 if (!inode && !IS_ROOT(dentry))
5108 inode = dentry->d_parent->d_inode;
5109
5110 if (inode) {
5111 root = BTRFS_I(inode)->root;
5112 if (btrfs_root_refs(&root->root_item) == 0)
5113 return 1;
5114
5115 if (btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
5116 return 1;
5117 }
5118 return 0;
5119}
5120
5121static void btrfs_dentry_release(struct dentry *dentry)
5122{
5123 if (dentry->d_fsdata)
5124 kfree(dentry->d_fsdata);
5125}
5126
5127static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
5128 unsigned int flags)
5129{
5130 struct dentry *ret;
5131
5132 ret = d_splice_alias(btrfs_lookup_dentry(dir, dentry), dentry);
5133 return ret;
5134}
5135
5136unsigned char btrfs_filetype_table[] = {
5137 DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
5138};
5139
5140static int btrfs_real_readdir(struct file *filp, void *dirent,
5141 filldir_t filldir)
5142{
5143 struct inode *inode = file_inode(filp);
5144 struct btrfs_root *root = BTRFS_I(inode)->root;
5145 struct btrfs_item *item;
5146 struct btrfs_dir_item *di;
5147 struct btrfs_key key;
5148 struct btrfs_key found_key;
5149 struct btrfs_path *path;
5150 struct list_head ins_list;
5151 struct list_head del_list;
5152 int ret;
5153 struct extent_buffer *leaf;
5154 int slot;
5155 unsigned char d_type;
5156 int over = 0;
5157 u32 di_cur;
5158 u32 di_total;
5159 u32 di_len;
5160 int key_type = BTRFS_DIR_INDEX_KEY;
5161 char tmp_name[32];
5162 char *name_ptr;
5163 int name_len;
5164 int is_curr = 0;
5165
5166
5167 if (root->fs_info->tree_root == root)
5168 key_type = BTRFS_DIR_ITEM_KEY;
5169
5170
5171 if (filp->f_pos == 0) {
5172 over = filldir(dirent, ".", 1,
5173 filp->f_pos, btrfs_ino(inode), DT_DIR);
5174 if (over)
5175 return 0;
5176 filp->f_pos = 1;
5177 }
5178
5179 if (filp->f_pos == 1) {
5180 u64 pino = parent_ino(filp->f_path.dentry);
5181 over = filldir(dirent, "..", 2,
5182 filp->f_pos, pino, DT_DIR);
5183 if (over)
5184 return 0;
5185 filp->f_pos = 2;
5186 }
5187 path = btrfs_alloc_path();
5188 if (!path)
5189 return -ENOMEM;
5190
5191 path->reada = 1;
5192
5193 if (key_type == BTRFS_DIR_INDEX_KEY) {
5194 INIT_LIST_HEAD(&ins_list);
5195 INIT_LIST_HEAD(&del_list);
5196 btrfs_get_delayed_items(inode, &ins_list, &del_list);
5197 }
5198
5199 btrfs_set_key_type(&key, key_type);
5200 key.offset = filp->f_pos;
5201 key.objectid = btrfs_ino(inode);
5202
5203 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5204 if (ret < 0)
5205 goto err;
5206
5207 while (1) {
5208 leaf = path->nodes[0];
5209 slot = path->slots[0];
5210 if (slot >= btrfs_header_nritems(leaf)) {
5211 ret = btrfs_next_leaf(root, path);
5212 if (ret < 0)
5213 goto err;
5214 else if (ret > 0)
5215 break;
5216 continue;
5217 }
5218
5219 item = btrfs_item_nr(leaf, slot);
5220 btrfs_item_key_to_cpu(leaf, &found_key, slot);
5221
5222 if (found_key.objectid != key.objectid)
5223 break;
5224 if (btrfs_key_type(&found_key) != key_type)
5225 break;
5226 if (found_key.offset < filp->f_pos)
5227 goto next;
5228 if (key_type == BTRFS_DIR_INDEX_KEY &&
5229 btrfs_should_delete_dir_index(&del_list,
5230 found_key.offset))
5231 goto next;
5232
5233 filp->f_pos = found_key.offset;
5234 is_curr = 1;
5235
5236 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
5237 di_cur = 0;
5238 di_total = btrfs_item_size(leaf, item);
5239
5240 while (di_cur < di_total) {
5241 struct btrfs_key location;
5242
5243 if (verify_dir_item(root, leaf, di))
5244 break;
5245
5246 name_len = btrfs_dir_name_len(leaf, di);
5247 if (name_len <= sizeof(tmp_name)) {
5248 name_ptr = tmp_name;
5249 } else {
5250 name_ptr = kmalloc(name_len, GFP_NOFS);
5251 if (!name_ptr) {
5252 ret = -ENOMEM;
5253 goto err;
5254 }
5255 }
5256 read_extent_buffer(leaf, name_ptr,
5257 (unsigned long)(di + 1), name_len);
5258
5259 d_type = btrfs_filetype_table[btrfs_dir_type(leaf, di)];
5260 btrfs_dir_item_key_to_cpu(leaf, di, &location);
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272 if (location.type == BTRFS_ROOT_ITEM_KEY &&
5273 location.objectid == root->root_key.objectid) {
5274 over = 0;
5275 goto skip;
5276 }
5277 over = filldir(dirent, name_ptr, name_len,
5278 found_key.offset, location.objectid,
5279 d_type);
5280
5281skip:
5282 if (name_ptr != tmp_name)
5283 kfree(name_ptr);
5284
5285 if (over)
5286 goto nopos;
5287 di_len = btrfs_dir_name_len(leaf, di) +
5288 btrfs_dir_data_len(leaf, di) + sizeof(*di);
5289 di_cur += di_len;
5290 di = (struct btrfs_dir_item *)((char *)di + di_len);
5291 }
5292next:
5293 path->slots[0]++;
5294 }
5295
5296 if (key_type == BTRFS_DIR_INDEX_KEY) {
5297 if (is_curr)
5298 filp->f_pos++;
5299 ret = btrfs_readdir_delayed_dir_index(filp, dirent, filldir,
5300 &ins_list);
5301 if (ret)
5302 goto nopos;
5303 }
5304
5305
5306 if (key_type == BTRFS_DIR_INDEX_KEY)
5307
5308
5309
5310
5311 filp->f_pos = 0x7fffffff;
5312 else
5313 filp->f_pos++;
5314nopos:
5315 ret = 0;
5316err:
5317 if (key_type == BTRFS_DIR_INDEX_KEY)
5318 btrfs_put_delayed_items(&ins_list, &del_list);
5319 btrfs_free_path(path);
5320 return ret;
5321}
5322
5323int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
5324{
5325 struct btrfs_root *root = BTRFS_I(inode)->root;
5326 struct btrfs_trans_handle *trans;
5327 int ret = 0;
5328 bool nolock = false;
5329
5330 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5331 return 0;
5332
5333 if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(inode))
5334 nolock = true;
5335
5336 if (wbc->sync_mode == WB_SYNC_ALL) {
5337 if (nolock)
5338 trans = btrfs_join_transaction_nolock(root);
5339 else
5340 trans = btrfs_join_transaction(root);
5341 if (IS_ERR(trans))
5342 return PTR_ERR(trans);
5343 ret = btrfs_commit_transaction(trans, root);
5344 }
5345 return ret;
5346}
5347
5348
5349
5350
5351
5352
5353
5354static int btrfs_dirty_inode(struct inode *inode)
5355{
5356 struct btrfs_root *root = BTRFS_I(inode)->root;
5357 struct btrfs_trans_handle *trans;
5358 int ret;
5359
5360 if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
5361 return 0;
5362
5363 trans = btrfs_join_transaction(root);
5364 if (IS_ERR(trans))
5365 return PTR_ERR(trans);
5366
5367 ret = btrfs_update_inode(trans, root, inode);
5368 if (ret && ret == -ENOSPC) {
5369
5370 btrfs_end_transaction(trans, root);
5371 trans = btrfs_start_transaction(root, 1);
5372 if (IS_ERR(trans))
5373 return PTR_ERR(trans);
5374
5375 ret = btrfs_update_inode(trans, root, inode);
5376 }
5377 btrfs_end_transaction(trans, root);
5378 if (BTRFS_I(inode)->delayed_node)
5379 btrfs_balance_delayed_items(root);
5380
5381 return ret;
5382}
5383
5384
5385
5386
5387
5388static int btrfs_update_time(struct inode *inode, struct timespec *now,
5389 int flags)
5390{
5391 struct btrfs_root *root = BTRFS_I(inode)->root;
5392
5393 if (btrfs_root_readonly(root))
5394 return -EROFS;
5395
5396 if (flags & S_VERSION)
5397 inode_inc_iversion(inode);
5398 if (flags & S_CTIME)
5399 inode->i_ctime = *now;
5400 if (flags & S_MTIME)
5401 inode->i_mtime = *now;
5402 if (flags & S_ATIME)
5403 inode->i_atime = *now;
5404 return btrfs_dirty_inode(inode);
5405}
5406
5407
5408
5409
5410
5411
5412static int btrfs_set_inode_index_count(struct inode *inode)
5413{
5414 struct btrfs_root *root = BTRFS_I(inode)->root;
5415 struct btrfs_key key, found_key;
5416 struct btrfs_path *path;
5417 struct extent_buffer *leaf;
5418 int ret;
5419
5420 key.objectid = btrfs_ino(inode);
5421 btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
5422 key.offset = (u64)-1;
5423
5424 path = btrfs_alloc_path();
5425 if (!path)
5426 return -ENOMEM;
5427
5428 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5429 if (ret < 0)
5430 goto out;
5431
5432 if (ret == 0)
5433 goto out;
5434 ret = 0;
5435
5436
5437
5438
5439
5440
5441
5442 if (path->slots[0] == 0) {
5443 BTRFS_I(inode)->index_cnt = 2;
5444 goto out;
5445 }
5446
5447 path->slots[0]--;
5448
5449 leaf = path->nodes[0];
5450 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
5451
5452 if (found_key.objectid != btrfs_ino(inode) ||
5453 btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
5454 BTRFS_I(inode)->index_cnt = 2;
5455 goto out;
5456 }
5457
5458 BTRFS_I(inode)->index_cnt = found_key.offset + 1;
5459out:
5460 btrfs_free_path(path);
5461 return ret;
5462}
5463
5464
5465
5466
5467
5468int btrfs_set_inode_index(struct inode *dir, u64 *index)
5469{
5470 int ret = 0;
5471
5472 if (BTRFS_I(dir)->index_cnt == (u64)-1) {
5473 ret = btrfs_inode_delayed_dir_index_count(dir);
5474 if (ret) {
5475 ret = btrfs_set_inode_index_count(dir);
5476 if (ret)
5477 return ret;
5478 }
5479 }
5480
5481 *index = BTRFS_I(dir)->index_cnt;
5482 BTRFS_I(dir)->index_cnt++;
5483
5484 return ret;
5485}
5486
5487static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
5488 struct btrfs_root *root,
5489 struct inode *dir,
5490 const char *name, int name_len,
5491 u64 ref_objectid, u64 objectid,
5492 umode_t mode, u64 *index)
5493{
5494 struct inode *inode;
5495 struct btrfs_inode_item *inode_item;
5496 struct btrfs_key *location;
5497 struct btrfs_path *path;
5498 struct btrfs_inode_ref *ref;
5499 struct btrfs_key key[2];
5500 u32 sizes[2];
5501 unsigned long ptr;
5502 int ret;
5503 int owner;
5504
5505 path = btrfs_alloc_path();
5506 if (!path)
5507 return ERR_PTR(-ENOMEM);
5508
5509 inode = new_inode(root->fs_info->sb);
5510 if (!inode) {
5511 btrfs_free_path(path);
5512 return ERR_PTR(-ENOMEM);
5513 }
5514
5515
5516
5517
5518
5519 inode->i_ino = objectid;
5520
5521 if (dir) {
5522 trace_btrfs_inode_request(dir);
5523
5524 ret = btrfs_set_inode_index(dir, index);
5525 if (ret) {
5526 btrfs_free_path(path);
5527 iput(inode);
5528 return ERR_PTR(ret);
5529 }
5530 }
5531
5532
5533
5534
5535
5536 BTRFS_I(inode)->index_cnt = 2;
5537 BTRFS_I(inode)->root = root;
5538 BTRFS_I(inode)->generation = trans->transid;
5539 inode->i_generation = BTRFS_I(inode)->generation;
5540
5541
5542
5543
5544
5545
5546
5547 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
5548
5549 if (S_ISDIR(mode))
5550 owner = 0;
5551 else
5552 owner = 1;
5553
5554 key[0].objectid = objectid;
5555 btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
5556 key[0].offset = 0;
5557
5558
5559
5560
5561
5562
5563
5564 key[1].objectid = objectid;
5565 btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
5566 key[1].offset = ref_objectid;
5567
5568 sizes[0] = sizeof(struct btrfs_inode_item);
5569 sizes[1] = name_len + sizeof(*ref);
5570
5571 path->leave_spinning = 1;
5572 ret = btrfs_insert_empty_items(trans, root, path, key, sizes, 2);
5573 if (ret != 0)
5574 goto fail;
5575
5576 inode_init_owner(inode, dir, mode);
5577 inode_set_bytes(inode, 0);
5578 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
5579 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
5580 struct btrfs_inode_item);
5581 memset_extent_buffer(path->nodes[0], 0, (unsigned long)inode_item,
5582 sizeof(*inode_item));
5583 fill_inode_item(trans, path->nodes[0], inode_item, inode);
5584
5585 ref = btrfs_item_ptr(path->nodes[0], path->slots[0] + 1,
5586 struct btrfs_inode_ref);
5587 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len);
5588 btrfs_set_inode_ref_index(path->nodes[0], ref, *index);
5589 ptr = (unsigned long)(ref + 1);
5590 write_extent_buffer(path->nodes[0], name, ptr, name_len);
5591
5592 btrfs_mark_buffer_dirty(path->nodes[0]);
5593 btrfs_free_path(path);
5594
5595 location = &BTRFS_I(inode)->location;
5596 location->objectid = objectid;
5597 location->offset = 0;
5598 btrfs_set_key_type(location, BTRFS_INODE_ITEM_KEY);
5599
5600 btrfs_inherit_iflags(inode, dir);
5601
5602 if (S_ISREG(mode)) {
5603 if (btrfs_test_opt(root, NODATASUM))
5604 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
5605 if (btrfs_test_opt(root, NODATACOW))
5606 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW |
5607 BTRFS_INODE_NODATASUM;
5608 }
5609
5610 insert_inode_hash(inode);
5611 inode_tree_add(inode);
5612
5613 trace_btrfs_inode_new(inode);
5614 btrfs_set_inode_last_trans(trans, inode);
5615
5616 btrfs_update_root_times(trans, root);
5617
5618 return inode;
5619fail:
5620 if (dir)
5621 BTRFS_I(dir)->index_cnt--;
5622 btrfs_free_path(path);
5623 iput(inode);
5624 return ERR_PTR(ret);
5625}
5626
5627static inline u8 btrfs_inode_type(struct inode *inode)
5628{
5629 return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT];
5630}
5631
5632
5633
5634
5635
5636
5637
5638int btrfs_add_link(struct btrfs_trans_handle *trans,
5639 struct inode *parent_inode, struct inode *inode,
5640 const char *name, int name_len, int add_backref, u64 index)
5641{
5642 int ret = 0;
5643 struct btrfs_key key;
5644 struct btrfs_root *root = BTRFS_I(parent_inode)->root;
5645 u64 ino = btrfs_ino(inode);
5646 u64 parent_ino = btrfs_ino(parent_inode);
5647
5648 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5649 memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
5650 } else {
5651 key.objectid = ino;
5652 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
5653 key.offset = 0;
5654 }
5655
5656 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5657 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
5658 key.objectid, root->root_key.objectid,
5659 parent_ino, index, name, name_len);
5660 } else if (add_backref) {
5661 ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
5662 parent_ino, index);
5663 }
5664
5665
5666 if (ret)
5667 return ret;
5668
5669 ret = btrfs_insert_dir_item(trans, root, name, name_len,
5670 parent_inode, &key,
5671 btrfs_inode_type(inode), index);
5672 if (ret == -EEXIST || ret == -EOVERFLOW)
5673 goto fail_dir_item;
5674 else if (ret) {
5675 btrfs_abort_transaction(trans, root, ret);
5676 return ret;
5677 }
5678
5679 btrfs_i_size_write(parent_inode, parent_inode->i_size +
5680 name_len * 2);
5681 inode_inc_iversion(parent_inode);
5682 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
5683 ret = btrfs_update_inode(trans, root, parent_inode);
5684 if (ret)
5685 btrfs_abort_transaction(trans, root, ret);
5686 return ret;
5687
5688fail_dir_item:
5689 if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
5690 u64 local_index;
5691 int err;
5692 err = btrfs_del_root_ref(trans, root->fs_info->tree_root,
5693 key.objectid, root->root_key.objectid,
5694 parent_ino, &local_index, name, name_len);
5695
5696 } else if (add_backref) {
5697 u64 local_index;
5698 int err;
5699
5700 err = btrfs_del_inode_ref(trans, root, name, name_len,
5701 ino, parent_ino, &local_index);
5702 }
5703 return ret;
5704}
5705
5706static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
5707 struct inode *dir, struct dentry *dentry,
5708 struct inode *inode, int backref, u64 index)
5709{
5710 int err = btrfs_add_link(trans, dir, inode,
5711 dentry->d_name.name, dentry->d_name.len,
5712 backref, index);
5713 if (err > 0)
5714 err = -EEXIST;
5715 return err;
5716}
5717
5718static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
5719 umode_t mode, dev_t rdev)
5720{
5721 struct btrfs_trans_handle *trans;
5722 struct btrfs_root *root = BTRFS_I(dir)->root;
5723 struct inode *inode = NULL;
5724 int err;
5725 int drop_inode = 0;
5726 u64 objectid;
5727 u64 index = 0;
5728
5729 if (!new_valid_dev(rdev))
5730 return -EINVAL;
5731
5732
5733
5734
5735
5736
5737 trans = btrfs_start_transaction(root, 5);
5738 if (IS_ERR(trans))
5739 return PTR_ERR(trans);
5740
5741 err = btrfs_find_free_ino(root, &objectid);
5742 if (err)
5743 goto out_unlock;
5744
5745 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
5746 dentry->d_name.len, btrfs_ino(dir), objectid,
5747 mode, &index);
5748 if (IS_ERR(inode)) {
5749 err = PTR_ERR(inode);
5750 goto out_unlock;
5751 }
5752
5753 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
5754 if (err) {
5755 drop_inode = 1;
5756 goto out_unlock;
5757 }
5758
5759
5760
5761
5762
5763
5764
5765
5766 inode->i_op = &btrfs_special_inode_operations;
5767 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
5768 if (err)
5769 drop_inode = 1;
5770 else {
5771 init_special_inode(inode, inode->i_mode, rdev);
5772 btrfs_update_inode(trans, root, inode);
5773 d_instantiate(dentry, inode);
5774 }
5775out_unlock:
5776 btrfs_end_transaction(trans, root);
5777 btrfs_btree_balance_dirty(root);
5778 if (drop_inode) {
5779 inode_dec_link_count(inode);
5780 iput(inode);
5781 }
5782 return err;
5783}
5784
5785static int btrfs_create(struct inode *dir, struct dentry *dentry,
5786 umode_t mode, bool excl)
5787{
5788 struct btrfs_trans_handle *trans;
5789 struct btrfs_root *root = BTRFS_I(dir)->root;
5790 struct inode *inode = NULL;
5791 int drop_inode_on_err = 0;
5792 int err;
5793 u64 objectid;
5794 u64 index = 0;
5795
5796
5797
5798
5799
5800
5801 trans = btrfs_start_transaction(root, 5);
5802 if (IS_ERR(trans))
5803 return PTR_ERR(trans);
5804
5805 err = btrfs_find_free_ino(root, &objectid);
5806 if (err)
5807 goto out_unlock;
5808
5809 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
5810 dentry->d_name.len, btrfs_ino(dir), objectid,
5811 mode, &index);
5812 if (IS_ERR(inode)) {
5813 err = PTR_ERR(inode);
5814 goto out_unlock;
5815 }
5816 drop_inode_on_err = 1;
5817
5818 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
5819 if (err)
5820 goto out_unlock;
5821
5822 err = btrfs_update_inode(trans, root, inode);
5823 if (err)
5824 goto out_unlock;
5825
5826
5827
5828
5829
5830
5831
5832 inode->i_fop = &btrfs_file_operations;
5833 inode->i_op = &btrfs_file_inode_operations;
5834
5835 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
5836 if (err)
5837 goto out_unlock;
5838
5839 inode->i_mapping->a_ops = &btrfs_aops;
5840 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
5841 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
5842 d_instantiate(dentry, inode);
5843
5844out_unlock:
5845 btrfs_end_transaction(trans, root);
5846 if (err && drop_inode_on_err) {
5847 inode_dec_link_count(inode);
5848 iput(inode);
5849 }
5850 btrfs_btree_balance_dirty(root);
5851 return err;
5852}
5853
5854static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
5855 struct dentry *dentry)
5856{
5857 struct btrfs_trans_handle *trans;
5858 struct btrfs_root *root = BTRFS_I(dir)->root;
5859 struct inode *inode = old_dentry->d_inode;
5860 u64 index;
5861 int err;
5862 int drop_inode = 0;
5863
5864
5865 if (root->objectid != BTRFS_I(inode)->root->objectid)
5866 return -EXDEV;
5867
5868 if (inode->i_nlink >= BTRFS_LINK_MAX)
5869 return -EMLINK;
5870
5871 err = btrfs_set_inode_index(dir, &index);
5872 if (err)
5873 goto fail;
5874
5875
5876
5877
5878
5879
5880 trans = btrfs_start_transaction(root, 5);
5881 if (IS_ERR(trans)) {
5882 err = PTR_ERR(trans);
5883 goto fail;
5884 }
5885
5886 btrfs_inc_nlink(inode);
5887 inode_inc_iversion(inode);
5888 inode->i_ctime = CURRENT_TIME;
5889 ihold(inode);
5890 set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
5891
5892 err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
5893
5894 if (err) {
5895 drop_inode = 1;
5896 } else {
5897 struct dentry *parent = dentry->d_parent;
5898 err = btrfs_update_inode(trans, root, inode);
5899 if (err)
5900 goto fail;
5901 d_instantiate(dentry, inode);
5902 btrfs_log_new_name(trans, inode, NULL, parent);
5903 }
5904
5905 btrfs_end_transaction(trans, root);
5906fail:
5907 if (drop_inode) {
5908 inode_dec_link_count(inode);
5909 iput(inode);
5910 }
5911 btrfs_btree_balance_dirty(root);
5912 return err;
5913}
5914
5915static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
5916{
5917 struct inode *inode = NULL;
5918 struct btrfs_trans_handle *trans;
5919 struct btrfs_root *root = BTRFS_I(dir)->root;
5920 int err = 0;
5921 int drop_on_err = 0;
5922 u64 objectid = 0;
5923 u64 index = 0;
5924
5925
5926
5927
5928
5929
5930 trans = btrfs_start_transaction(root, 5);
5931 if (IS_ERR(trans))
5932 return PTR_ERR(trans);
5933
5934 err = btrfs_find_free_ino(root, &objectid);
5935 if (err)
5936 goto out_fail;
5937
5938 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
5939 dentry->d_name.len, btrfs_ino(dir), objectid,
5940 S_IFDIR | mode, &index);
5941 if (IS_ERR(inode)) {
5942 err = PTR_ERR(inode);
5943 goto out_fail;
5944 }
5945
5946 drop_on_err = 1;
5947
5948 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
5949 if (err)
5950 goto out_fail;
5951
5952 inode->i_op = &btrfs_dir_inode_operations;
5953 inode->i_fop = &btrfs_dir_file_operations;
5954
5955 btrfs_i_size_write(inode, 0);
5956 err = btrfs_update_inode(trans, root, inode);
5957 if (err)
5958 goto out_fail;
5959
5960 err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
5961 dentry->d_name.len, 0, index);
5962 if (err)
5963 goto out_fail;
5964
5965 d_instantiate(dentry, inode);
5966 drop_on_err = 0;
5967
5968out_fail:
5969 btrfs_end_transaction(trans, root);
5970 if (drop_on_err)
5971 iput(inode);
5972 btrfs_btree_balance_dirty(root);
5973 return err;
5974}
5975
5976
5977
5978
5979
5980static int merge_extent_mapping(struct extent_map_tree *em_tree,
5981 struct extent_map *existing,
5982 struct extent_map *em,
5983 u64 map_start, u64 map_len)
5984{
5985 u64 start_diff;
5986
5987 BUG_ON(map_start < em->start || map_start >= extent_map_end(em));
5988 start_diff = map_start - em->start;
5989 em->start = map_start;
5990 em->len = map_len;
5991 if (em->block_start < EXTENT_MAP_LAST_BYTE &&
5992 !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
5993 em->block_start += start_diff;
5994 em->block_len -= start_diff;
5995 }
5996 return add_extent_mapping(em_tree, em, 0);
5997}
5998
5999static noinline int uncompress_inline(struct btrfs_path *path,
6000 struct inode *inode, struct page *page,
6001 size_t pg_offset, u64 extent_offset,
6002 struct btrfs_file_extent_item *item)
6003{
6004 int ret;
6005 struct extent_buffer *leaf = path->nodes[0];
6006 char *tmp;
6007 size_t max_size;
6008 unsigned long inline_size;
6009 unsigned long ptr;
6010 int compress_type;
6011
6012 WARN_ON(pg_offset != 0);
6013 compress_type = btrfs_file_extent_compression(leaf, item);
6014 max_size = btrfs_file_extent_ram_bytes(leaf, item);
6015 inline_size = btrfs_file_extent_inline_item_len(leaf,
6016 btrfs_item_nr(leaf, path->slots[0]));
6017 tmp = kmalloc(inline_size, GFP_NOFS);
6018 if (!tmp)
6019 return -ENOMEM;
6020 ptr = btrfs_file_extent_inline_start(item);
6021
6022 read_extent_buffer(leaf, tmp, ptr, inline_size);
6023
6024 max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
6025 ret = btrfs_decompress(compress_type, tmp, page,
6026 extent_offset, inline_size, max_size);
6027 if (ret) {
6028 char *kaddr = kmap_atomic(page);
6029 unsigned long copy_size = min_t(u64,
6030 PAGE_CACHE_SIZE - pg_offset,
6031 max_size - extent_offset);
6032 memset(kaddr + pg_offset, 0, copy_size);
6033 kunmap_atomic(kaddr);
6034 }
6035 kfree(tmp);
6036 return 0;
6037}
6038
6039
6040
6041
6042
6043
6044
6045
6046
6047
6048struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
6049 size_t pg_offset, u64 start, u64 len,
6050 int create)
6051{
6052 int ret;
6053 int err = 0;
6054 u64 bytenr;
6055 u64 extent_start = 0;
6056 u64 extent_end = 0;
6057 u64 objectid = btrfs_ino(inode);
6058 u32 found_type;
6059 struct btrfs_path *path = NULL;
6060 struct btrfs_root *root = BTRFS_I(inode)->root;
6061 struct btrfs_file_extent_item *item;
6062 struct extent_buffer *leaf;
6063 struct btrfs_key found_key;
6064 struct extent_map *em = NULL;
6065 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
6066 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
6067 struct btrfs_trans_handle *trans = NULL;
6068 int compress_type;
6069
6070again:
6071 read_lock(&em_tree->lock);
6072 em = lookup_extent_mapping(em_tree, start, len);
6073 if (em)
6074 em->bdev = root->fs_info->fs_devices->latest_bdev;
6075 read_unlock(&em_tree->lock);
6076
6077 if (em) {
6078 if (em->start > start || em->start + em->len <= start)
6079 free_extent_map(em);
6080 else if (em->block_start == EXTENT_MAP_INLINE && page)
6081 free_extent_map(em);
6082 else
6083 goto out;
6084 }
6085 em = alloc_extent_map();
6086 if (!em) {
6087 err = -ENOMEM;
6088 goto out;
6089 }
6090 em->bdev = root->fs_info->fs_devices->latest_bdev;
6091 em->start = EXTENT_MAP_HOLE;
6092 em->orig_start = EXTENT_MAP_HOLE;
6093 em->len = (u64)-1;
6094 em->block_len = (u64)-1;
6095
6096 if (!path) {
6097 path = btrfs_alloc_path();
6098 if (!path) {
6099 err = -ENOMEM;
6100 goto out;
6101 }
6102
6103
6104
6105
6106 path->reada = 1;
6107 }
6108
6109 ret = btrfs_lookup_file_extent(trans, root, path,
6110 objectid, start, trans != NULL);
6111 if (ret < 0) {
6112 err = ret;
6113 goto out;
6114 }
6115
6116 if (ret != 0) {
6117 if (path->slots[0] == 0)
6118 goto not_found;
6119 path->slots[0]--;
6120 }
6121
6122 leaf = path->nodes[0];
6123 item = btrfs_item_ptr(leaf, path->slots[0],
6124 struct btrfs_file_extent_item);
6125
6126 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6127 found_type = btrfs_key_type(&found_key);
6128 if (found_key.objectid != objectid ||
6129 found_type != BTRFS_EXTENT_DATA_KEY) {
6130 goto not_found;
6131 }
6132
6133 found_type = btrfs_file_extent_type(leaf, item);
6134 extent_start = found_key.offset;
6135 compress_type = btrfs_file_extent_compression(leaf, item);
6136 if (found_type == BTRFS_FILE_EXTENT_REG ||
6137 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
6138 extent_end = extent_start +
6139 btrfs_file_extent_num_bytes(leaf, item);
6140 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
6141 size_t size;
6142 size = btrfs_file_extent_inline_len(leaf, item);
6143 extent_end = ALIGN(extent_start + size, root->sectorsize);
6144 }
6145
6146 if (start >= extent_end) {
6147 path->slots[0]++;
6148 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
6149 ret = btrfs_next_leaf(root, path);
6150 if (ret < 0) {
6151 err = ret;
6152 goto out;
6153 }
6154 if (ret > 0)
6155 goto not_found;
6156 leaf = path->nodes[0];
6157 }
6158 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6159 if (found_key.objectid != objectid ||
6160 found_key.type != BTRFS_EXTENT_DATA_KEY)
6161 goto not_found;
6162 if (start + len <= found_key.offset)
6163 goto not_found;
6164 em->start = start;
6165 em->orig_start = start;
6166 em->len = found_key.offset - start;
6167 goto not_found_em;
6168 }
6169
6170 em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, item);
6171 if (found_type == BTRFS_FILE_EXTENT_REG ||
6172 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
6173 em->start = extent_start;
6174 em->len = extent_end - extent_start;
6175 em->orig_start = extent_start -
6176 btrfs_file_extent_offset(leaf, item);
6177 em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
6178 item);
6179 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
6180 if (bytenr == 0) {
6181 em->block_start = EXTENT_MAP_HOLE;
6182 goto insert;
6183 }
6184 if (compress_type != BTRFS_COMPRESS_NONE) {
6185 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
6186 em->compress_type = compress_type;
6187 em->block_start = bytenr;
6188 em->block_len = em->orig_block_len;
6189 } else {
6190 bytenr += btrfs_file_extent_offset(leaf, item);
6191 em->block_start = bytenr;
6192 em->block_len = em->len;
6193 if (found_type == BTRFS_FILE_EXTENT_PREALLOC)
6194 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
6195 }
6196 goto insert;
6197 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
6198 unsigned long ptr;
6199 char *map;
6200 size_t size;
6201 size_t extent_offset;
6202 size_t copy_size;
6203
6204 em->block_start = EXTENT_MAP_INLINE;
6205 if (!page || create) {
6206 em->start = extent_start;
6207 em->len = extent_end - extent_start;
6208 goto out;
6209 }
6210
6211 size = btrfs_file_extent_inline_len(leaf, item);
6212 extent_offset = page_offset(page) + pg_offset - extent_start;
6213 copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
6214 size - extent_offset);
6215 em->start = extent_start + extent_offset;
6216 em->len = ALIGN(copy_size, root->sectorsize);
6217 em->orig_block_len = em->len;
6218 em->orig_start = em->start;
6219 if (compress_type) {
6220 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
6221 em->compress_type = compress_type;
6222 }
6223 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
6224 if (create == 0 && !PageUptodate(page)) {
6225 if (btrfs_file_extent_compression(leaf, item) !=
6226 BTRFS_COMPRESS_NONE) {
6227 ret = uncompress_inline(path, inode, page,
6228 pg_offset,
6229 extent_offset, item);
6230 BUG_ON(ret);
6231 } else {
6232 map = kmap(page);
6233 read_extent_buffer(leaf, map + pg_offset, ptr,
6234 copy_size);
6235 if (pg_offset + copy_size < PAGE_CACHE_SIZE) {
6236 memset(map + pg_offset + copy_size, 0,
6237 PAGE_CACHE_SIZE - pg_offset -
6238 copy_size);
6239 }
6240 kunmap(page);
6241 }
6242 flush_dcache_page(page);
6243 } else if (create && PageUptodate(page)) {
6244 BUG();
6245 if (!trans) {
6246 kunmap(page);
6247 free_extent_map(em);
6248 em = NULL;
6249
6250 btrfs_release_path(path);
6251 trans = btrfs_join_transaction(root);
6252
6253 if (IS_ERR(trans))
6254 return ERR_CAST(trans);
6255 goto again;
6256 }
6257 map = kmap(page);
6258 write_extent_buffer(leaf, map + pg_offset, ptr,
6259 copy_size);
6260 kunmap(page);
6261 btrfs_mark_buffer_dirty(leaf);
6262 }
6263 set_extent_uptodate(io_tree, em->start,
6264 extent_map_end(em) - 1, NULL, GFP_NOFS);
6265 goto insert;
6266 } else {
6267 WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
6268 }
6269not_found:
6270 em->start = start;
6271 em->orig_start = start;
6272 em->len = len;
6273not_found_em:
6274 em->block_start = EXTENT_MAP_HOLE;
6275 set_bit(EXTENT_FLAG_VACANCY, &em->flags);
6276insert:
6277 btrfs_release_path(path);
6278 if (em->start > start || extent_map_end(em) <= start) {
6279 btrfs_err(root->fs_info, "bad extent! em: [%llu %llu] passed [%llu %llu]",
6280 (unsigned long long)em->start,
6281 (unsigned long long)em->len,
6282 (unsigned long long)start,
6283 (unsigned long long)len);
6284 err = -EIO;
6285 goto out;
6286 }
6287
6288 err = 0;
6289 write_lock(&em_tree->lock);
6290 ret = add_extent_mapping(em_tree, em, 0);
6291
6292
6293
6294
6295 if (ret == -EEXIST) {
6296 struct extent_map *existing;
6297
6298 ret = 0;
6299
6300 existing = lookup_extent_mapping(em_tree, start, len);
6301 if (existing && (existing->start > start ||
6302 existing->start + existing->len <= start)) {
6303 free_extent_map(existing);
6304 existing = NULL;
6305 }
6306 if (!existing) {
6307 existing = lookup_extent_mapping(em_tree, em->start,
6308 em->len);
6309 if (existing) {
6310 err = merge_extent_mapping(em_tree, existing,
6311 em, start,
6312 root->sectorsize);
6313 free_extent_map(existing);
6314 if (err) {
6315 free_extent_map(em);
6316 em = NULL;
6317 }
6318 } else {
6319 err = -EIO;
6320 free_extent_map(em);
6321 em = NULL;
6322 }
6323 } else {
6324 free_extent_map(em);
6325 em = existing;
6326 err = 0;
6327 }
6328 }
6329 write_unlock(&em_tree->lock);
6330out:
6331
6332 if (em)
6333 trace_btrfs_get_extent(root, em);
6334
6335 if (path)
6336 btrfs_free_path(path);
6337 if (trans) {
6338 ret = btrfs_end_transaction(trans, root);
6339 if (!err)
6340 err = ret;
6341 }
6342 if (err) {
6343 free_extent_map(em);
6344 return ERR_PTR(err);
6345 }
6346 BUG_ON(!em);
6347 return em;
6348}
6349
6350struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
6351 size_t pg_offset, u64 start, u64 len,
6352 int create)
6353{
6354 struct extent_map *em;
6355 struct extent_map *hole_em = NULL;
6356 u64 range_start = start;
6357 u64 end;
6358 u64 found;
6359 u64 found_end;
6360 int err = 0;
6361
6362 em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
6363 if (IS_ERR(em))
6364 return em;
6365 if (em) {
6366
6367
6368
6369
6370
6371
6372 if (em->block_start != EXTENT_MAP_HOLE &&
6373 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
6374 return em;
6375 else
6376 hole_em = em;
6377 }
6378
6379
6380 end = start + len;
6381 if (end < start)
6382 end = (u64)-1;
6383 else
6384 end -= 1;
6385
6386 em = NULL;
6387
6388
6389 found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
6390 end, len, EXTENT_DELALLOC, 1);
6391 found_end = range_start + found;
6392 if (found_end < range_start)
6393 found_end = (u64)-1;
6394
6395
6396
6397
6398
6399 if (range_start > end || found_end <= start) {
6400 em = hole_em;
6401 hole_em = NULL;
6402 goto out;
6403 }
6404
6405
6406
6407
6408 range_start = max(start,range_start);
6409 found = found_end - range_start;
6410
6411 if (found > 0) {
6412 u64 hole_start = start;
6413 u64 hole_len = len;
6414
6415 em = alloc_extent_map();
6416 if (!em) {
6417 err = -ENOMEM;
6418 goto out;
6419 }
6420
6421
6422
6423
6424
6425
6426
6427
6428 if (hole_em) {
6429 u64 calc_end = extent_map_end(hole_em);
6430
6431 if (calc_end <= start || (hole_em->start > end)) {
6432 free_extent_map(hole_em);
6433 hole_em = NULL;
6434 } else {
6435 hole_start = max(hole_em->start, start);
6436 hole_len = calc_end - hole_start;
6437 }
6438 }
6439 em->bdev = NULL;
6440 if (hole_em && range_start > hole_start) {
6441
6442
6443
6444
6445 em->len = min(hole_len,
6446 range_start - hole_start);
6447 em->start = hole_start;
6448 em->orig_start = hole_start;
6449
6450
6451
6452
6453 em->block_start = hole_em->block_start;
6454 em->block_len = hole_len;
6455 if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))
6456 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
6457 } else {
6458 em->start = range_start;
6459 em->len = found;
6460 em->orig_start = range_start;
6461 em->block_start = EXTENT_MAP_DELALLOC;
6462 em->block_len = found;
6463 }
6464 } else if (hole_em) {
6465 return hole_em;
6466 }
6467out:
6468
6469 free_extent_map(hole_em);
6470 if (err) {
6471 free_extent_map(em);
6472 return ERR_PTR(err);
6473 }
6474 return em;
6475}
6476
6477static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
6478 u64 start, u64 len)
6479{
6480 struct btrfs_root *root = BTRFS_I(inode)->root;
6481 struct btrfs_trans_handle *trans;
6482 struct extent_map *em;
6483 struct btrfs_key ins;
6484 u64 alloc_hint;
6485 int ret;
6486
6487 trans = btrfs_join_transaction(root);
6488 if (IS_ERR(trans))
6489 return ERR_CAST(trans);
6490
6491 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
6492
6493 alloc_hint = get_extent_allocation_hint(inode, start, len);
6494 ret = btrfs_reserve_extent(trans, root, len, root->sectorsize, 0,
6495 alloc_hint, &ins, 1);
6496 if (ret) {
6497 em = ERR_PTR(ret);
6498 goto out;
6499 }
6500
6501 em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
6502 ins.offset, ins.offset, ins.offset, 0);
6503 if (IS_ERR(em))
6504 goto out;
6505
6506 ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
6507 ins.offset, ins.offset, 0);
6508 if (ret) {
6509 btrfs_free_reserved_extent(root, ins.objectid, ins.offset);
6510 em = ERR_PTR(ret);
6511 }
6512out:
6513 btrfs_end_transaction(trans, root);
6514 return em;
6515}
6516
6517
6518
6519
6520
6521static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
6522 struct inode *inode, u64 offset, u64 *len,
6523 u64 *orig_start, u64 *orig_block_len,
6524 u64 *ram_bytes)
6525{
6526 struct btrfs_path *path;
6527 int ret;
6528 struct extent_buffer *leaf;
6529 struct btrfs_root *root = BTRFS_I(inode)->root;
6530 struct btrfs_file_extent_item *fi;
6531 struct btrfs_key key;
6532 u64 disk_bytenr;
6533 u64 backref_offset;
6534 u64 extent_end;
6535 u64 num_bytes;
6536 int slot;
6537 int found_type;
6538
6539 path = btrfs_alloc_path();
6540 if (!path)
6541 return -ENOMEM;
6542
6543 ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
6544 offset, 0);
6545 if (ret < 0)
6546 goto out;
6547
6548 slot = path->slots[0];
6549 if (ret == 1) {
6550 if (slot == 0) {
6551
6552 ret = 0;
6553 goto out;
6554 }
6555 slot--;
6556 }
6557 ret = 0;
6558 leaf = path->nodes[0];
6559 btrfs_item_key_to_cpu(leaf, &key, slot);
6560 if (key.objectid != btrfs_ino(inode) ||
6561 key.type != BTRFS_EXTENT_DATA_KEY) {
6562
6563 goto out;
6564 }
6565
6566 if (key.offset > offset) {
6567
6568 goto out;
6569 }
6570
6571 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
6572 found_type = btrfs_file_extent_type(leaf, fi);
6573 if (found_type != BTRFS_FILE_EXTENT_REG &&
6574 found_type != BTRFS_FILE_EXTENT_PREALLOC) {
6575
6576 goto out;
6577 }
6578 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
6579 backref_offset = btrfs_file_extent_offset(leaf, fi);
6580
6581 *orig_start = key.offset - backref_offset;
6582 *orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
6583 *ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
6584
6585 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
6586 if (extent_end < offset + *len) {
6587
6588 goto out;
6589 }
6590
6591 if (btrfs_extent_readonly(root, disk_bytenr))
6592 goto out;
6593
6594
6595
6596
6597
6598 if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
6599 key.offset - backref_offset, disk_bytenr))
6600 goto out;
6601
6602
6603
6604
6605
6606
6607
6608 disk_bytenr += backref_offset;
6609 disk_bytenr += offset - key.offset;
6610 num_bytes = min(offset + *len, extent_end) - offset;
6611 if (csum_exist_in_range(root, disk_bytenr, num_bytes))
6612 goto out;
6613
6614
6615
6616
6617 *len = num_bytes;
6618 ret = 1;
6619out:
6620 btrfs_free_path(path);
6621 return ret;
6622}
6623
6624static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
6625 struct extent_state **cached_state, int writing)
6626{
6627 struct btrfs_ordered_extent *ordered;
6628 int ret = 0;
6629
6630 while (1) {
6631 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
6632 0, cached_state);
6633
6634
6635
6636
6637
6638 ordered = btrfs_lookup_ordered_range(inode, lockstart,
6639 lockend - lockstart + 1);
6640
6641
6642
6643
6644
6645
6646
6647
6648 if (!ordered && (!writing ||
6649 !test_range_bit(&BTRFS_I(inode)->io_tree,
6650 lockstart, lockend, EXTENT_UPTODATE, 0,
6651 *cached_state)))
6652 break;
6653
6654 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
6655 cached_state, GFP_NOFS);
6656
6657 if (ordered) {
6658 btrfs_start_ordered_extent(inode, ordered, 1);
6659 btrfs_put_ordered_extent(ordered);
6660 } else {
6661
6662 ret = filemap_write_and_wait_range(inode->i_mapping,
6663 lockstart,
6664 lockend);
6665 if (ret)
6666 break;
6667
6668
6669
6670
6671
6672 ret = invalidate_inode_pages2_range(inode->i_mapping,
6673 lockstart >> PAGE_CACHE_SHIFT,
6674 lockend >> PAGE_CACHE_SHIFT);
6675 if (ret)
6676 break;
6677 }
6678
6679 cond_resched();
6680 }
6681
6682 return ret;
6683}
6684
6685static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
6686 u64 len, u64 orig_start,
6687 u64 block_start, u64 block_len,
6688 u64 orig_block_len, u64 ram_bytes,
6689 int type)
6690{
6691 struct extent_map_tree *em_tree;
6692 struct extent_map *em;
6693 struct btrfs_root *root = BTRFS_I(inode)->root;
6694 int ret;
6695
6696 em_tree = &BTRFS_I(inode)->extent_tree;
6697 em = alloc_extent_map();
6698 if (!em)
6699 return ERR_PTR(-ENOMEM);
6700
6701 em->start = start;
6702 em->orig_start = orig_start;
6703 em->mod_start = start;
6704 em->mod_len = len;
6705 em->len = len;
6706 em->block_len = block_len;
6707 em->block_start = block_start;
6708 em->bdev = root->fs_info->fs_devices->latest_bdev;
6709 em->orig_block_len = orig_block_len;
6710 em->ram_bytes = ram_bytes;
6711 em->generation = -1;
6712 set_bit(EXTENT_FLAG_PINNED, &em->flags);
6713 if (type == BTRFS_ORDERED_PREALLOC)
6714 set_bit(EXTENT_FLAG_FILLING, &em->flags);
6715
6716 do {
6717 btrfs_drop_extent_cache(inode, em->start,
6718 em->start + em->len - 1, 0);
6719 write_lock(&em_tree->lock);
6720 ret = add_extent_mapping(em_tree, em, 1);
6721 write_unlock(&em_tree->lock);
6722 } while (ret == -EEXIST);
6723
6724 if (ret) {
6725 free_extent_map(em);
6726 return ERR_PTR(ret);
6727 }
6728
6729 return em;
6730}
6731
6732
6733static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
6734 struct buffer_head *bh_result, int create)
6735{
6736 struct extent_map *em;
6737 struct btrfs_root *root = BTRFS_I(inode)->root;
6738 struct extent_state *cached_state = NULL;
6739 u64 start = iblock << inode->i_blkbits;
6740 u64 lockstart, lockend;
6741 u64 len = bh_result->b_size;
6742 struct btrfs_trans_handle *trans;
6743 int unlock_bits = EXTENT_LOCKED;
6744 int ret = 0;
6745
6746 if (create)
6747 unlock_bits |= EXTENT_DELALLOC | EXTENT_DIRTY;
6748 else
6749 len = min_t(u64, len, root->sectorsize);
6750
6751 lockstart = start;
6752 lockend = start + len - 1;
6753
6754
6755
6756
6757
6758 if (lock_extent_direct(inode, lockstart, lockend, &cached_state, create))
6759 return -ENOTBLK;
6760
6761 em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
6762 if (IS_ERR(em)) {
6763 ret = PTR_ERR(em);
6764 goto unlock_err;
6765 }
6766
6767
6768
6769
6770
6771
6772
6773
6774
6775
6776
6777
6778
6779
6780
6781 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) ||
6782 em->block_start == EXTENT_MAP_INLINE) {
6783 free_extent_map(em);
6784 ret = -ENOTBLK;
6785 goto unlock_err;
6786 }
6787
6788
6789 if (!create && (em->block_start == EXTENT_MAP_HOLE ||
6790 test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
6791 free_extent_map(em);
6792 goto unlock_err;
6793 }
6794
6795
6796
6797
6798
6799
6800
6801
6802
6803
6804 if (!create) {
6805 len = min(len, em->len - (start - em->start));
6806 lockstart = start + len;
6807 goto unlock;
6808 }
6809
6810 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
6811 ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW) &&
6812 em->block_start != EXTENT_MAP_HOLE)) {
6813 int type;
6814 int ret;
6815 u64 block_start, orig_start, orig_block_len, ram_bytes;
6816
6817 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
6818 type = BTRFS_ORDERED_PREALLOC;
6819 else
6820 type = BTRFS_ORDERED_NOCOW;
6821 len = min(len, em->len - (start - em->start));
6822 block_start = em->block_start + (start - em->start);
6823
6824
6825
6826
6827
6828
6829 trans = btrfs_join_transaction(root);
6830 if (IS_ERR(trans))
6831 goto must_cow;
6832
6833 if (can_nocow_odirect(trans, inode, start, &len, &orig_start,
6834 &orig_block_len, &ram_bytes) == 1) {
6835 if (type == BTRFS_ORDERED_PREALLOC) {
6836 free_extent_map(em);
6837 em = create_pinned_em(inode, start, len,
6838 orig_start,
6839 block_start, len,
6840 orig_block_len,
6841 ram_bytes, type);
6842 if (IS_ERR(em)) {
6843 btrfs_end_transaction(trans, root);
6844 goto unlock_err;
6845 }
6846 }
6847
6848 ret = btrfs_add_ordered_extent_dio(inode, start,
6849 block_start, len, len, type);
6850 btrfs_end_transaction(trans, root);
6851 if (ret) {
6852 free_extent_map(em);
6853 goto unlock_err;
6854 }
6855 goto unlock;
6856 }
6857 btrfs_end_transaction(trans, root);
6858 }
6859must_cow:
6860
6861
6862
6863
6864 len = bh_result->b_size;
6865 free_extent_map(em);
6866 em = btrfs_new_extent_direct(inode, start, len);
6867 if (IS_ERR(em)) {
6868 ret = PTR_ERR(em);
6869 goto unlock_err;
6870 }
6871 len = min(len, em->len - (start - em->start));
6872unlock:
6873 bh_result->b_blocknr = (em->block_start + (start - em->start)) >>
6874 inode->i_blkbits;
6875 bh_result->b_size = len;
6876 bh_result->b_bdev = em->bdev;
6877 set_buffer_mapped(bh_result);
6878 if (create) {
6879 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
6880 set_buffer_new(bh_result);
6881
6882
6883
6884
6885
6886 if (start + len > i_size_read(inode))
6887 i_size_write(inode, start + len);
6888
6889 spin_lock(&BTRFS_I(inode)->lock);
6890 BTRFS_I(inode)->outstanding_extents++;
6891 spin_unlock(&BTRFS_I(inode)->lock);
6892
6893 ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
6894 lockstart + len - 1, EXTENT_DELALLOC, NULL,
6895 &cached_state, GFP_NOFS);
6896 BUG_ON(ret);
6897 }
6898
6899
6900
6901
6902
6903
6904 if (lockstart < lockend) {
6905 clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
6906 lockend, unlock_bits, 1, 0,
6907 &cached_state, GFP_NOFS);
6908 } else {
6909 free_extent_state(cached_state);
6910 }
6911
6912 free_extent_map(em);
6913
6914 return 0;
6915
6916unlock_err:
6917 clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
6918 unlock_bits, 1, 0, &cached_state, GFP_NOFS);
6919 return ret;
6920}
6921
6922struct btrfs_dio_private {
6923 struct inode *inode;
6924 u64 logical_offset;
6925 u64 disk_bytenr;
6926 u64 bytes;
6927 void *private;
6928
6929
6930 atomic_t pending_bios;
6931
6932
6933 int errors;
6934
6935
6936 struct bio *orig_bio;
6937
6938
6939 struct bio *dio_bio;
6940};
6941
6942static void btrfs_endio_direct_read(struct bio *bio, int err)
6943{
6944 struct btrfs_dio_private *dip = bio->bi_private;
6945 struct bio_vec *bvec_end = bio->bi_io_vec + bio->bi_vcnt - 1;
6946 struct bio_vec *bvec = bio->bi_io_vec;
6947 struct inode *inode = dip->inode;
6948 struct btrfs_root *root = BTRFS_I(inode)->root;
6949 struct bio *dio_bio;
6950 u64 start;
6951
6952 start = dip->logical_offset;
6953 do {
6954 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
6955 struct page *page = bvec->bv_page;
6956 char *kaddr;
6957 u32 csum = ~(u32)0;
6958 u64 private = ~(u32)0;
6959 unsigned long flags;
6960
6961 if (get_state_private(&BTRFS_I(inode)->io_tree,
6962 start, &private))
6963 goto failed;
6964 local_irq_save(flags);
6965 kaddr = kmap_atomic(page);
6966 csum = btrfs_csum_data(kaddr + bvec->bv_offset,
6967 csum, bvec->bv_len);
6968 btrfs_csum_final(csum, (char *)&csum);
6969 kunmap_atomic(kaddr);
6970 local_irq_restore(flags);
6971
6972 flush_dcache_page(bvec->bv_page);
6973 if (csum != private) {
6974failed:
6975 btrfs_err(root->fs_info, "csum failed ino %llu off %llu csum %u private %u",
6976 (unsigned long long)btrfs_ino(inode),
6977 (unsigned long long)start,
6978 csum, (unsigned)private);
6979 err = -EIO;
6980 }
6981 }
6982
6983 start += bvec->bv_len;
6984 bvec++;
6985 } while (bvec <= bvec_end);
6986
6987 unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset,
6988 dip->logical_offset + dip->bytes - 1);
6989 dio_bio = dip->dio_bio;
6990
6991 kfree(dip);
6992
6993
6994 if (err)
6995 clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
6996 dio_end_io(dio_bio, err);
6997 bio_put(bio);
6998}
6999
7000static void btrfs_endio_direct_write(struct bio *bio, int err)
7001{
7002 struct btrfs_dio_private *dip = bio->bi_private;
7003 struct inode *inode = dip->inode;
7004 struct btrfs_root *root = BTRFS_I(inode)->root;
7005 struct btrfs_ordered_extent *ordered = NULL;
7006 u64 ordered_offset = dip->logical_offset;
7007 u64 ordered_bytes = dip->bytes;
7008 struct bio *dio_bio;
7009 int ret;
7010
7011 if (err)
7012 goto out_done;
7013again:
7014 ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
7015 &ordered_offset,
7016 ordered_bytes, !err);
7017 if (!ret)
7018 goto out_test;
7019
7020 ordered->work.func = finish_ordered_fn;
7021 ordered->work.flags = 0;
7022 btrfs_queue_worker(&root->fs_info->endio_write_workers,
7023 &ordered->work);
7024out_test:
7025
7026
7027
7028
7029 if (ordered_offset < dip->logical_offset + dip->bytes) {
7030 ordered_bytes = dip->logical_offset + dip->bytes -
7031 ordered_offset;
7032 ordered = NULL;
7033 goto again;
7034 }
7035out_done:
7036 dio_bio = dip->dio_bio;
7037
7038 kfree(dip);
7039
7040
7041 if (err)
7042 clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
7043 dio_end_io(dio_bio, err);
7044 bio_put(bio);
7045}
7046
7047static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
7048 struct bio *bio, int mirror_num,
7049 unsigned long bio_flags, u64 offset)
7050{
7051 int ret;
7052 struct btrfs_root *root = BTRFS_I(inode)->root;
7053 ret = btrfs_csum_one_bio(root, inode, bio, offset, 1);
7054 BUG_ON(ret);
7055 return 0;
7056}
7057
7058static void btrfs_end_dio_bio(struct bio *bio, int err)
7059{
7060 struct btrfs_dio_private *dip = bio->bi_private;
7061
7062 if (err) {
7063 printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
7064 "sector %#Lx len %u err no %d\n",
7065 (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
7066 (unsigned long long)bio->bi_sector, bio->bi_size, err);
7067 dip->errors = 1;
7068
7069
7070
7071
7072
7073 smp_mb__before_atomic_dec();
7074 }
7075
7076
7077 if (!atomic_dec_and_test(&dip->pending_bios))
7078 goto out;
7079
7080 if (dip->errors) {
7081 bio_io_error(dip->orig_bio);
7082 } else {
7083 set_bit(BIO_UPTODATE, &dip->dio_bio->bi_flags);
7084 bio_endio(dip->orig_bio, 0);
7085 }
7086out:
7087 bio_put(bio);
7088}
7089
7090static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
7091 u64 first_sector, gfp_t gfp_flags)
7092{
7093 int nr_vecs = bio_get_nr_vecs(bdev);
7094 return btrfs_bio_alloc(bdev, first_sector, nr_vecs, gfp_flags);
7095}
7096
7097static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
7098 int rw, u64 file_offset, int skip_sum,
7099 int async_submit)
7100{
7101 int write = rw & REQ_WRITE;
7102 struct btrfs_root *root = BTRFS_I(inode)->root;
7103 int ret;
7104
7105 if (async_submit)
7106 async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
7107
7108 bio_get(bio);
7109
7110 if (!write) {
7111 ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
7112 if (ret)
7113 goto err;
7114 }
7115
7116 if (skip_sum)
7117 goto map;
7118
7119 if (write && async_submit) {
7120 ret = btrfs_wq_submit_bio(root->fs_info,
7121 inode, rw, bio, 0, 0,
7122 file_offset,
7123 __btrfs_submit_bio_start_direct_io,
7124 __btrfs_submit_bio_done);
7125 goto err;
7126 } else if (write) {
7127
7128
7129
7130
7131 ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1);
7132 if (ret)
7133 goto err;
7134 } else if (!skip_sum) {
7135 ret = btrfs_lookup_bio_sums_dio(root, inode, bio, file_offset);
7136 if (ret)
7137 goto err;
7138 }
7139
7140map:
7141 ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
7142err:
7143 bio_put(bio);
7144 return ret;
7145}
7146
7147static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
7148 int skip_sum)
7149{
7150 struct inode *inode = dip->inode;
7151 struct btrfs_root *root = BTRFS_I(inode)->root;
7152 struct bio *bio;
7153 struct bio *orig_bio = dip->orig_bio;
7154 struct bio_vec *bvec = orig_bio->bi_io_vec;
7155 u64 start_sector = orig_bio->bi_sector;
7156 u64 file_offset = dip->logical_offset;
7157 u64 submit_len = 0;
7158 u64 map_length;
7159 int nr_pages = 0;
7160 int ret = 0;
7161 int async_submit = 0;
7162
7163 map_length = orig_bio->bi_size;
7164 ret = btrfs_map_block(root->fs_info, rw, start_sector << 9,
7165 &map_length, NULL, 0);
7166 if (ret) {
7167 bio_put(orig_bio);
7168 return -EIO;
7169 }
7170 if (map_length >= orig_bio->bi_size) {
7171 bio = orig_bio;
7172 goto submit;
7173 }
7174
7175
7176 if (btrfs_get_alloc_profile(root, 1) &
7177 (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6))
7178 async_submit = 0;
7179 else
7180 async_submit = 1;
7181
7182 bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
7183 if (!bio)
7184 return -ENOMEM;
7185 bio->bi_private = dip;
7186 bio->bi_end_io = btrfs_end_dio_bio;
7187 atomic_inc(&dip->pending_bios);
7188
7189 while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
7190 if (unlikely(map_length < submit_len + bvec->bv_len ||
7191 bio_add_page(bio, bvec->bv_page, bvec->bv_len,
7192 bvec->bv_offset) < bvec->bv_len)) {
7193
7194
7195
7196
7197
7198
7199 atomic_inc(&dip->pending_bios);
7200 ret = __btrfs_submit_dio_bio(bio, inode, rw,
7201 file_offset, skip_sum,
7202 async_submit);
7203 if (ret) {
7204 bio_put(bio);
7205 atomic_dec(&dip->pending_bios);
7206 goto out_err;
7207 }
7208
7209 start_sector += submit_len >> 9;
7210 file_offset += submit_len;
7211
7212 submit_len = 0;
7213 nr_pages = 0;
7214
7215 bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev,
7216 start_sector, GFP_NOFS);
7217 if (!bio)
7218 goto out_err;
7219 bio->bi_private = dip;
7220 bio->bi_end_io = btrfs_end_dio_bio;
7221
7222 map_length = orig_bio->bi_size;
7223 ret = btrfs_map_block(root->fs_info, rw,
7224 start_sector << 9,
7225 &map_length, NULL, 0);
7226 if (ret) {
7227 bio_put(bio);
7228 goto out_err;
7229 }
7230 } else {
7231 submit_len += bvec->bv_len;
7232 nr_pages ++;
7233 bvec++;
7234 }
7235 }
7236
7237submit:
7238 ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
7239 async_submit);
7240 if (!ret)
7241 return 0;
7242
7243 bio_put(bio);
7244out_err:
7245 dip->errors = 1;
7246
7247
7248
7249
7250 smp_mb__before_atomic_dec();
7251 if (atomic_dec_and_test(&dip->pending_bios))
7252 bio_io_error(dip->orig_bio);
7253
7254
7255 return 0;
7256}
7257
7258static void btrfs_submit_direct(int rw, struct bio *dio_bio,
7259 struct inode *inode, loff_t file_offset)
7260{
7261 struct btrfs_root *root = BTRFS_I(inode)->root;
7262 struct btrfs_dio_private *dip;
7263 struct bio_vec *bvec = dio_bio->bi_io_vec;
7264 struct bio *io_bio;
7265 int skip_sum;
7266 int write = rw & REQ_WRITE;
7267 int ret = 0;
7268
7269 skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
7270
7271 io_bio = btrfs_bio_clone(dio_bio, GFP_NOFS);
7272
7273 if (!io_bio) {
7274 ret = -ENOMEM;
7275 goto free_ordered;
7276 }
7277
7278 dip = kmalloc(sizeof(*dip), GFP_NOFS);
7279 if (!dip) {
7280 ret = -ENOMEM;
7281 goto free_io_bio;
7282 }
7283
7284 dip->private = dio_bio->bi_private;
7285 io_bio->bi_private = dio_bio->bi_private;
7286 dip->inode = inode;
7287 dip->logical_offset = file_offset;
7288
7289 dip->bytes = 0;
7290 do {
7291 dip->bytes += bvec->bv_len;
7292 bvec++;
7293 } while (bvec <= (dio_bio->bi_io_vec + dio_bio->bi_vcnt - 1));
7294
7295 dip->disk_bytenr = (u64)dio_bio->bi_sector << 9;
7296 io_bio->bi_private = dip;
7297 dip->errors = 0;
7298 dip->orig_bio = io_bio;
7299 dip->dio_bio = dio_bio;
7300 atomic_set(&dip->pending_bios, 0);
7301
7302 if (write)
7303 io_bio->bi_end_io = btrfs_endio_direct_write;
7304 else
7305 io_bio->bi_end_io = btrfs_endio_direct_read;
7306
7307 ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
7308 if (!ret)
7309 return;
7310
7311free_io_bio:
7312 bio_put(io_bio);
7313
7314free_ordered:
7315
7316
7317
7318
7319 if (write) {
7320 struct btrfs_ordered_extent *ordered;
7321 ordered = btrfs_lookup_ordered_extent(inode, file_offset);
7322 if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) &&
7323 !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags))
7324 btrfs_free_reserved_extent(root, ordered->start,
7325 ordered->disk_len);
7326 btrfs_put_ordered_extent(ordered);
7327 btrfs_put_ordered_extent(ordered);
7328 }
7329 bio_endio(dio_bio, ret);
7330}
7331
7332static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *iocb,
7333 const struct iovec *iov, loff_t offset,
7334 unsigned long nr_segs)
7335{
7336 int seg;
7337 int i;
7338 size_t size;
7339 unsigned long addr;
7340 unsigned blocksize_mask = root->sectorsize - 1;
7341 ssize_t retval = -EINVAL;
7342 loff_t end = offset;
7343
7344 if (offset & blocksize_mask)
7345 goto out;
7346
7347
7348 for (seg = 0; seg < nr_segs; seg++) {
7349 addr = (unsigned long)iov[seg].iov_base;
7350 size = iov[seg].iov_len;
7351 end += size;
7352 if ((addr & blocksize_mask) || (size & blocksize_mask))
7353 goto out;
7354
7355
7356 if (rw & WRITE)
7357 continue;
7358
7359
7360
7361
7362
7363
7364 for (i = seg + 1; i < nr_segs; i++) {
7365 if (iov[seg].iov_base == iov[i].iov_base)
7366 goto out;
7367 }
7368 }
7369 retval = 0;
7370out:
7371 return retval;
7372}
7373
7374static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
7375 const struct iovec *iov, loff_t offset,
7376 unsigned long nr_segs)
7377{
7378 struct file *file = iocb->ki_filp;
7379 struct inode *inode = file->f_mapping->host;
7380 size_t count = 0;
7381 int flags = 0;
7382 bool wakeup = true;
7383 bool relock = false;
7384 ssize_t ret;
7385
7386 if (check_direct_IO(BTRFS_I(inode)->root, rw, iocb, iov,
7387 offset, nr_segs))
7388 return 0;
7389
7390 atomic_inc(&inode->i_dio_count);
7391 smp_mb__after_atomic_inc();
7392
7393 if (rw & WRITE) {
7394 count = iov_length(iov, nr_segs);
7395
7396
7397
7398
7399
7400 if (offset + count <= inode->i_size) {
7401 mutex_unlock(&inode->i_mutex);
7402 relock = true;
7403 }
7404 ret = btrfs_delalloc_reserve_space(inode, count);
7405 if (ret)
7406 goto out;
7407 } else if (unlikely(test_bit(BTRFS_INODE_READDIO_NEED_LOCK,
7408 &BTRFS_I(inode)->runtime_flags))) {
7409 inode_dio_done(inode);
7410 flags = DIO_LOCKING | DIO_SKIP_HOLES;
7411 wakeup = false;
7412 }
7413
7414 ret = __blockdev_direct_IO(rw, iocb, inode,
7415 BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev,
7416 iov, offset, nr_segs, btrfs_get_blocks_direct, NULL,
7417 btrfs_submit_direct, flags);
7418 if (rw & WRITE) {
7419 if (ret < 0 && ret != -EIOCBQUEUED)
7420 btrfs_delalloc_release_space(inode, count);
7421 else if (ret >= 0 && (size_t)ret < count)
7422 btrfs_delalloc_release_space(inode,
7423 count - (size_t)ret);
7424 else
7425 btrfs_delalloc_release_metadata(inode, 0);
7426 }
7427out:
7428 if (wakeup)
7429 inode_dio_done(inode);
7430 if (relock)
7431 mutex_lock(&inode->i_mutex);
7432
7433 return ret;
7434}
7435
7436#define BTRFS_FIEMAP_FLAGS (FIEMAP_FLAG_SYNC)
7437
7438static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
7439 __u64 start, __u64 len)
7440{
7441 int ret;
7442
7443 ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
7444 if (ret)
7445 return ret;
7446
7447 return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
7448}
7449
7450int btrfs_readpage(struct file *file, struct page *page)
7451{
7452 struct extent_io_tree *tree;
7453 tree = &BTRFS_I(page->mapping->host)->io_tree;
7454 return extent_read_full_page(tree, page, btrfs_get_extent, 0);
7455}
7456
7457static int btrfs_writepage(struct page *page, struct writeback_control *wbc)
7458{
7459 struct extent_io_tree *tree;
7460
7461
7462 if (current->flags & PF_MEMALLOC) {
7463 redirty_page_for_writepage(wbc, page);
7464 unlock_page(page);
7465 return 0;
7466 }
7467 tree = &BTRFS_I(page->mapping->host)->io_tree;
7468 return extent_write_full_page(tree, page, btrfs_get_extent, wbc);
7469}
7470
7471static int btrfs_writepages(struct address_space *mapping,
7472 struct writeback_control *wbc)
7473{
7474 struct extent_io_tree *tree;
7475
7476 tree = &BTRFS_I(mapping->host)->io_tree;
7477 return extent_writepages(tree, mapping, btrfs_get_extent, wbc);
7478}
7479
7480static int
7481btrfs_readpages(struct file *file, struct address_space *mapping,
7482 struct list_head *pages, unsigned nr_pages)
7483{
7484 struct extent_io_tree *tree;
7485 tree = &BTRFS_I(mapping->host)->io_tree;
7486 return extent_readpages(tree, mapping, pages, nr_pages,
7487 btrfs_get_extent);
7488}
7489static int __btrfs_releasepage(struct page *page, gfp_t gfp_flags)
7490{
7491 struct extent_io_tree *tree;
7492 struct extent_map_tree *map;
7493 int ret;
7494
7495 tree = &BTRFS_I(page->mapping->host)->io_tree;
7496 map = &BTRFS_I(page->mapping->host)->extent_tree;
7497 ret = try_release_extent_mapping(map, tree, page, gfp_flags);
7498 if (ret == 1) {
7499 ClearPagePrivate(page);
7500 set_page_private(page, 0);
7501 page_cache_release(page);
7502 }
7503 return ret;
7504}
7505
7506static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
7507{
7508 if (PageWriteback(page) || PageDirty(page))
7509 return 0;
7510 return __btrfs_releasepage(page, gfp_flags & GFP_NOFS);
7511}
7512
7513static void btrfs_invalidatepage(struct page *page, unsigned long offset)
7514{
7515 struct inode *inode = page->mapping->host;
7516 struct extent_io_tree *tree;
7517 struct btrfs_ordered_extent *ordered;
7518 struct extent_state *cached_state = NULL;
7519 u64 page_start = page_offset(page);
7520 u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
7521
7522
7523
7524
7525
7526
7527
7528
7529 wait_on_page_writeback(page);
7530
7531 tree = &BTRFS_I(inode)->io_tree;
7532 if (offset) {
7533 btrfs_releasepage(page, GFP_NOFS);
7534 return;
7535 }
7536 lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
7537 ordered = btrfs_lookup_ordered_extent(inode, page_offset(page));
7538 if (ordered) {
7539
7540
7541
7542
7543 clear_extent_bit(tree, page_start, page_end,
7544 EXTENT_DIRTY | EXTENT_DELALLOC |
7545 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
7546 EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
7547
7548
7549
7550
7551 if (TestClearPagePrivate2(page) &&
7552 btrfs_dec_test_ordered_pending(inode, &ordered, page_start,
7553 PAGE_CACHE_SIZE, 1)) {
7554 btrfs_finish_ordered_io(ordered);
7555 }
7556 btrfs_put_ordered_extent(ordered);
7557 cached_state = NULL;
7558 lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
7559 }
7560 clear_extent_bit(tree, page_start, page_end,
7561 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
7562 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
7563 &cached_state, GFP_NOFS);
7564 __btrfs_releasepage(page, GFP_NOFS);
7565
7566 ClearPageChecked(page);
7567 if (PagePrivate(page)) {
7568 ClearPagePrivate(page);
7569 set_page_private(page, 0);
7570 page_cache_release(page);
7571 }
7572}
7573
7574
7575
7576
7577
7578
7579
7580
7581
7582
7583
7584
7585
7586
7587
7588
7589int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
7590{
7591 struct page *page = vmf->page;
7592 struct inode *inode = file_inode(vma->vm_file);
7593 struct btrfs_root *root = BTRFS_I(inode)->root;
7594 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
7595 struct btrfs_ordered_extent *ordered;
7596 struct extent_state *cached_state = NULL;
7597 char *kaddr;
7598 unsigned long zero_start;
7599 loff_t size;
7600 int ret;
7601 int reserved = 0;
7602 u64 page_start;
7603 u64 page_end;
7604
7605 sb_start_pagefault(inode->i_sb);
7606 ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
7607 if (!ret) {
7608 ret = file_update_time(vma->vm_file);
7609 reserved = 1;
7610 }
7611 if (ret) {
7612 if (ret == -ENOMEM)
7613 ret = VM_FAULT_OOM;
7614 else
7615 ret = VM_FAULT_SIGBUS;
7616 if (reserved)
7617 goto out;
7618 goto out_noreserve;
7619 }
7620
7621 ret = VM_FAULT_NOPAGE;
7622again:
7623 lock_page(page);
7624 size = i_size_read(inode);
7625 page_start = page_offset(page);
7626 page_end = page_start + PAGE_CACHE_SIZE - 1;
7627
7628 if ((page->mapping != inode->i_mapping) ||
7629 (page_start >= size)) {
7630
7631 goto out_unlock;
7632 }
7633 wait_on_page_writeback(page);
7634
7635 lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state);
7636 set_page_extent_mapped(page);
7637
7638
7639
7640
7641
7642 ordered = btrfs_lookup_ordered_extent(inode, page_start);
7643 if (ordered) {
7644 unlock_extent_cached(io_tree, page_start, page_end,
7645 &cached_state, GFP_NOFS);
7646 unlock_page(page);
7647 btrfs_start_ordered_extent(inode, ordered, 1);
7648 btrfs_put_ordered_extent(ordered);
7649 goto again;
7650 }
7651
7652
7653
7654
7655
7656
7657
7658
7659 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
7660 EXTENT_DIRTY | EXTENT_DELALLOC |
7661 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
7662 0, 0, &cached_state, GFP_NOFS);
7663
7664 ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
7665 &cached_state);
7666 if (ret) {
7667 unlock_extent_cached(io_tree, page_start, page_end,
7668 &cached_state, GFP_NOFS);
7669 ret = VM_FAULT_SIGBUS;
7670 goto out_unlock;
7671 }
7672 ret = 0;
7673
7674
7675 if (page_start + PAGE_CACHE_SIZE > size)
7676 zero_start = size & ~PAGE_CACHE_MASK;
7677 else
7678 zero_start = PAGE_CACHE_SIZE;
7679
7680 if (zero_start != PAGE_CACHE_SIZE) {
7681 kaddr = kmap(page);
7682 memset(kaddr + zero_start, 0, PAGE_CACHE_SIZE - zero_start);
7683 flush_dcache_page(page);
7684 kunmap(page);
7685 }
7686 ClearPageChecked(page);
7687 set_page_dirty(page);
7688 SetPageUptodate(page);
7689
7690 BTRFS_I(inode)->last_trans = root->fs_info->generation;
7691 BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
7692 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
7693
7694 unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
7695
7696out_unlock:
7697 if (!ret) {
7698 sb_end_pagefault(inode->i_sb);
7699 return VM_FAULT_LOCKED;
7700 }
7701 unlock_page(page);
7702out:
7703 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
7704out_noreserve:
7705 sb_end_pagefault(inode->i_sb);
7706 return ret;
7707}
7708
7709static int btrfs_truncate(struct inode *inode)
7710{
7711 struct btrfs_root *root = BTRFS_I(inode)->root;
7712 struct btrfs_block_rsv *rsv;
7713 int ret;
7714 int err = 0;
7715 struct btrfs_trans_handle *trans;
7716 u64 mask = root->sectorsize - 1;
7717 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
7718
7719 ret = btrfs_truncate_page(inode, inode->i_size, 0, 0);
7720 if (ret)
7721 return ret;
7722
7723 btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
7724 btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
7725
7726
7727
7728
7729
7730
7731
7732
7733
7734
7735
7736
7737
7738
7739
7740
7741
7742
7743
7744
7745
7746
7747
7748
7749
7750
7751
7752
7753
7754
7755
7756
7757
7758
7759
7760
7761
7762 rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
7763 if (!rsv)
7764 return -ENOMEM;
7765 rsv->size = min_size;
7766 rsv->failfast = 1;
7767
7768
7769
7770
7771
7772 trans = btrfs_start_transaction(root, 2);
7773 if (IS_ERR(trans)) {
7774 err = PTR_ERR(trans);
7775 goto out;
7776 }
7777
7778
7779 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
7780 min_size);
7781 BUG_ON(ret);
7782
7783
7784
7785
7786
7787
7788
7789
7790
7791
7792
7793
7794
7795
7796
7797
7798
7799
7800 if (inode->i_size == 0 && test_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
7801 &BTRFS_I(inode)->runtime_flags))
7802 btrfs_add_ordered_operation(trans, root, inode);
7803
7804
7805
7806
7807
7808
7809
7810
7811 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
7812 trans->block_rsv = rsv;
7813
7814 while (1) {
7815 ret = btrfs_truncate_inode_items(trans, root, inode,
7816 inode->i_size,
7817 BTRFS_EXTENT_DATA_KEY);
7818 if (ret != -ENOSPC) {
7819 err = ret;
7820 break;
7821 }
7822
7823 trans->block_rsv = &root->fs_info->trans_block_rsv;
7824 ret = btrfs_update_inode(trans, root, inode);
7825 if (ret) {
7826 err = ret;
7827 break;
7828 }
7829
7830 btrfs_end_transaction(trans, root);
7831 btrfs_btree_balance_dirty(root);
7832
7833 trans = btrfs_start_transaction(root, 2);
7834 if (IS_ERR(trans)) {
7835 ret = err = PTR_ERR(trans);
7836 trans = NULL;
7837 break;
7838 }
7839
7840 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
7841 rsv, min_size);
7842 BUG_ON(ret);
7843 trans->block_rsv = rsv;
7844 }
7845
7846 if (ret == 0 && inode->i_nlink > 0) {
7847 trans->block_rsv = root->orphan_block_rsv;
7848 ret = btrfs_orphan_del(trans, inode);
7849 if (ret)
7850 err = ret;
7851 }
7852
7853 if (trans) {
7854 trans->block_rsv = &root->fs_info->trans_block_rsv;
7855 ret = btrfs_update_inode(trans, root, inode);
7856 if (ret && !err)
7857 err = ret;
7858
7859 ret = btrfs_end_transaction(trans, root);
7860 btrfs_btree_balance_dirty(root);
7861 }
7862
7863out:
7864 btrfs_free_block_rsv(root, rsv);
7865
7866 if (ret && !err)
7867 err = ret;
7868
7869 return err;
7870}
7871
7872
7873
7874
7875int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
7876 struct btrfs_root *new_root, u64 new_dirid)
7877{
7878 struct inode *inode;
7879 int err;
7880 u64 index = 0;
7881
7882 inode = btrfs_new_inode(trans, new_root, NULL, "..", 2,
7883 new_dirid, new_dirid,
7884 S_IFDIR | (~current_umask() & S_IRWXUGO),
7885 &index);
7886 if (IS_ERR(inode))
7887 return PTR_ERR(inode);
7888 inode->i_op = &btrfs_dir_inode_operations;
7889 inode->i_fop = &btrfs_dir_file_operations;
7890
7891 set_nlink(inode, 1);
7892 btrfs_i_size_write(inode, 0);
7893
7894 err = btrfs_update_inode(trans, new_root, inode);
7895
7896 iput(inode);
7897 return err;
7898}
7899
7900struct inode *btrfs_alloc_inode(struct super_block *sb)
7901{
7902 struct btrfs_inode *ei;
7903 struct inode *inode;
7904
7905 ei = kmem_cache_alloc(btrfs_inode_cachep, GFP_NOFS);
7906 if (!ei)
7907 return NULL;
7908
7909 ei->root = NULL;
7910 ei->generation = 0;
7911 ei->last_trans = 0;
7912 ei->last_sub_trans = 0;
7913 ei->logged_trans = 0;
7914 ei->delalloc_bytes = 0;
7915 ei->disk_i_size = 0;
7916 ei->flags = 0;
7917 ei->csum_bytes = 0;
7918 ei->index_cnt = (u64)-1;
7919 ei->last_unlink_trans = 0;
7920 ei->last_log_commit = 0;
7921
7922 spin_lock_init(&ei->lock);
7923 ei->outstanding_extents = 0;
7924 ei->reserved_extents = 0;
7925
7926 ei->runtime_flags = 0;
7927 ei->force_compress = BTRFS_COMPRESS_NONE;
7928
7929 ei->delayed_node = NULL;
7930
7931 inode = &ei->vfs_inode;
7932 extent_map_tree_init(&ei->extent_tree);
7933 extent_io_tree_init(&ei->io_tree, &inode->i_data);
7934 extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
7935 ei->io_tree.track_uptodate = 1;
7936 ei->io_failure_tree.track_uptodate = 1;
7937 atomic_set(&ei->sync_writers, 0);
7938 mutex_init(&ei->log_mutex);
7939 mutex_init(&ei->delalloc_mutex);
7940 btrfs_ordered_inode_tree_init(&ei->ordered_tree);
7941 INIT_LIST_HEAD(&ei->delalloc_inodes);
7942 INIT_LIST_HEAD(&ei->ordered_operations);
7943 RB_CLEAR_NODE(&ei->rb_node);
7944
7945 return inode;
7946}
7947
7948static void btrfs_i_callback(struct rcu_head *head)
7949{
7950 struct inode *inode = container_of(head, struct inode, i_rcu);
7951 kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
7952}
7953
7954void btrfs_destroy_inode(struct inode *inode)
7955{
7956 struct btrfs_ordered_extent *ordered;
7957 struct btrfs_root *root = BTRFS_I(inode)->root;
7958
7959 WARN_ON(!hlist_empty(&inode->i_dentry));
7960 WARN_ON(inode->i_data.nrpages);
7961 WARN_ON(BTRFS_I(inode)->outstanding_extents);
7962 WARN_ON(BTRFS_I(inode)->reserved_extents);
7963 WARN_ON(BTRFS_I(inode)->delalloc_bytes);
7964 WARN_ON(BTRFS_I(inode)->csum_bytes);
7965
7966
7967
7968
7969
7970
7971 if (!root)
7972 goto free;
7973
7974
7975
7976
7977
7978 smp_mb();
7979 if (!list_empty(&BTRFS_I(inode)->ordered_operations)) {
7980 spin_lock(&root->fs_info->ordered_extent_lock);
7981 list_del_init(&BTRFS_I(inode)->ordered_operations);
7982 spin_unlock(&root->fs_info->ordered_extent_lock);
7983 }
7984
7985 if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
7986 &BTRFS_I(inode)->runtime_flags)) {
7987 btrfs_info(root->fs_info, "inode %llu still on the orphan list",
7988 (unsigned long long)btrfs_ino(inode));
7989 atomic_dec(&root->orphan_inodes);
7990 }
7991
7992 while (1) {
7993 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
7994 if (!ordered)
7995 break;
7996 else {
7997 btrfs_err(root->fs_info, "found ordered extent %llu %llu on inode cleanup",
7998 (unsigned long long)ordered->file_offset,
7999 (unsigned long long)ordered->len);
8000 btrfs_remove_ordered_extent(inode, ordered);
8001 btrfs_put_ordered_extent(ordered);
8002 btrfs_put_ordered_extent(ordered);
8003 }
8004 }
8005 inode_tree_del(inode);
8006 btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
8007free:
8008 call_rcu(&inode->i_rcu, btrfs_i_callback);
8009}
8010
8011int btrfs_drop_inode(struct inode *inode)
8012{
8013 struct btrfs_root *root = BTRFS_I(inode)->root;
8014
8015 if (root == NULL)
8016 return 1;
8017
8018
8019 if (btrfs_root_refs(&root->root_item) == 0 &&
8020 root != root->fs_info->tree_root)
8021 return 1;
8022 else
8023 return generic_drop_inode(inode);
8024}
8025
8026static void init_once(void *foo)
8027{
8028 struct btrfs_inode *ei = (struct btrfs_inode *) foo;
8029
8030 inode_init_once(&ei->vfs_inode);
8031}
8032
8033void btrfs_destroy_cachep(void)
8034{
8035
8036
8037
8038
8039 rcu_barrier();
8040 if (btrfs_inode_cachep)
8041 kmem_cache_destroy(btrfs_inode_cachep);
8042 if (btrfs_trans_handle_cachep)
8043 kmem_cache_destroy(btrfs_trans_handle_cachep);
8044 if (btrfs_transaction_cachep)
8045 kmem_cache_destroy(btrfs_transaction_cachep);
8046 if (btrfs_path_cachep)
8047 kmem_cache_destroy(btrfs_path_cachep);
8048 if (btrfs_free_space_cachep)
8049 kmem_cache_destroy(btrfs_free_space_cachep);
8050 if (btrfs_delalloc_work_cachep)
8051 kmem_cache_destroy(btrfs_delalloc_work_cachep);
8052}
8053
8054int btrfs_init_cachep(void)
8055{
8056 btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
8057 sizeof(struct btrfs_inode), 0,
8058 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
8059 if (!btrfs_inode_cachep)
8060 goto fail;
8061
8062 btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
8063 sizeof(struct btrfs_trans_handle), 0,
8064 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
8065 if (!btrfs_trans_handle_cachep)
8066 goto fail;
8067
8068 btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
8069 sizeof(struct btrfs_transaction), 0,
8070 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
8071 if (!btrfs_transaction_cachep)
8072 goto fail;
8073
8074 btrfs_path_cachep = kmem_cache_create("btrfs_path",
8075 sizeof(struct btrfs_path), 0,
8076 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
8077 if (!btrfs_path_cachep)
8078 goto fail;
8079
8080 btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
8081 sizeof(struct btrfs_free_space), 0,
8082 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
8083 if (!btrfs_free_space_cachep)
8084 goto fail;
8085
8086 btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work",
8087 sizeof(struct btrfs_delalloc_work), 0,
8088 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
8089 NULL);
8090 if (!btrfs_delalloc_work_cachep)
8091 goto fail;
8092
8093 return 0;
8094fail:
8095 btrfs_destroy_cachep();
8096 return -ENOMEM;
8097}
8098
8099static int btrfs_getattr(struct vfsmount *mnt,
8100 struct dentry *dentry, struct kstat *stat)
8101{
8102 u64 delalloc_bytes;
8103 struct inode *inode = dentry->d_inode;
8104 u32 blocksize = inode->i_sb->s_blocksize;
8105
8106 generic_fillattr(inode, stat);
8107 stat->dev = BTRFS_I(inode)->root->anon_dev;
8108 stat->blksize = PAGE_CACHE_SIZE;
8109
8110 spin_lock(&BTRFS_I(inode)->lock);
8111 delalloc_bytes = BTRFS_I(inode)->delalloc_bytes;
8112 spin_unlock(&BTRFS_I(inode)->lock);
8113 stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
8114 ALIGN(delalloc_bytes, blocksize)) >> 9;
8115 return 0;
8116}
8117
8118static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
8119 struct inode *new_dir, struct dentry *new_dentry)
8120{
8121 struct btrfs_trans_handle *trans;
8122 struct btrfs_root *root = BTRFS_I(old_dir)->root;
8123 struct btrfs_root *dest = BTRFS_I(new_dir)->root;
8124 struct inode *new_inode = new_dentry->d_inode;
8125 struct inode *old_inode = old_dentry->d_inode;
8126 struct timespec ctime = CURRENT_TIME;
8127 u64 index = 0;
8128 u64 root_objectid;
8129 int ret;
8130 u64 old_ino = btrfs_ino(old_inode);
8131
8132 if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
8133 return -EPERM;
8134
8135
8136 if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
8137 return -EXDEV;
8138
8139 if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
8140 (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
8141 return -ENOTEMPTY;
8142
8143 if (S_ISDIR(old_inode->i_mode) && new_inode &&
8144 new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
8145 return -ENOTEMPTY;
8146
8147
8148
8149 ret = btrfs_check_dir_item_collision(root, new_dir->i_ino,
8150 new_dentry->d_name.name,
8151 new_dentry->d_name.len);
8152
8153 if (ret) {
8154 if (ret == -EEXIST) {
8155
8156
8157 if (!new_inode) {
8158 WARN_ON(1);
8159 return ret;
8160 }
8161 } else {
8162
8163 return ret;
8164 }
8165 }
8166 ret = 0;
8167
8168
8169
8170
8171
8172
8173 if (new_inode && S_ISREG(old_inode->i_mode) && new_inode->i_size &&
8174 old_inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
8175 filemap_flush(old_inode->i_mapping);
8176
8177
8178 if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
8179 down_read(&root->fs_info->subvol_sem);
8180
8181
8182
8183
8184
8185
8186
8187
8188 trans = btrfs_start_transaction(root, 11);
8189 if (IS_ERR(trans)) {
8190 ret = PTR_ERR(trans);
8191 goto out_notrans;
8192 }
8193
8194 if (dest != root)
8195 btrfs_record_root_in_trans(trans, dest);
8196
8197 ret = btrfs_set_inode_index(new_dir, &index);
8198 if (ret)
8199 goto out_fail;
8200
8201 if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
8202
8203 root->fs_info->last_trans_log_full_commit = trans->transid;
8204 } else {
8205 ret = btrfs_insert_inode_ref(trans, dest,
8206 new_dentry->d_name.name,
8207 new_dentry->d_name.len,
8208 old_ino,
8209 btrfs_ino(new_dir), index);
8210 if (ret)
8211 goto out_fail;
8212
8213
8214
8215
8216
8217
8218
8219 btrfs_pin_log_trans(root);
8220 }
8221
8222
8223
8224
8225 if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
8226 btrfs_add_ordered_operation(trans, root, old_inode);
8227
8228 inode_inc_iversion(old_dir);
8229 inode_inc_iversion(new_dir);
8230 inode_inc_iversion(old_inode);
8231 old_dir->i_ctime = old_dir->i_mtime = ctime;
8232 new_dir->i_ctime = new_dir->i_mtime = ctime;
8233 old_inode->i_ctime = ctime;
8234
8235 if (old_dentry->d_parent != new_dentry->d_parent)
8236 btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
8237
8238 if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
8239 root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
8240 ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
8241 old_dentry->d_name.name,
8242 old_dentry->d_name.len);
8243 } else {
8244 ret = __btrfs_unlink_inode(trans, root, old_dir,
8245 old_dentry->d_inode,
8246 old_dentry->d_name.name,
8247 old_dentry->d_name.len);
8248 if (!ret)
8249 ret = btrfs_update_inode(trans, root, old_inode);
8250 }
8251 if (ret) {
8252 btrfs_abort_transaction(trans, root, ret);
8253 goto out_fail;
8254 }
8255
8256 if (new_inode) {
8257 inode_inc_iversion(new_inode);
8258 new_inode->i_ctime = CURRENT_TIME;
8259 if (unlikely(btrfs_ino(new_inode) ==
8260 BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
8261 root_objectid = BTRFS_I(new_inode)->location.objectid;
8262 ret = btrfs_unlink_subvol(trans, dest, new_dir,
8263 root_objectid,
8264 new_dentry->d_name.name,
8265 new_dentry->d_name.len);
8266 BUG_ON(new_inode->i_nlink == 0);
8267 } else {
8268 ret = btrfs_unlink_inode(trans, dest, new_dir,
8269 new_dentry->d_inode,
8270 new_dentry->d_name.name,
8271 new_dentry->d_name.len);
8272 }
8273 if (!ret && new_inode->i_nlink == 0) {
8274 ret = btrfs_orphan_add(trans, new_dentry->d_inode);
8275 BUG_ON(ret);
8276 }
8277 if (ret) {
8278 btrfs_abort_transaction(trans, root, ret);
8279 goto out_fail;
8280 }
8281 }
8282
8283 ret = btrfs_add_link(trans, new_dir, old_inode,
8284 new_dentry->d_name.name,
8285 new_dentry->d_name.len, 0, index);
8286 if (ret) {
8287 btrfs_abort_transaction(trans, root, ret);
8288 goto out_fail;
8289 }
8290
8291 if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
8292 struct dentry *parent = new_dentry->d_parent;
8293 btrfs_log_new_name(trans, old_inode, old_dir, parent);
8294 btrfs_end_log_trans(root);
8295 }
8296out_fail:
8297 btrfs_end_transaction(trans, root);
8298out_notrans:
8299 if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
8300 up_read(&root->fs_info->subvol_sem);
8301
8302 return ret;
8303}
8304
8305static void btrfs_run_delalloc_work(struct btrfs_work *work)
8306{
8307 struct btrfs_delalloc_work *delalloc_work;
8308
8309 delalloc_work = container_of(work, struct btrfs_delalloc_work,
8310 work);
8311 if (delalloc_work->wait)
8312 btrfs_wait_ordered_range(delalloc_work->inode, 0, (u64)-1);
8313 else
8314 filemap_flush(delalloc_work->inode->i_mapping);
8315
8316 if (delalloc_work->delay_iput)
8317 btrfs_add_delayed_iput(delalloc_work->inode);
8318 else
8319 iput(delalloc_work->inode);
8320 complete(&delalloc_work->completion);
8321}
8322
8323struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
8324 int wait, int delay_iput)
8325{
8326 struct btrfs_delalloc_work *work;
8327
8328 work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS);
8329 if (!work)
8330 return NULL;
8331
8332 init_completion(&work->completion);
8333 INIT_LIST_HEAD(&work->list);
8334 work->inode = inode;
8335 work->wait = wait;
8336 work->delay_iput = delay_iput;
8337 work->work.func = btrfs_run_delalloc_work;
8338
8339 return work;
8340}
8341
8342void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work)
8343{
8344 wait_for_completion(&work->completion);
8345 kmem_cache_free(btrfs_delalloc_work_cachep, work);
8346}
8347
8348
8349
8350
8351
8352int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
8353{
8354 struct btrfs_inode *binode;
8355 struct inode *inode;
8356 struct btrfs_delalloc_work *work, *next;
8357 struct list_head works;
8358 struct list_head splice;
8359 int ret = 0;
8360
8361 if (root->fs_info->sb->s_flags & MS_RDONLY)
8362 return -EROFS;
8363
8364 INIT_LIST_HEAD(&works);
8365 INIT_LIST_HEAD(&splice);
8366
8367 spin_lock(&root->fs_info->delalloc_lock);
8368 list_splice_init(&root->fs_info->delalloc_inodes, &splice);
8369 while (!list_empty(&splice)) {
8370 binode = list_entry(splice.next, struct btrfs_inode,
8371 delalloc_inodes);
8372
8373 list_del_init(&binode->delalloc_inodes);
8374
8375 inode = igrab(&binode->vfs_inode);
8376 if (!inode) {
8377 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
8378 &binode->runtime_flags);
8379 continue;
8380 }
8381
8382 list_add_tail(&binode->delalloc_inodes,
8383 &root->fs_info->delalloc_inodes);
8384 spin_unlock(&root->fs_info->delalloc_lock);
8385
8386 work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
8387 if (unlikely(!work)) {
8388 ret = -ENOMEM;
8389 goto out;
8390 }
8391 list_add_tail(&work->list, &works);
8392 btrfs_queue_worker(&root->fs_info->flush_workers,
8393 &work->work);
8394
8395 cond_resched();
8396 spin_lock(&root->fs_info->delalloc_lock);
8397 }
8398 spin_unlock(&root->fs_info->delalloc_lock);
8399
8400 list_for_each_entry_safe(work, next, &works, list) {
8401 list_del_init(&work->list);
8402 btrfs_wait_and_free_delalloc_work(work);
8403 }
8404
8405
8406
8407
8408
8409 atomic_inc(&root->fs_info->async_submit_draining);
8410 while (atomic_read(&root->fs_info->nr_async_submits) ||
8411 atomic_read(&root->fs_info->async_delalloc_pages)) {
8412 wait_event(root->fs_info->async_submit_wait,
8413 (atomic_read(&root->fs_info->nr_async_submits) == 0 &&
8414 atomic_read(&root->fs_info->async_delalloc_pages) == 0));
8415 }
8416 atomic_dec(&root->fs_info->async_submit_draining);
8417 return 0;
8418out:
8419 list_for_each_entry_safe(work, next, &works, list) {
8420 list_del_init(&work->list);
8421 btrfs_wait_and_free_delalloc_work(work);
8422 }
8423
8424 if (!list_empty_careful(&splice)) {
8425 spin_lock(&root->fs_info->delalloc_lock);
8426 list_splice_tail(&splice, &root->fs_info->delalloc_inodes);
8427 spin_unlock(&root->fs_info->delalloc_lock);
8428 }
8429 return ret;
8430}
8431
8432static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
8433 const char *symname)
8434{
8435 struct btrfs_trans_handle *trans;
8436 struct btrfs_root *root = BTRFS_I(dir)->root;
8437 struct btrfs_path *path;
8438 struct btrfs_key key;
8439 struct inode *inode = NULL;
8440 int err;
8441 int drop_inode = 0;
8442 u64 objectid;
8443 u64 index = 0 ;
8444 int name_len;
8445 int datasize;
8446 unsigned long ptr;
8447 struct btrfs_file_extent_item *ei;
8448 struct extent_buffer *leaf;
8449
8450 name_len = strlen(symname) + 1;
8451 if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
8452 return -ENAMETOOLONG;
8453
8454
8455
8456
8457
8458
8459 trans = btrfs_start_transaction(root, 5);
8460 if (IS_ERR(trans))
8461 return PTR_ERR(trans);
8462
8463 err = btrfs_find_free_ino(root, &objectid);
8464 if (err)
8465 goto out_unlock;
8466
8467 inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
8468 dentry->d_name.len, btrfs_ino(dir), objectid,
8469 S_IFLNK|S_IRWXUGO, &index);
8470 if (IS_ERR(inode)) {
8471 err = PTR_ERR(inode);
8472 goto out_unlock;
8473 }
8474
8475 err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
8476 if (err) {
8477 drop_inode = 1;
8478 goto out_unlock;
8479 }
8480
8481
8482
8483
8484
8485
8486
8487 inode->i_fop = &btrfs_file_operations;
8488 inode->i_op = &btrfs_file_inode_operations;
8489
8490 err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
8491 if (err)
8492 drop_inode = 1;
8493 else {
8494 inode->i_mapping->a_ops = &btrfs_aops;
8495 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
8496 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
8497 }
8498 if (drop_inode)
8499 goto out_unlock;
8500
8501 path = btrfs_alloc_path();
8502 if (!path) {
8503 err = -ENOMEM;
8504 drop_inode = 1;
8505 goto out_unlock;
8506 }
8507 key.objectid = btrfs_ino(inode);
8508 key.offset = 0;
8509 btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
8510 datasize = btrfs_file_extent_calc_inline_size(name_len);
8511 err = btrfs_insert_empty_item(trans, root, path, &key,
8512 datasize);
8513 if (err) {
8514 drop_inode = 1;
8515 btrfs_free_path(path);
8516 goto out_unlock;
8517 }
8518 leaf = path->nodes[0];
8519 ei = btrfs_item_ptr(leaf, path->slots[0],
8520 struct btrfs_file_extent_item);
8521 btrfs_set_file_extent_generation(leaf, ei, trans->transid);
8522 btrfs_set_file_extent_type(leaf, ei,
8523 BTRFS_FILE_EXTENT_INLINE);
8524 btrfs_set_file_extent_encryption(leaf, ei, 0);
8525 btrfs_set_file_extent_compression(leaf, ei, 0);
8526 btrfs_set_file_extent_other_encoding(leaf, ei, 0);
8527 btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);
8528
8529 ptr = btrfs_file_extent_inline_start(ei);
8530 write_extent_buffer(leaf, symname, ptr, name_len);
8531 btrfs_mark_buffer_dirty(leaf);
8532 btrfs_free_path(path);
8533
8534 inode->i_op = &btrfs_symlink_inode_operations;
8535 inode->i_mapping->a_ops = &btrfs_symlink_aops;
8536 inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
8537 inode_set_bytes(inode, name_len);
8538 btrfs_i_size_write(inode, name_len - 1);
8539 err = btrfs_update_inode(trans, root, inode);
8540 if (err)
8541 drop_inode = 1;
8542
8543out_unlock:
8544 if (!err)
8545 d_instantiate(dentry, inode);
8546 btrfs_end_transaction(trans, root);
8547 if (drop_inode) {
8548 inode_dec_link_count(inode);
8549 iput(inode);
8550 }
8551 btrfs_btree_balance_dirty(root);
8552 return err;
8553}
8554
8555static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
8556 u64 start, u64 num_bytes, u64 min_size,
8557 loff_t actual_len, u64 *alloc_hint,
8558 struct btrfs_trans_handle *trans)
8559{
8560 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
8561 struct extent_map *em;
8562 struct btrfs_root *root = BTRFS_I(inode)->root;
8563 struct btrfs_key ins;
8564 u64 cur_offset = start;
8565 u64 i_size;
8566 u64 cur_bytes;
8567 int ret = 0;
8568 bool own_trans = true;
8569
8570 if (trans)
8571 own_trans = false;
8572 while (num_bytes > 0) {
8573 if (own_trans) {
8574 trans = btrfs_start_transaction(root, 3);
8575 if (IS_ERR(trans)) {
8576 ret = PTR_ERR(trans);
8577 break;
8578 }
8579 }
8580
8581 cur_bytes = min(num_bytes, 256ULL * 1024 * 1024);
8582 cur_bytes = max(cur_bytes, min_size);
8583 ret = btrfs_reserve_extent(trans, root, cur_bytes,
8584 min_size, 0, *alloc_hint, &ins, 1);
8585 if (ret) {
8586 if (own_trans)
8587 btrfs_end_transaction(trans, root);
8588 break;
8589 }
8590
8591 ret = insert_reserved_file_extent(trans, inode,
8592 cur_offset, ins.objectid,
8593 ins.offset, ins.offset,
8594 ins.offset, 0, 0, 0,
8595 BTRFS_FILE_EXTENT_PREALLOC);
8596 if (ret) {
8597 btrfs_abort_transaction(trans, root, ret);
8598 if (own_trans)
8599 btrfs_end_transaction(trans, root);
8600 break;
8601 }
8602 btrfs_drop_extent_cache(inode, cur_offset,
8603 cur_offset + ins.offset -1, 0);
8604
8605 em = alloc_extent_map();
8606 if (!em) {
8607 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
8608 &BTRFS_I(inode)->runtime_flags);
8609 goto next;
8610 }
8611
8612 em->start = cur_offset;
8613 em->orig_start = cur_offset;
8614 em->len = ins.offset;
8615 em->block_start = ins.objectid;
8616 em->block_len = ins.offset;
8617 em->orig_block_len = ins.offset;
8618 em->ram_bytes = ins.offset;
8619 em->bdev = root->fs_info->fs_devices->latest_bdev;
8620 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
8621 em->generation = trans->transid;
8622
8623 while (1) {
8624 write_lock(&em_tree->lock);
8625 ret = add_extent_mapping(em_tree, em, 1);
8626 write_unlock(&em_tree->lock);
8627 if (ret != -EEXIST)
8628 break;
8629 btrfs_drop_extent_cache(inode, cur_offset,
8630 cur_offset + ins.offset - 1,
8631 0);
8632 }
8633 free_extent_map(em);
8634next:
8635 num_bytes -= ins.offset;
8636 cur_offset += ins.offset;
8637 *alloc_hint = ins.objectid + ins.offset;
8638
8639 inode_inc_iversion(inode);
8640 inode->i_ctime = CURRENT_TIME;
8641 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
8642 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
8643 (actual_len > inode->i_size) &&
8644 (cur_offset > inode->i_size)) {
8645 if (cur_offset > actual_len)
8646 i_size = actual_len;
8647 else
8648 i_size = cur_offset;
8649 i_size_write(inode, i_size);
8650 btrfs_ordered_update_i_size(inode, i_size, NULL);
8651 }
8652
8653 ret = btrfs_update_inode(trans, root, inode);
8654
8655 if (ret) {
8656 btrfs_abort_transaction(trans, root, ret);
8657 if (own_trans)
8658 btrfs_end_transaction(trans, root);
8659 break;
8660 }
8661
8662 if (own_trans)
8663 btrfs_end_transaction(trans, root);
8664 }
8665 return ret;
8666}
8667
8668int btrfs_prealloc_file_range(struct inode *inode, int mode,
8669 u64 start, u64 num_bytes, u64 min_size,
8670 loff_t actual_len, u64 *alloc_hint)
8671{
8672 return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
8673 min_size, actual_len, alloc_hint,
8674 NULL);
8675}
8676
8677int btrfs_prealloc_file_range_trans(struct inode *inode,
8678 struct btrfs_trans_handle *trans, int mode,
8679 u64 start, u64 num_bytes, u64 min_size,
8680 loff_t actual_len, u64 *alloc_hint)
8681{
8682 return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
8683 min_size, actual_len, alloc_hint, trans);
8684}
8685
8686static int btrfs_set_page_dirty(struct page *page)
8687{
8688 return __set_page_dirty_nobuffers(page);
8689}
8690
8691static int btrfs_permission(struct inode *inode, int mask)
8692{
8693 struct btrfs_root *root = BTRFS_I(inode)->root;
8694 umode_t mode = inode->i_mode;
8695
8696 if (mask & MAY_WRITE &&
8697 (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))) {
8698 if (btrfs_root_readonly(root))
8699 return -EROFS;
8700 if (BTRFS_I(inode)->flags & BTRFS_INODE_READONLY)
8701 return -EACCES;
8702 }
8703 return generic_permission(inode, mask);
8704}
8705
8706static const struct inode_operations btrfs_dir_inode_operations = {
8707 .getattr = btrfs_getattr,
8708 .lookup = btrfs_lookup,
8709 .create = btrfs_create,
8710 .unlink = btrfs_unlink,
8711 .link = btrfs_link,
8712 .mkdir = btrfs_mkdir,
8713 .rmdir = btrfs_rmdir,
8714 .rename = btrfs_rename,
8715 .symlink = btrfs_symlink,
8716 .setattr = btrfs_setattr,
8717 .mknod = btrfs_mknod,
8718 .setxattr = btrfs_setxattr,
8719 .getxattr = btrfs_getxattr,
8720 .listxattr = btrfs_listxattr,
8721 .removexattr = btrfs_removexattr,
8722 .permission = btrfs_permission,
8723 .get_acl = btrfs_get_acl,
8724};
8725static const struct inode_operations btrfs_dir_ro_inode_operations = {
8726 .lookup = btrfs_lookup,
8727 .permission = btrfs_permission,
8728 .get_acl = btrfs_get_acl,
8729};
8730
8731static const struct file_operations btrfs_dir_file_operations = {
8732 .llseek = generic_file_llseek,
8733 .read = generic_read_dir,
8734 .readdir = btrfs_real_readdir,
8735 .unlocked_ioctl = btrfs_ioctl,
8736#ifdef CONFIG_COMPAT
8737 .compat_ioctl = btrfs_ioctl,
8738#endif
8739 .release = btrfs_release_file,
8740 .fsync = btrfs_sync_file,
8741};
8742
8743static struct extent_io_ops btrfs_extent_io_ops = {
8744 .fill_delalloc = run_delalloc_range,
8745 .submit_bio_hook = btrfs_submit_bio_hook,
8746 .merge_bio_hook = btrfs_merge_bio_hook,
8747 .readpage_end_io_hook = btrfs_readpage_end_io_hook,
8748 .writepage_end_io_hook = btrfs_writepage_end_io_hook,
8749 .writepage_start_hook = btrfs_writepage_start_hook,
8750 .set_bit_hook = btrfs_set_bit_hook,
8751 .clear_bit_hook = btrfs_clear_bit_hook,
8752 .merge_extent_hook = btrfs_merge_extent_hook,
8753 .split_extent_hook = btrfs_split_extent_hook,
8754};
8755
8756
8757
8758
8759
8760
8761
8762
8763
8764
8765
8766
8767
8768static const struct address_space_operations btrfs_aops = {
8769 .readpage = btrfs_readpage,
8770 .writepage = btrfs_writepage,
8771 .writepages = btrfs_writepages,
8772 .readpages = btrfs_readpages,
8773 .direct_IO = btrfs_direct_IO,
8774 .invalidatepage = btrfs_invalidatepage,
8775 .releasepage = btrfs_releasepage,
8776 .set_page_dirty = btrfs_set_page_dirty,
8777 .error_remove_page = generic_error_remove_page,
8778};
8779
8780static const struct address_space_operations btrfs_symlink_aops = {
8781 .readpage = btrfs_readpage,
8782 .writepage = btrfs_writepage,
8783 .invalidatepage = btrfs_invalidatepage,
8784 .releasepage = btrfs_releasepage,
8785};
8786
8787static const struct inode_operations btrfs_file_inode_operations = {
8788 .getattr = btrfs_getattr,
8789 .setattr = btrfs_setattr,
8790 .setxattr = btrfs_setxattr,
8791 .getxattr = btrfs_getxattr,
8792 .listxattr = btrfs_listxattr,
8793 .removexattr = btrfs_removexattr,
8794 .permission = btrfs_permission,
8795 .fiemap = btrfs_fiemap,
8796 .get_acl = btrfs_get_acl,
8797 .update_time = btrfs_update_time,
8798};
8799static const struct inode_operations btrfs_special_inode_operations = {
8800 .getattr = btrfs_getattr,
8801 .setattr = btrfs_setattr,
8802 .permission = btrfs_permission,
8803 .setxattr = btrfs_setxattr,
8804 .getxattr = btrfs_getxattr,
8805 .listxattr = btrfs_listxattr,
8806 .removexattr = btrfs_removexattr,
8807 .get_acl = btrfs_get_acl,
8808 .update_time = btrfs_update_time,
8809};
8810static const struct inode_operations btrfs_symlink_inode_operations = {
8811 .readlink = generic_readlink,
8812 .follow_link = page_follow_link_light,
8813 .put_link = page_put_link,
8814 .getattr = btrfs_getattr,
8815 .setattr = btrfs_setattr,
8816 .permission = btrfs_permission,
8817 .setxattr = btrfs_setxattr,
8818 .getxattr = btrfs_getxattr,
8819 .listxattr = btrfs_listxattr,
8820 .removexattr = btrfs_removexattr,
8821 .get_acl = btrfs_get_acl,
8822 .update_time = btrfs_update_time,
8823};
8824
8825const struct dentry_operations btrfs_dentry_operations = {
8826 .d_delete = btrfs_dentry_delete,
8827 .d_release = btrfs_dentry_release,
8828};
8829