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