tree-log.c 115.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (C) 2008 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

#include <linux/sched.h>
20
#include <linux/slab.h>
21
#include <linux/blkdev.h>
J
Josef Bacik 已提交
22
#include <linux/list_sort.h>
23
#include "tree-log.h"
24 25 26
#include "disk-io.h"
#include "locking.h"
#include "print-tree.h"
M
Mark Fasheh 已提交
27 28
#include "backref.h"
#include "hash.h"
29 30 31 32 33 34 35 36 37 38

/* magic values for the inode_only field in btrfs_log_inode:
 *
 * LOG_INODE_ALL means to log everything
 * LOG_INODE_EXISTS means to log just enough to recreate the inode
 * during log replay
 */
#define LOG_INODE_ALL 0
#define LOG_INODE_EXISTS 1

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
/*
 * directory trouble cases
 *
 * 1) on rename or unlink, if the inode being unlinked isn't in the fsync
 * log, we must force a full commit before doing an fsync of the directory
 * where the unlink was done.
 * ---> record transid of last unlink/rename per directory
 *
 * mkdir foo/some_dir
 * normal commit
 * rename foo/some_dir foo2/some_dir
 * mkdir foo/some_dir
 * fsync foo/some_dir/some_file
 *
 * The fsync above will unlink the original some_dir without recording
 * it in its new location (foo2).  After a crash, some_dir will be gone
 * unless the fsync of some_file forces a full commit
 *
 * 2) we must log any new names for any file or dir that is in the fsync
 * log. ---> check inode while renaming/linking.
 *
 * 2a) we must log any new names for any file or dir during rename
 * when the directory they are being removed from was logged.
 * ---> check inode and old parent dir during rename
 *
 *  2a is actually the more important variant.  With the extra logging
 *  a crash might unlink the old name without recreating the new one
 *
 * 3) after a crash, we must go through any directories with a link count
 * of zero and redo the rm -rf
 *
 * mkdir f1/foo
 * normal commit
 * rm -rf f1/foo
 * fsync(f1)
 *
 * The directory f1 was fully removed from the FS, but fsync was never
 * called on f1, only its parent dir.  After a crash the rm -rf must
 * be replayed.  This must be able to recurse down the entire
 * directory tree.  The inode link count fixup code takes care of the
 * ugly details.
 */

82 83 84 85 86 87 88 89 90 91 92
/*
 * stages for the tree walking.  The first
 * stage (0) is to only pin down the blocks we find
 * the second stage (1) is to make sure that all the inodes
 * we find in the log are created in the subvolume.
 *
 * The last stage is to deal with directories and links and extents
 * and all the other fun semantics
 */
#define LOG_WALK_PIN_ONLY 0
#define LOG_WALK_REPLAY_INODES 1
93 94
#define LOG_WALK_REPLAY_DIR_INDEX 2
#define LOG_WALK_REPLAY_ALL 3
95

96
static int btrfs_log_inode(struct btrfs_trans_handle *trans,
97 98
			     struct btrfs_root *root, struct inode *inode,
			     int inode_only);
99 100 101
static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root,
			     struct btrfs_path *path, u64 objectid);
102 103 104 105 106
static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
				       struct btrfs_root *root,
				       struct btrfs_root *log,
				       struct btrfs_path *path,
				       u64 dirid, int del_all);
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136

/*
 * tree logging is a special write ahead log used to make sure that
 * fsyncs and O_SYNCs can happen without doing full tree commits.
 *
 * Full tree commits are expensive because they require commonly
 * modified blocks to be recowed, creating many dirty pages in the
 * extent tree an 4x-6x higher write load than ext3.
 *
 * Instead of doing a tree commit on every fsync, we use the
 * key ranges and transaction ids to find items for a given file or directory
 * that have changed in this transaction.  Those items are copied into
 * a special tree (one per subvolume root), that tree is written to disk
 * and then the fsync is considered complete.
 *
 * After a crash, items are copied out of the log-tree back into the
 * subvolume tree.  Any file data extents found are recorded in the extent
 * allocation tree, and the log-tree freed.
 *
 * The log tree is read three times, once to pin down all the extents it is
 * using in ram and once, once to create all the inodes logged in the tree
 * and once to do all the other items.
 */

/*
 * start a sub transaction and setup the log tree
 * this increments the log tree writer count to make the people
 * syncing the tree wait for us to finish
 */
static int start_log_trans(struct btrfs_trans_handle *trans,
137 138
			   struct btrfs_root *root,
			   struct btrfs_log_ctx *ctx)
139
{
140
	int index;
141
	int ret;
Y
Yan Zheng 已提交
142 143 144

	mutex_lock(&root->log_mutex);
	if (root->log_root) {
145
		if (btrfs_need_log_full_commit(root->fs_info, trans)) {
146 147 148
			ret = -EAGAIN;
			goto out;
		}
149 150
		if (!root->log_start_pid) {
			root->log_start_pid = current->pid;
151
			clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
152
		} else if (root->log_start_pid != current->pid) {
153
			set_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
154 155
		}

M
Miao Xie 已提交
156
		atomic_inc(&root->log_batch);
Y
Yan Zheng 已提交
157
		atomic_inc(&root->log_writers);
158 159 160
		if (ctx) {
			index = root->log_transid % 2;
			list_add_tail(&ctx->list, &root->log_ctxs[index]);
161
			ctx->log_transid = root->log_transid;
162
		}
Y
Yan Zheng 已提交
163 164 165
		mutex_unlock(&root->log_mutex);
		return 0;
	}
166 167

	ret = 0;
168
	mutex_lock(&root->fs_info->tree_log_mutex);
169
	if (!root->fs_info->log_root_tree)
170
		ret = btrfs_init_log_root_tree(trans, root->fs_info);
171 172 173 174 175
	mutex_unlock(&root->fs_info->tree_log_mutex);
	if (ret)
		goto out;

	if (!root->log_root) {
176
		ret = btrfs_add_log_tree(trans, root);
177
		if (ret)
178
			goto out;
179
	}
180
	clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
181
	root->log_start_pid = current->pid;
M
Miao Xie 已提交
182
	atomic_inc(&root->log_batch);
Y
Yan Zheng 已提交
183
	atomic_inc(&root->log_writers);
184 185 186
	if (ctx) {
		index = root->log_transid % 2;
		list_add_tail(&ctx->list, &root->log_ctxs[index]);
187
		ctx->log_transid = root->log_transid;
188
	}
189
out:
Y
Yan Zheng 已提交
190
	mutex_unlock(&root->log_mutex);
191
	return ret;
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
}

/*
 * returns 0 if there was a log transaction running and we were able
 * to join, or returns -ENOENT if there were not transactions
 * in progress
 */
static int join_running_log_trans(struct btrfs_root *root)
{
	int ret = -ENOENT;

	smp_mb();
	if (!root->log_root)
		return -ENOENT;

Y
Yan Zheng 已提交
207
	mutex_lock(&root->log_mutex);
208 209
	if (root->log_root) {
		ret = 0;
Y
Yan Zheng 已提交
210
		atomic_inc(&root->log_writers);
211
	}
Y
Yan Zheng 已提交
212
	mutex_unlock(&root->log_mutex);
213 214 215
	return ret;
}

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
/*
 * This either makes the current running log transaction wait
 * until you call btrfs_end_log_trans() or it makes any future
 * log transactions wait until you call btrfs_end_log_trans()
 */
int btrfs_pin_log_trans(struct btrfs_root *root)
{
	int ret = -ENOENT;

	mutex_lock(&root->log_mutex);
	atomic_inc(&root->log_writers);
	mutex_unlock(&root->log_mutex);
	return ret;
}

231 232 233 234
/*
 * indicate we're done making changes to the log tree
 * and wake up anyone waiting to do a sync
 */
235
void btrfs_end_log_trans(struct btrfs_root *root)
236
{
Y
Yan Zheng 已提交
237 238 239 240 241
	if (atomic_dec_and_test(&root->log_writers)) {
		smp_mb();
		if (waitqueue_active(&root->log_writer_wait))
			wake_up(&root->log_writer_wait);
	}
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
}


/*
 * the walk control struct is used to pass state down the chain when
 * processing the log tree.  The stage field tells us which part
 * of the log tree processing we are currently doing.  The others
 * are state fields used for that specific part
 */
struct walk_control {
	/* should we free the extent on disk when done?  This is used
	 * at transaction commit time while freeing a log tree
	 */
	int free;

	/* should we write out the extent buffer?  This is used
	 * while flushing the log tree to disk during a sync
	 */
	int write;

	/* should we wait for the extent buffer io to finish?  Also used
	 * while flushing the log tree to disk for a sync
	 */
	int wait;

	/* pin only walk, we record which extents on disk belong to the
	 * log trees
	 */
	int pin;

	/* what stage of the replay code we're currently in */
	int stage;

	/* the root we are currently replaying */
	struct btrfs_root *replay_dest;

	/* the trans handle for the current replay */
	struct btrfs_trans_handle *trans;

	/* the function that gets used to process blocks we find in the
	 * tree.  Note the extent_buffer might not be up to date when it is
	 * passed in, and it must be checked or read if you need the data
	 * inside it
	 */
	int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
			    struct walk_control *wc, u64 gen);
};

/*
 * process_func used to pin down extents, write them or wait on them
 */
static int process_one_buffer(struct btrfs_root *log,
			      struct extent_buffer *eb,
			      struct walk_control *wc, u64 gen)
{
297 298
	int ret = 0;

299 300 301 302 303 304 305 306 307 308
	/*
	 * If this fs is mixed then we need to be able to process the leaves to
	 * pin down any logged extents, so we have to read the block.
	 */
	if (btrfs_fs_incompat(log->fs_info, MIXED_GROUPS)) {
		ret = btrfs_read_buffer(eb, gen);
		if (ret)
			return ret;
	}

J
Josef Bacik 已提交
309
	if (wc->pin)
310 311
		ret = btrfs_pin_extent_for_log_replay(log->fs_info->extent_root,
						      eb->start, eb->len);
312

313
	if (!ret && btrfs_buffer_uptodate(eb, gen, 0)) {
314 315
		if (wc->pin && btrfs_header_level(eb) == 0)
			ret = btrfs_exclude_logged_extents(log, eb);
316 317 318 319 320
		if (wc->write)
			btrfs_write_tree_block(eb);
		if (wc->wait)
			btrfs_wait_tree_block_writeback(eb);
	}
321
	return ret;
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
}

/*
 * Item overwrite used by replay and tree logging.  eb, slot and key all refer
 * to the src data we are copying out.
 *
 * root is the tree we are copying into, and path is a scratch
 * path for use in this function (it should be released on entry and
 * will be released on exit).
 *
 * If the key is already in the destination tree the existing item is
 * overwritten.  If the existing item isn't big enough, it is extended.
 * If it is too large, it is truncated.
 *
 * If the key isn't in the destination yet, a new item is inserted.
 */
static noinline int overwrite_item(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   struct btrfs_path *path,
				   struct extent_buffer *eb, int slot,
				   struct btrfs_key *key)
{
	int ret;
	u32 item_size;
	u64 saved_i_size = 0;
	int save_old_i_size = 0;
	unsigned long src_ptr;
	unsigned long dst_ptr;
	int overwrite_root = 0;
351
	bool inode_item = key->type == BTRFS_INODE_ITEM_KEY;
352 353 354 355 356 357 358 359 360

	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
		overwrite_root = 1;

	item_size = btrfs_item_size_nr(eb, slot);
	src_ptr = btrfs_item_ptr_offset(eb, slot);

	/* look for the key in the destination tree */
	ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
361 362 363
	if (ret < 0)
		return ret;

364 365 366 367 368 369 370 371 372
	if (ret == 0) {
		char *src_copy;
		char *dst_copy;
		u32 dst_size = btrfs_item_size_nr(path->nodes[0],
						  path->slots[0]);
		if (dst_size != item_size)
			goto insert;

		if (item_size == 0) {
373
			btrfs_release_path(path);
374 375 376 377
			return 0;
		}
		dst_copy = kmalloc(item_size, GFP_NOFS);
		src_copy = kmalloc(item_size, GFP_NOFS);
378
		if (!dst_copy || !src_copy) {
379
			btrfs_release_path(path);
380 381 382 383
			kfree(dst_copy);
			kfree(src_copy);
			return -ENOMEM;
		}
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400

		read_extent_buffer(eb, src_copy, src_ptr, item_size);

		dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
		read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
				   item_size);
		ret = memcmp(dst_copy, src_copy, item_size);

		kfree(dst_copy);
		kfree(src_copy);
		/*
		 * they have the same contents, just return, this saves
		 * us from cowing blocks in the destination tree and doing
		 * extra writes that may not have been done by a previous
		 * sync
		 */
		if (ret == 0) {
401
			btrfs_release_path(path);
402 403 404
			return 0;
		}

405 406 407 408 409 410 411
		/*
		 * We need to load the old nbytes into the inode so when we
		 * replay the extents we've logged we get the right nbytes.
		 */
		if (inode_item) {
			struct btrfs_inode_item *item;
			u64 nbytes;
412
			u32 mode;
413 414 415 416 417 418 419

			item = btrfs_item_ptr(path->nodes[0], path->slots[0],
					      struct btrfs_inode_item);
			nbytes = btrfs_inode_nbytes(path->nodes[0], item);
			item = btrfs_item_ptr(eb, slot,
					      struct btrfs_inode_item);
			btrfs_set_inode_nbytes(eb, item, nbytes);
420 421 422 423 424 425 426 427 428

			/*
			 * If this is a directory we need to reset the i_size to
			 * 0 so that we can set it up properly when replaying
			 * the rest of the items in this log.
			 */
			mode = btrfs_inode_mode(eb, item);
			if (S_ISDIR(mode))
				btrfs_set_inode_size(eb, item, 0);
429 430 431
		}
	} else if (inode_item) {
		struct btrfs_inode_item *item;
432
		u32 mode;
433 434 435 436 437 438 439

		/*
		 * New inode, set nbytes to 0 so that the nbytes comes out
		 * properly when we replay the extents.
		 */
		item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
		btrfs_set_inode_nbytes(eb, item, 0);
440 441 442 443 444 445 446 447 448

		/*
		 * If this is a directory we need to reset the i_size to 0 so
		 * that we can set it up properly when replaying the rest of
		 * the items in this log.
		 */
		mode = btrfs_inode_mode(eb, item);
		if (S_ISDIR(mode))
			btrfs_set_inode_size(eb, item, 0);
449 450
	}
insert:
451
	btrfs_release_path(path);
452 453 454 455 456 457 458 459 460
	/* try to insert the key into the destination tree */
	ret = btrfs_insert_empty_item(trans, root, path,
				      key, item_size);

	/* make sure any existing item is the correct size */
	if (ret == -EEXIST) {
		u32 found_size;
		found_size = btrfs_item_size_nr(path->nodes[0],
						path->slots[0]);
461
		if (found_size > item_size)
462
			btrfs_truncate_item(root, path, item_size, 1);
463
		else if (found_size < item_size)
464
			btrfs_extend_item(root, path,
465
					  item_size - found_size);
466
	} else if (ret) {
467
		return ret;
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
	}
	dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
					path->slots[0]);

	/* don't overwrite an existing inode if the generation number
	 * was logged as zero.  This is done when the tree logging code
	 * is just logging an inode to make sure it exists after recovery.
	 *
	 * Also, don't overwrite i_size on directories during replay.
	 * log replay inserts and removes directory items based on the
	 * state of the tree found in the subvolume, and i_size is modified
	 * as it goes
	 */
	if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
		struct btrfs_inode_item *src_item;
		struct btrfs_inode_item *dst_item;

		src_item = (struct btrfs_inode_item *)src_ptr;
		dst_item = (struct btrfs_inode_item *)dst_ptr;

		if (btrfs_inode_generation(eb, src_item) == 0)
			goto no_copy;

		if (overwrite_root &&
		    S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
		    S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
			save_old_i_size = 1;
			saved_i_size = btrfs_inode_size(path->nodes[0],
							dst_item);
		}
	}

	copy_extent_buffer(path->nodes[0], eb, dst_ptr,
			   src_ptr, item_size);

	if (save_old_i_size) {
		struct btrfs_inode_item *dst_item;
		dst_item = (struct btrfs_inode_item *)dst_ptr;
		btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
	}

	/* make sure the generation is filled in */
	if (key->type == BTRFS_INODE_ITEM_KEY) {
		struct btrfs_inode_item *dst_item;
		dst_item = (struct btrfs_inode_item *)dst_ptr;
		if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
			btrfs_set_inode_generation(path->nodes[0], dst_item,
						   trans->transid);
		}
	}
no_copy:
	btrfs_mark_buffer_dirty(path->nodes[0]);
520
	btrfs_release_path(path);
521 522 523 524 525 526 527 528 529 530
	return 0;
}

/*
 * simple helper to read an inode off the disk from a given root
 * This can only be called for subvolume roots and not for the log
 */
static noinline struct inode *read_one_inode(struct btrfs_root *root,
					     u64 objectid)
{
531
	struct btrfs_key key;
532 533
	struct inode *inode;

534 535 536
	key.objectid = objectid;
	key.type = BTRFS_INODE_ITEM_KEY;
	key.offset = 0;
537
	inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
538 539 540
	if (IS_ERR(inode)) {
		inode = NULL;
	} else if (is_bad_inode(inode)) {
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
		iput(inode);
		inode = NULL;
	}
	return inode;
}

/* replays a single extent in 'eb' at 'slot' with 'key' into the
 * subvolume 'root'.  path is released on entry and should be released
 * on exit.
 *
 * extents in the log tree have not been allocated out of the extent
 * tree yet.  So, this completes the allocation, taking a reference
 * as required if the extent already exists or creating a new extent
 * if it isn't in the extent allocation tree yet.
 *
 * The extent is inserted into the file, dropping any existing extents
 * from the file that overlap the new one.
 */
static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      struct btrfs_path *path,
				      struct extent_buffer *eb, int slot,
				      struct btrfs_key *key)
{
	int found_type;
	u64 extent_end;
	u64 start = key->offset;
568
	u64 nbytes = 0;
569 570 571 572 573 574 575 576
	struct btrfs_file_extent_item *item;
	struct inode *inode = NULL;
	unsigned long size;
	int ret = 0;

