blob: c9f1020572f22cd0ec100da5c21164c14cbbdfdd [file] [log] [blame]
Chris Masondc17ff82008-01-08 15:46:30 -05001/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
Chris Masondc17ff82008-01-08 15:46:30 -050019#include <linux/slab.h>
Chris Masond6bfde82008-04-30 13:59:35 -040020#include <linux/blkdev.h>
Chris Masonf4219502008-07-22 11:18:09 -040021#include <linux/writeback.h>
22#include <linux/pagevec.h>
Chris Masondc17ff82008-01-08 15:46:30 -050023#include "ctree.h"
24#include "transaction.h"
25#include "btrfs_inode.h"
Chris Masone6dcd2d2008-07-17 12:53:50 -040026#include "extent_io.h"
Chris Masondc17ff82008-01-08 15:46:30 -050027
Chris Masone6dcd2d2008-07-17 12:53:50 -040028static u64 entry_end(struct btrfs_ordered_extent *entry)
Chris Masondc17ff82008-01-08 15:46:30 -050029{
Chris Masone6dcd2d2008-07-17 12:53:50 -040030 if (entry->file_offset + entry->len < entry->file_offset)
31 return (u64)-1;
32 return entry->file_offset + entry->len;
Chris Masondc17ff82008-01-08 15:46:30 -050033}
34
Chris Masond352ac62008-09-29 15:18:18 -040035/* returns NULL if the insertion worked, or it returns the node it did find
36 * in the tree
37 */
Chris Masone6dcd2d2008-07-17 12:53:50 -040038static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset,
39 struct rb_node *node)
Chris Masondc17ff82008-01-08 15:46:30 -050040{
Chris Masond3977122009-01-05 21:25:51 -050041 struct rb_node **p = &root->rb_node;
42 struct rb_node *parent = NULL;
Chris Masone6dcd2d2008-07-17 12:53:50 -040043 struct btrfs_ordered_extent *entry;
Chris Masondc17ff82008-01-08 15:46:30 -050044
Chris Masond3977122009-01-05 21:25:51 -050045 while (*p) {
Chris Masondc17ff82008-01-08 15:46:30 -050046 parent = *p;
Chris Masone6dcd2d2008-07-17 12:53:50 -040047 entry = rb_entry(parent, struct btrfs_ordered_extent, rb_node);
Chris Masondc17ff82008-01-08 15:46:30 -050048
Chris Masone6dcd2d2008-07-17 12:53:50 -040049 if (file_offset < entry->file_offset)
Chris Masondc17ff82008-01-08 15:46:30 -050050 p = &(*p)->rb_left;
Chris Masone6dcd2d2008-07-17 12:53:50 -040051 else if (file_offset >= entry_end(entry))
Chris Masondc17ff82008-01-08 15:46:30 -050052 p = &(*p)->rb_right;
53 else
54 return parent;
55 }
56
57 rb_link_node(node, parent, p);
58 rb_insert_color(node, root);
59 return NULL;
60}
61
Chris Masond352ac62008-09-29 15:18:18 -040062/*
63 * look for a given offset in the tree, and if it can't be found return the
64 * first lesser offset
65 */
Chris Masone6dcd2d2008-07-17 12:53:50 -040066static struct rb_node *__tree_search(struct rb_root *root, u64 file_offset,
67 struct rb_node **prev_ret)
Chris Masondc17ff82008-01-08 15:46:30 -050068{
Chris Masond3977122009-01-05 21:25:51 -050069 struct rb_node *n = root->rb_node;
Chris Masondc17ff82008-01-08 15:46:30 -050070 struct rb_node *prev = NULL;
Chris Masone6dcd2d2008-07-17 12:53:50 -040071 struct rb_node *test;
72 struct btrfs_ordered_extent *entry;
73 struct btrfs_ordered_extent *prev_entry = NULL;
Chris Masondc17ff82008-01-08 15:46:30 -050074
Chris Masond3977122009-01-05 21:25:51 -050075 while (n) {
Chris Masone6dcd2d2008-07-17 12:53:50 -040076 entry = rb_entry(n, struct btrfs_ordered_extent, rb_node);
Chris Masondc17ff82008-01-08 15:46:30 -050077 prev = n;
78 prev_entry = entry;
Chris Masondc17ff82008-01-08 15:46:30 -050079
Chris Masone6dcd2d2008-07-17 12:53:50 -040080 if (file_offset < entry->file_offset)
Chris Masondc17ff82008-01-08 15:46:30 -050081 n = n->rb_left;
Chris Masone6dcd2d2008-07-17 12:53:50 -040082 else if (file_offset >= entry_end(entry))
Chris Masondc17ff82008-01-08 15:46:30 -050083 n = n->rb_right;
84 else
85 return n;
86 }
87 if (!prev_ret)
88 return NULL;
89
Chris Masond3977122009-01-05 21:25:51 -050090 while (prev && file_offset >= entry_end(prev_entry)) {
Chris Masone6dcd2d2008-07-17 12:53:50 -040091 test = rb_next(prev);
92 if (!test)
93 break;
94 prev_entry = rb_entry(test, struct btrfs_ordered_extent,
95 rb_node);
96 if (file_offset < entry_end(prev_entry))
97 break;
98
99 prev = test;
100 }
101 if (prev)
102 prev_entry = rb_entry(prev, struct btrfs_ordered_extent,
103 rb_node);
Chris Masond3977122009-01-05 21:25:51 -0500104 while (prev && file_offset < entry_end(prev_entry)) {
Chris Masone6dcd2d2008-07-17 12:53:50 -0400105 test = rb_prev(prev);
106 if (!test)
107 break;
108 prev_entry = rb_entry(test, struct btrfs_ordered_extent,
109 rb_node);
110 prev = test;
Chris Masondc17ff82008-01-08 15:46:30 -0500111 }
112 *prev_ret = prev;
113 return NULL;
114}
115
Chris Masond352ac62008-09-29 15:18:18 -0400116/*
117 * helper to check if a given offset is inside a given entry
118 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400119static int offset_in_entry(struct btrfs_ordered_extent *entry, u64 file_offset)
Chris Masondc17ff82008-01-08 15:46:30 -0500120{
Chris Masone6dcd2d2008-07-17 12:53:50 -0400121 if (file_offset < entry->file_offset ||
122 entry->file_offset + entry->len <= file_offset)
123 return 0;
124 return 1;
125}
126
Chris Masond352ac62008-09-29 15:18:18 -0400127/*
128 * look find the first ordered struct that has this offset, otherwise
129 * the first one less than this offset
130 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400131static inline struct rb_node *tree_search(struct btrfs_ordered_inode_tree *tree,
132 u64 file_offset)
133{
134 struct rb_root *root = &tree->tree;
Chris Masondc17ff82008-01-08 15:46:30 -0500135 struct rb_node *prev;
136 struct rb_node *ret;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400137 struct btrfs_ordered_extent *entry;
138
139 if (tree->last) {
140 entry = rb_entry(tree->last, struct btrfs_ordered_extent,
141 rb_node);
142 if (offset_in_entry(entry, file_offset))
143 return tree->last;
144 }
145 ret = __tree_search(root, file_offset, &prev);
Chris Masondc17ff82008-01-08 15:46:30 -0500146 if (!ret)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400147 ret = prev;
148 if (ret)
149 tree->last = ret;
Chris Masondc17ff82008-01-08 15:46:30 -0500150 return ret;
151}
152
Chris Masoneb84ae02008-07-17 13:53:27 -0400153/* allocate and add a new ordered_extent into the per-inode tree.
154 * file_offset is the logical offset in the file
155 *
156 * start is the disk block number of an extent already reserved in the
157 * extent allocation tree
158 *
159 * len is the length of the extent
160 *
Chris Masoneb84ae02008-07-17 13:53:27 -0400161 * The tree is given a single reference on the ordered extent that was
162 * inserted.
163 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400164int btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
Yan Zheng80ff3852008-10-30 14:20:02 -0400165 u64 start, u64 len, u64 disk_len, int type)
Chris Masondc17ff82008-01-08 15:46:30 -0500166{
Chris Masondc17ff82008-01-08 15:46:30 -0500167 struct btrfs_ordered_inode_tree *tree;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400168 struct rb_node *node;
169 struct btrfs_ordered_extent *entry;
Chris Masondc17ff82008-01-08 15:46:30 -0500170
Chris Masone6dcd2d2008-07-17 12:53:50 -0400171 tree = &BTRFS_I(inode)->ordered_tree;
172 entry = kzalloc(sizeof(*entry), GFP_NOFS);
Chris Masondc17ff82008-01-08 15:46:30 -0500173 if (!entry)
174 return -ENOMEM;
175
Chris Masone6dcd2d2008-07-17 12:53:50 -0400176 entry->file_offset = file_offset;
177 entry->start = start;
178 entry->len = len;
Chris Masonc8b97812008-10-29 14:49:59 -0400179 entry->disk_len = disk_len;
Chris Mason8b62b722009-09-02 16:53:46 -0400180 entry->bytes_left = len;
Chris Mason3eaa2882008-07-24 11:57:52 -0400181 entry->inode = inode;
Yan Zhengd899e052008-10-30 14:25:28 -0400182 if (type != BTRFS_ORDERED_IO_DONE && type != BTRFS_ORDERED_COMPLETE)
Yan Zheng80ff3852008-10-30 14:20:02 -0400183 set_bit(type, &entry->flags);
Chris Mason3eaa2882008-07-24 11:57:52 -0400184
Chris Masone6dcd2d2008-07-17 12:53:50 -0400185 /* one ref for the tree */
186 atomic_set(&entry->refs, 1);
187 init_waitqueue_head(&entry->wait);
188 INIT_LIST_HEAD(&entry->list);
Chris Mason3eaa2882008-07-24 11:57:52 -0400189 INIT_LIST_HEAD(&entry->root_extent_list);
Chris Masondc17ff82008-01-08 15:46:30 -0500190
Josef Bacik49958fd2010-02-02 21:48:28 +0000191 spin_lock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400192 node = tree_insert(&tree->tree, file_offset,
193 &entry->rb_node);
Chris Masond3977122009-01-05 21:25:51 -0500194 BUG_ON(node);
Josef Bacik49958fd2010-02-02 21:48:28 +0000195 spin_unlock(&tree->lock);
Chris Masond3977122009-01-05 21:25:51 -0500196
Chris Mason3eaa2882008-07-24 11:57:52 -0400197 spin_lock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock);
198 list_add_tail(&entry->root_extent_list,
199 &BTRFS_I(inode)->root->fs_info->ordered_extents);
200 spin_unlock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock);
201
Chris Masone6dcd2d2008-07-17 12:53:50 -0400202 BUG_ON(node);
203 return 0;
204}
Chris Masondc17ff82008-01-08 15:46:30 -0500205
Chris Masoneb84ae02008-07-17 13:53:27 -0400206/*
207 * Add a struct btrfs_ordered_sum into the list of checksums to be inserted
Chris Mason3edf7d32008-07-18 06:17:13 -0400208 * when an ordered extent is finished. If the list covers more than one
209 * ordered extent, it is split across multiples.
Chris Masoneb84ae02008-07-17 13:53:27 -0400210 */
Chris Mason3edf7d32008-07-18 06:17:13 -0400211int btrfs_add_ordered_sum(struct inode *inode,
212 struct btrfs_ordered_extent *entry,
213 struct btrfs_ordered_sum *sum)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400214{
215 struct btrfs_ordered_inode_tree *tree;
Chris Mason1b1e2132008-06-25 16:01:31 -0400216
Chris Masone6dcd2d2008-07-17 12:53:50 -0400217 tree = &BTRFS_I(inode)->ordered_tree;
Josef Bacik49958fd2010-02-02 21:48:28 +0000218 spin_lock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400219 list_add_tail(&sum->list, &entry->list);
Josef Bacik49958fd2010-02-02 21:48:28 +0000220 spin_unlock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400221 return 0;
222}
223
Chris Masoneb84ae02008-07-17 13:53:27 -0400224/*
225 * this is used to account for finished IO across a given range
226 * of the file. The IO should not span ordered extents. If
227 * a given ordered_extent is completely done, 1 is returned, otherwise
228 * 0.
229 *
230 * test_and_set_bit on a flag in the struct btrfs_ordered_extent is used
231 * to make sure this function only returns 1 once for a given ordered extent.
232 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400233int btrfs_dec_test_ordered_pending(struct inode *inode,
Josef Bacik5a1a3df2010-02-02 20:51:14 +0000234 struct btrfs_ordered_extent **cached,
Chris Masone6dcd2d2008-07-17 12:53:50 -0400235 u64 file_offset, u64 io_size)
236{
237 struct btrfs_ordered_inode_tree *tree;
238 struct rb_node *node;
Josef Bacik5a1a3df2010-02-02 20:51:14 +0000239 struct btrfs_ordered_extent *entry = NULL;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400240 int ret;
241
242 tree = &BTRFS_I(inode)->ordered_tree;
Josef Bacik49958fd2010-02-02 21:48:28 +0000243 spin_lock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400244 node = tree_search(tree, file_offset);
245 if (!node) {
246 ret = 1;
247 goto out;
248 }
249
250 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
251 if (!offset_in_entry(entry, file_offset)) {
252 ret = 1;
253 goto out;
254 }
255
Chris Mason8b62b722009-09-02 16:53:46 -0400256 if (io_size > entry->bytes_left) {
257 printk(KERN_CRIT "bad ordered accounting left %llu size %llu\n",
258 (unsigned long long)entry->bytes_left,
259 (unsigned long long)io_size);
260 }
261 entry->bytes_left -= io_size;
262 if (entry->bytes_left == 0)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400263 ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
Chris Mason8b62b722009-09-02 16:53:46 -0400264 else
265 ret = 1;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400266out:
Josef Bacik5a1a3df2010-02-02 20:51:14 +0000267 if (!ret && cached && entry) {
268 *cached = entry;
269 atomic_inc(&entry->refs);
270 }
Josef Bacik49958fd2010-02-02 21:48:28 +0000271 spin_unlock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400272 return ret == 0;
273}
274
Chris Masoneb84ae02008-07-17 13:53:27 -0400275/*
276 * used to drop a reference on an ordered extent. This will free
277 * the extent if the last reference is dropped
278 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400279int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
280{
Chris Masonba1da2f2008-07-17 12:54:15 -0400281 struct list_head *cur;
282 struct btrfs_ordered_sum *sum;
283
284 if (atomic_dec_and_test(&entry->refs)) {
Chris Masond3977122009-01-05 21:25:51 -0500285 while (!list_empty(&entry->list)) {
Chris Masonba1da2f2008-07-17 12:54:15 -0400286 cur = entry->list.next;
287 sum = list_entry(cur, struct btrfs_ordered_sum, list);
288 list_del(&sum->list);
289 kfree(sum);
290 }
Chris Masondc17ff82008-01-08 15:46:30 -0500291 kfree(entry);
Chris Masonba1da2f2008-07-17 12:54:15 -0400292 }
Chris Masondc17ff82008-01-08 15:46:30 -0500293 return 0;
294}
295
Chris Masoneb84ae02008-07-17 13:53:27 -0400296/*
297 * remove an ordered extent from the tree. No references are dropped
Josef Bacik49958fd2010-02-02 21:48:28 +0000298 * and you must wake_up entry->wait. You must hold the tree lock
Yan, Zhengc2167752009-11-12 09:34:21 +0000299 * while you call this function.
Chris Masoneb84ae02008-07-17 13:53:27 -0400300 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000301static int __btrfs_remove_ordered_extent(struct inode *inode,
Chris Masone6dcd2d2008-07-17 12:53:50 -0400302 struct btrfs_ordered_extent *entry)
Chris Masondc17ff82008-01-08 15:46:30 -0500303{
Chris Masone6dcd2d2008-07-17 12:53:50 -0400304 struct btrfs_ordered_inode_tree *tree;
Josef Bacik287a0ab2010-03-19 18:07:23 +0000305 struct btrfs_root *root = BTRFS_I(inode)->root;
Chris Masondc17ff82008-01-08 15:46:30 -0500306 struct rb_node *node;
307
Chris Masone6dcd2d2008-07-17 12:53:50 -0400308 tree = &BTRFS_I(inode)->ordered_tree;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400309 node = &entry->rb_node;
Chris Masondc17ff82008-01-08 15:46:30 -0500310 rb_erase(node, &tree->tree);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400311 tree->last = NULL;
312 set_bit(BTRFS_ORDERED_COMPLETE, &entry->flags);
Chris Mason3eaa2882008-07-24 11:57:52 -0400313
Josef Bacik287a0ab2010-03-19 18:07:23 +0000314 spin_lock(&root->fs_info->ordered_extent_lock);
Chris Mason3eaa2882008-07-24 11:57:52 -0400315 list_del_init(&entry->root_extent_list);
Chris Mason5a3f23d2009-03-31 13:27:11 -0400316
317 /*
318 * we have no more ordered extents for this inode and
319 * no dirty pages. We can safely remove it from the
320 * list of ordered extents
321 */
322 if (RB_EMPTY_ROOT(&tree->tree) &&
323 !mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) {
324 list_del_init(&BTRFS_I(inode)->ordered_operations);
325 }
Josef Bacik287a0ab2010-03-19 18:07:23 +0000326 spin_unlock(&root->fs_info->ordered_extent_lock);
Chris Mason3eaa2882008-07-24 11:57:52 -0400327
Yan, Zhengc2167752009-11-12 09:34:21 +0000328 return 0;
329}
330
331/*
332 * remove an ordered extent from the tree. No references are dropped
333 * but any waiters are woken.
334 */
335int btrfs_remove_ordered_extent(struct inode *inode,
336 struct btrfs_ordered_extent *entry)
337{
338 struct btrfs_ordered_inode_tree *tree;
339 int ret;
340
341 tree = &BTRFS_I(inode)->ordered_tree;
Josef Bacik49958fd2010-02-02 21:48:28 +0000342 spin_lock(&tree->lock);
Yan, Zhengc2167752009-11-12 09:34:21 +0000343 ret = __btrfs_remove_ordered_extent(inode, entry);
Josef Bacik49958fd2010-02-02 21:48:28 +0000344 spin_unlock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400345 wake_up(&entry->wait);
Yan, Zhengc2167752009-11-12 09:34:21 +0000346
347 return ret;
Chris Mason81d7ed22008-04-25 08:51:48 -0400348}
Chris Masone6dcd2d2008-07-17 12:53:50 -0400349
Chris Masond352ac62008-09-29 15:18:18 -0400350/*
351 * wait for all the ordered extents in a root. This is done when balancing
352 * space between drives.
353 */
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000354int btrfs_wait_ordered_extents(struct btrfs_root *root,
355 int nocow_only, int delay_iput)
Chris Mason3eaa2882008-07-24 11:57:52 -0400356{
357 struct list_head splice;
358 struct list_head *cur;
359 struct btrfs_ordered_extent *ordered;
360 struct inode *inode;
361
362 INIT_LIST_HEAD(&splice);
363
364 spin_lock(&root->fs_info->ordered_extent_lock);
365 list_splice_init(&root->fs_info->ordered_extents, &splice);
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400366 while (!list_empty(&splice)) {
Chris Mason3eaa2882008-07-24 11:57:52 -0400367 cur = splice.next;
368 ordered = list_entry(cur, struct btrfs_ordered_extent,
369 root_extent_list);
Yan Zheng7ea394f2008-08-05 13:05:02 -0400370 if (nocow_only &&
Yan Zhengd899e052008-10-30 14:25:28 -0400371 !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags) &&
372 !test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) {
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400373 list_move(&ordered->root_extent_list,
374 &root->fs_info->ordered_extents);
Yan Zheng7ea394f2008-08-05 13:05:02 -0400375 cond_resched_lock(&root->fs_info->ordered_extent_lock);
376 continue;
377 }
378
Chris Mason3eaa2882008-07-24 11:57:52 -0400379 list_del_init(&ordered->root_extent_list);
380 atomic_inc(&ordered->refs);
Chris Mason3eaa2882008-07-24 11:57:52 -0400381
382 /*
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400383 * the inode may be getting freed (in sys_unlink path).
Chris Mason3eaa2882008-07-24 11:57:52 -0400384 */
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400385 inode = igrab(ordered->inode);
386
Chris Mason3eaa2882008-07-24 11:57:52 -0400387 spin_unlock(&root->fs_info->ordered_extent_lock);
388
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400389 if (inode) {
390 btrfs_start_ordered_extent(inode, ordered, 1);
391 btrfs_put_ordered_extent(ordered);
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000392 if (delay_iput)
393 btrfs_add_delayed_iput(inode);
394 else
395 iput(inode);
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400396 } else {
397 btrfs_put_ordered_extent(ordered);
398 }
Chris Mason3eaa2882008-07-24 11:57:52 -0400399
400 spin_lock(&root->fs_info->ordered_extent_lock);
401 }
402 spin_unlock(&root->fs_info->ordered_extent_lock);
403 return 0;
404}
405
Chris Masoneb84ae02008-07-17 13:53:27 -0400406/*
Chris Mason5a3f23d2009-03-31 13:27:11 -0400407 * this is used during transaction commit to write all the inodes
408 * added to the ordered operation list. These files must be fully on
409 * disk before the transaction commits.
410 *
411 * we have two modes here, one is to just start the IO via filemap_flush
412 * and the other is to wait for all the io. When we wait, we have an
413 * extra check to make sure the ordered operation list really is empty
414 * before we return
415 */
416int btrfs_run_ordered_operations(struct btrfs_root *root, int wait)
417{
418 struct btrfs_inode *btrfs_inode;
419 struct inode *inode;
420 struct list_head splice;
421
422 INIT_LIST_HEAD(&splice);
423
424 mutex_lock(&root->fs_info->ordered_operations_mutex);
425 spin_lock(&root->fs_info->ordered_extent_lock);
426again:
427 list_splice_init(&root->fs_info->ordered_operations, &splice);
428
429 while (!list_empty(&splice)) {
430 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
431 ordered_operations);
432
433 inode = &btrfs_inode->vfs_inode;
434
435 list_del_init(&btrfs_inode->ordered_operations);
436
437 /*
438 * the inode may be getting freed (in sys_unlink path).
439 */
440 inode = igrab(inode);
441
442 if (!wait && inode) {
443 list_add_tail(&BTRFS_I(inode)->ordered_operations,
444 &root->fs_info->ordered_operations);
445 }
446 spin_unlock(&root->fs_info->ordered_extent_lock);
447
448 if (inode) {
449 if (wait)
450 btrfs_wait_ordered_range(inode, 0, (u64)-1);
451 else
452 filemap_flush(inode->i_mapping);
Yan, Zheng24bbcf02009-11-12 09:36:34 +0000453 btrfs_add_delayed_iput(inode);
Chris Mason5a3f23d2009-03-31 13:27:11 -0400454 }
455
456 cond_resched();
457 spin_lock(&root->fs_info->ordered_extent_lock);
458 }
459 if (wait && !list_empty(&root->fs_info->ordered_operations))
460 goto again;
461
462 spin_unlock(&root->fs_info->ordered_extent_lock);
463 mutex_unlock(&root->fs_info->ordered_operations_mutex);
464
465 return 0;
466}
467
468/*
Chris Masoneb84ae02008-07-17 13:53:27 -0400469 * Used to start IO or wait for a given ordered extent to finish.
470 *
471 * If wait is one, this effectively waits on page writeback for all the pages
472 * in the extent, and it waits on the io completion code to insert
473 * metadata into the btree corresponding to the extent
474 */
475void btrfs_start_ordered_extent(struct inode *inode,
476 struct btrfs_ordered_extent *entry,
477 int wait)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400478{
479 u64 start = entry->file_offset;
480 u64 end = start + entry->len - 1;
481
Chris Masoneb84ae02008-07-17 13:53:27 -0400482 /*
483 * pages in the range can be dirty, clean or writeback. We
484 * start IO on any dirty ones so the wait doesn't stall waiting
485 * for pdflush to find them
486 */
Christoph Hellwig8aa38c32009-10-01 12:58:30 -0400487 filemap_fdatawrite_range(inode->i_mapping, start, end);
Chris Masonc8b97812008-10-29 14:49:59 -0400488 if (wait) {
Chris Masone6dcd2d2008-07-17 12:53:50 -0400489 wait_event(entry->wait, test_bit(BTRFS_ORDERED_COMPLETE,
490 &entry->flags));
Chris Masonc8b97812008-10-29 14:49:59 -0400491 }
Chris Masone6dcd2d2008-07-17 12:53:50 -0400492}
493
Chris Masoneb84ae02008-07-17 13:53:27 -0400494/*
495 * Used to wait on ordered extents across a large range of bytes.
496 */
Chris Masoncb843a62008-10-03 12:30:02 -0400497int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400498{
499 u64 end;
Chris Masone5a22172008-07-18 20:42:20 -0400500 u64 orig_end;
501 u64 wait_end;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400502 struct btrfs_ordered_extent *ordered;
Chris Mason8b62b722009-09-02 16:53:46 -0400503 int found;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400504
Chris Masone5a22172008-07-18 20:42:20 -0400505 if (start + len < start) {
Chris Masonf4219502008-07-22 11:18:09 -0400506 orig_end = INT_LIMIT(loff_t);
Chris Masone5a22172008-07-18 20:42:20 -0400507 } else {
508 orig_end = start + len - 1;
Chris Masonf4219502008-07-22 11:18:09 -0400509 if (orig_end > INT_LIMIT(loff_t))
510 orig_end = INT_LIMIT(loff_t);
Chris Masone5a22172008-07-18 20:42:20 -0400511 }
Chris Masonf4219502008-07-22 11:18:09 -0400512 wait_end = orig_end;
Chris Mason4a096752008-07-21 10:29:44 -0400513again:
Chris Masone5a22172008-07-18 20:42:20 -0400514 /* start IO across the range first to instantiate any delalloc
515 * extents
516 */
Christoph Hellwig8aa38c32009-10-01 12:58:30 -0400517 filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
Chris Masone5a22172008-07-18 20:42:20 -0400518
Chris Mason771ed682008-11-06 22:02:51 -0500519 /* The compression code will leave pages locked but return from
520 * writepage without setting the page writeback. Starting again
521 * with WB_SYNC_ALL will end up waiting for the IO to actually start.
522 */
Christoph Hellwig8aa38c32009-10-01 12:58:30 -0400523 filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
Chris Mason771ed682008-11-06 22:02:51 -0500524
Christoph Hellwig8aa38c32009-10-01 12:58:30 -0400525 filemap_fdatawait_range(inode->i_mapping, start, orig_end);
Chris Masonf4219502008-07-22 11:18:09 -0400526
527 end = orig_end;
Chris Mason8b62b722009-09-02 16:53:46 -0400528 found = 0;
Chris Masond3977122009-01-05 21:25:51 -0500529 while (1) {
Chris Masone6dcd2d2008-07-17 12:53:50 -0400530 ordered = btrfs_lookup_first_ordered_extent(inode, end);
Chris Masond3977122009-01-05 21:25:51 -0500531 if (!ordered)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400532 break;
Chris Masone5a22172008-07-18 20:42:20 -0400533 if (ordered->file_offset > orig_end) {
Chris Masone6dcd2d2008-07-17 12:53:50 -0400534 btrfs_put_ordered_extent(ordered);
535 break;
536 }
537 if (ordered->file_offset + ordered->len < start) {
538 btrfs_put_ordered_extent(ordered);
539 break;
540 }
Chris Mason8b62b722009-09-02 16:53:46 -0400541 found++;
Chris Masone5a22172008-07-18 20:42:20 -0400542 btrfs_start_ordered_extent(inode, ordered, 1);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400543 end = ordered->file_offset;
544 btrfs_put_ordered_extent(ordered);
Chris Masone5a22172008-07-18 20:42:20 -0400545 if (end == 0 || end == start)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400546 break;
547 end--;
548 }
Chris Mason8b62b722009-09-02 16:53:46 -0400549 if (found || test_range_bit(&BTRFS_I(inode)->io_tree, start, orig_end,
550 EXTENT_DELALLOC, 0, NULL)) {
Chris Mason771ed682008-11-06 22:02:51 -0500551 schedule_timeout(1);
Chris Mason4a096752008-07-21 10:29:44 -0400552 goto again;
553 }
Chris Masoncb843a62008-10-03 12:30:02 -0400554 return 0;
Chris Masone6dcd2d2008-07-17 12:53:50 -0400555}
556
Chris Masoneb84ae02008-07-17 13:53:27 -0400557/*
558 * find an ordered extent corresponding to file_offset. return NULL if
559 * nothing is found, otherwise take a reference on the extent and return it
560 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400561struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
562 u64 file_offset)
563{
564 struct btrfs_ordered_inode_tree *tree;
565 struct rb_node *node;
566 struct btrfs_ordered_extent *entry = NULL;
567
568 tree = &BTRFS_I(inode)->ordered_tree;
Josef Bacik49958fd2010-02-02 21:48:28 +0000569 spin_lock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400570 node = tree_search(tree, file_offset);
571 if (!node)
572 goto out;
573
574 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
575 if (!offset_in_entry(entry, file_offset))
576 entry = NULL;
577 if (entry)
578 atomic_inc(&entry->refs);
579out:
Josef Bacik49958fd2010-02-02 21:48:28 +0000580 spin_unlock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400581 return entry;
582}
583
Chris Masoneb84ae02008-07-17 13:53:27 -0400584/*
585 * lookup and return any extent before 'file_offset'. NULL is returned
586 * if none is found
587 */
Chris Masone6dcd2d2008-07-17 12:53:50 -0400588struct btrfs_ordered_extent *
Chris Masond3977122009-01-05 21:25:51 -0500589btrfs_lookup_first_ordered_extent(struct inode *inode, u64 file_offset)
Chris Masone6dcd2d2008-07-17 12:53:50 -0400590{
591 struct btrfs_ordered_inode_tree *tree;
592 struct rb_node *node;
593 struct btrfs_ordered_extent *entry = NULL;
594
595 tree = &BTRFS_I(inode)->ordered_tree;
Josef Bacik49958fd2010-02-02 21:48:28 +0000596 spin_lock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400597 node = tree_search(tree, file_offset);
598 if (!node)
599 goto out;
600
601 entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
602 atomic_inc(&entry->refs);
603out:
Josef Bacik49958fd2010-02-02 21:48:28 +0000604 spin_unlock(&tree->lock);
Chris Masone6dcd2d2008-07-17 12:53:50 -0400605 return entry;
606}
Chris Masondbe674a2008-07-17 12:54:05 -0400607
Chris Masoneb84ae02008-07-17 13:53:27 -0400608/*
609 * After an extent is done, call this to conditionally update the on disk
610 * i_size. i_size is updated to cover any fully written part of the file.
611 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000612int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
Chris Masondbe674a2008-07-17 12:54:05 -0400613 struct btrfs_ordered_extent *ordered)
614{
615 struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
616 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
617 u64 disk_i_size;
618 u64 new_i_size;
619 u64 i_size_test;
Yan, Zhengc2167752009-11-12 09:34:21 +0000620 u64 i_size = i_size_read(inode);
Chris Masondbe674a2008-07-17 12:54:05 -0400621 struct rb_node *node;
Yan, Zhengc2167752009-11-12 09:34:21 +0000622 struct rb_node *prev = NULL;
Chris Masondbe674a2008-07-17 12:54:05 -0400623 struct btrfs_ordered_extent *test;
Yan, Zhengc2167752009-11-12 09:34:21 +0000624 int ret = 1;
625
626 if (ordered)
627 offset = entry_end(ordered);
Yan, Zhenga038fab02009-12-28 05:01:58 +0000628 else
629 offset = ALIGN(offset, BTRFS_I(inode)->root->sectorsize);
Chris Masondbe674a2008-07-17 12:54:05 -0400630
Josef Bacik49958fd2010-02-02 21:48:28 +0000631 spin_lock(&tree->lock);
Chris Masondbe674a2008-07-17 12:54:05 -0400632 disk_i_size = BTRFS_I(inode)->disk_i_size;
633
Yan, Zhengc2167752009-11-12 09:34:21 +0000634 /* truncate file */
635 if (disk_i_size > i_size) {
636 BTRFS_I(inode)->disk_i_size = i_size;
637 ret = 0;
638 goto out;
639 }
640
Chris Masondbe674a2008-07-17 12:54:05 -0400641 /*
642 * if the disk i_size is already at the inode->i_size, or
643 * this ordered extent is inside the disk i_size, we're done
644 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000645 if (disk_i_size == i_size || offset <= disk_i_size) {
Chris Masondbe674a2008-07-17 12:54:05 -0400646 goto out;
647 }
648
649 /*
650 * we can't update the disk_isize if there are delalloc bytes
651 * between disk_i_size and this ordered extent
652 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000653 if (test_range_bit(io_tree, disk_i_size, offset - 1,
Chris Mason9655d292009-09-02 15:22:30 -0400654 EXTENT_DELALLOC, 0, NULL)) {
Chris Masondbe674a2008-07-17 12:54:05 -0400655 goto out;
656 }
657 /*
658 * walk backward from this ordered extent to disk_i_size.
659 * if we find an ordered extent then we can't update disk i_size
660 * yet
661 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000662 if (ordered) {
663 node = rb_prev(&ordered->rb_node);
664 } else {
665 prev = tree_search(tree, offset);
666 /*
667 * we insert file extents without involving ordered struct,
668 * so there should be no ordered struct cover this offset
669 */
670 if (prev) {
671 test = rb_entry(prev, struct btrfs_ordered_extent,
672 rb_node);
673 BUG_ON(offset_in_entry(test, offset));
674 }
675 node = prev;
676 }
677 while (node) {
Chris Masondbe674a2008-07-17 12:54:05 -0400678 test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
679 if (test->file_offset + test->len <= disk_i_size)
680 break;
Yan, Zhengc2167752009-11-12 09:34:21 +0000681 if (test->file_offset >= i_size)
Chris Masondbe674a2008-07-17 12:54:05 -0400682 break;
683 if (test->file_offset >= disk_i_size)
684 goto out;
Yan, Zhengc2167752009-11-12 09:34:21 +0000685 node = rb_prev(node);
Chris Masondbe674a2008-07-17 12:54:05 -0400686 }
Yan, Zhengc2167752009-11-12 09:34:21 +0000687 new_i_size = min_t(u64, offset, i_size);
Chris Masondbe674a2008-07-17 12:54:05 -0400688
689 /*
690 * at this point, we know we can safely update i_size to at least
691 * the offset from this ordered extent. But, we need to
692 * walk forward and see if ios from higher up in the file have
693 * finished.
694 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000695 if (ordered) {
696 node = rb_next(&ordered->rb_node);
697 } else {
698 if (prev)
699 node = rb_next(prev);
700 else
701 node = rb_first(&tree->tree);
702 }
Chris Masondbe674a2008-07-17 12:54:05 -0400703 i_size_test = 0;
704 if (node) {
705 /*
706 * do we have an area where IO might have finished
707 * between our ordered extent and the next one.
708 */
709 test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
Yan, Zhengc2167752009-11-12 09:34:21 +0000710 if (test->file_offset > offset)
Yan Zhengb48652c2008-08-04 23:23:47 -0400711 i_size_test = test->file_offset;
Chris Masondbe674a2008-07-17 12:54:05 -0400712 } else {
Yan, Zhengc2167752009-11-12 09:34:21 +0000713 i_size_test = i_size;
Chris Masondbe674a2008-07-17 12:54:05 -0400714 }
715
716 /*
717 * i_size_test is the end of a region after this ordered
718 * extent where there are no ordered extents. As long as there
719 * are no delalloc bytes in this area, it is safe to update
720 * disk_i_size to the end of the region.
721 */
Yan, Zhengc2167752009-11-12 09:34:21 +0000722 if (i_size_test > offset &&
723 !test_range_bit(io_tree, offset, i_size_test - 1,
724 EXTENT_DELALLOC, 0, NULL)) {
725 new_i_size = min_t(u64, i_size_test, i_size);
Chris Masondbe674a2008-07-17 12:54:05 -0400726 }
727 BTRFS_I(inode)->disk_i_size = new_i_size;
Yan, Zhengc2167752009-11-12 09:34:21 +0000728 ret = 0;
Chris Masondbe674a2008-07-17 12:54:05 -0400729out:
Yan, Zhengc2167752009-11-12 09:34:21 +0000730 /*
731 * we need to remove the ordered extent with the tree lock held
732 * so that other people calling this function don't find our fully
733 * processed ordered entry and skip updating the i_size
734 */
735 if (ordered)
736 __btrfs_remove_ordered_extent(inode, ordered);
Josef Bacik49958fd2010-02-02 21:48:28 +0000737 spin_unlock(&tree->lock);
Yan, Zhengc2167752009-11-12 09:34:21 +0000738 if (ordered)
739 wake_up(&ordered->wait);
740 return ret;
Chris Masondbe674a2008-07-17 12:54:05 -0400741}
Chris Masonba1da2f2008-07-17 12:54:15 -0400742
Chris Masoneb84ae02008-07-17 13:53:27 -0400743/*
744 * search the ordered extents for one corresponding to 'offset' and
745 * try to find a checksum. This is used because we allow pages to
746 * be reclaimed before their checksum is actually put into the btree
747 */
Chris Masond20f7042008-12-08 16:58:54 -0500748int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,
749 u32 *sum)
Chris Masonba1da2f2008-07-17 12:54:15 -0400750{
751 struct btrfs_ordered_sum *ordered_sum;
752 struct btrfs_sector_sum *sector_sums;
753 struct btrfs_ordered_extent *ordered;
754 struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
Chris Mason3edf7d32008-07-18 06:17:13 -0400755 unsigned long num_sectors;
756 unsigned long i;
757 u32 sectorsize = BTRFS_I(inode)->root->sectorsize;
Chris Masonba1da2f2008-07-17 12:54:15 -0400758 int ret = 1;
Chris Masonba1da2f2008-07-17 12:54:15 -0400759
760 ordered = btrfs_lookup_ordered_extent(inode, offset);
761 if (!ordered)
762 return 1;
763
Josef Bacik49958fd2010-02-02 21:48:28 +0000764 spin_lock(&tree->lock);
Qinghuang Fengc6e30872009-01-21 10:59:08 -0500765 list_for_each_entry_reverse(ordered_sum, &ordered->list, list) {
Chris Masond20f7042008-12-08 16:58:54 -0500766 if (disk_bytenr >= ordered_sum->bytenr) {
Chris Mason3edf7d32008-07-18 06:17:13 -0400767 num_sectors = ordered_sum->len / sectorsize;
Chris Masoned98b562008-07-22 23:06:42 -0400768 sector_sums = ordered_sum->sums;
Chris Mason3edf7d32008-07-18 06:17:13 -0400769 for (i = 0; i < num_sectors; i++) {
Chris Masond20f7042008-12-08 16:58:54 -0500770 if (sector_sums[i].bytenr == disk_bytenr) {
Chris Mason3edf7d32008-07-18 06:17:13 -0400771 *sum = sector_sums[i].sum;
772 ret = 0;
773 goto out;
774 }
775 }
Chris Masonba1da2f2008-07-17 12:54:15 -0400776 }
777 }
778out:
Josef Bacik49958fd2010-02-02 21:48:28 +0000779 spin_unlock(&tree->lock);
Chris Mason89642222008-07-24 09:41:53 -0400780 btrfs_put_ordered_extent(ordered);
Chris Masonba1da2f2008-07-17 12:54:15 -0400781 return ret;
782}
783
Chris Masonf4219502008-07-22 11:18:09 -0400784
Chris Mason5a3f23d2009-03-31 13:27:11 -0400785/*
786 * add a given inode to the list of inodes that must be fully on
787 * disk before a transaction commit finishes.
788 *
789 * This basically gives us the ext3 style data=ordered mode, and it is mostly
790 * used to make sure renamed files are fully on disk.
791 *
792 * It is a noop if the inode is already fully on disk.
793 *
794 * If trans is not null, we'll do a friendly check for a transaction that
795 * is already flushing things and force the IO down ourselves.
796 */
797int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
798 struct btrfs_root *root,
799 struct inode *inode)
800{
801 u64 last_mod;
802
803 last_mod = max(BTRFS_I(inode)->generation, BTRFS_I(inode)->last_trans);
804
805 /*
806 * if this file hasn't been changed since the last transaction
807 * commit, we can safely return without doing anything
808 */
809 if (last_mod < root->fs_info->last_trans_committed)
810 return 0;
811
812 /*
813 * the transaction is already committing. Just start the IO and
814 * don't bother with all of this list nonsense
815 */
816 if (trans && root->fs_info->running_transaction->blocked) {
817 btrfs_wait_ordered_range(inode, 0, (u64)-1);
818 return 0;
819 }
820
821 spin_lock(&root->fs_info->ordered_extent_lock);
822 if (list_empty(&BTRFS_I(inode)->ordered_operations)) {
823 list_add_tail(&BTRFS_I(inode)->ordered_operations,
824 &root->fs_info->ordered_operations);
825 }
826 spin_unlock(&root->fs_info->ordered_extent_lock);
827
828 return 0;
829}