]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/btrfs/ordered-data.c
2 * Copyright (C) 2007 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include <linux/gfp.h>
20 #include <linux/slab.h>
21 #include <linux/blkdev.h>
23 #include "transaction.h"
24 #include "btrfs_inode.h"
25 #include "extent_io.h"
28 static u64
entry_end(struct btrfs_ordered_extent
*entry
)
30 if (entry
->file_offset
+ entry
->len
< entry
->file_offset
)
32 return entry
->file_offset
+ entry
->len
;
35 static struct rb_node
*tree_insert(struct rb_root
*root
, u64 file_offset
,
38 struct rb_node
** p
= &root
->rb_node
;
39 struct rb_node
* parent
= NULL
;
40 struct btrfs_ordered_extent
*entry
;
44 entry
= rb_entry(parent
, struct btrfs_ordered_extent
, rb_node
);
46 if (file_offset
< entry
->file_offset
)
48 else if (file_offset
>= entry_end(entry
))
54 rb_link_node(node
, parent
, p
);
55 rb_insert_color(node
, root
);
59 static struct rb_node
*__tree_search(struct rb_root
*root
, u64 file_offset
,
60 struct rb_node
**prev_ret
)
62 struct rb_node
* n
= root
->rb_node
;
63 struct rb_node
*prev
= NULL
;
65 struct btrfs_ordered_extent
*entry
;
66 struct btrfs_ordered_extent
*prev_entry
= NULL
;
69 entry
= rb_entry(n
, struct btrfs_ordered_extent
, rb_node
);
73 if (file_offset
< entry
->file_offset
)
75 else if (file_offset
>= entry_end(entry
))
83 while(prev
&& file_offset
>= entry_end(prev_entry
)) {
87 prev_entry
= rb_entry(test
, struct btrfs_ordered_extent
,
89 if (file_offset
< entry_end(prev_entry
))
95 prev_entry
= rb_entry(prev
, struct btrfs_ordered_extent
,
97 while(prev
&& file_offset
< entry_end(prev_entry
)) {
101 prev_entry
= rb_entry(test
, struct btrfs_ordered_extent
,
109 static int offset_in_entry(struct btrfs_ordered_extent
*entry
, u64 file_offset
)
111 if (file_offset
< entry
->file_offset
||
112 entry
->file_offset
+ entry
->len
<= file_offset
)
117 static inline struct rb_node
*tree_search(struct btrfs_ordered_inode_tree
*tree
,
120 struct rb_root
*root
= &tree
->tree
;
121 struct rb_node
*prev
;
123 struct btrfs_ordered_extent
*entry
;
126 entry
= rb_entry(tree
->last
, struct btrfs_ordered_extent
,
128 if (offset_in_entry(entry
, file_offset
))
131 ret
= __tree_search(root
, file_offset
, &prev
);
139 int btrfs_add_ordered_extent(struct inode
*inode
, u64 file_offset
,
142 struct btrfs_ordered_inode_tree
*tree
;
143 struct rb_node
*node
;
144 struct btrfs_ordered_extent
*entry
;
146 tree
= &BTRFS_I(inode
)->ordered_tree
;
147 entry
= kzalloc(sizeof(*entry
), GFP_NOFS
);
151 mutex_lock(&tree
->mutex
);
152 entry
->file_offset
= file_offset
;
153 entry
->start
= start
;
155 entry
->inode
= inode
;
156 /* one ref for the tree */
157 atomic_set(&entry
->refs
, 1);
158 init_waitqueue_head(&entry
->wait
);
159 INIT_LIST_HEAD(&entry
->list
);
161 node
= tree_insert(&tree
->tree
, file_offset
,
164 entry
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
165 atomic_inc(&entry
->refs
);
167 set_extent_ordered(&BTRFS_I(inode
)->io_tree
, file_offset
,
168 entry_end(entry
) - 1, GFP_NOFS
);
170 set_bit(BTRFS_ORDERED_START
, &entry
->flags
);
171 mutex_unlock(&tree
->mutex
);
176 int btrfs_add_ordered_sum(struct inode
*inode
, struct btrfs_ordered_sum
*sum
)
178 struct btrfs_ordered_inode_tree
*tree
;
179 struct rb_node
*node
;
180 struct btrfs_ordered_extent
*entry
;
182 tree
= &BTRFS_I(inode
)->ordered_tree
;
183 mutex_lock(&tree
->mutex
);
184 node
= tree_search(tree
, sum
->file_offset
);
187 printk("add ordered sum failed to find a node for inode %lu offset %Lu\n", inode
->i_ino
, sum
->file_offset
);
188 node
= rb_first(&tree
->tree
);
190 entry
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
191 printk("entry %Lu %Lu %Lu\n", entry
->file_offset
, entry
->file_offset
+ entry
->len
, entry
->start
);
192 node
= rb_next(node
);
198 entry
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
199 if (!offset_in_entry(entry
, sum
->file_offset
)) {
203 list_add_tail(&sum
->list
, &entry
->list
);
204 mutex_unlock(&tree
->mutex
);
208 int btrfs_dec_test_ordered_pending(struct inode
*inode
,
209 u64 file_offset
, u64 io_size
)
211 struct btrfs_ordered_inode_tree
*tree
;
212 struct rb_node
*node
;
213 struct btrfs_ordered_extent
*entry
;
214 struct extent_io_tree
*io_tree
= &BTRFS_I(inode
)->io_tree
;
217 tree
= &BTRFS_I(inode
)->ordered_tree
;
218 mutex_lock(&tree
->mutex
);
219 clear_extent_ordered(io_tree
, file_offset
, file_offset
+ io_size
- 1,
221 node
= tree_search(tree
, file_offset
);
227 entry
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
228 if (!offset_in_entry(entry
, file_offset
)) {
233 ret
= test_range_bit(io_tree
, entry
->file_offset
,
234 entry
->file_offset
+ entry
->len
- 1,
236 if (!test_bit(BTRFS_ORDERED_START
, &entry
->flags
)) {
237 printk("inode %lu not ready yet for extent %Lu %Lu\n", inode
->i_ino
, entry
->file_offset
, entry_end(entry
));
240 ret
= test_and_set_bit(BTRFS_ORDERED_IO_DONE
, &entry
->flags
);
242 mutex_unlock(&tree
->mutex
);
246 int btrfs_put_ordered_extent(struct btrfs_ordered_extent
*entry
)
248 struct list_head
*cur
;
249 struct btrfs_ordered_sum
*sum
;
251 if (atomic_dec_and_test(&entry
->refs
)) {
252 while(!list_empty(&entry
->list
)) {
253 cur
= entry
->list
.next
;
254 sum
= list_entry(cur
, struct btrfs_ordered_sum
, list
);
255 list_del(&sum
->list
);
263 int btrfs_remove_ordered_extent(struct inode
*inode
,
264 struct btrfs_ordered_extent
*entry
)
266 struct btrfs_ordered_inode_tree
*tree
;
267 struct rb_node
*node
;
269 tree
= &BTRFS_I(inode
)->ordered_tree
;
270 mutex_lock(&tree
->mutex
);
271 node
= &entry
->rb_node
;
272 rb_erase(node
, &tree
->tree
);
274 set_bit(BTRFS_ORDERED_COMPLETE
, &entry
->flags
);
275 mutex_unlock(&tree
->mutex
);
276 wake_up(&entry
->wait
);
280 void btrfs_wait_ordered_extent(struct inode
*inode
,
281 struct btrfs_ordered_extent
*entry
)
283 u64 start
= entry
->file_offset
;
284 u64 end
= start
+ entry
->len
- 1;
285 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
286 do_sync_file_range(file
, start
, end
, SYNC_FILE_RANGE_WRITE
);
288 do_sync_mapping_range(inode
->i_mapping
, start
, end
,
289 SYNC_FILE_RANGE_WRITE
);
291 wait_event(entry
->wait
,
292 test_bit(BTRFS_ORDERED_COMPLETE
, &entry
->flags
));
295 static void btrfs_start_ordered_extent(struct inode
*inode
,
296 struct btrfs_ordered_extent
*entry
, int wait
)
298 u64 start
= entry
->file_offset
;
299 u64 end
= start
+ entry
->len
- 1;
301 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
302 do_sync_file_range(file
, start
, end
, SYNC_FILE_RANGE_WRITE
);
304 do_sync_mapping_range(inode
->i_mapping
, start
, end
,
305 SYNC_FILE_RANGE_WRITE
);
308 wait_event(entry
->wait
, test_bit(BTRFS_ORDERED_COMPLETE
,
312 void btrfs_wait_ordered_range(struct inode
*inode
, u64 start
, u64 len
)
315 struct btrfs_ordered_extent
*ordered
;
320 if (start
+ len
< start
)
323 end
= start
+ len
- 1;
326 ordered
= btrfs_lookup_first_ordered_extent(inode
, end
);
330 if (ordered
->file_offset
>= start
+ len
) {
331 btrfs_put_ordered_extent(ordered
);
334 if (ordered
->file_offset
+ ordered
->len
< start
) {
335 btrfs_put_ordered_extent(ordered
);
338 btrfs_start_ordered_extent(inode
, ordered
, should_wait
);
340 end
= ordered
->file_offset
;
341 btrfs_put_ordered_extent(ordered
);
346 if (should_wait
&& found
) {
352 int btrfs_add_ordered_pending(struct inode
*inode
,
353 struct btrfs_ordered_extent
*ordered
,
360 struct btrfs_ordered_inode_tree
*tree
;
361 struct extent_io_tree
*io_tree
= &BTRFS_I(inode
)->io_tree
;
363 tree
= &BTRFS_I(inode
)->ordered_tree
;
364 mutex_lock(&tree
->mutex
);
365 if (test_bit(BTRFS_ORDERED_IO_DONE
, &ordered
->flags
)) {
369 set_extent_ordered(io_tree
, start
, start
+ len
- 1, GFP_NOFS
);
372 mutex_unlock(&tree
->mutex
);
377 struct btrfs_ordered_extent
*btrfs_lookup_ordered_extent(struct inode
*inode
,
380 struct btrfs_ordered_inode_tree
*tree
;
381 struct rb_node
*node
;
382 struct btrfs_ordered_extent
*entry
= NULL
;
384 tree
= &BTRFS_I(inode
)->ordered_tree
;
385 mutex_lock(&tree
->mutex
);
386 node
= tree_search(tree
, file_offset
);
390 entry
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
391 if (!offset_in_entry(entry
, file_offset
))
394 atomic_inc(&entry
->refs
);
396 mutex_unlock(&tree
->mutex
);
400 struct btrfs_ordered_extent
*
401 btrfs_lookup_first_ordered_extent(struct inode
* inode
, u64 file_offset
)
403 struct btrfs_ordered_inode_tree
*tree
;
404 struct rb_node
*node
;
405 struct btrfs_ordered_extent
*entry
= NULL
;
407 tree
= &BTRFS_I(inode
)->ordered_tree
;
408 mutex_lock(&tree
->mutex
);
409 node
= tree_search(tree
, file_offset
);
413 entry
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
414 atomic_inc(&entry
->refs
);
416 mutex_unlock(&tree
->mutex
);
420 int btrfs_ordered_update_i_size(struct inode
*inode
,
421 struct btrfs_ordered_extent
*ordered
)
423 struct btrfs_ordered_inode_tree
*tree
= &BTRFS_I(inode
)->ordered_tree
;
424 struct extent_io_tree
*io_tree
= &BTRFS_I(inode
)->io_tree
;
428 struct rb_node
*node
;
429 struct btrfs_ordered_extent
*test
;
431 mutex_lock(&tree
->mutex
);
432 disk_i_size
= BTRFS_I(inode
)->disk_i_size
;
435 * if the disk i_size is already at the inode->i_size, or
436 * this ordered extent is inside the disk i_size, we're done
438 if (disk_i_size
>= inode
->i_size
||
439 ordered
->file_offset
+ ordered
->len
<= disk_i_size
) {
444 * we can't update the disk_isize if there are delalloc bytes
445 * between disk_i_size and this ordered extent
447 if (test_range_bit(io_tree
, disk_i_size
,
448 ordered
->file_offset
+ ordered
->len
- 1,
449 EXTENT_DELALLOC
, 0)) {
453 * walk backward from this ordered extent to disk_i_size.
454 * if we find an ordered extent then we can't update disk i_size
457 node
= &ordered
->rb_node
;
459 node
= rb_prev(node
);
462 test
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
463 if (test
->file_offset
+ test
->len
<= disk_i_size
)
465 if (test
->file_offset
>= inode
->i_size
)
467 if (test
->file_offset
>= disk_i_size
)
470 new_i_size
= min_t(u64
, entry_end(ordered
), i_size_read(inode
));
473 * at this point, we know we can safely update i_size to at least
474 * the offset from this ordered extent. But, we need to
475 * walk forward and see if ios from higher up in the file have
478 node
= rb_next(&ordered
->rb_node
);
482 * do we have an area where IO might have finished
483 * between our ordered extent and the next one.
485 test
= rb_entry(node
, struct btrfs_ordered_extent
, rb_node
);
486 if (test
->file_offset
> entry_end(ordered
)) {
487 i_size_test
= test
->file_offset
- 1;
490 i_size_test
= i_size_read(inode
);
494 * i_size_test is the end of a region after this ordered
495 * extent where there are no ordered extents. As long as there
496 * are no delalloc bytes in this area, it is safe to update
497 * disk_i_size to the end of the region.
499 if (i_size_test
> entry_end(ordered
) &&
500 !test_range_bit(io_tree
, entry_end(ordered
), i_size_test
,
501 EXTENT_DELALLOC
, 0)) {
502 new_i_size
= min_t(u64
, i_size_test
, i_size_read(inode
));
504 BTRFS_I(inode
)->disk_i_size
= new_i_size
;
506 mutex_unlock(&tree
->mutex
);
510 int btrfs_find_ordered_sum(struct inode
*inode
, u64 offset
, u32
*sum
)
512 struct btrfs_ordered_sum
*ordered_sum
;
513 struct btrfs_sector_sum
*sector_sums
;
514 struct btrfs_ordered_extent
*ordered
;
515 struct btrfs_ordered_inode_tree
*tree
= &BTRFS_I(inode
)->ordered_tree
;
516 struct list_head
*cur
;
520 ordered
= btrfs_lookup_ordered_extent(inode
, offset
);
524 mutex_lock(&tree
->mutex
);
525 list_for_each_prev(cur
, &ordered
->list
) {
526 ordered_sum
= list_entry(cur
, struct btrfs_ordered_sum
, list
);
527 if (offset
>= ordered_sum
->file_offset
&&
528 offset
< ordered_sum
->file_offset
+ ordered_sum
->len
) {
529 index
= (offset
- ordered_sum
->file_offset
) /
530 BTRFS_I(inode
)->root
->sectorsize
;;
531 sector_sums
= &ordered_sum
->sums
;
532 *sum
= sector_sums
[index
].sum
;
538 mutex_unlock(&tree
->mutex
);