	item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
	found_type = btrfs_file_extent_type(eb, item);

Y
Yan Zheng 已提交
577
	if (found_type == BTRFS_FILE_EXTENT_REG ||
578 579 580 581 582 583 584 585 586 587 588
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
		nbytes = btrfs_file_extent_num_bytes(eb, item);
		extent_end = start + nbytes;

		/*
		 * We don't add to the inodes nbytes if we are prealloc or a
		 * hole.
		 */
		if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
			nbytes = 0;
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
589
		size = btrfs_file_extent_inline_len(eb, slot, item);
590
		nbytes = btrfs_file_extent_ram_bytes(eb, item);
591
		extent_end = ALIGN(start + size, root->sectorsize);
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
	} else {
		ret = 0;
		goto out;
	}

	inode = read_one_inode(root, key->objectid);
	if (!inode) {
		ret = -EIO;
		goto out;
	}

	/*
	 * first check to see if we already have this extent in the
	 * file.  This must be done before the btrfs_drop_extents run
	 * so we don't try to drop this extent.
	 */
L
Li Zefan 已提交
608
	ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
609 610
				       start, 0);

Y
Yan Zheng 已提交
611 612 613
	if (ret == 0 &&
	    (found_type == BTRFS_FILE_EXTENT_REG ||
	     found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
		struct btrfs_file_extent_item cmp1;
		struct btrfs_file_extent_item cmp2;
		struct btrfs_file_extent_item *existing;
		struct extent_buffer *leaf;

		leaf = path->nodes[0];
		existing = btrfs_item_ptr(leaf, path->slots[0],
					  struct btrfs_file_extent_item);

		read_extent_buffer(eb, &cmp1, (unsigned long)item,
				   sizeof(cmp1));
		read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
				   sizeof(cmp2));

		/*
		 * we already have a pointer to this exact extent,
		 * we don't have to do anything
		 */
		if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
633
			btrfs_release_path(path);
634 635 636
			goto out;
		}
	}
637
	btrfs_release_path(path);
638 639

	/* drop any overlapping extents */
640
	ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
641 642
	if (ret)
		goto out;
643

Y
Yan Zheng 已提交
644 645
	if (found_type == BTRFS_FILE_EXTENT_REG ||
	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
646
		u64 offset;
Y
Yan Zheng 已提交
647 648 649 650 651
		unsigned long dest_offset;
		struct btrfs_key ins;

		ret = btrfs_insert_empty_item(trans, root, path, key,
					      sizeof(*item));
652 653
		if (ret)
			goto out;
Y
Yan Zheng 已提交
654 655 656 657 658 659 660 661
		dest_offset = btrfs_item_ptr_offset(path->nodes[0],
						    path->slots[0]);
		copy_extent_buffer(path->nodes[0], eb, dest_offset,
				(unsigned long)item,  sizeof(*item));

		ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
		ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
		ins.type = BTRFS_EXTENT_ITEM_KEY;
662
		offset = key->offset - btrfs_file_extent_offset(eb, item);
Y
Yan Zheng 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676

		if (ins.objectid > 0) {
			u64 csum_start;
			u64 csum_end;
			LIST_HEAD(ordered_sums);
			/*
			 * is this extent already allocated in the extent
			 * allocation tree?  If so, just add a reference
			 */
			ret = btrfs_lookup_extent(root, ins.objectid,
						ins.offset);
			if (ret == 0) {
				ret = btrfs_inc_extent_ref(trans, root,
						ins.objectid, ins.offset,
677
						0, root->root_key.objectid,
A
Arne Jansen 已提交
678
						key->objectid, offset, 0);
679 680
				if (ret)
					goto out;
Y
Yan Zheng 已提交
681 682 683 684 685
			} else {
				/*
				 * insert the extent pointer in the extent
				 * allocation tree
				 */
686 687 688
				ret = btrfs_alloc_logged_file_extent(trans,
						root, root->root_key.objectid,
						key->objectid, offset, &ins);
689 690
				if (ret)
					goto out;
Y
Yan Zheng 已提交
691
			}
692
			btrfs_release_path(path);
Y
Yan Zheng 已提交
693 694 695 696 697 698 699 700 701 702 703 704 705

			if (btrfs_file_extent_compression(eb, item)) {
				csum_start = ins.objectid;
				csum_end = csum_start + ins.offset;
			} else {
				csum_start = ins.objectid +
					btrfs_file_extent_offset(eb, item);
				csum_end = csum_start +
					btrfs_file_extent_num_bytes(eb, item);
			}

			ret = btrfs_lookup_csums_range(root->log_root,
						csum_start, csum_end - 1,
A
Arne Jansen 已提交
706
						&ordered_sums, 0);
707 708
			if (ret)
				goto out;
Y
Yan Zheng 已提交
709 710 711 712 713
			while (!list_empty(&ordered_sums)) {
				struct btrfs_ordered_sum *sums;
				sums = list_entry(ordered_sums.next,
						struct btrfs_ordered_sum,
						list);
714 715
				if (!ret)
					ret = btrfs_csum_file_blocks(trans,
Y
Yan Zheng 已提交
716 717 718 719 720
						root->fs_info->csum_root,
						sums);
				list_del(&sums->list);
				kfree(sums);
			}
721 722
			if (ret)
				goto out;
Y
Yan Zheng 已提交
723
		} else {
724
			btrfs_release_path(path);
Y
Yan Zheng 已提交
725 726 727 728
		}
	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
		/* inline extents are easy, we just overwrite them */
		ret = overwrite_item(trans, root, path, eb, slot, key);
729 730
		if (ret)
			goto out;
Y
Yan Zheng 已提交
731
	}
732

733
	inode_add_bytes(inode, nbytes);
734
	ret = btrfs_update_inode(trans, root, inode);
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
out:
	if (inode)
		iput(inode);
	return ret;
}

/*
 * when cleaning up conflicts between the directory names in the
 * subvolume, directory names in the log and directory names in the
 * inode back references, we may have to unlink inodes from directories.
 *
 * This is a helper function to do the unlink of a specific directory
 * item
 */
static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      struct btrfs_path *path,
				      struct inode *dir,
				      struct btrfs_dir_item *di)
{
	struct inode *inode;
	char *name;
	int name_len;
	struct extent_buffer *leaf;
	struct btrfs_key location;
	int ret;

	leaf = path->nodes[0];

	btrfs_dir_item_key_to_cpu(leaf, di, &location);
	name_len = btrfs_dir_name_len(leaf, di);
	name = kmalloc(name_len, GFP_NOFS);
767 768 769
	if (!name)
		return -ENOMEM;

770
	read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
771
	btrfs_release_path(path);
772 773

	inode = read_one_inode(root, location.objectid);
774
	if (!inode) {
775 776
		ret = -EIO;
		goto out;
777
	}
778

779
	ret = link_to_fixup_dir(trans, root, path, location.objectid);
780 781
	if (ret)
		goto out;
782

783
	ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
784 785
	if (ret)
		goto out;
786 787
	else
		ret = btrfs_run_delayed_items(trans, root);
788
out:
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
	kfree(name);
	iput(inode);
	return ret;
}

/*
 * helper function to see if a given name and sequence number found
 * in an inode back reference are already in a directory and correctly
 * point to this inode
 */
static noinline int inode_in_dir(struct btrfs_root *root,
				 struct btrfs_path *path,
				 u64 dirid, u64 objectid, u64 index,
				 const char *name, int name_len)
{
	struct btrfs_dir_item *di;
	struct btrfs_key location;
	int match = 0;

	di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
					 index, name, name_len, 0);
	if (di && !IS_ERR(di)) {
		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
		if (location.objectid != objectid)
			goto out;
	} else
		goto out;
816
	btrfs_release_path(path);
817 818 819 820 821 822 823 824 825 826

	di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
	if (di && !IS_ERR(di)) {
		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
		if (location.objectid != objectid)
			goto out;
	} else
		goto out;
	match = 1;
out:
827
	btrfs_release_path(path);
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
	return match;
}

/*
 * helper function to check a log tree for a named back reference in
 * an inode.  This is used to decide if a back reference that is
 * found in the subvolume conflicts with what we find in the log.
 *
 * inode backreferences may have multiple refs in a single item,
 * during replay we process one reference at a time, and we don't
 * want to delete valid links to a file from the subvolume if that
 * link is also in the log.
 */
static noinline int backref_in_log(struct btrfs_root *log,
				   struct btrfs_key *key,
M
Mark Fasheh 已提交
843
				   u64 ref_objectid,
844 845 846 847 848 849 850 851 852 853 854 855 856
				   char *name, int namelen)
{
	struct btrfs_path *path;
	struct btrfs_inode_ref *ref;
	unsigned long ptr;
	unsigned long ptr_end;
	unsigned long name_ptr;
	int found_name_len;
	int item_size;
	int ret;
	int match = 0;

	path = btrfs_alloc_path();
857 858 859
	if (!path)
		return -ENOMEM;

860 861 862 863 864
	ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
	if (ret != 0)
		goto out;

	ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
M
Mark Fasheh 已提交
865 866 867 868 869 870 871 872 873 874

	if (key->type == BTRFS_INODE_EXTREF_KEY) {
		if (btrfs_find_name_in_ext_backref(path, ref_objectid,
						   name, namelen, NULL))
			match = 1;

		goto out;
	}

	item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
	ptr_end = ptr + item_size;
	while (ptr < ptr_end) {
		ref = (struct btrfs_inode_ref *)ptr;
		found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
		if (found_name_len == namelen) {
			name_ptr = (unsigned long)(ref + 1);
			ret = memcmp_extent_buffer(path->nodes[0], name,
						   name_ptr, namelen);
			if (ret == 0) {
				match = 1;
				goto out;
			}
		}
		ptr = (unsigned long)(ref + 1) + found_name_len;
	}
out:
	btrfs_free_path(path);
	return match;
}

895
static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
896 897
				  struct btrfs_root *root,
				  struct btrfs_path *path,
898 899 900
				  struct btrfs_root *log_root,
				  struct inode *dir, struct inode *inode,
				  struct extent_buffer *eb,
M
Mark Fasheh 已提交
901 902 903
				  u64 inode_objectid, u64 parent_objectid,
				  u64 ref_index, char *name, int namelen,
				  int *search_done)
904
{
L
liubo 已提交
905
	int ret;
M
Mark Fasheh 已提交
906 907 908
	char *victim_name;
	int victim_name_len;
	struct extent_buffer *leaf;
909
	struct btrfs_dir_item *di;
M
Mark Fasheh 已提交
910 911
	struct btrfs_key search_key;
	struct btrfs_inode_extref *extref;
912

M
Mark Fasheh 已提交
913 914 915 916 917 918
again:
	/* Search old style refs */
	search_key.objectid = inode_objectid;
	search_key.type = BTRFS_INODE_REF_KEY;
	search_key.offset = parent_objectid;
	ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
919 920 921 922
	if (ret == 0) {
		struct btrfs_inode_ref *victim_ref;
		unsigned long ptr;
		unsigned long ptr_end;
M
Mark Fasheh 已提交
923 924

		leaf = path->nodes[0];
925 926 927 928

		/* are we trying to overwrite a back ref for the root directory
		 * if so, just jump out, we're done
		 */
M
Mark Fasheh 已提交
929
		if (search_key.objectid == search_key.offset)
930
			return 1;
931 932 933 934 935 936 937

		/* check all the names in this back reference to see
		 * if they are in the log.  if so, we allow them to stay
		 * otherwise they must be unlinked as a conflict
		 */
		ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
		ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
C
Chris Mason 已提交
938
		while (ptr < ptr_end) {
939 940 941 942
			victim_ref = (struct btrfs_inode_ref *)ptr;
			victim_name_len = btrfs_inode_ref_name_len(leaf,
								   victim_ref);
			victim_name = kmalloc(victim_name_len, GFP_NOFS);
943 944
			if (!victim_name)
				return -ENOMEM;
945 946 947 948 949

			read_extent_buffer(leaf, victim_name,
					   (unsigned long)(victim_ref + 1),
					   victim_name_len);

M
Mark Fasheh 已提交
950 951 952
			if (!backref_in_log(log_root, &search_key,
					    parent_objectid,
					    victim_name,
953
					    victim_name_len)) {
Z
Zach Brown 已提交
954
				inc_nlink(inode);
955
				btrfs_release_path(path);
956

957 958 959
				ret = btrfs_unlink_inode(trans, root, dir,
							 inode, victim_name,
							 victim_name_len);
M
Mark Fasheh 已提交
960
				kfree(victim_name);
961 962
				if (ret)
					return ret;
963 964 965
				ret = btrfs_run_delayed_items(trans, root);
				if (ret)
					return ret;
M
Mark Fasheh 已提交
966 967
				*search_done = 1;
				goto again;
968 969
			}
			kfree(victim_name);
M
Mark Fasheh 已提交
970

971 972 973
			ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
		}

974 975 976 977
		/*
		 * NOTE: we have searched root tree and checked the
		 * coresponding ref, it does not need to check again.
		 */
978
		*search_done = 1;
979
	}
980
	btrfs_release_path(path);
981

M
Mark Fasheh 已提交
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
	/* Same search but for extended refs */
	extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
					   inode_objectid, parent_objectid, 0,
					   0);
	if (!IS_ERR_OR_NULL(extref)) {
		u32 item_size;
		u32 cur_offset = 0;
		unsigned long base;
		struct inode *victim_parent;

		leaf = path->nodes[0];

		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
		base = btrfs_item_ptr_offset(leaf, path->slots[0]);

		while (cur_offset < item_size) {
			extref = (struct btrfs_inode_extref *)base + cur_offset;

			victim_name_len = btrfs_inode_extref_name_len(leaf, extref);

			if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
				goto next;

			victim_name = kmalloc(victim_name_len, GFP_NOFS);
1006 1007
			if (!victim_name)
				return -ENOMEM;
M
Mark Fasheh 已提交
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
			read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
					   victim_name_len);

			search_key.objectid = inode_objectid;
			search_key.type = BTRFS_INODE_EXTREF_KEY;
			search_key.offset = btrfs_extref_hash(parent_objectid,
							      victim_name,
							      victim_name_len);
			ret = 0;
			if (!backref_in_log(log_root, &search_key,
					    parent_objectid, victim_name,
					    victim_name_len)) {
				ret = -ENOENT;
				victim_parent = read_one_inode(root,
							       parent_objectid);
				if (victim_parent) {
Z
Zach Brown 已提交
1024
					inc_nlink(inode);
M
Mark Fasheh 已提交
1025 1026 1027 1028 1029 1030 1031
					btrfs_release_path(path);

					ret = btrfs_unlink_inode(trans, root,
								 victim_parent,
								 inode,
								 victim_name,
								 victim_name_len);
1032 1033 1034
					if (!ret)
						ret = btrfs_run_delayed_items(
								  trans, root);
M
Mark Fasheh 已提交
1035 1036 1037
				}
				iput(victim_parent);
				kfree(victim_name);
1038 1039
				if (ret)
					return ret;
M
Mark Fasheh 已提交
1040 1041 1042 1043
				*search_done = 1;
				goto again;
			}
			kfree(victim_name);
1044 1045
			if (ret)
				return ret;
M
Mark Fasheh 已提交
1046 1047 1048 1049 1050 1051 1052
next:
			cur_offset += victim_name_len + sizeof(*extref);
		}
		*search_done = 1;
	}
	btrfs_release_path(path);

L
liubo 已提交
1053 1054
	/* look for a conflicting sequence number */
	di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
M
Mark Fasheh 已提交
1055
					 ref_index, name, namelen, 0);
L
liubo 已提交
1056 1057
	if (di && !IS_ERR(di)) {
		ret = drop_one_dir_item(trans, root, path, dir, di);
1058 1059
		if (ret)
			return ret;
L
liubo 已提交
1060 1061 1062 1063 1064 1065 1066 1067
	}
	btrfs_release_path(path);

	/* look for a conflicing name */
	di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
				   name, namelen, 0);
	if (di && !IS_ERR(di)) {
		ret = drop_one_dir_item(trans, root, path, dir, di);
1068 1069
		if (ret)
			return ret;
L
liubo 已提交
1070 1071 1072
	}
	btrfs_release_path(path);

1073 1074
	return 0;
}
1075

M
Mark Fasheh 已提交
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
			     u32 *namelen, char **name, u64 *index,
			     u64 *parent_objectid)
{
	struct btrfs_inode_extref *extref;

	extref = (struct btrfs_inode_extref *)ref_ptr;

	*namelen = btrfs_inode_extref_name_len(eb, extref);
	*name = kmalloc(*namelen, GFP_NOFS);
	if (*name == NULL)
		return -ENOMEM;

	read_extent_buffer(eb, *name, (unsigned long)&extref->name,
			   *namelen);

	*index = btrfs_inode_extref_index(eb, extref);
	if (parent_objectid)
		*parent_objectid = btrfs_inode_extref_parent(eb, extref);

	return 0;
}

static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
			  u32 *namelen, char **name, u64 *index)
{
	struct btrfs_inode_ref *ref;

	ref = (struct btrfs_inode_ref *)ref_ptr;

	*namelen = btrfs_inode_ref_name_len(eb, ref);
	*name = kmalloc(*namelen, GFP_NOFS);
	if (*name == NULL)
		return -ENOMEM;

	read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);

	*index = btrfs_inode_ref_index(eb, ref);

	return 0;
}

1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
/*
 * replay one inode back reference item found in the log tree.
 * eb, slot and key refer to the buffer and key found in the log tree.
 * root is the destination we are replaying into, and path is for temp
 * use by this function.  (it should be released on return).
 */
static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root,
				  struct btrfs_root *log,
				  struct btrfs_path *path,
				  struct extent_buffer *eb, int slot,
				  struct btrfs_key *key)
{
1131 1132
	struct inode *dir = NULL;
	struct inode *inode = NULL;
1133 1134
	unsigned long ref_ptr;
	unsigned long ref_end;
1135
	char *name = NULL;
1136 1137 1138
	int namelen;
	int ret;
	int search_done = 0;
M
Mark Fasheh 已提交
1139 1140 1141
	int log_ref_ver = 0;
	u64 parent_objectid;
	u64 inode_objectid;
1142
	u64 ref_index = 0;
M
Mark Fasheh 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
	int ref_struct_size;

	ref_ptr = btrfs_item_ptr_offset(eb, slot);
	ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);

	if (key->type == BTRFS_INODE_EXTREF_KEY) {
		struct btrfs_inode_extref *r;

		ref_struct_size = sizeof(struct btrfs_inode_extref);
		log_ref_ver = 1;
		r = (struct btrfs_inode_extref *)ref_ptr;
		parent_objectid = btrfs_inode_extref_parent(eb, r);
	} else {
		ref_struct_size = sizeof(struct btrfs_inode_ref);
		parent_objectid = key->offset;
	}
	inode_objectid = key->objectid;
1160

1161 1162 1163 1164 1165 1166
	/*
	 * it is possible that we didn't log all the parent directories
	 * for a given inode.  If we don't find the dir, just don't
	 * copy the back ref in.  The link count fixup code will take
	 * care of the rest
	 */
