1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/slab.h>
20#include <linux/blkdev.h>
21#include <linux/writeback.h>
22#include <linux/pagevec.h>
23#include "ctree.h"
24#include "transaction.h"
25#include "btrfs_inode.h"
26#include "extent_io.h"
27#include "disk-io.h"
28
29static struct kmem_cache *btrfs_ordered_extent_cache;
30
31static u64 entry_end(struct btrfs_ordered_extent *entry)
32{
33 if (entry->file_offset + entry->len < entry->file_offset)
34 return (u64)-1;
35 return entry->file_offset + entry->len;
36}
37
38
39
40
41static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset,
42 struct rb_node *node)
43{
44 struct rb_node **p = &root->rb_node;
45 struct rb_node *parent = NULL;
46 struct btrfs_ordered_extent *entry;
47
48 while (*p) {
49 parent = *p;
50 entry = rb_entry(parent, struct btrfs_ordered_extent, rb_node);
51
52 if (file_offset < entry->file_offset)
53 p = &(*p)->rb_left;
54 else if (file_offset >= entry_end(entry))
55 p = &(*p)->rb_right;
56 else
57 return parent;
58 }
59
60 rb_link_node(node, parent, p);
61 rb_insert_color(node, root);
62 return NULL;
63}
64
65static void ordered_data_tree_panic(struct inode *inode, int errno,
66 u64 offset)
67{
68 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
69 btrfs_panic(fs_info, errno, "Inconsistency in ordered tree at offset "
70 "%llu\n", offset);
71}
72
73
74
75
76
77static struct rb_node *__tree_search(struct rb_root *root, u64 file_offset,
78 struct rb_node **prev_ret)
79{
80 struct rb_node *n = root->rb_node;
81 struct rb_node *prev = NULL;
82 struct rb_node *test;
83 struct btrfs_ordered_extent *entry;
84 struct btrfs_ordered_extent *prev_entry = NULL;
85
86 while (n) {
87 entry = rb_entry(n, struct btrfs_ordered_extent, rb_node);
88 prev = n;
89 prev_entry = entry;
90
91 if (file_offset < entry->file_offset)
92 n = n->rb_left;
93 else if (file_offset >= entry_end(entry))
94 n = n->rb_right;
95 else
96 return n;
97 }
98 if (!prev_ret)
99 return NULL;
100
101 while (prev && file_offset >= entry_end(prev_entry)) {
102 test = rb_next(prev);
103 if (!test)
104 break;
105 prev_entry = rb_entry(test, struct btrfs_ordered_extent,
106 rb_node);
107 if (file_offset < entry_end(prev_entry))
108 break;
109
110 prev = test;
111 }
112 if (prev)
113 prev_entry = rb_entry(prev, struct btrfs_ordered_extent,
114 rb_node);
115 while (prev && file_offset < entry_end(prev_entry)) {
116 test = rb_prev(prev);
117 if (!test)
118 break;
119 prev_entry = rb_entry(test, struct btrfs_ordered_extent,
120 rb_node);
121 prev = test;
122 }
123 *prev_ret = prev;
124 return NULL;
125}
126
127
128
129
130static int offset_in_entry(struct btrfs_ordered_extent *entry, u64 file_offset)
131{
132 if (file_offset < entry->file_offset ||
133 entry->file_offset + entry->len <= file_offset)
134 return 0;
135 return 1;
136}
137
138static int range_overlaps(struct btrfs_ordered_extent *entry, u64 file_offset,
139 u64 len)
140{
141 if (file_offset + len <= entry->file_offset ||
142 entry->file_offset + entry->len <= file_offset)
143 return 0;
144 return 1;
145}
146
147
148
149
150
151static inline struct rb_node *tree_search(struct btrfs_ordered_inode_tree *tree,
152 u64 file_offset)
153{
154 struct rb_root *root = &tree->tree;
155 struct rb_node *prev = NULL;
156 struct rb_node *ret;
157 struct btrfs_ordered_extent *entry;
158
159 if (tree->last) {
160 entry = rb_entry(tree->last, struct btrfs_ordered_extent,
161 rb_node);
162 if (offset_in_entry(entry, file_offset))
163 return tree->last;
164 }
165 ret = __tree_search(root, file_offset, &prev);
166 if (!ret)
167 ret = prev;
168 if (ret)
169 tree->last = ret;
170 return ret;
171}
172
173
174
175
176
177
178
179
180
181
182
183
184static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
185 u64 start, u64 len, u64 disk_len,
186 int type, int dio, int compress_type)
187{
188 struct btrfs_root *root = BTRFS_I(inode)->root;
189 struct btrfs_ordered_inode_tree *tree;
190 struct rb_node *node;
191 struct btrfs_ordered_extent *entry;
192
193 tree = &BTRFS_I(inode)->ordered_tree;
194 entry = kmem_cache_zalloc(btrfs_ordered_extent_cache, GFP_NOFS);
195 if (!entry)
196 return -ENOMEM;
197
198 entry->file_offset = file_offset;
199 entry->start = start;
200 entry->len = len;
201 if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) &&
202 !(type == BTRFS_ORDERED_NOCOW))
203 entry->csum_bytes_left = disk_len;
204 entry->disk_len = disk_len;
205 entry->bytes_left = len;
206 entry->inode = igrab(inode);
207 entry->compress_type = compress_type;
208 entry->truncated_len = (u64)-1;
209 if (type != BTRFS_ORDERED_IO_DONE && type != BTRFS_ORDERED_COMPLETE)
210 set_bit(type, &entry->flags);
211
212 if (dio)
213 set_bit(BTRFS_ORDERED_DIRECT, &entry->flags);
214
215
216 atomic_set(&entry->refs, 1);
217 init_waitqueue_head(&entry->wait);
218 INIT_LIST_HEAD(&entry->list);
219 INIT_LIST_HEAD(&entry->root_extent_list);
220 INIT_LIST_HEAD(&entry->work_list);
221 init_completion(&entry->completion);
222 INIT_LIST_HEAD(&entry->log_list);
223
224 trace_btrfs_ordered_extent_add(inode, entry);
225
226 spin_lock_irq(&tree->lock);
227 node = tree_insert(&tree->tree, file_offset,
228 &entry->rb_node);
229 if (node)
230 ordered_data_tree_panic(inode, -EEXIST, file_offset);
231 spin_unlock_irq(&tree->lock);
232
233 spin_lock(&root->ordered_extent_lock);
234 list_add_tail(&entry->root_extent_list,
235 &root->ordered_extents);
236 root->nr_ordered_extents++;
237 if (root->nr_ordered_extents == 1) {
238 spin_lock(&root->fs_info->ordered_root_lock);
239 BUG_ON(!list_empty(&root->ordered_root));
240 list_add_tail(&root->ordered_root,
241 &root->fs_info->ordered_roots);
242 spin_unlock(&root->fs_info->ordered_root_lock);
243 }
244 spin_unlock(&root->ordered_extent_lock);
245
246 return 0;
247}
248
249int btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
250 u64 start, u64 len, u64 disk_len, int type)
251{
252 return __btrfs_add_ordered_extent(inode, file_offset, start, len,
253 disk_len, type, 0,
254 BTRFS_COMPRESS_NONE);
255}
256
257int btrfs_add_ordered_extent_dio(struct inode *inode, u64 file_offset,
258 u64 start, u64 len, u64 disk_len, int type)
259{
260 return __btrfs_add_ordered_extent(inode, file_offset, start, len,
261 disk_len, type, 1,
262 BTRFS_COMPRESS_NONE);
263}
264
265int btrfs_add_ordered_extent_compress(struct inode *inode, u64 file_offset,
266 u64 start, u64 len, u64 disk_len,
267 int type, int compress_type)
268{
269 return __btrfs_add_ordered_extent(inode, file_offset, start, len,
270 disk_len, type, 0,
271 compress_type);
272}
273
274
275
276
277
278
279void btrfs_add_ordered_sum(struct inode *inode,
280 struct btrfs_ordered_extent *entry,
281 struct btrfs_ordered_sum *sum)
282{
283 struct btrfs_ordered_inode_tree *tree;
284
285 tree = &BTRFS_I(inode)->ordered_tree;
286 spin_lock_irq(&tree->lock);
287 list_add_tail(&sum->list, &entry->list);
288 WARN_ON(entry->csum_bytes_left < sum->len);
289 entry->csum_bytes_left -= sum->len;
290 if (entry->csum_bytes_left == 0)
291 wake_up(&entry->wait);
292 spin_unlock_irq(&tree->lock);
293}
294
295
296
297
298
299
300
301
302
303
304
305
306
307int btrfs_dec_test_first_ordered_pending(struct inode *inode,
308 struct btrfs_ordered_extent **cached,
309 u64 *file_offset, u64 io_size, int uptodate)
310{
311 struct btrfs_ordered_inode_tree *tree;
312 struct rb_node *node;
313 struct btrfs_ordered_extent *entry = NULL;
314 int ret;
315 unsigned long flags;
316 u64 dec_end;
317 u64 dec_start;
318 u64 to_dec;
319
320 tree = &BTRFS_I(inode)->ordered_tree;
321 spin_lock_irqsave(&tree->lock, flags);
322 node = tree_search(tree, *file_offset);
323 if (!node) {
324 ret = 1;
325 goto out;
326 }
327
328 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
329 if (!offset_in_entry(entry, *file_offset)) {
330 ret = 1;
331 goto out;
332 }
333
334 dec_start = max(*file_offset, entry->file_offset);
335 dec_end = min(*file_offset + io_size, entry->file_offset +
336 entry->len);
337 *file_offset = dec_end;
338 if (dec_start > dec_end) {
339 printk(KERN_CRIT "bad ordering dec_start %llu end %llu\n",
340 dec_start, dec_end);
341 }
342 to_dec = dec_end - dec_start;
343 if (to_dec > entry->bytes_left) {
344 printk(KERN_CRIT "bad ordered accounting left %llu size %llu\n",
345 entry->bytes_left, to_dec);
346 }
347 entry->bytes_left -= to_dec;
348 if (!uptodate)
349 set_bit(BTRFS_ORDERED_IOERR, &entry->flags);
350
351 if (entry->bytes_left == 0)
352 ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
353 else
354 ret = 1;
355out:
356 if (!ret && cached && entry) {
357 *cached = entry;
358 atomic_inc(&entry->refs);
359 }
360 spin_unlock_irqrestore(&tree->lock, flags);
361 return ret == 0;
362}
363
364
365
366
367
368
369
370
371
372
373int btrfs_dec_test_ordered_pending(struct inode *inode,
374 struct btrfs_ordered_extent **cached,
375 u64 file_offset, u64 io_size, int uptodate)
376{
377 struct btrfs_ordered_inode_tree *tree;
378 struct rb_node *node;
379 struct btrfs_ordered_extent *entry = NULL;
380 unsigned long flags;
381 int ret;
382
383 tree = &BTRFS_I(inode)->ordered_tree;
384 spin_lock_irqsave(&tree->lock, flags);
385 if (cached && *cached) {
386 entry = *cached;
387 goto have_entry;
388 }
389
390 node = tree_search(tree, file_offset);
391 if (!node) {
392 ret = 1;
393 goto out;
394 }
395
396 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
397have_entry:
398 if (!offset_in_entry(entry, file_offset)) {
399 ret = 1;
400 goto out;
401 }
402
403 if (io_size > entry->bytes_left) {
404 printk(KERN_CRIT "bad ordered accounting left %llu size %llu\n",
405 entry->bytes_left, io_size);
406 }
407 entry->bytes_left -= io_size;
408 if (!uptodate)
409 set_bit(BTRFS_ORDERED_IOERR, &entry->flags);
410
411 if (entry->bytes_left == 0)
412 ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
413 else
414 ret = 1;
415out:
416 if (!ret && cached && entry) {
417 *cached = entry;
418 atomic_inc(&entry->refs);
419 }
420 spin_unlock_irqrestore(&tree->lock, flags);
421 return ret == 0;
422}
423
424
425void btrfs_get_logged_extents(struct btrfs_root *log, struct inode *inode)
426{
427 struct btrfs_ordered_inode_tree *tree;
428 struct btrfs_ordered_extent *ordered;
429 struct rb_node *n;
430 int index = log->log_transid % 2;
431
432 tree = &BTRFS_I(inode)->ordered_tree;
433 spin_lock_irq(&tree->lock);
434 for (n = rb_first(&tree->tree); n; n = rb_next(n)) {
435 ordered = rb_entry(n, struct btrfs_ordered_extent, rb_node);
436 spin_lock(&log->log_extents_lock[index]);
437 if (list_empty(&ordered->log_list)) {
438 list_add_tail(&ordered->log_list, &log->logged_list[index]);
439 atomic_inc(&ordered->refs);
440 }
441 spin_unlock(&log->log_extents_lock[index]);
442 }
443 spin_unlock_irq(&tree->lock);
444}
445
446void btrfs_wait_logged_extents(struct btrfs_root *log, u64 transid)
447{
448 struct btrfs_ordered_extent *ordered;
449 int index = transid % 2;
450
451 spin_lock_irq(&log->log_extents_lock[index]);
452 while (!list_empty(&log->logged_list[index])) {
453 ordered = list_first_entry(&log->logged_list[index],
454 struct btrfs_ordered_extent,
455 log_list);
456 list_del_init(&ordered->log_list);
457 spin_unlock_irq(&log->log_extents_lock[index]);
458 wait_event(ordered->wait, test_bit(BTRFS_ORDERED_IO_DONE,
459 &ordered->flags));
460 btrfs_put_ordered_extent(ordered);
461 spin_lock_irq(&log->log_extents_lock[index]);
462 }
463 spin_unlock_irq(&log->log_extents_lock[index]);
464}
465
466void btrfs_free_logged_extents(struct btrfs_root *log, u64 transid)
467{
468 struct btrfs_ordered_extent *ordered;
469 int index = transid % 2;
470
471 spin_lock_irq(&log->log_extents_lock[index]);
472 while (!list_empty(&log->logged_list[index])) {
473 ordered = list_first_entry(&log->logged_list[index],
474 struct btrfs_ordered_extent,
475 log_list);
476 list_del_init(&ordered->log_list);
477 spin_unlock_irq(&log->log_extents_lock[index]);
478 btrfs_put_ordered_extent(ordered);
479 spin_lock_irq(&log->log_extents_lock[index]);
480 }
481 spin_unlock_irq(&log->log_extents_lock[index]);
482}
483
484
485
486
487
488void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
489{
490 struct list_head *cur;
491 struct btrfs_ordered_sum *sum;
492
493 trace_btrfs_ordered_extent_put(entry->inode, entry);
494
495 if (atomic_dec_and_test(&entry->refs)) {
496 if (entry->inode)
497 btrfs_add_delayed_iput(entry->inode);
498 while (!list_empty(&entry->list)) {
499 cur = entry->list.next;
500 sum = list_entry(cur, struct btrfs_ordered_sum, list);
501 list_del(&sum->list);
502 kfree(sum);
503 }
504 kmem_cache_free(btrfs_ordered_extent_cache, entry);
505 }
506}
507
508
509
510
511
512void btrfs_remove_ordered_extent(struct inode *inode,
513 struct btrfs_ordered_extent *entry)
514{
515 struct btrfs_ordered_inode_tree *tree;
516 struct btrfs_root *root = BTRFS_I(inode)->root;
517 struct rb_node *node;
518
519 tree = &BTRFS_I(inode)->ordered_tree;
520 spin_lock_irq(&tree->lock);
521 node = &entry->rb_node;
522 rb_erase(node, &tree->tree);
523 tree->last = NULL;
524 set_bit(BTRFS_ORDERED_COMPLETE, &entry->flags);
525 spin_unlock_irq(&tree->lock);
526
527 spin_lock(&root->ordered_extent_lock);
528 list_del_init(&entry->root_extent_list);
529 root->nr_ordered_extents--;
530
531 trace_btrfs_ordered_extent_remove(inode, entry);
532
533
534
535
536
537
538 if (RB_EMPTY_ROOT(&tree->tree) &&
539 !mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) {
540 list_del_init(&BTRFS_I(inode)->ordered_operations);
541 }
542
543 if (!root->nr_ordered_extents) {
544 spin_lock(&root->fs_info->ordered_root_lock);
545 BUG_ON(list_empty(&root->ordered_root));
546 list_del_init(&root->ordered_root);
547 spin_unlock(&root->fs_info->ordered_root_lock);
548 }
549 spin_unlock(&root->ordered_extent_lock);
550 wake_up(&entry->wait);
551}
552
553static void btrfs_run_ordered_extent_work(struct btrfs_work *work)
554{
555 struct btrfs_ordered_extent *ordered;
556
557 ordered = container_of(work, struct btrfs_ordered_extent, flush_work);
558 btrfs_start_ordered_extent(ordered->inode, ordered, 1);
559 complete(&ordered->completion);
560}
561
562
563
564
565
566void btrfs_wait_ordered_extents(struct btrfs_root *root)
567{
568 struct list_head splice, works;
569 struct btrfs_ordered_extent *ordered, *next;
570
571 INIT_LIST_HEAD(&splice);
572 INIT_LIST_HEAD(&works);
573
574 mutex_lock(&root->fs_info->ordered_operations_mutex);
575 spin_lock(&root->ordered_extent_lock);
576 list_splice_init(&root->ordered_extents, &splice);
577 while (!list_empty(&splice)) {
578 ordered = list_first_entry(&splice, struct btrfs_ordered_extent,
579 root_extent_list);
580 list_move_tail(&ordered->root_extent_list,
581 &root->ordered_extents);
582 atomic_inc(&ordered->refs);
583 spin_unlock(&root->ordered_extent_lock);
584
585 ordered->flush_work.func = btrfs_run_ordered_extent_work;
586 list_add_tail(&ordered->work_list, &works);
587 btrfs_queue_worker(&root->fs_info->flush_workers,
588 &ordered->flush_work);
589
590 cond_resched();
591 spin_lock(&root->ordered_extent_lock);
592 }
593 spin_unlock(&root->ordered_extent_lock);
594
595 list_for_each_entry_safe(ordered, next, &works, work_list) {
596 list_del_init(&ordered->work_list);
597 wait_for_completion(&ordered->completion);
598 btrfs_put_ordered_extent(ordered);
599 cond_resched();
600 }
601 mutex_unlock(&root->fs_info->ordered_operations_mutex);
602}
603
604void btrfs_wait_all_ordered_extents(struct btrfs_fs_info *fs_info)
605{
606 struct btrfs_root *root;
607 struct list_head splice;
608
609 INIT_LIST_HEAD(&splice);
610
611 spin_lock(&fs_info->ordered_root_lock);
612 list_splice_init(&fs_info->ordered_roots, &splice);
613 while (!list_empty(&splice)) {
614 root = list_first_entry(&splice, struct btrfs_root,
615 ordered_root);
616 root = btrfs_grab_fs_root(root);
617 BUG_ON(!root);
618 list_move_tail(&root->ordered_root,
619 &fs_info->ordered_roots);
620 spin_unlock(&fs_info->ordered_root_lock);
621
622 btrfs_wait_ordered_extents(root);
623 btrfs_put_fs_root(root);
624
625 spin_lock(&fs_info->ordered_root_lock);
626 }
627 spin_unlock(&fs_info->ordered_root_lock);
628}
629
630
631
632
633
634
635
636
637
638
639
640int btrfs_run_ordered_operations(struct btrfs_trans_handle *trans,
641 struct btrfs_root *root, int wait)
642{
643 struct btrfs_inode *btrfs_inode;
644 struct inode *inode;
645 struct btrfs_transaction *cur_trans = trans->transaction;
646 struct list_head splice;
647 struct list_head works;
648 struct btrfs_delalloc_work *work, *next;
649 int ret = 0;
650
651 INIT_LIST_HEAD(&splice);
652 INIT_LIST_HEAD(&works);
653
654 mutex_lock(&root->fs_info->ordered_extent_flush_mutex);
655 spin_lock(&root->fs_info->ordered_root_lock);
656 list_splice_init(&cur_trans->ordered_operations, &splice);
657 while (!list_empty(&splice)) {
658 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
659 ordered_operations);
660 inode = &btrfs_inode->vfs_inode;
661
662 list_del_init(&btrfs_inode->ordered_operations);
663
664
665
666
667 inode = igrab(inode);
668 if (!inode)
669 continue;
670
671 if (!wait)
672 list_add_tail(&BTRFS_I(inode)->ordered_operations,
673 &cur_trans->ordered_operations);
674 spin_unlock(&root->fs_info->ordered_root_lock);
675
676 work = btrfs_alloc_delalloc_work(inode, wait, 1);
677 if (!work) {
678 spin_lock(&root->fs_info->ordered_root_lock);
679 if (list_empty(&BTRFS_I(inode)->ordered_operations))
680 list_add_tail(&btrfs_inode->ordered_operations,
681 &splice);
682 list_splice_tail(&splice,
683 &cur_trans->ordered_operations);
684 spin_unlock(&root->fs_info->ordered_root_lock);
685 ret = -ENOMEM;
686 goto out;
687 }
688 list_add_tail(&work->list, &works);
689 btrfs_queue_worker(&root->fs_info->flush_workers,
690 &work->work);
691
692 cond_resched();
693 spin_lock(&root->fs_info->ordered_root_lock);
694 }
695 spin_unlock(&root->fs_info->ordered_root_lock);
696out:
697 list_for_each_entry_safe(work, next, &works, list) {
698 list_del_init(&work->list);
699 btrfs_wait_and_free_delalloc_work(work);
700 }
701 mutex_unlock(&root->fs_info->ordered_extent_flush_mutex);
702 return ret;
703}
704
705
706
707
708
709
710
711
712void btrfs_start_ordered_extent(struct inode *inode,
713 struct btrfs_ordered_extent *entry,
714 int wait)
715{
716 u64 start = entry->file_offset;
717 u64 end = start + entry->len - 1;
718
719 trace_btrfs_ordered_extent_start(inode, entry);
720
721
722
723
724
725
726 if (!test_bit(BTRFS_ORDERED_DIRECT, &entry->flags))
727 filemap_fdatawrite_range(inode->i_mapping, start, end);
728 if (wait) {
729 wait_event(entry->wait, test_bit(BTRFS_ORDERED_COMPLETE,
730 &entry->flags));
731 }
732}
733
734
735
736
737void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
738{
739 u64 end;
740 u64 orig_end;
741 struct btrfs_ordered_extent *ordered;
742
743 if (start + len < start) {
744 orig_end = INT_LIMIT(loff_t);
745 } else {
746 orig_end = start + len - 1;
747 if (orig_end > INT_LIMIT(loff_t))
748 orig_end = INT_LIMIT(loff_t);
749 }
750
751
752
753
754 filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770 if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
771 &BTRFS_I(inode)->runtime_flags))
772 filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
773
774 filemap_fdatawait_range(inode->i_mapping, start, orig_end);
775
776 end = orig_end;
777 while (1) {
778 ordered = btrfs_lookup_first_ordered_extent(inode, end);
779 if (!ordered)
780 break;
781 if (ordered->file_offset > orig_end) {
782 btrfs_put_ordered_extent(ordered);
783 break;
784 }
785 if (ordered->file_offset + ordered->len < start) {
786 btrfs_put_ordered_extent(ordered);
787 break;
788 }
789 btrfs_start_ordered_extent(inode, ordered, 1);
790 end = ordered->file_offset;
791 btrfs_put_ordered_extent(ordered);
792 if (end == 0 || end == start)
793 break;
794 end--;
795 }
796}
797
798
799
800
801
802struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
803 u64 file_offset)
804{
805 struct btrfs_ordered_inode_tree *tree;
806 struct rb_node *node;
807 struct btrfs_ordered_extent *entry = NULL;
808
809 tree = &BTRFS_I(inode)->ordered_tree;
810 spin_lock_irq(&tree->lock);
811 node = tree_search(tree, file_offset);
812 if (!node)
813 goto out;
814
815 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
816 if (!offset_in_entry(entry, file_offset))
817 entry = NULL;
818 if (entry)
819 atomic_inc(&entry->refs);
820out:
821 spin_unlock_irq(&tree->lock);
822 return entry;
823}
824
825
826
827
828struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode,
829 u64 file_offset,
830 u64 len)
831{
832 struct btrfs_ordered_inode_tree *tree;
833 struct rb_node *node;
834 struct btrfs_ordered_extent *entry = NULL;
835
836 tree = &BTRFS_I(inode)->ordered_tree;
837 spin_lock_irq(&tree->lock);
838 node = tree_search(tree, file_offset);
839 if (!node) {
840 node = tree_search(tree, file_offset + len);
841 if (!node)
842 goto out;
843 }
844
845 while (1) {
846 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
847 if (range_overlaps(entry, file_offset, len))
848 break;
849
850 if (entry->file_offset >= file_offset + len) {
851 entry = NULL;
852 break;
853 }
854 entry = NULL;
855 node = rb_next(node);
856 if (!node)
857 break;
858 }
859out:
860 if (entry)
861 atomic_inc(&entry->refs);
862 spin_unlock_irq(&tree->lock);
863 return entry;
864}
865
866
867
868
869
870struct btrfs_ordered_extent *
871btrfs_lookup_first_ordered_extent(struct inode *inode, u64 file_offset)
872{
873 struct btrfs_ordered_inode_tree *tree;
874 struct rb_node *node;
875 struct btrfs_ordered_extent *entry = NULL;
876
877 tree = &BTRFS_I(inode)->ordered_tree;
878 spin_lock_irq(&tree->lock);
879 node = tree_search(tree, file_offset);
880 if (!node)
881 goto out;
882
883 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
884 atomic_inc(&entry->refs);
885out:
886 spin_unlock_irq(&tree->lock);
887 return entry;
888}
889
890
891
892
893
894int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
895 struct btrfs_ordered_extent *ordered)
896{
897 struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
898 u64 disk_i_size;
899 u64 new_i_size;
900 u64 i_size = i_size_read(inode);
901 struct rb_node *node;
902 struct rb_node *prev = NULL;
903 struct btrfs_ordered_extent *test;
904 int ret = 1;
905
906 spin_lock_irq(&tree->lock);
907 if (ordered) {
908 offset = entry_end(ordered);
909 if (test_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags))
910 offset = min(offset,
911 ordered->file_offset +
912 ordered->truncated_len);
913 } else {
914 offset = ALIGN(offset, BTRFS_I(inode)->root->sectorsize);
915 }
916 disk_i_size = BTRFS_I(inode)->disk_i_size;
917
918
919 if (disk_i_size > i_size) {
920 BTRFS_I(inode)->disk_i_size = i_size;
921 ret = 0;
922 goto out;
923 }
924
925
926
927
928
929 if (disk_i_size == i_size)
930 goto out;
931
932
933
934
935
936 if (offset <= disk_i_size &&
937 (!ordered || ordered->outstanding_isize <= disk_i_size))
938 goto out;
939
940
941
942
943
944
945 if (ordered) {
946 node = rb_prev(&ordered->rb_node);
947 } else {
948 prev = tree_search(tree, offset);
949
950
951
952
953 if (prev) {
954 test = rb_entry(prev, struct btrfs_ordered_extent,
955 rb_node);
956 BUG_ON(offset_in_entry(test, offset));
957 }
958 node = prev;
959 }
960 for (; node; node = rb_prev(node)) {
961 test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
962
963
964 if (test_bit(BTRFS_ORDERED_UPDATED_ISIZE, &test->flags))
965 continue;
966 if (test->file_offset + test->len <= disk_i_size)
967 break;
968 if (test->file_offset >= i_size)
969 break;
970 if (entry_end(test) > disk_i_size) {
971
972
973
974
975
976 if (test->outstanding_isize < offset)
977 test->outstanding_isize = offset;
978 if (ordered &&
979 ordered->outstanding_isize >
980 test->outstanding_isize)
981 test->outstanding_isize =
982 ordered->outstanding_isize;
983 goto out;
984 }
985 }
986 new_i_size = min_t(u64, offset, i_size);
987
988
989
990
991
992 if (ordered && ordered->outstanding_isize > new_i_size)
993 new_i_size = min_t(u64, ordered->outstanding_isize, i_size);
994 BTRFS_I(inode)->disk_i_size = new_i_size;
995 ret = 0;
996out:
997
998
999
1000
1001
1002
1003
1004 if (ordered)
1005 set_bit(BTRFS_ORDERED_UPDATED_ISIZE, &ordered->flags);
1006 spin_unlock_irq(&tree->lock);
1007 return ret;
1008}
1009
1010
1011
1012
1013
1014
1015int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
1016 u32 *sum, int len)
1017{
1018 struct btrfs_ordered_sum *ordered_sum;
1019 struct btrfs_ordered_extent *ordered;
1020 struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
1021 unsigned long num_sectors;
1022 unsigned long i;
1023 u32 sectorsize = BTRFS_I(inode)->root->sectorsize;
1024 int index = 0;
1025
1026 ordered = btrfs_lookup_ordered_extent(inode, offset);
1027 if (!ordered)
1028 return 0;
1029
1030 spin_lock_irq(&tree->lock);
1031 list_for_each_entry_reverse(ordered_sum, &ordered->list, list) {
1032 if (disk_bytenr >= ordered_sum->bytenr &&
1033 disk_bytenr < ordered_sum->bytenr + ordered_sum->len) {
1034 i = (disk_bytenr - ordered_sum->bytenr) >>
1035 inode->i_sb->s_blocksize_bits;
1036 num_sectors = ordered_sum->len >>
1037 inode->i_sb->s_blocksize_bits;
1038 num_sectors = min_t(int, len - index, num_sectors - i);
1039 memcpy(sum + index, ordered_sum->sums + i,
1040 num_sectors);
1041
1042 index += (int)num_sectors;
1043 if (index == len)
1044 goto out;
1045 disk_bytenr += num_sectors * sectorsize;
1046 }
1047 }
1048out:
1049 spin_unlock_irq(&tree->lock);
1050 btrfs_put_ordered_extent(ordered);
1051 return index;
1052}
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
1068 struct btrfs_root *root, struct inode *inode)
1069{
1070 struct btrfs_transaction *cur_trans = trans->transaction;
1071 u64 last_mod;
1072
1073 last_mod = max(BTRFS_I(inode)->generation, BTRFS_I(inode)->last_trans);
1074
1075
1076
1077
1078
1079 if (last_mod < root->fs_info->last_trans_committed)
1080 return;
1081
1082 spin_lock(&root->fs_info->ordered_root_lock);
1083 if (list_empty(&BTRFS_I(inode)->ordered_operations)) {
1084 list_add_tail(&BTRFS_I(inode)->ordered_operations,
1085 &cur_trans->ordered_operations);
1086 }
1087 spin_unlock(&root->fs_info->ordered_root_lock);
1088}
1089
1090int __init ordered_data_init(void)
1091{
1092 btrfs_ordered_extent_cache = kmem_cache_create("btrfs_ordered_extent",
1093 sizeof(struct btrfs_ordered_extent), 0,
1094 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
1095 NULL);
1096 if (!btrfs_ordered_extent_cache)
1097 return -ENOMEM;
1098
1099 return 0;
1100}
1101
1102void ordered_data_exit(void)
1103{
1104 if (btrfs_ordered_extent_cache)
1105 kmem_cache_destroy(btrfs_ordered_extent_cache);
1106}
1107