blob: f9b0fc911661ad2f5e6d7f67a7d2bc05329bd4fb [file] [log] [blame]
Chris Masone02119d2008-09-05 16:13:11 -04001/*
2 * Copyright (C) 2008 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
19#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Josef Bacik5dc562c2012-08-17 13:14:17 -040021#include <linux/list_sort.h>
Chris Masone02119d2008-09-05 16:13:11 -040022#include "ctree.h"
23#include "transaction.h"
24#include "disk-io.h"
25#include "locking.h"
26#include "print-tree.h"
27#include "compat.h"
Christoph Hellwigb2950862008-12-02 09:54:17 -050028#include "tree-log.h"
Chris Masone02119d2008-09-05 16:13:11 -040029
30/* magic values for the inode_only field in btrfs_log_inode:
31 *
32 * LOG_INODE_ALL means to log everything
33 * LOG_INODE_EXISTS means to log just enough to recreate the inode
34 * during log replay
35 */
36#define LOG_INODE_ALL 0
37#define LOG_INODE_EXISTS 1
38
39/*
Chris Mason12fcfd22009-03-24 10:24:20 -040040 * directory trouble cases
41 *
42 * 1) on rename or unlink, if the inode being unlinked isn't in the fsync
43 * log, we must force a full commit before doing an fsync of the directory
44 * where the unlink was done.
45 * ---> record transid of last unlink/rename per directory
46 *
47 * mkdir foo/some_dir
48 * normal commit
49 * rename foo/some_dir foo2/some_dir
50 * mkdir foo/some_dir
51 * fsync foo/some_dir/some_file
52 *
53 * The fsync above will unlink the original some_dir without recording
54 * it in its new location (foo2). After a crash, some_dir will be gone
55 * unless the fsync of some_file forces a full commit
56 *
57 * 2) we must log any new names for any file or dir that is in the fsync
58 * log. ---> check inode while renaming/linking.
59 *
60 * 2a) we must log any new names for any file or dir during rename
61 * when the directory they are being removed from was logged.
62 * ---> check inode and old parent dir during rename
63 *
64 * 2a is actually the more important variant. With the extra logging
65 * a crash might unlink the old name without recreating the new one
66 *
67 * 3) after a crash, we must go through any directories with a link count
68 * of zero and redo the rm -rf
69 *
70 * mkdir f1/foo
71 * normal commit
72 * rm -rf f1/foo
73 * fsync(f1)
74 *
75 * The directory f1 was fully removed from the FS, but fsync was never
76 * called on f1, only its parent dir. After a crash the rm -rf must
77 * be replayed. This must be able to recurse down the entire
78 * directory tree. The inode link count fixup code takes care of the
79 * ugly details.
80 */
81
82/*
Chris Masone02119d2008-09-05 16:13:11 -040083 * stages for the tree walking. The first
84 * stage (0) is to only pin down the blocks we find
85 * the second stage (1) is to make sure that all the inodes
86 * we find in the log are created in the subvolume.
87 *
88 * The last stage is to deal with directories and links and extents
89 * and all the other fun semantics
90 */
91#define LOG_WALK_PIN_ONLY 0
92#define LOG_WALK_REPLAY_INODES 1
93#define LOG_WALK_REPLAY_ALL 2
94
Chris Mason12fcfd22009-03-24 10:24:20 -040095static int btrfs_log_inode(struct btrfs_trans_handle *trans,
Chris Masone02119d2008-09-05 16:13:11 -040096 struct btrfs_root *root, struct inode *inode,
97 int inode_only);
Yan Zhengec051c02009-01-05 15:43:42 -050098static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
99 struct btrfs_root *root,
100 struct btrfs_path *path, u64 objectid);
Chris Mason12fcfd22009-03-24 10:24:20 -0400101static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
102 struct btrfs_root *root,
103 struct btrfs_root *log,
104 struct btrfs_path *path,
105 u64 dirid, int del_all);
Chris Masone02119d2008-09-05 16:13:11 -0400106
107/*
108 * tree logging is a special write ahead log used to make sure that
109 * fsyncs and O_SYNCs can happen without doing full tree commits.
110 *
111 * Full tree commits are expensive because they require commonly
112 * modified blocks to be recowed, creating many dirty pages in the
113 * extent tree an 4x-6x higher write load than ext3.
114 *
115 * Instead of doing a tree commit on every fsync, we use the
116 * key ranges and transaction ids to find items for a given file or directory
117 * that have changed in this transaction. Those items are copied into
118 * a special tree (one per subvolume root), that tree is written to disk
119 * and then the fsync is considered complete.
120 *
121 * After a crash, items are copied out of the log-tree back into the
122 * subvolume tree. Any file data extents found are recorded in the extent
123 * allocation tree, and the log-tree freed.
124 *
125 * The log tree is read three times, once to pin down all the extents it is
126 * using in ram and once, once to create all the inodes logged in the tree
127 * and once to do all the other items.
128 */
129
130/*
Chris Masone02119d2008-09-05 16:13:11 -0400131 * start a sub transaction and setup the log tree
132 * this increments the log tree writer count to make the people
133 * syncing the tree wait for us to finish
134 */
135static int start_log_trans(struct btrfs_trans_handle *trans,
136 struct btrfs_root *root)
137{
138 int ret;
Yan, Zheng4a500fd2010-05-16 10:49:59 -0400139 int err = 0;
Yan Zheng7237f182009-01-21 12:54:03 -0500140
141 mutex_lock(&root->log_mutex);
142 if (root->log_root) {
Josef Bacikff782e02009-10-08 15:30:04 -0400143 if (!root->log_start_pid) {
144 root->log_start_pid = current->pid;
145 root->log_multiple_pids = false;
146 } else if (root->log_start_pid != current->pid) {
147 root->log_multiple_pids = true;
148 }
149
Yan Zheng7237f182009-01-21 12:54:03 -0500150 root->log_batch++;
151 atomic_inc(&root->log_writers);
152 mutex_unlock(&root->log_mutex);
153 return 0;
154 }
Josef Bacikff782e02009-10-08 15:30:04 -0400155 root->log_multiple_pids = false;
156 root->log_start_pid = current->pid;
Chris Masone02119d2008-09-05 16:13:11 -0400157 mutex_lock(&root->fs_info->tree_log_mutex);
158 if (!root->fs_info->log_root_tree) {
159 ret = btrfs_init_log_root_tree(trans, root->fs_info);
Yan, Zheng4a500fd2010-05-16 10:49:59 -0400160 if (ret)
161 err = ret;
Chris Masone02119d2008-09-05 16:13:11 -0400162 }
Yan, Zheng4a500fd2010-05-16 10:49:59 -0400163 if (err == 0 && !root->log_root) {
Chris Masone02119d2008-09-05 16:13:11 -0400164 ret = btrfs_add_log_tree(trans, root);
Yan, Zheng4a500fd2010-05-16 10:49:59 -0400165 if (ret)
166 err = ret;
Chris Masone02119d2008-09-05 16:13:11 -0400167 }
Chris Masone02119d2008-09-05 16:13:11 -0400168 mutex_unlock(&root->fs_info->tree_log_mutex);
Yan Zheng7237f182009-01-21 12:54:03 -0500169 root->log_batch++;
170 atomic_inc(&root->log_writers);
171 mutex_unlock(&root->log_mutex);
Yan, Zheng4a500fd2010-05-16 10:49:59 -0400172 return err;
Chris Masone02119d2008-09-05 16:13:11 -0400173}
174
175/*
176 * returns 0 if there was a log transaction running and we were able
177 * to join, or returns -ENOENT if there were not transactions
178 * in progress
179 */
180static int join_running_log_trans(struct btrfs_root *root)
181{
182 int ret = -ENOENT;
183
184 smp_mb();
185 if (!root->log_root)
186 return -ENOENT;
187
Yan Zheng7237f182009-01-21 12:54:03 -0500188 mutex_lock(&root->log_mutex);
Chris Masone02119d2008-09-05 16:13:11 -0400189 if (root->log_root) {
190 ret = 0;
Yan Zheng7237f182009-01-21 12:54:03 -0500191 atomic_inc(&root->log_writers);
Chris Masone02119d2008-09-05 16:13:11 -0400192 }
Yan Zheng7237f182009-01-21 12:54:03 -0500193 mutex_unlock(&root->log_mutex);
Chris Masone02119d2008-09-05 16:13:11 -0400194 return ret;
195}
196
197/*
Chris Mason12fcfd22009-03-24 10:24:20 -0400198 * This either makes the current running log transaction wait
199 * until you call btrfs_end_log_trans() or it makes any future
200 * log transactions wait until you call btrfs_end_log_trans()
201 */
202int btrfs_pin_log_trans(struct btrfs_root *root)
203{
204 int ret = -ENOENT;
205
206 mutex_lock(&root->log_mutex);
207 atomic_inc(&root->log_writers);
208 mutex_unlock(&root->log_mutex);
209 return ret;
210}
211
212/*
Chris Masone02119d2008-09-05 16:13:11 -0400213 * indicate we're done making changes to the log tree
214 * and wake up anyone waiting to do a sync
215 */
Jeff Mahoney143bede2012-03-01 14:56:26 +0100216void btrfs_end_log_trans(struct btrfs_root *root)
Chris Masone02119d2008-09-05 16:13:11 -0400217{
Yan Zheng7237f182009-01-21 12:54:03 -0500218 if (atomic_dec_and_test(&root->log_writers)) {
219 smp_mb();
220 if (waitqueue_active(&root->log_writer_wait))
221 wake_up(&root->log_writer_wait);
222 }
Chris Masone02119d2008-09-05 16:13:11 -0400223}
224
225
226/*
227 * the walk control struct is used to pass state down the chain when
228 * processing the log tree. The stage field tells us which part
229 * of the log tree processing we are currently doing. The others
230 * are state fields used for that specific part
231 */
232struct walk_control {
233 /* should we free the extent on disk when done? This is used
234 * at transaction commit time while freeing a log tree
235 */
236 int free;
237
238 /* should we write out the extent buffer? This is used
239 * while flushing the log tree to disk during a sync
240 */
241 int write;
242
243 /* should we wait for the extent buffer io to finish? Also used
244 * while flushing the log tree to disk for a sync
245 */
246 int wait;
247
248 /* pin only walk, we record which extents on disk belong to the
249 * log trees
250 */
251 int pin;
252
253 /* what stage of the replay code we're currently in */
254 int stage;
255
256 /* the root we are currently replaying */
257 struct btrfs_root *replay_dest;
258
259 /* the trans handle for the current replay */
260 struct btrfs_trans_handle *trans;
261
262 /* the function that gets used to process blocks we find in the
263 * tree. Note the extent_buffer might not be up to date when it is
264 * passed in, and it must be checked or read if you need the data
265 * inside it
266 */
267 int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
268 struct walk_control *wc, u64 gen);
269};
270
271/*
272 * process_func used to pin down extents, write them or wait on them
273 */
274static int process_one_buffer(struct btrfs_root *log,
275 struct extent_buffer *eb,
276 struct walk_control *wc, u64 gen)
277{
Josef Bacik04018de2009-04-03 10:14:18 -0400278 if (wc->pin)
Chris Masone688b7252011-10-31 20:52:39 -0400279 btrfs_pin_extent_for_log_replay(wc->trans,
280 log->fs_info->extent_root,
281 eb->start, eb->len);
Chris Masone02119d2008-09-05 16:13:11 -0400282
Chris Masonb9fab912012-05-06 07:23:47 -0400283 if (btrfs_buffer_uptodate(eb, gen, 0)) {
Chris Masone02119d2008-09-05 16:13:11 -0400284 if (wc->write)
285 btrfs_write_tree_block(eb);
286 if (wc->wait)
287 btrfs_wait_tree_block_writeback(eb);
288 }
289 return 0;
290}
291
292/*
293 * Item overwrite used by replay and tree logging. eb, slot and key all refer
294 * to the src data we are copying out.
295 *
296 * root is the tree we are copying into, and path is a scratch
297 * path for use in this function (it should be released on entry and
298 * will be released on exit).
299 *
300 * If the key is already in the destination tree the existing item is
301 * overwritten. If the existing item isn't big enough, it is extended.
302 * If it is too large, it is truncated.
303 *
304 * If the key isn't in the destination yet, a new item is inserted.
305 */
306static noinline int overwrite_item(struct btrfs_trans_handle *trans,
307 struct btrfs_root *root,
308 struct btrfs_path *path,
309 struct extent_buffer *eb, int slot,
310 struct btrfs_key *key)
311{
312 int ret;
313 u32 item_size;
314 u64 saved_i_size = 0;
315 int save_old_i_size = 0;
316 unsigned long src_ptr;
317 unsigned long dst_ptr;
318 int overwrite_root = 0;
319
320 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
321 overwrite_root = 1;
322
323 item_size = btrfs_item_size_nr(eb, slot);
324 src_ptr = btrfs_item_ptr_offset(eb, slot);
325
326 /* look for the key in the destination tree */
327 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
328 if (ret == 0) {
329 char *src_copy;
330 char *dst_copy;
331 u32 dst_size = btrfs_item_size_nr(path->nodes[0],
332 path->slots[0]);
333 if (dst_size != item_size)
334 goto insert;
335
336 if (item_size == 0) {
David Sterbab3b4aa72011-04-21 01:20:15 +0200337 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400338 return 0;
339 }
340 dst_copy = kmalloc(item_size, GFP_NOFS);
341 src_copy = kmalloc(item_size, GFP_NOFS);
liubo2a29edc2011-01-26 06:22:08 +0000342 if (!dst_copy || !src_copy) {
David Sterbab3b4aa72011-04-21 01:20:15 +0200343 btrfs_release_path(path);
liubo2a29edc2011-01-26 06:22:08 +0000344 kfree(dst_copy);
345 kfree(src_copy);
346 return -ENOMEM;
347 }
Chris Masone02119d2008-09-05 16:13:11 -0400348
349 read_extent_buffer(eb, src_copy, src_ptr, item_size);
350
351 dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
352 read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
353 item_size);
354 ret = memcmp(dst_copy, src_copy, item_size);
355
356 kfree(dst_copy);
357 kfree(src_copy);
358 /*
359 * they have the same contents, just return, this saves
360 * us from cowing blocks in the destination tree and doing
361 * extra writes that may not have been done by a previous
362 * sync
363 */
364 if (ret == 0) {
David Sterbab3b4aa72011-04-21 01:20:15 +0200365 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400366 return 0;
367 }
368
369 }
370insert:
David Sterbab3b4aa72011-04-21 01:20:15 +0200371 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400372 /* try to insert the key into the destination tree */
373 ret = btrfs_insert_empty_item(trans, root, path,
374 key, item_size);
375
376 /* make sure any existing item is the correct size */
377 if (ret == -EEXIST) {
378 u32 found_size;
379 found_size = btrfs_item_size_nr(path->nodes[0],
380 path->slots[0]);
Jeff Mahoney143bede2012-03-01 14:56:26 +0100381 if (found_size > item_size)
Chris Masone02119d2008-09-05 16:13:11 -0400382 btrfs_truncate_item(trans, root, path, item_size, 1);
Jeff Mahoney143bede2012-03-01 14:56:26 +0100383 else if (found_size < item_size)
384 btrfs_extend_item(trans, root, path,
385 item_size - found_size);
Chris Masone02119d2008-09-05 16:13:11 -0400386 } else if (ret) {
Yan, Zheng4a500fd2010-05-16 10:49:59 -0400387 return ret;
Chris Masone02119d2008-09-05 16:13:11 -0400388 }
389 dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
390 path->slots[0]);
391
392 /* don't overwrite an existing inode if the generation number
393 * was logged as zero. This is done when the tree logging code
394 * is just logging an inode to make sure it exists after recovery.
395 *
396 * Also, don't overwrite i_size on directories during replay.
397 * log replay inserts and removes directory items based on the
398 * state of the tree found in the subvolume, and i_size is modified
399 * as it goes
400 */
401 if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
402 struct btrfs_inode_item *src_item;
403 struct btrfs_inode_item *dst_item;
404
405 src_item = (struct btrfs_inode_item *)src_ptr;
406 dst_item = (struct btrfs_inode_item *)dst_ptr;
407
408 if (btrfs_inode_generation(eb, src_item) == 0)
409 goto no_copy;
410
411 if (overwrite_root &&
412 S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
413 S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
414 save_old_i_size = 1;
415 saved_i_size = btrfs_inode_size(path->nodes[0],
416 dst_item);
417 }
418 }
419
420 copy_extent_buffer(path->nodes[0], eb, dst_ptr,
421 src_ptr, item_size);
422
423 if (save_old_i_size) {
424 struct btrfs_inode_item *dst_item;
425 dst_item = (struct btrfs_inode_item *)dst_ptr;
426 btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
427 }
428
429 /* make sure the generation is filled in */
430 if (key->type == BTRFS_INODE_ITEM_KEY) {
431 struct btrfs_inode_item *dst_item;
432 dst_item = (struct btrfs_inode_item *)dst_ptr;
433 if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
434 btrfs_set_inode_generation(path->nodes[0], dst_item,
435 trans->transid);
436 }
437 }
438no_copy:
439 btrfs_mark_buffer_dirty(path->nodes[0]);
David Sterbab3b4aa72011-04-21 01:20:15 +0200440 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400441 return 0;
442}
443
444/*
445 * simple helper to read an inode off the disk from a given root
446 * This can only be called for subvolume roots and not for the log
447 */
448static noinline struct inode *read_one_inode(struct btrfs_root *root,
449 u64 objectid)
450{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400451 struct btrfs_key key;
Chris Masone02119d2008-09-05 16:13:11 -0400452 struct inode *inode;
Chris Masone02119d2008-09-05 16:13:11 -0400453
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400454 key.objectid = objectid;
455 key.type = BTRFS_INODE_ITEM_KEY;
456 key.offset = 0;
Josef Bacik73f73412009-12-04 17:38:27 +0000457 inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400458 if (IS_ERR(inode)) {
459 inode = NULL;
460 } else if (is_bad_inode(inode)) {
Chris Masone02119d2008-09-05 16:13:11 -0400461 iput(inode);
462 inode = NULL;
463 }
464 return inode;
465}
466
467/* replays a single extent in 'eb' at 'slot' with 'key' into the
468 * subvolume 'root'. path is released on entry and should be released
469 * on exit.
470 *
471 * extents in the log tree have not been allocated out of the extent
472 * tree yet. So, this completes the allocation, taking a reference
473 * as required if the extent already exists or creating a new extent
474 * if it isn't in the extent allocation tree yet.
475 *
476 * The extent is inserted into the file, dropping any existing extents
477 * from the file that overlap the new one.
478 */
479static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
480 struct btrfs_root *root,
481 struct btrfs_path *path,
482 struct extent_buffer *eb, int slot,
483 struct btrfs_key *key)
484{
485 int found_type;
486 u64 mask = root->sectorsize - 1;
487 u64 extent_end;
Chris Masone02119d2008-09-05 16:13:11 -0400488 u64 start = key->offset;
Yan Zheng07d400a2009-01-06 11:42:00 -0500489 u64 saved_nbytes;
Chris Masone02119d2008-09-05 16:13:11 -0400490 struct btrfs_file_extent_item *item;
491 struct inode *inode = NULL;
492 unsigned long size;
493 int ret = 0;
494
495 item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
496 found_type = btrfs_file_extent_type(eb, item);
497
Yan Zhengd899e052008-10-30 14:25:28 -0400498 if (found_type == BTRFS_FILE_EXTENT_REG ||
499 found_type == BTRFS_FILE_EXTENT_PREALLOC)
Chris Masone02119d2008-09-05 16:13:11 -0400500 extent_end = start + btrfs_file_extent_num_bytes(eb, item);
501 else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
Chris Masonc8b97812008-10-29 14:49:59 -0400502 size = btrfs_file_extent_inline_len(eb, item);
Chris Masone02119d2008-09-05 16:13:11 -0400503 extent_end = (start + size + mask) & ~mask;
504 } else {
505 ret = 0;
506 goto out;
507 }
508
509 inode = read_one_inode(root, key->objectid);
510 if (!inode) {
511 ret = -EIO;
512 goto out;
513 }
514
515 /*
516 * first check to see if we already have this extent in the
517 * file. This must be done before the btrfs_drop_extents run
518 * so we don't try to drop this extent.
519 */
Li Zefan33345d012011-04-20 10:31:50 +0800520 ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
Chris Masone02119d2008-09-05 16:13:11 -0400521 start, 0);
522
Yan Zhengd899e052008-10-30 14:25:28 -0400523 if (ret == 0 &&
524 (found_type == BTRFS_FILE_EXTENT_REG ||
525 found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
Chris Masone02119d2008-09-05 16:13:11 -0400526 struct btrfs_file_extent_item cmp1;
527 struct btrfs_file_extent_item cmp2;
528 struct btrfs_file_extent_item *existing;
529 struct extent_buffer *leaf;
530
531 leaf = path->nodes[0];
532 existing = btrfs_item_ptr(leaf, path->slots[0],
533 struct btrfs_file_extent_item);
534
535 read_extent_buffer(eb, &cmp1, (unsigned long)item,
536 sizeof(cmp1));
537 read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
538 sizeof(cmp2));
539
540 /*
541 * we already have a pointer to this exact extent,
542 * we don't have to do anything
543 */
544 if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
David Sterbab3b4aa72011-04-21 01:20:15 +0200545 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400546 goto out;
547 }
548 }
David Sterbab3b4aa72011-04-21 01:20:15 +0200549 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400550
Yan Zheng07d400a2009-01-06 11:42:00 -0500551 saved_nbytes = inode_get_bytes(inode);
Chris Masone02119d2008-09-05 16:13:11 -0400552 /* drop any overlapping extents */
Josef Bacik26714852012-08-29 12:24:27 -0400553 ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
Chris Masone02119d2008-09-05 16:13:11 -0400554 BUG_ON(ret);
555
Yan Zheng07d400a2009-01-06 11:42:00 -0500556 if (found_type == BTRFS_FILE_EXTENT_REG ||
557 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400558 u64 offset;
Yan Zheng07d400a2009-01-06 11:42:00 -0500559 unsigned long dest_offset;
560 struct btrfs_key ins;
Chris Masone02119d2008-09-05 16:13:11 -0400561
Yan Zheng07d400a2009-01-06 11:42:00 -0500562 ret = btrfs_insert_empty_item(trans, root, path, key,
563 sizeof(*item));
564 BUG_ON(ret);
565 dest_offset = btrfs_item_ptr_offset(path->nodes[0],
566 path->slots[0]);
567 copy_extent_buffer(path->nodes[0], eb, dest_offset,
568 (unsigned long)item, sizeof(*item));
569
570 ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
571 ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
572 ins.type = BTRFS_EXTENT_ITEM_KEY;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400573 offset = key->offset - btrfs_file_extent_offset(eb, item);
Yan Zheng07d400a2009-01-06 11:42:00 -0500574
575 if (ins.objectid > 0) {
576 u64 csum_start;
577 u64 csum_end;
578 LIST_HEAD(ordered_sums);
579 /*
580 * is this extent already allocated in the extent
581 * allocation tree? If so, just add a reference
582 */
583 ret = btrfs_lookup_extent(root, ins.objectid,
584 ins.offset);
585 if (ret == 0) {
586 ret = btrfs_inc_extent_ref(trans, root,
587 ins.objectid, ins.offset,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400588 0, root->root_key.objectid,
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200589 key->objectid, offset, 0);
Tsutomu Itoh37daa4f2011-04-28 09:18:21 +0000590 BUG_ON(ret);
Yan Zheng07d400a2009-01-06 11:42:00 -0500591 } else {
592 /*
593 * insert the extent pointer in the extent
594 * allocation tree
595 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400596 ret = btrfs_alloc_logged_file_extent(trans,
597 root, root->root_key.objectid,
598 key->objectid, offset, &ins);
Yan Zheng07d400a2009-01-06 11:42:00 -0500599 BUG_ON(ret);
600 }
David Sterbab3b4aa72011-04-21 01:20:15 +0200601 btrfs_release_path(path);
Yan Zheng07d400a2009-01-06 11:42:00 -0500602
603 if (btrfs_file_extent_compression(eb, item)) {
604 csum_start = ins.objectid;
605 csum_end = csum_start + ins.offset;
606 } else {
607 csum_start = ins.objectid +
608 btrfs_file_extent_offset(eb, item);
609 csum_end = csum_start +
610 btrfs_file_extent_num_bytes(eb, item);
611 }
612
613 ret = btrfs_lookup_csums_range(root->log_root,
614 csum_start, csum_end - 1,
Arne Jansena2de7332011-03-08 14:14:00 +0100615 &ordered_sums, 0);
Yan Zheng07d400a2009-01-06 11:42:00 -0500616 BUG_ON(ret);
617 while (!list_empty(&ordered_sums)) {
618 struct btrfs_ordered_sum *sums;
619 sums = list_entry(ordered_sums.next,
620 struct btrfs_ordered_sum,
621 list);
622 ret = btrfs_csum_file_blocks(trans,
623 root->fs_info->csum_root,
624 sums);
625 BUG_ON(ret);
626 list_del(&sums->list);
627 kfree(sums);
628 }
629 } else {
David Sterbab3b4aa72011-04-21 01:20:15 +0200630 btrfs_release_path(path);
Yan Zheng07d400a2009-01-06 11:42:00 -0500631 }
632 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
633 /* inline extents are easy, we just overwrite them */
634 ret = overwrite_item(trans, root, path, eb, slot, key);
635 BUG_ON(ret);
636 }
637
638 inode_set_bytes(inode, saved_nbytes);
Tsutomu Itohb9959292012-06-25 21:25:22 -0600639 ret = btrfs_update_inode(trans, root, inode);
Chris Masone02119d2008-09-05 16:13:11 -0400640out:
641 if (inode)
642 iput(inode);
643 return ret;
644}
645
646/*
647 * when cleaning up conflicts between the directory names in the
648 * subvolume, directory names in the log and directory names in the
649 * inode back references, we may have to unlink inodes from directories.
650 *
651 * This is a helper function to do the unlink of a specific directory
652 * item
653 */
654static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
655 struct btrfs_root *root,
656 struct btrfs_path *path,
657 struct inode *dir,
658 struct btrfs_dir_item *di)
659{
660 struct inode *inode;
661 char *name;
662 int name_len;
663 struct extent_buffer *leaf;
664 struct btrfs_key location;
665 int ret;
666
667 leaf = path->nodes[0];
668
669 btrfs_dir_item_key_to_cpu(leaf, di, &location);
670 name_len = btrfs_dir_name_len(leaf, di);
671 name = kmalloc(name_len, GFP_NOFS);
liubo2a29edc2011-01-26 06:22:08 +0000672 if (!name)
673 return -ENOMEM;
674
Chris Masone02119d2008-09-05 16:13:11 -0400675 read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
David Sterbab3b4aa72011-04-21 01:20:15 +0200676 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400677
678 inode = read_one_inode(root, location.objectid);
Tsutomu Itohc00e9492011-04-28 09:10:23 +0000679 if (!inode) {
680 kfree(name);
681 return -EIO;
682 }
Chris Masone02119d2008-09-05 16:13:11 -0400683
Yan Zhengec051c02009-01-05 15:43:42 -0500684 ret = link_to_fixup_dir(trans, root, path, location.objectid);
685 BUG_ON(ret);
Chris Mason12fcfd22009-03-24 10:24:20 -0400686
Chris Masone02119d2008-09-05 16:13:11 -0400687 ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
Yan Zhengec051c02009-01-05 15:43:42 -0500688 BUG_ON(ret);
Chris Masone02119d2008-09-05 16:13:11 -0400689 kfree(name);
690
691 iput(inode);
Chris Masonb6305562012-07-02 15:29:53 -0400692
693 btrfs_run_delayed_items(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -0400694 return ret;
695}
696
697/*
698 * helper function to see if a given name and sequence number found
699 * in an inode back reference are already in a directory and correctly
700 * point to this inode
701 */
702static noinline int inode_in_dir(struct btrfs_root *root,
703 struct btrfs_path *path,
704 u64 dirid, u64 objectid, u64 index,
705 const char *name, int name_len)
706{
707 struct btrfs_dir_item *di;
708 struct btrfs_key location;
709 int match = 0;
710
711 di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
712 index, name, name_len, 0);
713 if (di && !IS_ERR(di)) {
714 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
715 if (location.objectid != objectid)
716 goto out;
717 } else
718 goto out;
David Sterbab3b4aa72011-04-21 01:20:15 +0200719 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400720
721 di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
722 if (di && !IS_ERR(di)) {
723 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
724 if (location.objectid != objectid)
725 goto out;
726 } else
727 goto out;
728 match = 1;
729out:
David Sterbab3b4aa72011-04-21 01:20:15 +0200730 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400731 return match;
732}
733
734/*
735 * helper function to check a log tree for a named back reference in
736 * an inode. This is used to decide if a back reference that is
737 * found in the subvolume conflicts with what we find in the log.
738 *
739 * inode backreferences may have multiple refs in a single item,
740 * during replay we process one reference at a time, and we don't
741 * want to delete valid links to a file from the subvolume if that
742 * link is also in the log.
743 */
744static noinline int backref_in_log(struct btrfs_root *log,
745 struct btrfs_key *key,
746 char *name, int namelen)
747{
748 struct btrfs_path *path;
749 struct btrfs_inode_ref *ref;
750 unsigned long ptr;
751 unsigned long ptr_end;
752 unsigned long name_ptr;
753 int found_name_len;
754 int item_size;
755 int ret;
756 int match = 0;
757
758 path = btrfs_alloc_path();
liubo2a29edc2011-01-26 06:22:08 +0000759 if (!path)
760 return -ENOMEM;
761
Chris Masone02119d2008-09-05 16:13:11 -0400762 ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
763 if (ret != 0)
764 goto out;
765
766 item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
767 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
768 ptr_end = ptr + item_size;
769 while (ptr < ptr_end) {
770 ref = (struct btrfs_inode_ref *)ptr;
771 found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
772 if (found_name_len == namelen) {
773 name_ptr = (unsigned long)(ref + 1);
774 ret = memcmp_extent_buffer(path->nodes[0], name,
775 name_ptr, namelen);
776 if (ret == 0) {
777 match = 1;
778 goto out;
779 }
780 }
781 ptr = (unsigned long)(ref + 1) + found_name_len;
782 }
783out:
784 btrfs_free_path(path);
785 return match;
786}
787
788
789/*
790 * replay one inode back reference item found in the log tree.
791 * eb, slot and key refer to the buffer and key found in the log tree.
792 * root is the destination we are replaying into, and path is for temp
793 * use by this function. (it should be released on return).
794 */
795static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
796 struct btrfs_root *root,
797 struct btrfs_root *log,
798 struct btrfs_path *path,
799 struct extent_buffer *eb, int slot,
800 struct btrfs_key *key)
801{
Chris Masone02119d2008-09-05 16:13:11 -0400802 struct btrfs_inode_ref *ref;
liubo34f3e4f2011-08-06 08:35:23 +0000803 struct btrfs_dir_item *di;
804 struct inode *dir;
Chris Masone02119d2008-09-05 16:13:11 -0400805 struct inode *inode;
Chris Masone02119d2008-09-05 16:13:11 -0400806 unsigned long ref_ptr;
807 unsigned long ref_end;
liubo34f3e4f2011-08-06 08:35:23 +0000808 char *name;
809 int namelen;
810 int ret;
liuboc622ae62011-03-26 08:01:12 -0400811 int search_done = 0;
Chris Masone02119d2008-09-05 16:13:11 -0400812
Chris Masone02119d2008-09-05 16:13:11 -0400813 /*
814 * it is possible that we didn't log all the parent directories
815 * for a given inode. If we don't find the dir, just don't
816 * copy the back ref in. The link count fixup code will take
817 * care of the rest
818 */
819 dir = read_one_inode(root, key->offset);
820 if (!dir)
821 return -ENOENT;
822
823 inode = read_one_inode(root, key->objectid);
Tsutomu Itohc00e9492011-04-28 09:10:23 +0000824 if (!inode) {
825 iput(dir);
826 return -EIO;
827 }
Chris Masone02119d2008-09-05 16:13:11 -0400828
829 ref_ptr = btrfs_item_ptr_offset(eb, slot);
830 ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
831
832again:
833 ref = (struct btrfs_inode_ref *)ref_ptr;
834
835 namelen = btrfs_inode_ref_name_len(eb, ref);
836 name = kmalloc(namelen, GFP_NOFS);
837 BUG_ON(!name);
838
839 read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen);
840
841 /* if we already have a perfect match, we're done */
Li Zefan33345d012011-04-20 10:31:50 +0800842 if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
Chris Masone02119d2008-09-05 16:13:11 -0400843 btrfs_inode_ref_index(eb, ref),
844 name, namelen)) {
845 goto out;
846 }
847
848 /*
849 * look for a conflicting back reference in the metadata.
850 * if we find one we have to unlink that name of the file
851 * before we add our new link. Later on, we overwrite any
852 * existing back reference, and we don't want to create
853 * dangling pointers in the directory.
854 */
liuboc622ae62011-03-26 08:01:12 -0400855
856 if (search_done)
857 goto insert;
858
Chris Masone02119d2008-09-05 16:13:11 -0400859 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
860 if (ret == 0) {
861 char *victim_name;
862 int victim_name_len;
863 struct btrfs_inode_ref *victim_ref;
864 unsigned long ptr;
865 unsigned long ptr_end;
866 struct extent_buffer *leaf = path->nodes[0];
867
868 /* are we trying to overwrite a back ref for the root directory
869 * if so, just jump out, we're done
870 */
871 if (key->objectid == key->offset)
872 goto out_nowrite;
873
874 /* check all the names in this back reference to see
875 * if they are in the log. if so, we allow them to stay
876 * otherwise they must be unlinked as a conflict
877 */
878 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
879 ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
Chris Masond3977122009-01-05 21:25:51 -0500880 while (ptr < ptr_end) {
Chris Masone02119d2008-09-05 16:13:11 -0400881 victim_ref = (struct btrfs_inode_ref *)ptr;
882 victim_name_len = btrfs_inode_ref_name_len(leaf,
883 victim_ref);
884 victim_name = kmalloc(victim_name_len, GFP_NOFS);
885 BUG_ON(!victim_name);
886
887 read_extent_buffer(leaf, victim_name,
888 (unsigned long)(victim_ref + 1),
889 victim_name_len);
890
891 if (!backref_in_log(log, key, victim_name,
892 victim_name_len)) {
893 btrfs_inc_nlink(inode);
David Sterbab3b4aa72011-04-21 01:20:15 +0200894 btrfs_release_path(path);
Chris Mason12fcfd22009-03-24 10:24:20 -0400895
Chris Masone02119d2008-09-05 16:13:11 -0400896 ret = btrfs_unlink_inode(trans, root, dir,
897 inode, victim_name,
898 victim_name_len);
Chris Masonb6305562012-07-02 15:29:53 -0400899 btrfs_run_delayed_items(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -0400900 }
901 kfree(victim_name);
902 ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
903 }
904 BUG_ON(ret);
liuboc622ae62011-03-26 08:01:12 -0400905
906 /*
907 * NOTE: we have searched root tree and checked the
908 * coresponding ref, it does not need to check again.
909 */
910 search_done = 1;
Chris Masone02119d2008-09-05 16:13:11 -0400911 }
David Sterbab3b4aa72011-04-21 01:20:15 +0200912 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400913
liubo34f3e4f2011-08-06 08:35:23 +0000914 /* look for a conflicting sequence number */
915 di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
916 btrfs_inode_ref_index(eb, ref),
917 name, namelen, 0);
918 if (di && !IS_ERR(di)) {
919 ret = drop_one_dir_item(trans, root, path, dir, di);
920 BUG_ON(ret);
921 }
922 btrfs_release_path(path);
923
924 /* look for a conflicing name */
925 di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
926 name, namelen, 0);
927 if (di && !IS_ERR(di)) {
928 ret = drop_one_dir_item(trans, root, path, dir, di);
929 BUG_ON(ret);
930 }
931 btrfs_release_path(path);
932
liuboc622ae62011-03-26 08:01:12 -0400933insert:
Chris Masone02119d2008-09-05 16:13:11 -0400934 /* insert our name */
935 ret = btrfs_add_link(trans, dir, inode, name, namelen, 0,
936 btrfs_inode_ref_index(eb, ref));
937 BUG_ON(ret);
938
939 btrfs_update_inode(trans, root, inode);
940
941out:
942 ref_ptr = (unsigned long)(ref + 1) + namelen;
943 kfree(name);
944 if (ref_ptr < ref_end)
945 goto again;
946
947 /* finally write the back reference in the inode */
948 ret = overwrite_item(trans, root, path, eb, slot, key);
949 BUG_ON(ret);
950
951out_nowrite:
David Sterbab3b4aa72011-04-21 01:20:15 +0200952 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -0400953 iput(dir);
954 iput(inode);
955 return 0;
956}
957
Yan, Zhengc71bf092009-11-12 09:34:40 +0000958static int insert_orphan_item(struct btrfs_trans_handle *trans,
959 struct btrfs_root *root, u64 offset)
960{
961 int ret;
962 ret = btrfs_find_orphan_item(root, offset);
963 if (ret > 0)
964 ret = btrfs_insert_orphan_item(trans, root, offset);
965 return ret;
966}
967
968
Chris Masone02119d2008-09-05 16:13:11 -0400969/*
Chris Masone02119d2008-09-05 16:13:11 -0400970 * There are a few corners where the link count of the file can't
971 * be properly maintained during replay. So, instead of adding
972 * lots of complexity to the log code, we just scan the backrefs
973 * for any file that has been through replay.
974 *
975 * The scan will update the link count on the inode to reflect the
976 * number of back refs found. If it goes down to zero, the iput
977 * will free the inode.
978 */
979static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
980 struct btrfs_root *root,
981 struct inode *inode)
982{
983 struct btrfs_path *path;
984 int ret;
985 struct btrfs_key key;
986 u64 nlink = 0;
987 unsigned long ptr;
988 unsigned long ptr_end;
989 int name_len;
Li Zefan33345d012011-04-20 10:31:50 +0800990 u64 ino = btrfs_ino(inode);
Chris Masone02119d2008-09-05 16:13:11 -0400991
Li Zefan33345d012011-04-20 10:31:50 +0800992 key.objectid = ino;
Chris Masone02119d2008-09-05 16:13:11 -0400993 key.type = BTRFS_INODE_REF_KEY;
994 key.offset = (u64)-1;
995
996 path = btrfs_alloc_path();
liubo2a29edc2011-01-26 06:22:08 +0000997 if (!path)
998 return -ENOMEM;
Chris Masone02119d2008-09-05 16:13:11 -0400999
Chris Masond3977122009-01-05 21:25:51 -05001000 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04001001 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1002 if (ret < 0)
1003 break;
1004 if (ret > 0) {
1005 if (path->slots[0] == 0)
1006 break;
1007 path->slots[0]--;
1008 }
1009 btrfs_item_key_to_cpu(path->nodes[0], &key,
1010 path->slots[0]);
Li Zefan33345d012011-04-20 10:31:50 +08001011 if (key.objectid != ino ||
Chris Masone02119d2008-09-05 16:13:11 -04001012 key.type != BTRFS_INODE_REF_KEY)
1013 break;
1014 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
1015 ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
1016 path->slots[0]);
Chris Masond3977122009-01-05 21:25:51 -05001017 while (ptr < ptr_end) {
Chris Masone02119d2008-09-05 16:13:11 -04001018 struct btrfs_inode_ref *ref;
1019
1020 ref = (struct btrfs_inode_ref *)ptr;
1021 name_len = btrfs_inode_ref_name_len(path->nodes[0],
1022 ref);
1023 ptr = (unsigned long)(ref + 1) + name_len;
1024 nlink++;
1025 }
1026
1027 if (key.offset == 0)
1028 break;
1029 key.offset--;
David Sterbab3b4aa72011-04-21 01:20:15 +02001030 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001031 }
David Sterbab3b4aa72011-04-21 01:20:15 +02001032 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001033 if (nlink != inode->i_nlink) {
Miklos Szeredibfe86842011-10-28 14:13:29 +02001034 set_nlink(inode, nlink);
Chris Masone02119d2008-09-05 16:13:11 -04001035 btrfs_update_inode(trans, root, inode);
1036 }
Chris Mason8d5bf1c2008-09-11 15:51:21 -04001037 BTRFS_I(inode)->index_cnt = (u64)-1;
Chris Masone02119d2008-09-05 16:13:11 -04001038
Yan, Zhengc71bf092009-11-12 09:34:40 +00001039 if (inode->i_nlink == 0) {
1040 if (S_ISDIR(inode->i_mode)) {
1041 ret = replay_dir_deletes(trans, root, NULL, path,
Li Zefan33345d012011-04-20 10:31:50 +08001042 ino, 1);
Yan, Zhengc71bf092009-11-12 09:34:40 +00001043 BUG_ON(ret);
1044 }
Li Zefan33345d012011-04-20 10:31:50 +08001045 ret = insert_orphan_item(trans, root, ino);
Chris Mason12fcfd22009-03-24 10:24:20 -04001046 BUG_ON(ret);
1047 }
1048 btrfs_free_path(path);
1049
Chris Masone02119d2008-09-05 16:13:11 -04001050 return 0;
1051}
1052
1053static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
1054 struct btrfs_root *root,
1055 struct btrfs_path *path)
1056{
1057 int ret;
1058 struct btrfs_key key;
1059 struct inode *inode;
1060
1061 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1062 key.type = BTRFS_ORPHAN_ITEM_KEY;
1063 key.offset = (u64)-1;
Chris Masond3977122009-01-05 21:25:51 -05001064 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04001065 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1066 if (ret < 0)
1067 break;
1068
1069 if (ret == 1) {
1070 if (path->slots[0] == 0)
1071 break;
1072 path->slots[0]--;
1073 }
1074
1075 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1076 if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
1077 key.type != BTRFS_ORPHAN_ITEM_KEY)
1078 break;
1079
1080 ret = btrfs_del_item(trans, root, path);
Tsutomu Itoh65a246c2011-05-19 04:37:44 +00001081 if (ret)
1082 goto out;
Chris Masone02119d2008-09-05 16:13:11 -04001083
David Sterbab3b4aa72011-04-21 01:20:15 +02001084 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001085 inode = read_one_inode(root, key.offset);
Tsutomu Itohc00e9492011-04-28 09:10:23 +00001086 if (!inode)
1087 return -EIO;
Chris Masone02119d2008-09-05 16:13:11 -04001088
1089 ret = fixup_inode_link_count(trans, root, inode);
1090 BUG_ON(ret);
1091
1092 iput(inode);
1093
Chris Mason12fcfd22009-03-24 10:24:20 -04001094 /*
1095 * fixup on a directory may create new entries,
1096 * make sure we always look for the highset possible
1097 * offset
1098 */
1099 key.offset = (u64)-1;
Chris Masone02119d2008-09-05 16:13:11 -04001100 }
Tsutomu Itoh65a246c2011-05-19 04:37:44 +00001101 ret = 0;
1102out:
David Sterbab3b4aa72011-04-21 01:20:15 +02001103 btrfs_release_path(path);
Tsutomu Itoh65a246c2011-05-19 04:37:44 +00001104 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04001105}
1106
1107
1108/*
1109 * record a given inode in the fixup dir so we can check its link
1110 * count when replay is done. The link count is incremented here
1111 * so the inode won't go away until we check it
1112 */
1113static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
1114 struct btrfs_root *root,
1115 struct btrfs_path *path,
1116 u64 objectid)
1117{
1118 struct btrfs_key key;
1119 int ret = 0;
1120 struct inode *inode;
1121
1122 inode = read_one_inode(root, objectid);
Tsutomu Itohc00e9492011-04-28 09:10:23 +00001123 if (!inode)
1124 return -EIO;
Chris Masone02119d2008-09-05 16:13:11 -04001125
1126 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1127 btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
1128 key.offset = objectid;
1129
1130 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1131
David Sterbab3b4aa72011-04-21 01:20:15 +02001132 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001133 if (ret == 0) {
1134 btrfs_inc_nlink(inode);
Tsutomu Itohb9959292012-06-25 21:25:22 -06001135 ret = btrfs_update_inode(trans, root, inode);
Chris Masone02119d2008-09-05 16:13:11 -04001136 } else if (ret == -EEXIST) {
1137 ret = 0;
1138 } else {
1139 BUG();
1140 }
1141 iput(inode);
1142
1143 return ret;
1144}
1145
1146/*
1147 * when replaying the log for a directory, we only insert names
1148 * for inodes that actually exist. This means an fsync on a directory
1149 * does not implicitly fsync all the new files in it
1150 */
1151static noinline int insert_one_name(struct btrfs_trans_handle *trans,
1152 struct btrfs_root *root,
1153 struct btrfs_path *path,
1154 u64 dirid, u64 index,
1155 char *name, int name_len, u8 type,
1156 struct btrfs_key *location)
1157{
1158 struct inode *inode;
1159 struct inode *dir;
1160 int ret;
1161
1162 inode = read_one_inode(root, location->objectid);
1163 if (!inode)
1164 return -ENOENT;
1165
1166 dir = read_one_inode(root, dirid);
1167 if (!dir) {
1168 iput(inode);
1169 return -EIO;
1170 }
1171 ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
1172
1173 /* FIXME, put inode into FIXUP list */
1174
1175 iput(inode);
1176 iput(dir);
1177 return ret;
1178}
1179
1180/*
1181 * take a single entry in a log directory item and replay it into
1182 * the subvolume.
1183 *
1184 * if a conflicting item exists in the subdirectory already,
1185 * the inode it points to is unlinked and put into the link count
1186 * fix up tree.
1187 *
1188 * If a name from the log points to a file or directory that does
1189 * not exist in the FS, it is skipped. fsyncs on directories
1190 * do not force down inodes inside that directory, just changes to the
1191 * names or unlinks in a directory.
1192 */
1193static noinline int replay_one_name(struct btrfs_trans_handle *trans,
1194 struct btrfs_root *root,
1195 struct btrfs_path *path,
1196 struct extent_buffer *eb,
1197 struct btrfs_dir_item *di,
1198 struct btrfs_key *key)
1199{
1200 char *name;
1201 int name_len;
1202 struct btrfs_dir_item *dst_di;
1203 struct btrfs_key found_key;
1204 struct btrfs_key log_key;
1205 struct inode *dir;
Chris Masone02119d2008-09-05 16:13:11 -04001206 u8 log_type;
Chris Mason4bef0842008-09-08 11:18:08 -04001207 int exists;
Chris Masone02119d2008-09-05 16:13:11 -04001208 int ret;
1209
1210 dir = read_one_inode(root, key->objectid);
Tsutomu Itohc00e9492011-04-28 09:10:23 +00001211 if (!dir)
1212 return -EIO;
Chris Masone02119d2008-09-05 16:13:11 -04001213
1214 name_len = btrfs_dir_name_len(eb, di);
1215 name = kmalloc(name_len, GFP_NOFS);
liubo2a29edc2011-01-26 06:22:08 +00001216 if (!name)
1217 return -ENOMEM;
1218
Chris Masone02119d2008-09-05 16:13:11 -04001219 log_type = btrfs_dir_type(eb, di);
1220 read_extent_buffer(eb, name, (unsigned long)(di + 1),
1221 name_len);
1222
1223 btrfs_dir_item_key_to_cpu(eb, di, &log_key);
Chris Mason4bef0842008-09-08 11:18:08 -04001224 exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
1225 if (exists == 0)
1226 exists = 1;
1227 else
1228 exists = 0;
David Sterbab3b4aa72011-04-21 01:20:15 +02001229 btrfs_release_path(path);
Chris Mason4bef0842008-09-08 11:18:08 -04001230
Chris Masone02119d2008-09-05 16:13:11 -04001231 if (key->type == BTRFS_DIR_ITEM_KEY) {
1232 dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
1233 name, name_len, 1);
Chris Masond3977122009-01-05 21:25:51 -05001234 } else if (key->type == BTRFS_DIR_INDEX_KEY) {
Chris Masone02119d2008-09-05 16:13:11 -04001235 dst_di = btrfs_lookup_dir_index_item(trans, root, path,
1236 key->objectid,
1237 key->offset, name,
1238 name_len, 1);
1239 } else {
1240 BUG();
1241 }
David Sterbac7040052011-04-19 18:00:01 +02001242 if (IS_ERR_OR_NULL(dst_di)) {
Chris Masone02119d2008-09-05 16:13:11 -04001243 /* we need a sequence number to insert, so we only
1244 * do inserts for the BTRFS_DIR_INDEX_KEY types
1245 */
1246 if (key->type != BTRFS_DIR_INDEX_KEY)
1247 goto out;
1248 goto insert;
1249 }
1250
1251 btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
1252 /* the existing item matches the logged item */
1253 if (found_key.objectid == log_key.objectid &&
1254 found_key.type == log_key.type &&
1255 found_key.offset == log_key.offset &&
1256 btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
1257 goto out;
1258 }
1259
1260 /*
1261 * don't drop the conflicting directory entry if the inode
1262 * for the new entry doesn't exist
1263 */
Chris Mason4bef0842008-09-08 11:18:08 -04001264 if (!exists)
Chris Masone02119d2008-09-05 16:13:11 -04001265 goto out;
1266
Chris Masone02119d2008-09-05 16:13:11 -04001267 ret = drop_one_dir_item(trans, root, path, dir, dst_di);
1268 BUG_ON(ret);
1269
1270 if (key->type == BTRFS_DIR_INDEX_KEY)
1271 goto insert;
1272out:
David Sterbab3b4aa72011-04-21 01:20:15 +02001273 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001274 kfree(name);
1275 iput(dir);
1276 return 0;
1277
1278insert:
David Sterbab3b4aa72011-04-21 01:20:15 +02001279 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001280 ret = insert_one_name(trans, root, path, key->objectid, key->offset,
1281 name, name_len, log_type, &log_key);
1282
Stoyan Gaydarovc2934982009-04-02 17:05:11 -04001283 BUG_ON(ret && ret != -ENOENT);
Chris Masone02119d2008-09-05 16:13:11 -04001284 goto out;
1285}
1286
1287/*
1288 * find all the names in a directory item and reconcile them into
1289 * the subvolume. Only BTRFS_DIR_ITEM_KEY types will have more than
1290 * one name in a directory item, but the same code gets used for
1291 * both directory index types
1292 */
1293static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
1294 struct btrfs_root *root,
1295 struct btrfs_path *path,
1296 struct extent_buffer *eb, int slot,
1297 struct btrfs_key *key)
1298{
1299 int ret;
1300 u32 item_size = btrfs_item_size_nr(eb, slot);
1301 struct btrfs_dir_item *di;
1302 int name_len;
1303 unsigned long ptr;
1304 unsigned long ptr_end;
1305
1306 ptr = btrfs_item_ptr_offset(eb, slot);
1307 ptr_end = ptr + item_size;
Chris Masond3977122009-01-05 21:25:51 -05001308 while (ptr < ptr_end) {
Chris Masone02119d2008-09-05 16:13:11 -04001309 di = (struct btrfs_dir_item *)ptr;
Josef Bacik22a94d42011-03-16 16:47:17 -04001310 if (verify_dir_item(root, eb, di))
1311 return -EIO;
Chris Masone02119d2008-09-05 16:13:11 -04001312 name_len = btrfs_dir_name_len(eb, di);
1313 ret = replay_one_name(trans, root, path, eb, di, key);
1314 BUG_ON(ret);
1315 ptr = (unsigned long)(di + 1);
1316 ptr += name_len;
1317 }
1318 return 0;
1319}
1320
1321/*
1322 * directory replay has two parts. There are the standard directory
1323 * items in the log copied from the subvolume, and range items
1324 * created in the log while the subvolume was logged.
1325 *
1326 * The range items tell us which parts of the key space the log
1327 * is authoritative for. During replay, if a key in the subvolume
1328 * directory is in a logged range item, but not actually in the log
1329 * that means it was deleted from the directory before the fsync
1330 * and should be removed.
1331 */
1332static noinline int find_dir_range(struct btrfs_root *root,
1333 struct btrfs_path *path,
1334 u64 dirid, int key_type,
1335 u64 *start_ret, u64 *end_ret)
1336{
1337 struct btrfs_key key;
1338 u64 found_end;
1339 struct btrfs_dir_log_item *item;
1340 int ret;
1341 int nritems;
1342
1343 if (*start_ret == (u64)-1)
1344 return 1;
1345
1346 key.objectid = dirid;
1347 key.type = key_type;
1348 key.offset = *start_ret;
1349
1350 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1351 if (ret < 0)
1352 goto out;
1353 if (ret > 0) {
1354 if (path->slots[0] == 0)
1355 goto out;
1356 path->slots[0]--;
1357 }
1358 if (ret != 0)
1359 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1360
1361 if (key.type != key_type || key.objectid != dirid) {
1362 ret = 1;
1363 goto next;
1364 }
1365 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1366 struct btrfs_dir_log_item);
1367 found_end = btrfs_dir_log_end(path->nodes[0], item);
1368
1369 if (*start_ret >= key.offset && *start_ret <= found_end) {
1370 ret = 0;
1371 *start_ret = key.offset;
1372 *end_ret = found_end;
1373 goto out;
1374 }
1375 ret = 1;
1376next:
1377 /* check the next slot in the tree to see if it is a valid item */
1378 nritems = btrfs_header_nritems(path->nodes[0]);
1379 if (path->slots[0] >= nritems) {
1380 ret = btrfs_next_leaf(root, path);
1381 if (ret)
1382 goto out;
1383 } else {
1384 path->slots[0]++;
1385 }
1386
1387 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1388
1389 if (key.type != key_type || key.objectid != dirid) {
1390 ret = 1;
1391 goto out;
1392 }
1393 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1394 struct btrfs_dir_log_item);
1395 found_end = btrfs_dir_log_end(path->nodes[0], item);
1396 *start_ret = key.offset;
1397 *end_ret = found_end;
1398 ret = 0;
1399out:
David Sterbab3b4aa72011-04-21 01:20:15 +02001400 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001401 return ret;
1402}
1403
1404/*
1405 * this looks for a given directory item in the log. If the directory
1406 * item is not in the log, the item is removed and the inode it points
1407 * to is unlinked
1408 */
1409static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
1410 struct btrfs_root *root,
1411 struct btrfs_root *log,
1412 struct btrfs_path *path,
1413 struct btrfs_path *log_path,
1414 struct inode *dir,
1415 struct btrfs_key *dir_key)
1416{
1417 int ret;
1418 struct extent_buffer *eb;
1419 int slot;
1420 u32 item_size;
1421 struct btrfs_dir_item *di;
1422 struct btrfs_dir_item *log_di;
1423 int name_len;
1424 unsigned long ptr;
1425 unsigned long ptr_end;
1426 char *name;
1427 struct inode *inode;
1428 struct btrfs_key location;
1429
1430again:
1431 eb = path->nodes[0];
1432 slot = path->slots[0];
1433 item_size = btrfs_item_size_nr(eb, slot);
1434 ptr = btrfs_item_ptr_offset(eb, slot);
1435 ptr_end = ptr + item_size;
Chris Masond3977122009-01-05 21:25:51 -05001436 while (ptr < ptr_end) {
Chris Masone02119d2008-09-05 16:13:11 -04001437 di = (struct btrfs_dir_item *)ptr;
Josef Bacik22a94d42011-03-16 16:47:17 -04001438 if (verify_dir_item(root, eb, di)) {
1439 ret = -EIO;
1440 goto out;
1441 }
1442
Chris Masone02119d2008-09-05 16:13:11 -04001443 name_len = btrfs_dir_name_len(eb, di);
1444 name = kmalloc(name_len, GFP_NOFS);
1445 if (!name) {
1446 ret = -ENOMEM;
1447 goto out;
1448 }
1449 read_extent_buffer(eb, name, (unsigned long)(di + 1),
1450 name_len);
1451 log_di = NULL;
Chris Mason12fcfd22009-03-24 10:24:20 -04001452 if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
Chris Masone02119d2008-09-05 16:13:11 -04001453 log_di = btrfs_lookup_dir_item(trans, log, log_path,
1454 dir_key->objectid,
1455 name, name_len, 0);
Chris Mason12fcfd22009-03-24 10:24:20 -04001456 } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
Chris Masone02119d2008-09-05 16:13:11 -04001457 log_di = btrfs_lookup_dir_index_item(trans, log,
1458 log_path,
1459 dir_key->objectid,
1460 dir_key->offset,
1461 name, name_len, 0);
1462 }
David Sterbac7040052011-04-19 18:00:01 +02001463 if (IS_ERR_OR_NULL(log_di)) {
Chris Masone02119d2008-09-05 16:13:11 -04001464 btrfs_dir_item_key_to_cpu(eb, di, &location);
David Sterbab3b4aa72011-04-21 01:20:15 +02001465 btrfs_release_path(path);
1466 btrfs_release_path(log_path);
Chris Masone02119d2008-09-05 16:13:11 -04001467 inode = read_one_inode(root, location.objectid);
Tsutomu Itohc00e9492011-04-28 09:10:23 +00001468 if (!inode) {
1469 kfree(name);
1470 return -EIO;
1471 }
Chris Masone02119d2008-09-05 16:13:11 -04001472
1473 ret = link_to_fixup_dir(trans, root,
1474 path, location.objectid);
1475 BUG_ON(ret);
1476 btrfs_inc_nlink(inode);
1477 ret = btrfs_unlink_inode(trans, root, dir, inode,
1478 name, name_len);
1479 BUG_ON(ret);
Chris Masonb6305562012-07-02 15:29:53 -04001480
1481 btrfs_run_delayed_items(trans, root);
1482
Chris Masone02119d2008-09-05 16:13:11 -04001483 kfree(name);
1484 iput(inode);
1485
1486 /* there might still be more names under this key
1487 * check and repeat if required
1488 */
1489 ret = btrfs_search_slot(NULL, root, dir_key, path,
1490 0, 0);
1491 if (ret == 0)
1492 goto again;
1493 ret = 0;
1494 goto out;
1495 }
David Sterbab3b4aa72011-04-21 01:20:15 +02001496 btrfs_release_path(log_path);
Chris Masone02119d2008-09-05 16:13:11 -04001497 kfree(name);
1498
1499 ptr = (unsigned long)(di + 1);
1500 ptr += name_len;
1501 }
1502 ret = 0;
1503out:
David Sterbab3b4aa72011-04-21 01:20:15 +02001504 btrfs_release_path(path);
1505 btrfs_release_path(log_path);
Chris Masone02119d2008-09-05 16:13:11 -04001506 return ret;
1507}
1508
1509/*
1510 * deletion replay happens before we copy any new directory items
1511 * out of the log or out of backreferences from inodes. It
1512 * scans the log to find ranges of keys that log is authoritative for,
1513 * and then scans the directory to find items in those ranges that are
1514 * not present in the log.
1515 *
1516 * Anything we don't find in the log is unlinked and removed from the
1517 * directory.
1518 */
1519static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
1520 struct btrfs_root *root,
1521 struct btrfs_root *log,
1522 struct btrfs_path *path,
Chris Mason12fcfd22009-03-24 10:24:20 -04001523 u64 dirid, int del_all)
Chris Masone02119d2008-09-05 16:13:11 -04001524{
1525 u64 range_start;
1526 u64 range_end;
1527 int key_type = BTRFS_DIR_LOG_ITEM_KEY;
1528 int ret = 0;
1529 struct btrfs_key dir_key;
1530 struct btrfs_key found_key;
1531 struct btrfs_path *log_path;
1532 struct inode *dir;
1533
1534 dir_key.objectid = dirid;
1535 dir_key.type = BTRFS_DIR_ITEM_KEY;
1536 log_path = btrfs_alloc_path();
1537 if (!log_path)
1538 return -ENOMEM;
1539
1540 dir = read_one_inode(root, dirid);
1541 /* it isn't an error if the inode isn't there, that can happen
1542 * because we replay the deletes before we copy in the inode item
1543 * from the log
1544 */
1545 if (!dir) {
1546 btrfs_free_path(log_path);
1547 return 0;
1548 }
1549again:
1550 range_start = 0;
1551 range_end = 0;
Chris Masond3977122009-01-05 21:25:51 -05001552 while (1) {
Chris Mason12fcfd22009-03-24 10:24:20 -04001553 if (del_all)
1554 range_end = (u64)-1;
1555 else {
1556 ret = find_dir_range(log, path, dirid, key_type,
1557 &range_start, &range_end);
1558 if (ret != 0)
1559 break;
1560 }
Chris Masone02119d2008-09-05 16:13:11 -04001561
1562 dir_key.offset = range_start;
Chris Masond3977122009-01-05 21:25:51 -05001563 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04001564 int nritems;
1565 ret = btrfs_search_slot(NULL, root, &dir_key, path,
1566 0, 0);
1567 if (ret < 0)
1568 goto out;
1569
1570 nritems = btrfs_header_nritems(path->nodes[0]);
1571 if (path->slots[0] >= nritems) {
1572 ret = btrfs_next_leaf(root, path);
1573 if (ret)
1574 break;
1575 }
1576 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1577 path->slots[0]);
1578 if (found_key.objectid != dirid ||
1579 found_key.type != dir_key.type)
1580 goto next_type;
1581
1582 if (found_key.offset > range_end)
1583 break;
1584
1585 ret = check_item_in_log(trans, root, log, path,
Chris Mason12fcfd22009-03-24 10:24:20 -04001586 log_path, dir,
1587 &found_key);
Chris Masone02119d2008-09-05 16:13:11 -04001588 BUG_ON(ret);
1589 if (found_key.offset == (u64)-1)
1590 break;
1591 dir_key.offset = found_key.offset + 1;
1592 }
David Sterbab3b4aa72011-04-21 01:20:15 +02001593 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001594 if (range_end == (u64)-1)
1595 break;
1596 range_start = range_end + 1;
1597 }
1598
1599next_type:
1600 ret = 0;
1601 if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
1602 key_type = BTRFS_DIR_LOG_INDEX_KEY;
1603 dir_key.type = BTRFS_DIR_INDEX_KEY;
David Sterbab3b4aa72011-04-21 01:20:15 +02001604 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001605 goto again;
1606 }
1607out:
David Sterbab3b4aa72011-04-21 01:20:15 +02001608 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001609 btrfs_free_path(log_path);
1610 iput(dir);
1611 return ret;
1612}
1613
1614/*
1615 * the process_func used to replay items from the log tree. This
1616 * gets called in two different stages. The first stage just looks
1617 * for inodes and makes sure they are all copied into the subvolume.
1618 *
1619 * The second stage copies all the other item types from the log into
1620 * the subvolume. The two stage approach is slower, but gets rid of
1621 * lots of complexity around inodes referencing other inodes that exist
1622 * only in the log (references come from either directory items or inode
1623 * back refs).
1624 */
1625static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
1626 struct walk_control *wc, u64 gen)
1627{
1628 int nritems;
1629 struct btrfs_path *path;
1630 struct btrfs_root *root = wc->replay_dest;
1631 struct btrfs_key key;
Chris Masone02119d2008-09-05 16:13:11 -04001632 int level;
1633 int i;
1634 int ret;
1635
Tsutomu Itoh018642a2012-05-29 18:10:13 +09001636 ret = btrfs_read_buffer(eb, gen);
1637 if (ret)
1638 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04001639
1640 level = btrfs_header_level(eb);
1641
1642 if (level != 0)
1643 return 0;
1644
1645 path = btrfs_alloc_path();
Mark Fasheh1e5063d2011-07-12 10:46:06 -07001646 if (!path)
1647 return -ENOMEM;
Chris Masone02119d2008-09-05 16:13:11 -04001648
1649 nritems = btrfs_header_nritems(eb);
1650 for (i = 0; i < nritems; i++) {
1651 btrfs_item_key_to_cpu(eb, &key, i);
Chris Masone02119d2008-09-05 16:13:11 -04001652
1653 /* inode keys are done during the first stage */
1654 if (key.type == BTRFS_INODE_ITEM_KEY &&
1655 wc->stage == LOG_WALK_REPLAY_INODES) {
Chris Masone02119d2008-09-05 16:13:11 -04001656 struct btrfs_inode_item *inode_item;
1657 u32 mode;
1658
1659 inode_item = btrfs_item_ptr(eb, i,
1660 struct btrfs_inode_item);
1661 mode = btrfs_inode_mode(eb, inode_item);
1662 if (S_ISDIR(mode)) {
1663 ret = replay_dir_deletes(wc->trans,
Chris Mason12fcfd22009-03-24 10:24:20 -04001664 root, log, path, key.objectid, 0);
Chris Masone02119d2008-09-05 16:13:11 -04001665 BUG_ON(ret);
1666 }
1667 ret = overwrite_item(wc->trans, root, path,
1668 eb, i, &key);
1669 BUG_ON(ret);
1670
Yan, Zhengc71bf092009-11-12 09:34:40 +00001671 /* for regular files, make sure corresponding
1672 * orhpan item exist. extents past the new EOF
1673 * will be truncated later by orphan cleanup.
Chris Masone02119d2008-09-05 16:13:11 -04001674 */
1675 if (S_ISREG(mode)) {
Yan, Zhengc71bf092009-11-12 09:34:40 +00001676 ret = insert_orphan_item(wc->trans, root,
1677 key.objectid);
Chris Masone02119d2008-09-05 16:13:11 -04001678 BUG_ON(ret);
Chris Masone02119d2008-09-05 16:13:11 -04001679 }
Yan, Zhengc71bf092009-11-12 09:34:40 +00001680
Chris Masone02119d2008-09-05 16:13:11 -04001681 ret = link_to_fixup_dir(wc->trans, root,
1682 path, key.objectid);
1683 BUG_ON(ret);
1684 }
1685 if (wc->stage < LOG_WALK_REPLAY_ALL)
1686 continue;
1687
1688 /* these keys are simply copied */
1689 if (key.type == BTRFS_XATTR_ITEM_KEY) {
1690 ret = overwrite_item(wc->trans, root, path,
1691 eb, i, &key);
1692 BUG_ON(ret);
1693 } else if (key.type == BTRFS_INODE_REF_KEY) {
1694 ret = add_inode_ref(wc->trans, root, log, path,
1695 eb, i, &key);
1696 BUG_ON(ret && ret != -ENOENT);
1697 } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
1698 ret = replay_one_extent(wc->trans, root, path,
1699 eb, i, &key);
1700 BUG_ON(ret);
Chris Masone02119d2008-09-05 16:13:11 -04001701 } else if (key.type == BTRFS_DIR_ITEM_KEY ||
1702 key.type == BTRFS_DIR_INDEX_KEY) {
1703 ret = replay_one_dir_item(wc->trans, root, path,
1704 eb, i, &key);
1705 BUG_ON(ret);
1706 }
1707 }
1708 btrfs_free_path(path);
1709 return 0;
1710}
1711
Chris Masond3977122009-01-05 21:25:51 -05001712static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
Chris Masone02119d2008-09-05 16:13:11 -04001713 struct btrfs_root *root,
1714 struct btrfs_path *path, int *level,
1715 struct walk_control *wc)
1716{
1717 u64 root_owner;
Chris Masone02119d2008-09-05 16:13:11 -04001718 u64 bytenr;
1719 u64 ptr_gen;
1720 struct extent_buffer *next;
1721 struct extent_buffer *cur;
1722 struct extent_buffer *parent;
1723 u32 blocksize;
1724 int ret = 0;
1725
1726 WARN_ON(*level < 0);
1727 WARN_ON(*level >= BTRFS_MAX_LEVEL);
1728
Chris Masond3977122009-01-05 21:25:51 -05001729 while (*level > 0) {
Chris Masone02119d2008-09-05 16:13:11 -04001730 WARN_ON(*level < 0);
1731 WARN_ON(*level >= BTRFS_MAX_LEVEL);
1732 cur = path->nodes[*level];
1733
1734 if (btrfs_header_level(cur) != *level)
1735 WARN_ON(1);
1736
1737 if (path->slots[*level] >=
1738 btrfs_header_nritems(cur))
1739 break;
1740
1741 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
1742 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
1743 blocksize = btrfs_level_size(root, *level - 1);
1744
1745 parent = path->nodes[*level];
1746 root_owner = btrfs_header_owner(parent);
Chris Masone02119d2008-09-05 16:13:11 -04001747
1748 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
liubo2a29edc2011-01-26 06:22:08 +00001749 if (!next)
1750 return -ENOMEM;
Chris Masone02119d2008-09-05 16:13:11 -04001751
Chris Masone02119d2008-09-05 16:13:11 -04001752 if (*level == 1) {
Mark Fasheh1e5063d2011-07-12 10:46:06 -07001753 ret = wc->process_func(root, next, wc, ptr_gen);
1754 if (ret)
1755 return ret;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04001756
Chris Masone02119d2008-09-05 16:13:11 -04001757 path->slots[*level]++;
1758 if (wc->free) {
Tsutomu Itoh018642a2012-05-29 18:10:13 +09001759 ret = btrfs_read_buffer(next, ptr_gen);
1760 if (ret) {
1761 free_extent_buffer(next);
1762 return ret;
1763 }
Chris Masone02119d2008-09-05 16:13:11 -04001764
1765 btrfs_tree_lock(next);
Chris Masonb4ce94d2009-02-04 09:25:08 -05001766 btrfs_set_lock_blocking(next);
Chris Masonbd681512011-07-16 15:23:14 -04001767 clean_tree_block(trans, root, next);
Chris Masone02119d2008-09-05 16:13:11 -04001768 btrfs_wait_tree_block_writeback(next);
1769 btrfs_tree_unlock(next);
1770
Chris Masone02119d2008-09-05 16:13:11 -04001771 WARN_ON(root_owner !=
1772 BTRFS_TREE_LOG_OBJECTID);
Chris Masone688b7252011-10-31 20:52:39 -04001773 ret = btrfs_free_and_pin_reserved_extent(root,
Chris Masond00aff02008-09-11 15:54:42 -04001774 bytenr, blocksize);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001775 BUG_ON(ret); /* -ENOMEM or logic errors */
Chris Masone02119d2008-09-05 16:13:11 -04001776 }
1777 free_extent_buffer(next);
1778 continue;
1779 }
Tsutomu Itoh018642a2012-05-29 18:10:13 +09001780 ret = btrfs_read_buffer(next, ptr_gen);
1781 if (ret) {
1782 free_extent_buffer(next);
1783 return ret;
1784 }
Chris Masone02119d2008-09-05 16:13:11 -04001785
1786 WARN_ON(*level <= 0);
1787 if (path->nodes[*level-1])
1788 free_extent_buffer(path->nodes[*level-1]);
1789 path->nodes[*level-1] = next;
1790 *level = btrfs_header_level(next);
1791 path->slots[*level] = 0;
1792 cond_resched();
1793 }
1794 WARN_ON(*level < 0);
1795 WARN_ON(*level >= BTRFS_MAX_LEVEL);
1796
Yan, Zheng4a500fd2010-05-16 10:49:59 -04001797 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
Chris Masone02119d2008-09-05 16:13:11 -04001798
1799 cond_resched();
1800 return 0;
1801}
1802
Chris Masond3977122009-01-05 21:25:51 -05001803static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
Chris Masone02119d2008-09-05 16:13:11 -04001804 struct btrfs_root *root,
1805 struct btrfs_path *path, int *level,
1806 struct walk_control *wc)
1807{
1808 u64 root_owner;
Chris Masone02119d2008-09-05 16:13:11 -04001809 int i;
1810 int slot;
1811 int ret;
1812
Chris Masond3977122009-01-05 21:25:51 -05001813 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
Chris Masone02119d2008-09-05 16:13:11 -04001814 slot = path->slots[i];
Yan, Zheng4a500fd2010-05-16 10:49:59 -04001815 if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
Chris Masone02119d2008-09-05 16:13:11 -04001816 path->slots[i]++;
1817 *level = i;
1818 WARN_ON(*level == 0);
1819 return 0;
1820 } else {
Zheng Yan31840ae2008-09-23 13:14:14 -04001821 struct extent_buffer *parent;
1822 if (path->nodes[*level] == root->node)
1823 parent = path->nodes[*level];
1824 else
1825 parent = path->nodes[*level + 1];
1826
1827 root_owner = btrfs_header_owner(parent);
Mark Fasheh1e5063d2011-07-12 10:46:06 -07001828 ret = wc->process_func(root, path->nodes[*level], wc,
Chris Masone02119d2008-09-05 16:13:11 -04001829 btrfs_header_generation(path->nodes[*level]));
Mark Fasheh1e5063d2011-07-12 10:46:06 -07001830 if (ret)
1831 return ret;
1832
Chris Masone02119d2008-09-05 16:13:11 -04001833 if (wc->free) {
1834 struct extent_buffer *next;
1835
1836 next = path->nodes[*level];
1837
1838 btrfs_tree_lock(next);
Chris Masonb4ce94d2009-02-04 09:25:08 -05001839 btrfs_set_lock_blocking(next);
Chris Masonbd681512011-07-16 15:23:14 -04001840 clean_tree_block(trans, root, next);
Chris Masone02119d2008-09-05 16:13:11 -04001841 btrfs_wait_tree_block_writeback(next);
1842 btrfs_tree_unlock(next);
1843
Chris Masone02119d2008-09-05 16:13:11 -04001844 WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
Chris Masone688b7252011-10-31 20:52:39 -04001845 ret = btrfs_free_and_pin_reserved_extent(root,
Chris Masone02119d2008-09-05 16:13:11 -04001846 path->nodes[*level]->start,
Chris Masond00aff02008-09-11 15:54:42 -04001847 path->nodes[*level]->len);
Chris Masone02119d2008-09-05 16:13:11 -04001848 BUG_ON(ret);
1849 }
1850 free_extent_buffer(path->nodes[*level]);
1851 path->nodes[*level] = NULL;
1852 *level = i + 1;
1853 }
1854 }
1855 return 1;
1856}
1857
1858/*
1859 * drop the reference count on the tree rooted at 'snap'. This traverses
1860 * the tree freeing any blocks that have a ref count of zero after being
1861 * decremented.
1862 */
1863static int walk_log_tree(struct btrfs_trans_handle *trans,
1864 struct btrfs_root *log, struct walk_control *wc)
1865{
1866 int ret = 0;
1867 int wret;
1868 int level;
1869 struct btrfs_path *path;
1870 int i;
1871 int orig_level;
1872
1873 path = btrfs_alloc_path();
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00001874 if (!path)
1875 return -ENOMEM;
Chris Masone02119d2008-09-05 16:13:11 -04001876
1877 level = btrfs_header_level(log->node);
1878 orig_level = level;
1879 path->nodes[level] = log->node;
1880 extent_buffer_get(log->node);
1881 path->slots[level] = 0;
1882
Chris Masond3977122009-01-05 21:25:51 -05001883 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04001884 wret = walk_down_log_tree(trans, log, path, &level, wc);
1885 if (wret > 0)
1886 break;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001887 if (wret < 0) {
Chris Masone02119d2008-09-05 16:13:11 -04001888 ret = wret;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001889 goto out;
1890 }
Chris Masone02119d2008-09-05 16:13:11 -04001891
1892 wret = walk_up_log_tree(trans, log, path, &level, wc);
1893 if (wret > 0)
1894 break;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001895 if (wret < 0) {
Chris Masone02119d2008-09-05 16:13:11 -04001896 ret = wret;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001897 goto out;
1898 }
Chris Masone02119d2008-09-05 16:13:11 -04001899 }
1900
1901 /* was the root node processed? if not, catch it here */
1902 if (path->nodes[orig_level]) {
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001903 ret = wc->process_func(log, path->nodes[orig_level], wc,
Chris Masone02119d2008-09-05 16:13:11 -04001904 btrfs_header_generation(path->nodes[orig_level]));
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001905 if (ret)
1906 goto out;
Chris Masone02119d2008-09-05 16:13:11 -04001907 if (wc->free) {
1908 struct extent_buffer *next;
1909
1910 next = path->nodes[orig_level];
1911
1912 btrfs_tree_lock(next);
Chris Masonb4ce94d2009-02-04 09:25:08 -05001913 btrfs_set_lock_blocking(next);
Chris Masonbd681512011-07-16 15:23:14 -04001914 clean_tree_block(trans, log, next);
Chris Masone02119d2008-09-05 16:13:11 -04001915 btrfs_wait_tree_block_writeback(next);
1916 btrfs_tree_unlock(next);
1917
Chris Masone02119d2008-09-05 16:13:11 -04001918 WARN_ON(log->root_key.objectid !=
1919 BTRFS_TREE_LOG_OBJECTID);
Chris Masone688b7252011-10-31 20:52:39 -04001920 ret = btrfs_free_and_pin_reserved_extent(log, next->start,
Chris Masond00aff02008-09-11 15:54:42 -04001921 next->len);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001922 BUG_ON(ret); /* -ENOMEM or logic errors */
Chris Masone02119d2008-09-05 16:13:11 -04001923 }
1924 }
1925
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001926out:
Chris Masone02119d2008-09-05 16:13:11 -04001927 for (i = 0; i <= orig_level; i++) {
1928 if (path->nodes[i]) {
1929 free_extent_buffer(path->nodes[i]);
1930 path->nodes[i] = NULL;
1931 }
1932 }
1933 btrfs_free_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04001934 return ret;
1935}
1936
Yan Zheng7237f182009-01-21 12:54:03 -05001937/*
1938 * helper function to update the item for a given subvolumes log root
1939 * in the tree of log roots
1940 */
1941static int update_log_root(struct btrfs_trans_handle *trans,
1942 struct btrfs_root *log)
1943{
1944 int ret;
1945
1946 if (log->log_transid == 1) {
1947 /* insert root item on the first sync */
1948 ret = btrfs_insert_root(trans, log->fs_info->log_root_tree,
1949 &log->root_key, &log->root_item);
1950 } else {
1951 ret = btrfs_update_root(trans, log->fs_info->log_root_tree,
1952 &log->root_key, &log->root_item);
1953 }
1954 return ret;
1955}
1956
Chris Mason12fcfd22009-03-24 10:24:20 -04001957static int wait_log_commit(struct btrfs_trans_handle *trans,
1958 struct btrfs_root *root, unsigned long transid)
Chris Masone02119d2008-09-05 16:13:11 -04001959{
1960 DEFINE_WAIT(wait);
Yan Zheng7237f182009-01-21 12:54:03 -05001961 int index = transid % 2;
Chris Masone02119d2008-09-05 16:13:11 -04001962
Yan Zheng7237f182009-01-21 12:54:03 -05001963 /*
1964 * we only allow two pending log transactions at a time,
1965 * so we know that if ours is more than 2 older than the
1966 * current transaction, we're done
1967 */
Chris Masone02119d2008-09-05 16:13:11 -04001968 do {
Yan Zheng7237f182009-01-21 12:54:03 -05001969 prepare_to_wait(&root->log_commit_wait[index],
1970 &wait, TASK_UNINTERRUPTIBLE);
1971 mutex_unlock(&root->log_mutex);
Chris Mason12fcfd22009-03-24 10:24:20 -04001972
1973 if (root->fs_info->last_trans_log_full_commit !=
1974 trans->transid && root->log_transid < transid + 2 &&
Yan Zheng7237f182009-01-21 12:54:03 -05001975 atomic_read(&root->log_commit[index]))
Chris Masone02119d2008-09-05 16:13:11 -04001976 schedule();
Chris Mason12fcfd22009-03-24 10:24:20 -04001977
Yan Zheng7237f182009-01-21 12:54:03 -05001978 finish_wait(&root->log_commit_wait[index], &wait);
1979 mutex_lock(&root->log_mutex);
Jan Kara6dd70ce2012-01-26 15:01:11 -05001980 } while (root->fs_info->last_trans_log_full_commit !=
1981 trans->transid && root->log_transid < transid + 2 &&
Yan Zheng7237f182009-01-21 12:54:03 -05001982 atomic_read(&root->log_commit[index]));
1983 return 0;
1984}
1985
Jeff Mahoney143bede2012-03-01 14:56:26 +01001986static void wait_for_writer(struct btrfs_trans_handle *trans,
1987 struct btrfs_root *root)
Yan Zheng7237f182009-01-21 12:54:03 -05001988{
1989 DEFINE_WAIT(wait);
Jan Kara6dd70ce2012-01-26 15:01:11 -05001990 while (root->fs_info->last_trans_log_full_commit !=
1991 trans->transid && atomic_read(&root->log_writers)) {
Yan Zheng7237f182009-01-21 12:54:03 -05001992 prepare_to_wait(&root->log_writer_wait,
1993 &wait, TASK_UNINTERRUPTIBLE);
1994 mutex_unlock(&root->log_mutex);
Chris Mason12fcfd22009-03-24 10:24:20 -04001995 if (root->fs_info->last_trans_log_full_commit !=
1996 trans->transid && atomic_read(&root->log_writers))
Yan Zheng7237f182009-01-21 12:54:03 -05001997 schedule();
1998 mutex_lock(&root->log_mutex);
1999 finish_wait(&root->log_writer_wait, &wait);
2000 }
Chris Masone02119d2008-09-05 16:13:11 -04002001}
2002
2003/*
2004 * btrfs_sync_log does sends a given tree log down to the disk and
2005 * updates the super blocks to record it. When this call is done,
Chris Mason12fcfd22009-03-24 10:24:20 -04002006 * you know that any inodes previously logged are safely on disk only
2007 * if it returns 0.
2008 *
2009 * Any other return value means you need to call btrfs_commit_transaction.
2010 * Some of the edge cases for fsyncing directories that have had unlinks
2011 * or renames done in the past mean that sometimes the only safe
2012 * fsync is to commit the whole FS. When btrfs_sync_log returns -EAGAIN,
2013 * that has happened.
Chris Masone02119d2008-09-05 16:13:11 -04002014 */
2015int btrfs_sync_log(struct btrfs_trans_handle *trans,
2016 struct btrfs_root *root)
2017{
Yan Zheng7237f182009-01-21 12:54:03 -05002018 int index1;
2019 int index2;
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002020 int mark;
Chris Masone02119d2008-09-05 16:13:11 -04002021 int ret;
Chris Masone02119d2008-09-05 16:13:11 -04002022 struct btrfs_root *log = root->log_root;
Yan Zheng7237f182009-01-21 12:54:03 -05002023 struct btrfs_root *log_root_tree = root->fs_info->log_root_tree;
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002024 unsigned long log_transid = 0;
Chris Masone02119d2008-09-05 16:13:11 -04002025
Yan Zheng7237f182009-01-21 12:54:03 -05002026 mutex_lock(&root->log_mutex);
2027 index1 = root->log_transid % 2;
2028 if (atomic_read(&root->log_commit[index1])) {
Chris Mason12fcfd22009-03-24 10:24:20 -04002029 wait_log_commit(trans, root, root->log_transid);
Yan Zheng7237f182009-01-21 12:54:03 -05002030 mutex_unlock(&root->log_mutex);
2031 return 0;
Chris Masone02119d2008-09-05 16:13:11 -04002032 }
Yan Zheng7237f182009-01-21 12:54:03 -05002033 atomic_set(&root->log_commit[index1], 1);
2034
2035 /* wait for previous tree log sync to complete */
2036 if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
Chris Mason12fcfd22009-03-24 10:24:20 -04002037 wait_log_commit(trans, root, root->log_transid - 1);
Yan, Zheng86df7eb2009-10-14 09:24:59 -04002038 while (1) {
Yan Zheng7237f182009-01-21 12:54:03 -05002039 unsigned long batch = root->log_batch;
Chris Masoncd354ad2011-10-20 15:45:37 -04002040 /* when we're on an ssd, just kick the log commit out */
2041 if (!btrfs_test_opt(root, SSD) && root->log_multiple_pids) {
Yan, Zheng86df7eb2009-10-14 09:24:59 -04002042 mutex_unlock(&root->log_mutex);
2043 schedule_timeout_uninterruptible(1);
2044 mutex_lock(&root->log_mutex);
2045 }
Chris Mason12fcfd22009-03-24 10:24:20 -04002046 wait_for_writer(trans, root);
Yan Zheng7237f182009-01-21 12:54:03 -05002047 if (batch == root->log_batch)
Chris Masone02119d2008-09-05 16:13:11 -04002048 break;
2049 }
Chris Masond0c803c2008-09-11 16:17:57 -04002050
Chris Mason12fcfd22009-03-24 10:24:20 -04002051 /* bail out if we need to do a full commit */
2052 if (root->fs_info->last_trans_log_full_commit == trans->transid) {
2053 ret = -EAGAIN;
2054 mutex_unlock(&root->log_mutex);
2055 goto out;
2056 }
2057
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002058 log_transid = root->log_transid;
2059 if (log_transid % 2 == 0)
2060 mark = EXTENT_DIRTY;
2061 else
2062 mark = EXTENT_NEW;
2063
Chris Mason690587d2009-10-13 13:29:19 -04002064 /* we start IO on all the marked extents here, but we don't actually
2065 * wait for them until later.
2066 */
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002067 ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002068 if (ret) {
2069 btrfs_abort_transaction(trans, root, ret);
2070 mutex_unlock(&root->log_mutex);
2071 goto out;
2072 }
Yan Zheng7237f182009-01-21 12:54:03 -05002073
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002074 btrfs_set_root_node(&log->root_item, log->node);
Yan Zheng7237f182009-01-21 12:54:03 -05002075
2076 root->log_batch = 0;
2077 root->log_transid++;
2078 log->log_transid = root->log_transid;
Josef Bacikff782e02009-10-08 15:30:04 -04002079 root->log_start_pid = 0;
Yan Zheng7237f182009-01-21 12:54:03 -05002080 smp_mb();
2081 /*
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002082 * IO has been started, blocks of the log tree have WRITTEN flag set
2083 * in their headers. new modifications of the log will be written to
2084 * new positions. so it's safe to allow log writers to go in.
Yan Zheng7237f182009-01-21 12:54:03 -05002085 */
2086 mutex_unlock(&root->log_mutex);
2087
2088 mutex_lock(&log_root_tree->log_mutex);
2089 log_root_tree->log_batch++;
2090 atomic_inc(&log_root_tree->log_writers);
2091 mutex_unlock(&log_root_tree->log_mutex);
2092
2093 ret = update_log_root(trans, log);
Yan Zheng7237f182009-01-21 12:54:03 -05002094
2095 mutex_lock(&log_root_tree->log_mutex);
2096 if (atomic_dec_and_test(&log_root_tree->log_writers)) {
2097 smp_mb();
2098 if (waitqueue_active(&log_root_tree->log_writer_wait))
2099 wake_up(&log_root_tree->log_writer_wait);
2100 }
2101
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002102 if (ret) {
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002103 if (ret != -ENOSPC) {
2104 btrfs_abort_transaction(trans, root, ret);
2105 mutex_unlock(&log_root_tree->log_mutex);
2106 goto out;
2107 }
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002108 root->fs_info->last_trans_log_full_commit = trans->transid;
2109 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2110 mutex_unlock(&log_root_tree->log_mutex);
2111 ret = -EAGAIN;
2112 goto out;
2113 }
2114
Yan Zheng7237f182009-01-21 12:54:03 -05002115 index2 = log_root_tree->log_transid % 2;
2116 if (atomic_read(&log_root_tree->log_commit[index2])) {
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002117 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
Chris Mason12fcfd22009-03-24 10:24:20 -04002118 wait_log_commit(trans, log_root_tree,
2119 log_root_tree->log_transid);
Yan Zheng7237f182009-01-21 12:54:03 -05002120 mutex_unlock(&log_root_tree->log_mutex);
Chris Masonb31eabd2011-01-31 16:48:24 -05002121 ret = 0;
Yan Zheng7237f182009-01-21 12:54:03 -05002122 goto out;
2123 }
2124 atomic_set(&log_root_tree->log_commit[index2], 1);
2125
Chris Mason12fcfd22009-03-24 10:24:20 -04002126 if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
2127 wait_log_commit(trans, log_root_tree,
2128 log_root_tree->log_transid - 1);
2129 }
Yan Zheng7237f182009-01-21 12:54:03 -05002130
Chris Mason12fcfd22009-03-24 10:24:20 -04002131 wait_for_writer(trans, log_root_tree);
2132
2133 /*
2134 * now that we've moved on to the tree of log tree roots,
2135 * check the full commit flag again
2136 */
2137 if (root->fs_info->last_trans_log_full_commit == trans->transid) {
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002138 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
Chris Mason12fcfd22009-03-24 10:24:20 -04002139 mutex_unlock(&log_root_tree->log_mutex);
2140 ret = -EAGAIN;
2141 goto out_wake_log_root;
2142 }
Yan Zheng7237f182009-01-21 12:54:03 -05002143
2144 ret = btrfs_write_and_wait_marked_extents(log_root_tree,
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002145 &log_root_tree->dirty_log_pages,
2146 EXTENT_DIRTY | EXTENT_NEW);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002147 if (ret) {
2148 btrfs_abort_transaction(trans, root, ret);
2149 mutex_unlock(&log_root_tree->log_mutex);
2150 goto out_wake_log_root;
2151 }
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002152 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
Chris Masone02119d2008-09-05 16:13:11 -04002153
David Sterba6c417612011-04-13 15:41:04 +02002154 btrfs_set_super_log_root(root->fs_info->super_for_commit,
Yan Zheng7237f182009-01-21 12:54:03 -05002155 log_root_tree->node->start);
David Sterba6c417612011-04-13 15:41:04 +02002156 btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
Yan Zheng7237f182009-01-21 12:54:03 -05002157 btrfs_header_level(log_root_tree->node));
Chris Masone02119d2008-09-05 16:13:11 -04002158
Yan Zheng7237f182009-01-21 12:54:03 -05002159 log_root_tree->log_batch = 0;
2160 log_root_tree->log_transid++;
Chris Masone02119d2008-09-05 16:13:11 -04002161 smp_mb();
Yan Zheng7237f182009-01-21 12:54:03 -05002162
2163 mutex_unlock(&log_root_tree->log_mutex);
2164
2165 /*
2166 * nobody else is going to jump in and write the the ctree
2167 * super here because the log_commit atomic below is protecting
2168 * us. We must be called with a transaction handle pinning
2169 * the running transaction open, so a full commit can't hop
2170 * in and cause problems either.
2171 */
Arne Jansena2de7332011-03-08 14:14:00 +01002172 btrfs_scrub_pause_super(root);
Chris Mason47226072009-10-13 12:55:09 -04002173 write_ctree_super(trans, root->fs_info->tree_root, 1);
Arne Jansena2de7332011-03-08 14:14:00 +01002174 btrfs_scrub_continue_super(root);
Chris Mason12fcfd22009-03-24 10:24:20 -04002175 ret = 0;
Yan Zheng7237f182009-01-21 12:54:03 -05002176
Chris Mason257c62e2009-10-13 13:21:08 -04002177 mutex_lock(&root->log_mutex);
2178 if (root->last_log_commit < log_transid)
2179 root->last_log_commit = log_transid;
2180 mutex_unlock(&root->log_mutex);
2181
Chris Mason12fcfd22009-03-24 10:24:20 -04002182out_wake_log_root:
Yan Zheng7237f182009-01-21 12:54:03 -05002183 atomic_set(&log_root_tree->log_commit[index2], 0);
2184 smp_mb();
2185 if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
2186 wake_up(&log_root_tree->log_commit_wait[index2]);
Chris Masone02119d2008-09-05 16:13:11 -04002187out:
Yan Zheng7237f182009-01-21 12:54:03 -05002188 atomic_set(&root->log_commit[index1], 0);
2189 smp_mb();
2190 if (waitqueue_active(&root->log_commit_wait[index1]))
2191 wake_up(&root->log_commit_wait[index1]);
Chris Masonb31eabd2011-01-31 16:48:24 -05002192 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04002193}
2194
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002195static void free_log_tree(struct btrfs_trans_handle *trans,
2196 struct btrfs_root *log)
Chris Masone02119d2008-09-05 16:13:11 -04002197{
2198 int ret;
Chris Masond0c803c2008-09-11 16:17:57 -04002199 u64 start;
2200 u64 end;
Chris Masone02119d2008-09-05 16:13:11 -04002201 struct walk_control wc = {
2202 .free = 1,
2203 .process_func = process_one_buffer
2204 };
2205
Chris Masone02119d2008-09-05 16:13:11 -04002206 ret = walk_log_tree(trans, log, &wc);
2207 BUG_ON(ret);
2208
Chris Masond3977122009-01-05 21:25:51 -05002209 while (1) {
Chris Masond0c803c2008-09-11 16:17:57 -04002210 ret = find_first_extent_bit(&log->dirty_log_pages,
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002211 0, &start, &end, EXTENT_DIRTY | EXTENT_NEW);
Chris Masond0c803c2008-09-11 16:17:57 -04002212 if (ret)
2213 break;
2214
Yan, Zheng8cef4e12009-11-12 09:33:26 +00002215 clear_extent_bits(&log->dirty_log_pages, start, end,
2216 EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS);
Chris Masond0c803c2008-09-11 16:17:57 -04002217 }
2218
Yan Zheng7237f182009-01-21 12:54:03 -05002219 free_extent_buffer(log->node);
2220 kfree(log);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002221}
2222
2223/*
2224 * free all the extents used by the tree log. This should be called
2225 * at commit time of the full transaction
2226 */
2227int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
2228{
2229 if (root->log_root) {
2230 free_log_tree(trans, root->log_root);
2231 root->log_root = NULL;
2232 }
2233 return 0;
2234}
2235
2236int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
2237 struct btrfs_fs_info *fs_info)
2238{
2239 if (fs_info->log_root_tree) {
2240 free_log_tree(trans, fs_info->log_root_tree);
2241 fs_info->log_root_tree = NULL;
2242 }
Chris Masone02119d2008-09-05 16:13:11 -04002243 return 0;
2244}
2245
2246/*
Chris Masone02119d2008-09-05 16:13:11 -04002247 * If both a file and directory are logged, and unlinks or renames are
2248 * mixed in, we have a few interesting corners:
2249 *
2250 * create file X in dir Y
2251 * link file X to X.link in dir Y
2252 * fsync file X
2253 * unlink file X but leave X.link
2254 * fsync dir Y
2255 *
2256 * After a crash we would expect only X.link to exist. But file X
2257 * didn't get fsync'd again so the log has back refs for X and X.link.
2258 *
2259 * We solve this by removing directory entries and inode backrefs from the
2260 * log when a file that was logged in the current transaction is
2261 * unlinked. Any later fsync will include the updated log entries, and
2262 * we'll be able to reconstruct the proper directory items from backrefs.
2263 *
2264 * This optimizations allows us to avoid relogging the entire inode
2265 * or the entire directory.
2266 */
2267int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
2268 struct btrfs_root *root,
2269 const char *name, int name_len,
2270 struct inode *dir, u64 index)
2271{
2272 struct btrfs_root *log;
2273 struct btrfs_dir_item *di;
2274 struct btrfs_path *path;
2275 int ret;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002276 int err = 0;
Chris Masone02119d2008-09-05 16:13:11 -04002277 int bytes_del = 0;
Li Zefan33345d012011-04-20 10:31:50 +08002278 u64 dir_ino = btrfs_ino(dir);
Chris Masone02119d2008-09-05 16:13:11 -04002279
Chris Mason3a5f1d42008-09-11 15:53:37 -04002280 if (BTRFS_I(dir)->logged_trans < trans->transid)
2281 return 0;
2282
Chris Masone02119d2008-09-05 16:13:11 -04002283 ret = join_running_log_trans(root);
2284 if (ret)
2285 return 0;
2286
2287 mutex_lock(&BTRFS_I(dir)->log_mutex);
2288
2289 log = root->log_root;
2290 path = btrfs_alloc_path();
Tsutomu Itoha62f44a2011-04-25 19:43:51 -04002291 if (!path) {
2292 err = -ENOMEM;
2293 goto out_unlock;
2294 }
liubo2a29edc2011-01-26 06:22:08 +00002295
Li Zefan33345d012011-04-20 10:31:50 +08002296 di = btrfs_lookup_dir_item(trans, log, path, dir_ino,
Chris Masone02119d2008-09-05 16:13:11 -04002297 name, name_len, -1);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002298 if (IS_ERR(di)) {
2299 err = PTR_ERR(di);
2300 goto fail;
2301 }
2302 if (di) {
Chris Masone02119d2008-09-05 16:13:11 -04002303 ret = btrfs_delete_one_dir_name(trans, log, path, di);
2304 bytes_del += name_len;
2305 BUG_ON(ret);
2306 }
David Sterbab3b4aa72011-04-21 01:20:15 +02002307 btrfs_release_path(path);
Li Zefan33345d012011-04-20 10:31:50 +08002308 di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
Chris Masone02119d2008-09-05 16:13:11 -04002309 index, name, name_len, -1);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002310 if (IS_ERR(di)) {
2311 err = PTR_ERR(di);
2312 goto fail;
2313 }
2314 if (di) {
Chris Masone02119d2008-09-05 16:13:11 -04002315 ret = btrfs_delete_one_dir_name(trans, log, path, di);
2316 bytes_del += name_len;
2317 BUG_ON(ret);
2318 }
2319
2320 /* update the directory size in the log to reflect the names
2321 * we have removed
2322 */
2323 if (bytes_del) {
2324 struct btrfs_key key;
2325
Li Zefan33345d012011-04-20 10:31:50 +08002326 key.objectid = dir_ino;
Chris Masone02119d2008-09-05 16:13:11 -04002327 key.offset = 0;
2328 key.type = BTRFS_INODE_ITEM_KEY;
David Sterbab3b4aa72011-04-21 01:20:15 +02002329 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002330
2331 ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002332 if (ret < 0) {
2333 err = ret;
2334 goto fail;
2335 }
Chris Masone02119d2008-09-05 16:13:11 -04002336 if (ret == 0) {
2337 struct btrfs_inode_item *item;
2338 u64 i_size;
2339
2340 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2341 struct btrfs_inode_item);
2342 i_size = btrfs_inode_size(path->nodes[0], item);
2343 if (i_size > bytes_del)
2344 i_size -= bytes_del;
2345 else
2346 i_size = 0;
2347 btrfs_set_inode_size(path->nodes[0], item, i_size);
2348 btrfs_mark_buffer_dirty(path->nodes[0]);
2349 } else
2350 ret = 0;
David Sterbab3b4aa72011-04-21 01:20:15 +02002351 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002352 }
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002353fail:
Chris Masone02119d2008-09-05 16:13:11 -04002354 btrfs_free_path(path);
Tsutomu Itoha62f44a2011-04-25 19:43:51 -04002355out_unlock:
Chris Masone02119d2008-09-05 16:13:11 -04002356 mutex_unlock(&BTRFS_I(dir)->log_mutex);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002357 if (ret == -ENOSPC) {
2358 root->fs_info->last_trans_log_full_commit = trans->transid;
2359 ret = 0;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002360 } else if (ret < 0)
2361 btrfs_abort_transaction(trans, root, ret);
2362
Chris Mason12fcfd22009-03-24 10:24:20 -04002363 btrfs_end_log_trans(root);
Chris Masone02119d2008-09-05 16:13:11 -04002364
Andi Kleen411fc6b2010-10-29 15:14:31 -04002365 return err;
Chris Masone02119d2008-09-05 16:13:11 -04002366}
2367
2368/* see comments for btrfs_del_dir_entries_in_log */
2369int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
2370 struct btrfs_root *root,
2371 const char *name, int name_len,
2372 struct inode *inode, u64 dirid)
2373{
2374 struct btrfs_root *log;
2375 u64 index;
2376 int ret;
2377
Chris Mason3a5f1d42008-09-11 15:53:37 -04002378 if (BTRFS_I(inode)->logged_trans < trans->transid)
2379 return 0;
2380
Chris Masone02119d2008-09-05 16:13:11 -04002381 ret = join_running_log_trans(root);
2382 if (ret)
2383 return 0;
2384 log = root->log_root;
2385 mutex_lock(&BTRFS_I(inode)->log_mutex);
2386
Li Zefan33345d012011-04-20 10:31:50 +08002387 ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
Chris Masone02119d2008-09-05 16:13:11 -04002388 dirid, &index);
2389 mutex_unlock(&BTRFS_I(inode)->log_mutex);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002390 if (ret == -ENOSPC) {
2391 root->fs_info->last_trans_log_full_commit = trans->transid;
2392 ret = 0;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002393 } else if (ret < 0 && ret != -ENOENT)
2394 btrfs_abort_transaction(trans, root, ret);
Chris Mason12fcfd22009-03-24 10:24:20 -04002395 btrfs_end_log_trans(root);
Chris Masone02119d2008-09-05 16:13:11 -04002396
Chris Masone02119d2008-09-05 16:13:11 -04002397 return ret;
2398}
2399
2400/*
2401 * creates a range item in the log for 'dirid'. first_offset and
2402 * last_offset tell us which parts of the key space the log should
2403 * be considered authoritative for.
2404 */
2405static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
2406 struct btrfs_root *log,
2407 struct btrfs_path *path,
2408 int key_type, u64 dirid,
2409 u64 first_offset, u64 last_offset)
2410{
2411 int ret;
2412 struct btrfs_key key;
2413 struct btrfs_dir_log_item *item;
2414
2415 key.objectid = dirid;
2416 key.offset = first_offset;
2417 if (key_type == BTRFS_DIR_ITEM_KEY)
2418 key.type = BTRFS_DIR_LOG_ITEM_KEY;
2419 else
2420 key.type = BTRFS_DIR_LOG_INDEX_KEY;
2421 ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002422 if (ret)
2423 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04002424
2425 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2426 struct btrfs_dir_log_item);
2427 btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
2428 btrfs_mark_buffer_dirty(path->nodes[0]);
David Sterbab3b4aa72011-04-21 01:20:15 +02002429 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002430 return 0;
2431}
2432
2433/*
2434 * log all the items included in the current transaction for a given
2435 * directory. This also creates the range items in the log tree required
2436 * to replay anything deleted before the fsync
2437 */
2438static noinline int log_dir_items(struct btrfs_trans_handle *trans,
2439 struct btrfs_root *root, struct inode *inode,
2440 struct btrfs_path *path,
2441 struct btrfs_path *dst_path, int key_type,
2442 u64 min_offset, u64 *last_offset_ret)
2443{
2444 struct btrfs_key min_key;
2445 struct btrfs_key max_key;
2446 struct btrfs_root *log = root->log_root;
2447 struct extent_buffer *src;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002448 int err = 0;
Chris Masone02119d2008-09-05 16:13:11 -04002449 int ret;
2450 int i;
2451 int nritems;
2452 u64 first_offset = min_offset;
2453 u64 last_offset = (u64)-1;
Li Zefan33345d012011-04-20 10:31:50 +08002454 u64 ino = btrfs_ino(inode);
Chris Masone02119d2008-09-05 16:13:11 -04002455
2456 log = root->log_root;
Li Zefan33345d012011-04-20 10:31:50 +08002457 max_key.objectid = ino;
Chris Masone02119d2008-09-05 16:13:11 -04002458 max_key.offset = (u64)-1;
2459 max_key.type = key_type;
2460
Li Zefan33345d012011-04-20 10:31:50 +08002461 min_key.objectid = ino;
Chris Masone02119d2008-09-05 16:13:11 -04002462 min_key.type = key_type;
2463 min_key.offset = min_offset;
2464
2465 path->keep_locks = 1;
2466
2467 ret = btrfs_search_forward(root, &min_key, &max_key,
2468 path, 0, trans->transid);
2469
2470 /*
2471 * we didn't find anything from this transaction, see if there
2472 * is anything at all
2473 */
Li Zefan33345d012011-04-20 10:31:50 +08002474 if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) {
2475 min_key.objectid = ino;
Chris Masone02119d2008-09-05 16:13:11 -04002476 min_key.type = key_type;
2477 min_key.offset = (u64)-1;
David Sterbab3b4aa72011-04-21 01:20:15 +02002478 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002479 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
2480 if (ret < 0) {
David Sterbab3b4aa72011-04-21 01:20:15 +02002481 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002482 return ret;
2483 }
Li Zefan33345d012011-04-20 10:31:50 +08002484 ret = btrfs_previous_item(root, path, ino, key_type);
Chris Masone02119d2008-09-05 16:13:11 -04002485
2486 /* if ret == 0 there are items for this type,
2487 * create a range to tell us the last key of this type.
2488 * otherwise, there are no items in this directory after
2489 * *min_offset, and we create a range to indicate that.
2490 */
2491 if (ret == 0) {
2492 struct btrfs_key tmp;
2493 btrfs_item_key_to_cpu(path->nodes[0], &tmp,
2494 path->slots[0]);
Chris Masond3977122009-01-05 21:25:51 -05002495 if (key_type == tmp.type)
Chris Masone02119d2008-09-05 16:13:11 -04002496 first_offset = max(min_offset, tmp.offset) + 1;
Chris Masone02119d2008-09-05 16:13:11 -04002497 }
2498 goto done;
2499 }
2500
2501 /* go backward to find any previous key */
Li Zefan33345d012011-04-20 10:31:50 +08002502 ret = btrfs_previous_item(root, path, ino, key_type);
Chris Masone02119d2008-09-05 16:13:11 -04002503 if (ret == 0) {
2504 struct btrfs_key tmp;
2505 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
2506 if (key_type == tmp.type) {
2507 first_offset = tmp.offset;
2508 ret = overwrite_item(trans, log, dst_path,
2509 path->nodes[0], path->slots[0],
2510 &tmp);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002511 if (ret) {
2512 err = ret;
2513 goto done;
2514 }
Chris Masone02119d2008-09-05 16:13:11 -04002515 }
2516 }
David Sterbab3b4aa72011-04-21 01:20:15 +02002517 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002518
2519 /* find the first key from this transaction again */
2520 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
2521 if (ret != 0) {
2522 WARN_ON(1);
2523 goto done;
2524 }
2525
2526 /*
2527 * we have a block from this transaction, log every item in it
2528 * from our directory
2529 */
Chris Masond3977122009-01-05 21:25:51 -05002530 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04002531 struct btrfs_key tmp;
2532 src = path->nodes[0];
2533 nritems = btrfs_header_nritems(src);
2534 for (i = path->slots[0]; i < nritems; i++) {
2535 btrfs_item_key_to_cpu(src, &min_key, i);
2536
Li Zefan33345d012011-04-20 10:31:50 +08002537 if (min_key.objectid != ino || min_key.type != key_type)
Chris Masone02119d2008-09-05 16:13:11 -04002538 goto done;
2539 ret = overwrite_item(trans, log, dst_path, src, i,
2540 &min_key);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002541 if (ret) {
2542 err = ret;
2543 goto done;
2544 }
Chris Masone02119d2008-09-05 16:13:11 -04002545 }
2546 path->slots[0] = nritems;
2547
2548 /*
2549 * look ahead to the next item and see if it is also
2550 * from this directory and from this transaction
2551 */
2552 ret = btrfs_next_leaf(root, path);
2553 if (ret == 1) {
2554 last_offset = (u64)-1;
2555 goto done;
2556 }
2557 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
Li Zefan33345d012011-04-20 10:31:50 +08002558 if (tmp.objectid != ino || tmp.type != key_type) {
Chris Masone02119d2008-09-05 16:13:11 -04002559 last_offset = (u64)-1;
2560 goto done;
2561 }
2562 if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
2563 ret = overwrite_item(trans, log, dst_path,
2564 path->nodes[0], path->slots[0],
2565 &tmp);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002566 if (ret)
2567 err = ret;
2568 else
2569 last_offset = tmp.offset;
Chris Masone02119d2008-09-05 16:13:11 -04002570 goto done;
2571 }
2572 }
2573done:
David Sterbab3b4aa72011-04-21 01:20:15 +02002574 btrfs_release_path(path);
2575 btrfs_release_path(dst_path);
Chris Masone02119d2008-09-05 16:13:11 -04002576
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002577 if (err == 0) {
2578 *last_offset_ret = last_offset;
2579 /*
2580 * insert the log range keys to indicate where the log
2581 * is valid
2582 */
2583 ret = insert_dir_log_key(trans, log, path, key_type,
Li Zefan33345d012011-04-20 10:31:50 +08002584 ino, first_offset, last_offset);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002585 if (ret)
2586 err = ret;
2587 }
2588 return err;
Chris Masone02119d2008-09-05 16:13:11 -04002589}
2590
2591/*
2592 * logging directories is very similar to logging inodes, We find all the items
2593 * from the current transaction and write them to the log.
2594 *
2595 * The recovery code scans the directory in the subvolume, and if it finds a
2596 * key in the range logged that is not present in the log tree, then it means
2597 * that dir entry was unlinked during the transaction.
2598 *
2599 * In order for that scan to work, we must include one key smaller than
2600 * the smallest logged by this transaction and one key larger than the largest
2601 * key logged by this transaction.
2602 */
2603static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
2604 struct btrfs_root *root, struct inode *inode,
2605 struct btrfs_path *path,
2606 struct btrfs_path *dst_path)
2607{
2608 u64 min_key;
2609 u64 max_key;
2610 int ret;
2611 int key_type = BTRFS_DIR_ITEM_KEY;
2612
2613again:
2614 min_key = 0;
2615 max_key = 0;
Chris Masond3977122009-01-05 21:25:51 -05002616 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04002617 ret = log_dir_items(trans, root, inode, path,
2618 dst_path, key_type, min_key,
2619 &max_key);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002620 if (ret)
2621 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04002622 if (max_key == (u64)-1)
2623 break;
2624 min_key = max_key + 1;
2625 }
2626
2627 if (key_type == BTRFS_DIR_ITEM_KEY) {
2628 key_type = BTRFS_DIR_INDEX_KEY;
2629 goto again;
2630 }
2631 return 0;
2632}
2633
2634/*
2635 * a helper function to drop items from the log before we relog an
2636 * inode. max_key_type indicates the highest item type to remove.
2637 * This cannot be run for file data extents because it does not
2638 * free the extents they point to.
2639 */
2640static int drop_objectid_items(struct btrfs_trans_handle *trans,
2641 struct btrfs_root *log,
2642 struct btrfs_path *path,
2643 u64 objectid, int max_key_type)
2644{
2645 int ret;
2646 struct btrfs_key key;
2647 struct btrfs_key found_key;
2648
2649 key.objectid = objectid;
2650 key.type = max_key_type;
2651 key.offset = (u64)-1;
2652
Chris Masond3977122009-01-05 21:25:51 -05002653 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04002654 ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002655 BUG_ON(ret == 0);
2656 if (ret < 0)
Chris Masone02119d2008-09-05 16:13:11 -04002657 break;
2658
2659 if (path->slots[0] == 0)
2660 break;
2661
2662 path->slots[0]--;
2663 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2664 path->slots[0]);
2665
2666 if (found_key.objectid != objectid)
2667 break;
2668
2669 ret = btrfs_del_item(trans, log, path);
Tsutomu Itoh65a246c2011-05-19 04:37:44 +00002670 if (ret)
2671 break;
David Sterbab3b4aa72011-04-21 01:20:15 +02002672 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04002673 }
David Sterbab3b4aa72011-04-21 01:20:15 +02002674 btrfs_release_path(path);
Josef Bacik5bdbeb22012-05-29 16:59:49 -04002675 if (ret > 0)
2676 ret = 0;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002677 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04002678}
2679
Chris Mason31ff1cd2008-09-11 16:17:57 -04002680static noinline int copy_items(struct btrfs_trans_handle *trans,
Liu Bod2794402012-08-29 01:07:56 -06002681 struct inode *inode,
Chris Mason31ff1cd2008-09-11 16:17:57 -04002682 struct btrfs_path *dst_path,
2683 struct extent_buffer *src,
2684 int start_slot, int nr, int inode_only)
2685{
2686 unsigned long src_offset;
2687 unsigned long dst_offset;
Liu Bod2794402012-08-29 01:07:56 -06002688 struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
Chris Mason31ff1cd2008-09-11 16:17:57 -04002689 struct btrfs_file_extent_item *extent;
2690 struct btrfs_inode_item *inode_item;
2691 int ret;
2692 struct btrfs_key *ins_keys;
2693 u32 *ins_sizes;
2694 char *ins_data;
2695 int i;
Chris Masond20f7042008-12-08 16:58:54 -05002696 struct list_head ordered_sums;
Liu Bod2794402012-08-29 01:07:56 -06002697 int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
Chris Masond20f7042008-12-08 16:58:54 -05002698
2699 INIT_LIST_HEAD(&ordered_sums);
Chris Mason31ff1cd2008-09-11 16:17:57 -04002700
2701 ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
2702 nr * sizeof(u32), GFP_NOFS);
liubo2a29edc2011-01-26 06:22:08 +00002703 if (!ins_data)
2704 return -ENOMEM;
2705
Chris Mason31ff1cd2008-09-11 16:17:57 -04002706 ins_sizes = (u32 *)ins_data;
2707 ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));
2708
2709 for (i = 0; i < nr; i++) {
2710 ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot);
2711 btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot);
2712 }
2713 ret = btrfs_insert_empty_items(trans, log, dst_path,
2714 ins_keys, ins_sizes, nr);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002715 if (ret) {
2716 kfree(ins_data);
2717 return ret;
2718 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04002719
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002720 for (i = 0; i < nr; i++, dst_path->slots[0]++) {
Chris Mason31ff1cd2008-09-11 16:17:57 -04002721 dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0],
2722 dst_path->slots[0]);
2723
2724 src_offset = btrfs_item_ptr_offset(src, start_slot + i);
2725
2726 copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
2727 src_offset, ins_sizes[i]);
2728
2729 if (inode_only == LOG_INODE_EXISTS &&
2730 ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
2731 inode_item = btrfs_item_ptr(dst_path->nodes[0],
2732 dst_path->slots[0],
2733 struct btrfs_inode_item);
2734 btrfs_set_inode_size(dst_path->nodes[0], inode_item, 0);
2735
2736 /* set the generation to zero so the recover code
2737 * can tell the difference between an logging
2738 * just to say 'this inode exists' and a logging
2739 * to say 'update this inode with these values'
2740 */
2741 btrfs_set_inode_generation(dst_path->nodes[0],
2742 inode_item, 0);
2743 }
2744 /* take a reference on file data extents so that truncates
2745 * or deletes of this inode don't have to relog the inode
2746 * again
2747 */
Liu Bod2794402012-08-29 01:07:56 -06002748 if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY &&
2749 !skip_csum) {
Chris Mason31ff1cd2008-09-11 16:17:57 -04002750 int found_type;
2751 extent = btrfs_item_ptr(src, start_slot + i,
2752 struct btrfs_file_extent_item);
2753
liubo8e531cd2011-05-06 10:36:09 +08002754 if (btrfs_file_extent_generation(src, extent) < trans->transid)
2755 continue;
2756
Chris Mason31ff1cd2008-09-11 16:17:57 -04002757 found_type = btrfs_file_extent_type(src, extent);
Yan Zhengd899e052008-10-30 14:25:28 -04002758 if (found_type == BTRFS_FILE_EXTENT_REG ||
2759 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002760 u64 ds, dl, cs, cl;
2761 ds = btrfs_file_extent_disk_bytenr(src,
2762 extent);
2763 /* ds == 0 is a hole */
2764 if (ds == 0)
2765 continue;
2766
2767 dl = btrfs_file_extent_disk_num_bytes(src,
2768 extent);
2769 cs = btrfs_file_extent_offset(src, extent);
2770 cl = btrfs_file_extent_num_bytes(src,
Joe Perchesa419aef2009-08-18 11:18:35 -07002771 extent);
Chris Mason580afd72008-12-08 19:15:39 -05002772 if (btrfs_file_extent_compression(src,
2773 extent)) {
2774 cs = 0;
2775 cl = dl;
2776 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002777
2778 ret = btrfs_lookup_csums_range(
2779 log->fs_info->csum_root,
2780 ds + cs, ds + cs + cl - 1,
Arne Jansena2de7332011-03-08 14:14:00 +01002781 &ordered_sums, 0);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002782 BUG_ON(ret);
Chris Mason31ff1cd2008-09-11 16:17:57 -04002783 }
2784 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04002785 }
2786
2787 btrfs_mark_buffer_dirty(dst_path->nodes[0]);
David Sterbab3b4aa72011-04-21 01:20:15 +02002788 btrfs_release_path(dst_path);
Chris Mason31ff1cd2008-09-11 16:17:57 -04002789 kfree(ins_data);
Chris Masond20f7042008-12-08 16:58:54 -05002790
2791 /*
2792 * we have to do this after the loop above to avoid changing the
2793 * log tree while trying to change the log tree.
2794 */
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002795 ret = 0;
Chris Masond3977122009-01-05 21:25:51 -05002796 while (!list_empty(&ordered_sums)) {
Chris Masond20f7042008-12-08 16:58:54 -05002797 struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
2798 struct btrfs_ordered_sum,
2799 list);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002800 if (!ret)
2801 ret = btrfs_csum_file_blocks(trans, log, sums);
Chris Masond20f7042008-12-08 16:58:54 -05002802 list_del(&sums->list);
2803 kfree(sums);
2804 }
Yan, Zheng4a500fd2010-05-16 10:49:59 -04002805 return ret;
Chris Mason31ff1cd2008-09-11 16:17:57 -04002806}
2807
Josef Bacik5dc562c2012-08-17 13:14:17 -04002808static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
2809{
2810 struct extent_map *em1, *em2;
2811
2812 em1 = list_entry(a, struct extent_map, list);
2813 em2 = list_entry(b, struct extent_map, list);
2814
2815 if (em1->start < em2->start)
2816 return -1;
2817 else if (em1->start > em2->start)
2818 return 1;
2819 return 0;
2820}
2821
2822struct log_args {
2823 struct extent_buffer *src;
2824 u64 next_offset;
2825 int start_slot;
2826 int nr;
2827};
2828
2829static int log_one_extent(struct btrfs_trans_handle *trans,
2830 struct inode *inode, struct btrfs_root *root,
2831 struct extent_map *em, struct btrfs_path *path,
2832 struct btrfs_path *dst_path, struct log_args *args)
2833{
2834 struct btrfs_root *log = root->log_root;
2835 struct btrfs_file_extent_item *fi;
2836 struct btrfs_key key;
Liu Bo4e2f84e2012-08-27 10:52:20 -06002837 u64 start = em->mod_start;
2838 u64 len = em->mod_len;
Josef Bacik5dc562c2012-08-17 13:14:17 -04002839 u64 num_bytes;
2840 int nritems;
2841 int ret;
2842
2843 if (BTRFS_I(inode)->logged_trans == trans->transid) {
Josef Bacik5dc562c2012-08-17 13:14:17 -04002844 ret = __btrfs_drop_extents(trans, log, inode, dst_path, start,
Josef Bacik2aaa6652012-08-29 14:27:18 -04002845 start + len, NULL, 0);
Josef Bacik5dc562c2012-08-17 13:14:17 -04002846 if (ret)
2847 return ret;
2848 }
2849
2850 while (len) {
2851 if (args->nr)
2852 goto next_slot;
2853 key.objectid = btrfs_ino(inode);
2854 key.type = BTRFS_EXTENT_DATA_KEY;
2855 key.offset = start;
2856
2857 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2858 if (ret < 0)
2859 return ret;
2860 if (ret) {
2861 /*
2862 * This shouldn't happen, but it might so warn and
2863 * return an error.
2864 */
2865 WARN_ON(1);
2866 return -ENOENT;
2867 }
2868 args->src = path->nodes[0];
2869next_slot:
2870 fi = btrfs_item_ptr(args->src, path->slots[0],
2871 struct btrfs_file_extent_item);
2872 if (args->nr &&
2873 args->start_slot + args->nr == path->slots[0]) {
2874 args->nr++;
2875 } else if (args->nr) {
Liu Bod2794402012-08-29 01:07:56 -06002876 ret = copy_items(trans, inode, dst_path, args->src,
Josef Bacik5dc562c2012-08-17 13:14:17 -04002877 args->start_slot, args->nr,
2878 LOG_INODE_ALL);
2879 if (ret)
2880 return ret;
2881 args->nr = 1;
2882 args->start_slot = path->slots[0];
2883 } else if (!args->nr) {
2884 args->nr = 1;
2885 args->start_slot = path->slots[0];
2886 }
2887 nritems = btrfs_header_nritems(path->nodes[0]);
2888 path->slots[0]++;
2889 num_bytes = btrfs_file_extent_num_bytes(args->src, fi);
2890 if (len < num_bytes) {
2891 /* I _think_ this is ok, envision we write to a
2892 * preallocated space that is adjacent to a previously
2893 * written preallocated space that gets merged when we
2894 * mark this preallocated space written. If we do not
2895 * have the adjacent extent in cache then when we copy
2896 * this extent it could end up being larger than our EM
2897 * thinks it is, which is a-ok, so just set len to 0.
2898 */
2899 len = 0;
2900 } else {
2901 len -= num_bytes;
2902 }
2903 start += btrfs_file_extent_num_bytes(args->src, fi);
2904 args->next_offset = start;
2905
2906 if (path->slots[0] < nritems) {
2907 if (len)
2908 goto next_slot;
2909 break;
2910 }
2911
2912 if (args->nr) {
Liu Bod2794402012-08-29 01:07:56 -06002913 ret = copy_items(trans, inode, dst_path, args->src,
Josef Bacik5dc562c2012-08-17 13:14:17 -04002914 args->start_slot, args->nr,
2915 LOG_INODE_ALL);
2916 if (ret)
2917 return ret;
2918 args->nr = 0;
2919 btrfs_release_path(path);
2920 }
2921 }
2922
2923 return 0;
2924}
2925
2926static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
2927 struct btrfs_root *root,
2928 struct inode *inode,
2929 struct btrfs_path *path,
2930 struct btrfs_path *dst_path)
2931{
2932 struct log_args args;
Josef Bacik5dc562c2012-08-17 13:14:17 -04002933 struct extent_map *em, *n;
2934 struct list_head extents;
2935 struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
2936 u64 test_gen;
2937 int ret = 0;
2938
2939 INIT_LIST_HEAD(&extents);
2940
2941 memset(&args, 0, sizeof(args));
2942
2943 write_lock(&tree->lock);
2944 test_gen = root->fs_info->last_trans_committed;
2945
2946 list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
2947 list_del_init(&em->list);
2948 if (em->generation <= test_gen)
2949 continue;
2950 list_add_tail(&em->list, &extents);
2951 }
2952
2953 list_sort(NULL, &extents, extent_cmp);
2954
2955 while (!list_empty(&extents)) {
2956 em = list_entry(extents.next, struct extent_map, list);
2957
2958 list_del_init(&em->list);
2959
2960 /*
2961 * If we had an error we just need to delete everybody from our
2962 * private list.
2963 */
2964 if (ret)
2965 continue;
2966
2967 /*
2968 * If the previous EM and the last extent we left off on aren't
2969 * sequential then we need to copy the items we have and redo
2970 * our search
2971 */
Liu Bo4e2f84e2012-08-27 10:52:20 -06002972 if (args.nr && em->mod_start != args.next_offset) {
Liu Bod2794402012-08-29 01:07:56 -06002973 ret = copy_items(trans, inode, dst_path, args.src,
Josef Bacik5dc562c2012-08-17 13:14:17 -04002974 args.start_slot, args.nr,
2975 LOG_INODE_ALL);
2976 if (ret)
2977 continue;
2978 btrfs_release_path(path);
2979 args.nr = 0;
2980 }
2981
2982 ret = log_one_extent(trans, inode, root, em, path, dst_path, &args);
2983 }
2984
2985 if (!ret && args.nr)
Liu Bod2794402012-08-29 01:07:56 -06002986 ret = copy_items(trans, inode, dst_path, args.src,
Josef Bacik5dc562c2012-08-17 13:14:17 -04002987 args.start_slot, args.nr, LOG_INODE_ALL);
2988 btrfs_release_path(path);
2989 WARN_ON(!list_empty(&extents));
2990 write_unlock(&tree->lock);
2991 return ret;
2992}
2993
Chris Masone02119d2008-09-05 16:13:11 -04002994/* log a single inode in the tree log.
2995 * At least one parent directory for this inode must exist in the tree
2996 * or be logged already.
2997 *
2998 * Any items from this inode changed by the current transaction are copied
2999 * to the log tree. An extra reference is taken on any extents in this
3000 * file, allowing us to avoid a whole pile of corner cases around logging
3001 * blocks that have been removed from the tree.
3002 *
3003 * See LOG_INODE_ALL and related defines for a description of what inode_only
3004 * does.
3005 *
3006 * This handles both files and directories.
3007 */
Chris Mason12fcfd22009-03-24 10:24:20 -04003008static int btrfs_log_inode(struct btrfs_trans_handle *trans,
Chris Masone02119d2008-09-05 16:13:11 -04003009 struct btrfs_root *root, struct inode *inode,
3010 int inode_only)
3011{
3012 struct btrfs_path *path;
3013 struct btrfs_path *dst_path;
3014 struct btrfs_key min_key;
3015 struct btrfs_key max_key;
3016 struct btrfs_root *log = root->log_root;
Chris Mason31ff1cd2008-09-11 16:17:57 -04003017 struct extent_buffer *src = NULL;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003018 int err = 0;
Chris Masone02119d2008-09-05 16:13:11 -04003019 int ret;
Chris Mason3a5f1d42008-09-11 15:53:37 -04003020 int nritems;
Chris Mason31ff1cd2008-09-11 16:17:57 -04003021 int ins_start_slot = 0;
3022 int ins_nr;
Josef Bacik5dc562c2012-08-17 13:14:17 -04003023 bool fast_search = false;
Li Zefan33345d012011-04-20 10:31:50 +08003024 u64 ino = btrfs_ino(inode);
Chris Masone02119d2008-09-05 16:13:11 -04003025
3026 log = root->log_root;
3027
3028 path = btrfs_alloc_path();
Tsutomu Itoh5df67082011-02-01 09:17:35 +00003029 if (!path)
3030 return -ENOMEM;
Chris Masone02119d2008-09-05 16:13:11 -04003031 dst_path = btrfs_alloc_path();
Tsutomu Itoh5df67082011-02-01 09:17:35 +00003032 if (!dst_path) {
3033 btrfs_free_path(path);
3034 return -ENOMEM;
3035 }
Chris Masone02119d2008-09-05 16:13:11 -04003036
Li Zefan33345d012011-04-20 10:31:50 +08003037 min_key.objectid = ino;
Chris Masone02119d2008-09-05 16:13:11 -04003038 min_key.type = BTRFS_INODE_ITEM_KEY;
3039 min_key.offset = 0;
3040
Li Zefan33345d012011-04-20 10:31:50 +08003041 max_key.objectid = ino;
Chris Mason12fcfd22009-03-24 10:24:20 -04003042
Chris Mason12fcfd22009-03-24 10:24:20 -04003043
Josef Bacik5dc562c2012-08-17 13:14:17 -04003044 /* today the code can only do partial logging of directories */
Chris Masone02119d2008-09-05 16:13:11 -04003045 if (inode_only == LOG_INODE_EXISTS || S_ISDIR(inode->i_mode))
3046 max_key.type = BTRFS_XATTR_ITEM_KEY;
3047 else
3048 max_key.type = (u8)-1;
3049 max_key.offset = (u64)-1;
3050
Miao Xie16cdcec2011-04-22 18:12:22 +08003051 ret = btrfs_commit_inode_delayed_items(trans, inode);
3052 if (ret) {
3053 btrfs_free_path(path);
3054 btrfs_free_path(dst_path);
3055 return ret;
3056 }
3057
Chris Masone02119d2008-09-05 16:13:11 -04003058 mutex_lock(&BTRFS_I(inode)->log_mutex);
3059
3060 /*
3061 * a brute force approach to making sure we get the most uptodate
3062 * copies of everything.
3063 */
3064 if (S_ISDIR(inode->i_mode)) {
3065 int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;
3066
3067 if (inode_only == LOG_INODE_EXISTS)
3068 max_key_type = BTRFS_XATTR_ITEM_KEY;
Li Zefan33345d012011-04-20 10:31:50 +08003069 ret = drop_objectid_items(trans, log, path, ino, max_key_type);
Chris Masone02119d2008-09-05 16:13:11 -04003070 } else {
Josef Bacik5dc562c2012-08-17 13:14:17 -04003071 if (test_and_clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3072 &BTRFS_I(inode)->runtime_flags)) {
3073 ret = btrfs_truncate_inode_items(trans, log,
3074 inode, 0, 0);
3075 } else {
3076 fast_search = true;
3077 max_key.type = BTRFS_XATTR_ITEM_KEY;
3078 ret = drop_objectid_items(trans, log, path, ino,
3079 BTRFS_XATTR_ITEM_KEY);
3080 }
Chris Masone02119d2008-09-05 16:13:11 -04003081 }
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003082 if (ret) {
3083 err = ret;
3084 goto out_unlock;
3085 }
Chris Masone02119d2008-09-05 16:13:11 -04003086 path->keep_locks = 1;
3087
Chris Masond3977122009-01-05 21:25:51 -05003088 while (1) {
Chris Mason31ff1cd2008-09-11 16:17:57 -04003089 ins_nr = 0;
Chris Masone02119d2008-09-05 16:13:11 -04003090 ret = btrfs_search_forward(root, &min_key, &max_key,
3091 path, 0, trans->transid);
3092 if (ret != 0)
3093 break;
Chris Mason3a5f1d42008-09-11 15:53:37 -04003094again:
Chris Mason31ff1cd2008-09-11 16:17:57 -04003095 /* note, ins_nr might be > 0 here, cleanup outside the loop */
Li Zefan33345d012011-04-20 10:31:50 +08003096 if (min_key.objectid != ino)
Chris Masone02119d2008-09-05 16:13:11 -04003097 break;
3098 if (min_key.type > max_key.type)
3099 break;
Chris Mason31ff1cd2008-09-11 16:17:57 -04003100
Chris Masone02119d2008-09-05 16:13:11 -04003101 src = path->nodes[0];
Chris Mason31ff1cd2008-09-11 16:17:57 -04003102 if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
3103 ins_nr++;
3104 goto next_slot;
3105 } else if (!ins_nr) {
3106 ins_start_slot = path->slots[0];
3107 ins_nr = 1;
3108 goto next_slot;
Chris Masone02119d2008-09-05 16:13:11 -04003109 }
3110
Liu Bod2794402012-08-29 01:07:56 -06003111 ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
Chris Mason31ff1cd2008-09-11 16:17:57 -04003112 ins_nr, inode_only);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003113 if (ret) {
3114 err = ret;
3115 goto out_unlock;
3116 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04003117 ins_nr = 1;
3118 ins_start_slot = path->slots[0];
3119next_slot:
Chris Masone02119d2008-09-05 16:13:11 -04003120
Chris Mason3a5f1d42008-09-11 15:53:37 -04003121 nritems = btrfs_header_nritems(path->nodes[0]);
3122 path->slots[0]++;
3123 if (path->slots[0] < nritems) {
3124 btrfs_item_key_to_cpu(path->nodes[0], &min_key,
3125 path->slots[0]);
3126 goto again;
3127 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04003128 if (ins_nr) {
Liu Bod2794402012-08-29 01:07:56 -06003129 ret = copy_items(trans, inode, dst_path, src,
Chris Mason31ff1cd2008-09-11 16:17:57 -04003130 ins_start_slot,
3131 ins_nr, inode_only);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003132 if (ret) {
3133 err = ret;
3134 goto out_unlock;
3135 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04003136 ins_nr = 0;
3137 }
David Sterbab3b4aa72011-04-21 01:20:15 +02003138 btrfs_release_path(path);
Chris Mason3a5f1d42008-09-11 15:53:37 -04003139
Chris Masone02119d2008-09-05 16:13:11 -04003140 if (min_key.offset < (u64)-1)
3141 min_key.offset++;
3142 else if (min_key.type < (u8)-1)
3143 min_key.type++;
3144 else if (min_key.objectid < (u64)-1)
3145 min_key.objectid++;
3146 else
3147 break;
3148 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04003149 if (ins_nr) {
Liu Bod2794402012-08-29 01:07:56 -06003150 ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
Chris Mason31ff1cd2008-09-11 16:17:57 -04003151 ins_nr, inode_only);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003152 if (ret) {
3153 err = ret;
3154 goto out_unlock;
3155 }
Chris Mason31ff1cd2008-09-11 16:17:57 -04003156 ins_nr = 0;
3157 }
Josef Bacik5dc562c2012-08-17 13:14:17 -04003158
3159 if (fast_search) {
3160 btrfs_release_path(path);
3161 btrfs_release_path(dst_path);
3162 ret = btrfs_log_changed_extents(trans, root, inode, path,
3163 dst_path);
3164 if (ret) {
3165 err = ret;
3166 goto out_unlock;
3167 }
Liu Bo06d3d222012-08-27 10:52:19 -06003168 } else {
3169 struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
3170 struct extent_map *em, *n;
3171
3172 list_for_each_entry_safe(em, n, &tree->modified_extents, list)
3173 list_del_init(&em->list);
Josef Bacik5dc562c2012-08-17 13:14:17 -04003174 }
3175
Chris Mason9623f9a2008-09-11 17:42:42 -04003176 if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
David Sterbab3b4aa72011-04-21 01:20:15 +02003177 btrfs_release_path(path);
3178 btrfs_release_path(dst_path);
Chris Masone02119d2008-09-05 16:13:11 -04003179 ret = log_directory_changes(trans, root, inode, path, dst_path);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003180 if (ret) {
3181 err = ret;
3182 goto out_unlock;
3183 }
Chris Masone02119d2008-09-05 16:13:11 -04003184 }
Chris Mason3a5f1d42008-09-11 15:53:37 -04003185 BTRFS_I(inode)->logged_trans = trans->transid;
Liu Bo46d8bc32012-08-29 01:07:55 -06003186 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003187out_unlock:
Chris Masone02119d2008-09-05 16:13:11 -04003188 mutex_unlock(&BTRFS_I(inode)->log_mutex);
3189
3190 btrfs_free_path(path);
3191 btrfs_free_path(dst_path);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003192 return err;
Chris Masone02119d2008-09-05 16:13:11 -04003193}
3194
Chris Mason12fcfd22009-03-24 10:24:20 -04003195/*
3196 * follow the dentry parent pointers up the chain and see if any
3197 * of the directories in it require a full commit before they can
3198 * be logged. Returns zero if nothing special needs to be done or 1 if
3199 * a full commit is required.
3200 */
3201static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
3202 struct inode *inode,
3203 struct dentry *parent,
3204 struct super_block *sb,
3205 u64 last_committed)
Chris Masone02119d2008-09-05 16:13:11 -04003206{
Chris Mason12fcfd22009-03-24 10:24:20 -04003207 int ret = 0;
3208 struct btrfs_root *root;
Josef Bacik6a912212010-11-20 09:48:00 +00003209 struct dentry *old_parent = NULL;
Chris Masone02119d2008-09-05 16:13:11 -04003210
Chris Masonaf4176b2009-03-24 10:24:31 -04003211 /*
3212 * for regular files, if its inode is already on disk, we don't
3213 * have to worry about the parents at all. This is because
3214 * we can use the last_unlink_trans field to record renames
3215 * and other fun in this file.
3216 */
3217 if (S_ISREG(inode->i_mode) &&
3218 BTRFS_I(inode)->generation <= last_committed &&
3219 BTRFS_I(inode)->last_unlink_trans <= last_committed)
3220 goto out;
3221
Chris Mason12fcfd22009-03-24 10:24:20 -04003222 if (!S_ISDIR(inode->i_mode)) {
3223 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
3224 goto out;
3225 inode = parent->d_inode;
3226 }
3227
3228 while (1) {
3229 BTRFS_I(inode)->logged_trans = trans->transid;
3230 smp_mb();
3231
3232 if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
3233 root = BTRFS_I(inode)->root;
3234
3235 /*
3236 * make sure any commits to the log are forced
3237 * to be full commits
3238 */
3239 root->fs_info->last_trans_log_full_commit =
3240 trans->transid;
3241 ret = 1;
3242 break;
3243 }
3244
3245 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
3246 break;
3247
Yan, Zheng76dda932009-09-21 16:00:26 -04003248 if (IS_ROOT(parent))
Chris Mason12fcfd22009-03-24 10:24:20 -04003249 break;
3250
Josef Bacik6a912212010-11-20 09:48:00 +00003251 parent = dget_parent(parent);
3252 dput(old_parent);
3253 old_parent = parent;
Chris Mason12fcfd22009-03-24 10:24:20 -04003254 inode = parent->d_inode;
3255
3256 }
Josef Bacik6a912212010-11-20 09:48:00 +00003257 dput(old_parent);
Chris Mason12fcfd22009-03-24 10:24:20 -04003258out:
Chris Masone02119d2008-09-05 16:13:11 -04003259 return ret;
3260}
3261
3262/*
3263 * helper function around btrfs_log_inode to make sure newly created
3264 * parent directories also end up in the log. A minimal inode and backref
3265 * only logging is done of any parent directories that are older than
3266 * the last committed transaction
3267 */
Chris Mason12fcfd22009-03-24 10:24:20 -04003268int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
3269 struct btrfs_root *root, struct inode *inode,
3270 struct dentry *parent, int exists_only)
Chris Masone02119d2008-09-05 16:13:11 -04003271{
Chris Mason12fcfd22009-03-24 10:24:20 -04003272 int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL;
Chris Masone02119d2008-09-05 16:13:11 -04003273 struct super_block *sb;
Josef Bacik6a912212010-11-20 09:48:00 +00003274 struct dentry *old_parent = NULL;
Chris Mason12fcfd22009-03-24 10:24:20 -04003275 int ret = 0;
3276 u64 last_committed = root->fs_info->last_trans_committed;
3277
3278 sb = inode->i_sb;
3279
Sage Weil3a5e1402009-04-02 16:49:40 -04003280 if (btrfs_test_opt(root, NOTREELOG)) {
3281 ret = 1;
3282 goto end_no_trans;
3283 }
3284
Chris Mason12fcfd22009-03-24 10:24:20 -04003285 if (root->fs_info->last_trans_log_full_commit >
3286 root->fs_info->last_trans_committed) {
3287 ret = 1;
3288 goto end_no_trans;
3289 }
3290
Yan, Zheng76dda932009-09-21 16:00:26 -04003291 if (root != BTRFS_I(inode)->root ||
3292 btrfs_root_refs(&root->root_item) == 0) {
3293 ret = 1;
3294 goto end_no_trans;
3295 }
3296
Chris Mason12fcfd22009-03-24 10:24:20 -04003297 ret = check_parent_dirs_for_sync(trans, inode, parent,
3298 sb, last_committed);
3299 if (ret)
3300 goto end_no_trans;
Chris Masone02119d2008-09-05 16:13:11 -04003301
Josef Bacik22ee6982012-05-29 16:57:49 -04003302 if (btrfs_inode_in_log(inode, trans->transid)) {
Chris Mason257c62e2009-10-13 13:21:08 -04003303 ret = BTRFS_NO_LOG_SYNC;
3304 goto end_no_trans;
3305 }
3306
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003307 ret = start_log_trans(trans, root);
3308 if (ret)
3309 goto end_trans;
Chris Mason12fcfd22009-03-24 10:24:20 -04003310
3311 ret = btrfs_log_inode(trans, root, inode, inode_only);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003312 if (ret)
3313 goto end_trans;
Chris Mason12fcfd22009-03-24 10:24:20 -04003314
Chris Masonaf4176b2009-03-24 10:24:31 -04003315 /*
3316 * for regular files, if its inode is already on disk, we don't
3317 * have to worry about the parents at all. This is because
3318 * we can use the last_unlink_trans field to record renames
3319 * and other fun in this file.
3320 */
3321 if (S_ISREG(inode->i_mode) &&
3322 BTRFS_I(inode)->generation <= last_committed &&
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003323 BTRFS_I(inode)->last_unlink_trans <= last_committed) {
3324 ret = 0;
3325 goto end_trans;
3326 }
Chris Masonaf4176b2009-03-24 10:24:31 -04003327
3328 inode_only = LOG_INODE_EXISTS;
Chris Masond3977122009-01-05 21:25:51 -05003329 while (1) {
Chris Mason12fcfd22009-03-24 10:24:20 -04003330 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
Chris Masone02119d2008-09-05 16:13:11 -04003331 break;
3332
Chris Mason12fcfd22009-03-24 10:24:20 -04003333 inode = parent->d_inode;
Yan, Zheng76dda932009-09-21 16:00:26 -04003334 if (root != BTRFS_I(inode)->root)
3335 break;
3336
Chris Mason12fcfd22009-03-24 10:24:20 -04003337 if (BTRFS_I(inode)->generation >
3338 root->fs_info->last_trans_committed) {
3339 ret = btrfs_log_inode(trans, root, inode, inode_only);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003340 if (ret)
3341 goto end_trans;
Chris Mason12fcfd22009-03-24 10:24:20 -04003342 }
Yan, Zheng76dda932009-09-21 16:00:26 -04003343 if (IS_ROOT(parent))
Chris Masone02119d2008-09-05 16:13:11 -04003344 break;
Chris Mason12fcfd22009-03-24 10:24:20 -04003345
Josef Bacik6a912212010-11-20 09:48:00 +00003346 parent = dget_parent(parent);
3347 dput(old_parent);
3348 old_parent = parent;
Chris Masone02119d2008-09-05 16:13:11 -04003349 }
Chris Mason12fcfd22009-03-24 10:24:20 -04003350 ret = 0;
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003351end_trans:
Josef Bacik6a912212010-11-20 09:48:00 +00003352 dput(old_parent);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003353 if (ret < 0) {
Josef Bacik0fa83cd2012-08-24 14:48:11 -04003354 WARN_ON(ret != -ENOSPC);
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003355 root->fs_info->last_trans_log_full_commit = trans->transid;
3356 ret = 1;
3357 }
Chris Mason12fcfd22009-03-24 10:24:20 -04003358 btrfs_end_log_trans(root);
3359end_no_trans:
3360 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04003361}
3362
3363/*
3364 * it is not safe to log dentry if the chunk root has added new
3365 * chunks. This returns 0 if the dentry was logged, and 1 otherwise.
3366 * If this returns 1, you must commit the transaction to safely get your
3367 * data on disk.
3368 */
3369int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
3370 struct btrfs_root *root, struct dentry *dentry)
3371{
Josef Bacik6a912212010-11-20 09:48:00 +00003372 struct dentry *parent = dget_parent(dentry);
3373 int ret;
3374
3375 ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent, 0);
3376 dput(parent);
3377
3378 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04003379}
3380
3381/*
3382 * should be called during mount to recover any replay any log trees
3383 * from the FS
3384 */
3385int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
3386{
3387 int ret;
3388 struct btrfs_path *path;
3389 struct btrfs_trans_handle *trans;
3390 struct btrfs_key key;
3391 struct btrfs_key found_key;
3392 struct btrfs_key tmp_key;
3393 struct btrfs_root *log;
3394 struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
3395 struct walk_control wc = {
3396 .process_func = process_one_buffer,
3397 .stage = 0,
3398 };
3399
Chris Masone02119d2008-09-05 16:13:11 -04003400 path = btrfs_alloc_path();
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00003401 if (!path)
3402 return -ENOMEM;
3403
3404 fs_info->log_root_recovering = 1;
Chris Masone02119d2008-09-05 16:13:11 -04003405
Yan, Zheng4a500fd2010-05-16 10:49:59 -04003406 trans = btrfs_start_transaction(fs_info->tree_root, 0);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003407 if (IS_ERR(trans)) {
3408 ret = PTR_ERR(trans);
3409 goto error;
3410 }
Chris Masone02119d2008-09-05 16:13:11 -04003411
3412 wc.trans = trans;
3413 wc.pin = 1;
3414
Tsutomu Itohdb5b4932011-03-23 08:14:16 +00003415 ret = walk_log_tree(trans, log_root_tree, &wc);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003416 if (ret) {
3417 btrfs_error(fs_info, ret, "Failed to pin buffers while "
3418 "recovering log root tree.");
3419 goto error;
3420 }
Chris Masone02119d2008-09-05 16:13:11 -04003421
3422again:
3423 key.objectid = BTRFS_TREE_LOG_OBJECTID;
3424 key.offset = (u64)-1;
3425 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
3426
Chris Masond3977122009-01-05 21:25:51 -05003427 while (1) {
Chris Masone02119d2008-09-05 16:13:11 -04003428 ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003429
3430 if (ret < 0) {
3431 btrfs_error(fs_info, ret,
3432 "Couldn't find tree log root.");
3433 goto error;
3434 }
Chris Masone02119d2008-09-05 16:13:11 -04003435 if (ret > 0) {
3436 if (path->slots[0] == 0)
3437 break;
3438 path->slots[0]--;
3439 }
3440 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
3441 path->slots[0]);
David Sterbab3b4aa72011-04-21 01:20:15 +02003442 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04003443 if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
3444 break;
3445
3446 log = btrfs_read_fs_root_no_radix(log_root_tree,
3447 &found_key);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003448 if (IS_ERR(log)) {
3449 ret = PTR_ERR(log);
3450 btrfs_error(fs_info, ret,
3451 "Couldn't read tree log root.");
3452 goto error;
3453 }
Chris Masone02119d2008-09-05 16:13:11 -04003454
3455 tmp_key.objectid = found_key.offset;
3456 tmp_key.type = BTRFS_ROOT_ITEM_KEY;
3457 tmp_key.offset = (u64)-1;
3458
3459 wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003460 if (IS_ERR(wc.replay_dest)) {
3461 ret = PTR_ERR(wc.replay_dest);
3462 btrfs_error(fs_info, ret, "Couldn't read target root "
3463 "for tree log recovery.");
3464 goto error;
3465 }
Chris Masone02119d2008-09-05 16:13:11 -04003466
Yan Zheng07d400a2009-01-06 11:42:00 -05003467 wc.replay_dest->log_root = log;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003468 btrfs_record_root_in_trans(trans, wc.replay_dest);
Chris Masone02119d2008-09-05 16:13:11 -04003469 ret = walk_log_tree(trans, log, &wc);
3470 BUG_ON(ret);
3471
3472 if (wc.stage == LOG_WALK_REPLAY_ALL) {
3473 ret = fixup_inode_link_counts(trans, wc.replay_dest,
3474 path);
3475 BUG_ON(ret);
3476 }
Chris Masone02119d2008-09-05 16:13:11 -04003477
3478 key.offset = found_key.offset - 1;
Yan Zheng07d400a2009-01-06 11:42:00 -05003479 wc.replay_dest->log_root = NULL;
Chris Masone02119d2008-09-05 16:13:11 -04003480 free_extent_buffer(log->node);
Chris Masonb263c2c2009-06-11 11:24:47 -04003481 free_extent_buffer(log->commit_root);
Chris Masone02119d2008-09-05 16:13:11 -04003482 kfree(log);
3483
3484 if (found_key.offset == 0)
3485 break;
3486 }
David Sterbab3b4aa72011-04-21 01:20:15 +02003487 btrfs_release_path(path);
Chris Masone02119d2008-09-05 16:13:11 -04003488
3489 /* step one is to pin it all, step two is to replay just inodes */
3490 if (wc.pin) {
3491 wc.pin = 0;
3492 wc.process_func = replay_one_buffer;
3493 wc.stage = LOG_WALK_REPLAY_INODES;
3494 goto again;
3495 }
3496 /* step three is to replay everything */
3497 if (wc.stage < LOG_WALK_REPLAY_ALL) {
3498 wc.stage++;
3499 goto again;
3500 }
3501
3502 btrfs_free_path(path);
3503
3504 free_extent_buffer(log_root_tree->node);
3505 log_root_tree->log_root = NULL;
3506 fs_info->log_root_recovering = 0;
3507
3508 /* step 4: commit the transaction, which also unpins the blocks */
3509 btrfs_commit_transaction(trans, fs_info->tree_root);
3510
3511 kfree(log_root_tree);
3512 return 0;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003513
3514error:
3515 btrfs_free_path(path);
3516 return ret;
Chris Masone02119d2008-09-05 16:13:11 -04003517}
Chris Mason12fcfd22009-03-24 10:24:20 -04003518
3519/*
3520 * there are some corner cases where we want to force a full
3521 * commit instead of allowing a directory to be logged.
3522 *
3523 * They revolve around files there were unlinked from the directory, and
3524 * this function updates the parent directory so that a full commit is
3525 * properly done if it is fsync'd later after the unlinks are done.
3526 */
3527void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
3528 struct inode *dir, struct inode *inode,
3529 int for_rename)
3530{
3531 /*
Chris Masonaf4176b2009-03-24 10:24:31 -04003532 * when we're logging a file, if it hasn't been renamed
3533 * or unlinked, and its inode is fully committed on disk,
3534 * we don't have to worry about walking up the directory chain
3535 * to log its parents.
3536 *
3537 * So, we use the last_unlink_trans field to put this transid
3538 * into the file. When the file is logged we check it and
3539 * don't log the parents if the file is fully on disk.
3540 */
3541 if (S_ISREG(inode->i_mode))
3542 BTRFS_I(inode)->last_unlink_trans = trans->transid;
3543
3544 /*
Chris Mason12fcfd22009-03-24 10:24:20 -04003545 * if this directory was already logged any new
3546 * names for this file/dir will get recorded
3547 */
3548 smp_mb();
3549 if (BTRFS_I(dir)->logged_trans == trans->transid)
3550 return;
3551
3552 /*
3553 * if the inode we're about to unlink was logged,
3554 * the log will be properly updated for any new names
3555 */
3556 if (BTRFS_I(inode)->logged_trans == trans->transid)
3557 return;
3558
3559 /*
3560 * when renaming files across directories, if the directory
3561 * there we're unlinking from gets fsync'd later on, there's
3562 * no way to find the destination directory later and fsync it
3563 * properly. So, we have to be conservative and force commits
3564 * so the new name gets discovered.
3565 */
3566 if (for_rename)
3567 goto record;
3568
3569 /* we can safely do the unlink without any special recording */
3570 return;
3571
3572record:
3573 BTRFS_I(dir)->last_unlink_trans = trans->transid;
3574}
3575
3576/*
3577 * Call this after adding a new name for a file and it will properly
3578 * update the log to reflect the new name.
3579 *
3580 * It will return zero if all goes well, and it will return 1 if a
3581 * full transaction commit is required.
3582 */
3583int btrfs_log_new_name(struct btrfs_trans_handle *trans,
3584 struct inode *inode, struct inode *old_dir,
3585 struct dentry *parent)
3586{
3587 struct btrfs_root * root = BTRFS_I(inode)->root;
3588
3589 /*
Chris Masonaf4176b2009-03-24 10:24:31 -04003590 * this will force the logging code to walk the dentry chain
3591 * up for the file
3592 */
3593 if (S_ISREG(inode->i_mode))
3594 BTRFS_I(inode)->last_unlink_trans = trans->transid;
3595
3596 /*
Chris Mason12fcfd22009-03-24 10:24:20 -04003597 * if this inode hasn't been logged and directory we're renaming it
3598 * from hasn't been logged, we don't need to log it
3599 */
3600 if (BTRFS_I(inode)->logged_trans <=
3601 root->fs_info->last_trans_committed &&
3602 (!old_dir || BTRFS_I(old_dir)->logged_trans <=
3603 root->fs_info->last_trans_committed))
3604 return 0;
3605
3606 return btrfs_log_inode_parent(trans, root, inode, parent, 1);
3607}
3608