M
Mark Fasheh 已提交
1167
	dir = read_one_inode(root, parent_objectid);
1168 1169 1170 1171
	if (!dir) {
		ret = -ENOENT;
		goto out;
	}
1172

M
Mark Fasheh 已提交
1173
	inode = read_one_inode(root, inode_objectid);
1174
	if (!inode) {
1175 1176
		ret = -EIO;
		goto out;
1177 1178 1179
	}

	while (ref_ptr < ref_end) {
M
Mark Fasheh 已提交
1180 1181 1182 1183 1184 1185 1186 1187 1188
		if (log_ref_ver) {
			ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
						&ref_index, &parent_objectid);
			/*
			 * parent object can change from one array
			 * item to another.
			 */
			if (!dir)
				dir = read_one_inode(root, parent_objectid);
1189 1190 1191 1192
			if (!dir) {
				ret = -ENOENT;
				goto out;
			}
M
Mark Fasheh 已提交
1193 1194 1195 1196 1197
		} else {
			ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
					     &ref_index);
		}
		if (ret)
1198
			goto out;
1199 1200 1201

		/* if we already have a perfect match, we're done */
		if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
M
Mark Fasheh 已提交
1202
				  ref_index, name, namelen)) {
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
			/*
			 * look for a conflicting back reference in the
			 * metadata. if we find one we have to unlink that name
			 * of the file before we add our new link.  Later on, we
			 * overwrite any existing back reference, and we don't
			 * want to create dangling pointers in the directory.
			 */

			if (!search_done) {
				ret = __add_inode_ref(trans, root, path, log,
M
Mark Fasheh 已提交
1213 1214 1215 1216
						      dir, inode, eb,
						      inode_objectid,
						      parent_objectid,
						      ref_index, name, namelen,
1217
						      &search_done);
1218 1219 1220
				if (ret) {
					if (ret == 1)
						ret = 0;
1221 1222
					goto out;
				}
1223 1224 1225 1226
			}

			/* insert our name */
			ret = btrfs_add_link(trans, dir, inode, name, namelen,
M
Mark Fasheh 已提交
1227
					     0, ref_index);
1228 1229
			if (ret)
				goto out;
1230 1231 1232 1233

			btrfs_update_inode(trans, root, inode);
		}

M
Mark Fasheh 已提交
1234
		ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
1235
		kfree(name);
1236
		name = NULL;
M
Mark Fasheh 已提交
1237 1238 1239 1240
		if (log_ref_ver) {
			iput(dir);
			dir = NULL;
		}
1241
	}
1242 1243 1244

	/* finally write the back reference in the inode */
	ret = overwrite_item(trans, root, path, eb, slot, key);
1245
out:
1246
	btrfs_release_path(path);
1247
	kfree(name);
1248 1249
	iput(dir);
	iput(inode);
1250
	return ret;
1251 1252
}

1253 1254 1255 1256
static int insert_orphan_item(struct btrfs_trans_handle *trans,
			      struct btrfs_root *root, u64 offset)
{
	int ret;
1257 1258
	ret = btrfs_find_item(root, NULL, BTRFS_ORPHAN_OBJECTID,
			offset, BTRFS_ORPHAN_ITEM_KEY, NULL);
1259 1260 1261 1262 1263
	if (ret > 0)
		ret = btrfs_insert_orphan_item(trans, root, offset);
	return ret;
}

M
Mark Fasheh 已提交
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
static int count_inode_extrefs(struct btrfs_root *root,
			       struct inode *inode, struct btrfs_path *path)
{
	int ret = 0;
	int name_len;
	unsigned int nlink = 0;
	u32 item_size;
	u32 cur_offset = 0;
	u64 inode_objectid = btrfs_ino(inode);
	u64 offset = 0;
	unsigned long ptr;
	struct btrfs_inode_extref *extref;
	struct extent_buffer *leaf;

	while (1) {
		ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
					    &extref, &offset);
		if (ret)
			break;
1283

M
Mark Fasheh 已提交
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
		leaf = path->nodes[0];
		item_size = btrfs_item_size_nr(leaf, path->slots[0]);
		ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);

		while (cur_offset < item_size) {
			extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
			name_len = btrfs_inode_extref_name_len(leaf, extref);

			nlink++;

			cur_offset += name_len + sizeof(*extref);
		}

		offset++;
		btrfs_release_path(path);
	}
	btrfs_release_path(path);

	if (ret < 0)
		return ret;
	return nlink;
}

static int count_inode_refs(struct btrfs_root *root,
			       struct inode *inode, struct btrfs_path *path)
1309 1310 1311
{
	int ret;
	struct btrfs_key key;
M
Mark Fasheh 已提交
1312
	unsigned int nlink = 0;
1313 1314 1315
	unsigned long ptr;
	unsigned long ptr_end;
	int name_len;
L
Li Zefan 已提交
1316
	u64 ino = btrfs_ino(inode);
1317

L
Li Zefan 已提交
1318
	key.objectid = ino;
1319 1320 1321
	key.type = BTRFS_INODE_REF_KEY;
	key.offset = (u64)-1;

C
Chris Mason 已提交
1322
	while (1) {
1323 1324 1325 1326 1327 1328 1329 1330
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		if (ret < 0)
			break;
		if (ret > 0) {
			if (path->slots[0] == 0)
				break;
			path->slots[0]--;
		}
1331
process_slot:
1332 1333
		btrfs_item_key_to_cpu(path->nodes[0], &key,
				      path->slots[0]);
L
Li Zefan 已提交
1334
		if (key.objectid != ino ||
1335 1336 1337 1338 1339
		    key.type != BTRFS_INODE_REF_KEY)
			break;
		ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
		ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
						   path->slots[0]);
C
Chris Mason 已提交
1340
		while (ptr < ptr_end) {
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
			struct btrfs_inode_ref *ref;

			ref = (struct btrfs_inode_ref *)ptr;
			name_len = btrfs_inode_ref_name_len(path->nodes[0],
							    ref);
			ptr = (unsigned long)(ref + 1) + name_len;
			nlink++;
		}

		if (key.offset == 0)
			break;
1352 1353 1354 1355
		if (path->slots[0] > 0) {
			path->slots[0]--;
			goto process_slot;
		}
1356
		key.offset--;
1357
		btrfs_release_path(path);
1358
	}
1359
	btrfs_release_path(path);
M
Mark Fasheh 已提交
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403

	return nlink;
}

/*
 * There are a few corners where the link count of the file can't
 * be properly maintained during replay.  So, instead of adding
 * lots of complexity to the log code, we just scan the backrefs
 * for any file that has been through replay.
 *
 * The scan will update the link count on the inode to reflect the
 * number of back refs found.  If it goes down to zero, the iput
 * will free the inode.
 */
static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
					   struct btrfs_root *root,
					   struct inode *inode)
{
	struct btrfs_path *path;
	int ret;
	u64 nlink = 0;
	u64 ino = btrfs_ino(inode);

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	ret = count_inode_refs(root, inode, path);
	if (ret < 0)
		goto out;

	nlink = ret;

	ret = count_inode_extrefs(root, inode, path);
	if (ret == -ENOENT)
		ret = 0;

	if (ret < 0)
		goto out;

	nlink += ret;

	ret = 0;

1404
	if (nlink != inode->i_nlink) {
M
Miklos Szeredi 已提交
1405
		set_nlink(inode, nlink);
1406 1407
		btrfs_update_inode(trans, root, inode);
	}
1408
	BTRFS_I(inode)->index_cnt = (u64)-1;
1409

1410 1411 1412
	if (inode->i_nlink == 0) {
		if (S_ISDIR(inode->i_mode)) {
			ret = replay_dir_deletes(trans, root, NULL, path,
L
Li Zefan 已提交
1413
						 ino, 1);
1414 1415
			if (ret)
				goto out;
1416
		}
L
Li Zefan 已提交
1417
		ret = insert_orphan_item(trans, root, ino);
1418 1419
	}

M
Mark Fasheh 已提交
1420 1421 1422
out:
	btrfs_free_path(path);
	return ret;
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435
}

static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
					    struct btrfs_root *root,
					    struct btrfs_path *path)
{
	int ret;
	struct btrfs_key key;
	struct inode *inode;

	key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
	key.type = BTRFS_ORPHAN_ITEM_KEY;
	key.offset = (u64)-1;
C
Chris Mason 已提交
1436
	while (1) {
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
		if (ret < 0)
			break;

		if (ret == 1) {
			if (path->slots[0] == 0)
				break;
			path->slots[0]--;
		}

		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
		if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
		    key.type != BTRFS_ORPHAN_ITEM_KEY)
			break;

		ret = btrfs_del_item(trans, root, path);
1453 1454
		if (ret)
			goto out;
1455

1456
		btrfs_release_path(path);
1457
		inode = read_one_inode(root, key.offset);
1458 1459
		if (!inode)
			return -EIO;
1460 1461 1462

		ret = fixup_inode_link_count(trans, root, inode);
		iput(inode);
1463 1464
		if (ret)
			goto out;
1465

1466 1467 1468 1469 1470 1471
		/*
		 * fixup on a directory may create new entries,
		 * make sure we always look for the highset possible
		 * offset
		 */
		key.offset = (u64)-1;
1472
	}
1473 1474
	ret = 0;
out:
1475
	btrfs_release_path(path);
1476
	return ret;
1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
}


/*
 * record a given inode in the fixup dir so we can check its link
 * count when replay is done.  The link count is incremented here
 * so the inode won't go away until we check it
 */
static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      struct btrfs_path *path,
				      u64 objectid)
{
	struct btrfs_key key;
	int ret = 0;
	struct inode *inode;

	inode = read_one_inode(root, objectid);
1495 1496
	if (!inode)
		return -EIO;
1497 1498 1499 1500 1501 1502 1503

	key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
	btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
	key.offset = objectid;

	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);

1504
	btrfs_release_path(path);
1505
	if (ret == 0) {
1506 1507 1508
		if (!inode->i_nlink)
			set_nlink(inode, 1);
		else
Z
Zach Brown 已提交
1509
			inc_nlink(inode);
1510
		ret = btrfs_update_inode(trans, root, inode);
1511 1512 1513
	} else if (ret == -EEXIST) {
		ret = 0;
	} else {
1514
		BUG(); /* Logic Error */
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
	}
	iput(inode);

	return ret;
}

/*
 * when replaying the log for a directory, we only insert names
 * for inodes that actually exist.  This means an fsync on a directory
 * does not implicitly fsync all the new files in it
 */
static noinline int insert_one_name(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root,
				    struct btrfs_path *path,
				    u64 dirid, u64 index,
				    char *name, int name_len, u8 type,
				    struct btrfs_key *location)
{
	struct inode *inode;
	struct inode *dir;
	int ret;

	inode = read_one_inode(root, location->objectid);
	if (!inode)
		return -ENOENT;

	dir = read_one_inode(root, dirid);
	if (!dir) {
		iput(inode);
		return -EIO;
	}
1546

1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
	ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);

	/* FIXME, put inode into FIXUP list */

	iput(inode);
	iput(dir);
	return ret;
}

/*
 * take a single entry in a log directory item and replay it into
 * the subvolume.
 *
 * if a conflicting item exists in the subdirectory already,
 * the inode it points to is unlinked and put into the link count
 * fix up tree.
 *
 * If a name from the log points to a file or directory that does
 * not exist in the FS, it is skipped.  fsyncs on directories
 * do not force down inodes inside that directory, just changes to the
 * names or unlinks in a directory.
 */
static noinline int replay_one_name(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root,
				    struct btrfs_path *path,
				    struct extent_buffer *eb,
				    struct btrfs_dir_item *di,
				    struct btrfs_key *key)
{
	char *name;
	int name_len;
	struct btrfs_dir_item *dst_di;
	struct btrfs_key found_key;
	struct btrfs_key log_key;
	struct inode *dir;
	u8 log_type;
C
Chris Mason 已提交
1583
	int exists;
1584
	int ret = 0;
1585
	bool update_size = (key->type == BTRFS_DIR_INDEX_KEY);
1586 1587

	dir = read_one_inode(root, key->objectid);
1588 1589
	if (!dir)
		return -EIO;
1590 1591 1592

	name_len = btrfs_dir_name_len(eb, di);
	name = kmalloc(name_len, GFP_NOFS);
1593 1594 1595 1596
	if (!name) {
		ret = -ENOMEM;
		goto out;
	}
1597

1598 1599 1600 1601 1602
	log_type = btrfs_dir_type(eb, di);
	read_extent_buffer(eb, name, (unsigned long)(di + 1),
		   name_len);

	btrfs_dir_item_key_to_cpu(eb, di, &log_key);
C
Chris Mason 已提交
1603 1604 1605 1606 1607
	exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
	if (exists == 0)
		exists = 1;
	else
		exists = 0;
1608
	btrfs_release_path(path);
C
Chris Mason 已提交
1609

1610 1611 1612
	if (key->type == BTRFS_DIR_ITEM_KEY) {
		dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
				       name, name_len, 1);
C
Chris Mason 已提交
1613
	} else if (key->type == BTRFS_DIR_INDEX_KEY) {
1614 1615 1616 1617 1618
		dst_di = btrfs_lookup_dir_index_item(trans, root, path,
						     key->objectid,
						     key->offset, name,
						     name_len, 1);
	} else {
1619 1620 1621
		/* Corruption */
		ret = -EINVAL;
		goto out;
1622
	}
1623
	if (IS_ERR_OR_NULL(dst_di)) {
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
		/* we need a sequence number to insert, so we only
		 * do inserts for the BTRFS_DIR_INDEX_KEY types
		 */
		if (key->type != BTRFS_DIR_INDEX_KEY)
			goto out;
		goto insert;
	}

	btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
	/* the existing item matches the logged item */
	if (found_key.objectid == log_key.objectid &&
	    found_key.type == log_key.type &&
	    found_key.offset == log_key.offset &&
	    btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
		goto out;
	}

	/*
	 * don't drop the conflicting directory entry if the inode
	 * for the new entry doesn't exist
	 */
C
Chris Mason 已提交
1645
	if (!exists)
1646 1647 1648
		goto out;

	ret = drop_one_dir_item(trans, root, path, dir, dst_di);
1649 1650
	if (ret)
		goto out;
1651 1652 1653 1654

	if (key->type == BTRFS_DIR_INDEX_KEY)
		goto insert;
out:
1655
	btrfs_release_path(path);
1656 1657 1658 1659
	if (!ret && update_size) {
		btrfs_i_size_write(dir, dir->i_size + name_len * 2);
		ret = btrfs_update_inode(trans, root, dir);
	}
1660 1661
	kfree(name);
	iput(dir);
1662
	return ret;
1663 1664

insert:
1665
	btrfs_release_path(path);
1666 1667
	ret = insert_one_name(trans, root, path, key->objectid, key->offset,
			      name, name_len, log_type, &log_key);
1668 1669
	if (ret && ret != -ENOENT)
		goto out;
1670
	update_size = false;
1671
	ret = 0;
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
	goto out;
}

/*
 * find all the names in a directory item and reconcile them into
 * the subvolume.  Only BTRFS_DIR_ITEM_KEY types will have more than
 * one name in a directory item, but the same code gets used for
 * both directory index types
 */
static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
					struct btrfs_root *root,
					struct btrfs_path *path,
					struct extent_buffer *eb, int slot,
					struct btrfs_key *key)
{
	int ret;
	u32 item_size = btrfs_item_size_nr(eb, slot);
	struct btrfs_dir_item *di;
	int name_len;
	unsigned long ptr;
	unsigned long ptr_end;

	ptr = btrfs_item_ptr_offset(eb, slot);
	ptr_end = ptr + item_size;
C
Chris Mason 已提交
1696
	while (ptr < ptr_end) {
1697
		di = (struct btrfs_dir_item *)ptr;
1698 1699
		if (verify_dir_item(root, eb, di))
			return -EIO;
1700 1701
		name_len = btrfs_dir_name_len(eb, di);
		ret = replay_one_name(trans, root, path, eb, di, key);
1702 1703
		if (ret)
			return ret;
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
		ptr = (unsigned long)(di + 1);
		ptr += name_len;
	}
	return 0;
}

/*
 * directory replay has two parts.  There are the standard directory
 * items in the log copied from the subvolume, and range items
 * created in the log while the subvolume was logged.
 *
 * The range items tell us which parts of the key space the log
 * is authoritative for.  During replay, if a key in the subvolume
 * directory is in a logged range item, but not actually in the log
 * that means it was deleted from the directory before the fsync
 * and should be removed.
 */
static noinline int find_dir_range(struct btrfs_root *root,
				   struct btrfs_path *path,
				   u64 dirid, int key_type,
				   u64 *start_ret, u64 *end_ret)
{
	struct btrfs_key key;
	u64 found_end;
	struct btrfs_dir_log_item *item;
	int ret;
	int nritems;

	if (*start_ret == (u64)-1)
		return 1;

	key.objectid = dirid;
	key.type = key_type;
	key.offset = *start_ret;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto out;
	if (ret > 0) {
		if (path->slots[0] == 0)
			goto out;
		path->slots[0]--;
	}
	if (ret != 0)
		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);

	if (key.type != key_type || key.objectid != dirid) {
		ret = 1;
		goto next;
	}
	item = btrfs_item_ptr(path->nodes[0], path->slots[0],
			      struct btrfs_dir_log_item);
	found_end = btrfs_dir_log_end(path->nodes[0], item);

	if (*start_ret >= key.offset && *start_ret <= found_end) {
		ret = 0;
		*start_ret = key.offset;
		*end_ret = found_end;
		goto out;
	}
	ret = 1;
next:
	/* check the next slot in the tree to see if it is a valid item */
	nritems = btrfs_header_nritems(path->nodes[0]);
	if (path->slots[0] >= nritems) {
		ret = btrfs_next_leaf(root, path);
		if (ret)
			goto out;
	} else {
		path->slots[0]++;
	}

	btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);

	if (key.type != key_type || key.objectid != dirid) {
		ret = 1;
		goto out;
	}
	item = btrfs_item_ptr(path->nodes[0], path->slots[0],
			      struct btrfs_dir_log_item);
	found_end = btrfs_dir_log_end(path->nodes[0], item);
	*start_ret = key.offset;
	*end_ret = found_end;
	ret = 0;
out:
1789
	btrfs_release_path(path);
1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824
	return ret;
}

/*
 * this looks for a given directory item in the log.  If the directory
 * item is not in the log, the item is removed and the inode it points
 * to is unlinked
 */
static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
				      struct btrfs_root *root,
				      struct btrfs_root *log,
				      struct btrfs_path *path,
				      struct btrfs_path *log_path,
				      struct inode *dir,
				      struct btrfs_key *dir_key)
{
	int ret;
	struct extent_buffer *eb;
	int slot;
	u32 item_size;
	struct btrfs_dir_item *di;
	struct btrfs_dir_item *log_di;
	int name_len;
	unsigned long ptr;
	unsigned long ptr_end;
	char *name;
	struct inode *inode;
	struct btrfs_key location;

again:
	eb = path->nodes[0];
	slot = path->slots[0];
	item_size = btrfs_item_size_nr(eb, slot);
	ptr = btrfs_item_ptr_offset(eb, slot);
	ptr_end = ptr + item_size;
C
Chris Mason 已提交
1825
	while (ptr < ptr_end) {
1826
		di = (struct btrfs_dir_item *)ptr;
1827 1828 1829 1830 1831
		if (verify_dir_item(root, eb, di)) {
			ret = -EIO;
			goto out;
		}

1832 1833 1834 1835 1836 1837 1838 1839 1840
		name_len = btrfs_dir_name_len(eb, di);
		name = kmalloc(name_len, GFP_NOFS);
		if (!name) {
			ret = -ENOMEM;
			goto out;
		}
		read_extent_buffer(eb, name, (unsigned long)(di + 1),
				  name_len);
		log_di = NULL;
1841
		if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
1842 1843 1844
			log_di = btrfs_lookup_dir_item(trans, log, log_path,
						       dir_key->objectid,
						       name, name_len, 0);
1845
		} else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
1846 1847 1848 1849 1850 1851
			log_di = btrfs_lookup_dir_index_item(trans, log,
						     log_path,
						     dir_key->objectid,
						     dir_key->offset,
						     name, name_len, 0);
		}
1852
		if (!log_di || (IS_ERR(log_di) && PTR_ERR(log_di) == -ENOENT)) {
1853
			btrfs_dir_item_key_to_cpu(eb, di, &location);
1854 1855
			btrfs_release_path(path);
			btrfs_release_path(log_path);
1856
			inode = read_one_inode(root, location.objectid);
1857 1858 1859 1860
			if (!inode) {
				kfree(name);
				return -EIO;
			}
1861 1862 1863

			ret = link_to_fixup_dir(trans, root,
						path, location.objectid);
1864 1865 1866 1867 1868 1869
			if (ret) {
				kfree(name);
				iput(inode);
				goto out;
			}

Z
Zach Brown 已提交
1870
			inc_nlink(inode);
1871 1872
			ret = btrfs_unlink_inode(trans, root, dir, inode,
						 name, name_len);
1873
			if (!ret)
1874
				ret = btrfs_run_delayed_items(trans, root);
1875 1876
			kfree(name);
			iput(inode);
1877 1878
			if (ret)
				goto out;
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888

			/* there might still be more names under this key
			 * check and repeat if required
			 */
			ret = btrfs_search_slot(NULL, root, dir_key, path,
						0, 0);
			if (ret == 0)
				goto again;
			ret = 0;
			goto out;
1889 1890 1891
		} else if (IS_ERR(log_di)) {
			kfree(name);
			return PTR_ERR(log_di);
1892
		}
1893
		btrfs_release_path(log_path);
1894 1895 1896 1897 1898 1899 1900
		kfree(name);

		ptr = (unsigned long)(di + 1);
		ptr += name_len;
	}
	ret = 0;
out:
1901 1902
	btrfs_release_path(path);
	btrfs_release_path(log_path);
1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
	return ret;
}

/*
 * deletion replay happens before we copy any new directory items
 * out of the log or out of backreferences from inodes.  It
 * scans the log to find ranges of keys that log is authoritative for,
 * and then scans the directory to find items in those ranges that are
 * not present in the log.
 *
 * Anything we don't find in the log is unlinked and removed from the
 * directory.
 */
static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
				       struct btrfs_root *root,
				       struct btrfs_root *log,
				       struct btrfs_path *path,
1920
				       u64 dirid, int del_all)
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
{
	u64 range_start;
	u64 range_end;
	int key_type = BTRFS_DIR_LOG_ITEM_KEY;
	int ret = 0;
	struct btrfs_key dir_key;
	struct btrfs_key found_key;
	struct btrfs_path *log_path;
	struct inode *dir;

	dir_key.objectid = dirid;
	dir_key.type = BTRFS_DIR_ITEM_KEY;
	log_path = btrfs_alloc_path();
	if (!log_path)
		return -ENOMEM;

	dir = read_one_inode(root, dirid);
	/* it isn't an error if the inode isn't there, that can happen
	 * because we replay the deletes before we copy in the inode item
	 * from the log
	 */
	if (!dir) {
		btrfs_free_path(log_path);
		return 0;
	}
again:
	range_start = 0;
	range_end = 0;
C
Chris Mason 已提交
1949
	while (1) {
1950 1951 1952 1953 1954 1955 1956 1957
		if (del_all)
			range_end = (u64)-1;
		else {
			ret = find_dir_range(log, path, dirid, key_type,
					     &range_start, &range_end);
			if (ret != 0)
				break;
		}
1958 1959

		dir_key.offset = range_start;
C
Chris Mason 已提交
1960
		while (1) {
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
			int nritems;
			ret = btrfs_search_slot(NULL, root, &dir_key, path,
						0, 0);
			if (ret < 0)
				goto out;

			nritems = btrfs_header_nritems(path->nodes[0]);
			if (path->slots[0] >= nritems) {
				ret = btrfs_next_leaf(root, path);
				if (ret)
					break;
			}
			btrfs_item_key_to_cpu(path->nodes[0], &found_key,
					      path->slots[0]);
			if (found_key.objectid != dirid ||
			    found_key.type != dir_key.type)
				goto next_type;

			if (found_key.offset > range_end)
				break;

			ret = check_item_in_log(trans, root, log, path,
1983 1984
						log_path, dir,
						&found_key);
1985 1986
			if (ret)
				goto out;
1987 1988 1989 1990
			if (found_key.offset == (u64)-1)
				break;
			dir_key.offset = found_key.offset + 1;
		}
1991
		btrfs_release_path(path);
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
		if (range_end == (u64)-1)
			break;
		range_start = range_end + 1;
	}

next_type:
	ret = 0;
	if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
		key_type = BTRFS_DIR_LOG_INDEX_KEY;
		dir_key.type = BTRFS_DIR_INDEX_KEY;
2002
		btrfs_release_path(path);
2003 2004 2005
		goto again;
	}
out:
2006
	btrfs_release_path(path);
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
	btrfs_free_path(log_path);
	iput(dir);
	return ret;
}

/*
 * the process_func used to replay items from the log tree.  This
 * gets called in two different stages.  The first stage just looks
 * for inodes and makes sure they are all copied into the subvolume.
 *
 * The second stage copies all the other item types from the log into
 * the subvolume.  The two stage approach is slower, but gets rid of
 * lots of complexity around inodes referencing other inodes that exist
 * only in the log (references come from either directory items or inode
 * back refs).
 */
static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
			     struct walk_control *wc, u64 gen)
{
	int nritems;
	struct btrfs_path *path;
	struct btrfs_root *root = wc->replay_dest;
	struct btrfs_key key;
	int level;
	int i;
	int ret;

2034 2035 2036
	ret = btrfs_read_buffer(eb, gen);
	if (ret)
		return ret;
2037 2038 2039 2040 2041 2042 2043

	level = btrfs_header_level(eb);

	if (level != 0)
		return 0;

	path = btrfs_alloc_path();
2044 2045
	if (!path)
		return -ENOMEM;
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061

	nritems = btrfs_header_nritems(eb);
	for (i = 0; i < nritems; i++) {
		btrfs_item_key_to_cpu(eb, &key, i);

		/* inode keys are done during the first stage */
		if (key.type == BTRFS_INODE_ITEM_KEY &&
		    wc->stage == LOG_WALK_REPLAY_INODES) {
			struct btrfs_inode_item *inode_item;
			u32 mode;

			inode_item = btrfs_item_ptr(eb, i,
					    struct btrfs_inode_item);
			mode = btrfs_inode_mode(eb, inode_item);
			if (S_ISDIR(mode)) {
				ret = replay_dir_deletes(wc->trans,
2062
					 root, log, path, key.objectid, 0);
2063 2064
				if (ret)
					break;
2065 2066 2067
			}
			ret = overwrite_item(wc->trans, root, path,
					     eb, i, &key);
2068 2069
			if (ret)
				break;
2070

2071 2072 2073
			/* for regular files, make sure corresponding
			 * orhpan item exist. extents past the new EOF
			 * will be truncated later by orphan cleanup.
2074 2075
			 */
			if (S_ISREG(mode)) {
2076 2077
				ret = insert_orphan_item(wc->trans, root,
							 key.objectid);
2078 2079
				if (ret)
					break;
2080
			}
2081

2082 2083
			ret = link_to_fixup_dir(wc->trans, root,
						path, key.objectid);
2084 2085
			if (ret)
				break;
2086
		}
2087 2088 2089 2090 2091 2092 2093 2094 2095

		if (key.type == BTRFS_DIR_INDEX_KEY &&
		    wc->stage == LOG_WALK_REPLAY_DIR_INDEX) {
			ret = replay_one_dir_item(wc->trans, root, path,
						  eb, i, &key);
			if (ret)
				break;
		}

2096 2097 2098 2099 2100 2101 2102
		if (wc->stage < LOG_WALK_REPLAY_ALL)
			continue;

		/* these keys are simply copied */
		if (key.type == BTRFS_XATTR_ITEM_KEY) {
			ret = overwrite_item(wc->trans, root, path,
					     eb, i, &key);
2103 2104
			if (ret)
				break;
2105 2106
		} else if (key.type == BTRFS_INODE_REF_KEY ||
			   key.type == BTRFS_INODE_EXTREF_KEY) {
M
Mark Fasheh 已提交
2107 2108
			ret = add_inode_ref(wc->trans, root, log, path,
					    eb, i, &key);
2109 2110 2111
			if (ret && ret != -ENOENT)
				break;
			ret = 0;
2112 2113 2114
		} else if (key.type == BTRFS_EXTENT_DATA_KEY) {
			ret = replay_one_extent(wc->trans, root, path,
						eb, i, &key);
2115 2116
			if (ret)
				break;
2117
		} else if (key.type == BTRFS_DIR_ITEM_KEY) {
2118 2119
			ret = replay_one_dir_item(wc->trans, root, path,
						  eb, i, &key);
2120 2121
			if (ret)
				break;
2122 2123 2124
		}
	}
	btrfs_free_path(path);
2125
	return ret;
2126 2127
}

C
Chris Mason 已提交
2128
static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
				   struct btrfs_root *root,
				   struct btrfs_path *path, int *level,
				   struct walk_control *wc)
{
	u64 root_owner;
	u64 bytenr;
	u64 ptr_gen;
	struct extent_buffer *next;
	struct extent_buffer *cur;
	struct extent_buffer *parent;
	u32 blocksize;
	int ret = 0;

	WARN_ON(*level < 0);
	WARN_ON(*level >= BTRFS_MAX_LEVEL);

C
Chris Mason 已提交
2145
	while (*level > 0) {
2146 2147 2148 2149
		WARN_ON(*level < 0);
		WARN_ON(*level >= BTRFS_MAX_LEVEL);
		cur = path->nodes[*level];

2150
		WARN_ON(btrfs_header_level(cur) != *level);
2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163

		if (path->slots[*level] >=
		    btrfs_header_nritems(cur))
			break;

		bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
		ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
		blocksize = btrfs_level_size(root, *level - 1);

		parent = path->nodes[*level];
		root_owner = btrfs_header_owner(parent);

		next = btrfs_find_create_tree_block(root, bytenr, blocksize);
2164 2165
		if (!next)
			return -ENOMEM;
2166 2167

		if (*level == 1) {
2168
			ret = wc->process_func(root, next, wc, ptr_gen);
2169 2170
			if (ret) {
				free_extent_buffer(next);
2171
				return ret;
2172
			}
2173

2174 2175
			path->slots[*level]++;
			if (wc->free) {
2176 2177 2178 2179 2180
				ret = btrfs_read_buffer(next, ptr_gen);
				if (ret) {
					free_extent_buffer(next);
					return ret;
				}
2181

2182 2183 2184 2185 2186 2187 2188
				if (trans) {
					btrfs_tree_lock(next);
					btrfs_set_lock_blocking(next);
					clean_tree_block(trans, root, next);
					btrfs_wait_tree_block_writeback(next);
					btrfs_tree_unlock(next);
				}
2189 2190 2191

				WARN_ON(root_owner !=
					BTRFS_TREE_LOG_OBJECTID);
2192
				ret = btrfs_free_and_pin_reserved_extent(root,
2193
							 bytenr, blocksize);
2194 2195 2196 2197
				if (ret) {
					free_extent_buffer(next);
					return ret;
				}
2198 2199 2200 2201
			}
			free_extent_buffer(next);
			continue;
		}
2202 2203 2204 2205 2206
		ret = btrfs_read_buffer(next, ptr_gen);
		if (ret) {
			free_extent_buffer(next);
			return ret;
		}
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218

		WARN_ON(*level <= 0);
		if (path->nodes[*level-1])
			free_extent_buffer(path->nodes[*level-1]);
		path->nodes[*level-1] = next;
		*level = btrfs_header_level(next);
		path->slots[*level] = 0;
		cond_resched();
	}
	WARN_ON(*level < 0);
	WARN_ON(*level >= BTRFS_MAX_LEVEL);

2219
	path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2220 2221 2222 2223 2224

	cond_resched();
	return 0;
}

C
Chris Mason 已提交
2225
static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
2226 2227 2228 2229 2230 2231 2232 2233 2234
				 struct btrfs_root *root,
				 struct btrfs_path *path, int *level,
				 struct walk_control *wc)
{
	u64 root_owner;
	int i;
	int slot;
	int ret;

C
Chris Mason 已提交
2235
	for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2236
		slot = path->slots[i];
2237
		if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
2238 2239 2240 2241 2242
			path->slots[i]++;
			*level = i;
			WARN_ON(*level == 0);
			return 0;
		} else {
Z
Zheng Yan 已提交
2243 2244 2245 2246 2247 2248 2249
			struct extent_buffer *parent;
			if (path->nodes[*level] == root->node)
				parent = path->nodes[*level];
			else
				parent = path->nodes[*level + 1];

			root_owner = btrfs_header_owner(parent);
2250
			ret = wc->process_func(root, path->nodes[*level], wc,
2251
				 btrfs_header_generation(path->nodes[*level]));
2252 2253 2254
			if (ret)
				return ret;

2255 2256 2257 2258 2259
			if (wc->free) {
				struct extent_buffer *next;

				next = path->nodes[*level];

2260 2261 2262 2263 2264 2265 2266
				if (trans) {
					btrfs_tree_lock(next);
					btrfs_set_lock_blocking(next);
					clean_tree_block(trans, root, next);
					btrfs_wait_tree_block_writeback(next);
					btrfs_tree_unlock(next);
				}
2267 2268

				WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
2269
				ret = btrfs_free_and_pin_reserved_extent(root,
2270
						path->nodes[*level]->start,
2271
						path->nodes[*level]->len);
2272 2273
				if (ret)
					return ret;
2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297
			}
			free_extent_buffer(path->nodes[*level]);
			path->nodes[*level] = NULL;
			*level = i + 1;
		}
	}
	return 1;
}

/*
 * drop the reference count on the tree rooted at 'snap'.  This traverses
 * the tree freeing any blocks that have a ref count of zero after being
 * decremented.
 */
static int walk_log_tree(struct btrfs_trans_handle *trans,
			 struct btrfs_root *log, struct walk_control *wc)
{
	int ret = 0;
	int wret;
	int level;
	struct btrfs_path *path;
	int orig_level;

	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
2298 2299
	if (!path)
		return -ENOMEM;
2300 2301 2302 2303 2304 2305 2306

	level = btrfs_header_level(log->node);
	orig_level = level;
	path->nodes[level] = log->node;
	extent_buffer_get(log->node);
	path->slots[level] = 0;

C
Chris Mason 已提交
2307
	while (1) {
2308 2309 2310
		wret = walk_down_log_tree(trans, log, path, &level, wc);
		if (wret > 0)
			break;
2311
		if (wret < 0) {
2312
			ret = wret;
2313 2314
			goto out;
		}
2315 2316 2317 2318

		wret = walk_up_log_tree(trans, log, path, &level, wc);
		if (wret > 0)
			break;
2319
		if (wret < 0) {
2320
			ret = wret;
2321 2322
			goto out;
		}
2323 2324 2325 2326
	}

	/* was the root node processed? if not, catch it here */
	if (path->nodes[orig_level]) {
2327
		ret = wc->process_func(log, path->nodes[orig_level], wc,
2328
			 btrfs_header_generation(path->nodes[orig_level]));
2329 2330
		if (ret)
			goto out;
2331 2332 2333 2334 2335
		if (wc->free) {
			struct extent_buffer *next;

			next = path->nodes[orig_level];

2336 2337 2338 2339 2340 2341 2342
			if (trans) {
				btrfs_tree_lock(next);
				btrfs_set_lock_blocking(next);
				clean_tree_block(trans, log, next);
				btrfs_wait_tree_block_writeback(next);
				btrfs_tree_unlock(next);
			}
2343 2344 2345

			WARN_ON(log->root_key.objectid !=
				BTRFS_TREE_LOG_OBJECTID);
2346
			ret = btrfs_free_and_pin_reserved_extent(log, next->start,
2347
							 next->len);
2348 2349
			if (ret)
				goto out;
2350 2351 2352
		}
	}

2353
out:
2354 2355 2356 2357
	btrfs_free_path(path);
	return ret;
}

Y
Yan Zheng 已提交
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377
/*
 * helper function to update the item for a given subvolumes log root
 * in the tree of log roots
 */
static int update_log_root(struct btrfs_trans_handle *trans,
			   struct btrfs_root *log)
{
	int ret;

	if (log->log_transid == 1) {
		/* insert root item on the first sync */
		ret = btrfs_insert_root(trans, log->fs_info->log_root_tree,
				&log->root_key, &log->root_item);
	} else {
		ret = btrfs_update_root(trans, log->fs_info->log_root_tree,
				&log->root_key, &log->root_item);
	}
	return ret;
}

2378 2379
static void wait_log_commit(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root, int transid)
2380 2381
{
	DEFINE_WAIT(wait);
Y
Yan Zheng 已提交
2382
	int index = transid % 2;
2383

Y
Yan Zheng 已提交
2384 2385 2386 2387 2388
	/*
	 * we only allow two pending log transactions at a time,
	 * so we know that if ours is more than 2 older than the
	 * current transaction, we're done
	 */
2389
	do {
Y
Yan Zheng 已提交
2390 2391 2392
		prepare_to_wait(&root->log_commit_wait[index],
				&wait, TASK_UNINTERRUPTIBLE);
		mutex_unlock(&root->log_mutex);
2393

2394
		if (root->log_transid_committed < transid &&
Y
Yan Zheng 已提交
2395 2396
		    atomic_read(&root->log_commit[index]))
			schedule();
2397

Y
Yan Zheng 已提交
2398 2399
		finish_wait(&root->log_commit_wait[index], &wait);
		mutex_lock(&root->log_mutex);
2400
	} while (root->log_transid_committed < transid &&
Y
Yan Zheng 已提交
2401 2402 2403
		 atomic_read(&root->log_commit[index]));
}

2404 2405
static void wait_for_writer(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root)
Y
Yan Zheng 已提交
2406 2407
{
	DEFINE_WAIT(wait);
2408 2409

	while (atomic_read(&root->log_writers)) {
Y
Yan Zheng 已提交
2410 2411 2412
		prepare_to_wait(&root->log_writer_wait,
				&wait, TASK_UNINTERRUPTIBLE);
		mutex_unlock(&root->log_mutex);
2413
		if (atomic_read(&root->log_writers))
2414
			schedule();
Y
Yan Zheng 已提交
2415 2416 2417
		mutex_lock(&root->log_mutex);
		finish_wait(&root->log_writer_wait, &wait);
	}
2418 2419
}

2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
static inline void btrfs_remove_log_ctx(struct btrfs_root *root,
					struct btrfs_log_ctx *ctx)
{
	if (!ctx)
		return;

	mutex_lock(&root->log_mutex);
	list_del_init(&ctx->list);
	mutex_unlock(&root->log_mutex);
}

/* 
 * Invoked in log mutex context, or be sure there is no other task which
 * can access the list.
 */
static inline void btrfs_remove_all_log_ctxs(struct btrfs_root *root,
					     int index, int error)
{
	struct btrfs_log_ctx *ctx;

	if (!error) {
		INIT_LIST_HEAD(&root->log_ctxs[index]);
		return;
	}

	list_for_each_entry(ctx, &root->log_ctxs[index], list)
		ctx->log_ret = error;

	INIT_LIST_HEAD(&root->log_ctxs[index]);
}

2451 2452 2453
/*
 * btrfs_sync_log does sends a given tree log down to the disk and
 * updates the super blocks to record it.  When this call is done,
2454 2455 2456 2457 2458 2459 2460 2461
 * you know that any inodes previously logged are safely on disk only
 * if it returns 0.
 *
 * Any other return value means you need to call btrfs_commit_transaction.
 * Some of the edge cases for fsyncing directories that have had unlinks
 * or renames done in the past mean that sometimes the only safe
 * fsync is to commit the whole FS.  When btrfs_sync_log returns -EAGAIN,
 * that has happened.
2462 2463
 */
int btrfs_sync_log(struct btrfs_trans_handle *trans,
2464
		   struct btrfs_root *root, struct btrfs_log_ctx *ctx)
2465
{
Y
Yan Zheng 已提交
2466 2467
	int index1;
	int index2;
2468
	int mark;
2469 2470
	int ret;
	struct btrfs_root *log = root->log_root;
Y
Yan Zheng 已提交
2471
	struct btrfs_root *log_root_tree = root->fs_info->log_root_tree;
2472
	int log_transid = 0;
2473
	struct btrfs_log_ctx root_log_ctx;
2474
	struct blk_plug plug;
2475

Y
Yan Zheng 已提交
2476
	mutex_lock(&root->log_mutex);
2477 2478 2479 2480 2481 2482 2483
	log_transid = ctx->log_transid;
	if (root->log_transid_committed >= log_transid) {
		mutex_unlock(&root->log_mutex);
		return ctx->log_ret;
	}

	index1 = log_transid % 2;
Y
Yan Zheng 已提交
2484
	if (atomic_read(&root->log_commit[index1])) {
2485
		wait_log_commit(trans, root, log_transid);
Y
Yan Zheng 已提交
2486
		mutex_unlock(&root->log_mutex);
2487
		return ctx->log_ret;
2488
	}
2489
	ASSERT(log_transid == root->log_transid);
Y
Yan Zheng 已提交
2490 2491 2492 2493
	atomic_set(&root->log_commit[index1], 1);

	/* wait for previous tree log sync to complete */
	if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
2494
		wait_log_commit(trans, root, log_transid - 1);
2495

2496
	while (1) {
M
Miao Xie 已提交
2497
		int batch = atomic_read(&root->log_batch);
2498
		/* when we're on an ssd, just kick the log commit out */
2499 2500
		if (!btrfs_test_opt(root, SSD) &&
		    test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) {
2501 2502 2503 2504
			mutex_unlock(&root->log_mutex);
			schedule_timeout_uninterruptible(1);
			mutex_lock(&root->log_mutex);
		}
2505
		wait_for_writer(trans, root);
M
Miao Xie 已提交
2506
		if (batch == atomic_read(&root->log_batch))
2507 2508 2509
			break;
	}

2510
	/* bail out if we need to do a full commit */
2511
	if (btrfs_need_log_full_commit(root->fs_info, trans)) {
2512
		ret = -EAGAIN;
2513
		btrfs_free_logged_extents(log, log_transid);
2514 2515 2516 2517
		mutex_unlock(&root->log_mutex);
		goto out;
	}

2518 2519 2520 2521 2522
	if (log_transid % 2 == 0)
		mark = EXTENT_DIRTY;
	else
		mark = EXTENT_NEW;

2523 2524 2525
	/* we start IO on  all the marked extents here, but we don't actually
	 * wait for them until later.
	 */
2526
	blk_start_plug(&plug);
2527
	ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark);
2528
	if (ret) {
2529
		blk_finish_plug(&plug);
2530
		btrfs_abort_transaction(trans, root, ret);
2531
		btrfs_free_logged_extents(log, log_transid);
2532
		btrfs_set_log_full_commit(root->fs_info, trans);
2533 2534 2535
		mutex_unlock(&root->log_mutex);
		goto out;
	}
Y
Yan Zheng 已提交
2536

2537
	btrfs_set_root_node(&log->root_item, log->node);
Y
Yan Zheng 已提交
2538 2539 2540

	root->log_transid++;
	log->log_transid = root->log_transid;
2541
	root->log_start_pid = 0;
Y
Yan Zheng 已提交
2542
	/*
2543 2544 2545
	 * IO has been started, blocks of the log tree have WRITTEN flag set
	 * in their headers. new modifications of the log will be written to
	 * new positions. so it's safe to allow log writers to go in.
Y
Yan Zheng 已提交
2546 2547 2548
	 */
	mutex_unlock(&root->log_mutex);

2549 2550
	btrfs_init_log_ctx(&root_log_ctx);

Y
Yan Zheng 已提交
2551
	mutex_lock(&log_root_tree->log_mutex);
M
Miao Xie 已提交
2552
	atomic_inc(&log_root_tree->log_batch);
Y
Yan Zheng 已提交
2553
	atomic_inc(&log_root_tree->log_writers);
2554 2555 2556 2557 2558

	index2 = log_root_tree->log_transid % 2;
	list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
	root_log_ctx.log_transid = log_root_tree->log_transid;

Y
Yan Zheng 已提交
2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
	mutex_unlock(&log_root_tree->log_mutex);

	ret = update_log_root(trans, log);

	mutex_lock(&log_root_tree->log_mutex);
	if (atomic_dec_and_test(&log_root_tree->log_writers)) {
		smp_mb();
		if (waitqueue_active(&log_root_tree->log_writer_wait))
			wake_up(&log_root_tree->log_writer_wait);
	}

2570
	if (ret) {
2571 2572 2573
		if (!list_empty(&root_log_ctx.list))
			list_del_init(&root_log_ctx.list);

2574
		blk_finish_plug(&plug);
2575 2576
		btrfs_set_log_full_commit(root->fs_info, trans);

2577 2578 2579 2580 2581
		if (ret != -ENOSPC) {
			btrfs_abort_transaction(trans, root, ret);
			mutex_unlock(&log_root_tree->log_mutex);
			goto out;
		}
2582
		btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2583
		btrfs_free_logged_extents(log, log_transid);
2584 2585 2586 2587 2588
		mutex_unlock(&log_root_tree->log_mutex);
		ret = -EAGAIN;
		goto out;
	}

2589 2590 2591 2592 2593
	if (log_root_tree->log_transid_committed >= root_log_ctx.log_transid) {
		mutex_unlock(&log_root_tree->log_mutex);
		ret = root_log_ctx.log_ret;
		goto out;
	}
2594

2595
	index2 = root_log_ctx.log_transid % 2;
Y
Yan Zheng 已提交
2596
	if (atomic_read(&log_root_tree->log_commit[index2])) {
2597
		blk_finish_plug(&plug);
2598
		btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2599
		wait_log_commit(trans, log_root_tree,
2600
				root_log_ctx.log_transid);
2601
		btrfs_free_logged_extents(log, log_transid);
Y
Yan Zheng 已提交
2602
		mutex_unlock(&log_root_tree->log_mutex);
2603
		ret = root_log_ctx.log_ret;
Y
Yan Zheng 已提交
2604 2605
		goto out;
	}
2606
	ASSERT(root_log_ctx.log_transid == log_root_tree->log_transid);
Y
Yan Zheng 已提交
2607 2608
	atomic_set(&log_root_tree->log_commit[index2], 1);

2609 2610
	if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
		wait_log_commit(trans, log_root_tree,
2611
				root_log_ctx.log_transid - 1);
2612 2613 2614
	}

	wait_for_writer(trans, log_root_tree);
Y
Yan Zheng 已提交
2615

2616 2617 2618 2619
	/*
	 * now that we've moved on to the tree of log tree roots,
	 * check the full commit flag again
	 */
2620
	if (btrfs_need_log_full_commit(root->fs_info, trans)) {
2621
		blk_finish_plug(&plug);
2622
		btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2623
		btrfs_free_logged_extents(log, log_transid);
2624 2625 2626 2627
		mutex_unlock(&log_root_tree->log_mutex);
		ret = -EAGAIN;
		goto out_wake_log_root;
	}
Y
Yan Zheng 已提交
2628

2629 2630 2631 2632
	ret = btrfs_write_marked_extents(log_root_tree,
					 &log_root_tree->dirty_log_pages,
					 EXTENT_DIRTY | EXTENT_NEW);
	blk_finish_plug(&plug);
2633
	if (ret) {
2634
		btrfs_set_log_full_commit(root->fs_info, trans);
2635
		btrfs_abort_transaction(trans, root, ret);
2636
		btrfs_free_logged_extents(log, log_transid);
2637 2638 2639
		mutex_unlock(&log_root_tree->log_mutex);
		goto out_wake_log_root;
	}
2640
	btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2641 2642 2643
	btrfs_wait_marked_extents(log_root_tree,
				  &log_root_tree->dirty_log_pages,
				  EXTENT_NEW | EXTENT_DIRTY);
2644
	btrfs_wait_logged_extents(log, log_transid);
2645

2646
	btrfs_set_super_log_root(root->fs_info->super_for_commit,
Y
Yan Zheng 已提交
2647
				log_root_tree->node->start);
2648
	btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
Y
Yan Zheng 已提交
2649
				btrfs_header_level(log_root_tree->node));
2650

Y
Yan Zheng 已提交
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
	log_root_tree->log_transid++;
	mutex_unlock(&log_root_tree->log_mutex);

	/*
	 * nobody else is going to jump in and write the the ctree
	 * super here because the log_commit atomic below is protecting
	 * us.  We must be called with a transaction handle pinning
	 * the running transaction open, so a full commit can't hop
	 * in and cause problems either.
	 */
2661 2662
	ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
	if (ret) {
2663
		btrfs_set_log_full_commit(root->fs_info, trans);
2664 2665 2666
		btrfs_abort_transaction(trans, root, ret);
		goto out_wake_log_root;
	}
Y
Yan Zheng 已提交
2667

2668 2669 2670 2671 2672
	mutex_lock(&root->log_mutex);
	if (root->last_log_commit < log_transid)
		root->last_log_commit = log_transid;
	mutex_unlock(&root->log_mutex);

2673
out_wake_log_root:
2674 2675 2676 2677 2678 2679
	/*
	 * We needn't get log_mutex here because we are sure all
	 * the other tasks are blocked.
	 */
	btrfs_remove_all_log_ctxs(log_root_tree, index2, ret);

2680 2681
	mutex_lock(&log_root_tree->log_mutex);
	log_root_tree->log_transid_committed++;
Y
Yan Zheng 已提交
2682
	atomic_set(&log_root_tree->log_commit[index2], 0);
2683 2684
	mutex_unlock(&log_root_tree->log_mutex);

Y
Yan Zheng 已提交
2685 2686
	if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
		wake_up(&log_root_tree->log_commit_wait[index2]);
2687
out:
2688 2689 2690
	/* See above. */
	btrfs_remove_all_log_ctxs(root, index1, ret);

2691 2692
	mutex_lock(&root->log_mutex);
	root->log_transid_committed++;
Y
Yan Zheng 已提交
2693
	atomic_set(&root->log_commit[index1], 0);
2694
	mutex_unlock(&root->log_mutex);
2695

Y
Yan Zheng 已提交
2696 2697
	if (waitqueue_active(&root->log_commit_wait[index1]))
		wake_up(&root->log_commit_wait[index1]);
2698
	return ret;
2699 2700
}

2701 2702
static void free_log_tree(struct btrfs_trans_handle *trans,
			  struct btrfs_root *log)
2703 2704
{
	int ret;
2705 2706
	u64 start;
	u64 end;
2707 2708 2709 2710 2711
	struct walk_control wc = {
		.free = 1,
		.process_func = process_one_buffer
	};

2712 2713 2714 2715
	ret = walk_log_tree(trans, log, &wc);
	/* I don't think this can happen but just in case */
	if (ret)
		btrfs_abort_transaction(trans, log, ret);
2716

C
Chris Mason 已提交
2717
	while (1) {
2718
		ret = find_first_extent_bit(&log->dirty_log_pages,
2719 2720
				0, &start, &end, EXTENT_DIRTY | EXTENT_NEW,
				NULL);
2721 2722 2723
		if (ret)
			break;

2724 2725
		clear_extent_bits(&log->dirty_log_pages, start, end,
				  EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS);
2726 2727
	}

2728 2729 2730 2731 2732 2733 2734 2735
	/*
	 * We may have short-circuited the log tree with the full commit logic
	 * and left ordered extents on our list, so clear these out to keep us
	 * from leaking inodes and memory.
	 */
	btrfs_free_logged_extents(log, 0);
	btrfs_free_logged_extents(log, 1);

Y
Yan Zheng 已提交
2736 2737
	free_extent_buffer(log->node);
	kfree(log);
2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759
}

/*
 * free all the extents used by the tree log.  This should be called
 * at commit time of the full transaction
 */
int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
{
	if (root->log_root) {
		free_log_tree(trans, root->log_root);
		root->log_root = NULL;
	}
	return 0;
}

int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	if (fs_info->log_root_tree) {
		free_log_tree(trans, fs_info->log_root_tree);
		fs_info->log_root_tree = NULL;
	}
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792
	return 0;
}

/*
 * If both a file and directory are logged, and unlinks or renames are
 * mixed in, we have a few interesting corners:
 *
 * create file X in dir Y
 * link file X to X.link in dir Y
 * fsync file X
 * unlink file X but leave X.link
 * fsync dir Y
 *
 * After a crash we would expect only X.link to exist.  But file X
 * didn't get fsync'd again so the log has back refs for X and X.link.
 *
 * We solve this by removing directory entries and inode backrefs from the
 * log when a file that was logged in the current transaction is
 * unlinked.  Any later fsync will include the updated log entries, and
 * we'll be able to reconstruct the proper directory items from backrefs.
 *
 * This optimizations allows us to avoid relogging the entire inode
 * or the entire directory.
 */
int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root,
				 const char *name, int name_len,
				 struct inode *dir, u64 index)
{
	struct btrfs_root *log;
	struct btrfs_dir_item *di;
	struct btrfs_path *path;
	int ret;
2793
	int err = 0;
2794
	int bytes_del = 0;
L
Li Zefan 已提交
2795
	u64 dir_ino = btrfs_ino(dir);
2796

2797 2798 2799
	if (BTRFS_I(dir)->logged_trans < trans->transid)
		return 0;

2800 2801 2802 2803 2804 2805 2806 2807
	ret = join_running_log_trans(root);
	if (ret)
		return 0;

	mutex_lock(&BTRFS_I(dir)->log_mutex);

	log = root->log_root;
	path = btrfs_alloc_path();
2808 2809 2810 2811
	if (!path) {
		err = -ENOMEM;
		goto out_unlock;
	}
2812

L
Li Zefan 已提交
2813
	di = btrfs_lookup_dir_item(trans, log, path, dir_ino,
2814
				   name, name_len, -1);
2815 2816 2817 2818 2819
	if (IS_ERR(di)) {
		err = PTR_ERR(di);
		goto fail;
	}
	if (di) {
2820 2821
		ret = btrfs_delete_one_dir_name(trans, log, path, di);
		bytes_del += name_len;
2822 2823 2824 2825
		if (ret) {
			err = ret;
			goto fail;
		}
2826
	}
2827
	btrfs_release_path(path);
L
Li Zefan 已提交
2828
	di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
2829
					 index, name, name_len, -1);
2830 2831 2832 2833 2834
	if (IS_ERR(di)) {
		err = PTR_ERR(di);
		goto fail;
	}
	if (di) {
2835 2836
		ret = btrfs_delete_one_dir_name(trans, log, path, di);
		bytes_del += name_len;
2837 2838 2839 2840
		if (ret) {
			err = ret;
			goto fail;
		}
2841 2842 2843 2844 2845 2846 2847 2848
	}

	/* update the directory size in the log to reflect the names
	 * we have removed
	 */
	if (bytes_del) {
		struct btrfs_key key;

L
Li Zefan 已提交
2849
		key.objectid = dir_ino;
2850 2851
		key.offset = 0;
		key.type = BTRFS_INODE_ITEM_KEY;
2852
		btrfs_release_path(path);
2853 2854

		ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
2855 2856 2857 2858
		if (ret < 0) {
			err = ret;
			goto fail;
		}
2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873
		if (ret == 0) {
			struct btrfs_inode_item *item;
			u64 i_size;

			item = btrfs_item_ptr(path->nodes[0], path->slots[0],
					      struct btrfs_inode_item);
			i_size = btrfs_inode_size(path->nodes[0], item);
			if (i_size > bytes_del)
				i_size -= bytes_del;
			else
				i_size = 0;
			btrfs_set_inode_size(path->nodes[0], item, i_size);
			btrfs_mark_buffer_dirty(path->nodes[0]);
		} else
			ret = 0;
2874
		btrfs_release_path(path);
2875
	}
2876
fail:
2877
	btrfs_free_path(path);
2878
out_unlock:
2879
	mutex_unlock(&BTRFS_I(dir)->log_mutex);
2880
	if (ret == -ENOSPC) {
2881
		btrfs_set_log_full_commit(root->fs_info, trans);
2882
		ret = 0;
2883 2884 2885
	} else if (ret < 0)
		btrfs_abort_transaction(trans, root, ret);

2886
	btrfs_end_log_trans(root);
2887

2888
	return err;
2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900
}

/* see comments for btrfs_del_dir_entries_in_log */
int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root,
			       const char *name, int name_len,
			       struct inode *inode, u64 dirid)
{
	struct btrfs_root *log;
	u64 index;
	int ret;

2901 2902 2903
	if (BTRFS_I(inode)->logged_trans < trans->transid)
		return 0;

2904 2905 2906 2907 2908 2909
	ret = join_running_log_trans(root);
	if (ret)
		return 0;
	log = root->log_root;
	mutex_lock(&BTRFS_I(inode)->log_mutex);

L
Li Zefan 已提交
2910
	ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
2911 2912
				  dirid, &index);
	mutex_unlock(&BTRFS_I(inode)->log_mutex);
2913
	if (ret == -ENOSPC) {
2914
		btrfs_set_log_full_commit(root->fs_info, trans);
2915
		ret = 0;
2916 2917
	} else if (ret < 0 && ret != -ENOENT)
		btrfs_abort_transaction(trans, root, ret);
2918
	btrfs_end_log_trans(root);
2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944

	return ret;
}

/*
 * creates a range item in the log for 'dirid'.  first_offset and
 * last_offset tell us which parts of the key space the log should
 * be considered authoritative for.
 */
static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
				       struct btrfs_root *log,
				       struct btrfs_path *path,
				       int key_type, u64 dirid,
				       u64 first_offset, u64 last_offset)
{
	int ret;
	struct btrfs_key key;
	struct btrfs_dir_log_item *item;

	key.objectid = dirid;
	key.offset = first_offset;
	if (key_type == BTRFS_DIR_ITEM_KEY)
		key.type = BTRFS_DIR_LOG_ITEM_KEY;
	else
		key.type = BTRFS_DIR_LOG_INDEX_KEY;
	ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
2945 2946
	if (ret)
		return ret;
2947 2948 2949 2950 2951

	item = btrfs_item_ptr(path->nodes[0], path->slots[0],
			      struct btrfs_dir_log_item);
	btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
	btrfs_mark_buffer_dirty(path->nodes[0]);
2952
	btrfs_release_path(path);
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
	return 0;
}

/*
 * log all the items included in the current transaction for a given
 * directory.  This also creates the range items in the log tree required
 * to replay anything deleted before the fsync
 */
static noinline int log_dir_items(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, struct inode *inode,
			  struct btrfs_path *path,
			  struct btrfs_path *dst_path, int key_type,
			  u64 min_offset, u64 *last_offset_ret)
{
	struct btrfs_key min_key;
	struct btrfs_root *log = root->log_root;
	struct extent_buffer *src;
2970
	int err = 0;
2971 2972 2973 2974 2975
	int ret;
	int i;
	int nritems;
	u64 first_offset = min_offset;
	u64 last_offset = (u64)-1;
L
Li Zefan 已提交
2976
	u64 ino = btrfs_ino(inode);
2977 2978 2979

	log = root->log_root;

L
Li Zefan 已提交
2980
	min_key.objectid = ino;
2981 2982 2983 2984 2985
	min_key.type = key_type;
	min_key.offset = min_offset;

	path->keep_locks = 1;

2986
	ret = btrfs_search_forward(root, &min_key, path, trans->transid);
2987 2988 2989 2990 2991

	/*
	 * we didn't find anything from this transaction, see if there
	 * is anything at all
	 */
L
Li Zefan 已提交
2992 2993
	if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) {
		min_key.objectid = ino;
2994 2995
		min_key.type = key_type;
		min_key.offset = (u64)-1;
2996
		btrfs_release_path(path);
2997 2998
		ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
		if (ret < 0) {
2999
			btrfs_release_path(path);
3000 3001
			return ret;
		}
L
Li Zefan 已提交
3002
		ret = btrfs_previous_item(root, path, ino, key_type);
3003 3004 3005 3006 3007 3008 3009 3010 3011 3012

		/* if ret == 0 there are items for this type,
		 * create a range to tell us the last key of this type.
		 * otherwise, there are no items in this directory after
		 * *min_offset, and we create a range to indicate that.
		 */
		if (ret == 0) {
			struct btrfs_key tmp;
			btrfs_item_key_to_cpu(path->nodes[0], &tmp,
					      path->slots[0]);
C
Chris Mason 已提交
3013
			if (key_type == tmp.type)
3014 3015 3016 3017 3018 3019
				first_offset = max(min_offset, tmp.offset) + 1;
		}
		goto done;
	}

	/* go backward to find any previous key */
L
Li Zefan 已提交
3020
	ret = btrfs_previous_item(root, path, ino, key_type);
3021 3022 3023 3024 3025 3026 3027 3028
	if (ret == 0) {
		struct btrfs_key tmp;
		btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
		if (key_type == tmp.type) {
			first_offset = tmp.offset;
			ret = overwrite_item(trans, log, dst_path,
					     path->nodes[0], path->slots[0],
					     &tmp);
3029 3030 3031 3032
			if (ret) {
				err = ret;
				goto done;
			}
3033 3034
		}
	}
3035
	btrfs_release_path(path);
3036 3037 3038

	/* find the first key from this transaction again */
	ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3039
	if (WARN_ON(ret != 0))
3040 3041 3042 3043 3044 3045
		goto done;

	/*
	 * we have a block from this transaction, log every item in it
	 * from our directory
	 */
C
Chris Mason 已提交
3046
	while (1) {
3047 3048 3049 3050 3051 3052
		struct btrfs_key tmp;
		src = path->nodes[0];
		nritems = btrfs_header_nritems(src);
		for (i = path->slots[0]; i < nritems; i++) {
			btrfs_item_key_to_cpu(src, &min_key, i);

L
Li Zefan 已提交
3053
			if (min_key.objectid != ino || min_key.type != key_type)
3054 3055 3056
				goto done;
			ret = overwrite_item(trans, log, dst_path, src, i,
					     &min_key);
3057 3058 3059 3060
			if (ret) {
				err = ret;
				goto done;
			}
3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073
		}
		path->slots[0] = nritems;

		/*
		 * look ahead to the next item and see if it is also
		 * from this directory and from this transaction
		 */
		ret = btrfs_next_leaf(root, path);
		if (ret == 1) {
			last_offset = (u64)-1;
			goto done;
		}
		btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
L
Li Zefan 已提交
3074
		if (tmp.objectid != ino || tmp.type != key_type) {
3075 3076 3077 3078 3079 3080 3081
			last_offset = (u64)-1;
			goto done;
		}
		if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
			ret = overwrite_item(trans, log, dst_path,
					     path->nodes[0], path->slots[0],
					     &tmp);
3082 3083 3084 3085
			if (ret)
				err = ret;
			else
				last_offset = tmp.offset;
3086 3087 3088 3089
			goto done;
		}
	}
done:
3090 3091
	btrfs_release_path(path);
	btrfs_release_path(dst_path);
3092

3093 3094 3095 3096 3097 3098 3099
	if (err == 0) {
		*last_offset_ret = last_offset;
		/*
		 * insert the log range keys to indicate where the log
		 * is valid
		 */
		ret = insert_dir_log_key(trans, log, path, key_type,
L
Li Zefan 已提交
3100
					 ino, first_offset, last_offset);
3101 3102 3103 3104
		if (ret)
			err = ret;
	}
	return err;
3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131
}

/*
 * logging directories is very similar to logging inodes, We find all the items
 * from the current transaction and write them to the log.
 *
 * The recovery code scans the directory in the subvolume, and if it finds a
 * key in the range logged that is not present in the log tree, then it means
 * that dir entry was unlinked during the transaction.
 *
 * In order for that scan to work, we must include one key smaller than
 * the smallest logged by this transaction and one key larger than the largest
 * key logged by this transaction.
 */
static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root, struct inode *inode,
			  struct btrfs_path *path,
			  struct btrfs_path *dst_path)
{
	u64 min_key;
	u64 max_key;
	int ret;
	int key_type = BTRFS_DIR_ITEM_KEY;

again:
	min_key = 0;
	max_key = 0;
C
Chris Mason 已提交
3132
	while (1) {
3133 3134 3135
		ret = log_dir_items(trans, root, inode, path,
				    dst_path, key_type, min_key,
				    &max_key);
3136 3137
		if (ret)
			return ret;
3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163
		if (max_key == (u64)-1)
			break;
		min_key = max_key + 1;
	}

	if (key_type == BTRFS_DIR_ITEM_KEY) {
		key_type = BTRFS_DIR_INDEX_KEY;
		goto again;
	}
	return 0;
}

/*
 * a helper function to drop items from the log before we relog an
 * inode.  max_key_type indicates the highest item type to remove.
 * This cannot be run for file data extents because it does not
 * free the extents they point to.
 */
static int drop_objectid_items(struct btrfs_trans_handle *trans,
				  struct btrfs_root *log,
				  struct btrfs_path *path,
				  u64 objectid, int max_key_type)
{
	int ret;
	struct btrfs_key key;
	struct btrfs_key found_key;
3164
	int start_slot;
3165 3166 3167 3168 3169

	key.objectid = objectid;
	key.type = max_key_type;
	key.offset = (u64)-1;

C
Chris Mason 已提交
3170
	while (1) {
3171
		ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
3172
		BUG_ON(ret == 0); /* Logic error */
3173
		if (ret < 0)
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
			break;

		if (path->slots[0] == 0)
			break;

		path->slots[0]--;
		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
				      path->slots[0]);

		if (found_key.objectid != objectid)
			break;

3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
		found_key.offset = 0;
		found_key.type = 0;
		ret = btrfs_bin_search(path->nodes[0], &found_key, 0,
				       &start_slot);

		ret = btrfs_del_items(trans, log, path, start_slot,
				      path->slots[0] - start_slot + 1);
		/*
		 * If start slot isn't 0 then we don't need to re-search, we've
		 * found the last guy with the objectid in this tree.
		 */
		if (ret || start_slot != 0)
3198
			break;
3199
		btrfs_release_path(path);
3200
	}
3201
	btrfs_release_path(path);
3202 3203
	if (ret > 0)
		ret = 0;
3204
	return ret;
3205 3206
}

3207 3208 3209 3210 3211
static void fill_inode_item(struct btrfs_trans_handle *trans,
			    struct extent_buffer *leaf,
			    struct btrfs_inode_item *item,
			    struct inode *inode, int log_inode_only)
{
3212 3213 3214
	struct btrfs_map_token token;

	btrfs_init_map_token(&token);
3215 3216 3217 3218 3219 3220 3221

	if (log_inode_only) {
		/* set the generation to zero so the recover code
		 * can tell the difference between an logging
		 * just to say 'this inode exists' and a logging
		 * to say 'update this inode with these values'
		 */
3222 3223
		btrfs_set_token_inode_generation(leaf, item, 0, &token);
		btrfs_set_token_inode_size(leaf, item, 0, &token);
3224
	} else {
3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
		btrfs_set_token_inode_generation(leaf, item,
						 BTRFS_I(inode)->generation,
						 &token);
		btrfs_set_token_inode_size(leaf, item, inode->i_size, &token);
	}

	btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
	btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
	btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
	btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);

	btrfs_set_token_timespec_sec(leaf, btrfs_inode_atime(item),
				     inode->i_atime.tv_sec, &token);
	btrfs_set_token_timespec_nsec(leaf, btrfs_inode_atime(item),
				      inode->i_atime.tv_nsec, &token);

	btrfs_set_token_timespec_sec(leaf, btrfs_inode_mtime(item),
				     inode->i_mtime.tv_sec, &token);
	btrfs_set_token_timespec_nsec(leaf, btrfs_inode_mtime(item),
				      inode->i_mtime.tv_nsec, &token);

	btrfs_set_token_timespec_sec(leaf, btrfs_inode_ctime(item),
				     inode->i_ctime.tv_sec, &token);
	btrfs_set_token_timespec_nsec(leaf, btrfs_inode_ctime(item),
				      inode->i_ctime.tv_nsec, &token);

	btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
				     &token);

	btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
	btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
	btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
	btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
	btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3259 3260
}

3261 3262 3263 3264 3265 3266 3267
static int log_inode_item(struct btrfs_trans_handle *trans,
			  struct btrfs_root *log, struct btrfs_path *path,
			  struct inode *inode)
{
	struct btrfs_inode_item *inode_item;
	int ret;

3268 3269
	ret = btrfs_insert_empty_item(trans, log, path,
				      &BTRFS_I(inode)->location,
3270 3271 3272 3273 3274 3275 3276 3277 3278 3279
				      sizeof(*inode_item));
	if (ret && ret != -EEXIST)
		return ret;
	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
				    struct btrfs_inode_item);
	fill_inode_item(trans, path->nodes[0], inode_item, inode, 0);
	btrfs_release_path(path);
	return 0;
}

3280
static noinline int copy_items(struct btrfs_trans_handle *trans,
3281
			       struct inode *inode,
3282
			       struct btrfs_path *dst_path,
3283
			       struct btrfs_path *src_path, u64 *last_extent,
3284 3285 3286 3287
			       int start_slot, int nr, int inode_only)
{
	unsigned long src_offset;
	unsigned long dst_offset;
3288
	struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
3289 3290
	struct btrfs_file_extent_item *extent;
	struct btrfs_inode_item *inode_item;
3291 3292
	struct extent_buffer *src = src_path->nodes[0];
	struct btrfs_key first_key, last_key, key;
3293 3294 3295 3296 3297
	int ret;
	struct btrfs_key *ins_keys;
	u32 *ins_sizes;
	char *ins_data;
	int i;
3298
	struct list_head ordered_sums;
3299
	int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
3300 3301 3302
	bool has_extents = false;
	bool need_find_last_extent = (*last_extent == 0);
	bool done = false;
3303 3304

	INIT_LIST_HEAD(&ordered_sums);
3305 3306 3307

	ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
			   nr * sizeof(u32), GFP_NOFS);
3308 3309 3310
	if (!ins_data)
		return -ENOMEM;

3311 3312
	first_key.objectid = (u64)-1;

3313 3314 3315 3316 3317 3318 3319 3320 3321
	ins_sizes = (u32 *)ins_data;
	ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));

	for (i = 0; i < nr; i++) {
		ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot);
		btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot);
	}
	ret = btrfs_insert_empty_items(trans, log, dst_path,
				       ins_keys, ins_sizes, nr);
3322 3323 3324 3325
	if (ret) {
		kfree(ins_data);
		return ret;
	}
3326

3327
	for (i = 0; i < nr; i++, dst_path->slots[0]++) {
3328 3329 3330 3331 3332
		dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0],
						   dst_path->slots[0]);

		src_offset = btrfs_item_ptr_offset(src, start_slot + i);

3333 3334 3335
		if ((i == (nr - 1)))
			last_key = ins_keys[i];

3336
		if (ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
3337 3338 3339
			inode_item = btrfs_item_ptr(dst_path->nodes[0],
						    dst_path->slots[0],
						    struct btrfs_inode_item);
3340 3341 3342 3343 3344
			fill_inode_item(trans, dst_path->nodes[0], inode_item,
					inode, inode_only == LOG_INODE_EXISTS);
		} else {
			copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
					   src_offset, ins_sizes[i]);
3345
		}
3346

3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361
		/*
		 * We set need_find_last_extent here in case we know we were
		 * processing other items and then walk into the first extent in
		 * the inode.  If we don't hit an extent then nothing changes,
		 * we'll do the last search the next time around.
		 */
		if (ins_keys[i].type == BTRFS_EXTENT_DATA_KEY) {
			has_extents = true;
			if (need_find_last_extent &&
			    first_key.objectid == (u64)-1)
				first_key = ins_keys[i];
		} else {
			need_find_last_extent = false;
		}

3362 3363 3364 3365
		/* take a reference on file data extents so that truncates
		 * or deletes of this inode don't have to relog the inode
		 * again
		 */
3366 3367
		if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY &&
		    !skip_csum) {
3368 3369 3370 3371
			int found_type;
			extent = btrfs_item_ptr(src, start_slot + i,
						struct btrfs_file_extent_item);

3372 3373 3374
			if (btrfs_file_extent_generation(src, extent) < trans->transid)
				continue;

3375
			found_type = btrfs_file_extent_type(src, extent);
3376
			if (found_type == BTRFS_FILE_EXTENT_REG) {
3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
				u64 ds, dl, cs, cl;
				ds = btrfs_file_extent_disk_bytenr(src,
								extent);
				/* ds == 0 is a hole */
				if (ds == 0)
					continue;

				dl = btrfs_file_extent_disk_num_bytes(src,
								extent);
				cs = btrfs_file_extent_offset(src, extent);
				cl = btrfs_file_extent_num_bytes(src,
3388
								extent);
3389 3390 3391 3392 3393
				if (btrfs_file_extent_compression(src,
								  extent)) {
					cs = 0;
					cl = dl;
				}
3394 3395 3396 3397

				ret = btrfs_lookup_csums_range(
						log->fs_info->csum_root,
						ds + cs, ds + cs + cl - 1,
A
Arne Jansen 已提交
3398
						&ordered_sums, 0);
3399 3400 3401 3402 3403
				if (ret) {
					btrfs_release_path(dst_path);
					kfree(ins_data);
					return ret;
				}
3404 3405 3406 3407 3408
			}
		}
	}

	btrfs_mark_buffer_dirty(dst_path->nodes[0]);
3409
	btrfs_release_path(dst_path);
3410
	kfree(ins_data);
3411 3412 3413 3414 3415

	/*
	 * we have to do this after the loop above to avoid changing the
	 * log tree while trying to change the log tree.
	 */
3416
	ret = 0;
C
Chris Mason 已提交
3417
	while (!list_empty(&ordered_sums)) {
3418 3419 3420
		struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
						   struct btrfs_ordered_sum,
						   list);
3421 3422
		if (!ret)
			ret = btrfs_csum_file_blocks(trans, log, sums);
3423 3424 3425
		list_del(&sums->list);
		kfree(sums);
	}
3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454

	if (!has_extents)
		return ret;

	/*
	 * Because we use btrfs_search_forward we could skip leaves that were
	 * not modified and then assume *last_extent is valid when it really
	 * isn't.  So back up to the previous leaf and read the end of the last
	 * extent before we go and fill in holes.
	 */
	if (need_find_last_extent) {
		u64 len;

		ret = btrfs_prev_leaf(BTRFS_I(inode)->root, src_path);
		if (ret < 0)
			return ret;
		if (ret)
			goto fill_holes;
		if (src_path->slots[0])
			src_path->slots[0]--;
		src = src_path->nodes[0];
		btrfs_item_key_to_cpu(src, &key, src_path->slots[0]);
		if (key.objectid != btrfs_ino(inode) ||
		    key.type != BTRFS_EXTENT_DATA_KEY)
			goto fill_holes;
		extent = btrfs_item_ptr(src, src_path->slots[0],
					struct btrfs_file_extent_item);
		if (btrfs_file_extent_type(src, extent) ==
		    BTRFS_FILE_EXTENT_INLINE) {
3455 3456 3457
			len = btrfs_file_extent_inline_len(src,
							   src_path->slots[0],
							   extent);
3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520
			*last_extent = ALIGN(key.offset + len,
					     log->sectorsize);
		} else {
			len = btrfs_file_extent_num_bytes(src, extent);
			*last_extent = key.offset + len;
		}
	}
fill_holes:
	/* So we did prev_leaf, now we need to move to the next leaf, but a few
	 * things could have happened
	 *
	 * 1) A merge could have happened, so we could currently be on a leaf
	 * that holds what we were copying in the first place.
	 * 2) A split could have happened, and now not all of the items we want
	 * are on the same leaf.
	 *
	 * So we need to adjust how we search for holes, we need to drop the
	 * path and re-search for the first extent key we found, and then walk
	 * forward until we hit the last one we copied.
	 */
	if (need_find_last_extent) {
		/* btrfs_prev_leaf could return 1 without releasing the path */
		btrfs_release_path(src_path);
		ret = btrfs_search_slot(NULL, BTRFS_I(inode)->root, &first_key,
					src_path, 0, 0);
		if (ret < 0)
			return ret;
		ASSERT(ret == 0);
		src = src_path->nodes[0];
		i = src_path->slots[0];
	} else {
		i = start_slot;
	}

	/*
	 * Ok so here we need to go through and fill in any holes we may have
	 * to make sure that holes are punched for those areas in case they had
	 * extents previously.
	 */
	while (!done) {
		u64 offset, len;
		u64 extent_end;

		if (i >= btrfs_header_nritems(src_path->nodes[0])) {
			ret = btrfs_next_leaf(BTRFS_I(inode)->root, src_path);
			if (ret < 0)
				return ret;
			ASSERT(ret == 0);
			src = src_path->nodes[0];
			i = 0;
		}

		btrfs_item_key_to_cpu(src, &key, i);
		if (!btrfs_comp_cpu_keys(&key, &last_key))
			done = true;
		if (key.objectid != btrfs_ino(inode) ||
		    key.type != BTRFS_EXTENT_DATA_KEY) {
			i++;
			continue;
		}
		extent = btrfs_item_ptr(src, i, struct btrfs_file_extent_item);
		if (btrfs_file_extent_type(src, extent) ==
		    BTRFS_FILE_EXTENT_INLINE) {
3521
			len = btrfs_file_extent_inline_len(src, i, extent);
3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547
			extent_end = ALIGN(key.offset + len, log->sectorsize);
		} else {
			len = btrfs_file_extent_num_bytes(src, extent);
			extent_end = key.offset + len;
		}
		i++;

		if (*last_extent == key.offset) {
			*last_extent = extent_end;
			continue;
		}
		offset = *last_extent;
		len = key.offset - *last_extent;
		ret = btrfs_insert_file_extent(trans, log, btrfs_ino(inode),
					       offset, 0, 0, len, 0, len, 0,
					       0, 0);
		if (ret)
			break;
		*last_extent = offset + len;
	}
	/*
	 * Need to let the callers know we dropped the path so they should
	 * re-search.
	 */
	if (!ret && need_find_last_extent)
		ret = 1;
3548
	return ret;
3549 3550
}

J
Josef Bacik 已提交
3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566
static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
{
	struct extent_map *em1, *em2;

	em1 = list_entry(a, struct extent_map, list);
	em2 = list_entry(b, struct extent_map, list);

	if (em1->start < em2->start)
		return -1;
	else if (em1->start > em2->start)
		return 1;
	return 0;
}

static int log_one_extent(struct btrfs_trans_handle *trans,
			  struct inode *inode, struct btrfs_root *root,
3567 3568
			  struct extent_map *em, struct btrfs_path *path,
			  struct list_head *logged_list)
J
Josef Bacik 已提交
3569 3570
{
	struct btrfs_root *log = root->log_root;
3571 3572
	struct btrfs_file_extent_item *fi;
	struct extent_buffer *leaf;
3573
	struct btrfs_ordered_extent *ordered;
3574
	struct list_head ordered_sums;
3575
	struct btrfs_map_token token;
J
Josef Bacik 已提交
3576
	struct btrfs_key key;
3577 3578 3579 3580
	u64 mod_start = em->mod_start;
	u64 mod_len = em->mod_len;
	u64 csum_offset;
	u64 csum_len;
3581 3582
	u64 extent_offset = em->start - em->orig_start;
	u64 block_len;
J
Josef Bacik 已提交
3583
	int ret;
3584
	bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
3585
	int extent_inserted = 0;
J
Josef Bacik 已提交
3586

3587
	INIT_LIST_HEAD(&ordered_sums);
3588
	btrfs_init_map_token(&token);
3589

3590 3591 3592
	ret = __btrfs_drop_extents(trans, log, inode, path, em->start,
				   em->start + em->len, NULL, 0, 1,
				   sizeof(*fi), &extent_inserted);
J
Josef Bacik 已提交
3593
	if (ret)
3594
		return ret;
3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605

	if (!extent_inserted) {
		key.objectid = btrfs_ino(inode);
		key.type = BTRFS_EXTENT_DATA_KEY;
		key.offset = em->start;

		ret = btrfs_insert_empty_item(trans, log, path, &key,
					      sizeof(*fi));
		if (ret)
			return ret;
	}
3606 3607 3608
	leaf = path->nodes[0];
	fi = btrfs_item_ptr(leaf, path->slots[0],
			    struct btrfs_file_extent_item);
3609

3610 3611
	btrfs_set_token_file_extent_generation(leaf, fi, em->generation,
					       &token);
3612 3613
	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
		skip_csum = true;
3614 3615 3616
		btrfs_set_token_file_extent_type(leaf, fi,
						 BTRFS_FILE_EXTENT_PREALLOC,
						 &token);
3617
	} else {
3618 3619 3620
		btrfs_set_token_file_extent_type(leaf, fi,
						 BTRFS_FILE_EXTENT_REG,
						 &token);
3621
		if (em->block_start == EXTENT_MAP_HOLE)
3622 3623 3624 3625 3626
			skip_csum = true;
	}

	block_len = max(em->block_len, em->orig_block_len);
	if (em->compress_type != BTRFS_COMPRESS_NONE) {
3627 3628 3629 3630 3631
		btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
							em->block_start,
							&token);
		btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
							   &token);
3632
	} else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
3633 3634 3635 3636 3637
		btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
							em->block_start -
							extent_offset, &token);
		btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
							   &token);
3638
	} else {
3639 3640 3641 3642 3643 3644 3645 3646 3647
		btrfs_set_token_file_extent_disk_bytenr(leaf, fi, 0, &token);
		btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, 0,
							   &token);
	}

	btrfs_set_token_file_extent_offset(leaf, fi,
					   em->start - em->orig_start,
					   &token);
	btrfs_set_token_file_extent_num_bytes(leaf, fi, em->len, &token);
J
Josef Bacik 已提交
3648
	btrfs_set_token_file_extent_ram_bytes(leaf, fi, em->ram_bytes, &token);
3649 3650 3651 3652
	btrfs_set_token_file_extent_compression(leaf, fi, em->compress_type,
						&token);
	btrfs_set_token_file_extent_encryption(leaf, fi, 0, &token);
	btrfs_set_token_file_extent_other_encoding(leaf, fi, 0, &token);
3653
	btrfs_mark_buffer_dirty(leaf);
3654

3655 3656 3657 3658
	btrfs_release_path(path);
	if (ret) {
		return ret;
	}
3659

3660 3661
	if (skip_csum)
		return 0;
J
Josef Bacik 已提交
3662

3663 3664 3665 3666
	/*
	 * First check and see if our csums are on our outstanding ordered
	 * extents.
	 */
3667
	list_for_each_entry(ordered, logged_list, log_list) {
3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715
		struct btrfs_ordered_sum *sum;

		if (!mod_len)
			break;

		if (ordered->file_offset + ordered->len <= mod_start ||
		    mod_start + mod_len <= ordered->file_offset)
			continue;

		/*
		 * We are going to copy all the csums on this ordered extent, so
		 * go ahead and adjust mod_start and mod_len in case this
		 * ordered extent has already been logged.
		 */
		if (ordered->file_offset > mod_start) {
			if (ordered->file_offset + ordered->len >=
			    mod_start + mod_len)
				mod_len = ordered->file_offset - mod_start;
			/*
			 * If we have this case
			 *
			 * |--------- logged extent ---------|
			 *       |----- ordered extent ----|
			 *
			 * Just don't mess with mod_start and mod_len, we'll
			 * just end up logging more csums than we need and it
			 * will be ok.
			 */
		} else {
			if (ordered->file_offset + ordered->len <
			    mod_start + mod_len) {
				mod_len = (mod_start + mod_len) -
					(ordered->file_offset + ordered->len);
				mod_start = ordered->file_offset +
					ordered->len;
			} else {
				mod_len = 0;
			}
		}

		/*
		 * To keep us from looping for the above case of an ordered
		 * extent that falls inside of the logged extent.
		 */
		if (test_and_set_bit(BTRFS_ORDERED_LOGGED_CSUM,
				     &ordered->flags))
			continue;

3716 3717 3718 3719 3720
		if (ordered->csum_bytes_left) {
			btrfs_start_ordered_extent(inode, ordered, 0);
			wait_event(ordered->wait,
				   ordered->csum_bytes_left == 0);
		}
3721 3722 3723

		list_for_each_entry(sum, &ordered->list, list) {
			ret = btrfs_csum_file_blocks(trans, log, sum);
3724
			if (ret)
3725 3726 3727 3728 3729 3730 3731 3732 3733
				goto unlocked;
		}

	}
unlocked:

	if (!mod_len || ret)
		return ret;

3734 3735 3736 3737 3738 3739 3740
	if (em->compress_type) {
		csum_offset = 0;
		csum_len = block_len;
	} else {
		csum_offset = mod_start - em->start;
		csum_len = mod_len;
	}
3741

3742 3743 3744 3745 3746 3747 3748
	/* block start is already adjusted for the file extent offset. */
	ret = btrfs_lookup_csums_range(log->fs_info->csum_root,
				       em->block_start + csum_offset,
				       em->block_start + csum_offset +
				       csum_len - 1, &ordered_sums, 0);
	if (ret)
		return ret;
J
Josef Bacik 已提交
3749

3750 3751 3752 3753 3754 3755 3756 3757
	while (!list_empty(&ordered_sums)) {
		struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
						   struct btrfs_ordered_sum,
						   list);
		if (!ret)
			ret = btrfs_csum_file_blocks(trans, log, sums);
		list_del(&sums->list);
		kfree(sums);
J
Josef Bacik 已提交
3758 3759
	}

3760
	return ret;
J
Josef Bacik 已提交
3761 3762 3763 3764 3765
}

static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root,
				     struct inode *inode,
3766 3767
				     struct btrfs_path *path,
				     struct list_head *logged_list)
J
Josef Bacik 已提交
3768 3769 3770 3771 3772 3773
{
	struct extent_map *em, *n;
	struct list_head extents;
	struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
	u64 test_gen;
	int ret = 0;
3774
	int num = 0;
J
Josef Bacik 已提交
3775 3776 3777 3778 3779 3780 3781 3782

	INIT_LIST_HEAD(&extents);

	write_lock(&tree->lock);
	test_gen = root->fs_info->last_trans_committed;

	list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
		list_del_init(&em->list);
3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795

		/*
		 * Just an arbitrary number, this can be really CPU intensive
		 * once we start getting a lot of extents, and really once we
		 * have a bunch of extents we just want to commit since it will
		 * be faster.
		 */
		if (++num > 32768) {
			list_del_init(&tree->modified_extents);
			ret = -EFBIG;
			goto process;
		}

J
Josef Bacik 已提交
3796 3797
		if (em->generation <= test_gen)
			continue;
3798 3799 3800
		/* Need a ref to keep it from getting evicted from cache */
		atomic_inc(&em->refs);
		set_bit(EXTENT_FLAG_LOGGING, &em->flags);
J
Josef Bacik 已提交
3801
		list_add_tail(&em->list, &extents);
3802
		num++;
J
Josef Bacik 已提交
3803 3804 3805 3806
	}

	list_sort(NULL, &extents, extent_cmp);

3807
process:
J
Josef Bacik 已提交
3808 3809 3810 3811 3812 3813 3814 3815 3816
	while (!list_empty(&extents)) {
		em = list_entry(extents.next, struct extent_map, list);

		list_del_init(&em->list);

		/*
		 * If we had an error we just need to delete everybody from our
		 * private list.
		 */
3817
		if (ret) {
3818
			clear_em_logging(tree, em);
3819
			free_extent_map(em);
J
Josef Bacik 已提交
3820
			continue;
3821 3822 3823
		}

		write_unlock(&tree->lock);
J
Josef Bacik 已提交
3824

3825
		ret = log_one_extent(trans, inode, root, em, path, logged_list);
3826
		write_lock(&tree->lock);
3827 3828
		clear_em_logging(tree, em);
		free_extent_map(em);
J
Josef Bacik 已提交
3829
	}
3830 3831
	WARN_ON(!list_empty(&extents));
	write_unlock(&tree->lock);
J
Josef Bacik 已提交
3832 3833 3834 3835 3836

	btrfs_release_path(path);
	return ret;
}

3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850
/* log a single inode in the tree log.
 * At least one parent directory for this inode must exist in the tree
 * or be logged already.
 *
 * Any items from this inode changed by the current transaction are copied
 * to the log tree.  An extra reference is taken on any extents in this
 * file, allowing us to avoid a whole pile of corner cases around logging
 * blocks that have been removed from the tree.
 *
 * See LOG_INODE_ALL and related defines for a description of what inode_only
 * does.
 *
 * This handles both files and directories.
 */
3851
static int btrfs_log_inode(struct btrfs_trans_handle *trans,
3852 3853 3854 3855 3856 3857 3858 3859
			     struct btrfs_root *root, struct inode *inode,
			     int inode_only)
{
	struct btrfs_path *path;
	struct btrfs_path *dst_path;
	struct btrfs_key min_key;
	struct btrfs_key max_key;
	struct btrfs_root *log = root->log_root;
3860
	struct extent_buffer *src = NULL;
3861
	LIST_HEAD(logged_list);
3862
	u64 last_extent = 0;
3863
	int err = 0;
3864
	int ret;
3865
	int nritems;
3866 3867
	int ins_start_slot = 0;
	int ins_nr;
J
Josef Bacik 已提交
3868
	bool fast_search = false;
L
Li Zefan 已提交
3869
	u64 ino = btrfs_ino(inode);
3870 3871

	path = btrfs_alloc_path();
3872 3873
	if (!path)
		return -ENOMEM;
3874
	dst_path = btrfs_alloc_path();
3875 3876 3877 3878
	if (!dst_path) {
		btrfs_free_path(path);
		return -ENOMEM;
	}
3879

L
Li Zefan 已提交
3880
	min_key.objectid = ino;
3881 3882 3883
	min_key.type = BTRFS_INODE_ITEM_KEY;
	min_key.offset = 0;

L
Li Zefan 已提交
3884
	max_key.objectid = ino;
3885 3886


J
Josef Bacik 已提交
3887
	/* today the code can only do partial logging of directories */
3888 3889 3890 3891
	if (S_ISDIR(inode->i_mode) ||
	    (!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
		       &BTRFS_I(inode)->runtime_flags) &&
	     inode_only == LOG_INODE_EXISTS))
3892 3893 3894 3895 3896
		max_key.type = BTRFS_XATTR_ITEM_KEY;
	else
		max_key.type = (u8)-1;
	max_key.offset = (u64)-1;

3897 3898 3899 3900 3901 3902 3903 3904 3905
	/* Only run delayed items if we are a dir or a new file */
	if (S_ISDIR(inode->i_mode) ||
	    BTRFS_I(inode)->generation > root->fs_info->last_trans_committed) {
		ret = btrfs_commit_inode_delayed_items(trans, inode);
		if (ret) {
			btrfs_free_path(path);
			btrfs_free_path(dst_path);
			return ret;
		}
3906 3907
	}

3908 3909
	mutex_lock(&BTRFS_I(inode)->log_mutex);

3910
	btrfs_get_logged_extents(inode, &logged_list);
3911

3912 3913 3914 3915 3916 3917 3918 3919 3920
	/*
	 * a brute force approach to making sure we get the most uptodate
	 * copies of everything.
	 */
	if (S_ISDIR(inode->i_mode)) {
		int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;

		if (inode_only == LOG_INODE_EXISTS)
			max_key_type = BTRFS_XATTR_ITEM_KEY;
L
Li Zefan 已提交
3921
		ret = drop_objectid_items(trans, log, path, ino, max_key_type);
3922
	} else {
J
Josef Bacik 已提交
3923 3924
		if (test_and_clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
				       &BTRFS_I(inode)->runtime_flags)) {
3925 3926
			clear_bit(BTRFS_INODE_COPY_EVERYTHING,
				  &BTRFS_I(inode)->runtime_flags);
J
Josef Bacik 已提交
3927 3928
			ret = btrfs_truncate_inode_items(trans, log,
							 inode, 0, 0);
3929
		} else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
3930 3931
					      &BTRFS_I(inode)->runtime_flags) ||
			   inode_only == LOG_INODE_EXISTS) {
3932 3933
			if (inode_only == LOG_INODE_ALL)
				fast_search = true;
3934
			max_key.type = BTRFS_XATTR_ITEM_KEY;
J
Josef Bacik 已提交
3935
			ret = drop_objectid_items(trans, log, path, ino,
3936
						  max_key.type);
3937 3938 3939 3940 3941 3942 3943 3944 3945
		} else {
			if (inode_only == LOG_INODE_ALL)
				fast_search = true;
			ret = log_inode_item(trans, log, dst_path, inode);
			if (ret) {
				err = ret;
				goto out_unlock;
			}
			goto log_extents;
J
Josef Bacik 已提交
3946
		}
3947

3948
	}
3949 3950 3951 3952
	if (ret) {
		err = ret;
		goto out_unlock;
	}
3953 3954
	path->keep_locks = 1;

C
Chris Mason 已提交
3955
	while (1) {
3956
		ins_nr = 0;
3957
		ret = btrfs_search_forward(root, &min_key,
3958
					   path, trans->transid);
3959 3960
		if (ret != 0)
			break;
3961
again:
3962
		/* note, ins_nr might be > 0 here, cleanup outside the loop */
L
Li Zefan 已提交
3963
		if (min_key.objectid != ino)
3964 3965 3966
			break;
		if (min_key.type > max_key.type)
			break;
3967

3968
		src = path->nodes[0];
3969 3970 3971 3972 3973 3974 3975
		if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
			ins_nr++;
			goto next_slot;
		} else if (!ins_nr) {
			ins_start_slot = path->slots[0];
			ins_nr = 1;
			goto next_slot;
3976 3977
		}

3978 3979 3980
		ret = copy_items(trans, inode, dst_path, path, &last_extent,
				 ins_start_slot, ins_nr, inode_only);
		if (ret < 0) {
3981 3982
			err = ret;
			goto out_unlock;
3983 3984 3985 3986
		} if (ret) {
			ins_nr = 0;
			btrfs_release_path(path);
			continue;
3987
		}
3988 3989 3990
		ins_nr = 1;
		ins_start_slot = path->slots[0];
next_slot:
3991

3992 3993 3994 3995 3996 3997 3998
		nritems = btrfs_header_nritems(path->nodes[0]);
		path->slots[0]++;
		if (path->slots[0] < nritems) {
			btrfs_item_key_to_cpu(path->nodes[0], &min_key,
					      path->slots[0]);
			goto again;
		}
3999
		if (ins_nr) {
4000 4001
			ret = copy_items(trans, inode, dst_path, path,
					 &last_extent, ins_start_slot,
4002
					 ins_nr, inode_only);
4003
			if (ret < 0) {
4004 4005 4006
				err = ret;
				goto out_unlock;
			}
4007
			ret = 0;
4008 4009
			ins_nr = 0;
		}
4010
		btrfs_release_path(path);
4011

4012
		if (min_key.offset < (u64)-1) {
4013
			min_key.offset++;
4014
		} else if (min_key.type < max_key.type) {
4015
			min_key.type++;
4016 4017
			min_key.offset = 0;
		} else {
4018
			break;
4019
		}
4020
	}
4021
	if (ins_nr) {
4022 4023 4024
		ret = copy_items(trans, inode, dst_path, path, &last_extent,
				 ins_start_slot, ins_nr, inode_only);
		if (ret < 0) {
4025 4026 4027
			err = ret;
			goto out_unlock;
		}
4028
		ret = 0;
4029 4030
		ins_nr = 0;
	}
J
Josef Bacik 已提交
4031

4032
log_extents:
4033 4034
	btrfs_release_path(path);
	btrfs_release_path(dst_path);
J
Josef Bacik 已提交
4035
	if (fast_search) {
4036 4037
		ret = btrfs_log_changed_extents(trans, root, inode, dst_path,
						&logged_list);
J
Josef Bacik 已提交
4038 4039 4040 4041
		if (ret) {
			err = ret;
			goto out_unlock;
		}
4042
	} else if (inode_only == LOG_INODE_ALL) {
4043 4044 4045
		struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
		struct extent_map *em, *n;

4046
		write_lock(&tree->lock);
4047 4048
		list_for_each_entry_safe(em, n, &tree->modified_extents, list)
			list_del_init(&em->list);
4049
		write_unlock(&tree->lock);
J
Josef Bacik 已提交
4050 4051
	}

4052
	if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
4053
		ret = log_directory_changes(trans, root, inode, path, dst_path);
4054 4055 4056 4057
		if (ret) {
			err = ret;
			goto out_unlock;
		}
4058
	}
4059
	BTRFS_I(inode)->logged_trans = trans->transid;
4060
	BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
4061
out_unlock:
4062 4063 4064 4065
	if (unlikely(err))
		btrfs_put_logged_extents(&logged_list);
	else
		btrfs_submit_logged_extents(&logged_list, log);
4066 4067 4068 4069
	mutex_unlock(&BTRFS_I(inode)->log_mutex);

	btrfs_free_path(path);
	btrfs_free_path(dst_path);
4070
	return err;
4071 4072
}

4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083
/*
 * follow the dentry parent pointers up the chain and see if any
 * of the directories in it require a full commit before they can
 * be logged.  Returns zero if nothing special needs to be done or 1 if
 * a full commit is required.
 */
static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
					       struct inode *inode,
					       struct dentry *parent,
					       struct super_block *sb,
					       u64 last_committed)
4084
{
4085 4086
	int ret = 0;
	struct btrfs_root *root;
4087
	struct dentry *old_parent = NULL;
4088
	struct inode *orig_inode = inode;
4089

4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100
	/*
	 * for regular files, if its inode is already on disk, we don't
	 * have to worry about the parents at all.  This is because
	 * we can use the last_unlink_trans field to record renames
	 * and other fun in this file.
	 */
	if (S_ISREG(inode->i_mode) &&
	    BTRFS_I(inode)->generation <= last_committed &&
	    BTRFS_I(inode)->last_unlink_trans <= last_committed)
			goto out;

4101 4102 4103 4104 4105 4106 4107
	if (!S_ISDIR(inode->i_mode)) {
		if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
			goto out;
		inode = parent->d_inode;
	}

	while (1) {
4108 4109 4110 4111 4112 4113 4114 4115
		/*
		 * If we are logging a directory then we start with our inode,
		 * not our parents inode, so we need to skipp setting the
		 * logged_trans so that further down in the log code we don't
		 * think this inode has already been logged.
		 */
		if (inode != orig_inode)
			BTRFS_I(inode)->logged_trans = trans->transid;
4116 4117 4118 4119 4120 4121 4122 4123 4124
		smp_mb();

		if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
			root = BTRFS_I(inode)->root;

			/*
			 * make sure any commits to the log are forced
			 * to be full commits
			 */
4125
			btrfs_set_log_full_commit(root->fs_info, trans);
4126 4127 4128 4129 4130 4131 4132
			ret = 1;
			break;
		}

		if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
			break;

4133
		if (IS_ROOT(parent))
4134 4135
			break;

4136 4137 4138
		parent = dget_parent(parent);
		dput(old_parent);
		old_parent = parent;
4139 4140 4141
		inode = parent->d_inode;

	}
4142
	dput(old_parent);
4143
out:
4144 4145 4146 4147 4148 4149 4150 4151 4152
	return ret;
}

/*
 * helper function around btrfs_log_inode to make sure newly created
 * parent directories also end up in the log.  A minimal inode and backref
 * only logging is done of any parent directories that are older than
 * the last committed transaction
 */
4153 4154
static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
			    	  struct btrfs_root *root, struct inode *inode,
4155 4156
			    	  struct dentry *parent, int exists_only,
				  struct btrfs_log_ctx *ctx)
4157
{
4158
	int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL;
4159
	struct super_block *sb;
4160
	struct dentry *old_parent = NULL;
4161 4162 4163 4164 4165
	int ret = 0;
	u64 last_committed = root->fs_info->last_trans_committed;

	sb = inode->i_sb;

S
Sage Weil 已提交
4166 4167 4168 4169 4170
	if (btrfs_test_opt(root, NOTREELOG)) {
		ret = 1;
		goto end_no_trans;
	}

4171 4172 4173 4174
	/*
	 * The prev transaction commit doesn't complete, we need do
	 * full commit by ourselves.
	 */
4175 4176 4177 4178 4179 4180
	if (root->fs_info->last_trans_log_full_commit >
	    root->fs_info->last_trans_committed) {
		ret = 1;
		goto end_no_trans;
	}

4181 4182 4183 4184 4185 4186
	if (root != BTRFS_I(inode)->root ||
	    btrfs_root_refs(&root->root_item) == 0) {
		ret = 1;
		goto end_no_trans;
	}

4187 4188 4189 4190
	ret = check_parent_dirs_for_sync(trans, inode, parent,
					 sb, last_committed);
	if (ret)
		goto end_no_trans;
4191

4192
	if (btrfs_inode_in_log(inode, trans->transid)) {
4193 4194 4195 4196
		ret = BTRFS_NO_LOG_SYNC;
		goto end_no_trans;
	}

4197
	ret = start_log_trans(trans, root, ctx);
4198
	if (ret)
4199
		goto end_no_trans;
4200

4201
	ret = btrfs_log_inode(trans, root, inode, inode_only);
4202 4203
	if (ret)
		goto end_trans;
4204

4205 4206 4207 4208 4209 4210 4211 4212
	/*
	 * for regular files, if its inode is already on disk, we don't
	 * have to worry about the parents at all.  This is because
	 * we can use the last_unlink_trans field to record renames
	 * and other fun in this file.
	 */
	if (S_ISREG(inode->i_mode) &&
	    BTRFS_I(inode)->generation <= last_committed &&
4213 4214 4215 4216
	    BTRFS_I(inode)->last_unlink_trans <= last_committed) {
		ret = 0;
		goto end_trans;
	}
4217 4218

	inode_only = LOG_INODE_EXISTS;
4219 4220
	while (1) {
		if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
4221 4222
			break;

4223
		inode = parent->d_inode;
4224 4225 4226
		if (root != BTRFS_I(inode)->root)
			break;

4227 4228 4229
		if (BTRFS_I(inode)->generation >
		    root->fs_info->last_trans_committed) {
			ret = btrfs_log_inode(trans, root, inode, inode_only);
4230 4231
			if (ret)
				goto end_trans;
4232
		}
4233
		if (IS_ROOT(parent))
4234
			break;
4235

4236 4237 4238
		parent = dget_parent(parent);
		dput(old_parent);
		old_parent = parent;
4239
	}
4240
	ret = 0;
4241
end_trans:
4242
	dput(old_parent);
4243
	if (ret < 0) {
4244
		btrfs_set_log_full_commit(root->fs_info, trans);
4245 4246
		ret = 1;
	}
4247 4248 4249

	if (ret)
		btrfs_remove_log_ctx(root, ctx);
4250 4251 4252
	btrfs_end_log_trans(root);
end_no_trans:
	return ret;
4253 4254 4255 4256 4257 4258 4259 4260 4261
}

/*
 * it is not safe to log dentry if the chunk root has added new
 * chunks.  This returns 0 if the dentry was logged, and 1 otherwise.
 * If this returns 1, you must commit the transaction to safely get your
 * data on disk.
 */
int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
4262 4263
			  struct btrfs_root *root, struct dentry *dentry,
			  struct btrfs_log_ctx *ctx)
4264
{
4265 4266 4267
	struct dentry *parent = dget_parent(dentry);
	int ret;

4268 4269
	ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent,
				     0, ctx);
4270 4271 4272
	dput(parent);

	return ret;
4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294
}

/*
 * should be called during mount to recover any replay any log trees
 * from the FS
 */
int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_trans_handle *trans;
	struct btrfs_key key;
	struct btrfs_key found_key;
	struct btrfs_key tmp_key;
	struct btrfs_root *log;
	struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
	struct walk_control wc = {
		.process_func = process_one_buffer,
		.stage = 0,
	};

	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
4295 4296 4297 4298
	if (!path)
		return -ENOMEM;

	fs_info->log_root_recovering = 1;
4299

4300
	trans = btrfs_start_transaction(fs_info->tree_root, 0);
4301 4302 4303 4304
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto error;
	}
4305 4306 4307 4308

	wc.trans = trans;
	wc.pin = 1;

T
Tsutomu Itoh 已提交
4309
	ret = walk_log_tree(trans, log_root_tree, &wc);
4310 4311 4312 4313 4314
	if (ret) {
		btrfs_error(fs_info, ret, "Failed to pin buffers while "
			    "recovering log root tree.");
		goto error;
	}
4315 4316 4317 4318 4319 4320

again:
	key.objectid = BTRFS_TREE_LOG_OBJECTID;
	key.offset = (u64)-1;
	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);

C
Chris Mason 已提交
4321
	while (1) {
4322
		ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
4323 4324 4325 4326 4327 4328

		if (ret < 0) {
			btrfs_error(fs_info, ret,
				    "Couldn't find tree log root.");
			goto error;
		}
4329 4330 4331 4332 4333 4334 4335
		if (ret > 0) {
			if (path->slots[0] == 0)
				break;
			path->slots[0]--;
		}
		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
				      path->slots[0]);
4336
		btrfs_release_path(path);
4337 4338 4339
		if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
			break;

4340
		log = btrfs_read_fs_root(log_root_tree, &found_key);
4341 4342 4343 4344 4345 4346
		if (IS_ERR(log)) {
			ret = PTR_ERR(log);
			btrfs_error(fs_info, ret,
				    "Couldn't read tree log root.");
			goto error;
		}
4347 4348 4349 4350 4351 4352

		tmp_key.objectid = found_key.offset;
		tmp_key.type = BTRFS_ROOT_ITEM_KEY;
		tmp_key.offset = (u64)-1;

		wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key);
4353 4354
		if (IS_ERR(wc.replay_dest)) {
			ret = PTR_ERR(wc.replay_dest);
4355 4356 4357
			free_extent_buffer(log->node);
			free_extent_buffer(log->commit_root);
			kfree(log);
4358 4359 4360 4361
			btrfs_error(fs_info, ret, "Couldn't read target root "
				    "for tree log recovery.");
			goto error;
		}
4362

Y
Yan Zheng 已提交
4363
		wc.replay_dest->log_root = log;
4364
		btrfs_record_root_in_trans(trans, wc.replay_dest);
4365 4366
		ret = walk_log_tree(trans, log, &wc);

4367
		if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
4368 4369 4370 4371 4372
			ret = fixup_inode_link_counts(trans, wc.replay_dest,
						      path);
		}

		key.offset = found_key.offset - 1;
Y
Yan Zheng 已提交
4373
		wc.replay_dest->log_root = NULL;
4374
		free_extent_buffer(log->node);
4375
		free_extent_buffer(log->commit_root);
4376 4377
		kfree(log);

4378 4379 4380
		if (ret)
			goto error;

4381 4382 4383
		if (found_key.offset == 0)
			break;
	}
4384
	btrfs_release_path(path);
4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400

	/* step one is to pin it all, step two is to replay just inodes */
	if (wc.pin) {
		wc.pin = 0;
		wc.process_func = replay_one_buffer;
		wc.stage = LOG_WALK_REPLAY_INODES;
		goto again;
	}
	/* step three is to replay everything */
	if (wc.stage < LOG_WALK_REPLAY_ALL) {
		wc.stage++;
		goto again;
	}

	btrfs_free_path(path);

4401 4402 4403 4404 4405
	/* step 4: commit the transaction, which also unpins the blocks */
	ret = btrfs_commit_transaction(trans, fs_info->tree_root);
	if (ret)
		return ret;

4406 4407 4408 4409
	free_extent_buffer(log_root_tree->node);
	log_root_tree->log_root = NULL;
	fs_info->log_root_recovering = 0;
	kfree(log_root_tree);
4410

4411
	return 0;
4412
error:
4413 4414
	if (wc.trans)
		btrfs_end_transaction(wc.trans, fs_info->tree_root);
4415 4416
	btrfs_free_path(path);
	return ret;
4417
}
4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430

/*
 * there are some corner cases where we want to force a full
 * commit instead of allowing a directory to be logged.
 *
 * They revolve around files there were unlinked from the directory, and
 * this function updates the parent directory so that a full commit is
 * properly done if it is fsync'd later after the unlinks are done.
 */
void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
			     struct inode *dir, struct inode *inode,
			     int for_rename)
{
4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
	/*
	 * when we're logging a file, if it hasn't been renamed
	 * or unlinked, and its inode is fully committed on disk,
	 * we don't have to worry about walking up the directory chain
	 * to log its parents.
	 *
	 * So, we use the last_unlink_trans field to put this transid
	 * into the file.  When the file is logged we check it and
	 * don't log the parents if the file is fully on disk.
	 */
	if (S_ISREG(inode->i_mode))
		BTRFS_I(inode)->last_unlink_trans = trans->transid;

4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488
	/*
	 * if this directory was already logged any new
	 * names for this file/dir will get recorded
	 */
	smp_mb();
	if (BTRFS_I(dir)->logged_trans == trans->transid)
		return;

	/*
	 * if the inode we're about to unlink was logged,
	 * the log will be properly updated for any new names
	 */
	if (BTRFS_I(inode)->logged_trans == trans->transid)
		return;

	/*
	 * when renaming files across directories, if the directory
	 * there we're unlinking from gets fsync'd later on, there's
	 * no way to find the destination directory later and fsync it
	 * properly.  So, we have to be conservative and force commits
	 * so the new name gets discovered.
	 */
	if (for_rename)
		goto record;

	/* we can safely do the unlink without any special recording */
	return;

record:
	BTRFS_I(dir)->last_unlink_trans = trans->transid;
}

/*
 * Call this after adding a new name for a file and it will properly
 * update the log to reflect the new name.
 *
 * It will return zero if all goes well, and it will return 1 if a
 * full transaction commit is required.
 */
int btrfs_log_new_name(struct btrfs_trans_handle *trans,
			struct inode *inode, struct inode *old_dir,
			struct dentry *parent)
{
	struct btrfs_root * root = BTRFS_I(inode)->root;

4489 4490 4491 4492 4493 4494 4495
	/*
	 * this will force the logging code to walk the dentry chain
	 * up for the file
	 */
	if (S_ISREG(inode->i_mode))
		BTRFS_I(inode)->last_unlink_trans = trans->transid;

4496 4497 4498 4499 4500 4501 4502 4503 4504 4505
	/*
	 * if this inode hasn't been logged and directory we're renaming it
	 * from hasn't been logged, we don't need to log it
	 */
	if (BTRFS_I(inode)->logged_trans <=
	    root->fs_info->last_trans_committed &&
	    (!old_dir || BTRFS_I(old_dir)->logged_trans <=
		    root->fs_info->last_trans_committed))
		return 0;

4506
	return btrfs_log_inode_parent(trans, root, inode, parent, 1, NULL);
4507 4508
}