1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2008 Oracle.  All rights reserved.
4  */
5 
6 #include <linux/sched.h>
7 #include <linux/slab.h>
8 #include <linux/blkdev.h>
9 #include <linux/list_sort.h>
10 #include <linux/iversion.h>
11 #include "misc.h"
12 #include "ctree.h"
13 #include "tree-log.h"
14 #include "disk-io.h"
15 #include "locking.h"
16 #include "print-tree.h"
17 #include "backref.h"
18 #include "compression.h"
19 #include "qgroup.h"
20 #include "block-group.h"
21 #include "space-info.h"
22 #include "zoned.h"
23 #include "inode-item.h"
24 
25 #define MAX_CONFLICT_INODES 10
26 
27 /* magic values for the inode_only field in btrfs_log_inode:
28  *
29  * LOG_INODE_ALL means to log everything
30  * LOG_INODE_EXISTS means to log just enough to recreate the inode
31  * during log replay
32  */
33 enum {
34 	LOG_INODE_ALL,
35 	LOG_INODE_EXISTS,
36 };
37 
38 /*
39  * directory trouble cases
40  *
41  * 1) on rename or unlink, if the inode being unlinked isn't in the fsync
42  * log, we must force a full commit before doing an fsync of the directory
43  * where the unlink was done.
44  * ---> record transid of last unlink/rename per directory
45  *
46  * mkdir foo/some_dir
47  * normal commit
48  * rename foo/some_dir foo2/some_dir
49  * mkdir foo/some_dir
50  * fsync foo/some_dir/some_file
51  *
52  * The fsync above will unlink the original some_dir without recording
53  * it in its new location (foo2).  After a crash, some_dir will be gone
54  * unless the fsync of some_file forces a full commit
55  *
56  * 2) we must log any new names for any file or dir that is in the fsync
57  * log. ---> check inode while renaming/linking.
58  *
59  * 2a) we must log any new names for any file or dir during rename
60  * when the directory they are being removed from was logged.
61  * ---> check inode and old parent dir during rename
62  *
63  *  2a is actually the more important variant.  With the extra logging
64  *  a crash might unlink the old name without recreating the new one
65  *
66  * 3) after a crash, we must go through any directories with a link count
67  * of zero and redo the rm -rf
68  *
69  * mkdir f1/foo
70  * normal commit
71  * rm -rf f1/foo
72  * fsync(f1)
73  *
74  * The directory f1 was fully removed from the FS, but fsync was never
75  * called on f1, only its parent dir.  After a crash the rm -rf must
76  * be replayed.  This must be able to recurse down the entire
77  * directory tree.  The inode link count fixup code takes care of the
78  * ugly details.
79  */
80 
81 /*
82  * stages for the tree walking.  The first
83  * stage (0) is to only pin down the blocks we find
84  * the second stage (1) is to make sure that all the inodes
85  * we find in the log are created in the subvolume.
86  *
87  * The last stage is to deal with directories and links and extents
88  * and all the other fun semantics
89  */
90 enum {
91 	LOG_WALK_PIN_ONLY,
92 	LOG_WALK_REPLAY_INODES,
93 	LOG_WALK_REPLAY_DIR_INDEX,
94 	LOG_WALK_REPLAY_ALL,
95 };
96 
97 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
98 			   struct btrfs_inode *inode,
99 			   int inode_only,
100 			   struct btrfs_log_ctx *ctx);
101 static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
102 			     struct btrfs_root *root,
103 			     struct btrfs_path *path, u64 objectid);
104 static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
105 				       struct btrfs_root *root,
106 				       struct btrfs_root *log,
107 				       struct btrfs_path *path,
108 				       u64 dirid, int del_all);
109 static void wait_log_commit(struct btrfs_root *root, int transid);
110 
111 /*
112  * tree logging is a special write ahead log used to make sure that
113  * fsyncs and O_SYNCs can happen without doing full tree commits.
114  *
115  * Full tree commits are expensive because they require commonly
116  * modified blocks to be recowed, creating many dirty pages in the
117  * extent tree an 4x-6x higher write load than ext3.
118  *
119  * Instead of doing a tree commit on every fsync, we use the
120  * key ranges and transaction ids to find items for a given file or directory
121  * that have changed in this transaction.  Those items are copied into
122  * a special tree (one per subvolume root), that tree is written to disk
123  * and then the fsync is considered complete.
124  *
125  * After a crash, items are copied out of the log-tree back into the
126  * subvolume tree.  Any file data extents found are recorded in the extent
127  * allocation tree, and the log-tree freed.
128  *
129  * The log tree is read three times, once to pin down all the extents it is
130  * using in ram and once, once to create all the inodes logged in the tree
131  * and once to do all the other items.
132  */
133 
134 /*
135  * start a sub transaction and setup the log tree
136  * this increments the log tree writer count to make the people
137  * syncing the tree wait for us to finish
138  */
start_log_trans(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_log_ctx * ctx)139 static int start_log_trans(struct btrfs_trans_handle *trans,
140 			   struct btrfs_root *root,
141 			   struct btrfs_log_ctx *ctx)
142 {
143 	struct btrfs_fs_info *fs_info = root->fs_info;
144 	struct btrfs_root *tree_root = fs_info->tree_root;
145 	const bool zoned = btrfs_is_zoned(fs_info);
146 	int ret = 0;
147 	bool created = false;
148 
149 	/*
150 	 * First check if the log root tree was already created. If not, create
151 	 * it before locking the root's log_mutex, just to keep lockdep happy.
152 	 */
153 	if (!test_bit(BTRFS_ROOT_HAS_LOG_TREE, &tree_root->state)) {
154 		mutex_lock(&tree_root->log_mutex);
155 		if (!fs_info->log_root_tree) {
156 			ret = btrfs_init_log_root_tree(trans, fs_info);
157 			if (!ret) {
158 				set_bit(BTRFS_ROOT_HAS_LOG_TREE, &tree_root->state);
159 				created = true;
160 			}
161 		}
162 		mutex_unlock(&tree_root->log_mutex);
163 		if (ret)
164 			return ret;
165 	}
166 
167 	mutex_lock(&root->log_mutex);
168 
169 again:
170 	if (root->log_root) {
171 		int index = (root->log_transid + 1) % 2;
172 
173 		if (btrfs_need_log_full_commit(trans)) {
174 			ret = BTRFS_LOG_FORCE_COMMIT;
175 			goto out;
176 		}
177 
178 		if (zoned && atomic_read(&root->log_commit[index])) {
179 			wait_log_commit(root, root->log_transid - 1);
180 			goto again;
181 		}
182 
183 		if (!root->log_start_pid) {
184 			clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
185 			root->log_start_pid = current->pid;
186 		} else if (root->log_start_pid != current->pid) {
187 			set_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
188 		}
189 	} else {
190 		/*
191 		 * This means fs_info->log_root_tree was already created
192 		 * for some other FS trees. Do the full commit not to mix
193 		 * nodes from multiple log transactions to do sequential
194 		 * writing.
195 		 */
196 		if (zoned && !created) {
197 			ret = BTRFS_LOG_FORCE_COMMIT;
198 			goto out;
199 		}
200 
201 		ret = btrfs_add_log_tree(trans, root);
202 		if (ret)
203 			goto out;
204 
205 		set_bit(BTRFS_ROOT_HAS_LOG_TREE, &root->state);
206 		clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
207 		root->log_start_pid = current->pid;
208 	}
209 
210 	atomic_inc(&root->log_writers);
211 	if (!ctx->logging_new_name) {
212 		int index = root->log_transid % 2;
213 		list_add_tail(&ctx->list, &root->log_ctxs[index]);
214 		ctx->log_transid = root->log_transid;
215 	}
216 
217 out:
218 	mutex_unlock(&root->log_mutex);
219 	return ret;
220 }
221 
222 /*
223  * returns 0 if there was a log transaction running and we were able
224  * to join, or returns -ENOENT if there were not transactions
225  * in progress
226  */
join_running_log_trans(struct btrfs_root * root)227 static int join_running_log_trans(struct btrfs_root *root)
228 {
229 	const bool zoned = btrfs_is_zoned(root->fs_info);
230 	int ret = -ENOENT;
231 
232 	if (!test_bit(BTRFS_ROOT_HAS_LOG_TREE, &root->state))
233 		return ret;
234 
235 	mutex_lock(&root->log_mutex);
236 again:
237 	if (root->log_root) {
238 		int index = (root->log_transid + 1) % 2;
239 
240 		ret = 0;
241 		if (zoned && atomic_read(&root->log_commit[index])) {
242 			wait_log_commit(root, root->log_transid - 1);
243 			goto again;
244 		}
245 		atomic_inc(&root->log_writers);
246 	}
247 	mutex_unlock(&root->log_mutex);
248 	return ret;
249 }
250 
251 /*
252  * This either makes the current running log transaction wait
253  * until you call btrfs_end_log_trans() or it makes any future
254  * log transactions wait until you call btrfs_end_log_trans()
255  */
btrfs_pin_log_trans(struct btrfs_root * root)256 void btrfs_pin_log_trans(struct btrfs_root *root)
257 {
258 	atomic_inc(&root->log_writers);
259 }
260 
261 /*
262  * indicate we're done making changes to the log tree
263  * and wake up anyone waiting to do a sync
264  */
btrfs_end_log_trans(struct btrfs_root * root)265 void btrfs_end_log_trans(struct btrfs_root *root)
266 {
267 	if (atomic_dec_and_test(&root->log_writers)) {
268 		/* atomic_dec_and_test implies a barrier */
269 		cond_wake_up_nomb(&root->log_writer_wait);
270 	}
271 }
272 
btrfs_wait_tree_block_writeback(struct extent_buffer * buf)273 static void btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
274 {
275 	filemap_fdatawait_range(buf->pages[0]->mapping,
276 			        buf->start, buf->start + buf->len - 1);
277 }
278 
279 /*
280  * the walk control struct is used to pass state down the chain when
281  * processing the log tree.  The stage field tells us which part
282  * of the log tree processing we are currently doing.  The others
283  * are state fields used for that specific part
284  */
285 struct walk_control {
286 	/* should we free the extent on disk when done?  This is used
287 	 * at transaction commit time while freeing a log tree
288 	 */
289 	int free;
290 
291 	/* pin only walk, we record which extents on disk belong to the
292 	 * log trees
293 	 */
294 	int pin;
295 
296 	/* what stage of the replay code we're currently in */
297 	int stage;
298 
299 	/*
300 	 * Ignore any items from the inode currently being processed. Needs
301 	 * to be set every time we find a BTRFS_INODE_ITEM_KEY and we are in
302 	 * the LOG_WALK_REPLAY_INODES stage.
303 	 */
304 	bool ignore_cur_inode;
305 
306 	/* the root we are currently replaying */
307 	struct btrfs_root *replay_dest;
308 
309 	/* the trans handle for the current replay */
310 	struct btrfs_trans_handle *trans;
311 
312 	/* the function that gets used to process blocks we find in the
313 	 * tree.  Note the extent_buffer might not be up to date when it is
314 	 * passed in, and it must be checked or read if you need the data
315 	 * inside it
316 	 */
317 	int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
318 			    struct walk_control *wc, u64 gen, int level);
319 };
320 
321 /*
322  * process_func used to pin down extents, write them or wait on them
323  */
process_one_buffer(struct btrfs_root * log,struct extent_buffer * eb,struct walk_control * wc,u64 gen,int level)324 static int process_one_buffer(struct btrfs_root *log,
325 			      struct extent_buffer *eb,
326 			      struct walk_control *wc, u64 gen, int level)
327 {
328 	struct btrfs_fs_info *fs_info = log->fs_info;
329 	int ret = 0;
330 
331 	/*
332 	 * If this fs is mixed then we need to be able to process the leaves to
333 	 * pin down any logged extents, so we have to read the block.
334 	 */
335 	if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
336 		ret = btrfs_read_extent_buffer(eb, gen, level, NULL);
337 		if (ret)
338 			return ret;
339 	}
340 
341 	if (wc->pin) {
342 		ret = btrfs_pin_extent_for_log_replay(wc->trans, eb->start,
343 						      eb->len);
344 		if (ret)
345 			return ret;
346 
347 		if (btrfs_buffer_uptodate(eb, gen, 0) &&
348 		    btrfs_header_level(eb) == 0)
349 			ret = btrfs_exclude_logged_extents(eb);
350 	}
351 	return ret;
352 }
353 
do_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)354 static int do_overwrite_item(struct btrfs_trans_handle *trans,
355 			     struct btrfs_root *root,
356 			     struct btrfs_path *path,
357 			     struct extent_buffer *eb, int slot,
358 			     struct btrfs_key *key)
359 {
360 	int ret;
361 	u32 item_size;
362 	u64 saved_i_size = 0;
363 	int save_old_i_size = 0;
364 	unsigned long src_ptr;
365 	unsigned long dst_ptr;
366 	int overwrite_root = 0;
367 	bool inode_item = key->type == BTRFS_INODE_ITEM_KEY;
368 
369 	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
370 		overwrite_root = 1;
371 
372 	item_size = btrfs_item_size(eb, slot);
373 	src_ptr = btrfs_item_ptr_offset(eb, slot);
374 
375 	/* Our caller must have done a search for the key for us. */
376 	ASSERT(path->nodes[0] != NULL);
377 
378 	/*
379 	 * And the slot must point to the exact key or the slot where the key
380 	 * should be at (the first item with a key greater than 'key')
381 	 */
382 	if (path->slots[0] < btrfs_header_nritems(path->nodes[0])) {
383 		struct btrfs_key found_key;
384 
385 		btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
386 		ret = btrfs_comp_cpu_keys(&found_key, key);
387 		ASSERT(ret >= 0);
388 	} else {
389 		ret = 1;
390 	}
391 
392 	if (ret == 0) {
393 		char *src_copy;
394 		char *dst_copy;
395 		u32 dst_size = btrfs_item_size(path->nodes[0],
396 						  path->slots[0]);
397 		if (dst_size != item_size)
398 			goto insert;
399 
400 		if (item_size == 0) {
401 			btrfs_release_path(path);
402 			return 0;
403 		}
404 		dst_copy = kmalloc(item_size, GFP_NOFS);
405 		src_copy = kmalloc(item_size, GFP_NOFS);
406 		if (!dst_copy || !src_copy) {
407 			btrfs_release_path(path);
408 			kfree(dst_copy);
409 			kfree(src_copy);
410 			return -ENOMEM;
411 		}
412 
413 		read_extent_buffer(eb, src_copy, src_ptr, item_size);
414 
415 		dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
416 		read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
417 				   item_size);
418 		ret = memcmp(dst_copy, src_copy, item_size);
419 
420 		kfree(dst_copy);
421 		kfree(src_copy);
422 		/*
423 		 * they have the same contents, just return, this saves
424 		 * us from cowing blocks in the destination tree and doing
425 		 * extra writes that may not have been done by a previous
426 		 * sync
427 		 */
428 		if (ret == 0) {
429 			btrfs_release_path(path);
430 			return 0;
431 		}
432 
433 		/*
434 		 * We need to load the old nbytes into the inode so when we
435 		 * replay the extents we've logged we get the right nbytes.
436 		 */
437 		if (inode_item) {
438 			struct btrfs_inode_item *item;
439 			u64 nbytes;
440 			u32 mode;
441 
442 			item = btrfs_item_ptr(path->nodes[0], path->slots[0],
443 					      struct btrfs_inode_item);
444 			nbytes = btrfs_inode_nbytes(path->nodes[0], item);
445 			item = btrfs_item_ptr(eb, slot,
446 					      struct btrfs_inode_item);
447 			btrfs_set_inode_nbytes(eb, item, nbytes);
448 
449 			/*
450 			 * If this is a directory we need to reset the i_size to
451 			 * 0 so that we can set it up properly when replaying
452 			 * the rest of the items in this log.
453 			 */
454 			mode = btrfs_inode_mode(eb, item);
455 			if (S_ISDIR(mode))
456 				btrfs_set_inode_size(eb, item, 0);
457 		}
458 	} else if (inode_item) {
459 		struct btrfs_inode_item *item;
460 		u32 mode;
461 
462 		/*
463 		 * New inode, set nbytes to 0 so that the nbytes comes out
464 		 * properly when we replay the extents.
465 		 */
466 		item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
467 		btrfs_set_inode_nbytes(eb, item, 0);
468 
469 		/*
470 		 * If this is a directory we need to reset the i_size to 0 so
471 		 * that we can set it up properly when replaying the rest of
472 		 * the items in this log.
473 		 */
474 		mode = btrfs_inode_mode(eb, item);
475 		if (S_ISDIR(mode))
476 			btrfs_set_inode_size(eb, item, 0);
477 	}
478 insert:
479 	btrfs_release_path(path);
480 	/* try to insert the key into the destination tree */
481 	path->skip_release_on_error = 1;
482 	ret = btrfs_insert_empty_item(trans, root, path,
483 				      key, item_size);
484 	path->skip_release_on_error = 0;
485 
486 	/* make sure any existing item is the correct size */
487 	if (ret == -EEXIST || ret == -EOVERFLOW) {
488 		u32 found_size;
489 		found_size = btrfs_item_size(path->nodes[0],
490 						path->slots[0]);
491 		if (found_size > item_size)
492 			btrfs_truncate_item(path, item_size, 1);
493 		else if (found_size < item_size)
494 			btrfs_extend_item(path, item_size - found_size);
495 	} else if (ret) {
496 		return ret;
497 	}
498 	dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
499 					path->slots[0]);
500 
501 	/* don't overwrite an existing inode if the generation number
502 	 * was logged as zero.  This is done when the tree logging code
503 	 * is just logging an inode to make sure it exists after recovery.
504 	 *
505 	 * Also, don't overwrite i_size on directories during replay.
506 	 * log replay inserts and removes directory items based on the
507 	 * state of the tree found in the subvolume, and i_size is modified
508 	 * as it goes
509 	 */
510 	if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
511 		struct btrfs_inode_item *src_item;
512 		struct btrfs_inode_item *dst_item;
513 
514 		src_item = (struct btrfs_inode_item *)src_ptr;
515 		dst_item = (struct btrfs_inode_item *)dst_ptr;
516 
517 		if (btrfs_inode_generation(eb, src_item) == 0) {
518 			struct extent_buffer *dst_eb = path->nodes[0];
519 			const u64 ino_size = btrfs_inode_size(eb, src_item);
520 
521 			/*
522 			 * For regular files an ino_size == 0 is used only when
523 			 * logging that an inode exists, as part of a directory
524 			 * fsync, and the inode wasn't fsynced before. In this
525 			 * case don't set the size of the inode in the fs/subvol
526 			 * tree, otherwise we would be throwing valid data away.
527 			 */
528 			if (S_ISREG(btrfs_inode_mode(eb, src_item)) &&
529 			    S_ISREG(btrfs_inode_mode(dst_eb, dst_item)) &&
530 			    ino_size != 0)
531 				btrfs_set_inode_size(dst_eb, dst_item, ino_size);
532 			goto no_copy;
533 		}
534 
535 		if (overwrite_root &&
536 		    S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
537 		    S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
538 			save_old_i_size = 1;
539 			saved_i_size = btrfs_inode_size(path->nodes[0],
540 							dst_item);
541 		}
542 	}
543 
544 	copy_extent_buffer(path->nodes[0], eb, dst_ptr,
545 			   src_ptr, item_size);
546 
547 	if (save_old_i_size) {
548 		struct btrfs_inode_item *dst_item;
549 		dst_item = (struct btrfs_inode_item *)dst_ptr;
550 		btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
551 	}
552 
553 	/* make sure the generation is filled in */
554 	if (key->type == BTRFS_INODE_ITEM_KEY) {
555 		struct btrfs_inode_item *dst_item;
556 		dst_item = (struct btrfs_inode_item *)dst_ptr;
557 		if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
558 			btrfs_set_inode_generation(path->nodes[0], dst_item,
559 						   trans->transid);
560 		}
561 	}
562 no_copy:
563 	btrfs_mark_buffer_dirty(path->nodes[0]);
564 	btrfs_release_path(path);
565 	return 0;
566 }
567 
568 /*
569  * Item overwrite used by replay and tree logging.  eb, slot and key all refer
570  * to the src data we are copying out.
571  *
572  * root is the tree we are copying into, and path is a scratch
573  * path for use in this function (it should be released on entry and
574  * will be released on exit).
575  *
576  * If the key is already in the destination tree the existing item is
577  * overwritten.  If the existing item isn't big enough, it is extended.
578  * If it is too large, it is truncated.
579  *
580  * If the key isn't in the destination yet, a new item is inserted.
581  */
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)582 static int overwrite_item(struct btrfs_trans_handle *trans,
583 			  struct btrfs_root *root,
584 			  struct btrfs_path *path,
585 			  struct extent_buffer *eb, int slot,
586 			  struct btrfs_key *key)
587 {
588 	int ret;
589 
590 	/* Look for the key in the destination tree. */
591 	ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
592 	if (ret < 0)
593 		return ret;
594 
595 	return do_overwrite_item(trans, root, path, eb, slot, key);
596 }
597 
598 /*
599  * simple helper to read an inode off the disk from a given root
600  * This can only be called for subvolume roots and not for the log
601  */
read_one_inode(struct btrfs_root * root,u64 objectid)602 static noinline struct inode *read_one_inode(struct btrfs_root *root,
603 					     u64 objectid)
604 {
605 	struct inode *inode;
606 
607 	inode = btrfs_iget(root->fs_info->sb, objectid, root);
608 	if (IS_ERR(inode))
609 		inode = NULL;
610 	return inode;
611 }
612 
613 /* replays a single extent in 'eb' at 'slot' with 'key' into the
614  * subvolume 'root'.  path is released on entry and should be released
615  * on exit.
616  *
617  * extents in the log tree have not been allocated out of the extent
618  * tree yet.  So, this completes the allocation, taking a reference
619  * as required if the extent already exists or creating a new extent
620  * if it isn't in the extent allocation tree yet.
621  *
622  * The extent is inserted into the file, dropping any existing extents
623  * from the file that overlap the new one.
624  */
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)625 static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
626 				      struct btrfs_root *root,
627 				      struct btrfs_path *path,
628 				      struct extent_buffer *eb, int slot,
629 				      struct btrfs_key *key)
630 {
631 	struct btrfs_drop_extents_args drop_args = { 0 };
632 	struct btrfs_fs_info *fs_info = root->fs_info;
633 	int found_type;
634 	u64 extent_end;
635 	u64 start = key->offset;
636 	u64 nbytes = 0;
637 	struct btrfs_file_extent_item *item;
638 	struct inode *inode = NULL;
639 	unsigned long size;
640 	int ret = 0;
641 
642 	item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
643 	found_type = btrfs_file_extent_type(eb, item);
644 
645 	if (found_type == BTRFS_FILE_EXTENT_REG ||
646 	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
647 		nbytes = btrfs_file_extent_num_bytes(eb, item);
648 		extent_end = start + nbytes;
649 
650 		/*
651 		 * We don't add to the inodes nbytes if we are prealloc or a
652 		 * hole.
653 		 */
654 		if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
655 			nbytes = 0;
656 	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
657 		size = btrfs_file_extent_ram_bytes(eb, item);
658 		nbytes = btrfs_file_extent_ram_bytes(eb, item);
659 		extent_end = ALIGN(start + size,
660 				   fs_info->sectorsize);
661 	} else {
662 		ret = 0;
663 		goto out;
664 	}
665 
666 	inode = read_one_inode(root, key->objectid);
667 	if (!inode) {
668 		ret = -EIO;
669 		goto out;
670 	}
671 
672 	/*
673 	 * first check to see if we already have this extent in the
674 	 * file.  This must be done before the btrfs_drop_extents run
675 	 * so we don't try to drop this extent.
676 	 */
677 	ret = btrfs_lookup_file_extent(trans, root, path,
678 			btrfs_ino(BTRFS_I(inode)), start, 0);
679 
680 	if (ret == 0 &&
681 	    (found_type == BTRFS_FILE_EXTENT_REG ||
682 	     found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
683 		struct btrfs_file_extent_item cmp1;
684 		struct btrfs_file_extent_item cmp2;
685 		struct btrfs_file_extent_item *existing;
686 		struct extent_buffer *leaf;
687 
688 		leaf = path->nodes[0];
689 		existing = btrfs_item_ptr(leaf, path->slots[0],
690 					  struct btrfs_file_extent_item);
691 
692 		read_extent_buffer(eb, &cmp1, (unsigned long)item,
693 				   sizeof(cmp1));
694 		read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
695 				   sizeof(cmp2));
696 
697 		/*
698 		 * we already have a pointer to this exact extent,
699 		 * we don't have to do anything
700 		 */
701 		if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
702 			btrfs_release_path(path);
703 			goto out;
704 		}
705 	}
706 	btrfs_release_path(path);
707 
708 	/* drop any overlapping extents */
709 	drop_args.start = start;
710 	drop_args.end = extent_end;
711 	drop_args.drop_cache = true;
712 	ret = btrfs_drop_extents(trans, root, BTRFS_I(inode), &drop_args);
713 	if (ret)
714 		goto out;
715 
716 	if (found_type == BTRFS_FILE_EXTENT_REG ||
717 	    found_type == BTRFS_FILE_EXTENT_PREALLOC) {
718 		u64 offset;
719 		unsigned long dest_offset;
720 		struct btrfs_key ins;
721 
722 		if (btrfs_file_extent_disk_bytenr(eb, item) == 0 &&
723 		    btrfs_fs_incompat(fs_info, NO_HOLES))
724 			goto update_inode;
725 
726 		ret = btrfs_insert_empty_item(trans, root, path, key,
727 					      sizeof(*item));
728 		if (ret)
729 			goto out;
730 		dest_offset = btrfs_item_ptr_offset(path->nodes[0],
731 						    path->slots[0]);
732 		copy_extent_buffer(path->nodes[0], eb, dest_offset,
733 				(unsigned long)item,  sizeof(*item));
734 
735 		ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
736 		ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
737 		ins.type = BTRFS_EXTENT_ITEM_KEY;
738 		offset = key->offset - btrfs_file_extent_offset(eb, item);
739 
740 		/*
741 		 * Manually record dirty extent, as here we did a shallow
742 		 * file extent item copy and skip normal backref update,
743 		 * but modifying extent tree all by ourselves.
744 		 * So need to manually record dirty extent for qgroup,
745 		 * as the owner of the file extent changed from log tree
746 		 * (doesn't affect qgroup) to fs/file tree(affects qgroup)
747 		 */
748 		ret = btrfs_qgroup_trace_extent(trans,
749 				btrfs_file_extent_disk_bytenr(eb, item),
750 				btrfs_file_extent_disk_num_bytes(eb, item),
751 				GFP_NOFS);
752 		if (ret < 0)
753 			goto out;
754 
755 		if (ins.objectid > 0) {
756 			struct btrfs_ref ref = { 0 };
757 			u64 csum_start;
758 			u64 csum_end;
759 			LIST_HEAD(ordered_sums);
760 
761 			/*
762 			 * is this extent already allocated in the extent
763 			 * allocation tree?  If so, just add a reference
764 			 */
765 			ret = btrfs_lookup_data_extent(fs_info, ins.objectid,
766 						ins.offset);
767 			if (ret < 0) {
768 				goto out;
769 			} else if (ret == 0) {
770 				btrfs_init_generic_ref(&ref,
771 						BTRFS_ADD_DELAYED_REF,
772 						ins.objectid, ins.offset, 0);
773 				btrfs_init_data_ref(&ref,
774 						root->root_key.objectid,
775 						key->objectid, offset, 0, false);
776 				ret = btrfs_inc_extent_ref(trans, &ref);
777 				if (ret)
778 					goto out;
779 			} else {
780 				/*
781 				 * insert the extent pointer in the extent
782 				 * allocation tree
783 				 */
784 				ret = btrfs_alloc_logged_file_extent(trans,
785 						root->root_key.objectid,
786 						key->objectid, offset, &ins);
787 				if (ret)
788 					goto out;
789 			}
790 			btrfs_release_path(path);
791 
792 			if (btrfs_file_extent_compression(eb, item)) {
793 				csum_start = ins.objectid;
794 				csum_end = csum_start + ins.offset;
795 			} else {
796 				csum_start = ins.objectid +
797 					btrfs_file_extent_offset(eb, item);
798 				csum_end = csum_start +
799 					btrfs_file_extent_num_bytes(eb, item);
800 			}
801 
802 			ret = btrfs_lookup_csums_range(root->log_root,
803 						csum_start, csum_end - 1,
804 						&ordered_sums, 0, false);
805 			if (ret)
806 				goto out;
807 			/*
808 			 * Now delete all existing cums in the csum root that
809 			 * cover our range. We do this because we can have an
810 			 * extent that is completely referenced by one file
811 			 * extent item and partially referenced by another
812 			 * file extent item (like after using the clone or
813 			 * extent_same ioctls). In this case if we end up doing
814 			 * the replay of the one that partially references the
815 			 * extent first, and we do not do the csum deletion
816 			 * below, we can get 2 csum items in the csum tree that
817 			 * overlap each other. For example, imagine our log has
818 			 * the two following file extent items:
819 			 *
820 			 * key (257 EXTENT_DATA 409600)
821 			 *     extent data disk byte 12845056 nr 102400
822 			 *     extent data offset 20480 nr 20480 ram 102400
823 			 *
824 			 * key (257 EXTENT_DATA 819200)
825 			 *     extent data disk byte 12845056 nr 102400
826 			 *     extent data offset 0 nr 102400 ram 102400
827 			 *
828 			 * Where the second one fully references the 100K extent
829 			 * that starts at disk byte 12845056, and the log tree
830 			 * has a single csum item that covers the entire range
831 			 * of the extent:
832 			 *
833 			 * key (EXTENT_CSUM EXTENT_CSUM 12845056) itemsize 100
834 			 *
835 			 * After the first file extent item is replayed, the
836 			 * csum tree gets the following csum item:
837 			 *
838 			 * key (EXTENT_CSUM EXTENT_CSUM 12865536) itemsize 20
839 			 *
840 			 * Which covers the 20K sub-range starting at offset 20K
841 			 * of our extent. Now when we replay the second file
842 			 * extent item, if we do not delete existing csum items
843 			 * that cover any of its blocks, we end up getting two
844 			 * csum items in our csum tree that overlap each other:
845 			 *
846 			 * key (EXTENT_CSUM EXTENT_CSUM 12845056) itemsize 100
847 			 * key (EXTENT_CSUM EXTENT_CSUM 12865536) itemsize 20
848 			 *
849 			 * Which is a problem, because after this anyone trying
850 			 * to lookup up for the checksum of any block of our
851 			 * extent starting at an offset of 40K or higher, will
852 			 * end up looking at the second csum item only, which
853 			 * does not contain the checksum for any block starting
854 			 * at offset 40K or higher of our extent.
855 			 */
856 			while (!list_empty(&ordered_sums)) {
857 				struct btrfs_ordered_sum *sums;
858 				struct btrfs_root *csum_root;
859 
860 				sums = list_entry(ordered_sums.next,
861 						struct btrfs_ordered_sum,
862 						list);
863 				csum_root = btrfs_csum_root(fs_info,
864 							    sums->bytenr);
865 				if (!ret)
866 					ret = btrfs_del_csums(trans, csum_root,
867 							      sums->bytenr,
868 							      sums->len);
869 				if (!ret)
870 					ret = btrfs_csum_file_blocks(trans,
871 								     csum_root,
872 								     sums);
873 				list_del(&sums->list);
874 				kfree(sums);
875 			}
876 			if (ret)
877 				goto out;
878 		} else {
879 			btrfs_release_path(path);
880 		}
881 	} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
882 		/* inline extents are easy, we just overwrite them */
883 		ret = overwrite_item(trans, root, path, eb, slot, key);
884 		if (ret)
885 			goto out;
886 	}
887 
888 	ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), start,
889 						extent_end - start);
890 	if (ret)
891 		goto out;
892 
893 update_inode:
894 	btrfs_update_inode_bytes(BTRFS_I(inode), nbytes, drop_args.bytes_found);
895 	ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
896 out:
897 	iput(inode);
898 	return ret;
899 }
900 
unlink_inode_for_log_replay(struct btrfs_trans_handle * trans,struct btrfs_inode * dir,struct btrfs_inode * inode,const char * name,int name_len)901 static int unlink_inode_for_log_replay(struct btrfs_trans_handle *trans,
902 				       struct btrfs_inode *dir,
903 				       struct btrfs_inode *inode,
904 				       const char *name,
905 				       int name_len)
906 {
907 	int ret;
908 
909 	ret = btrfs_unlink_inode(trans, dir, inode, name, name_len);
910 	if (ret)
911 		return ret;
912 	/*
913 	 * Whenever we need to check if a name exists or not, we check the
914 	 * fs/subvolume tree. So after an unlink we must run delayed items, so
915 	 * that future checks for a name during log replay see that the name
916 	 * does not exists anymore.
917 	 */
918 	return btrfs_run_delayed_items(trans);
919 }
920 
921 /*
922  * when cleaning up conflicts between the directory names in the
923  * subvolume, directory names in the log and directory names in the
924  * inode back references, we may have to unlink inodes from directories.
925  *
926  * This is a helper function to do the unlink of a specific directory
927  * item
928  */
drop_one_dir_item(struct btrfs_trans_handle * trans,struct btrfs_path * path,struct btrfs_inode * dir,struct btrfs_dir_item * di)929 static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
930 				      struct btrfs_path *path,
931 				      struct btrfs_inode *dir,
932 				      struct btrfs_dir_item *di)
933 {
934 	struct btrfs_root *root = dir->root;
935 	struct inode *inode;
936 	char *name;
937 	int name_len;
938 	struct extent_buffer *leaf;
939 	struct btrfs_key location;
940 	int ret;
941 
942 	leaf = path->nodes[0];
943 
944 	btrfs_dir_item_key_to_cpu(leaf, di, &location);
945 	name_len = btrfs_dir_name_len(leaf, di);
946 	name = kmalloc(name_len, GFP_NOFS);
947 	if (!name)
948 		return -ENOMEM;
949 
950 	read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
951 	btrfs_release_path(path);
952 
953 	inode = read_one_inode(root, location.objectid);
954 	if (!inode) {
955 		ret = -EIO;
956 		goto out;
957 	}
958 
959 	ret = link_to_fixup_dir(trans, root, path, location.objectid);
960 	if (ret)
961 		goto out;
962 
963 	ret = unlink_inode_for_log_replay(trans, dir, BTRFS_I(inode), name,
964 			name_len);
965 out:
966 	kfree(name);
967 	iput(inode);
968 	return ret;
969 }
970 
971 /*
972  * See if a given name and sequence number found in an inode back reference are
973  * already in a directory and correctly point to this inode.
974  *
975  * Returns: < 0 on error, 0 if the directory entry does not exists and 1 if it
976  * exists.
977  */
inode_in_dir(struct btrfs_root * root,struct btrfs_path * path,u64 dirid,u64 objectid,u64 index,const char * name,int name_len)978 static noinline int inode_in_dir(struct btrfs_root *root,
979 				 struct btrfs_path *path,
980 				 u64 dirid, u64 objectid, u64 index,
981 				 const char *name, int name_len)
982 {
983 	struct btrfs_dir_item *di;
984 	struct btrfs_key location;
985 	int ret = 0;
986 
987 	di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
988 					 index, name, name_len, 0);
989 	if (IS_ERR(di)) {
990 		ret = PTR_ERR(di);
991 		goto out;
992 	} else if (di) {
993 		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
994 		if (location.objectid != objectid)
995 			goto out;
996 	} else {
997 		goto out;
998 	}
999 
1000 	btrfs_release_path(path);
1001 	di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
1002 	if (IS_ERR(di)) {
1003 		ret = PTR_ERR(di);
1004 		goto out;
1005 	} else if (di) {
1006 		btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
1007 		if (location.objectid == objectid)
1008 			ret = 1;
1009 	}
1010 out:
1011 	btrfs_release_path(path);
1012 	return ret;
1013 }
1014 
1015 /*
1016  * helper function to check a log tree for a named back reference in
1017  * an inode.  This is used to decide if a back reference that is
1018  * found in the subvolume conflicts with what we find in the log.
1019  *
1020  * inode backreferences may have multiple refs in a single item,
1021  * during replay we process one reference at a time, and we don't
1022  * want to delete valid links to a file from the subvolume if that
1023  * link is also in the log.
1024  */
backref_in_log(struct btrfs_root * log,struct btrfs_key * key,u64 ref_objectid,const char * name,int namelen)1025 static noinline int backref_in_log(struct btrfs_root *log,
1026 				   struct btrfs_key *key,
1027 				   u64 ref_objectid,
1028 				   const char *name, int namelen)
1029 {
1030 	struct btrfs_path *path;
1031 	int ret;
1032 
1033 	path = btrfs_alloc_path();
1034 	if (!path)
1035 		return -ENOMEM;
1036 
1037 	ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
1038 	if (ret < 0) {
1039 		goto out;
1040 	} else if (ret == 1) {
1041 		ret = 0;
1042 		goto out;
1043 	}
1044 
1045 	if (key->type == BTRFS_INODE_EXTREF_KEY)
1046 		ret = !!btrfs_find_name_in_ext_backref(path->nodes[0],
1047 						       path->slots[0],
1048 						       ref_objectid,
1049 						       name, namelen);
1050 	else
1051 		ret = !!btrfs_find_name_in_backref(path->nodes[0],
1052 						   path->slots[0],
1053 						   name, namelen);
1054 out:
1055 	btrfs_free_path(path);
1056 	return ret;
1057 }
1058 
__add_inode_ref(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,struct btrfs_root * log_root,struct btrfs_inode * dir,struct btrfs_inode * inode,u64 inode_objectid,u64 parent_objectid,u64 ref_index,char * name,int namelen)1059 static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
1060 				  struct btrfs_root *root,
1061 				  struct btrfs_path *path,
1062 				  struct btrfs_root *log_root,
1063 				  struct btrfs_inode *dir,
1064 				  struct btrfs_inode *inode,
1065 				  u64 inode_objectid, u64 parent_objectid,
1066 				  u64 ref_index, char *name, int namelen)
1067 {
1068 	int ret;
1069 	char *victim_name;
1070 	int victim_name_len;
1071 	struct extent_buffer *leaf;
1072 	struct btrfs_dir_item *di;
1073 	struct btrfs_key search_key;
1074 	struct btrfs_inode_extref *extref;
1075 
1076 again:
1077 	/* Search old style refs */
1078 	search_key.objectid = inode_objectid;
1079 	search_key.type = BTRFS_INODE_REF_KEY;
1080 	search_key.offset = parent_objectid;
1081 	ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
1082 	if (ret == 0) {
1083 		struct btrfs_inode_ref *victim_ref;
1084 		unsigned long ptr;
1085 		unsigned long ptr_end;
1086 
1087 		leaf = path->nodes[0];
1088 
1089 		/* are we trying to overwrite a back ref for the root directory
1090 		 * if so, just jump out, we're done
1091 		 */
1092 		if (search_key.objectid == search_key.offset)
1093 			return 1;
1094 
1095 		/* check all the names in this back reference to see
1096 		 * if they are in the log.  if so, we allow them to stay
1097 		 * otherwise they must be unlinked as a conflict
1098 		 */
1099 		ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
1100 		ptr_end = ptr + btrfs_item_size(leaf, path->slots[0]);
1101 		while (ptr < ptr_end) {
1102 			victim_ref = (struct btrfs_inode_ref *)ptr;
1103 			victim_name_len = btrfs_inode_ref_name_len(leaf,
1104 								   victim_ref);
1105 			victim_name = kmalloc(victim_name_len, GFP_NOFS);
1106 			if (!victim_name)
1107 				return -ENOMEM;
1108 
1109 			read_extent_buffer(leaf, victim_name,
1110 					   (unsigned long)(victim_ref + 1),
1111 					   victim_name_len);
1112 
1113 			ret = backref_in_log(log_root, &search_key,
1114 					     parent_objectid, victim_name,
1115 					     victim_name_len);
1116 			if (ret < 0) {
1117 				kfree(victim_name);
1118 				return ret;
1119 			} else if (!ret) {
1120 				inc_nlink(&inode->vfs_inode);
1121 				btrfs_release_path(path);
1122 
1123 				ret = unlink_inode_for_log_replay(trans, dir, inode,
1124 						victim_name, victim_name_len);
1125 				kfree(victim_name);
1126 				if (ret)
1127 					return ret;
1128 				goto again;
1129 			}
1130 			kfree(victim_name);
1131 
1132 			ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
1133 		}
1134 	}
1135 	btrfs_release_path(path);
1136 
1137 	/* Same search but for extended refs */
1138 	extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
1139 					   inode_objectid, parent_objectid, 0,
1140 					   0);
1141 	if (IS_ERR(extref)) {
1142 		return PTR_ERR(extref);
1143 	} else if (extref) {
1144 		u32 item_size;
1145 		u32 cur_offset = 0;
1146 		unsigned long base;
1147 		struct inode *victim_parent;
1148 
1149 		leaf = path->nodes[0];
1150 
1151 		item_size = btrfs_item_size(leaf, path->slots[0]);
1152 		base = btrfs_item_ptr_offset(leaf, path->slots[0]);
1153 
1154 		while (cur_offset < item_size) {
1155 			extref = (struct btrfs_inode_extref *)(base + cur_offset);
1156 
1157 			victim_name_len = btrfs_inode_extref_name_len(leaf, extref);
1158 
1159 			if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
1160 				goto next;
1161 
1162 			victim_name = kmalloc(victim_name_len, GFP_NOFS);
1163 			if (!victim_name)
1164 				return -ENOMEM;
1165 			read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
1166 					   victim_name_len);
1167 
1168 			search_key.objectid = inode_objectid;
1169 			search_key.type = BTRFS_INODE_EXTREF_KEY;
1170 			search_key.offset = btrfs_extref_hash(parent_objectid,
1171 							      victim_name,
1172 							      victim_name_len);
1173 			ret = backref_in_log(log_root, &search_key,
1174 					     parent_objectid, victim_name,
1175 					     victim_name_len);
1176 			if (ret < 0) {
1177 				kfree(victim_name);
1178 				return ret;
1179 			} else if (!ret) {
1180 				ret = -ENOENT;
1181 				victim_parent = read_one_inode(root,
1182 						parent_objectid);
1183 				if (victim_parent) {
1184 					inc_nlink(&inode->vfs_inode);
1185 					btrfs_release_path(path);
1186 
1187 					ret = unlink_inode_for_log_replay(trans,
1188 							BTRFS_I(victim_parent),
1189 							inode,
1190 							victim_name,
1191 							victim_name_len);
1192 				}
1193 				iput(victim_parent);
1194 				kfree(victim_name);
1195 				if (ret)
1196 					return ret;
1197 				goto again;
1198 			}
1199 			kfree(victim_name);
1200 next:
1201 			cur_offset += victim_name_len + sizeof(*extref);
1202 		}
1203 	}
1204 	btrfs_release_path(path);
1205 
1206 	/* look for a conflicting sequence number */
1207 	di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
1208 					 ref_index, name, namelen, 0);
1209 	if (IS_ERR(di)) {
1210 		return PTR_ERR(di);
1211 	} else if (di) {
1212 		ret = drop_one_dir_item(trans, path, dir, di);
1213 		if (ret)
1214 			return ret;
1215 	}
1216 	btrfs_release_path(path);
1217 
1218 	/* look for a conflicting name */
1219 	di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
1220 				   name, namelen, 0);
1221 	if (IS_ERR(di)) {
1222 		return PTR_ERR(di);
1223 	} else if (di) {
1224 		ret = drop_one_dir_item(trans, path, dir, di);
1225 		if (ret)
1226 			return ret;
1227 	}
1228 	btrfs_release_path(path);
1229 
1230 	return 0;
1231 }
1232 
extref_get_fields(struct extent_buffer * eb,unsigned long ref_ptr,u32 * namelen,char ** name,u64 * index,u64 * parent_objectid)1233 static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
1234 			     u32 *namelen, char **name, u64 *index,
1235 			     u64 *parent_objectid)
1236 {
1237 	struct btrfs_inode_extref *extref;
1238 
1239 	extref = (struct btrfs_inode_extref *)ref_ptr;
1240 
1241 	*namelen = btrfs_inode_extref_name_len(eb, extref);
1242 	*name = kmalloc(*namelen, GFP_NOFS);
1243 	if (*name == NULL)
1244 		return -ENOMEM;
1245 
1246 	read_extent_buffer(eb, *name, (unsigned long)&extref->name,
1247 			   *namelen);
1248 
1249 	if (index)
1250 		*index = btrfs_inode_extref_index(eb, extref);
1251 	if (parent_objectid)
1252 		*parent_objectid = btrfs_inode_extref_parent(eb, extref);
1253 
1254 	return 0;
1255 }
1256 
ref_get_fields(struct extent_buffer * eb,unsigned long ref_ptr,u32 * namelen,char ** name,u64 * index)1257 static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
1258 			  u32 *namelen, char **name, u64 *index)
1259 {
1260 	struct btrfs_inode_ref *ref;
1261 
1262 	ref = (struct btrfs_inode_ref *)ref_ptr;
1263 
1264 	*namelen = btrfs_inode_ref_name_len(eb, ref);
1265 	*name = kmalloc(*namelen, GFP_NOFS);
1266 	if (*name == NULL)
1267 		return -ENOMEM;
1268 
1269 	read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);
1270 
1271 	if (index)
1272 		*index = btrfs_inode_ref_index(eb, ref);
1273 
1274 	return 0;
1275 }
1276 
1277 /*
1278  * Take an inode reference item from the log tree and iterate all names from the
1279  * inode reference item in the subvolume tree with the same key (if it exists).
1280  * For any name that is not in the inode reference item from the log tree, do a
1281  * proper unlink of that name (that is, remove its entry from the inode
1282  * reference item and both dir index keys).
1283  */
unlink_old_inode_refs(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,struct btrfs_inode * inode,struct extent_buffer * log_eb,int log_slot,struct btrfs_key * key)1284 static int unlink_old_inode_refs(struct btrfs_trans_handle *trans,
1285 				 struct btrfs_root *root,
1286 				 struct btrfs_path *path,
1287 				 struct btrfs_inode *inode,
1288 				 struct extent_buffer *log_eb,
1289 				 int log_slot,
1290 				 struct btrfs_key *key)
1291 {
1292 	int ret;
1293 	unsigned long ref_ptr;
1294 	unsigned long ref_end;
1295 	struct extent_buffer *eb;
1296 
1297 again:
1298 	btrfs_release_path(path);
1299 	ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
1300 	if (ret > 0) {
1301 		ret = 0;
1302 		goto out;
1303 	}
1304 	if (ret < 0)
1305 		goto out;
1306 
1307 	eb = path->nodes[0];
1308 	ref_ptr = btrfs_item_ptr_offset(eb, path->slots[0]);
1309 	ref_end = ref_ptr + btrfs_item_size(eb, path->slots[0]);
1310 	while (ref_ptr < ref_end) {
1311 		char *name = NULL;
1312 		int namelen;
1313 		u64 parent_id;
1314 
1315 		if (key->type == BTRFS_INODE_EXTREF_KEY) {
1316 			ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
1317 						NULL, &parent_id);
1318 		} else {
1319 			parent_id = key->offset;
1320 			ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
1321 					     NULL);
1322 		}
1323 		if (ret)
1324 			goto out;
1325 
1326 		if (key->type == BTRFS_INODE_EXTREF_KEY)
1327 			ret = !!btrfs_find_name_in_ext_backref(log_eb, log_slot,
1328 							       parent_id, name,
1329 							       namelen);
1330 		else
1331 			ret = !!btrfs_find_name_in_backref(log_eb, log_slot,
1332 							   name, namelen);
1333 
1334 		if (!ret) {
1335 			struct inode *dir;
1336 
1337 			btrfs_release_path(path);
1338 			dir = read_one_inode(root, parent_id);
1339 			if (!dir) {
1340 				ret = -ENOENT;
1341 				kfree(name);
1342 				goto out;
1343 			}
1344 			ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir),
1345 						 inode, name, namelen);
1346 			kfree(name);
1347 			iput(dir);
1348 			if (ret)
1349 				goto out;
1350 			goto again;
1351 		}
1352 
1353 		kfree(name);
1354 		ref_ptr += namelen;
1355 		if (key->type == BTRFS_INODE_EXTREF_KEY)
1356 			ref_ptr += sizeof(struct btrfs_inode_extref);
1357 		else
1358 			ref_ptr += sizeof(struct btrfs_inode_ref);
1359 	}
1360 	ret = 0;
1361  out:
1362 	btrfs_release_path(path);
1363 	return ret;
1364 }
1365 
1366 /*
1367  * replay one inode back reference item found in the log tree.
1368  * eb, slot and key refer to the buffer and key found in the log tree.
1369  * root is the destination we are replaying into, and path is for temp
1370  * use by this function.  (it should be released on return).
1371  */
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)1372 static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
1373 				  struct btrfs_root *root,
1374 				  struct btrfs_root *log,
1375 				  struct btrfs_path *path,
1376 				  struct extent_buffer *eb, int slot,
1377 				  struct btrfs_key *key)
1378 {
1379 	struct inode *dir = NULL;
1380 	struct inode *inode = NULL;
1381 	unsigned long ref_ptr;
1382 	unsigned long ref_end;
1383 	char *name = NULL;
1384 	int namelen;
1385 	int ret;
1386 	int log_ref_ver = 0;
1387 	u64 parent_objectid;
1388 	u64 inode_objectid;
1389 	u64 ref_index = 0;
1390 	int ref_struct_size;
1391 
1392 	ref_ptr = btrfs_item_ptr_offset(eb, slot);
1393 	ref_end = ref_ptr + btrfs_item_size(eb, slot);
1394 
1395 	if (key->type == BTRFS_INODE_EXTREF_KEY) {
1396 		struct btrfs_inode_extref *r;
1397 
1398 		ref_struct_size = sizeof(struct btrfs_inode_extref);
1399 		log_ref_ver = 1;
1400 		r = (struct btrfs_inode_extref *)ref_ptr;
1401 		parent_objectid = btrfs_inode_extref_parent(eb, r);
1402 	} else {
1403 		ref_struct_size = sizeof(struct btrfs_inode_ref);
1404 		parent_objectid = key->offset;
1405 	}
1406 	inode_objectid = key->objectid;
1407 
1408 	/*
1409 	 * it is possible that we didn't log all the parent directories
1410 	 * for a given inode.  If we don't find the dir, just don't
1411 	 * copy the back ref in.  The link count fixup code will take
1412 	 * care of the rest
1413 	 */
1414 	dir = read_one_inode(root, parent_objectid);
1415 	if (!dir) {
1416 		ret = -ENOENT;
1417 		goto out;
1418 	}
1419 
1420 	inode = read_one_inode(root, inode_objectid);
1421 	if (!inode) {
1422 		ret = -EIO;
1423 		goto out;
1424 	}
1425 
1426 	while (ref_ptr < ref_end) {
1427 		if (log_ref_ver) {
1428 			ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
1429 						&ref_index, &parent_objectid);
1430 			/*
1431 			 * parent object can change from one array
1432 			 * item to another.
1433 			 */
1434 			if (!dir)
1435 				dir = read_one_inode(root, parent_objectid);
1436 			if (!dir) {
1437 				ret = -ENOENT;
1438 				goto out;
1439 			}
1440 		} else {
1441 			ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
1442 					     &ref_index);
1443 		}
1444 		if (ret)
1445 			goto out;
1446 
1447 		ret = inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)),
1448 				   btrfs_ino(BTRFS_I(inode)), ref_index,
1449 				   name, namelen);
1450 		if (ret < 0) {
1451 			goto out;
1452 		} else if (ret == 0) {
1453 			/*
1454 			 * look for a conflicting back reference in the
1455 			 * metadata. if we find one we have to unlink that name
1456 			 * of the file before we add our new link.  Later on, we
1457 			 * overwrite any existing back reference, and we don't
1458 			 * want to create dangling pointers in the directory.
1459 			 */
1460 			ret = __add_inode_ref(trans, root, path, log,
1461 					      BTRFS_I(dir), BTRFS_I(inode),
1462 					      inode_objectid, parent_objectid,
1463 					      ref_index, name, namelen);
1464 			if (ret) {
1465 				if (ret == 1)
1466 					ret = 0;
1467 				goto out;
1468 			}
1469 
1470 			/* insert our name */
1471 			ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode),
1472 					     name, namelen, 0, ref_index);
1473 			if (ret)
1474 				goto out;
1475 
1476 			ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
1477 			if (ret)
1478 				goto out;
1479 		}
1480 		/* Else, ret == 1, we already have a perfect match, we're done. */
1481 
1482 		ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
1483 		kfree(name);
1484 		name = NULL;
1485 		if (log_ref_ver) {
1486 			iput(dir);
1487 			dir = NULL;
1488 		}
1489 	}
1490 
1491 	/*
1492 	 * Before we overwrite the inode reference item in the subvolume tree
1493 	 * with the item from the log tree, we must unlink all names from the
1494 	 * parent directory that are in the subvolume's tree inode reference
1495 	 * item, otherwise we end up with an inconsistent subvolume tree where
1496 	 * dir index entries exist for a name but there is no inode reference
1497 	 * item with the same name.
1498 	 */
1499 	ret = unlink_old_inode_refs(trans, root, path, BTRFS_I(inode), eb, slot,
1500 				    key);
1501 	if (ret)
1502 		goto out;
1503 
1504 	/* finally write the back reference in the inode */
1505 	ret = overwrite_item(trans, root, path, eb, slot, key);
1506 out:
1507 	btrfs_release_path(path);
1508 	kfree(name);
1509 	iput(dir);
1510 	iput(inode);
1511 	return ret;
1512 }
1513 
count_inode_extrefs(struct btrfs_root * root,struct btrfs_inode * inode,struct btrfs_path * path)1514 static int count_inode_extrefs(struct btrfs_root *root,
1515 		struct btrfs_inode *inode, struct btrfs_path *path)
1516 {
1517 	int ret = 0;
1518 	int name_len;
1519 	unsigned int nlink = 0;
1520 	u32 item_size;
1521 	u32 cur_offset = 0;
1522 	u64 inode_objectid = btrfs_ino(inode);
1523 	u64 offset = 0;
1524 	unsigned long ptr;
1525 	struct btrfs_inode_extref *extref;
1526 	struct extent_buffer *leaf;
1527 
1528 	while (1) {
1529 		ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
1530 					    &extref, &offset);
1531 		if (ret)
1532 			break;
1533 
1534 		leaf = path->nodes[0];
1535 		item_size = btrfs_item_size(leaf, path->slots[0]);
1536 		ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
1537 		cur_offset = 0;
1538 
1539 		while (cur_offset < item_size) {
1540 			extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
1541 			name_len = btrfs_inode_extref_name_len(leaf, extref);
1542 
1543 			nlink++;
1544 
1545 			cur_offset += name_len + sizeof(*extref);
1546 		}
1547 
1548 		offset++;
1549 		btrfs_release_path(path);
1550 	}
1551 	btrfs_release_path(path);
1552 
1553 	if (ret < 0 && ret != -ENOENT)
1554 		return ret;
1555 	return nlink;
1556 }
1557 
count_inode_refs(struct btrfs_root * root,struct btrfs_inode * inode,struct btrfs_path * path)1558 static int count_inode_refs(struct btrfs_root *root,
1559 			struct btrfs_inode *inode, struct btrfs_path *path)
1560 {
1561 	int ret;
1562 	struct btrfs_key key;
1563 	unsigned int nlink = 0;
1564 	unsigned long ptr;
1565 	unsigned long ptr_end;
1566 	int name_len;
1567 	u64 ino = btrfs_ino(inode);
1568 
1569 	key.objectid = ino;
1570 	key.type = BTRFS_INODE_REF_KEY;
1571 	key.offset = (u64)-1;
1572 
1573 	while (1) {
1574 		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1575 		if (ret < 0)
1576 			break;
1577 		if (ret > 0) {
1578 			if (path->slots[0] == 0)
1579 				break;
1580 			path->slots[0]--;
1581 		}
1582 process_slot:
1583 		btrfs_item_key_to_cpu(path->nodes[0], &key,
1584 				      path->slots[0]);
1585 		if (key.objectid != ino ||
1586 		    key.type != BTRFS_INODE_REF_KEY)
1587 			break;
1588 		ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
1589 		ptr_end = ptr + btrfs_item_size(path->nodes[0],
1590 						   path->slots[0]);
1591 		while (ptr < ptr_end) {
1592 			struct btrfs_inode_ref *ref;
1593 
1594 			ref = (struct btrfs_inode_ref *)ptr;
1595 			name_len = btrfs_inode_ref_name_len(path->nodes[0],
1596 							    ref);
1597 			ptr = (unsigned long)(ref + 1) + name_len;
1598 			nlink++;
1599 		}
1600 
1601 		if (key.offset == 0)
1602 			break;
1603 		if (path->slots[0] > 0) {
1604 			path->slots[0]--;
1605 			goto process_slot;
1606 		}
1607 		key.offset--;
1608 		btrfs_release_path(path);
1609 	}
1610 	btrfs_release_path(path);
1611 
1612 	return nlink;
1613 }
1614 
1615 /*
1616  * There are a few corners where the link count of the file can't
1617  * be properly maintained during replay.  So, instead of adding
1618  * lots of complexity to the log code, we just scan the backrefs
1619  * for any file that has been through replay.
1620  *
1621  * The scan will update the link count on the inode to reflect the
1622  * number of back refs found.  If it goes down to zero, the iput
1623  * will free the inode.
1624  */
fixup_inode_link_count(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct inode * inode)1625 static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
1626 					   struct btrfs_root *root,
1627 					   struct inode *inode)
1628 {
1629 	struct btrfs_path *path;
1630 	int ret;
1631 	u64 nlink = 0;
1632 	u64 ino = btrfs_ino(BTRFS_I(inode));
1633 
1634 	path = btrfs_alloc_path();
1635 	if (!path)
1636 		return -ENOMEM;
1637 
1638 	ret = count_inode_refs(root, BTRFS_I(inode), path);
1639 	if (ret < 0)
1640 		goto out;
1641 
1642 	nlink = ret;
1643 
1644 	ret = count_inode_extrefs(root, BTRFS_I(inode), path);
1645 	if (ret < 0)
1646 		goto out;
1647 
1648 	nlink += ret;
1649 
1650 	ret = 0;
1651 
1652 	if (nlink != inode->i_nlink) {
1653 		set_nlink(inode, nlink);
1654 		ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
1655 		if (ret)
1656 			goto out;
1657 	}
1658 	BTRFS_I(inode)->index_cnt = (u64)-1;
1659 
1660 	if (inode->i_nlink == 0) {
1661 		if (S_ISDIR(inode->i_mode)) {
1662 			ret = replay_dir_deletes(trans, root, NULL, path,
1663 						 ino, 1);
1664 			if (ret)
1665 				goto out;
1666 		}
1667 		ret = btrfs_insert_orphan_item(trans, root, ino);
1668 		if (ret == -EEXIST)
1669 			ret = 0;
1670 	}
1671 
1672 out:
1673 	btrfs_free_path(path);
1674 	return ret;
1675 }
1676 
fixup_inode_link_counts(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path)1677 static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
1678 					    struct btrfs_root *root,
1679 					    struct btrfs_path *path)
1680 {
1681 	int ret;
1682 	struct btrfs_key key;
1683 	struct inode *inode;
1684 
1685 	key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1686 	key.type = BTRFS_ORPHAN_ITEM_KEY;
1687 	key.offset = (u64)-1;
1688 	while (1) {
1689 		ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1690 		if (ret < 0)
1691 			break;
1692 
1693 		if (ret == 1) {
1694 			ret = 0;
1695 			if (path->slots[0] == 0)
1696 				break;
1697 			path->slots[0]--;
1698 		}
1699 
1700 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1701 		if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
1702 		    key.type != BTRFS_ORPHAN_ITEM_KEY)
1703 			break;
1704 
1705 		ret = btrfs_del_item(trans, root, path);
1706 		if (ret)
1707 			break;
1708 
1709 		btrfs_release_path(path);
1710 		inode = read_one_inode(root, key.offset);
1711 		if (!inode) {
1712 			ret = -EIO;
1713 			break;
1714 		}
1715 
1716 		ret = fixup_inode_link_count(trans, root, inode);
1717 		iput(inode);
1718 		if (ret)
1719 			break;
1720 
1721 		/*
1722 		 * fixup on a directory may create new entries,
1723 		 * make sure we always look for the highset possible
1724 		 * offset
1725 		 */
1726 		key.offset = (u64)-1;
1727 	}
1728 	btrfs_release_path(path);
1729 	return ret;
1730 }
1731 
1732 
1733 /*
1734  * record a given inode in the fixup dir so we can check its link
1735  * count when replay is done.  The link count is incremented here
1736  * so the inode won't go away until we check it
1737  */
link_to_fixup_dir(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,u64 objectid)1738 static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
1739 				      struct btrfs_root *root,
1740 				      struct btrfs_path *path,
1741 				      u64 objectid)
1742 {
1743 	struct btrfs_key key;
1744 	int ret = 0;
1745 	struct inode *inode;
1746 
1747 	inode = read_one_inode(root, objectid);
1748 	if (!inode)
1749 		return -EIO;
1750 
1751 	key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1752 	key.type = BTRFS_ORPHAN_ITEM_KEY;
1753 	key.offset = objectid;
1754 
1755 	ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1756 
1757 	btrfs_release_path(path);
1758 	if (ret == 0) {
1759 		if (!inode->i_nlink)
1760 			set_nlink(inode, 1);
1761 		else
1762 			inc_nlink(inode);
1763 		ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
1764 	} else if (ret == -EEXIST) {
1765 		ret = 0;
1766 	}
1767 	iput(inode);
1768 
1769 	return ret;
1770 }
1771 
1772 /*
1773  * when replaying the log for a directory, we only insert names
1774  * for inodes that actually exist.  This means an fsync on a directory
1775  * does not implicitly fsync all the new files in it
1776  */
insert_one_name(struct btrfs_trans_handle * trans,struct btrfs_root * root,u64 dirid,u64 index,char * name,int name_len,struct btrfs_key * location)1777 static noinline int insert_one_name(struct btrfs_trans_handle *trans,
1778 				    struct btrfs_root *root,
1779 				    u64 dirid, u64 index,
1780 				    char *name, int name_len,
1781 				    struct btrfs_key *location)
1782 {
1783 	struct inode *inode;
1784 	struct inode *dir;
1785 	int ret;
1786 
1787 	inode = read_one_inode(root, location->objectid);
1788 	if (!inode)
1789 		return -ENOENT;
1790 
1791 	dir = read_one_inode(root, dirid);
1792 	if (!dir) {
1793 		iput(inode);
1794 		return -EIO;
1795 	}
1796 
1797 	ret = btrfs_add_link(trans, BTRFS_I(dir), BTRFS_I(inode), name,
1798 			name_len, 1, index);
1799 
1800 	/* FIXME, put inode into FIXUP list */
1801 
1802 	iput(inode);
1803 	iput(dir);
1804 	return ret;
1805 }
1806 
delete_conflicting_dir_entry(struct btrfs_trans_handle * trans,struct btrfs_inode * dir,struct btrfs_path * path,struct btrfs_dir_item * dst_di,const struct btrfs_key * log_key,u8 log_type,bool exists)1807 static int delete_conflicting_dir_entry(struct btrfs_trans_handle *trans,
1808 					struct btrfs_inode *dir,
1809 					struct btrfs_path *path,
1810 					struct btrfs_dir_item *dst_di,
1811 					const struct btrfs_key *log_key,
1812 					u8 log_type,
1813 					bool exists)
1814 {
1815 	struct btrfs_key found_key;
1816 
1817 	btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
1818 	/* The existing dentry points to the same inode, don't delete it. */
1819 	if (found_key.objectid == log_key->objectid &&
1820 	    found_key.type == log_key->type &&
1821 	    found_key.offset == log_key->offset &&
1822 	    btrfs_dir_type(path->nodes[0], dst_di) == log_type)
1823 		return 1;
1824 
1825 	/*
1826 	 * Don't drop the conflicting directory entry if the inode for the new
1827 	 * entry doesn't exist.
1828 	 */
1829 	if (!exists)
1830 		return 0;
1831 
1832 	return drop_one_dir_item(trans, path, dir, dst_di);
1833 }
1834 
1835 /*
1836  * take a single entry in a log directory item and replay it into
1837  * the subvolume.
1838  *
1839  * if a conflicting item exists in the subdirectory already,
1840  * the inode it points to is unlinked and put into the link count
1841  * fix up tree.
1842  *
1843  * If a name from the log points to a file or directory that does
1844  * not exist in the FS, it is skipped.  fsyncs on directories
1845  * do not force down inodes inside that directory, just changes to the
1846  * names or unlinks in a directory.
1847  *
1848  * Returns < 0 on error, 0 if the name wasn't replayed (dentry points to a
1849  * non-existing inode) and 1 if the name was replayed.
1850  */
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)1851 static noinline int replay_one_name(struct btrfs_trans_handle *trans,
1852 				    struct btrfs_root *root,
1853 				    struct btrfs_path *path,
1854 				    struct extent_buffer *eb,
1855 				    struct btrfs_dir_item *di,
1856 				    struct btrfs_key *key)
1857 {
1858 	char *name;
1859 	int name_len;
1860 	struct btrfs_dir_item *dir_dst_di;
1861 	struct btrfs_dir_item *index_dst_di;
1862 	bool dir_dst_matches = false;
1863 	bool index_dst_matches = false;
1864 	struct btrfs_key log_key;
1865 	struct btrfs_key search_key;
1866 	struct inode *dir;
1867 	u8 log_type;
1868 	bool exists;
1869 	int ret;
1870 	bool update_size = true;
1871 	bool name_added = false;
1872 
1873 	dir = read_one_inode(root, key->objectid);
1874 	if (!dir)
1875 		return -EIO;
1876 
1877 	name_len = btrfs_dir_name_len(eb, di);
1878 	name = kmalloc(name_len, GFP_NOFS);
1879 	if (!name) {
1880 		ret = -ENOMEM;
1881 		goto out;
1882 	}
1883 
1884 	log_type = btrfs_dir_type(eb, di);
1885 	read_extent_buffer(eb, name, (unsigned long)(di + 1),
1886 		   name_len);
1887 
1888 	btrfs_dir_item_key_to_cpu(eb, di, &log_key);
1889 	ret = btrfs_lookup_inode(trans, root, path, &log_key, 0);
1890 	btrfs_release_path(path);
1891 	if (ret < 0)
1892 		goto out;
1893 	exists = (ret == 0);
1894 	ret = 0;
1895 
1896 	dir_dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
1897 					   name, name_len, 1);
1898 	if (IS_ERR(dir_dst_di)) {
1899 		ret = PTR_ERR(dir_dst_di);
1900 		goto out;
1901 	} else if (dir_dst_di) {
1902 		ret = delete_conflicting_dir_entry(trans, BTRFS_I(dir), path,
1903 						   dir_dst_di, &log_key, log_type,
1904 						   exists);
1905 		if (ret < 0)
1906 			goto out;
1907 		dir_dst_matches = (ret == 1);
1908 	}
1909 
1910 	btrfs_release_path(path);
1911 
1912 	index_dst_di = btrfs_lookup_dir_index_item(trans, root, path,
1913 						   key->objectid, key->offset,
1914 						   name, name_len, 1);
1915 	if (IS_ERR(index_dst_di)) {
1916 		ret = PTR_ERR(index_dst_di);
1917 		goto out;
1918 	} else if (index_dst_di) {
1919 		ret = delete_conflicting_dir_entry(trans, BTRFS_I(dir), path,
1920 						   index_dst_di, &log_key,
1921 						   log_type, exists);
1922 		if (ret < 0)
1923 			goto out;
1924 		index_dst_matches = (ret == 1);
1925 	}
1926 
1927 	btrfs_release_path(path);
1928 
1929 	if (dir_dst_matches && index_dst_matches) {
1930 		ret = 0;
1931 		update_size = false;
1932 		goto out;
1933 	}
1934 
1935 	/*
1936 	 * Check if the inode reference exists in the log for the given name,
1937 	 * inode and parent inode
1938 	 */
1939 	search_key.objectid = log_key.objectid;
1940 	search_key.type = BTRFS_INODE_REF_KEY;
1941 	search_key.offset = key->objectid;
1942 	ret = backref_in_log(root->log_root, &search_key, 0, name, name_len);
1943 	if (ret < 0) {
1944 	        goto out;
1945 	} else if (ret) {
1946 	        /* The dentry will be added later. */
1947 	        ret = 0;
1948 	        update_size = false;
1949 	        goto out;
1950 	}
1951 
1952 	search_key.objectid = log_key.objectid;
1953 	search_key.type = BTRFS_INODE_EXTREF_KEY;
1954 	search_key.offset = key->objectid;
1955 	ret = backref_in_log(root->log_root, &search_key, key->objectid, name,
1956 			     name_len);
1957 	if (ret < 0) {
1958 		goto out;
1959 	} else if (ret) {
1960 		/* The dentry will be added later. */
1961 		ret = 0;
1962 		update_size = false;
1963 		goto out;
1964 	}
1965 	btrfs_release_path(path);
1966 	ret = insert_one_name(trans, root, key->objectid, key->offset,
1967 			      name, name_len, &log_key);
1968 	if (ret && ret != -ENOENT && ret != -EEXIST)
1969 		goto out;
1970 	if (!ret)
1971 		name_added = true;
1972 	update_size = false;
1973 	ret = 0;
1974 
1975 out:
1976 	if (!ret && update_size) {
1977 		btrfs_i_size_write(BTRFS_I(dir), dir->i_size + name_len * 2);
1978 		ret = btrfs_update_inode(trans, root, BTRFS_I(dir));
1979 	}
1980 	kfree(name);
1981 	iput(dir);
1982 	if (!ret && name_added)
1983 		ret = 1;
1984 	return ret;
1985 }
1986 
1987 /* Replay one dir item from a BTRFS_DIR_INDEX_KEY key. */
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)1988 static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
1989 					struct btrfs_root *root,
1990 					struct btrfs_path *path,
1991 					struct extent_buffer *eb, int slot,
1992 					struct btrfs_key *key)
1993 {
1994 	int ret;
1995 	struct btrfs_dir_item *di;
1996 
1997 	/* We only log dir index keys, which only contain a single dir item. */
1998 	ASSERT(key->type == BTRFS_DIR_INDEX_KEY);
1999 
2000 	di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
2001 	ret = replay_one_name(trans, root, path, eb, di, key);
2002 	if (ret < 0)
2003 		return ret;
2004 
2005 	/*
2006 	 * If this entry refers to a non-directory (directories can not have a
2007 	 * link count > 1) and it was added in the transaction that was not
2008 	 * committed, make sure we fixup the link count of the inode the entry
2009 	 * points to. Otherwise something like the following would result in a
2010 	 * directory pointing to an inode with a wrong link that does not account
2011 	 * for this dir entry:
2012 	 *
2013 	 * mkdir testdir
2014 	 * touch testdir/foo
2015 	 * touch testdir/bar
2016 	 * sync
2017 	 *
2018 	 * ln testdir/bar testdir/bar_link
2019 	 * ln testdir/foo testdir/foo_link
2020 	 * xfs_io -c "fsync" testdir/bar
2021 	 *
2022 	 * <power failure>
2023 	 *
2024 	 * mount fs, log replay happens
2025 	 *
2026 	 * File foo would remain with a link count of 1 when it has two entries
2027 	 * pointing to it in the directory testdir. This would make it impossible
2028 	 * to ever delete the parent directory has it would result in stale
2029 	 * dentries that can never be deleted.
2030 	 */
2031 	if (ret == 1 && btrfs_dir_type(eb, di) != BTRFS_FT_DIR) {
2032 		struct btrfs_path *fixup_path;
2033 		struct btrfs_key di_key;
2034 
2035 		fixup_path = btrfs_alloc_path();
2036 		if (!fixup_path)
2037 			return -ENOMEM;
2038 
2039 		btrfs_dir_item_key_to_cpu(eb, di, &di_key);
2040 		ret = link_to_fixup_dir(trans, root, fixup_path, di_key.objectid);
2041 		btrfs_free_path(fixup_path);
2042 	}
2043 
2044 	return ret;
2045 }
2046 
2047 /*
2048  * directory replay has two parts.  There are the standard directory
2049  * items in the log copied from the subvolume, and range items
2050  * created in the log while the subvolume was logged.
2051  *
2052  * The range items tell us which parts of the key space the log
2053  * is authoritative for.  During replay, if a key in the subvolume
2054  * directory is in a logged range item, but not actually in the log
2055  * that means it was deleted from the directory before the fsync
2056  * and should be removed.
2057  */
find_dir_range(struct btrfs_root * root,struct btrfs_path * path,u64 dirid,u64 * start_ret,u64 * end_ret)2058 static noinline int find_dir_range(struct btrfs_root *root,
2059 				   struct btrfs_path *path,
2060 				   u64 dirid,
2061 				   u64 *start_ret, u64 *end_ret)
2062 {
2063 	struct btrfs_key key;
2064 	u64 found_end;
2065 	struct btrfs_dir_log_item *item;
2066 	int ret;
2067 	int nritems;
2068 
2069 	if (*start_ret == (u64)-1)
2070 		return 1;
2071 
2072 	key.objectid = dirid;
2073 	key.type = BTRFS_DIR_LOG_INDEX_KEY;
2074 	key.offset = *start_ret;
2075 
2076 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2077 	if (ret < 0)
2078 		goto out;
2079 	if (ret > 0) {
2080 		if (path->slots[0] == 0)
2081 			goto out;
2082 		path->slots[0]--;
2083 	}
2084 	if (ret != 0)
2085 		btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2086 
2087 	if (key.type != BTRFS_DIR_LOG_INDEX_KEY || key.objectid != dirid) {
2088 		ret = 1;
2089 		goto next;
2090 	}
2091 	item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2092 			      struct btrfs_dir_log_item);
2093 	found_end = btrfs_dir_log_end(path->nodes[0], item);
2094 
2095 	if (*start_ret >= key.offset && *start_ret <= found_end) {
2096 		ret = 0;
2097 		*start_ret = key.offset;
2098 		*end_ret = found_end;
2099 		goto out;
2100 	}
2101 	ret = 1;
2102 next:
2103 	/* check the next slot in the tree to see if it is a valid item */
2104 	nritems = btrfs_header_nritems(path->nodes[0]);
2105 	path->slots[0]++;
2106 	if (path->slots[0] >= nritems) {
2107 		ret = btrfs_next_leaf(root, path);
2108 		if (ret)
2109 			goto out;
2110 	}
2111 
2112 	btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2113 
2114 	if (key.type != BTRFS_DIR_LOG_INDEX_KEY || key.objectid != dirid) {
2115 		ret = 1;
2116 		goto out;
2117 	}
2118 	item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2119 			      struct btrfs_dir_log_item);
2120 	found_end = btrfs_dir_log_end(path->nodes[0], item);
2121 	*start_ret = key.offset;
2122 	*end_ret = found_end;
2123 	ret = 0;
2124 out:
2125 	btrfs_release_path(path);
2126 	return ret;
2127 }
2128 
2129 /*
2130  * this looks for a given directory item in the log.  If the directory
2131  * item is not in the log, the item is removed and the inode it points
2132  * to is unlinked
2133  */
check_item_in_log(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_path * path,struct btrfs_path * log_path,struct inode * dir,struct btrfs_key * dir_key)2134 static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
2135 				      struct btrfs_root *log,
2136 				      struct btrfs_path *path,
2137 				      struct btrfs_path *log_path,
2138 				      struct inode *dir,
2139 				      struct btrfs_key *dir_key)
2140 {
2141 	struct btrfs_root *root = BTRFS_I(dir)->root;
2142 	int ret;
2143 	struct extent_buffer *eb;
2144 	int slot;
2145 	struct btrfs_dir_item *di;
2146 	int name_len;
2147 	char *name;
2148 	struct inode *inode = NULL;
2149 	struct btrfs_key location;
2150 
2151 	/*
2152 	 * Currently we only log dir index keys. Even if we replay a log created
2153 	 * by an older kernel that logged both dir index and dir item keys, all
2154 	 * we need to do is process the dir index keys, we (and our caller) can
2155 	 * safely ignore dir item keys (key type BTRFS_DIR_ITEM_KEY).
2156 	 */
2157 	ASSERT(dir_key->type == BTRFS_DIR_INDEX_KEY);
2158 
2159 	eb = path->nodes[0];
2160 	slot = path->slots[0];
2161 	di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
2162 	name_len = btrfs_dir_name_len(eb, di);
2163 	name = kmalloc(name_len, GFP_NOFS);
2164 	if (!name) {
2165 		ret = -ENOMEM;
2166 		goto out;
2167 	}
2168 
2169 	read_extent_buffer(eb, name, (unsigned long)(di + 1), name_len);
2170 
2171 	if (log) {
2172 		struct btrfs_dir_item *log_di;
2173 
2174 		log_di = btrfs_lookup_dir_index_item(trans, log, log_path,
2175 						     dir_key->objectid,
2176 						     dir_key->offset,
2177 						     name, name_len, 0);
2178 		if (IS_ERR(log_di)) {
2179 			ret = PTR_ERR(log_di);
2180 			goto out;
2181 		} else if (log_di) {
2182 			/* The dentry exists in the log, we have nothing to do. */
2183 			ret = 0;
2184 			goto out;
2185 		}
2186 	}
2187 
2188 	btrfs_dir_item_key_to_cpu(eb, di, &location);
2189 	btrfs_release_path(path);
2190 	btrfs_release_path(log_path);
2191 	inode = read_one_inode(root, location.objectid);
2192 	if (!inode) {
2193 		ret = -EIO;
2194 		goto out;
2195 	}
2196 
2197 	ret = link_to_fixup_dir(trans, root, path, location.objectid);
2198 	if (ret)
2199 		goto out;
2200 
2201 	inc_nlink(inode);
2202 	ret = unlink_inode_for_log_replay(trans, BTRFS_I(dir), BTRFS_I(inode),
2203 					  name, name_len);
2204 	/*
2205 	 * Unlike dir item keys, dir index keys can only have one name (entry) in
2206 	 * them, as there are no key collisions since each key has a unique offset
2207 	 * (an index number), so we're done.
2208 	 */
2209 out:
2210 	btrfs_release_path(path);
2211 	btrfs_release_path(log_path);
2212 	kfree(name);
2213 	iput(inode);
2214 	return ret;
2215 }
2216 
replay_xattr_deletes(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_root * log,struct btrfs_path * path,const u64 ino)2217 static int replay_xattr_deletes(struct btrfs_trans_handle *trans,
2218 			      struct btrfs_root *root,
2219 			      struct btrfs_root *log,
2220 			      struct btrfs_path *path,
2221 			      const u64 ino)
2222 {
2223 	struct btrfs_key search_key;
2224 	struct btrfs_path *log_path;
2225 	int i;
2226 	int nritems;
2227 	int ret;
2228 
2229 	log_path = btrfs_alloc_path();
2230 	if (!log_path)
2231 		return -ENOMEM;
2232 
2233 	search_key.objectid = ino;
2234 	search_key.type = BTRFS_XATTR_ITEM_KEY;
2235 	search_key.offset = 0;
2236 again:
2237 	ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
2238 	if (ret < 0)
2239 		goto out;
2240 process_leaf:
2241 	nritems = btrfs_header_nritems(path->nodes[0]);
2242 	for (i = path->slots[0]; i < nritems; i++) {
2243 		struct btrfs_key key;
2244 		struct btrfs_dir_item *di;
2245 		struct btrfs_dir_item *log_di;
2246 		u32 total_size;
2247 		u32 cur;
2248 
2249 		btrfs_item_key_to_cpu(path->nodes[0], &key, i);
2250 		if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY) {
2251 			ret = 0;
2252 			goto out;
2253 		}
2254 
2255 		di = btrfs_item_ptr(path->nodes[0], i, struct btrfs_dir_item);
2256 		total_size = btrfs_item_size(path->nodes[0], i);
2257 		cur = 0;
2258 		while (cur < total_size) {
2259 			u16 name_len = btrfs_dir_name_len(path->nodes[0], di);
2260 			u16 data_len = btrfs_dir_data_len(path->nodes[0], di);
2261 			u32 this_len = sizeof(*di) + name_len + data_len;
2262 			char *name;
2263 
2264 			name = kmalloc(name_len, GFP_NOFS);
2265 			if (!name) {
2266 				ret = -ENOMEM;
2267 				goto out;
2268 			}
2269 			read_extent_buffer(path->nodes[0], name,
2270 					   (unsigned long)(di + 1), name_len);
2271 
2272 			log_di = btrfs_lookup_xattr(NULL, log, log_path, ino,
2273 						    name, name_len, 0);
2274 			btrfs_release_path(log_path);
2275 			if (!log_di) {
2276 				/* Doesn't exist in log tree, so delete it. */
2277 				btrfs_release_path(path);
2278 				di = btrfs_lookup_xattr(trans, root, path, ino,
2279 							name, name_len, -1);
2280 				kfree(name);
2281 				if (IS_ERR(di)) {
2282 					ret = PTR_ERR(di);
2283 					goto out;
2284 				}
2285 				ASSERT(di);
2286 				ret = btrfs_delete_one_dir_name(trans, root,
2287 								path, di);
2288 				if (ret)
2289 					goto out;
2290 				btrfs_release_path(path);
2291 				search_key = key;
2292 				goto again;
2293 			}
2294 			kfree(name);
2295 			if (IS_ERR(log_di)) {
2296 				ret = PTR_ERR(log_di);
2297 				goto out;
2298 			}
2299 			cur += this_len;
2300 			di = (struct btrfs_dir_item *)((char *)di + this_len);
2301 		}
2302 	}
2303 	ret = btrfs_next_leaf(root, path);
2304 	if (ret > 0)
2305 		ret = 0;
2306 	else if (ret == 0)
2307 		goto process_leaf;
2308 out:
2309 	btrfs_free_path(log_path);
2310 	btrfs_release_path(path);
2311 	return ret;
2312 }
2313 
2314 
2315 /*
2316  * deletion replay happens before we copy any new directory items
2317  * out of the log or out of backreferences from inodes.  It
2318  * scans the log to find ranges of keys that log is authoritative for,
2319  * and then scans the directory to find items in those ranges that are
2320  * not present in the log.
2321  *
2322  * Anything we don't find in the log is unlinked and removed from the
2323  * directory.
2324  */
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)2325 static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
2326 				       struct btrfs_root *root,
2327 				       struct btrfs_root *log,
2328 				       struct btrfs_path *path,
2329 				       u64 dirid, int del_all)
2330 {
2331 	u64 range_start;
2332 	u64 range_end;
2333 	int ret = 0;
2334 	struct btrfs_key dir_key;
2335 	struct btrfs_key found_key;
2336 	struct btrfs_path *log_path;
2337 	struct inode *dir;
2338 
2339 	dir_key.objectid = dirid;
2340 	dir_key.type = BTRFS_DIR_INDEX_KEY;
2341 	log_path = btrfs_alloc_path();
2342 	if (!log_path)
2343 		return -ENOMEM;
2344 
2345 	dir = read_one_inode(root, dirid);
2346 	/* it isn't an error if the inode isn't there, that can happen
2347 	 * because we replay the deletes before we copy in the inode item
2348 	 * from the log
2349 	 */
2350 	if (!dir) {
2351 		btrfs_free_path(log_path);
2352 		return 0;
2353 	}
2354 
2355 	range_start = 0;
2356 	range_end = 0;
2357 	while (1) {
2358 		if (del_all)
2359 			range_end = (u64)-1;
2360 		else {
2361 			ret = find_dir_range(log, path, dirid,
2362 					     &range_start, &range_end);
2363 			if (ret < 0)
2364 				goto out;
2365 			else if (ret > 0)
2366 				break;
2367 		}
2368 
2369 		dir_key.offset = range_start;
2370 		while (1) {
2371 			int nritems;
2372 			ret = btrfs_search_slot(NULL, root, &dir_key, path,
2373 						0, 0);
2374 			if (ret < 0)
2375 				goto out;
2376 
2377 			nritems = btrfs_header_nritems(path->nodes[0]);
2378 			if (path->slots[0] >= nritems) {
2379 				ret = btrfs_next_leaf(root, path);
2380 				if (ret == 1)
2381 					break;
2382 				else if (ret < 0)
2383 					goto out;
2384 			}
2385 			btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2386 					      path->slots[0]);
2387 			if (found_key.objectid != dirid ||
2388 			    found_key.type != dir_key.type) {
2389 				ret = 0;
2390 				goto out;
2391 			}
2392 
2393 			if (found_key.offset > range_end)
2394 				break;
2395 
2396 			ret = check_item_in_log(trans, log, path,
2397 						log_path, dir,
2398 						&found_key);
2399 			if (ret)
2400 				goto out;
2401 			if (found_key.offset == (u64)-1)
2402 				break;
2403 			dir_key.offset = found_key.offset + 1;
2404 		}
2405 		btrfs_release_path(path);
2406 		if (range_end == (u64)-1)
2407 			break;
2408 		range_start = range_end + 1;
2409 	}
2410 	ret = 0;
2411 out:
2412 	btrfs_release_path(path);
2413 	btrfs_free_path(log_path);
2414 	iput(dir);
2415 	return ret;
2416 }
2417 
2418 /*
2419  * the process_func used to replay items from the log tree.  This
2420  * gets called in two different stages.  The first stage just looks
2421  * for inodes and makes sure they are all copied into the subvolume.
2422  *
2423  * The second stage copies all the other item types from the log into
2424  * the subvolume.  The two stage approach is slower, but gets rid of
2425  * lots of complexity around inodes referencing other inodes that exist
2426  * only in the log (references come from either directory items or inode
2427  * back refs).
2428  */
replay_one_buffer(struct btrfs_root * log,struct extent_buffer * eb,struct walk_control * wc,u64 gen,int level)2429 static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
2430 			     struct walk_control *wc, u64 gen, int level)
2431 {
2432 	int nritems;
2433 	struct btrfs_path *path;
2434 	struct btrfs_root *root = wc->replay_dest;
2435 	struct btrfs_key key;
2436 	int i;
2437 	int ret;
2438 
2439 	ret = btrfs_read_extent_buffer(eb, gen, level, NULL);
2440 	if (ret)
2441 		return ret;
2442 
2443 	level = btrfs_header_level(eb);
2444 
2445 	if (level != 0)
2446 		return 0;
2447 
2448 	path = btrfs_alloc_path();
2449 	if (!path)
2450 		return -ENOMEM;
2451 
2452 	nritems = btrfs_header_nritems(eb);
2453 	for (i = 0; i < nritems; i++) {
2454 		btrfs_item_key_to_cpu(eb, &key, i);
2455 
2456 		/* inode keys are done during the first stage */
2457 		if (key.type == BTRFS_INODE_ITEM_KEY &&
2458 		    wc->stage == LOG_WALK_REPLAY_INODES) {
2459 			struct btrfs_inode_item *inode_item;
2460 			u32 mode;
2461 
2462 			inode_item = btrfs_item_ptr(eb, i,
2463 					    struct btrfs_inode_item);
2464 			/*
2465 			 * If we have a tmpfile (O_TMPFILE) that got fsync'ed
2466 			 * and never got linked before the fsync, skip it, as
2467 			 * replaying it is pointless since it would be deleted
2468 			 * later. We skip logging tmpfiles, but it's always
2469 			 * possible we are replaying a log created with a kernel
2470 			 * that used to log tmpfiles.
2471 			 */
2472 			if (btrfs_inode_nlink(eb, inode_item) == 0) {
2473 				wc->ignore_cur_inode = true;
2474 				continue;
2475 			} else {
2476 				wc->ignore_cur_inode = false;
2477 			}
2478 			ret = replay_xattr_deletes(wc->trans, root, log,
2479 						   path, key.objectid);
2480 			if (ret)
2481 				break;
2482 			mode = btrfs_inode_mode(eb, inode_item);
2483 			if (S_ISDIR(mode)) {
2484 				ret = replay_dir_deletes(wc->trans,
2485 					 root, log, path, key.objectid, 0);
2486 				if (ret)
2487 					break;
2488 			}
2489 			ret = overwrite_item(wc->trans, root, path,
2490 					     eb, i, &key);
2491 			if (ret)
2492 				break;
2493 
2494 			/*
2495 			 * Before replaying extents, truncate the inode to its
2496 			 * size. We need to do it now and not after log replay
2497 			 * because before an fsync we can have prealloc extents
2498 			 * added beyond the inode's i_size. If we did it after,
2499 			 * through orphan cleanup for example, we would drop
2500 			 * those prealloc extents just after replaying them.
2501 			 */
2502 			if (S_ISREG(mode)) {
2503 				struct btrfs_drop_extents_args drop_args = { 0 };
2504 				struct inode *inode;
2505 				u64 from;
2506 
2507 				inode = read_one_inode(root, key.objectid);
2508 				if (!inode) {
2509 					ret = -EIO;
2510 					break;
2511 				}
2512 				from = ALIGN(i_size_read(inode),
2513 					     root->fs_info->sectorsize);
2514 				drop_args.start = from;
2515 				drop_args.end = (u64)-1;
2516 				drop_args.drop_cache = true;
2517 				ret = btrfs_drop_extents(wc->trans, root,
2518 							 BTRFS_I(inode),
2519 							 &drop_args);
2520 				if (!ret) {
2521 					inode_sub_bytes(inode,
2522 							drop_args.bytes_found);
2523 					/* Update the inode's nbytes. */
2524 					ret = btrfs_update_inode(wc->trans,
2525 							root, BTRFS_I(inode));
2526 				}
2527 				iput(inode);
2528 				if (ret)
2529 					break;
2530 			}
2531 
2532 			ret = link_to_fixup_dir(wc->trans, root,
2533 						path, key.objectid);
2534 			if (ret)
2535 				break;
2536 		}
2537 
2538 		if (wc->ignore_cur_inode)
2539 			continue;
2540 
2541 		if (key.type == BTRFS_DIR_INDEX_KEY &&
2542 		    wc->stage == LOG_WALK_REPLAY_DIR_INDEX) {
2543 			ret = replay_one_dir_item(wc->trans, root, path,
2544 						  eb, i, &key);
2545 			if (ret)
2546 				break;
2547 		}
2548 
2549 		if (wc->stage < LOG_WALK_REPLAY_ALL)
2550 			continue;
2551 
2552 		/* these keys are simply copied */
2553 		if (key.type == BTRFS_XATTR_ITEM_KEY) {
2554 			ret = overwrite_item(wc->trans, root, path,
2555 					     eb, i, &key);
2556 			if (ret)
2557 				break;
2558 		} else if (key.type == BTRFS_INODE_REF_KEY ||
2559 			   key.type == BTRFS_INODE_EXTREF_KEY) {
2560 			ret = add_inode_ref(wc->trans, root, log, path,
2561 					    eb, i, &key);
2562 			if (ret && ret != -ENOENT)
2563 				break;
2564 			ret = 0;
2565 		} else if (key.type == BTRFS_EXTENT_DATA_KEY) {
2566 			ret = replay_one_extent(wc->trans, root, path,
2567 						eb, i, &key);
2568 			if (ret)
2569 				break;
2570 		}
2571 		/*
2572 		 * We don't log BTRFS_DIR_ITEM_KEY keys anymore, only the
2573 		 * BTRFS_DIR_INDEX_KEY items which we use to derive the
2574 		 * BTRFS_DIR_ITEM_KEY items. If we are replaying a log from an
2575 		 * older kernel with such keys, ignore them.
2576 		 */
2577 	}
2578 	btrfs_free_path(path);
2579 	return ret;
2580 }
2581 
2582 /*
2583  * Correctly adjust the reserved bytes occupied by a log tree extent buffer
2584  */
unaccount_log_buffer(struct btrfs_fs_info * fs_info,u64 start)2585 static void unaccount_log_buffer(struct btrfs_fs_info *fs_info, u64 start)
2586 {
2587 	struct btrfs_block_group *cache;
2588 
2589 	cache = btrfs_lookup_block_group(fs_info, start);
2590 	if (!cache) {
2591 		btrfs_err(fs_info, "unable to find block group for %llu", start);
2592 		return;
2593 	}
2594 
2595 	spin_lock(&cache->space_info->lock);
2596 	spin_lock(&cache->lock);
2597 	cache->reserved -= fs_info->nodesize;
2598 	cache->space_info->bytes_reserved -= fs_info->nodesize;
2599 	spin_unlock(&cache->lock);
2600 	spin_unlock(&cache->space_info->lock);
2601 
2602 	btrfs_put_block_group(cache);
2603 }
2604 
walk_down_log_tree(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,int * level,struct walk_control * wc)2605 static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
2606 				   struct btrfs_root *root,
2607 				   struct btrfs_path *path, int *level,
2608 				   struct walk_control *wc)
2609 {
2610 	struct btrfs_fs_info *fs_info = root->fs_info;
2611 	u64 bytenr;
2612 	u64 ptr_gen;
2613 	struct extent_buffer *next;
2614 	struct extent_buffer *cur;
2615 	u32 blocksize;
2616 	int ret = 0;
2617 
2618 	while (*level > 0) {
2619 		struct btrfs_key first_key;
2620 
2621 		cur = path->nodes[*level];
2622 
2623 		WARN_ON(btrfs_header_level(cur) != *level);
2624 
2625 		if (path->slots[*level] >=
2626 		    btrfs_header_nritems(cur))
2627 			break;
2628 
2629 		bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2630 		ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2631 		btrfs_node_key_to_cpu(cur, &first_key, path->slots[*level]);
2632 		blocksize = fs_info->nodesize;
2633 
2634 		next = btrfs_find_create_tree_block(fs_info, bytenr,
2635 						    btrfs_header_owner(cur),
2636 						    *level - 1);
2637 		if (IS_ERR(next))
2638 			return PTR_ERR(next);
2639 
2640 		if (*level == 1) {
2641 			ret = wc->process_func(root, next, wc, ptr_gen,
2642 					       *level - 1);
2643 			if (ret) {
2644 				free_extent_buffer(next);
2645 				return ret;
2646 			}
2647 
2648 			path->slots[*level]++;
2649 			if (wc->free) {
2650 				ret = btrfs_read_extent_buffer(next, ptr_gen,
2651 							*level - 1, &first_key);
2652 				if (ret) {
2653 					free_extent_buffer(next);
2654 					return ret;
2655 				}
2656 
2657 				if (trans) {
2658 					btrfs_tree_lock(next);
2659 					btrfs_clean_tree_block(next);
2660 					btrfs_wait_tree_block_writeback(next);
2661 					btrfs_tree_unlock(next);
2662 					ret = btrfs_pin_reserved_extent(trans,
2663 							bytenr, blocksize);
2664 					if (ret) {
2665 						free_extent_buffer(next);
2666 						return ret;
2667 					}
2668 					btrfs_redirty_list_add(
2669 						trans->transaction, next);
2670 				} else {
2671 					if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
2672 						clear_extent_buffer_dirty(next);
2673 					unaccount_log_buffer(fs_info, bytenr);
2674 				}
2675 			}
2676 			free_extent_buffer(next);
2677 			continue;
2678 		}
2679 		ret = btrfs_read_extent_buffer(next, ptr_gen, *level - 1, &first_key);
2680 		if (ret) {
2681 			free_extent_buffer(next);
2682 			return ret;
2683 		}
2684 
2685 		if (path->nodes[*level-1])
2686 			free_extent_buffer(path->nodes[*level-1]);
2687 		path->nodes[*level-1] = next;
2688 		*level = btrfs_header_level(next);
2689 		path->slots[*level] = 0;
2690 		cond_resched();
2691 	}
2692 	path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2693 
2694 	cond_resched();
2695 	return 0;
2696 }
2697 
walk_up_log_tree(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,int * level,struct walk_control * wc)2698 static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
2699 				 struct btrfs_root *root,
2700 				 struct btrfs_path *path, int *level,
2701 				 struct walk_control *wc)
2702 {
2703 	struct btrfs_fs_info *fs_info = root->fs_info;
2704 	int i;
2705 	int slot;
2706 	int ret;
2707 
2708 	for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2709 		slot = path->slots[i];
2710 		if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
2711 			path->slots[i]++;
2712 			*level = i;
2713 			WARN_ON(*level == 0);
2714 			return 0;
2715 		} else {
2716 			ret = wc->process_func(root, path->nodes[*level], wc,
2717 				 btrfs_header_generation(path->nodes[*level]),
2718 				 *level);
2719 			if (ret)
2720 				return ret;
2721 
2722 			if (wc->free) {
2723 				struct extent_buffer *next;
2724 
2725 				next = path->nodes[*level];
2726 
2727 				if (trans) {
2728 					btrfs_tree_lock(next);
2729 					btrfs_clean_tree_block(next);
2730 					btrfs_wait_tree_block_writeback(next);
2731 					btrfs_tree_unlock(next);
2732 					ret = btrfs_pin_reserved_extent(trans,
2733 						     path->nodes[*level]->start,
2734 						     path->nodes[*level]->len);
2735 					if (ret)
2736 						return ret;
2737 					btrfs_redirty_list_add(trans->transaction,
2738 							       next);
2739 				} else {
2740 					if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
2741 						clear_extent_buffer_dirty(next);
2742 
2743 					unaccount_log_buffer(fs_info,
2744 						path->nodes[*level]->start);
2745 				}
2746 			}
2747 			free_extent_buffer(path->nodes[*level]);
2748 			path->nodes[*level] = NULL;
2749 			*level = i + 1;
2750 		}
2751 	}
2752 	return 1;
2753 }
2754 
2755 /*
2756  * drop the reference count on the tree rooted at 'snap'.  This traverses
2757  * the tree freeing any blocks that have a ref count of zero after being
2758  * decremented.
2759  */
walk_log_tree(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct walk_control * wc)2760 static int walk_log_tree(struct btrfs_trans_handle *trans,
2761 			 struct btrfs_root *log, struct walk_control *wc)
2762 {
2763 	struct btrfs_fs_info *fs_info = log->fs_info;
2764 	int ret = 0;
2765 	int wret;
2766 	int level;
2767 	struct btrfs_path *path;
2768 	int orig_level;
2769 
2770 	path = btrfs_alloc_path();
2771 	if (!path)
2772 		return -ENOMEM;
2773 
2774 	level = btrfs_header_level(log->node);
2775 	orig_level = level;
2776 	path->nodes[level] = log->node;
2777 	atomic_inc(&log->node->refs);
2778 	path->slots[level] = 0;
2779 
2780 	while (1) {
2781 		wret = walk_down_log_tree(trans, log, path, &level, wc);
2782 		if (wret > 0)
2783 			break;
2784 		if (wret < 0) {
2785 			ret = wret;
2786 			goto out;
2787 		}
2788 
2789 		wret = walk_up_log_tree(trans, log, path, &level, wc);
2790 		if (wret > 0)
2791 			break;
2792 		if (wret < 0) {
2793 			ret = wret;
2794 			goto out;
2795 		}
2796 	}
2797 
2798 	/* was the root node processed? if not, catch it here */
2799 	if (path->nodes[orig_level]) {
2800 		ret = wc->process_func(log, path->nodes[orig_level], wc,
2801 			 btrfs_header_generation(path->nodes[orig_level]),
2802 			 orig_level);
2803 		if (ret)
2804 			goto out;
2805 		if (wc->free) {
2806 			struct extent_buffer *next;
2807 
2808 			next = path->nodes[orig_level];
2809 
2810 			if (trans) {
2811 				btrfs_tree_lock(next);
2812 				btrfs_clean_tree_block(next);
2813 				btrfs_wait_tree_block_writeback(next);
2814 				btrfs_tree_unlock(next);
2815 				ret = btrfs_pin_reserved_extent(trans,
2816 						next->start, next->len);
2817 				if (ret)
2818 					goto out;
2819 				btrfs_redirty_list_add(trans->transaction, next);
2820 			} else {
2821 				if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
2822 					clear_extent_buffer_dirty(next);
2823 				unaccount_log_buffer(fs_info, next->start);
2824 			}
2825 		}
2826 	}
2827 
2828 out:
2829 	btrfs_free_path(path);
2830 	return ret;
2831 }
2832 
2833 /*
2834  * helper function to update the item for a given subvolumes log root
2835  * in the tree of log roots
2836  */
update_log_root(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_root_item * root_item)2837 static int update_log_root(struct btrfs_trans_handle *trans,
2838 			   struct btrfs_root *log,
2839 			   struct btrfs_root_item *root_item)
2840 {
2841 	struct btrfs_fs_info *fs_info = log->fs_info;
2842 	int ret;
2843 
2844 	if (log->log_transid == 1) {
2845 		/* insert root item on the first sync */
2846 		ret = btrfs_insert_root(trans, fs_info->log_root_tree,
2847 				&log->root_key, root_item);
2848 	} else {
2849 		ret = btrfs_update_root(trans, fs_info->log_root_tree,
2850 				&log->root_key, root_item);
2851 	}
2852 	return ret;
2853 }
2854 
wait_log_commit(struct btrfs_root * root,int transid)2855 static void wait_log_commit(struct btrfs_root *root, int transid)
2856 {
2857 	DEFINE_WAIT(wait);
2858 	int index = transid % 2;
2859 
2860 	/*
2861 	 * we only allow two pending log transactions at a time,
2862 	 * so we know that if ours is more than 2 older than the
2863 	 * current transaction, we're done
2864 	 */
2865 	for (;;) {
2866 		prepare_to_wait(&root->log_commit_wait[index],
2867 				&wait, TASK_UNINTERRUPTIBLE);
2868 
2869 		if (!(root->log_transid_committed < transid &&
2870 		      atomic_read(&root->log_commit[index])))
2871 			break;
2872 
2873 		mutex_unlock(&root->log_mutex);
2874 		schedule();
2875 		mutex_lock(&root->log_mutex);
2876 	}
2877 	finish_wait(&root->log_commit_wait[index], &wait);
2878 }
2879 
wait_for_writer(struct btrfs_root * root)2880 static void wait_for_writer(struct btrfs_root *root)
2881 {
2882 	DEFINE_WAIT(wait);
2883 
2884 	for (;;) {
2885 		prepare_to_wait(&root->log_writer_wait, &wait,
2886 				TASK_UNINTERRUPTIBLE);
2887 		if (!atomic_read(&root->log_writers))
2888 			break;
2889 
2890 		mutex_unlock(&root->log_mutex);
2891 		schedule();
2892 		mutex_lock(&root->log_mutex);
2893 	}
2894 	finish_wait(&root->log_writer_wait, &wait);
2895 }
2896 
btrfs_remove_log_ctx(struct btrfs_root * root,struct btrfs_log_ctx * ctx)2897 static inline void btrfs_remove_log_ctx(struct btrfs_root *root,
2898 					struct btrfs_log_ctx *ctx)
2899 {
2900 	mutex_lock(&root->log_mutex);
2901 	list_del_init(&ctx->list);
2902 	mutex_unlock(&root->log_mutex);
2903 }
2904 
2905 /*
2906  * Invoked in log mutex context, or be sure there is no other task which
2907  * can access the list.
2908  */
btrfs_remove_all_log_ctxs(struct btrfs_root * root,int index,int error)2909 static inline void btrfs_remove_all_log_ctxs(struct btrfs_root *root,
2910 					     int index, int error)
2911 {
2912 	struct btrfs_log_ctx *ctx;
2913 	struct btrfs_log_ctx *safe;
2914 
2915 	list_for_each_entry_safe(ctx, safe, &root->log_ctxs[index], list) {
2916 		list_del_init(&ctx->list);
2917 		ctx->log_ret = error;
2918 	}
2919 }
2920 
2921 /*
2922  * btrfs_sync_log does sends a given tree log down to the disk and
2923  * updates the super blocks to record it.  When this call is done,
2924  * you know that any inodes previously logged are safely on disk only
2925  * if it returns 0.
2926  *
2927  * Any other return value means you need to call btrfs_commit_transaction.
2928  * Some of the edge cases for fsyncing directories that have had unlinks
2929  * or renames done in the past mean that sometimes the only safe
2930  * fsync is to commit the whole FS.  When btrfs_sync_log returns -EAGAIN,
2931  * that has happened.
2932  */
btrfs_sync_log(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_log_ctx * ctx)2933 int btrfs_sync_log(struct btrfs_trans_handle *trans,
2934 		   struct btrfs_root *root, struct btrfs_log_ctx *ctx)
2935 {
2936 	int index1;
2937 	int index2;
2938 	int mark;
2939 	int ret;
2940 	struct btrfs_fs_info *fs_info = root->fs_info;
2941 	struct btrfs_root *log = root->log_root;
2942 	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
2943 	struct btrfs_root_item new_root_item;
2944 	int log_transid = 0;
2945 	struct btrfs_log_ctx root_log_ctx;
2946 	struct blk_plug plug;
2947 	u64 log_root_start;
2948 	u64 log_root_level;
2949 
2950 	mutex_lock(&root->log_mutex);
2951 	log_transid = ctx->log_transid;
2952 	if (root->log_transid_committed >= log_transid) {
2953 		mutex_unlock(&root->log_mutex);
2954 		return ctx->log_ret;
2955 	}
2956 
2957 	index1 = log_transid % 2;
2958 	if (atomic_read(&root->log_commit[index1])) {
2959 		wait_log_commit(root, log_transid);
2960 		mutex_unlock(&root->log_mutex);
2961 		return ctx->log_ret;
2962 	}
2963 	ASSERT(log_transid == root->log_transid);
2964 	atomic_set(&root->log_commit[index1], 1);
2965 
2966 	/* wait for previous tree log sync to complete */
2967 	if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
2968 		wait_log_commit(root, log_transid - 1);
2969 
2970 	while (1) {
2971 		int batch = atomic_read(&root->log_batch);
2972 		/* when we're on an ssd, just kick the log commit out */
2973 		if (!btrfs_test_opt(fs_info, SSD) &&
2974 		    test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) {
2975 			mutex_unlock(&root->log_mutex);
2976 			schedule_timeout_uninterruptible(1);
2977 			mutex_lock(&root->log_mutex);
2978 		}
2979 		wait_for_writer(root);
2980 		if (batch == atomic_read(&root->log_batch))
2981 			break;
2982 	}
2983 
2984 	/* bail out if we need to do a full commit */
2985 	if (btrfs_need_log_full_commit(trans)) {
2986 		ret = BTRFS_LOG_FORCE_COMMIT;
2987 		mutex_unlock(&root->log_mutex);
2988 		goto out;
2989 	}
2990 
2991 	if (log_transid % 2 == 0)
2992 		mark = EXTENT_DIRTY;
2993 	else
2994 		mark = EXTENT_NEW;
2995 
2996 	/* we start IO on  all the marked extents here, but we don't actually
2997 	 * wait for them until later.
2998 	 */
2999 	blk_start_plug(&plug);
3000 	ret = btrfs_write_marked_extents(fs_info, &log->dirty_log_pages, mark);
3001 	/*
3002 	 * -EAGAIN happens when someone, e.g., a concurrent transaction
3003 	 *  commit, writes a dirty extent in this tree-log commit. This
3004 	 *  concurrent write will create a hole writing out the extents,
3005 	 *  and we cannot proceed on a zoned filesystem, requiring
3006 	 *  sequential writing. While we can bail out to a full commit
3007 	 *  here, but we can continue hoping the concurrent writing fills
3008 	 *  the hole.
3009 	 */
3010 	if (ret == -EAGAIN && btrfs_is_zoned(fs_info))
3011 		ret = 0;
3012 	if (ret) {
3013 		blk_finish_plug(&plug);
3014 		btrfs_set_log_full_commit(trans);
3015 		mutex_unlock(&root->log_mutex);
3016 		goto out;
3017 	}
3018 
3019 	/*
3020 	 * We _must_ update under the root->log_mutex in order to make sure we
3021 	 * have a consistent view of the log root we are trying to commit at
3022 	 * this moment.
3023 	 *
3024 	 * We _must_ copy this into a local copy, because we are not holding the
3025 	 * log_root_tree->log_mutex yet.  This is important because when we
3026 	 * commit the log_root_tree we must have a consistent view of the
3027 	 * log_root_tree when we update the super block to point at the
3028 	 * log_root_tree bytenr.  If we update the log_root_tree here we'll race
3029 	 * with the commit and possibly point at the new block which we may not
3030 	 * have written out.
3031 	 */
3032 	btrfs_set_root_node(&log->root_item, log->node);
3033 	memcpy(&new_root_item, &log->root_item, sizeof(new_root_item));
3034 
3035 	root->log_transid++;
3036 	log->log_transid = root->log_transid;
3037 	root->log_start_pid = 0;
3038 	/*
3039 	 * IO has been started, blocks of the log tree have WRITTEN flag set
3040 	 * in their headers. new modifications of the log will be written to
3041 	 * new positions. so it's safe to allow log writers to go in.
3042 	 */
3043 	mutex_unlock(&root->log_mutex);
3044 
3045 	if (btrfs_is_zoned(fs_info)) {
3046 		mutex_lock(&fs_info->tree_root->log_mutex);
3047 		if (!log_root_tree->node) {
3048 			ret = btrfs_alloc_log_tree_node(trans, log_root_tree);
3049 			if (ret) {
3050 				mutex_unlock(&fs_info->tree_root->log_mutex);
3051 				blk_finish_plug(&plug);
3052 				goto out;
3053 			}
3054 		}
3055 		mutex_unlock(&fs_info->tree_root->log_mutex);
3056 	}
3057 
3058 	btrfs_init_log_ctx(&root_log_ctx, NULL);
3059 
3060 	mutex_lock(&log_root_tree->log_mutex);
3061 
3062 	index2 = log_root_tree->log_transid % 2;
3063 	list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
3064 	root_log_ctx.log_transid = log_root_tree->log_transid;
3065 
3066 	/*
3067 	 * Now we are safe to update the log_root_tree because we're under the
3068 	 * log_mutex, and we're a current writer so we're holding the commit
3069 	 * open until we drop the log_mutex.
3070 	 */
3071 	ret = update_log_root(trans, log, &new_root_item);
3072 	if (ret) {
3073 		if (!list_empty(&root_log_ctx.list))
3074 			list_del_init(&root_log_ctx.list);
3075 
3076 		blk_finish_plug(&plug);
3077 		btrfs_set_log_full_commit(trans);
3078 		if (ret != -ENOSPC)
3079 			btrfs_err(fs_info,
3080 				  "failed to update log for root %llu ret %d",
3081 				  root->root_key.objectid, ret);
3082 		btrfs_wait_tree_log_extents(log, mark);
3083 		mutex_unlock(&log_root_tree->log_mutex);
3084 		goto out;
3085 	}
3086 
3087 	if (log_root_tree->log_transid_committed >= root_log_ctx.log_transid) {
3088 		blk_finish_plug(&plug);
3089 		list_del_init(&root_log_ctx.list);
3090 		mutex_unlock(&log_root_tree->log_mutex);
3091 		ret = root_log_ctx.log_ret;
3092 		goto out;
3093 	}
3094 
3095 	index2 = root_log_ctx.log_transid % 2;
3096 	if (atomic_read(&log_root_tree->log_commit[index2])) {
3097 		blk_finish_plug(&plug);
3098 		ret = btrfs_wait_tree_log_extents(log, mark);
3099 		wait_log_commit(log_root_tree,
3100 				root_log_ctx.log_transid);
3101 		mutex_unlock(&log_root_tree->log_mutex);
3102 		if (!ret)
3103 			ret = root_log_ctx.log_ret;
3104 		goto out;
3105 	}
3106 	ASSERT(root_log_ctx.log_transid == log_root_tree->log_transid);
3107 	atomic_set(&log_root_tree->log_commit[index2], 1);
3108 
3109 	if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
3110 		wait_log_commit(log_root_tree,
3111 				root_log_ctx.log_transid - 1);
3112 	}
3113 
3114 	/*
3115 	 * now that we've moved on to the tree of log tree roots,
3116 	 * check the full commit flag again
3117 	 */
3118 	if (btrfs_need_log_full_commit(trans)) {
3119 		blk_finish_plug(&plug);
3120 		btrfs_wait_tree_log_extents(log, mark);
3121 		mutex_unlock(&log_root_tree->log_mutex);
3122 		ret = BTRFS_LOG_FORCE_COMMIT;
3123 		goto out_wake_log_root;
3124 	}
3125 
3126 	ret = btrfs_write_marked_extents(fs_info,
3127 					 &log_root_tree->dirty_log_pages,
3128 					 EXTENT_DIRTY | EXTENT_NEW);
3129 	blk_finish_plug(&plug);
3130 	/*
3131 	 * As described above, -EAGAIN indicates a hole in the extents. We
3132 	 * cannot wait for these write outs since the waiting cause a
3133 	 * deadlock. Bail out to the full commit instead.
3134 	 */
3135 	if (ret == -EAGAIN && btrfs_is_zoned(fs_info)) {
3136 		btrfs_set_log_full_commit(trans);
3137 		btrfs_wait_tree_log_extents(log, mark);
3138 		mutex_unlock(&log_root_tree->log_mutex);
3139 		goto out_wake_log_root;
3140 	} else if (ret) {
3141 		btrfs_set_log_full_commit(trans);
3142 		mutex_unlock(&log_root_tree->log_mutex);
3143 		goto out_wake_log_root;
3144 	}
3145 	ret = btrfs_wait_tree_log_extents(log, mark);
3146 	if (!ret)
3147 		ret = btrfs_wait_tree_log_extents(log_root_tree,
3148 						  EXTENT_NEW | EXTENT_DIRTY);
3149 	if (ret) {
3150 		btrfs_set_log_full_commit(trans);
3151 		mutex_unlock(&log_root_tree->log_mutex);
3152 		goto out_wake_log_root;
3153 	}
3154 
3155 	log_root_start = log_root_tree->node->start;
3156 	log_root_level = btrfs_header_level(log_root_tree->node);
3157 	log_root_tree->log_transid++;
3158 	mutex_unlock(&log_root_tree->log_mutex);
3159 
3160 	/*
3161 	 * Here we are guaranteed that nobody is going to write the superblock
3162 	 * for the current transaction before us and that neither we do write
3163 	 * our superblock before the previous transaction finishes its commit
3164 	 * and writes its superblock, because:
3165 	 *
3166 	 * 1) We are holding a handle on the current transaction, so no body
3167 	 *    can commit it until we release the handle;
3168 	 *
3169 	 * 2) Before writing our superblock we acquire the tree_log_mutex, so
3170 	 *    if the previous transaction is still committing, and hasn't yet
3171 	 *    written its superblock, we wait for it to do it, because a
3172 	 *    transaction commit acquires the tree_log_mutex when the commit
3173 	 *    begins and releases it only after writing its superblock.
3174 	 */
3175 	mutex_lock(&fs_info->tree_log_mutex);
3176 
3177 	/*
3178 	 * The previous transaction writeout phase could have failed, and thus
3179 	 * marked the fs in an error state.  We must not commit here, as we
3180 	 * could have updated our generation in the super_for_commit and
3181 	 * writing the super here would result in transid mismatches.  If there
3182 	 * is an error here just bail.
3183 	 */
3184 	if (BTRFS_FS_ERROR(fs_info)) {
3185 		ret = -EIO;
3186 		btrfs_set_log_full_commit(trans);
3187 		btrfs_abort_transaction(trans, ret);
3188 		mutex_unlock(&fs_info->tree_log_mutex);
3189 		goto out_wake_log_root;
3190 	}
3191 
3192 	btrfs_set_super_log_root(fs_info->super_for_commit, log_root_start);
3193 	btrfs_set_super_log_root_level(fs_info->super_for_commit, log_root_level);
3194 	ret = write_all_supers(fs_info, 1);
3195 	mutex_unlock(&fs_info->tree_log_mutex);
3196 	if (ret) {
3197 		btrfs_set_log_full_commit(trans);
3198 		btrfs_abort_transaction(trans, ret);
3199 		goto out_wake_log_root;
3200 	}
3201 
3202 	/*
3203 	 * We know there can only be one task here, since we have not yet set
3204 	 * root->log_commit[index1] to 0 and any task attempting to sync the
3205 	 * log must wait for the previous log transaction to commit if it's
3206 	 * still in progress or wait for the current log transaction commit if
3207 	 * someone else already started it. We use <= and not < because the
3208 	 * first log transaction has an ID of 0.
3209 	 */
3210 	ASSERT(root->last_log_commit <= log_transid);
3211 	root->last_log_commit = log_transid;
3212 
3213 out_wake_log_root:
3214 	mutex_lock(&log_root_tree->log_mutex);
3215 	btrfs_remove_all_log_ctxs(log_root_tree, index2, ret);
3216 
3217 	log_root_tree->log_transid_committed++;
3218 	atomic_set(&log_root_tree->log_commit[index2], 0);
3219 	mutex_unlock(&log_root_tree->log_mutex);
3220 
3221 	/*
3222 	 * The barrier before waitqueue_active (in cond_wake_up) is needed so
3223 	 * all the updates above are seen by the woken threads. It might not be
3224 	 * necessary, but proving that seems to be hard.
3225 	 */
3226 	cond_wake_up(&log_root_tree->log_commit_wait[index2]);
3227 out:
3228 	mutex_lock(&root->log_mutex);
3229 	btrfs_remove_all_log_ctxs(root, index1, ret);
3230 	root->log_transid_committed++;
3231 	atomic_set(&root->log_commit[index1], 0);
3232 	mutex_unlock(&root->log_mutex);
3233 
3234 	/*
3235 	 * The barrier before waitqueue_active (in cond_wake_up) is needed so
3236 	 * all the updates above are seen by the woken threads. It might not be
3237 	 * necessary, but proving that seems to be hard.
3238 	 */
3239 	cond_wake_up(&root->log_commit_wait[index1]);
3240 	return ret;
3241 }
3242 
free_log_tree(struct btrfs_trans_handle * trans,struct btrfs_root * log)3243 static void free_log_tree(struct btrfs_trans_handle *trans,
3244 			  struct btrfs_root *log)
3245 {
3246 	int ret;
3247 	struct walk_control wc = {
3248 		.free = 1,
3249 		.process_func = process_one_buffer
3250 	};
3251 
3252 	if (log->node) {
3253 		ret = walk_log_tree(trans, log, &wc);
3254 		if (ret) {
3255 			/*
3256 			 * We weren't able to traverse the entire log tree, the
3257 			 * typical scenario is getting an -EIO when reading an
3258 			 * extent buffer of the tree, due to a previous writeback
3259 			 * failure of it.
3260 			 */
3261 			set_bit(BTRFS_FS_STATE_LOG_CLEANUP_ERROR,
3262 				&log->fs_info->fs_state);
3263 
3264 			/*
3265 			 * Some extent buffers of the log tree may still be dirty
3266 			 * and not yet written back to storage, because we may
3267 			 * have updates to a log tree without syncing a log tree,
3268 			 * such as during rename and link operations. So flush
3269 			 * them out and wait for their writeback to complete, so
3270 			 * that we properly cleanup their state and pages.
3271 			 */
3272 			btrfs_write_marked_extents(log->fs_info,
3273 						   &log->dirty_log_pages,
3274 						   EXTENT_DIRTY | EXTENT_NEW);
3275 			btrfs_wait_tree_log_extents(log,
3276 						    EXTENT_DIRTY | EXTENT_NEW);
3277 
3278 			if (trans)
3279 				btrfs_abort_transaction(trans, ret);
3280 			else
3281 				btrfs_handle_fs_error(log->fs_info, ret, NULL);
3282 		}
3283 	}
3284 
3285 	clear_extent_bits(&log->dirty_log_pages, 0, (u64)-1,
3286 			  EXTENT_DIRTY | EXTENT_NEW | EXTENT_NEED_WAIT);
3287 	extent_io_tree_release(&log->log_csum_range);
3288 
3289 	btrfs_put_root(log);
3290 }
3291 
3292 /*
3293  * free all the extents used by the tree log.  This should be called
3294  * at commit time of the full transaction
3295  */
btrfs_free_log(struct btrfs_trans_handle * trans,struct btrfs_root * root)3296 int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
3297 {
3298 	if (root->log_root) {
3299 		free_log_tree(trans, root->log_root);
3300 		root->log_root = NULL;
3301 		clear_bit(BTRFS_ROOT_HAS_LOG_TREE, &root->state);
3302 	}
3303 	return 0;
3304 }
3305 
btrfs_free_log_root_tree(struct btrfs_trans_handle * trans,struct btrfs_fs_info * fs_info)3306 int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
3307 			     struct btrfs_fs_info *fs_info)
3308 {
3309 	if (fs_info->log_root_tree) {
3310 		free_log_tree(trans, fs_info->log_root_tree);
3311 		fs_info->log_root_tree = NULL;
3312 		clear_bit(BTRFS_ROOT_HAS_LOG_TREE, &fs_info->tree_root->state);
3313 	}
3314 	return 0;
3315 }
3316 
3317 /*
3318  * Check if an inode was logged in the current transaction. This correctly deals
3319  * with the case where the inode was logged but has a logged_trans of 0, which
3320  * happens if the inode is evicted and loaded again, as logged_trans is an in
3321  * memory only field (not persisted).
3322  *
3323  * Returns 1 if the inode was logged before in the transaction, 0 if it was not,
3324  * and < 0 on error.
3325  */
inode_logged(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path_in)3326 static int inode_logged(struct btrfs_trans_handle *trans,
3327 			struct btrfs_inode *inode,
3328 			struct btrfs_path *path_in)
3329 {
3330 	struct btrfs_path *path = path_in;
3331 	struct btrfs_key key;
3332 	int ret;
3333 
3334 	if (inode->logged_trans == trans->transid)
3335 		return 1;
3336 
3337 	/*
3338 	 * If logged_trans is not 0, then we know the inode logged was not logged
3339 	 * in this transaction, so we can return false right away.
3340 	 */
3341 	if (inode->logged_trans > 0)
3342 		return 0;
3343 
3344 	/*
3345 	 * If no log tree was created for this root in this transaction, then
3346 	 * the inode can not have been logged in this transaction. In that case
3347 	 * set logged_trans to anything greater than 0 and less than the current
3348 	 * transaction's ID, to avoid the search below in a future call in case
3349 	 * a log tree gets created after this.
3350 	 */
3351 	if (!test_bit(BTRFS_ROOT_HAS_LOG_TREE, &inode->root->state)) {
3352 		inode->logged_trans = trans->transid - 1;
3353 		return 0;
3354 	}
3355 
3356 	/*
3357 	 * We have a log tree and the inode's logged_trans is 0. We can't tell
3358 	 * for sure if the inode was logged before in this transaction by looking
3359 	 * only at logged_trans. We could be pessimistic and assume it was, but
3360 	 * that can lead to unnecessarily logging an inode during rename and link
3361 	 * operations, and then further updating the log in followup rename and
3362 	 * link operations, specially if it's a directory, which adds latency
3363 	 * visible to applications doing a series of rename or link operations.
3364 	 *
3365 	 * A logged_trans of 0 here can mean several things:
3366 	 *
3367 	 * 1) The inode was never logged since the filesystem was mounted, and may
3368 	 *    or may have not been evicted and loaded again;
3369 	 *
3370 	 * 2) The inode was logged in a previous transaction, then evicted and
3371 	 *    then loaded again;
3372 	 *
3373 	 * 3) The inode was logged in the current transaction, then evicted and
3374 	 *    then loaded again.
3375 	 *
3376 	 * For cases 1) and 2) we don't want to return true, but we need to detect
3377 	 * case 3) and return true. So we do a search in the log root for the inode
3378 	 * item.
3379 	 */
3380 	key.objectid = btrfs_ino(inode);
3381 	key.type = BTRFS_INODE_ITEM_KEY;
3382 	key.offset = 0;
3383 
3384 	if (!path) {
3385 		path = btrfs_alloc_path();
3386 		if (!path)
3387 			return -ENOMEM;
3388 	}
3389 
3390 	ret = btrfs_search_slot(NULL, inode->root->log_root, &key, path, 0, 0);
3391 
3392 	if (path_in)
3393 		btrfs_release_path(path);
3394 	else
3395 		btrfs_free_path(path);
3396 
3397 	/*
3398 	 * Logging an inode always results in logging its inode item. So if we
3399 	 * did not find the item we know the inode was not logged for sure.
3400 	 */
3401 	if (ret < 0) {
3402 		return ret;
3403 	} else if (ret > 0) {
3404 		/*
3405 		 * Set logged_trans to a value greater than 0 and less then the
3406 		 * current transaction to avoid doing the search in future calls.
3407 		 */
3408 		inode->logged_trans = trans->transid - 1;
3409 		return 0;
3410 	}
3411 
3412 	/*
3413 	 * The inode was previously logged and then evicted, set logged_trans to
3414 	 * the current transacion's ID, to avoid future tree searches as long as
3415 	 * the inode is not evicted again.
3416 	 */
3417 	inode->logged_trans = trans->transid;
3418 
3419 	/*
3420 	 * If it's a directory, then we must set last_dir_index_offset to the
3421 	 * maximum possible value, so that the next attempt to log the inode does
3422 	 * not skip checking if dir index keys found in modified subvolume tree
3423 	 * leaves have been logged before, otherwise it would result in attempts
3424 	 * to insert duplicate dir index keys in the log tree. This must be done
3425 	 * because last_dir_index_offset is an in-memory only field, not persisted
3426 	 * in the inode item or any other on-disk structure, so its value is lost
3427 	 * once the inode is evicted.
3428 	 */
3429 	if (S_ISDIR(inode->vfs_inode.i_mode))
3430 		inode->last_dir_index_offset = (u64)-1;
3431 
3432 	return 1;
3433 }
3434 
3435 /*
3436  * Delete a directory entry from the log if it exists.
3437  *
3438  * Returns < 0 on error
3439  *           1 if the entry does not exists
3440  *           0 if the entry existed and was successfully deleted
3441  */
del_logged_dentry(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_path * path,u64 dir_ino,const char * name,int name_len,u64 index)3442 static int del_logged_dentry(struct btrfs_trans_handle *trans,
3443 			     struct btrfs_root *log,
3444 			     struct btrfs_path *path,
3445 			     u64 dir_ino,
3446 			     const char *name, int name_len,
3447 			     u64 index)
3448 {
3449 	struct btrfs_dir_item *di;
3450 
3451 	/*
3452 	 * We only log dir index items of a directory, so we don't need to look
3453 	 * for dir item keys.
3454 	 */
3455 	di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
3456 					 index, name, name_len, -1);
3457 	if (IS_ERR(di))
3458 		return PTR_ERR(di);
3459 	else if (!di)
3460 		return 1;
3461 
3462 	/*
3463 	 * We do not need to update the size field of the directory's
3464 	 * inode item because on log replay we update the field to reflect
3465 	 * all existing entries in the directory (see overwrite_item()).
3466 	 */
3467 	return btrfs_delete_one_dir_name(trans, log, path, di);
3468 }
3469 
3470 /*
3471  * If both a file and directory are logged, and unlinks or renames are
3472  * mixed in, we have a few interesting corners:
3473  *
3474  * create file X in dir Y
3475  * link file X to X.link in dir Y
3476  * fsync file X
3477  * unlink file X but leave X.link
3478  * fsync dir Y
3479  *
3480  * After a crash we would expect only X.link to exist.  But file X
3481  * didn't get fsync'd again so the log has back refs for X and X.link.
3482  *
3483  * We solve this by removing directory entries and inode backrefs from the
3484  * log when a file that was logged in the current transaction is
3485  * unlinked.  Any later fsync will include the updated log entries, and
3486  * we'll be able to reconstruct the proper directory items from backrefs.
3487  *
3488  * This optimizations allows us to avoid relogging the entire inode
3489  * or the entire directory.
3490  */
btrfs_del_dir_entries_in_log(struct btrfs_trans_handle * trans,struct btrfs_root * root,const char * name,int name_len,struct btrfs_inode * dir,u64 index)3491 void btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
3492 				  struct btrfs_root *root,
3493 				  const char *name, int name_len,
3494 				  struct btrfs_inode *dir, u64 index)
3495 {
3496 	struct btrfs_path *path;
3497 	int ret;
3498 
3499 	ret = inode_logged(trans, dir, NULL);
3500 	if (ret == 0)
3501 		return;
3502 	else if (ret < 0) {
3503 		btrfs_set_log_full_commit(trans);
3504 		return;
3505 	}
3506 
3507 	ret = join_running_log_trans(root);
3508 	if (ret)
3509 		return;
3510 
3511 	mutex_lock(&dir->log_mutex);
3512 
3513 	path = btrfs_alloc_path();
3514 	if (!path) {
3515 		ret = -ENOMEM;
3516 		goto out_unlock;
3517 	}
3518 
3519 	ret = del_logged_dentry(trans, root->log_root, path, btrfs_ino(dir),
3520 				name, name_len, index);
3521 	btrfs_free_path(path);
3522 out_unlock:
3523 	mutex_unlock(&dir->log_mutex);
3524 	if (ret < 0)
3525 		btrfs_set_log_full_commit(trans);
3526 	btrfs_end_log_trans(root);
3527 }
3528 
3529 /* see comments for btrfs_del_dir_entries_in_log */
btrfs_del_inode_ref_in_log(struct btrfs_trans_handle * trans,struct btrfs_root * root,const char * name,int name_len,struct btrfs_inode * inode,u64 dirid)3530 void btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
3531 				struct btrfs_root *root,
3532 				const char *name, int name_len,
3533 				struct btrfs_inode *inode, u64 dirid)
3534 {
3535 	struct btrfs_root *log;
3536 	u64 index;
3537 	int ret;
3538 
3539 	ret = inode_logged(trans, inode, NULL);
3540 	if (ret == 0)
3541 		return;
3542 	else if (ret < 0) {
3543 		btrfs_set_log_full_commit(trans);
3544 		return;
3545 	}
3546 
3547 	ret = join_running_log_trans(root);
3548 	if (ret)
3549 		return;
3550 	log = root->log_root;
3551 	mutex_lock(&inode->log_mutex);
3552 
3553 	ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
3554 				  dirid, &index);
3555 	mutex_unlock(&inode->log_mutex);
3556 	if (ret < 0 && ret != -ENOENT)
3557 		btrfs_set_log_full_commit(trans);
3558 	btrfs_end_log_trans(root);
3559 }
3560 
3561 /*
3562  * creates a range item in the log for 'dirid'.  first_offset and
3563  * last_offset tell us which parts of the key space the log should
3564  * be considered authoritative for.
3565  */
insert_dir_log_key(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_path * path,u64 dirid,u64 first_offset,u64 last_offset)3566 static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
3567 				       struct btrfs_root *log,
3568 				       struct btrfs_path *path,
3569 				       u64 dirid,
3570 				       u64 first_offset, u64 last_offset)
3571 {
3572 	int ret;
3573 	struct btrfs_key key;
3574 	struct btrfs_dir_log_item *item;
3575 
3576 	key.objectid = dirid;
3577 	key.offset = first_offset;
3578 	key.type = BTRFS_DIR_LOG_INDEX_KEY;
3579 	ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
3580 	/*
3581 	 * -EEXIST is fine and can happen sporadically when we are logging a
3582 	 * directory and have concurrent insertions in the subvolume's tree for
3583 	 * items from other inodes and that result in pushing off some dir items
3584 	 * from one leaf to another in order to accommodate for the new items.
3585 	 * This results in logging the same dir index range key.
3586 	 */
3587 	if (ret && ret != -EEXIST)
3588 		return ret;
3589 
3590 	item = btrfs_item_ptr(path->nodes[0], path->slots[0],
3591 			      struct btrfs_dir_log_item);
3592 	if (ret == -EEXIST) {
3593 		const u64 curr_end = btrfs_dir_log_end(path->nodes[0], item);
3594 
3595 		/*
3596 		 * btrfs_del_dir_entries_in_log() might have been called during
3597 		 * an unlink between the initial insertion of this key and the
3598 		 * current update, or we might be logging a single entry deletion
3599 		 * during a rename, so set the new last_offset to the max value.
3600 		 */
3601 		last_offset = max(last_offset, curr_end);
3602 	}
3603 	btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
3604 	btrfs_mark_buffer_dirty(path->nodes[0]);
3605 	btrfs_release_path(path);
3606 	return 0;
3607 }
3608 
flush_dir_items_batch(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct extent_buffer * src,struct btrfs_path * dst_path,int start_slot,int count)3609 static int flush_dir_items_batch(struct btrfs_trans_handle *trans,
3610 				 struct btrfs_root *log,
3611 				 struct extent_buffer *src,
3612 				 struct btrfs_path *dst_path,
3613 				 int start_slot,
3614 				 int count)
3615 {
3616 	char *ins_data = NULL;
3617 	struct btrfs_item_batch batch;
3618 	struct extent_buffer *dst;
3619 	unsigned long src_offset;
3620 	unsigned long dst_offset;
3621 	struct btrfs_key key;
3622 	u32 item_size;
3623 	int ret;
3624 	int i;
3625 
3626 	ASSERT(count > 0);
3627 	batch.nr = count;
3628 
3629 	if (count == 1) {
3630 		btrfs_item_key_to_cpu(src, &key, start_slot);
3631 		item_size = btrfs_item_size(src, start_slot);
3632 		batch.keys = &key;
3633 		batch.data_sizes = &item_size;
3634 		batch.total_data_size = item_size;
3635 	} else {
3636 		struct btrfs_key *ins_keys;
3637 		u32 *ins_sizes;
3638 
3639 		ins_data = kmalloc(count * sizeof(u32) +
3640 				   count * sizeof(struct btrfs_key), GFP_NOFS);
3641 		if (!ins_data)
3642 			return -ENOMEM;
3643 
3644 		ins_sizes = (u32 *)ins_data;
3645 		ins_keys = (struct btrfs_key *)(ins_data + count * sizeof(u32));
3646 		batch.keys = ins_keys;
3647 		batch.data_sizes = ins_sizes;
3648 		batch.total_data_size = 0;
3649 
3650 		for (i = 0; i < count; i++) {
3651 			const int slot = start_slot + i;
3652 
3653 			btrfs_item_key_to_cpu(src, &ins_keys[i], slot);
3654 			ins_sizes[i] = btrfs_item_size(src, slot);
3655 			batch.total_data_size += ins_sizes[i];
3656 		}
3657 	}
3658 
3659 	ret = btrfs_insert_empty_items(trans, log, dst_path, &batch);
3660 	if (ret)
3661 		goto out;
3662 
3663 	dst = dst_path->nodes[0];
3664 	/*
3665 	 * Copy all the items in bulk, in a single copy operation. Item data is
3666 	 * organized such that it's placed at the end of a leaf and from right
3667 	 * to left. For example, the data for the second item ends at an offset
3668 	 * that matches the offset where the data for the first item starts, the
3669 	 * data for the third item ends at an offset that matches the offset
3670 	 * where the data of the second items starts, and so on.
3671 	 * Therefore our source and destination start offsets for copy match the
3672 	 * offsets of the last items (highest slots).
3673 	 */
3674 	dst_offset = btrfs_item_ptr_offset(dst, dst_path->slots[0] + count - 1);
3675 	src_offset = btrfs_item_ptr_offset(src, start_slot + count - 1);
3676 	copy_extent_buffer(dst, src, dst_offset, src_offset, batch.total_data_size);
3677 	btrfs_release_path(dst_path);
3678 out:
3679 	kfree(ins_data);
3680 
3681 	return ret;
3682 }
3683 
process_dir_items_leaf(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,struct btrfs_path * dst_path,struct btrfs_log_ctx * ctx,u64 * last_old_dentry_offset)3684 static int process_dir_items_leaf(struct btrfs_trans_handle *trans,
3685 				  struct btrfs_inode *inode,
3686 				  struct btrfs_path *path,
3687 				  struct btrfs_path *dst_path,
3688 				  struct btrfs_log_ctx *ctx,
3689 				  u64 *last_old_dentry_offset)
3690 {
3691 	struct btrfs_root *log = inode->root->log_root;
3692 	struct extent_buffer *src;
3693 	const int nritems = btrfs_header_nritems(path->nodes[0]);
3694 	const u64 ino = btrfs_ino(inode);
3695 	bool last_found = false;
3696 	int batch_start = 0;
3697 	int batch_size = 0;
3698 	int i;
3699 
3700 	/*
3701 	 * We need to clone the leaf, release the read lock on it, and use the
3702 	 * clone before modifying the log tree. See the comment at copy_items()
3703 	 * about why we need to do this.
3704 	 */
3705 	src = btrfs_clone_extent_buffer(path->nodes[0]);
3706 	if (!src)
3707 		return -ENOMEM;
3708 
3709 	i = path->slots[0];
3710 	btrfs_release_path(path);
3711 	path->nodes[0] = src;
3712 	path->slots[0] = i;
3713 
3714 	for (; i < nritems; i++) {
3715 		struct btrfs_dir_item *di;
3716 		struct btrfs_key key;
3717 		int ret;
3718 
3719 		btrfs_item_key_to_cpu(src, &key, i);
3720 
3721 		if (key.objectid != ino || key.type != BTRFS_DIR_INDEX_KEY) {
3722 			last_found = true;
3723 			break;
3724 		}
3725 
3726 		di = btrfs_item_ptr(src, i, struct btrfs_dir_item);
3727 		ctx->last_dir_item_offset = key.offset;
3728 
3729 		/*
3730 		 * Skip ranges of items that consist only of dir item keys created
3731 		 * in past transactions. However if we find a gap, we must log a
3732 		 * dir index range item for that gap, so that index keys in that
3733 		 * gap are deleted during log replay.
3734 		 */
3735 		if (btrfs_dir_transid(src, di) < trans->transid) {
3736 			if (key.offset > *last_old_dentry_offset + 1) {
3737 				ret = insert_dir_log_key(trans, log, dst_path,
3738 						 ino, *last_old_dentry_offset + 1,
3739 						 key.offset - 1);
3740 				if (ret < 0)
3741 					return ret;
3742 			}
3743 
3744 			*last_old_dentry_offset = key.offset;
3745 			continue;
3746 		}
3747 
3748 		/* If we logged this dir index item before, we can skip it. */
3749 		if (key.offset <= inode->last_dir_index_offset)
3750 			continue;
3751 
3752 		/*
3753 		 * We must make sure that when we log a directory entry, the
3754 		 * corresponding inode, after log replay, has a matching link
3755 		 * count. For example:
3756 		 *
3757 		 * touch foo
3758 		 * mkdir mydir
3759 		 * sync
3760 		 * ln foo mydir/bar
3761 		 * xfs_io -c "fsync" mydir
3762 		 * <crash>
3763 		 * <mount fs and log replay>
3764 		 *
3765 		 * Would result in a fsync log that when replayed, our file inode
3766 		 * would have a link count of 1, but we get two directory entries
3767 		 * pointing to the same inode. After removing one of the names,
3768 		 * it would not be possible to remove the other name, which
3769 		 * resulted always in stale file handle errors, and would not be
3770 		 * possible to rmdir the parent directory, since its i_size could
3771 		 * never be decremented to the value BTRFS_EMPTY_DIR_SIZE,
3772 		 * resulting in -ENOTEMPTY errors.
3773 		 */
3774 		if (!ctx->log_new_dentries) {
3775 			struct btrfs_key di_key;
3776 
3777 			btrfs_dir_item_key_to_cpu(src, di, &di_key);
3778 			if (di_key.type != BTRFS_ROOT_ITEM_KEY)
3779 				ctx->log_new_dentries = true;
3780 		}
3781 
3782 		if (batch_size == 0)
3783 			batch_start = i;
3784 		batch_size++;
3785 	}
3786 
3787 	if (batch_size > 0) {
3788 		int ret;
3789 
3790 		ret = flush_dir_items_batch(trans, log, src, dst_path,
3791 					    batch_start, batch_size);
3792 		if (ret < 0)
3793 			return ret;
3794 	}
3795 
3796 	return last_found ? 1 : 0;
3797 }
3798 
3799 /*
3800  * log all the items included in the current transaction for a given
3801  * directory.  This also creates the range items in the log tree required
3802  * to replay anything deleted before the fsync
3803  */
log_dir_items(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,struct btrfs_path * dst_path,struct btrfs_log_ctx * ctx,u64 min_offset,u64 * last_offset_ret)3804 static noinline int log_dir_items(struct btrfs_trans_handle *trans,
3805 			  struct btrfs_inode *inode,
3806 			  struct btrfs_path *path,
3807 			  struct btrfs_path *dst_path,
3808 			  struct btrfs_log_ctx *ctx,
3809 			  u64 min_offset, u64 *last_offset_ret)
3810 {
3811 	struct btrfs_key min_key;
3812 	struct btrfs_root *root = inode->root;
3813 	struct btrfs_root *log = root->log_root;
3814 	int err = 0;
3815 	int ret;
3816 	u64 last_old_dentry_offset = min_offset - 1;
3817 	u64 last_offset = (u64)-1;
3818 	u64 ino = btrfs_ino(inode);
3819 
3820 	min_key.objectid = ino;
3821 	min_key.type = BTRFS_DIR_INDEX_KEY;
3822 	min_key.offset = min_offset;
3823 
3824 	ret = btrfs_search_forward(root, &min_key, path, trans->transid);
3825 
3826 	/*
3827 	 * we didn't find anything from this transaction, see if there
3828 	 * is anything at all
3829 	 */
3830 	if (ret != 0 || min_key.objectid != ino ||
3831 	    min_key.type != BTRFS_DIR_INDEX_KEY) {
3832 		min_key.objectid = ino;
3833 		min_key.type = BTRFS_DIR_INDEX_KEY;
3834 		min_key.offset = (u64)-1;
3835 		btrfs_release_path(path);
3836 		ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3837 		if (ret < 0) {
3838 			btrfs_release_path(path);
3839 			return ret;
3840 		}
3841 		ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
3842 
3843 		/* if ret == 0 there are items for this type,
3844 		 * create a range to tell us the last key of this type.
3845 		 * otherwise, there are no items in this directory after
3846 		 * *min_offset, and we create a range to indicate that.
3847 		 */
3848 		if (ret == 0) {
3849 			struct btrfs_key tmp;
3850 
3851 			btrfs_item_key_to_cpu(path->nodes[0], &tmp,
3852 					      path->slots[0]);
3853 			if (tmp.type == BTRFS_DIR_INDEX_KEY)
3854 				last_old_dentry_offset = tmp.offset;
3855 		} else if (ret < 0) {
3856 			err = ret;
3857 		}
3858 
3859 		goto done;
3860 	}
3861 
3862 	/* go backward to find any previous key */
3863 	ret = btrfs_previous_item(root, path, ino, BTRFS_DIR_INDEX_KEY);
3864 	if (ret == 0) {
3865 		struct btrfs_key tmp;
3866 
3867 		btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
3868 		/*
3869 		 * The dir index key before the first one we found that needs to
3870 		 * be logged might be in a previous leaf, and there might be a
3871 		 * gap between these keys, meaning that we had deletions that
3872 		 * happened. So the key range item we log (key type
3873 		 * BTRFS_DIR_LOG_INDEX_KEY) must cover a range that starts at the
3874 		 * previous key's offset plus 1, so that those deletes are replayed.
3875 		 */
3876 		if (tmp.type == BTRFS_DIR_INDEX_KEY)
3877 			last_old_dentry_offset = tmp.offset;
3878 	} else if (ret < 0) {
3879 		err = ret;
3880 		goto done;
3881 	}
3882 
3883 	btrfs_release_path(path);
3884 
3885 	/*
3886 	 * Find the first key from this transaction again or the one we were at
3887 	 * in the loop below in case we had to reschedule. We may be logging the
3888 	 * directory without holding its VFS lock, which happen when logging new
3889 	 * dentries (through log_new_dir_dentries()) or in some cases when we
3890 	 * need to log the parent directory of an inode. This means a dir index
3891 	 * key might be deleted from the inode's root, and therefore we may not
3892 	 * find it anymore. If we can't find it, just move to the next key. We
3893 	 * can not bail out and ignore, because if we do that we will simply
3894 	 * not log dir index keys that come after the one that was just deleted
3895 	 * and we can end up logging a dir index range that ends at (u64)-1
3896 	 * (@last_offset is initialized to that), resulting in removing dir
3897 	 * entries we should not remove at log replay time.
3898 	 */
3899 search:
3900 	ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3901 	if (ret > 0)
3902 		ret = btrfs_next_item(root, path);
3903 	if (ret < 0)
3904 		err = ret;
3905 	/* If ret is 1, there are no more keys in the inode's root. */
3906 	if (ret != 0)
3907 		goto done;
3908 
3909 	/*
3910 	 * we have a block from this transaction, log every item in it
3911 	 * from our directory
3912 	 */
3913 	while (1) {
3914 		ret = process_dir_items_leaf(trans, inode, path, dst_path, ctx,
3915 					     &last_old_dentry_offset);
3916 		if (ret != 0) {
3917 			if (ret < 0)
3918 				err = ret;
3919 			goto done;
3920 		}
3921 		path->slots[0] = btrfs_header_nritems(path->nodes[0]);
3922 
3923 		/*
3924 		 * look ahead to the next item and see if it is also
3925 		 * from this directory and from this transaction
3926 		 */
3927 		ret = btrfs_next_leaf(root, path);
3928 		if (ret) {
3929 			if (ret == 1)
3930 				last_offset = (u64)-1;
3931 			else
3932 				err = ret;
3933 			goto done;
3934 		}
3935 		btrfs_item_key_to_cpu(path->nodes[0], &min_key, path->slots[0]);
3936 		if (min_key.objectid != ino || min_key.type != BTRFS_DIR_INDEX_KEY) {
3937 			last_offset = (u64)-1;
3938 			goto done;
3939 		}
3940 		if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
3941 			/*
3942 			 * The next leaf was not changed in the current transaction
3943 			 * and has at least one dir index key.
3944 			 * We check for the next key because there might have been
3945 			 * one or more deletions between the last key we logged and
3946 			 * that next key. So the key range item we log (key type
3947 			 * BTRFS_DIR_LOG_INDEX_KEY) must end at the next key's
3948 			 * offset minus 1, so that those deletes are replayed.
3949 			 */
3950 			last_offset = min_key.offset - 1;
3951 			goto done;
3952 		}
3953 		if (need_resched()) {
3954 			btrfs_release_path(path);
3955 			cond_resched();
3956 			goto search;
3957 		}
3958 	}
3959 done:
3960 	btrfs_release_path(path);
3961 	btrfs_release_path(dst_path);
3962 
3963 	if (err == 0) {
3964 		*last_offset_ret = last_offset;
3965 		/*
3966 		 * In case the leaf was changed in the current transaction but
3967 		 * all its dir items are from a past transaction, the last item
3968 		 * in the leaf is a dir item and there's no gap between that last
3969 		 * dir item and the first one on the next leaf (which did not
3970 		 * change in the current transaction), then we don't need to log
3971 		 * a range, last_old_dentry_offset is == to last_offset.
3972 		 */
3973 		ASSERT(last_old_dentry_offset <= last_offset);
3974 		if (last_old_dentry_offset < last_offset) {
3975 			ret = insert_dir_log_key(trans, log, path, ino,
3976 						 last_old_dentry_offset + 1,
3977 						 last_offset);
3978 			if (ret)
3979 				err = ret;
3980 		}
3981 	}
3982 	return err;
3983 }
3984 
3985 /*
3986  * If the inode was logged before and it was evicted, then its
3987  * last_dir_index_offset is (u64)-1, so we don't the value of the last index
3988  * key offset. If that's the case, search for it and update the inode. This
3989  * is to avoid lookups in the log tree every time we try to insert a dir index
3990  * key from a leaf changed in the current transaction, and to allow us to always
3991  * do batch insertions of dir index keys.
3992  */
update_last_dir_index_offset(struct btrfs_inode * inode,struct btrfs_path * path,const struct btrfs_log_ctx * ctx)3993 static int update_last_dir_index_offset(struct btrfs_inode *inode,
3994 					struct btrfs_path *path,
3995 					const struct btrfs_log_ctx *ctx)
3996 {
3997 	const u64 ino = btrfs_ino(inode);
3998 	struct btrfs_key key;
3999 	int ret;
4000 
4001 	lockdep_assert_held(&inode->log_mutex);
4002 
4003 	if (inode->last_dir_index_offset != (u64)-1)
4004 		return 0;
4005 
4006 	if (!ctx->logged_before) {
4007 		inode->last_dir_index_offset = BTRFS_DIR_START_INDEX - 1;
4008 		return 0;
4009 	}
4010 
4011 	key.objectid = ino;
4012 	key.type = BTRFS_DIR_INDEX_KEY;
4013 	key.offset = (u64)-1;
4014 
4015 	ret = btrfs_search_slot(NULL, inode->root->log_root, &key, path, 0, 0);
4016 	/*
4017 	 * An error happened or we actually have an index key with an offset
4018 	 * value of (u64)-1. Bail out, we're done.
4019 	 */
4020 	if (ret <= 0)
4021 		goto out;
4022 
4023 	ret = 0;
4024 	inode->last_dir_index_offset = BTRFS_DIR_START_INDEX - 1;
4025 
4026 	/*
4027 	 * No dir index items, bail out and leave last_dir_index_offset with
4028 	 * the value right before the first valid index value.
4029 	 */
4030 	if (path->slots[0] == 0)
4031 		goto out;
4032 
4033 	/*
4034 	 * btrfs_search_slot() left us at one slot beyond the slot with the last
4035 	 * index key, or beyond the last key of the directory that is not an
4036 	 * index key. If we have an index key before, set last_dir_index_offset
4037 	 * to its offset value, otherwise leave it with a value right before the
4038 	 * first valid index value, as it means we have an empty directory.
4039 	 */
4040 	btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0] - 1);
4041 	if (key.objectid == ino && key.type == BTRFS_DIR_INDEX_KEY)
4042 		inode->last_dir_index_offset = key.offset;
4043 
4044 out:
4045 	btrfs_release_path(path);
4046 
4047 	return ret;
4048 }
4049 
4050 /*
4051  * logging directories is very similar to logging inodes, We find all the items
4052  * from the current transaction and write them to the log.
4053  *
4054  * The recovery code scans the directory in the subvolume, and if it finds a
4055  * key in the range logged that is not present in the log tree, then it means
4056  * that dir entry was unlinked during the transaction.
4057  *
4058  * In order for that scan to work, we must include one key smaller than
4059  * the smallest logged by this transaction and one key larger than the largest
4060  * key logged by this transaction.
4061  */
log_directory_changes(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,struct btrfs_path * dst_path,struct btrfs_log_ctx * ctx)4062 static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
4063 			  struct btrfs_inode *inode,
4064 			  struct btrfs_path *path,
4065 			  struct btrfs_path *dst_path,
4066 			  struct btrfs_log_ctx *ctx)
4067 {
4068 	u64 min_key;
4069 	u64 max_key;
4070 	int ret;
4071 
4072 	ret = update_last_dir_index_offset(inode, path, ctx);
4073 	if (ret)
4074 		return ret;
4075 
4076 	min_key = BTRFS_DIR_START_INDEX;
4077 	max_key = 0;
4078 	ctx->last_dir_item_offset = inode->last_dir_index_offset;
4079 
4080 	while (1) {
4081 		ret = log_dir_items(trans, inode, path, dst_path,
4082 				ctx, min_key, &max_key);
4083 		if (ret)
4084 			return ret;
4085 		if (max_key == (u64)-1)
4086 			break;
4087 		min_key = max_key + 1;
4088 	}
4089 
4090 	inode->last_dir_index_offset = ctx->last_dir_item_offset;
4091 
4092 	return 0;
4093 }
4094 
4095 /*
4096  * a helper function to drop items from the log before we relog an
4097  * inode.  max_key_type indicates the highest item type to remove.
4098  * This cannot be run for file data extents because it does not
4099  * free the extents they point to.
4100  */
drop_inode_items(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_path * path,struct btrfs_inode * inode,int max_key_type)4101 static int drop_inode_items(struct btrfs_trans_handle *trans,
4102 				  struct btrfs_root *log,
4103 				  struct btrfs_path *path,
4104 				  struct btrfs_inode *inode,
4105 				  int max_key_type)
4106 {
4107 	int ret;
4108 	struct btrfs_key key;
4109 	struct btrfs_key found_key;
4110 	int start_slot;
4111 
4112 	key.objectid = btrfs_ino(inode);
4113 	key.type = max_key_type;
4114 	key.offset = (u64)-1;
4115 
4116 	while (1) {
4117 		ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
4118 		BUG_ON(ret == 0); /* Logic error */
4119 		if (ret < 0)
4120 			break;
4121 
4122 		if (path->slots[0] == 0)
4123 			break;
4124 
4125 		path->slots[0]--;
4126 		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
4127 				      path->slots[0]);
4128 
4129 		if (found_key.objectid != key.objectid)
4130 			break;
4131 
4132 		found_key.offset = 0;
4133 		found_key.type = 0;
4134 		ret = btrfs_bin_search(path->nodes[0], &found_key, &start_slot);
4135 		if (ret < 0)
4136 			break;
4137 
4138 		ret = btrfs_del_items(trans, log, path, start_slot,
4139 				      path->slots[0] - start_slot + 1);
4140 		/*
4141 		 * If start slot isn't 0 then we don't need to re-search, we've
4142 		 * found the last guy with the objectid in this tree.
4143 		 */
4144 		if (ret || start_slot != 0)
4145 			break;
4146 		btrfs_release_path(path);
4147 	}
4148 	btrfs_release_path(path);
4149 	if (ret > 0)
4150 		ret = 0;
4151 	return ret;
4152 }
4153 
truncate_inode_items(struct btrfs_trans_handle * trans,struct btrfs_root * log_root,struct btrfs_inode * inode,u64 new_size,u32 min_type)4154 static int truncate_inode_items(struct btrfs_trans_handle *trans,
4155 				struct btrfs_root *log_root,
4156 				struct btrfs_inode *inode,
4157 				u64 new_size, u32 min_type)
4158 {
4159 	struct btrfs_truncate_control control = {
4160 		.new_size = new_size,
4161 		.ino = btrfs_ino(inode),
4162 		.min_type = min_type,
4163 		.skip_ref_updates = true,
4164 	};
4165 
4166 	return btrfs_truncate_inode_items(trans, log_root, &control);
4167 }
4168 
fill_inode_item(struct btrfs_trans_handle * trans,struct extent_buffer * leaf,struct btrfs_inode_item * item,struct inode * inode,int log_inode_only,u64 logged_isize)4169 static void fill_inode_item(struct btrfs_trans_handle *trans,
4170 			    struct extent_buffer *leaf,
4171 			    struct btrfs_inode_item *item,
4172 			    struct inode *inode, int log_inode_only,
4173 			    u64 logged_isize)
4174 {
4175 	struct btrfs_map_token token;
4176 	u64 flags;
4177 
4178 	btrfs_init_map_token(&token, leaf);
4179 
4180 	if (log_inode_only) {
4181 		/* set the generation to zero so the recover code
4182 		 * can tell the difference between an logging
4183 		 * just to say 'this inode exists' and a logging
4184 		 * to say 'update this inode with these values'
4185 		 */
4186 		btrfs_set_token_inode_generation(&token, item, 0);
4187 		btrfs_set_token_inode_size(&token, item, logged_isize);
4188 	} else {
4189 		btrfs_set_token_inode_generation(&token, item,
4190 						 BTRFS_I(inode)->generation);
4191 		btrfs_set_token_inode_size(&token, item, inode->i_size);
4192 	}
4193 
4194 	btrfs_set_token_inode_uid(&token, item, i_uid_read(inode));
4195 	btrfs_set_token_inode_gid(&token, item, i_gid_read(inode));
4196 	btrfs_set_token_inode_mode(&token, item, inode->i_mode);
4197 	btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);
4198 
4199 	btrfs_set_token_timespec_sec(&token, &item->atime,
4200 				     inode->i_atime.tv_sec);
4201 	btrfs_set_token_timespec_nsec(&token, &item->atime,
4202 				      inode->i_atime.tv_nsec);
4203 
4204 	btrfs_set_token_timespec_sec(&token, &item->mtime,
4205 				     inode->i_mtime.tv_sec);
4206 	btrfs_set_token_timespec_nsec(&token, &item->mtime,
4207 				      inode->i_mtime.tv_nsec);
4208 
4209 	btrfs_set_token_timespec_sec(&token, &item->ctime,
4210 				     inode->i_ctime.tv_sec);
4211 	btrfs_set_token_timespec_nsec(&token, &item->ctime,
4212 				      inode->i_ctime.tv_nsec);
4213 
4214 	/*
4215 	 * We do not need to set the nbytes field, in fact during a fast fsync
4216 	 * its value may not even be correct, since a fast fsync does not wait
4217 	 * for ordered extent completion, which is where we update nbytes, it
4218 	 * only waits for writeback to complete. During log replay as we find
4219 	 * file extent items and replay them, we adjust the nbytes field of the
4220 	 * inode item in subvolume tree as needed (see overwrite_item()).
4221 	 */
4222 
4223 	btrfs_set_token_inode_sequence(&token, item, inode_peek_iversion(inode));
4224 	btrfs_set_token_inode_transid(&token, item, trans->transid);
4225 	btrfs_set_token_inode_rdev(&token, item, inode->i_rdev);
4226 	flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags,
4227 					  BTRFS_I(inode)->ro_flags);
4228 	btrfs_set_token_inode_flags(&token, item, flags);
4229 	btrfs_set_token_inode_block_group(&token, item, 0);
4230 }
4231 
log_inode_item(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_path * path,struct btrfs_inode * inode,bool inode_item_dropped)4232 static int log_inode_item(struct btrfs_trans_handle *trans,
4233 			  struct btrfs_root *log, struct btrfs_path *path,
4234 			  struct btrfs_inode *inode, bool inode_item_dropped)
4235 {
4236 	struct btrfs_inode_item *inode_item;
4237 	int ret;
4238 
4239 	/*
4240 	 * If we are doing a fast fsync and the inode was logged before in the
4241 	 * current transaction, then we know the inode was previously logged and
4242 	 * it exists in the log tree. For performance reasons, in this case use
4243 	 * btrfs_search_slot() directly with ins_len set to 0 so that we never
4244 	 * attempt a write lock on the leaf's parent, which adds unnecessary lock
4245 	 * contention in case there are concurrent fsyncs for other inodes of the
4246 	 * same subvolume. Using btrfs_insert_empty_item() when the inode item
4247 	 * already exists can also result in unnecessarily splitting a leaf.
4248 	 */
4249 	if (!inode_item_dropped && inode->logged_trans == trans->transid) {
4250 		ret = btrfs_search_slot(trans, log, &inode->location, path, 0, 1);
4251 		ASSERT(ret <= 0);
4252 		if (ret > 0)
4253 			ret = -ENOENT;
4254 	} else {
4255 		/*
4256 		 * This means it is the first fsync in the current transaction,
4257 		 * so the inode item is not in the log and we need to insert it.
4258 		 * We can never get -EEXIST because we are only called for a fast
4259 		 * fsync and in case an inode eviction happens after the inode was
4260 		 * logged before in the current transaction, when we load again
4261 		 * the inode, we set BTRFS_INODE_NEEDS_FULL_SYNC on its runtime
4262 		 * flags and set ->logged_trans to 0.
4263 		 */
4264 		ret = btrfs_insert_empty_item(trans, log, path, &inode->location,
4265 					      sizeof(*inode_item));
4266 		ASSERT(ret != -EEXIST);
4267 	}
4268 	if (ret)
4269 		return ret;
4270 	inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
4271 				    struct btrfs_inode_item);
4272 	fill_inode_item(trans, path->nodes[0], inode_item, &inode->vfs_inode,
4273 			0, 0);
4274 	btrfs_release_path(path);
4275 	return 0;
4276 }
4277 
log_csums(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_root * log_root,struct btrfs_ordered_sum * sums)4278 static int log_csums(struct btrfs_trans_handle *trans,
4279 		     struct btrfs_inode *inode,
4280 		     struct btrfs_root *log_root,
4281 		     struct btrfs_ordered_sum *sums)
4282 {
4283 	const u64 lock_end = sums->bytenr + sums->len - 1;
4284 	struct extent_state *cached_state = NULL;
4285 	int ret;
4286 
4287 	/*
4288 	 * If this inode was not used for reflink operations in the current
4289 	 * transaction with new extents, then do the fast path, no need to
4290 	 * worry about logging checksum items with overlapping ranges.
4291 	 */
4292 	if (inode->last_reflink_trans < trans->transid)
4293 		return btrfs_csum_file_blocks(trans, log_root, sums);
4294 
4295 	/*
4296 	 * Serialize logging for checksums. This is to avoid racing with the
4297 	 * same checksum being logged by another task that is logging another
4298 	 * file which happens to refer to the same extent as well. Such races
4299 	 * can leave checksum items in the log with overlapping ranges.
4300 	 */
4301 	ret = lock_extent(&log_root->log_csum_range, sums->bytenr, lock_end,
4302 			  &cached_state);
4303 	if (ret)
4304 		return ret;
4305 	/*
4306 	 * Due to extent cloning, we might have logged a csum item that covers a
4307 	 * subrange of a cloned extent, and later we can end up logging a csum
4308 	 * item for a larger subrange of the same extent or the entire range.
4309 	 * This would leave csum items in the log tree that cover the same range
4310 	 * and break the searches for checksums in the log tree, resulting in
4311 	 * some checksums missing in the fs/subvolume tree. So just delete (or
4312 	 * trim and adjust) any existing csum items in the log for this range.
4313 	 */
4314 	ret = btrfs_del_csums(trans, log_root, sums->bytenr, sums->len);
4315 	if (!ret)
4316 		ret = btrfs_csum_file_blocks(trans, log_root, sums);
4317 
4318 	unlock_extent(&log_root->log_csum_range, sums->bytenr, lock_end,
4319 		      &cached_state);
4320 
4321 	return ret;
4322 }
4323 
copy_items(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * dst_path,struct btrfs_path * src_path,int start_slot,int nr,int inode_only,u64 logged_isize)4324 static noinline int copy_items(struct btrfs_trans_handle *trans,
4325 			       struct btrfs_inode *inode,
4326 			       struct btrfs_path *dst_path,
4327 			       struct btrfs_path *src_path,
4328 			       int start_slot, int nr, int inode_only,
4329 			       u64 logged_isize)
4330 {
4331 	struct btrfs_root *log = inode->root->log_root;
4332 	struct btrfs_file_extent_item *extent;
4333 	struct extent_buffer *src;
4334 	int ret = 0;
4335 	struct btrfs_key *ins_keys;
4336 	u32 *ins_sizes;
4337 	struct btrfs_item_batch batch;
4338 	char *ins_data;
4339 	int i;
4340 	int dst_index;
4341 	const bool skip_csum = (inode->flags & BTRFS_INODE_NODATASUM);
4342 	const u64 i_size = i_size_read(&inode->vfs_inode);
4343 
4344 	/*
4345 	 * To keep lockdep happy and avoid deadlocks, clone the source leaf and
4346 	 * use the clone. This is because otherwise we would be changing the log
4347 	 * tree, to insert items from the subvolume tree or insert csum items,
4348 	 * while holding a read lock on a leaf from the subvolume tree, which
4349 	 * creates a nasty lock dependency when COWing log tree nodes/leaves:
4350 	 *
4351 	 * 1) Modifying the log tree triggers an extent buffer allocation while
4352 	 *    holding a write lock on a parent extent buffer from the log tree.
4353 	 *    Allocating the pages for an extent buffer, or the extent buffer
4354 	 *    struct, can trigger inode eviction and finally the inode eviction
4355 	 *    will trigger a release/remove of a delayed node, which requires
4356 	 *    taking the delayed node's mutex;
4357 	 *
4358 	 * 2) Allocating a metadata extent for a log tree can trigger the async
4359 	 *    reclaim thread and make us wait for it to release enough space and
4360 	 *    unblock our reservation ticket. The reclaim thread can start
4361 	 *    flushing delayed items, and that in turn results in the need to
4362 	 *    lock delayed node mutexes and in the need to write lock extent
4363 	 *    buffers of a subvolume tree - all this while holding a write lock
4364 	 *    on the parent extent buffer in the log tree.
4365 	 *
4366 	 * So one task in scenario 1) running in parallel with another task in
4367 	 * scenario 2) could lead to a deadlock, one wanting to lock a delayed
4368 	 * node mutex while having a read lock on a leaf from the subvolume,
4369 	 * while the other is holding the delayed node's mutex and wants to
4370 	 * write lock the same subvolume leaf for flushing delayed items.
4371 	 */
4372 	src = btrfs_clone_extent_buffer(src_path->nodes[0]);
4373 	if (!src)
4374 		return -ENOMEM;
4375 
4376 	i = src_path->slots[0];
4377 	btrfs_release_path(src_path);
4378 	src_path->nodes[0] = src;
4379 	src_path->slots[0] = i;
4380 
4381 	ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
4382 			   nr * sizeof(u32), GFP_NOFS);
4383 	if (!ins_data)
4384 		return -ENOMEM;
4385 
4386 	ins_sizes = (u32 *)ins_data;
4387 	ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));
4388 	batch.keys = ins_keys;
4389 	batch.data_sizes = ins_sizes;
4390 	batch.total_data_size = 0;
4391 	batch.nr = 0;
4392 
4393 	dst_index = 0;
4394 	for (i = 0; i < nr; i++) {
4395 		const int src_slot = start_slot + i;
4396 		struct btrfs_root *csum_root;
4397 		struct btrfs_ordered_sum *sums;
4398 		struct btrfs_ordered_sum *sums_next;
4399 		LIST_HEAD(ordered_sums);
4400 		u64 disk_bytenr;
4401 		u64 disk_num_bytes;
4402 		u64 extent_offset;
4403 		u64 extent_num_bytes;
4404 		bool is_old_extent;
4405 
4406 		btrfs_item_key_to_cpu(src, &ins_keys[dst_index], src_slot);
4407 
4408 		if (ins_keys[dst_index].type != BTRFS_EXTENT_DATA_KEY)
4409 			goto add_to_batch;
4410 
4411 		extent = btrfs_item_ptr(src, src_slot,
4412 					struct btrfs_file_extent_item);
4413 
4414 		is_old_extent = (btrfs_file_extent_generation(src, extent) <
4415 				 trans->transid);
4416 
4417 		/*
4418 		 * Don't copy extents from past generations. That would make us
4419 		 * log a lot more metadata for common cases like doing only a
4420 		 * few random writes into a file and then fsync it for the first
4421 		 * time or after the full sync flag is set on the inode. We can
4422 		 * get leaves full of extent items, most of which are from past
4423 		 * generations, so we can skip them - as long as the inode has
4424 		 * not been the target of a reflink operation in this transaction,
4425 		 * as in that case it might have had file extent items with old
4426 		 * generations copied into it. We also must always log prealloc
4427 		 * extents that start at or beyond eof, otherwise we would lose
4428 		 * them on log replay.
4429 		 */
4430 		if (is_old_extent &&
4431 		    ins_keys[dst_index].offset < i_size &&
4432 		    inode->last_reflink_trans < trans->transid)
4433 			continue;
4434 
4435 		if (skip_csum)
4436 			goto add_to_batch;
4437 
4438 		/* Only regular extents have checksums. */
4439 		if (btrfs_file_extent_type(src, extent) != BTRFS_FILE_EXTENT_REG)
4440 			goto add_to_batch;
4441 
4442 		/*
4443 		 * If it's an extent created in a past transaction, then its
4444 		 * checksums are already accessible from the committed csum tree,
4445 		 * no need to log them.
4446 		 */
4447 		if (is_old_extent)
4448 			goto add_to_batch;
4449 
4450 		disk_bytenr = btrfs_file_extent_disk_bytenr(src, extent);
4451 		/* If it's an explicit hole, there are no checksums. */
4452 		if (disk_bytenr == 0)
4453 			goto add_to_batch;
4454 
4455 		disk_num_bytes = btrfs_file_extent_disk_num_bytes(src, extent);
4456 
4457 		if (btrfs_file_extent_compression(src, extent)) {
4458 			extent_offset = 0;
4459 			extent_num_bytes = disk_num_bytes;
4460 		} else {
4461 			extent_offset = btrfs_file_extent_offset(src, extent);
4462 			extent_num_bytes = btrfs_file_extent_num_bytes(src, extent);
4463 		}
4464 
4465 		csum_root = btrfs_csum_root(trans->fs_info, disk_bytenr);
4466 		disk_bytenr += extent_offset;
4467 		ret = btrfs_lookup_csums_range(csum_root, disk_bytenr,
4468 					       disk_bytenr + extent_num_bytes - 1,
4469 					       &ordered_sums, 0, false);
4470 		if (ret)
4471 			goto out;
4472 
4473 		list_for_each_entry_safe(sums, sums_next, &ordered_sums, list) {
4474 			if (!ret)
4475 				ret = log_csums(trans, inode, log, sums);
4476 			list_del(&sums->list);
4477 			kfree(sums);
4478 		}
4479 		if (ret)
4480 			goto out;
4481 
4482 add_to_batch:
4483 		ins_sizes[dst_index] = btrfs_item_size(src, src_slot);
4484 		batch.total_data_size += ins_sizes[dst_index];
4485 		batch.nr++;
4486 		dst_index++;
4487 	}
4488 
4489 	/*
4490 	 * We have a leaf full of old extent items that don't need to be logged,
4491 	 * so we don't need to do anything.
4492 	 */
4493 	if (batch.nr == 0)
4494 		goto out;
4495 
4496 	ret = btrfs_insert_empty_items(trans, log, dst_path, &batch);
4497 	if (ret)
4498 		goto out;
4499 
4500 	dst_index = 0;
4501 	for (i = 0; i < nr; i++) {
4502 		const int src_slot = start_slot + i;
4503 		const int dst_slot = dst_path->slots[0] + dst_index;
4504 		struct btrfs_key key;
4505 		unsigned long src_offset;
4506 		unsigned long dst_offset;
4507 
4508 		/*
4509 		 * We're done, all the remaining items in the source leaf
4510 		 * correspond to old file extent items.
4511 		 */
4512 		if (dst_index >= batch.nr)
4513 			break;
4514 
4515 		btrfs_item_key_to_cpu(src, &key, src_slot);
4516 
4517 		if (key.type != BTRFS_EXTENT_DATA_KEY)
4518 			goto copy_item;
4519 
4520 		extent = btrfs_item_ptr(src, src_slot,
4521 					struct btrfs_file_extent_item);
4522 
4523 		/* See the comment in the previous loop, same logic. */
4524 		if (btrfs_file_extent_generation(src, extent) < trans->transid &&
4525 		    key.offset < i_size &&
4526 		    inode->last_reflink_trans < trans->transid)
4527 			continue;
4528 
4529 copy_item:
4530 		dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0], dst_slot);
4531 		src_offset = btrfs_item_ptr_offset(src, src_slot);
4532 
4533 		if (key.type == BTRFS_INODE_ITEM_KEY) {
4534 			struct btrfs_inode_item *inode_item;
4535 
4536 			inode_item = btrfs_item_ptr(dst_path->nodes[0], dst_slot,
4537 						    struct btrfs_inode_item);
4538 			fill_inode_item(trans, dst_path->nodes[0], inode_item,
4539 					&inode->vfs_inode,
4540 					inode_only == LOG_INODE_EXISTS,
4541 					logged_isize);
4542 		} else {
4543 			copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
4544 					   src_offset, ins_sizes[dst_index]);
4545 		}
4546 
4547 		dst_index++;
4548 	}
4549 
4550 	btrfs_mark_buffer_dirty(dst_path->nodes[0]);
4551 	btrfs_release_path(dst_path);
4552 out:
4553 	kfree(ins_data);
4554 
4555 	return ret;
4556 }
4557 
extent_cmp(void * priv,const struct list_head * a,const struct list_head * b)4558 static int extent_cmp(void *priv, const struct list_head *a,
4559 		      const struct list_head *b)
4560 {
4561 	const struct extent_map *em1, *em2;
4562 
4563 	em1 = list_entry(a, struct extent_map, list);
4564 	em2 = list_entry(b, struct extent_map, list);
4565 
4566 	if (em1->start < em2->start)
4567 		return -1;
4568 	else if (em1->start > em2->start)
4569 		return 1;
4570 	return 0;
4571 }
4572 
log_extent_csums(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_root * log_root,const struct extent_map * em,struct btrfs_log_ctx * ctx)4573 static int log_extent_csums(struct btrfs_trans_handle *trans,
4574 			    struct btrfs_inode *inode,
4575 			    struct btrfs_root *log_root,
4576 			    const struct extent_map *em,
4577 			    struct btrfs_log_ctx *ctx)
4578 {
4579 	struct btrfs_ordered_extent *ordered;
4580 	struct btrfs_root *csum_root;
4581 	u64 csum_offset;
4582 	u64 csum_len;
4583 	u64 mod_start = em->mod_start;
4584 	u64 mod_len = em->mod_len;
4585 	LIST_HEAD(ordered_sums);
4586 	int ret = 0;
4587 
4588 	if (inode->flags & BTRFS_INODE_NODATASUM ||
4589 	    test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
4590 	    em->block_start == EXTENT_MAP_HOLE)
4591 		return 0;
4592 
4593 	list_for_each_entry(ordered, &ctx->ordered_extents, log_list) {
4594 		const u64 ordered_end = ordered->file_offset + ordered->num_bytes;
4595 		const u64 mod_end = mod_start + mod_len;
4596 		struct btrfs_ordered_sum *sums;
4597 
4598 		if (mod_len == 0)
4599 			break;
4600 
4601 		if (ordered_end <= mod_start)
4602 			continue;
4603 		if (mod_end <= ordered->file_offset)
4604 			break;
4605 
4606 		/*
4607 		 * We are going to copy all the csums on this ordered extent, so
4608 		 * go ahead and adjust mod_start and mod_len in case this ordered
4609 		 * extent has already been logged.
4610 		 */
4611 		if (ordered->file_offset > mod_start) {
4612 			if (ordered_end >= mod_end)
4613 				mod_len = ordered->file_offset - mod_start;
4614 			/*
4615 			 * If we have this case
4616 			 *
4617 			 * |--------- logged extent ---------|
4618 			 *       |----- ordered extent ----|
4619 			 *
4620 			 * Just don't mess with mod_start and mod_len, we'll
4621 			 * just end up logging more csums than we need and it
4622 			 * will be ok.
4623 			 */
4624 		} else {
4625 			if (ordered_end < mod_end) {
4626 				mod_len = mod_end - ordered_end;
4627 				mod_start = ordered_end;
4628 			} else {
4629 				mod_len = 0;
4630 			}
4631 		}
4632 
4633 		/*
4634 		 * To keep us from looping for the above case of an ordered
4635 		 * extent that falls inside of the logged extent.
4636 		 */
4637 		if (test_and_set_bit(BTRFS_ORDERED_LOGGED_CSUM, &ordered->flags))
4638 			continue;
4639 
4640 		list_for_each_entry(sums, &ordered->list, list) {
4641 			ret = log_csums(trans, inode, log_root, sums);
4642 			if (ret)
4643 				return ret;
4644 		}
4645 	}
4646 
4647 	/* We're done, found all csums in the ordered extents. */
4648 	if (mod_len == 0)
4649 		return 0;
4650 
4651 	/* If we're compressed we have to save the entire range of csums. */
4652 	if (em->compress_type) {
4653 		csum_offset = 0;
4654 		csum_len = max(em->block_len, em->orig_block_len);
4655 	} else {
4656 		csum_offset = mod_start - em->start;
4657 		csum_len = mod_len;
4658 	}
4659 
4660 	/* block start is already adjusted for the file extent offset. */
4661 	csum_root = btrfs_csum_root(trans->fs_info, em->block_start);
4662 	ret = btrfs_lookup_csums_range(csum_root,
4663 				       em->block_start + csum_offset,
4664 				       em->block_start + csum_offset +
4665 				       csum_len - 1, &ordered_sums, 0, false);
4666 	if (ret)
4667 		return ret;
4668 
4669 	while (!list_empty(&ordered_sums)) {
4670 		struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
4671 						   struct btrfs_ordered_sum,
4672 						   list);
4673 		if (!ret)
4674 			ret = log_csums(trans, inode, log_root, sums);
4675 		list_del(&sums->list);
4676 		kfree(sums);
4677 	}
4678 
4679 	return ret;
4680 }
4681 
log_one_extent(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,const struct extent_map * em,struct btrfs_path * path,struct btrfs_log_ctx * ctx)4682 static int log_one_extent(struct btrfs_trans_handle *trans,
4683 			  struct btrfs_inode *inode,
4684 			  const struct extent_map *em,
4685 			  struct btrfs_path *path,
4686 			  struct btrfs_log_ctx *ctx)
4687 {
4688 	struct btrfs_drop_extents_args drop_args = { 0 };
4689 	struct btrfs_root *log = inode->root->log_root;
4690 	struct btrfs_file_extent_item fi = { 0 };
4691 	struct extent_buffer *leaf;
4692 	struct btrfs_key key;
4693 	u64 extent_offset = em->start - em->orig_start;
4694 	u64 block_len;
4695 	int ret;
4696 
4697 	btrfs_set_stack_file_extent_generation(&fi, trans->transid);
4698 	if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
4699 		btrfs_set_stack_file_extent_type(&fi, BTRFS_FILE_EXTENT_PREALLOC);
4700 	else
4701 		btrfs_set_stack_file_extent_type(&fi, BTRFS_FILE_EXTENT_REG);
4702 
4703 	block_len = max(em->block_len, em->orig_block_len);
4704 	if (em->compress_type != BTRFS_COMPRESS_NONE) {
4705 		btrfs_set_stack_file_extent_disk_bytenr(&fi, em->block_start);
4706 		btrfs_set_stack_file_extent_disk_num_bytes(&fi, block_len);
4707 	} else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
4708 		btrfs_set_stack_file_extent_disk_bytenr(&fi, em->block_start -
4709 							extent_offset);
4710 		btrfs_set_stack_file_extent_disk_num_bytes(&fi, block_len);
4711 	}
4712 
4713 	btrfs_set_stack_file_extent_offset(&fi, extent_offset);
4714 	btrfs_set_stack_file_extent_num_bytes(&fi, em->len);
4715 	btrfs_set_stack_file_extent_ram_bytes(&fi, em->ram_bytes);
4716 	btrfs_set_stack_file_extent_compression(&fi, em->compress_type);
4717 
4718 	ret = log_extent_csums(trans, inode, log, em, ctx);
4719 	if (ret)
4720 		return ret;
4721 
4722 	/*
4723 	 * If this is the first time we are logging the inode in the current
4724 	 * transaction, we can avoid btrfs_drop_extents(), which is expensive
4725 	 * because it does a deletion search, which always acquires write locks
4726 	 * for extent buffers at levels 2, 1 and 0. This not only wastes time
4727 	 * but also adds significant contention in a log tree, since log trees
4728 	 * are small, with a root at level 2 or 3 at most, due to their short
4729 	 * life span.
4730 	 */
4731 	if (ctx->logged_before) {
4732 		drop_args.path = path;
4733 		drop_args.start = em->start;
4734 		drop_args.end = em->start + em->len;
4735 		drop_args.replace_extent = true;
4736 		drop_args.extent_item_size = sizeof(fi);
4737 		ret = btrfs_drop_extents(trans, log, inode, &drop_args);
4738 		if (ret)
4739 			return ret;
4740 	}
4741 
4742 	if (!drop_args.extent_inserted) {
4743 		key.objectid = btrfs_ino(inode);
4744 		key.type = BTRFS_EXTENT_DATA_KEY;
4745 		key.offset = em->start;
4746 
4747 		ret = btrfs_insert_empty_item(trans, log, path, &key,
4748 					      sizeof(fi));
4749 		if (ret)
4750 			return ret;
4751 	}
4752 	leaf = path->nodes[0];
4753 	write_extent_buffer(leaf, &fi,
4754 			    btrfs_item_ptr_offset(leaf, path->slots[0]),
4755 			    sizeof(fi));
4756 	btrfs_mark_buffer_dirty(leaf);
4757 
4758 	btrfs_release_path(path);
4759 
4760 	return ret;
4761 }
4762 
4763 /*
4764  * Log all prealloc extents beyond the inode's i_size to make sure we do not
4765  * lose them after doing a full/fast fsync and replaying the log. We scan the
4766  * subvolume's root instead of iterating the inode's extent map tree because
4767  * otherwise we can log incorrect extent items based on extent map conversion.
4768  * That can happen due to the fact that extent maps are merged when they
4769  * are not in the extent map tree's list of modified extents.
4770  */
btrfs_log_prealloc_extents(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path)4771 static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans,
4772 				      struct btrfs_inode *inode,
4773 				      struct btrfs_path *path)
4774 {
4775 	struct btrfs_root *root = inode->root;
4776 	struct btrfs_key key;
4777 	const u64 i_size = i_size_read(&inode->vfs_inode);
4778 	const u64 ino = btrfs_ino(inode);
4779 	struct btrfs_path *dst_path = NULL;
4780 	bool dropped_extents = false;
4781 	u64 truncate_offset = i_size;
4782 	struct extent_buffer *leaf;
4783 	int slot;
4784 	int ins_nr = 0;
4785 	int start_slot;
4786 	int ret;
4787 
4788 	if (!(inode->flags & BTRFS_INODE_PREALLOC))
4789 		return 0;
4790 
4791 	key.objectid = ino;
4792 	key.type = BTRFS_EXTENT_DATA_KEY;
4793 	key.offset = i_size;
4794 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4795 	if (ret < 0)
4796 		goto out;
4797 
4798 	/*
4799 	 * We must check if there is a prealloc extent that starts before the
4800 	 * i_size and crosses the i_size boundary. This is to ensure later we
4801 	 * truncate down to the end of that extent and not to the i_size, as
4802 	 * otherwise we end up losing part of the prealloc extent after a log
4803 	 * replay and with an implicit hole if there is another prealloc extent
4804 	 * that starts at an offset beyond i_size.
4805 	 */
4806 	ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
4807 	if (ret < 0)
4808 		goto out;
4809 
4810 	if (ret == 0) {
4811 		struct btrfs_file_extent_item *ei;
4812 
4813 		leaf = path->nodes[0];
4814 		slot = path->slots[0];
4815 		ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
4816 
4817 		if (btrfs_file_extent_type(leaf, ei) ==
4818 		    BTRFS_FILE_EXTENT_PREALLOC) {
4819 			u64 extent_end;
4820 
4821 			btrfs_item_key_to_cpu(leaf, &key, slot);
4822 			extent_end = key.offset +
4823 				btrfs_file_extent_num_bytes(leaf, ei);
4824 
4825 			if (extent_end > i_size)
4826 				truncate_offset = extent_end;
4827 		}
4828 	} else {
4829 		ret = 0;
4830 	}
4831 
4832 	while (true) {
4833 		leaf = path->nodes[0];
4834 		slot = path->slots[0];
4835 
4836 		if (slot >= btrfs_header_nritems(leaf)) {
4837 			if (ins_nr > 0) {
4838 				ret = copy_items(trans, inode, dst_path, path,
4839 						 start_slot, ins_nr, 1, 0);
4840 				if (ret < 0)
4841 					goto out;
4842 				ins_nr = 0;
4843 			}
4844 			ret = btrfs_next_leaf(root, path);
4845 			if (ret < 0)
4846 				goto out;
4847 			if (ret > 0) {
4848 				ret = 0;
4849 				break;
4850 			}
4851 			continue;
4852 		}
4853 
4854 		btrfs_item_key_to_cpu(leaf, &key, slot);
4855 		if (key.objectid > ino)
4856 			break;
4857 		if (WARN_ON_ONCE(key.objectid < ino) ||
4858 		    key.type < BTRFS_EXTENT_DATA_KEY ||
4859 		    key.offset < i_size) {
4860 			path->slots[0]++;
4861 			continue;
4862 		}
4863 		if (!dropped_extents) {
4864 			/*
4865 			 * Avoid logging extent items logged in past fsync calls
4866 			 * and leading to duplicate keys in the log tree.
4867 			 */
4868 			ret = truncate_inode_items(trans, root->log_root, inode,
4869 						   truncate_offset,
4870 						   BTRFS_EXTENT_DATA_KEY);
4871 			if (ret)
4872 				goto out;
4873 			dropped_extents = true;
4874 		}
4875 		if (ins_nr == 0)
4876 			start_slot = slot;
4877 		ins_nr++;
4878 		path->slots[0]++;
4879 		if (!dst_path) {
4880 			dst_path = btrfs_alloc_path();
4881 			if (!dst_path) {
4882 				ret = -ENOMEM;
4883 				goto out;
4884 			}
4885 		}
4886 	}
4887 	if (ins_nr > 0)
4888 		ret = copy_items(trans, inode, dst_path, path,
4889 				 start_slot, ins_nr, 1, 0);
4890 out:
4891 	btrfs_release_path(path);
4892 	btrfs_free_path(dst_path);
4893 	return ret;
4894 }
4895 
btrfs_log_changed_extents(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,struct btrfs_log_ctx * ctx)4896 static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
4897 				     struct btrfs_inode *inode,
4898 				     struct btrfs_path *path,
4899 				     struct btrfs_log_ctx *ctx)
4900 {
4901 	struct btrfs_ordered_extent *ordered;
4902 	struct btrfs_ordered_extent *tmp;
4903 	struct extent_map *em, *n;
4904 	struct list_head extents;
4905 	struct extent_map_tree *tree = &inode->extent_tree;
4906 	int ret = 0;
4907 	int num = 0;
4908 
4909 	INIT_LIST_HEAD(&extents);
4910 
4911 	write_lock(&tree->lock);
4912 
4913 	list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
4914 		list_del_init(&em->list);
4915 		/*
4916 		 * Just an arbitrary number, this can be really CPU intensive
4917 		 * once we start getting a lot of extents, and really once we
4918 		 * have a bunch of extents we just want to commit since it will
4919 		 * be faster.
4920 		 */
4921 		if (++num > 32768) {
4922 			list_del_init(&tree->modified_extents);
4923 			ret = -EFBIG;
4924 			goto process;
4925 		}
4926 
4927 		if (em->generation < trans->transid)
4928 			continue;
4929 
4930 		/* We log prealloc extents beyond eof later. */
4931 		if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) &&
4932 		    em->start >= i_size_read(&inode->vfs_inode))
4933 			continue;
4934 
4935 		/* Need a ref to keep it from getting evicted from cache */
4936 		refcount_inc(&em->refs);
4937 		set_bit(EXTENT_FLAG_LOGGING, &em->flags);
4938 		list_add_tail(&em->list, &extents);
4939 		num++;
4940 	}
4941 
4942 	list_sort(NULL, &extents, extent_cmp);
4943 process:
4944 	while (!list_empty(&extents)) {
4945 		em = list_entry(extents.next, struct extent_map, list);
4946 
4947 		list_del_init(&em->list);
4948 
4949 		/*
4950 		 * If we had an error we just need to delete everybody from our
4951 		 * private list.
4952 		 */
4953 		if (ret) {
4954 			clear_em_logging(tree, em);
4955 			free_extent_map(em);
4956 			continue;
4957 		}
4958 
4959 		write_unlock(&tree->lock);
4960 
4961 		ret = log_one_extent(trans, inode, em, path, ctx);
4962 		write_lock(&tree->lock);
4963 		clear_em_logging(tree, em);
4964 		free_extent_map(em);
4965 	}
4966 	WARN_ON(!list_empty(&extents));
4967 	write_unlock(&tree->lock);
4968 
4969 	if (!ret)
4970 		ret = btrfs_log_prealloc_extents(trans, inode, path);
4971 	if (ret)
4972 		return ret;
4973 
4974 	/*
4975 	 * We have logged all extents successfully, now make sure the commit of
4976 	 * the current transaction waits for the ordered extents to complete
4977 	 * before it commits and wipes out the log trees, otherwise we would
4978 	 * lose data if an ordered extents completes after the transaction
4979 	 * commits and a power failure happens after the transaction commit.
4980 	 */
4981 	list_for_each_entry_safe(ordered, tmp, &ctx->ordered_extents, log_list) {
4982 		list_del_init(&ordered->log_list);
4983 		set_bit(BTRFS_ORDERED_LOGGED, &ordered->flags);
4984 
4985 		if (!test_bit(BTRFS_ORDERED_COMPLETE, &ordered->flags)) {
4986 			spin_lock_irq(&inode->ordered_tree.lock);
4987 			if (!test_bit(BTRFS_ORDERED_COMPLETE, &ordered->flags)) {
4988 				set_bit(BTRFS_ORDERED_PENDING, &ordered->flags);
4989 				atomic_inc(&trans->transaction->pending_ordered);
4990 			}
4991 			spin_unlock_irq(&inode->ordered_tree.lock);
4992 		}
4993 		btrfs_put_ordered_extent(ordered);
4994 	}
4995 
4996 	return 0;
4997 }
4998 
logged_inode_size(struct btrfs_root * log,struct btrfs_inode * inode,struct btrfs_path * path,u64 * size_ret)4999 static int logged_inode_size(struct btrfs_root *log, struct btrfs_inode *inode,
5000 			     struct btrfs_path *path, u64 *size_ret)
5001 {
5002 	struct btrfs_key key;
5003 	int ret;
5004 
5005 	key.objectid = btrfs_ino(inode);
5006 	key.type = BTRFS_INODE_ITEM_KEY;
5007 	key.offset = 0;
5008 
5009 	ret = btrfs_search_slot(NULL, log, &key, path, 0, 0);
5010 	if (ret < 0) {
5011 		return ret;
5012 	} else if (ret > 0) {
5013 		*size_ret = 0;
5014 	} else {
5015 		struct btrfs_inode_item *item;
5016 
5017 		item = btrfs_item_ptr(path->nodes[0], path->slots[0],
5018 				      struct btrfs_inode_item);
5019 		*size_ret = btrfs_inode_size(path->nodes[0], item);
5020 		/*
5021 		 * If the in-memory inode's i_size is smaller then the inode
5022 		 * size stored in the btree, return the inode's i_size, so
5023 		 * that we get a correct inode size after replaying the log
5024 		 * when before a power failure we had a shrinking truncate
5025 		 * followed by addition of a new name (rename / new hard link).
5026 		 * Otherwise return the inode size from the btree, to avoid
5027 		 * data loss when replaying a log due to previously doing a
5028 		 * write that expands the inode's size and logging a new name
5029 		 * immediately after.
5030 		 */
5031 		if (*size_ret > inode->vfs_inode.i_size)
5032 			*size_ret = inode->vfs_inode.i_size;
5033 	}
5034 
5035 	btrfs_release_path(path);
5036 	return 0;
5037 }
5038 
5039 /*
5040  * At the moment we always log all xattrs. This is to figure out at log replay
5041  * time which xattrs must have their deletion replayed. If a xattr is missing
5042  * in the log tree and exists in the fs/subvol tree, we delete it. This is
5043  * because if a xattr is deleted, the inode is fsynced and a power failure
5044  * happens, causing the log to be replayed the next time the fs is mounted,
5045  * we want the xattr to not exist anymore (same behaviour as other filesystems
5046  * with a journal, ext3/4, xfs, f2fs, etc).
5047  */
btrfs_log_all_xattrs(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,struct btrfs_path * dst_path)5048 static int btrfs_log_all_xattrs(struct btrfs_trans_handle *trans,
5049 				struct btrfs_inode *inode,
5050 				struct btrfs_path *path,
5051 				struct btrfs_path *dst_path)
5052 {
5053 	struct btrfs_root *root = inode->root;
5054 	int ret;
5055 	struct btrfs_key key;
5056 	const u64 ino = btrfs_ino(inode);
5057 	int ins_nr = 0;
5058 	int start_slot = 0;
5059 	bool found_xattrs = false;
5060 
5061 	if (test_bit(BTRFS_INODE_NO_XATTRS, &inode->runtime_flags))
5062 		return 0;
5063 
5064 	key.objectid = ino;
5065 	key.type = BTRFS_XATTR_ITEM_KEY;
5066 	key.offset = 0;
5067 
5068 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5069 	if (ret < 0)
5070 		return ret;
5071 
5072 	while (true) {
5073 		int slot = path->slots[0];
5074 		struct extent_buffer *leaf = path->nodes[0];
5075 		int nritems = btrfs_header_nritems(leaf);
5076 
5077 		if (slot >= nritems) {
5078 			if (ins_nr > 0) {
5079 				ret = copy_items(trans, inode, dst_path, path,
5080 						 start_slot, ins_nr, 1, 0);
5081 				if (ret < 0)
5082 					return ret;
5083 				ins_nr = 0;
5084 			}
5085 			ret = btrfs_next_leaf(root, path);
5086 			if (ret < 0)
5087 				return ret;
5088 			else if (ret > 0)
5089 				break;
5090 			continue;
5091 		}
5092 
5093 		btrfs_item_key_to_cpu(leaf, &key, slot);
5094 		if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY)
5095 			break;
5096 
5097 		if (ins_nr == 0)
5098 			start_slot = slot;
5099 		ins_nr++;
5100 		path->slots[0]++;
5101 		found_xattrs = true;
5102 		cond_resched();
5103 	}
5104 	if (ins_nr > 0) {
5105 		ret = copy_items(trans, inode, dst_path, path,
5106 				 start_slot, ins_nr, 1, 0);
5107 		if (ret < 0)
5108 			return ret;
5109 	}
5110 
5111 	if (!found_xattrs)
5112 		set_bit(BTRFS_INODE_NO_XATTRS, &inode->runtime_flags);
5113 
5114 	return 0;
5115 }
5116 
5117 /*
5118  * When using the NO_HOLES feature if we punched a hole that causes the
5119  * deletion of entire leafs or all the extent items of the first leaf (the one
5120  * that contains the inode item and references) we may end up not processing
5121  * any extents, because there are no leafs with a generation matching the
5122  * current transaction that have extent items for our inode. So we need to find
5123  * if any holes exist and then log them. We also need to log holes after any
5124  * truncate operation that changes the inode's size.
5125  */
btrfs_log_holes(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path)5126 static int btrfs_log_holes(struct btrfs_trans_handle *trans,
5127 			   struct btrfs_inode *inode,
5128 			   struct btrfs_path *path)
5129 {
5130 	struct btrfs_root *root = inode->root;
5131 	struct btrfs_fs_info *fs_info = root->fs_info;
5132 	struct btrfs_key key;
5133 	const u64 ino = btrfs_ino(inode);
5134 	const u64 i_size = i_size_read(&inode->vfs_inode);
5135 	u64 prev_extent_end = 0;
5136 	int ret;
5137 
5138 	if (!btrfs_fs_incompat(fs_info, NO_HOLES) || i_size == 0)
5139 		return 0;
5140 
5141 	key.objectid = ino;
5142 	key.type = BTRFS_EXTENT_DATA_KEY;
5143 	key.offset = 0;
5144 
5145 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5146 	if (ret < 0)
5147 		return ret;
5148 
5149 	while (true) {
5150 		struct extent_buffer *leaf = path->nodes[0];
5151 
5152 		if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
5153 			ret = btrfs_next_leaf(root, path);
5154 			if (ret < 0)
5155 				return ret;
5156 			if (ret > 0) {
5157 				ret = 0;
5158 				break;
5159 			}
5160 			leaf = path->nodes[0];
5161 		}
5162 
5163 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
5164 		if (key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY)
5165 			break;
5166 
5167 		/* We have a hole, log it. */
5168 		if (prev_extent_end < key.offset) {
5169 			const u64 hole_len = key.offset - prev_extent_end;
5170 
5171 			/*
5172 			 * Release the path to avoid deadlocks with other code
5173 			 * paths that search the root while holding locks on
5174 			 * leafs from the log root.
5175 			 */
5176 			btrfs_release_path(path);
5177 			ret = btrfs_insert_hole_extent(trans, root->log_root,
5178 						       ino, prev_extent_end,
5179 						       hole_len);
5180 			if (ret < 0)
5181 				return ret;
5182 
5183 			/*
5184 			 * Search for the same key again in the root. Since it's
5185 			 * an extent item and we are holding the inode lock, the
5186 			 * key must still exist. If it doesn't just emit warning
5187 			 * and return an error to fall back to a transaction
5188 			 * commit.
5189 			 */
5190 			ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5191 			if (ret < 0)
5192 				return ret;
5193 			if (WARN_ON(ret > 0))
5194 				return -ENOENT;
5195 			leaf = path->nodes[0];
5196 		}
5197 
5198 		prev_extent_end = btrfs_file_extent_end(path);
5199 		path->slots[0]++;
5200 		cond_resched();
5201 	}
5202 
5203 	if (prev_extent_end < i_size) {
5204 		u64 hole_len;
5205 
5206 		btrfs_release_path(path);
5207 		hole_len = ALIGN(i_size - prev_extent_end, fs_info->sectorsize);
5208 		ret = btrfs_insert_hole_extent(trans, root->log_root, ino,
5209 					       prev_extent_end, hole_len);
5210 		if (ret < 0)
5211 			return ret;
5212 	}
5213 
5214 	return 0;
5215 }
5216 
5217 /*
5218  * When we are logging a new inode X, check if it doesn't have a reference that
5219  * matches the reference from some other inode Y created in a past transaction
5220  * and that was renamed in the current transaction. If we don't do this, then at
5221  * log replay time we can lose inode Y (and all its files if it's a directory):
5222  *
5223  * mkdir /mnt/x
5224  * echo "hello world" > /mnt/x/foobar
5225  * sync
5226  * mv /mnt/x /mnt/y
5227  * mkdir /mnt/x                 # or touch /mnt/x
5228  * xfs_io -c fsync /mnt/x
5229  * <power fail>
5230  * mount fs, trigger log replay
5231  *
5232  * After the log replay procedure, we would lose the first directory and all its
5233  * files (file foobar).
5234  * For the case where inode Y is not a directory we simply end up losing it:
5235  *
5236  * echo "123" > /mnt/foo
5237  * sync
5238  * mv /mnt/foo /mnt/bar
5239  * echo "abc" > /mnt/foo
5240  * xfs_io -c fsync /mnt/foo
5241  * <power fail>
5242  *
5243  * We also need this for cases where a snapshot entry is replaced by some other
5244  * entry (file or directory) otherwise we end up with an unreplayable log due to
5245  * attempts to delete the snapshot entry (entry of type BTRFS_ROOT_ITEM_KEY) as
5246  * if it were a regular entry:
5247  *
5248  * mkdir /mnt/x
5249  * btrfs subvolume snapshot /mnt /mnt/x/snap
5250  * btrfs subvolume delete /mnt/x/snap
5251  * rmdir /mnt/x
5252  * mkdir /mnt/x
5253  * fsync /mnt/x or fsync some new file inside it
5254  * <power fail>
5255  *
5256  * The snapshot delete, rmdir of x, mkdir of a new x and the fsync all happen in
5257  * the same transaction.
5258  */
btrfs_check_ref_name_override(struct extent_buffer * eb,const int slot,const struct btrfs_key * key,struct btrfs_inode * inode,u64 * other_ino,u64 * other_parent)5259 static int btrfs_check_ref_name_override(struct extent_buffer *eb,
5260 					 const int slot,
5261 					 const struct btrfs_key *key,
5262 					 struct btrfs_inode *inode,
5263 					 u64 *other_ino, u64 *other_parent)
5264 {
5265 	int ret;
5266 	struct btrfs_path *search_path;
5267 	char *name = NULL;
5268 	u32 name_len = 0;
5269 	u32 item_size = btrfs_item_size(eb, slot);
5270 	u32 cur_offset = 0;
5271 	unsigned long ptr = btrfs_item_ptr_offset(eb, slot);
5272 
5273 	search_path = btrfs_alloc_path();
5274 	if (!search_path)
5275 		return -ENOMEM;
5276 	search_path->search_commit_root = 1;
5277 	search_path->skip_locking = 1;
5278 
5279 	while (cur_offset < item_size) {
5280 		u64 parent;
5281 		u32 this_name_len;
5282 		u32 this_len;
5283 		unsigned long name_ptr;
5284 		struct btrfs_dir_item *di;
5285 
5286 		if (key->type == BTRFS_INODE_REF_KEY) {
5287 			struct btrfs_inode_ref *iref;
5288 
5289 			iref = (struct btrfs_inode_ref *)(ptr + cur_offset);
5290 			parent = key->offset;
5291 			this_name_len = btrfs_inode_ref_name_len(eb, iref);
5292 			name_ptr = (unsigned long)(iref + 1);
5293 			this_len = sizeof(*iref) + this_name_len;
5294 		} else {
5295 			struct btrfs_inode_extref *extref;
5296 
5297 			extref = (struct btrfs_inode_extref *)(ptr +
5298 							       cur_offset);
5299 			parent = btrfs_inode_extref_parent(eb, extref);
5300 			this_name_len = btrfs_inode_extref_name_len(eb, extref);
5301 			name_ptr = (unsigned long)&extref->name;
5302 			this_len = sizeof(*extref) + this_name_len;
5303 		}
5304 
5305 		if (this_name_len > name_len) {
5306 			char *new_name;
5307 
5308 			new_name = krealloc(name, this_name_len, GFP_NOFS);
5309 			if (!new_name) {
5310 				ret = -ENOMEM;
5311 				goto out;
5312 			}
5313 			name_len = this_name_len;
5314 			name = new_name;
5315 		}
5316 
5317 		read_extent_buffer(eb, name, name_ptr, this_name_len);
5318 		di = btrfs_lookup_dir_item(NULL, inode->root, search_path,
5319 				parent, name, this_name_len, 0);
5320 		if (di && !IS_ERR(di)) {
5321 			struct btrfs_key di_key;
5322 
5323 			btrfs_dir_item_key_to_cpu(search_path->nodes[0],
5324 						  di, &di_key);
5325 			if (di_key.type == BTRFS_INODE_ITEM_KEY) {
5326 				if (di_key.objectid != key->objectid) {
5327 					ret = 1;
5328 					*other_ino = di_key.objectid;
5329 					*other_parent = parent;
5330 				} else {
5331 					ret = 0;
5332 				}
5333 			} else {
5334 				ret = -EAGAIN;
5335 			}
5336 			goto out;
5337 		} else if (IS_ERR(di)) {
5338 			ret = PTR_ERR(di);
5339 			goto out;
5340 		}
5341 		btrfs_release_path(search_path);
5342 
5343 		cur_offset += this_len;
5344 	}
5345 	ret = 0;
5346 out:
5347 	btrfs_free_path(search_path);
5348 	kfree(name);
5349 	return ret;
5350 }
5351 
5352 /*
5353  * Check if we need to log an inode. This is used in contexts where while
5354  * logging an inode we need to log another inode (either that it exists or in
5355  * full mode). This is used instead of btrfs_inode_in_log() because the later
5356  * requires the inode to be in the log and have the log transaction committed,
5357  * while here we do not care if the log transaction was already committed - our
5358  * caller will commit the log later - and we want to avoid logging an inode
5359  * multiple times when multiple tasks have joined the same log transaction.
5360  */
need_log_inode(const struct btrfs_trans_handle * trans,const struct btrfs_inode * inode)5361 static bool need_log_inode(const struct btrfs_trans_handle *trans,
5362 			   const struct btrfs_inode *inode)
5363 {
5364 	/*
5365 	 * If a directory was not modified, no dentries added or removed, we can
5366 	 * and should avoid logging it.
5367 	 */
5368 	if (S_ISDIR(inode->vfs_inode.i_mode) && inode->last_trans < trans->transid)
5369 		return false;
5370 
5371 	/*
5372 	 * If this inode does not have new/updated/deleted xattrs since the last
5373 	 * time it was logged and is flagged as logged in the current transaction,
5374 	 * we can skip logging it. As for new/deleted names, those are updated in
5375 	 * the log by link/unlink/rename operations.
5376 	 * In case the inode was logged and then evicted and reloaded, its
5377 	 * logged_trans will be 0, in which case we have to fully log it since
5378 	 * logged_trans is a transient field, not persisted.
5379 	 */
5380 	if (inode->logged_trans == trans->transid &&
5381 	    !test_bit(BTRFS_INODE_COPY_EVERYTHING, &inode->runtime_flags))
5382 		return false;
5383 
5384 	return true;
5385 }
5386 
5387 struct btrfs_dir_list {
5388 	u64 ino;
5389 	struct list_head list;
5390 };
5391 
5392 /*
5393  * Log the inodes of the new dentries of a directory.
5394  * See process_dir_items_leaf() for details about why it is needed.
5395  * This is a recursive operation - if an existing dentry corresponds to a
5396  * directory, that directory's new entries are logged too (same behaviour as
5397  * ext3/4, xfs, f2fs, reiserfs, nilfs2). Note that when logging the inodes
5398  * the dentries point to we do not acquire their VFS lock, otherwise lockdep
5399  * complains about the following circular lock dependency / possible deadlock:
5400  *
5401  *        CPU0                                        CPU1
5402  *        ----                                        ----
5403  * lock(&type->i_mutex_dir_key#3/2);
5404  *                                            lock(sb_internal#2);
5405  *                                            lock(&type->i_mutex_dir_key#3/2);
5406  * lock(&sb->s_type->i_mutex_key#14);
5407  *
5408  * Where sb_internal is the lock (a counter that works as a lock) acquired by
5409  * sb_start_intwrite() in btrfs_start_transaction().
5410  * Not acquiring the VFS lock of the inodes is still safe because:
5411  *
5412  * 1) For regular files we log with a mode of LOG_INODE_EXISTS. It's possible
5413  *    that while logging the inode new references (names) are added or removed
5414  *    from the inode, leaving the logged inode item with a link count that does
5415  *    not match the number of logged inode reference items. This is fine because
5416  *    at log replay time we compute the real number of links and correct the
5417  *    link count in the inode item (see replay_one_buffer() and
5418  *    link_to_fixup_dir());
5419  *
5420  * 2) For directories we log with a mode of LOG_INODE_ALL. It's possible that
5421  *    while logging the inode's items new index items (key type
5422  *    BTRFS_DIR_INDEX_KEY) are added to fs/subvol tree and the logged inode item
5423  *    has a size that doesn't match the sum of the lengths of all the logged
5424  *    names - this is ok, not a problem, because at log replay time we set the
5425  *    directory's i_size to the correct value (see replay_one_name() and
5426  *    do_overwrite_item()).
5427  */
log_new_dir_dentries(struct btrfs_trans_handle * trans,struct btrfs_inode * start_inode,struct btrfs_log_ctx * ctx)5428 static int log_new_dir_dentries(struct btrfs_trans_handle *trans,
5429 				struct btrfs_inode *start_inode,
5430 				struct btrfs_log_ctx *ctx)
5431 {
5432 	struct btrfs_root *root = start_inode->root;
5433 	struct btrfs_fs_info *fs_info = root->fs_info;
5434 	struct btrfs_path *path;
5435 	LIST_HEAD(dir_list);
5436 	struct btrfs_dir_list *dir_elem;
5437 	u64 ino = btrfs_ino(start_inode);
5438 	int ret = 0;
5439 
5440 	/*
5441 	 * If we are logging a new name, as part of a link or rename operation,
5442 	 * don't bother logging new dentries, as we just want to log the names
5443 	 * of an inode and that any new parents exist.
5444 	 */
5445 	if (ctx->logging_new_name)
5446 		return 0;
5447 
5448 	path = btrfs_alloc_path();
5449 	if (!path)
5450 		return -ENOMEM;
5451 
5452 	while (true) {
5453 		struct extent_buffer *leaf;
5454 		struct btrfs_key min_key;
5455 		bool continue_curr_inode = true;
5456 		int nritems;
5457 		int i;
5458 
5459 		min_key.objectid = ino;
5460 		min_key.type = BTRFS_DIR_INDEX_KEY;
5461 		min_key.offset = 0;
5462 again:
5463 		btrfs_release_path(path);
5464 		ret = btrfs_search_forward(root, &min_key, path, trans->transid);
5465 		if (ret < 0) {
5466 			break;
5467 		} else if (ret > 0) {
5468 			ret = 0;
5469 			goto next;
5470 		}
5471 
5472 		leaf = path->nodes[0];
5473 		nritems = btrfs_header_nritems(leaf);
5474 		for (i = path->slots[0]; i < nritems; i++) {
5475 			struct btrfs_dir_item *di;
5476 			struct btrfs_key di_key;
5477 			struct inode *di_inode;
5478 			int log_mode = LOG_INODE_EXISTS;
5479 			int type;
5480 
5481 			btrfs_item_key_to_cpu(leaf, &min_key, i);
5482 			if (min_key.objectid != ino ||
5483 			    min_key.type != BTRFS_DIR_INDEX_KEY) {
5484 				continue_curr_inode = false;
5485 				break;
5486 			}
5487 
5488 			di = btrfs_item_ptr(leaf, i, struct btrfs_dir_item);
5489 			type = btrfs_dir_type(leaf, di);
5490 			if (btrfs_dir_transid(leaf, di) < trans->transid)
5491 				continue;
5492 			btrfs_dir_item_key_to_cpu(leaf, di, &di_key);
5493 			if (di_key.type == BTRFS_ROOT_ITEM_KEY)
5494 				continue;
5495 
5496 			btrfs_release_path(path);
5497 			di_inode = btrfs_iget(fs_info->sb, di_key.objectid, root);
5498 			if (IS_ERR(di_inode)) {
5499 				ret = PTR_ERR(di_inode);
5500 				goto out;
5501 			}
5502 
5503 			if (!need_log_inode(trans, BTRFS_I(di_inode))) {
5504 				btrfs_add_delayed_iput(di_inode);
5505 				break;
5506 			}
5507 
5508 			ctx->log_new_dentries = false;
5509 			if (type == BTRFS_FT_DIR)
5510 				log_mode = LOG_INODE_ALL;
5511 			ret = btrfs_log_inode(trans, BTRFS_I(di_inode),
5512 					      log_mode, ctx);
5513 			btrfs_add_delayed_iput(di_inode);
5514 			if (ret)
5515 				goto out;
5516 			if (ctx->log_new_dentries) {
5517 				dir_elem = kmalloc(sizeof(*dir_elem), GFP_NOFS);
5518 				if (!dir_elem) {
5519 					ret = -ENOMEM;
5520 					goto out;
5521 				}
5522 				dir_elem->ino = di_key.objectid;
5523 				list_add_tail(&dir_elem->list, &dir_list);
5524 			}
5525 			break;
5526 		}
5527 
5528 		if (continue_curr_inode && min_key.offset < (u64)-1) {
5529 			min_key.offset++;
5530 			goto again;
5531 		}
5532 
5533 next:
5534 		if (list_empty(&dir_list))
5535 			break;
5536 
5537 		dir_elem = list_first_entry(&dir_list, struct btrfs_dir_list, list);
5538 		ino = dir_elem->ino;
5539 		list_del(&dir_elem->list);
5540 		kfree(dir_elem);
5541 	}
5542 out:
5543 	btrfs_free_path(path);
5544 	if (ret) {
5545 		struct btrfs_dir_list *next;
5546 
5547 		list_for_each_entry_safe(dir_elem, next, &dir_list, list)
5548 			kfree(dir_elem);
5549 	}
5550 
5551 	return ret;
5552 }
5553 
5554 struct btrfs_ino_list {
5555 	u64 ino;
5556 	u64 parent;
5557 	struct list_head list;
5558 };
5559 
free_conflicting_inodes(struct btrfs_log_ctx * ctx)5560 static void free_conflicting_inodes(struct btrfs_log_ctx *ctx)
5561 {
5562 	struct btrfs_ino_list *curr;
5563 	struct btrfs_ino_list *next;
5564 
5565 	list_for_each_entry_safe(curr, next, &ctx->conflict_inodes, list) {
5566 		list_del(&curr->list);
5567 		kfree(curr);
5568 	}
5569 }
5570 
conflicting_inode_is_dir(struct btrfs_root * root,u64 ino,struct btrfs_path * path)5571 static int conflicting_inode_is_dir(struct btrfs_root *root, u64 ino,
5572 				    struct btrfs_path *path)
5573 {
5574 	struct btrfs_key key;
5575 	int ret;
5576 
5577 	key.objectid = ino;
5578 	key.type = BTRFS_INODE_ITEM_KEY;
5579 	key.offset = 0;
5580 
5581 	path->search_commit_root = 1;
5582 	path->skip_locking = 1;
5583 
5584 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5585 	if (WARN_ON_ONCE(ret > 0)) {
5586 		/*
5587 		 * We have previously found the inode through the commit root
5588 		 * so this should not happen. If it does, just error out and
5589 		 * fallback to a transaction commit.
5590 		 */
5591 		ret = -ENOENT;
5592 	} else if (ret == 0) {
5593 		struct btrfs_inode_item *item;
5594 
5595 		item = btrfs_item_ptr(path->nodes[0], path->slots[0],
5596 				      struct btrfs_inode_item);
5597 		if (S_ISDIR(btrfs_inode_mode(path->nodes[0], item)))
5598 			ret = 1;
5599 	}
5600 
5601 	btrfs_release_path(path);
5602 	path->search_commit_root = 0;
5603 	path->skip_locking = 0;
5604 
5605 	return ret;
5606 }
5607 
add_conflicting_inode(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,u64 ino,u64 parent,struct btrfs_log_ctx * ctx)5608 static int add_conflicting_inode(struct btrfs_trans_handle *trans,
5609 				 struct btrfs_root *root,
5610 				 struct btrfs_path *path,
5611 				 u64 ino, u64 parent,
5612 				 struct btrfs_log_ctx *ctx)
5613 {
5614 	struct btrfs_ino_list *ino_elem;
5615 	struct inode *inode;
5616 
5617 	/*
5618 	 * It's rare to have a lot of conflicting inodes, in practice it is not
5619 	 * common to have more than 1 or 2. We don't want to collect too many,
5620 	 * as we could end up logging too many inodes (even if only in
5621 	 * LOG_INODE_EXISTS mode) and slow down other fsyncs or transaction
5622 	 * commits.
5623 	 */
5624 	if (ctx->num_conflict_inodes >= MAX_CONFLICT_INODES) {
5625 		btrfs_set_log_full_commit(trans);
5626 		return BTRFS_LOG_FORCE_COMMIT;
5627 	}
5628 
5629 	inode = btrfs_iget(root->fs_info->sb, ino, root);
5630 	/*
5631 	 * If the other inode that had a conflicting dir entry was deleted in
5632 	 * the current transaction then we either:
5633 	 *
5634 	 * 1) Log the parent directory (later after adding it to the list) if
5635 	 *    the inode is a directory. This is because it may be a deleted
5636 	 *    subvolume/snapshot or it may be a regular directory that had
5637 	 *    deleted subvolumes/snapshots (or subdirectories that had them),
5638 	 *    and at the moment we can't deal with dropping subvolumes/snapshots
5639 	 *    during log replay. So we just log the parent, which will result in
5640 	 *    a fallback to a transaction commit if we are dealing with those
5641 	 *    cases (last_unlink_trans will match the current transaction);
5642 	 *
5643 	 * 2) Do nothing if it's not a directory. During log replay we simply
5644 	 *    unlink the conflicting dentry from the parent directory and then
5645 	 *    add the dentry for our inode. Like this we can avoid logging the
5646 	 *    parent directory (and maybe fallback to a transaction commit in
5647 	 *    case it has a last_unlink_trans == trans->transid, due to moving
5648 	 *    some inode from it to some other directory).
5649 	 */
5650 	if (IS_ERR(inode)) {
5651 		int ret = PTR_ERR(inode);
5652 
5653 		if (ret != -ENOENT)
5654 			return ret;
5655 
5656 		ret = conflicting_inode_is_dir(root, ino, path);
5657 		/* Not a directory or we got an error. */
5658 		if (ret <= 0)
5659 			return ret;
5660 
5661 		/* Conflicting inode is a directory, so we'll log its parent. */
5662 		ino_elem = kmalloc(sizeof(*ino_elem), GFP_NOFS);
5663 		if (!ino_elem)
5664 			return -ENOMEM;
5665 		ino_elem->ino = ino;
5666 		ino_elem->parent = parent;
5667 		list_add_tail(&ino_elem->list, &ctx->conflict_inodes);
5668 		ctx->num_conflict_inodes++;
5669 
5670 		return 0;
5671 	}
5672 
5673 	/*
5674 	 * If the inode was already logged skip it - otherwise we can hit an
5675 	 * infinite loop. Example:
5676 	 *
5677 	 * From the commit root (previous transaction) we have the following
5678 	 * inodes:
5679 	 *
5680 	 * inode 257 a directory
5681 	 * inode 258 with references "zz" and "zz_link" on inode 257
5682 	 * inode 259 with reference "a" on inode 257
5683 	 *
5684 	 * And in the current (uncommitted) transaction we have:
5685 	 *
5686 	 * inode 257 a directory, unchanged
5687 	 * inode 258 with references "a" and "a2" on inode 257
5688 	 * inode 259 with reference "zz_link" on inode 257
5689 	 * inode 261 with reference "zz" on inode 257
5690 	 *
5691 	 * When logging inode 261 the following infinite loop could
5692 	 * happen if we don't skip already logged inodes:
5693 	 *
5694 	 * - we detect inode 258 as a conflicting inode, with inode 261
5695 	 *   on reference "zz", and log it;
5696 	 *
5697 	 * - we detect inode 259 as a conflicting inode, with inode 258
5698 	 *   on reference "a", and log it;
5699 	 *
5700 	 * - we detect inode 258 as a conflicting inode, with inode 259
5701 	 *   on reference "zz_link", and log it - again! After this we
5702 	 *   repeat the above steps forever.
5703 	 *
5704 	 * Here we can use need_log_inode() because we only need to log the
5705 	 * inode in LOG_INODE_EXISTS mode and rename operations update the log,
5706 	 * so that the log ends up with the new name and without the old name.
5707 	 */
5708 	if (!need_log_inode(trans, BTRFS_I(inode))) {
5709 		btrfs_add_delayed_iput(inode);
5710 		return 0;
5711 	}
5712 
5713 	btrfs_add_delayed_iput(inode);
5714 
5715 	ino_elem = kmalloc(sizeof(*ino_elem), GFP_NOFS);
5716 	if (!ino_elem)
5717 		return -ENOMEM;
5718 	ino_elem->ino = ino;
5719 	ino_elem->parent = parent;
5720 	list_add_tail(&ino_elem->list, &ctx->conflict_inodes);
5721 	ctx->num_conflict_inodes++;
5722 
5723 	return 0;
5724 }
5725 
log_conflicting_inodes(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_log_ctx * ctx)5726 static int log_conflicting_inodes(struct btrfs_trans_handle *trans,
5727 				  struct btrfs_root *root,
5728 				  struct btrfs_log_ctx *ctx)
5729 {
5730 	struct btrfs_fs_info *fs_info = root->fs_info;
5731 	int ret = 0;
5732 
5733 	/*
5734 	 * Conflicting inodes are logged by the first call to btrfs_log_inode(),
5735 	 * otherwise we could have unbounded recursion of btrfs_log_inode()
5736 	 * calls. This check guarantees we can have only 1 level of recursion.
5737 	 */
5738 	if (ctx->logging_conflict_inodes)
5739 		return 0;
5740 
5741 	ctx->logging_conflict_inodes = true;
5742 
5743 	/*
5744 	 * New conflicting inodes may be found and added to the list while we
5745 	 * are logging a conflicting inode, so keep iterating while the list is
5746 	 * not empty.
5747 	 */
5748 	while (!list_empty(&ctx->conflict_inodes)) {
5749 		struct btrfs_ino_list *curr;
5750 		struct inode *inode;
5751 		u64 ino;
5752 		u64 parent;
5753 
5754 		curr = list_first_entry(&ctx->conflict_inodes,
5755 					struct btrfs_ino_list, list);
5756 		ino = curr->ino;
5757 		parent = curr->parent;
5758 		list_del(&curr->list);
5759 		kfree(curr);
5760 
5761 		inode = btrfs_iget(fs_info->sb, ino, root);
5762 		/*
5763 		 * If the other inode that had a conflicting dir entry was
5764 		 * deleted in the current transaction, we need to log its parent
5765 		 * directory. See the comment at add_conflicting_inode().
5766 		 */
5767 		if (IS_ERR(inode)) {
5768 			ret = PTR_ERR(inode);
5769 			if (ret != -ENOENT)
5770 				break;
5771 
5772 			inode = btrfs_iget(fs_info->sb, parent, root);
5773 			if (IS_ERR(inode)) {
5774 				ret = PTR_ERR(inode);
5775 				break;
5776 			}
5777 
5778 			/*
5779 			 * Always log the directory, we cannot make this
5780 			 * conditional on need_log_inode() because the directory
5781 			 * might have been logged in LOG_INODE_EXISTS mode or
5782 			 * the dir index of the conflicting inode is not in a
5783 			 * dir index key range logged for the directory. So we
5784 			 * must make sure the deletion is recorded.
5785 			 */
5786 			ret = btrfs_log_inode(trans, BTRFS_I(inode),
5787 					      LOG_INODE_ALL, ctx);
5788 			btrfs_add_delayed_iput(inode);
5789 			if (ret)
5790 				break;
5791 			continue;
5792 		}
5793 
5794 		/*
5795 		 * Here we can use need_log_inode() because we only need to log
5796 		 * the inode in LOG_INODE_EXISTS mode and rename operations
5797 		 * update the log, so that the log ends up with the new name and
5798 		 * without the old name.
5799 		 *
5800 		 * We did this check at add_conflicting_inode(), but here we do
5801 		 * it again because if some other task logged the inode after
5802 		 * that, we can avoid doing it again.
5803 		 */
5804 		if (!need_log_inode(trans, BTRFS_I(inode))) {
5805 			btrfs_add_delayed_iput(inode);
5806 			continue;
5807 		}
5808 
5809 		/*
5810 		 * We are safe logging the other inode without acquiring its
5811 		 * lock as long as we log with the LOG_INODE_EXISTS mode. We
5812 		 * are safe against concurrent renames of the other inode as
5813 		 * well because during a rename we pin the log and update the
5814 		 * log with the new name before we unpin it.
5815 		 */
5816 		ret = btrfs_log_inode(trans, BTRFS_I(inode), LOG_INODE_EXISTS, ctx);
5817 		btrfs_add_delayed_iput(inode);
5818 		if (ret)
5819 			break;
5820 	}
5821 
5822 	ctx->logging_conflict_inodes = false;
5823 	if (ret)
5824 		free_conflicting_inodes(ctx);
5825 
5826 	return ret;
5827 }
5828 
copy_inode_items_to_log(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_key * min_key,const struct btrfs_key * max_key,struct btrfs_path * path,struct btrfs_path * dst_path,const u64 logged_isize,const int inode_only,struct btrfs_log_ctx * ctx,bool * need_log_inode_item)5829 static int copy_inode_items_to_log(struct btrfs_trans_handle *trans,
5830 				   struct btrfs_inode *inode,
5831 				   struct btrfs_key *min_key,
5832 				   const struct btrfs_key *max_key,
5833 				   struct btrfs_path *path,
5834 				   struct btrfs_path *dst_path,
5835 				   const u64 logged_isize,
5836 				   const int inode_only,
5837 				   struct btrfs_log_ctx *ctx,
5838 				   bool *need_log_inode_item)
5839 {
5840 	const u64 i_size = i_size_read(&inode->vfs_inode);
5841 	struct btrfs_root *root = inode->root;
5842 	int ins_start_slot = 0;
5843 	int ins_nr = 0;
5844 	int ret;
5845 
5846 	while (1) {
5847 		ret = btrfs_search_forward(root, min_key, path, trans->transid);
5848 		if (ret < 0)
5849 			return ret;
5850 		if (ret > 0) {
5851 			ret = 0;
5852 			break;
5853 		}
5854 again:
5855 		/* Note, ins_nr might be > 0 here, cleanup outside the loop */
5856 		if (min_key->objectid != max_key->objectid)
5857 			break;
5858 		if (min_key->type > max_key->type)
5859 			break;
5860 
5861 		if (min_key->type == BTRFS_INODE_ITEM_KEY) {
5862 			*need_log_inode_item = false;
5863 		} else if (min_key->type == BTRFS_EXTENT_DATA_KEY &&
5864 			   min_key->offset >= i_size) {
5865 			/*
5866 			 * Extents at and beyond eof are logged with
5867 			 * btrfs_log_prealloc_extents().
5868 			 * Only regular files have BTRFS_EXTENT_DATA_KEY keys,
5869 			 * and no keys greater than that, so bail out.
5870 			 */
5871 			break;
5872 		} else if ((min_key->type == BTRFS_INODE_REF_KEY ||
5873 			    min_key->type == BTRFS_INODE_EXTREF_KEY) &&
5874 			   (inode->generation == trans->transid ||
5875 			    ctx->logging_conflict_inodes)) {
5876 			u64 other_ino = 0;
5877 			u64 other_parent = 0;
5878 
5879 			ret = btrfs_check_ref_name_override(path->nodes[0],
5880 					path->slots[0], min_key, inode,
5881 					&other_ino, &other_parent);
5882 			if (ret < 0) {
5883 				return ret;
5884 			} else if (ret > 0 &&
5885 				   other_ino != btrfs_ino(BTRFS_I(ctx->inode))) {
5886 				if (ins_nr > 0) {
5887 					ins_nr++;
5888 				} else {
5889 					ins_nr = 1;
5890 					ins_start_slot = path->slots[0];
5891 				}
5892 				ret = copy_items(trans, inode, dst_path, path,
5893 						 ins_start_slot, ins_nr,
5894 						 inode_only, logged_isize);
5895 				if (ret < 0)
5896 					return ret;
5897 				ins_nr = 0;
5898 
5899 				btrfs_release_path(path);
5900 				ret = add_conflicting_inode(trans, root, path,
5901 							    other_ino,
5902 							    other_parent, ctx);
5903 				if (ret)
5904 					return ret;
5905 				goto next_key;
5906 			}
5907 		} else if (min_key->type == BTRFS_XATTR_ITEM_KEY) {
5908 			/* Skip xattrs, logged later with btrfs_log_all_xattrs() */
5909 			if (ins_nr == 0)
5910 				goto next_slot;
5911 			ret = copy_items(trans, inode, dst_path, path,
5912 					 ins_start_slot,
5913 					 ins_nr, inode_only, logged_isize);
5914 			if (ret < 0)
5915 				return ret;
5916 			ins_nr = 0;
5917 			goto next_slot;
5918 		}
5919 
5920 		if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
5921 			ins_nr++;
5922 			goto next_slot;
5923 		} else if (!ins_nr) {
5924 			ins_start_slot = path->slots[0];
5925 			ins_nr = 1;
5926 			goto next_slot;
5927 		}
5928 
5929 		ret = copy_items(trans, inode, dst_path, path, ins_start_slot,
5930 				 ins_nr, inode_only, logged_isize);
5931 		if (ret < 0)
5932 			return ret;
5933 		ins_nr = 1;
5934 		ins_start_slot = path->slots[0];
5935 next_slot:
5936 		path->slots[0]++;
5937 		if (path->slots[0] < btrfs_header_nritems(path->nodes[0])) {
5938 			btrfs_item_key_to_cpu(path->nodes[0], min_key,
5939 					      path->slots[0]);
5940 			goto again;
5941 		}
5942 		if (ins_nr) {
5943 			ret = copy_items(trans, inode, dst_path, path,
5944 					 ins_start_slot, ins_nr, inode_only,
5945 					 logged_isize);
5946 			if (ret < 0)
5947 				return ret;
5948 			ins_nr = 0;
5949 		}
5950 		btrfs_release_path(path);
5951 next_key:
5952 		if (min_key->offset < (u64)-1) {
5953 			min_key->offset++;
5954 		} else if (min_key->type < max_key->type) {
5955 			min_key->type++;
5956 			min_key->offset = 0;
5957 		} else {
5958 			break;
5959 		}
5960 
5961 		/*
5962 		 * We may process many leaves full of items for our inode, so
5963 		 * avoid monopolizing a cpu for too long by rescheduling while
5964 		 * not holding locks on any tree.
5965 		 */
5966 		cond_resched();
5967 	}
5968 	if (ins_nr) {
5969 		ret = copy_items(trans, inode, dst_path, path, ins_start_slot,
5970 				 ins_nr, inode_only, logged_isize);
5971 		if (ret)
5972 			return ret;
5973 	}
5974 
5975 	if (inode_only == LOG_INODE_ALL && S_ISREG(inode->vfs_inode.i_mode)) {
5976 		/*
5977 		 * Release the path because otherwise we might attempt to double
5978 		 * lock the same leaf with btrfs_log_prealloc_extents() below.
5979 		 */
5980 		btrfs_release_path(path);
5981 		ret = btrfs_log_prealloc_extents(trans, inode, dst_path);
5982 	}
5983 
5984 	return ret;
5985 }
5986 
insert_delayed_items_batch(struct btrfs_trans_handle * trans,struct btrfs_root * log,struct btrfs_path * path,const struct btrfs_item_batch * batch,const struct btrfs_delayed_item * first_item)5987 static int insert_delayed_items_batch(struct btrfs_trans_handle *trans,
5988 				      struct btrfs_root *log,
5989 				      struct btrfs_path *path,
5990 				      const struct btrfs_item_batch *batch,
5991 				      const struct btrfs_delayed_item *first_item)
5992 {
5993 	const struct btrfs_delayed_item *curr = first_item;
5994 	int ret;
5995 
5996 	ret = btrfs_insert_empty_items(trans, log, path, batch);
5997 	if (ret)
5998 		return ret;
5999 
6000 	for (int i = 0; i < batch->nr; i++) {
6001 		char *data_ptr;
6002 
6003 		data_ptr = btrfs_item_ptr(path->nodes[0], path->slots[0], char);
6004 		write_extent_buffer(path->nodes[0], &curr->data,
6005 				    (unsigned long)data_ptr, curr->data_len);
6006 		curr = list_next_entry(curr, log_list);
6007 		path->slots[0]++;
6008 	}
6009 
6010 	btrfs_release_path(path);
6011 
6012 	return 0;
6013 }
6014 
log_delayed_insertion_items(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,const struct list_head * delayed_ins_list,struct btrfs_log_ctx * ctx)6015 static int log_delayed_insertion_items(struct btrfs_trans_handle *trans,
6016 				       struct btrfs_inode *inode,
6017 				       struct btrfs_path *path,
6018 				       const struct list_head *delayed_ins_list,
6019 				       struct btrfs_log_ctx *ctx)
6020 {
6021 	/* 195 (4095 bytes of keys and sizes) fits in a single 4K page. */
6022 	const int max_batch_size = 195;
6023 	const int leaf_data_size = BTRFS_LEAF_DATA_SIZE(trans->fs_info);
6024 	const u64 ino = btrfs_ino(inode);
6025 	struct btrfs_root *log = inode->root->log_root;
6026 	struct btrfs_item_batch batch = {
6027 		.nr = 0,
6028 		.total_data_size = 0,
6029 	};
6030 	const struct btrfs_delayed_item *first = NULL;
6031 	const struct btrfs_delayed_item *curr;
6032 	char *ins_data;
6033 	struct btrfs_key *ins_keys;
6034 	u32 *ins_sizes;
6035 	u64 curr_batch_size = 0;
6036 	int batch_idx = 0;
6037 	int ret;
6038 
6039 	/* We are adding dir index items to the log tree. */
6040 	lockdep_assert_held(&inode->log_mutex);
6041 
6042 	/*
6043 	 * We collect delayed items before copying index keys from the subvolume
6044 	 * to the log tree. However just after we collected them, they may have
6045 	 * been flushed (all of them or just some of them), and therefore we
6046 	 * could have copied them from the subvolume tree to the log tree.
6047 	 * So find the first delayed item that was not yet logged (they are
6048 	 * sorted by index number).
6049 	 */
6050 	list_for_each_entry(curr, delayed_ins_list, log_list) {
6051 		if (curr->index > inode->last_dir_index_offset) {
6052 			first = curr;
6053 			break;
6054 		}
6055 	}
6056 
6057 	/* Empty list or all delayed items were already logged. */
6058 	if (!first)
6059 		return 0;
6060 
6061 	ins_data = kmalloc(max_batch_size * sizeof(u32) +
6062 			   max_batch_size * sizeof(struct btrfs_key), GFP_NOFS);
6063 	if (!ins_data)
6064 		return -ENOMEM;
6065 	ins_sizes = (u32 *)ins_data;
6066 	batch.data_sizes = ins_sizes;
6067 	ins_keys = (struct btrfs_key *)(ins_data + max_batch_size * sizeof(u32));
6068 	batch.keys = ins_keys;
6069 
6070 	curr = first;
6071 	while (!list_entry_is_head(curr, delayed_ins_list, log_list)) {
6072 		const u32 curr_size = curr->data_len + sizeof(struct btrfs_item);
6073 
6074 		if (curr_batch_size + curr_size > leaf_data_size ||
6075 		    batch.nr == max_batch_size) {
6076 			ret = insert_delayed_items_batch(trans, log, path,
6077 							 &batch, first);
6078 			if (ret)
6079 				goto out;
6080 			batch_idx = 0;
6081 			batch.nr = 0;
6082 			batch.total_data_size = 0;
6083 			curr_batch_size = 0;
6084 			first = curr;
6085 		}
6086 
6087 		ins_sizes[batch_idx] = curr->data_len;
6088 		ins_keys[batch_idx].objectid = ino;
6089 		ins_keys[batch_idx].type = BTRFS_DIR_INDEX_KEY;
6090 		ins_keys[batch_idx].offset = curr->index;
6091 		curr_batch_size += curr_size;
6092 		batch.total_data_size += curr->data_len;
6093 		batch.nr++;
6094 		batch_idx++;
6095 		curr = list_next_entry(curr, log_list);
6096 	}
6097 
6098 	ASSERT(batch.nr >= 1);
6099 	ret = insert_delayed_items_batch(trans, log, path, &batch, first);
6100 
6101 	curr = list_last_entry(delayed_ins_list, struct btrfs_delayed_item,
6102 			       log_list);
6103 	inode->last_dir_index_offset = curr->index;
6104 out:
6105 	kfree(ins_data);
6106 
6107 	return ret;
6108 }
6109 
log_delayed_deletions_full(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,const struct list_head * delayed_del_list,struct btrfs_log_ctx * ctx)6110 static int log_delayed_deletions_full(struct btrfs_trans_handle *trans,
6111 				      struct btrfs_inode *inode,
6112 				      struct btrfs_path *path,
6113 				      const struct list_head *delayed_del_list,
6114 				      struct btrfs_log_ctx *ctx)
6115 {
6116 	const u64 ino = btrfs_ino(inode);
6117 	const struct btrfs_delayed_item *curr;
6118 
6119 	curr = list_first_entry(delayed_del_list, struct btrfs_delayed_item,
6120 				log_list);
6121 
6122 	while (!list_entry_is_head(curr, delayed_del_list, log_list)) {
6123 		u64 first_dir_index = curr->index;
6124 		u64 last_dir_index;
6125 		const struct btrfs_delayed_item *next;
6126 		int ret;
6127 
6128 		/*
6129 		 * Find a range of consecutive dir index items to delete. Like
6130 		 * this we log a single dir range item spanning several contiguous
6131 		 * dir items instead of logging one range item per dir index item.
6132 		 */
6133 		next = list_next_entry(curr, log_list);
6134 		while (!list_entry_is_head(next, delayed_del_list, log_list)) {
6135 			if (next->index != curr->index + 1)
6136 				break;
6137 			curr = next;
6138 			next = list_next_entry(next, log_list);
6139 		}
6140 
6141 		last_dir_index = curr->index;
6142 		ASSERT(last_dir_index >= first_dir_index);
6143 
6144 		ret = insert_dir_log_key(trans, inode->root->log_root, path,
6145 					 ino, first_dir_index, last_dir_index);
6146 		if (ret)
6147 			return ret;
6148 		curr = list_next_entry(curr, log_list);
6149 	}
6150 
6151 	return 0;
6152 }
6153 
batch_delete_dir_index_items(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,struct btrfs_log_ctx * ctx,const struct list_head * delayed_del_list,const struct btrfs_delayed_item * first,const struct btrfs_delayed_item ** last_ret)6154 static int batch_delete_dir_index_items(struct btrfs_trans_handle *trans,
6155 					struct btrfs_inode *inode,
6156 					struct btrfs_path *path,
6157 					struct btrfs_log_ctx *ctx,
6158 					const struct list_head *delayed_del_list,
6159 					const struct btrfs_delayed_item *first,
6160 					const struct btrfs_delayed_item **last_ret)
6161 {
6162 	const struct btrfs_delayed_item *next;
6163 	struct extent_buffer *leaf = path->nodes[0];
6164 	const int last_slot = btrfs_header_nritems(leaf) - 1;
6165 	int slot = path->slots[0] + 1;
6166 	const u64 ino = btrfs_ino(inode);
6167 
6168 	next = list_next_entry(first, log_list);
6169 
6170 	while (slot < last_slot &&
6171 	       !list_entry_is_head(next, delayed_del_list, log_list)) {
6172 		struct btrfs_key key;
6173 
6174 		btrfs_item_key_to_cpu(leaf, &key, slot);
6175 		if (key.objectid != ino ||
6176 		    key.type != BTRFS_DIR_INDEX_KEY ||
6177 		    key.offset != next->index)
6178 			break;
6179 
6180 		slot++;
6181 		*last_ret = next;
6182 		next = list_next_entry(next, log_list);
6183 	}
6184 
6185 	return btrfs_del_items(trans, inode->root->log_root, path,
6186 			       path->slots[0], slot - path->slots[0]);
6187 }
6188 
log_delayed_deletions_incremental(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,const struct list_head * delayed_del_list,struct btrfs_log_ctx * ctx)6189 static int log_delayed_deletions_incremental(struct btrfs_trans_handle *trans,
6190 					     struct btrfs_inode *inode,
6191 					     struct btrfs_path *path,
6192 					     const struct list_head *delayed_del_list,
6193 					     struct btrfs_log_ctx *ctx)
6194 {
6195 	struct btrfs_root *log = inode->root->log_root;
6196 	const struct btrfs_delayed_item *curr;
6197 	u64 last_range_start;
6198 	u64 last_range_end = 0;
6199 	struct btrfs_key key;
6200 
6201 	key.objectid = btrfs_ino(inode);
6202 	key.type = BTRFS_DIR_INDEX_KEY;
6203 	curr = list_first_entry(delayed_del_list, struct btrfs_delayed_item,
6204 				log_list);
6205 
6206 	while (!list_entry_is_head(curr, delayed_del_list, log_list)) {
6207 		const struct btrfs_delayed_item *last = curr;
6208 		u64 first_dir_index = curr->index;
6209 		u64 last_dir_index;
6210 		bool deleted_items = false;
6211 		int ret;
6212 
6213 		key.offset = curr->index;
6214 		ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
6215 		if (ret < 0) {
6216 			return ret;
6217 		} else if (ret == 0) {
6218 			ret = batch_delete_dir_index_items(trans, inode, path, ctx,
6219 							   delayed_del_list, curr,
6220 							   &last);
6221 			if (ret)
6222 				return ret;
6223 			deleted_items = true;
6224 		}
6225 
6226 		btrfs_release_path(path);
6227 
6228 		/*
6229 		 * If we deleted items from the leaf, it means we have a range
6230 		 * item logging their range, so no need to add one or update an
6231 		 * existing one. Otherwise we have to log a dir range item.
6232 		 */
6233 		if (deleted_items)
6234 			goto next_batch;
6235 
6236 		last_dir_index = last->index;
6237 		ASSERT(last_dir_index >= first_dir_index);
6238 		/*
6239 		 * If this range starts right after where the previous one ends,
6240 		 * then we want to reuse the previous range item and change its
6241 		 * end offset to the end of this range. This is just to minimize
6242 		 * leaf space usage, by avoiding adding a new range item.
6243 		 */
6244 		if (last_range_end != 0 && first_dir_index == last_range_end + 1)
6245 			first_dir_index = last_range_start;
6246 
6247 		ret = insert_dir_log_key(trans, log, path, key.objectid,
6248 					 first_dir_index, last_dir_index);
6249 		if (ret)
6250 			return ret;
6251 
6252 		last_range_start = first_dir_index;
6253 		last_range_end = last_dir_index;
6254 next_batch:
6255 		curr = list_next_entry(last, log_list);
6256 	}
6257 
6258 	return 0;
6259 }
6260 
log_delayed_deletion_items(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_path * path,const struct list_head * delayed_del_list,struct btrfs_log_ctx * ctx)6261 static int log_delayed_deletion_items(struct btrfs_trans_handle *trans,
6262 				      struct btrfs_inode *inode,
6263 				      struct btrfs_path *path,
6264 				      const struct list_head *delayed_del_list,
6265 				      struct btrfs_log_ctx *ctx)
6266 {
6267 	/*
6268 	 * We are deleting dir index items from the log tree or adding range
6269 	 * items to it.
6270 	 */
6271 	lockdep_assert_held(&inode->log_mutex);
6272 
6273 	if (list_empty(delayed_del_list))
6274 		return 0;
6275 
6276 	if (ctx->logged_before)
6277 		return log_delayed_deletions_incremental(trans, inode, path,
6278 							 delayed_del_list, ctx);
6279 
6280 	return log_delayed_deletions_full(trans, inode, path, delayed_del_list,
6281 					  ctx);
6282 }
6283 
6284 /*
6285  * Similar logic as for log_new_dir_dentries(), but it iterates over the delayed
6286  * items instead of the subvolume tree.
6287  */
log_new_delayed_dentries(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,const struct list_head * delayed_ins_list,struct btrfs_log_ctx * ctx)6288 static int log_new_delayed_dentries(struct btrfs_trans_handle *trans,
6289 				    struct btrfs_inode *inode,
6290 				    const struct list_head *delayed_ins_list,
6291 				    struct btrfs_log_ctx *ctx)
6292 {
6293 	const bool orig_log_new_dentries = ctx->log_new_dentries;
6294 	struct btrfs_fs_info *fs_info = trans->fs_info;
6295 	struct btrfs_delayed_item *item;
6296 	int ret = 0;
6297 
6298 	/*
6299 	 * No need for the log mutex, plus to avoid potential deadlocks or
6300 	 * lockdep annotations due to nesting of delayed inode mutexes and log
6301 	 * mutexes.
6302 	 */
6303 	lockdep_assert_not_held(&inode->log_mutex);
6304 
6305 	ASSERT(!ctx->logging_new_delayed_dentries);
6306 	ctx->logging_new_delayed_dentries = true;
6307 
6308 	list_for_each_entry(item, delayed_ins_list, log_list) {
6309 		struct btrfs_dir_item *dir_item;
6310 		struct inode *di_inode;
6311 		struct btrfs_key key;
6312 		int log_mode = LOG_INODE_EXISTS;
6313 
6314 		dir_item = (struct btrfs_dir_item *)item->data;
6315 		btrfs_disk_key_to_cpu(&key, &dir_item->location);
6316 
6317 		if (key.type == BTRFS_ROOT_ITEM_KEY)
6318 			continue;
6319 
6320 		di_inode = btrfs_iget(fs_info->sb, key.objectid, inode->root);
6321 		if (IS_ERR(di_inode)) {
6322 			ret = PTR_ERR(di_inode);
6323 			break;
6324 		}
6325 
6326 		if (!need_log_inode(trans, BTRFS_I(di_inode))) {
6327 			btrfs_add_delayed_iput(di_inode);
6328 			continue;
6329 		}
6330 
6331 		if (btrfs_stack_dir_type(dir_item) == BTRFS_FT_DIR)
6332 			log_mode = LOG_INODE_ALL;
6333 
6334 		ctx->log_new_dentries = false;
6335 		ret = btrfs_log_inode(trans, BTRFS_I(di_inode), log_mode, ctx);
6336 
6337 		if (!ret && ctx->log_new_dentries)
6338 			ret = log_new_dir_dentries(trans, BTRFS_I(di_inode), ctx);
6339 
6340 		btrfs_add_delayed_iput(di_inode);
6341 
6342 		if (ret)
6343 			break;
6344 	}
6345 
6346 	ctx->log_new_dentries = orig_log_new_dentries;
6347 	ctx->logging_new_delayed_dentries = false;
6348 
6349 	return ret;
6350 }
6351 
6352 /* log a single inode in the tree log.
6353  * At least one parent directory for this inode must exist in the tree
6354  * or be logged already.
6355  *
6356  * Any items from this inode changed by the current transaction are copied
6357  * to the log tree.  An extra reference is taken on any extents in this
6358  * file, allowing us to avoid a whole pile of corner cases around logging
6359  * blocks that have been removed from the tree.
6360  *
6361  * See LOG_INODE_ALL and related defines for a description of what inode_only
6362  * does.
6363  *
6364  * This handles both files and directories.
6365  */
btrfs_log_inode(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,int inode_only,struct btrfs_log_ctx * ctx)6366 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
6367 			   struct btrfs_inode *inode,
6368 			   int inode_only,
6369 			   struct btrfs_log_ctx *ctx)
6370 {
6371 	struct btrfs_path *path;
6372 	struct btrfs_path *dst_path;
6373 	struct btrfs_key min_key;
6374 	struct btrfs_key max_key;
6375 	struct btrfs_root *log = inode->root->log_root;
6376 	int ret;
6377 	bool fast_search = false;
6378 	u64 ino = btrfs_ino(inode);
6379 	struct extent_map_tree *em_tree = &inode->extent_tree;
6380 	u64 logged_isize = 0;
6381 	bool need_log_inode_item = true;
6382 	bool xattrs_logged = false;
6383 	bool inode_item_dropped = true;
6384 	bool full_dir_logging = false;
6385 	LIST_HEAD(delayed_ins_list);
6386 	LIST_HEAD(delayed_del_list);
6387 
6388 	path = btrfs_alloc_path();
6389 	if (!path)
6390 		return -ENOMEM;
6391 	dst_path = btrfs_alloc_path();
6392 	if (!dst_path) {
6393 		btrfs_free_path(path);
6394 		return -ENOMEM;
6395 	}
6396 
6397 	min_key.objectid = ino;
6398 	min_key.type = BTRFS_INODE_ITEM_KEY;
6399 	min_key.offset = 0;
6400 
6401 	max_key.objectid = ino;
6402 
6403 
6404 	/* today the code can only do partial logging of directories */
6405 	if (S_ISDIR(inode->vfs_inode.i_mode) ||
6406 	    (!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
6407 		       &inode->runtime_flags) &&
6408 	     inode_only >= LOG_INODE_EXISTS))
6409 		max_key.type = BTRFS_XATTR_ITEM_KEY;
6410 	else
6411 		max_key.type = (u8)-1;
6412 	max_key.offset = (u64)-1;
6413 
6414 	if (S_ISDIR(inode->vfs_inode.i_mode) && inode_only == LOG_INODE_ALL)
6415 		full_dir_logging = true;
6416 
6417 	/*
6418 	 * If we are logging a directory while we are logging dentries of the
6419 	 * delayed items of some other inode, then we need to flush the delayed
6420 	 * items of this directory and not log the delayed items directly. This
6421 	 * is to prevent more than one level of recursion into btrfs_log_inode()
6422 	 * by having something like this:
6423 	 *
6424 	 *     $ mkdir -p a/b/c/d/e/f/g/h/...
6425 	 *     $ xfs_io -c "fsync" a
6426 	 *
6427 	 * Where all directories in the path did not exist before and are
6428 	 * created in the current transaction.
6429 	 * So in such a case we directly log the delayed items of the main
6430 	 * directory ("a") without flushing them first, while for each of its
6431 	 * subdirectories we flush their delayed items before logging them.
6432 	 * This prevents a potential unbounded recursion like this:
6433 	 *
6434 	 * btrfs_log_inode()
6435 	 *   log_new_delayed_dentries()
6436 	 *      btrfs_log_inode()
6437 	 *        log_new_delayed_dentries()
6438 	 *          btrfs_log_inode()
6439 	 *            log_new_delayed_dentries()
6440 	 *              (...)
6441 	 *
6442 	 * We have thresholds for the maximum number of delayed items to have in
6443 	 * memory, and once they are hit, the items are flushed asynchronously.
6444 	 * However the limit is quite high, so lets prevent deep levels of
6445 	 * recursion to happen by limiting the maximum depth to be 1.
6446 	 */
6447 	if (full_dir_logging && ctx->logging_new_delayed_dentries) {
6448 		ret = btrfs_commit_inode_delayed_items(trans, inode);
6449 		if (ret)
6450 			goto out;
6451 	}
6452 
6453 	mutex_lock(&inode->log_mutex);
6454 
6455 	/*
6456 	 * For symlinks, we must always log their content, which is stored in an
6457 	 * inline extent, otherwise we could end up with an empty symlink after
6458 	 * log replay, which is invalid on linux (symlink(2) returns -ENOENT if
6459 	 * one attempts to create an empty symlink).
6460 	 * We don't need to worry about flushing delalloc, because when we create
6461 	 * the inline extent when the symlink is created (we never have delalloc
6462 	 * for symlinks).
6463 	 */
6464 	if (S_ISLNK(inode->vfs_inode.i_mode))
6465 		inode_only = LOG_INODE_ALL;
6466 
6467 	/*
6468 	 * Before logging the inode item, cache the value returned by
6469 	 * inode_logged(), because after that we have the need to figure out if
6470 	 * the inode was previously logged in this transaction.
6471 	 */
6472 	ret = inode_logged(trans, inode, path);
6473 	if (ret < 0)
6474 		goto out_unlock;
6475 	ctx->logged_before = (ret == 1);
6476 	ret = 0;
6477 
6478 	/*
6479 	 * This is for cases where logging a directory could result in losing a
6480 	 * a file after replaying the log. For example, if we move a file from a
6481 	 * directory A to a directory B, then fsync directory A, we have no way
6482 	 * to known the file was moved from A to B, so logging just A would
6483 	 * result in losing the file after a log replay.
6484 	 */
6485 	if (full_dir_logging && inode->last_unlink_trans >= trans->transid) {
6486 		btrfs_set_log_full_commit(trans);
6487 		ret = BTRFS_LOG_FORCE_COMMIT;
6488 		goto out_unlock;
6489 	}
6490 
6491 	/*
6492 	 * a brute force approach to making sure we get the most uptodate
6493 	 * copies of everything.
6494 	 */
6495 	if (S_ISDIR(inode->vfs_inode.i_mode)) {
6496 		clear_bit(BTRFS_INODE_COPY_EVERYTHING, &inode->runtime_flags);
6497 		if (ctx->logged_before)
6498 			ret = drop_inode_items(trans, log, path, inode,
6499 					       BTRFS_XATTR_ITEM_KEY);
6500 	} else {
6501 		if (inode_only == LOG_INODE_EXISTS && ctx->logged_before) {
6502 			/*
6503 			 * Make sure the new inode item we write to the log has
6504 			 * the same isize as the current one (if it exists).
6505 			 * This is necessary to prevent data loss after log
6506 			 * replay, and also to prevent doing a wrong expanding
6507 			 * truncate - for e.g. create file, write 4K into offset
6508 			 * 0, fsync, write 4K into offset 4096, add hard link,
6509 			 * fsync some other file (to sync log), power fail - if
6510 			 * we use the inode's current i_size, after log replay
6511 			 * we get a 8Kb file, with the last 4Kb extent as a hole
6512 			 * (zeroes), as if an expanding truncate happened,
6513 			 * instead of getting a file of 4Kb only.
6514 			 */
6515 			ret = logged_inode_size(log, inode, path, &logged_isize);
6516 			if (ret)
6517 				goto out_unlock;
6518 		}
6519 		if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
6520 			     &inode->runtime_flags)) {
6521 			if (inode_only == LOG_INODE_EXISTS) {
6522 				max_key.type = BTRFS_XATTR_ITEM_KEY;
6523 				if (ctx->logged_before)
6524 					ret = drop_inode_items(trans, log, path,
6525 							       inode, max_key.type);
6526 			} else {
6527 				clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
6528 					  &inode->runtime_flags);
6529 				clear_bit(BTRFS_INODE_COPY_EVERYTHING,
6530 					  &inode->runtime_flags);
6531 				if (ctx->logged_before)
6532 					ret = truncate_inode_items(trans, log,
6533 								   inode, 0, 0);
6534 			}
6535 		} else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
6536 					      &inode->runtime_flags) ||
6537 			   inode_only == LOG_INODE_EXISTS) {
6538 			if (inode_only == LOG_INODE_ALL)
6539 				fast_search = true;
6540 			max_key.type = BTRFS_XATTR_ITEM_KEY;
6541 			if (ctx->logged_before)
6542 				ret = drop_inode_items(trans, log, path, inode,
6543 						       max_key.type);
6544 		} else {
6545 			if (inode_only == LOG_INODE_ALL)
6546 				fast_search = true;
6547 			inode_item_dropped = false;
6548 			goto log_extents;
6549 		}
6550 
6551 	}
6552 	if (ret)
6553 		goto out_unlock;
6554 
6555 	/*
6556 	 * If we are logging a directory in full mode, collect the delayed items
6557 	 * before iterating the subvolume tree, so that we don't miss any new
6558 	 * dir index items in case they get flushed while or right after we are
6559 	 * iterating the subvolume tree.
6560 	 */
6561 	if (full_dir_logging && !ctx->logging_new_delayed_dentries)
6562 		btrfs_log_get_delayed_items(inode, &delayed_ins_list,
6563 					    &delayed_del_list);
6564 
6565 	ret = copy_inode_items_to_log(trans, inode, &min_key, &max_key,
6566 				      path, dst_path, logged_isize,
6567 				      inode_only, ctx,
6568 				      &need_log_inode_item);
6569 	if (ret)
6570 		goto out_unlock;
6571 
6572 	btrfs_release_path(path);
6573 	btrfs_release_path(dst_path);
6574 	ret = btrfs_log_all_xattrs(trans, inode, path, dst_path);
6575 	if (ret)
6576 		goto out_unlock;
6577 	xattrs_logged = true;
6578 	if (max_key.type >= BTRFS_EXTENT_DATA_KEY && !fast_search) {
6579 		btrfs_release_path(path);
6580 		btrfs_release_path(dst_path);
6581 		ret = btrfs_log_holes(trans, inode, path);
6582 		if (ret)
6583 			goto out_unlock;
6584 	}
6585 log_extents:
6586 	btrfs_release_path(path);
6587 	btrfs_release_path(dst_path);
6588 	if (need_log_inode_item) {
6589 		ret = log_inode_item(trans, log, dst_path, inode, inode_item_dropped);
6590 		if (ret)
6591 			goto out_unlock;
6592 		/*
6593 		 * If we are doing a fast fsync and the inode was logged before
6594 		 * in this transaction, we don't need to log the xattrs because
6595 		 * they were logged before. If xattrs were added, changed or
6596 		 * deleted since the last time we logged the inode, then we have
6597 		 * already logged them because the inode had the runtime flag
6598 		 * BTRFS_INODE_COPY_EVERYTHING set.
6599 		 */
6600 		if (!xattrs_logged && inode->logged_trans < trans->transid) {
6601 			ret = btrfs_log_all_xattrs(trans, inode, path, dst_path);
6602 			if (ret)
6603 				goto out_unlock;
6604 			btrfs_release_path(path);
6605 		}
6606 	}
6607 	if (fast_search) {
6608 		ret = btrfs_log_changed_extents(trans, inode, dst_path, ctx);
6609 		if (ret)
6610 			goto out_unlock;
6611 	} else if (inode_only == LOG_INODE_ALL) {
6612 		struct extent_map *em, *n;
6613 
6614 		write_lock(&em_tree->lock);
6615 		list_for_each_entry_safe(em, n, &em_tree->modified_extents, list)
6616 			list_del_init(&em->list);
6617 		write_unlock(&em_tree->lock);
6618 	}
6619 
6620 	if (full_dir_logging) {
6621 		ret = log_directory_changes(trans, inode, path, dst_path, ctx);
6622 		if (ret)
6623 			goto out_unlock;
6624 		ret = log_delayed_insertion_items(trans, inode, path,
6625 						  &delayed_ins_list, ctx);
6626 		if (ret)
6627 			goto out_unlock;
6628 		ret = log_delayed_deletion_items(trans, inode, path,
6629 						 &delayed_del_list, ctx);
6630 		if (ret)
6631 			goto out_unlock;
6632 	}
6633 
6634 	spin_lock(&inode->lock);
6635 	inode->logged_trans = trans->transid;
6636 	/*
6637 	 * Don't update last_log_commit if we logged that an inode exists.
6638 	 * We do this for three reasons:
6639 	 *
6640 	 * 1) We might have had buffered writes to this inode that were
6641 	 *    flushed and had their ordered extents completed in this
6642 	 *    transaction, but we did not previously log the inode with
6643 	 *    LOG_INODE_ALL. Later the inode was evicted and after that
6644 	 *    it was loaded again and this LOG_INODE_EXISTS log operation
6645 	 *    happened. We must make sure that if an explicit fsync against
6646 	 *    the inode is performed later, it logs the new extents, an
6647 	 *    updated inode item, etc, and syncs the log. The same logic
6648 	 *    applies to direct IO writes instead of buffered writes.
6649 	 *
6650 	 * 2) When we log the inode with LOG_INODE_EXISTS, its inode item
6651 	 *    is logged with an i_size of 0 or whatever value was logged
6652 	 *    before. If later the i_size of the inode is increased by a
6653 	 *    truncate operation, the log is synced through an fsync of
6654 	 *    some other inode and then finally an explicit fsync against
6655 	 *    this inode is made, we must make sure this fsync logs the
6656 	 *    inode with the new i_size, the hole between old i_size and
6657 	 *    the new i_size, and syncs the log.
6658 	 *
6659 	 * 3) If we are logging that an ancestor inode exists as part of
6660 	 *    logging a new name from a link or rename operation, don't update
6661 	 *    its last_log_commit - otherwise if an explicit fsync is made
6662 	 *    against an ancestor, the fsync considers the inode in the log
6663 	 *    and doesn't sync the log, resulting in the ancestor missing after
6664 	 *    a power failure unless the log was synced as part of an fsync
6665 	 *    against any other unrelated inode.
6666 	 */
6667 	if (inode_only != LOG_INODE_EXISTS)
6668 		inode->last_log_commit = inode->last_sub_trans;
6669 	spin_unlock(&inode->lock);
6670 
6671 	/*
6672 	 * Reset the last_reflink_trans so that the next fsync does not need to
6673 	 * go through the slower path when logging extents and their checksums.
6674 	 */
6675 	if (inode_only == LOG_INODE_ALL)
6676 		inode->last_reflink_trans = 0;
6677 
6678 out_unlock:
6679 	mutex_unlock(&inode->log_mutex);
6680 out:
6681 	btrfs_free_path(path);
6682 	btrfs_free_path(dst_path);
6683 
6684 	if (ret)
6685 		free_conflicting_inodes(ctx);
6686 	else
6687 		ret = log_conflicting_inodes(trans, inode->root, ctx);
6688 
6689 	if (full_dir_logging && !ctx->logging_new_delayed_dentries) {
6690 		if (!ret)
6691 			ret = log_new_delayed_dentries(trans, inode,
6692 						       &delayed_ins_list, ctx);
6693 
6694 		btrfs_log_put_delayed_items(inode, &delayed_ins_list,
6695 					    &delayed_del_list);
6696 	}
6697 
6698 	return ret;
6699 }
6700 
btrfs_log_all_parents(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct btrfs_log_ctx * ctx)6701 static int btrfs_log_all_parents(struct btrfs_trans_handle *trans,
6702 				 struct btrfs_inode *inode,
6703 				 struct btrfs_log_ctx *ctx)
6704 {
6705 	struct btrfs_fs_info *fs_info = trans->fs_info;
6706 	int ret;
6707 	struct btrfs_path *path;
6708 	struct btrfs_key key;
6709 	struct btrfs_root *root = inode->root;
6710 	const u64 ino = btrfs_ino(inode);
6711 
6712 	path = btrfs_alloc_path();
6713 	if (!path)
6714 		return -ENOMEM;
6715 	path->skip_locking = 1;
6716 	path->search_commit_root = 1;
6717 
6718 	key.objectid = ino;
6719 	key.type = BTRFS_INODE_REF_KEY;
6720 	key.offset = 0;
6721 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6722 	if (ret < 0)
6723 		goto out;
6724 
6725 	while (true) {
6726 		struct extent_buffer *leaf = path->nodes[0];
6727 		int slot = path->slots[0];
6728 		u32 cur_offset = 0;
6729 		u32 item_size;
6730 		unsigned long ptr;
6731 
6732 		if (slot >= btrfs_header_nritems(leaf)) {
6733 			ret = btrfs_next_leaf(root, path);
6734 			if (ret < 0)
6735 				goto out;
6736 			else if (ret > 0)
6737 				break;
6738 			continue;
6739 		}
6740 
6741 		btrfs_item_key_to_cpu(leaf, &key, slot);
6742 		/* BTRFS_INODE_EXTREF_KEY is BTRFS_INODE_REF_KEY + 1 */
6743 		if (key.objectid != ino || key.type > BTRFS_INODE_EXTREF_KEY)
6744 			break;
6745 
6746 		item_size = btrfs_item_size(leaf, slot);
6747 		ptr = btrfs_item_ptr_offset(leaf, slot);
6748 		while (cur_offset < item_size) {
6749 			struct btrfs_key inode_key;
6750 			struct inode *dir_inode;
6751 
6752 			inode_key.type = BTRFS_INODE_ITEM_KEY;
6753 			inode_key.offset = 0;
6754 
6755 			if (key.type == BTRFS_INODE_EXTREF_KEY) {
6756 				struct btrfs_inode_extref *extref;
6757 
6758 				extref = (struct btrfs_inode_extref *)
6759 					(ptr + cur_offset);
6760 				inode_key.objectid = btrfs_inode_extref_parent(
6761 					leaf, extref);
6762 				cur_offset += sizeof(*extref);
6763 				cur_offset += btrfs_inode_extref_name_len(leaf,
6764 					extref);
6765 			} else {
6766 				inode_key.objectid = key.offset;
6767 				cur_offset = item_size;
6768 			}
6769 
6770 			dir_inode = btrfs_iget(fs_info->sb, inode_key.objectid,
6771 					       root);
6772 			/*
6773 			 * If the parent inode was deleted, return an error to
6774 			 * fallback to a transaction commit. This is to prevent
6775 			 * getting an inode that was moved from one parent A to
6776 			 * a parent B, got its former parent A deleted and then
6777 			 * it got fsync'ed, from existing at both parents after
6778 			 * a log replay (and the old parent still existing).
6779 			 * Example:
6780 			 *
6781 			 * mkdir /mnt/A
6782 			 * mkdir /mnt/B
6783 			 * touch /mnt/B/bar
6784 			 * sync
6785 			 * mv /mnt/B/bar /mnt/A/bar
6786 			 * mv -T /mnt/A /mnt/B
6787 			 * fsync /mnt/B/bar
6788 			 * <power fail>
6789 			 *
6790 			 * If we ignore the old parent B which got deleted,
6791 			 * after a log replay we would have file bar linked
6792 			 * at both parents and the old parent B would still
6793 			 * exist.
6794 			 */
6795 			if (IS_ERR(dir_inode)) {
6796 				ret = PTR_ERR(dir_inode);
6797 				goto out;
6798 			}
6799 
6800 			if (!need_log_inode(trans, BTRFS_I(dir_inode))) {
6801 				btrfs_add_delayed_iput(dir_inode);
6802 				continue;
6803 			}
6804 
6805 			ctx->log_new_dentries = false;
6806 			ret = btrfs_log_inode(trans, BTRFS_I(dir_inode),
6807 					      LOG_INODE_ALL, ctx);
6808 			if (!ret && ctx->log_new_dentries)
6809 				ret = log_new_dir_dentries(trans,
6810 						   BTRFS_I(dir_inode), ctx);
6811 			btrfs_add_delayed_iput(dir_inode);
6812 			if (ret)
6813 				goto out;
6814 		}
6815 		path->slots[0]++;
6816 	}
6817 	ret = 0;
6818 out:
6819 	btrfs_free_path(path);
6820 	return ret;
6821 }
6822 
log_new_ancestors(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_path * path,struct btrfs_log_ctx * ctx)6823 static int log_new_ancestors(struct btrfs_trans_handle *trans,
6824 			     struct btrfs_root *root,
6825 			     struct btrfs_path *path,
6826 			     struct btrfs_log_ctx *ctx)
6827 {
6828 	struct btrfs_key found_key;
6829 
6830 	btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
6831 
6832 	while (true) {
6833 		struct btrfs_fs_info *fs_info = root->fs_info;
6834 		struct extent_buffer *leaf = path->nodes[0];
6835 		int slot = path->slots[0];
6836 		struct btrfs_key search_key;
6837 		struct inode *inode;
6838 		u64 ino;
6839 		int ret = 0;
6840 
6841 		btrfs_release_path(path);
6842 
6843 		ino = found_key.offset;
6844 
6845 		search_key.objectid = found_key.offset;
6846 		search_key.type = BTRFS_INODE_ITEM_KEY;
6847 		search_key.offset = 0;
6848 		inode = btrfs_iget(fs_info->sb, ino, root);
6849 		if (IS_ERR(inode))
6850 			return PTR_ERR(inode);
6851 
6852 		if (BTRFS_I(inode)->generation >= trans->transid &&
6853 		    need_log_inode(trans, BTRFS_I(inode)))
6854 			ret = btrfs_log_inode(trans, BTRFS_I(inode),
6855 					      LOG_INODE_EXISTS, ctx);
6856 		btrfs_add_delayed_iput(inode);
6857 		if (ret)
6858 			return ret;
6859 
6860 		if (search_key.objectid == BTRFS_FIRST_FREE_OBJECTID)
6861 			break;
6862 
6863 		search_key.type = BTRFS_INODE_REF_KEY;
6864 		ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
6865 		if (ret < 0)
6866 			return ret;
6867 
6868 		leaf = path->nodes[0];
6869 		slot = path->slots[0];
6870 		if (slot >= btrfs_header_nritems(leaf)) {
6871 			ret = btrfs_next_leaf(root, path);
6872 			if (ret < 0)
6873 				return ret;
6874 			else if (ret > 0)
6875 				return -ENOENT;
6876 			leaf = path->nodes[0];
6877 			slot = path->slots[0];
6878 		}
6879 
6880 		btrfs_item_key_to_cpu(leaf, &found_key, slot);
6881 		if (found_key.objectid != search_key.objectid ||
6882 		    found_key.type != BTRFS_INODE_REF_KEY)
6883 			return -ENOENT;
6884 	}
6885 	return 0;
6886 }
6887 
log_new_ancestors_fast(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct dentry * parent,struct btrfs_log_ctx * ctx)6888 static int log_new_ancestors_fast(struct btrfs_trans_handle *trans,
6889 				  struct btrfs_inode *inode,
6890 				  struct dentry *parent,
6891 				  struct btrfs_log_ctx *ctx)
6892 {
6893 	struct btrfs_root *root = inode->root;
6894 	struct dentry *old_parent = NULL;
6895 	struct super_block *sb = inode->vfs_inode.i_sb;
6896 	int ret = 0;
6897 
6898 	while (true) {
6899 		if (!parent || d_really_is_negative(parent) ||
6900 		    sb != parent->d_sb)
6901 			break;
6902 
6903 		inode = BTRFS_I(d_inode(parent));
6904 		if (root != inode->root)
6905 			break;
6906 
6907 		if (inode->generation >= trans->transid &&
6908 		    need_log_inode(trans, inode)) {
6909 			ret = btrfs_log_inode(trans, inode,
6910 					      LOG_INODE_EXISTS, ctx);
6911 			if (ret)
6912 				break;
6913 		}
6914 		if (IS_ROOT(parent))
6915 			break;
6916 
6917 		parent = dget_parent(parent);
6918 		dput(old_parent);
6919 		old_parent = parent;
6920 	}
6921 	dput(old_parent);
6922 
6923 	return ret;
6924 }
6925 
log_all_new_ancestors(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct dentry * parent,struct btrfs_log_ctx * ctx)6926 static int log_all_new_ancestors(struct btrfs_trans_handle *trans,
6927 				 struct btrfs_inode *inode,
6928 				 struct dentry *parent,
6929 				 struct btrfs_log_ctx *ctx)
6930 {
6931 	struct btrfs_root *root = inode->root;
6932 	const u64 ino = btrfs_ino(inode);
6933 	struct btrfs_path *path;
6934 	struct btrfs_key search_key;
6935 	int ret;
6936 
6937 	/*
6938 	 * For a single hard link case, go through a fast path that does not
6939 	 * need to iterate the fs/subvolume tree.
6940 	 */
6941 	if (inode->vfs_inode.i_nlink < 2)
6942 		return log_new_ancestors_fast(trans, inode, parent, ctx);
6943 
6944 	path = btrfs_alloc_path();
6945 	if (!path)
6946 		return -ENOMEM;
6947 
6948 	search_key.objectid = ino;
6949 	search_key.type = BTRFS_INODE_REF_KEY;
6950 	search_key.offset = 0;
6951 again:
6952 	ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
6953 	if (ret < 0)
6954 		goto out;
6955 	if (ret == 0)
6956 		path->slots[0]++;
6957 
6958 	while (true) {
6959 		struct extent_buffer *leaf = path->nodes[0];
6960 		int slot = path->slots[0];
6961 		struct btrfs_key found_key;
6962 
6963 		if (slot >= btrfs_header_nritems(leaf)) {
6964 			ret = btrfs_next_leaf(root, path);
6965 			if (ret < 0)
6966 				goto out;
6967 			else if (ret > 0)
6968 				break;
6969 			continue;
6970 		}
6971 
6972 		btrfs_item_key_to_cpu(leaf, &found_key, slot);
6973 		if (found_key.objectid != ino ||
6974 		    found_key.type > BTRFS_INODE_EXTREF_KEY)
6975 			break;
6976 
6977 		/*
6978 		 * Don't deal with extended references because they are rare
6979 		 * cases and too complex to deal with (we would need to keep
6980 		 * track of which subitem we are processing for each item in
6981 		 * this loop, etc). So just return some error to fallback to
6982 		 * a transaction commit.
6983 		 */
6984 		if (found_key.type == BTRFS_INODE_EXTREF_KEY) {
6985 			ret = -EMLINK;
6986 			goto out;
6987 		}
6988 
6989 		/*
6990 		 * Logging ancestors needs to do more searches on the fs/subvol
6991 		 * tree, so it releases the path as needed to avoid deadlocks.
6992 		 * Keep track of the last inode ref key and resume from that key
6993 		 * after logging all new ancestors for the current hard link.
6994 		 */
6995 		memcpy(&search_key, &found_key, sizeof(search_key));
6996 
6997 		ret = log_new_ancestors(trans, root, path, ctx);
6998 		if (ret)
6999 			goto out;
7000 		btrfs_release_path(path);
7001 		goto again;
7002 	}
7003 	ret = 0;
7004 out:
7005 	btrfs_free_path(path);
7006 	return ret;
7007 }
7008 
7009 /*
7010  * helper function around btrfs_log_inode to make sure newly created
7011  * parent directories also end up in the log.  A minimal inode and backref
7012  * only logging is done of any parent directories that are older than
7013  * the last committed transaction
7014  */
btrfs_log_inode_parent(struct btrfs_trans_handle * trans,struct btrfs_inode * inode,struct dentry * parent,int inode_only,struct btrfs_log_ctx * ctx)7015 static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
7016 				  struct btrfs_inode *inode,
7017 				  struct dentry *parent,
7018 				  int inode_only,
7019 				  struct btrfs_log_ctx *ctx)
7020 {
7021 	struct btrfs_root *root = inode->root;
7022 	struct btrfs_fs_info *fs_info = root->fs_info;
7023 	int ret = 0;
7024 	bool log_dentries = false;
7025 
7026 	if (btrfs_test_opt(fs_info, NOTREELOG)) {
7027 		ret = BTRFS_LOG_FORCE_COMMIT;
7028 		goto end_no_trans;
7029 	}
7030 
7031 	if (btrfs_root_refs(&root->root_item) == 0) {
7032 		ret = BTRFS_LOG_FORCE_COMMIT;
7033 		goto end_no_trans;
7034 	}
7035 
7036 	/*
7037 	 * Skip already logged inodes or inodes corresponding to tmpfiles
7038 	 * (since logging them is pointless, a link count of 0 means they
7039 	 * will never be accessible).
7040 	 */
7041 	if ((btrfs_inode_in_log(inode, trans->transid) &&
7042 	     list_empty(&ctx->ordered_extents)) ||
7043 	    inode->vfs_inode.i_nlink == 0) {
7044 		ret = BTRFS_NO_LOG_SYNC;
7045 		goto end_no_trans;
7046 	}
7047 
7048 	ret = start_log_trans(trans, root, ctx);
7049 	if (ret)
7050 		goto end_no_trans;
7051 
7052 	ret = btrfs_log_inode(trans, inode, inode_only, ctx);
7053 	if (ret)
7054 		goto end_trans;
7055 
7056 	/*
7057 	 * for regular files, if its inode is already on disk, we don't
7058 	 * have to worry about the parents at all.  This is because
7059 	 * we can use the last_unlink_trans field to record renames
7060 	 * and other fun in this file.
7061 	 */
7062 	if (S_ISREG(inode->vfs_inode.i_mode) &&
7063 	    inode->generation < trans->transid &&
7064 	    inode->last_unlink_trans < trans->transid) {
7065 		ret = 0;
7066 		goto end_trans;
7067 	}
7068 
7069 	if (S_ISDIR(inode->vfs_inode.i_mode) && ctx->log_new_dentries)
7070 		log_dentries = true;
7071 
7072 	/*
7073 	 * On unlink we must make sure all our current and old parent directory
7074 	 * inodes are fully logged. This is to prevent leaving dangling
7075 	 * directory index entries in directories that were our parents but are
7076 	 * not anymore. Not doing this results in old parent directory being
7077 	 * impossible to delete after log replay (rmdir will always fail with
7078 	 * error -ENOTEMPTY).
7079 	 *
7080 	 * Example 1:
7081 	 *
7082 	 * mkdir testdir
7083 	 * touch testdir/foo
7084 	 * ln testdir/foo testdir/bar
7085 	 * sync
7086 	 * unlink testdir/bar
7087 	 * xfs_io -c fsync testdir/foo
7088 	 * <power failure>
7089 	 * mount fs, triggers log replay
7090 	 *
7091 	 * If we don't log the parent directory (testdir), after log replay the
7092 	 * directory still has an entry pointing to the file inode using the bar
7093 	 * name, but a matching BTRFS_INODE_[REF|EXTREF]_KEY does not exist and
7094 	 * the file inode has a link count of 1.
7095 	 *
7096 	 * Example 2:
7097 	 *
7098 	 * mkdir testdir
7099 	 * touch foo
7100 	 * ln foo testdir/foo2
7101 	 * ln foo testdir/foo3
7102 	 * sync
7103 	 * unlink testdir/foo3
7104 	 * xfs_io -c fsync foo
7105 	 * <power failure>
7106 	 * mount fs, triggers log replay
7107 	 *
7108 	 * Similar as the first example, after log replay the parent directory
7109 	 * testdir still has an entry pointing to the inode file with name foo3
7110 	 * but the file inode does not have a matching BTRFS_INODE_REF_KEY item
7111 	 * and has a link count of 2.
7112 	 */
7113 	if (inode->last_unlink_trans >= trans->transid) {
7114 		ret = btrfs_log_all_parents(trans, inode, ctx);
7115 		if (ret)
7116 			goto end_trans;
7117 	}
7118 
7119 	ret = log_all_new_ancestors(trans, inode, parent, ctx);
7120 	if (ret)
7121 		goto end_trans;
7122 
7123 	if (log_dentries)
7124 		ret = log_new_dir_dentries(trans, inode, ctx);
7125 	else
7126 		ret = 0;
7127 end_trans:
7128 	if (ret < 0) {
7129 		btrfs_set_log_full_commit(trans);
7130 		ret = BTRFS_LOG_FORCE_COMMIT;
7131 	}
7132 
7133 	if (ret)
7134 		btrfs_remove_log_ctx(root, ctx);
7135 	btrfs_end_log_trans(root);
7136 end_no_trans:
7137 	return ret;
7138 }
7139 
7140 /*
7141  * it is not safe to log dentry if the chunk root has added new
7142  * chunks.  This returns 0 if the dentry was logged, and 1 otherwise.
7143  * If this returns 1, you must commit the transaction to safely get your
7144  * data on disk.
7145  */
btrfs_log_dentry_safe(struct btrfs_trans_handle * trans,struct dentry * dentry,struct btrfs_log_ctx * ctx)7146 int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
7147 			  struct dentry *dentry,
7148 			  struct btrfs_log_ctx *ctx)
7149 {
7150 	struct dentry *parent = dget_parent(dentry);
7151 	int ret;
7152 
7153 	ret = btrfs_log_inode_parent(trans, BTRFS_I(d_inode(dentry)), parent,
7154 				     LOG_INODE_ALL, ctx);
7155 	dput(parent);
7156 
7157 	return ret;
7158 }
7159 
7160 /*
7161  * should be called during mount to recover any replay any log trees
7162  * from the FS
7163  */
btrfs_recover_log_trees(struct btrfs_root * log_root_tree)7164 int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
7165 {
7166 	int ret;
7167 	struct btrfs_path *path;
7168 	struct btrfs_trans_handle *trans;
7169 	struct btrfs_key key;
7170 	struct btrfs_key found_key;
7171 	struct btrfs_root *log;
7172 	struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
7173 	struct walk_control wc = {
7174 		.process_func = process_one_buffer,
7175 		.stage = LOG_WALK_PIN_ONLY,
7176 	};
7177 
7178 	path = btrfs_alloc_path();
7179 	if (!path)
7180 		return -ENOMEM;
7181 
7182 	set_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);
7183 
7184 	trans = btrfs_start_transaction(fs_info->tree_root, 0);
7185 	if (IS_ERR(trans)) {
7186 		ret = PTR_ERR(trans);
7187 		goto error;
7188 	}
7189 
7190 	wc.trans = trans;
7191 	wc.pin = 1;
7192 
7193 	ret = walk_log_tree(trans, log_root_tree, &wc);
7194 	if (ret) {
7195 		btrfs_abort_transaction(trans, ret);
7196 		goto error;
7197 	}
7198 
7199 again:
7200 	key.objectid = BTRFS_TREE_LOG_OBJECTID;
7201 	key.offset = (u64)-1;
7202 	key.type = BTRFS_ROOT_ITEM_KEY;
7203 
7204 	while (1) {
7205 		ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
7206 
7207 		if (ret < 0) {
7208 			btrfs_abort_transaction(trans, ret);
7209 			goto error;
7210 		}
7211 		if (ret > 0) {
7212 			if (path->slots[0] == 0)
7213 				break;
7214 			path->slots[0]--;
7215 		}
7216 		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
7217 				      path->slots[0]);
7218 		btrfs_release_path(path);
7219 		if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
7220 			break;
7221 
7222 		log = btrfs_read_tree_root(log_root_tree, &found_key);
7223 		if (IS_ERR(log)) {
7224 			ret = PTR_ERR(log);
7225 			btrfs_abort_transaction(trans, ret);
7226 			goto error;
7227 		}
7228 
7229 		wc.replay_dest = btrfs_get_fs_root(fs_info, found_key.offset,
7230 						   true);
7231 		if (IS_ERR(wc.replay_dest)) {
7232 			ret = PTR_ERR(wc.replay_dest);
7233 
7234 			/*
7235 			 * We didn't find the subvol, likely because it was
7236 			 * deleted.  This is ok, simply skip this log and go to
7237 			 * the next one.
7238 			 *
7239 			 * We need to exclude the root because we can't have
7240 			 * other log replays overwriting this log as we'll read
7241 			 * it back in a few more times.  This will keep our
7242 			 * block from being modified, and we'll just bail for
7243 			 * each subsequent pass.
7244 			 */
7245 			if (ret == -ENOENT)
7246 				ret = btrfs_pin_extent_for_log_replay(trans,
7247 							log->node->start,
7248 							log->node->len);
7249 			btrfs_put_root(log);
7250 
7251 			if (!ret)
7252 				goto next;
7253 			btrfs_abort_transaction(trans, ret);
7254 			goto error;
7255 		}
7256 
7257 		wc.replay_dest->log_root = log;
7258 		ret = btrfs_record_root_in_trans(trans, wc.replay_dest);
7259 		if (ret)
7260 			/* The loop needs to continue due to the root refs */
7261 			btrfs_abort_transaction(trans, ret);
7262 		else
7263 			ret = walk_log_tree(trans, log, &wc);
7264 
7265 		if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
7266 			ret = fixup_inode_link_counts(trans, wc.replay_dest,
7267 						      path);
7268 			if (ret)
7269 				btrfs_abort_transaction(trans, ret);
7270 		}
7271 
7272 		if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
7273 			struct btrfs_root *root = wc.replay_dest;
7274 
7275 			btrfs_release_path(path);
7276 
7277 			/*
7278 			 * We have just replayed everything, and the highest
7279 			 * objectid of fs roots probably has changed in case
7280 			 * some inode_item's got replayed.
7281 			 *
7282 			 * root->objectid_mutex is not acquired as log replay
7283 			 * could only happen during mount.
7284 			 */
7285 			ret = btrfs_init_root_free_objectid(root);
7286 			if (ret)
7287 				btrfs_abort_transaction(trans, ret);
7288 		}
7289 
7290 		wc.replay_dest->log_root = NULL;
7291 		btrfs_put_root(wc.replay_dest);
7292 		btrfs_put_root(log);
7293 
7294 		if (ret)
7295 			goto error;
7296 next:
7297 		if (found_key.offset == 0)
7298 			break;
7299 		key.offset = found_key.offset - 1;
7300 	}
7301 	btrfs_release_path(path);
7302 
7303 	/* step one is to pin it all, step two is to replay just inodes */
7304 	if (wc.pin) {
7305 		wc.pin = 0;
7306 		wc.process_func = replay_one_buffer;
7307 		wc.stage = LOG_WALK_REPLAY_INODES;
7308 		goto again;
7309 	}
7310 	/* step three is to replay everything */
7311 	if (wc.stage < LOG_WALK_REPLAY_ALL) {
7312 		wc.stage++;
7313 		goto again;
7314 	}
7315 
7316 	btrfs_free_path(path);
7317 
7318 	/* step 4: commit the transaction, which also unpins the blocks */
7319 	ret = btrfs_commit_transaction(trans);
7320 	if (ret)
7321 		return ret;
7322 
7323 	log_root_tree->log_root = NULL;
7324 	clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);
7325 	btrfs_put_root(log_root_tree);
7326 
7327 	return 0;
7328 error:
7329 	if (wc.trans)
7330 		btrfs_end_transaction(wc.trans);
7331 	clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);
7332 	btrfs_free_path(path);
7333 	return ret;
7334 }
7335 
7336 /*
7337  * there are some corner cases where we want to force a full
7338  * commit instead of allowing a directory to be logged.
7339  *
7340  * They revolve around files there were unlinked from the directory, and
7341  * this function updates the parent directory so that a full commit is
7342  * properly done if it is fsync'd later after the unlinks are done.
7343  *
7344  * Must be called before the unlink operations (updates to the subvolume tree,
7345  * inodes, etc) are done.
7346  */
btrfs_record_unlink_dir(struct btrfs_trans_handle * trans,struct btrfs_inode * dir,struct btrfs_inode * inode,int for_rename)7347 void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
7348 			     struct btrfs_inode *dir, struct btrfs_inode *inode,
7349 			     int for_rename)
7350 {
7351 	/*
7352 	 * when we're logging a file, if it hasn't been renamed
7353 	 * or unlinked, and its inode is fully committed on disk,
7354 	 * we don't have to worry about walking up the directory chain
7355 	 * to log its parents.
7356 	 *
7357 	 * So, we use the last_unlink_trans field to put this transid
7358 	 * into the file.  When the file is logged we check it and
7359 	 * don't log the parents if the file is fully on disk.
7360 	 */
7361 	mutex_lock(&inode->log_mutex);
7362 	inode->last_unlink_trans = trans->transid;
7363 	mutex_unlock(&inode->log_mutex);
7364 
7365 	/*
7366 	 * if this directory was already logged any new
7367 	 * names for this file/dir will get recorded
7368 	 */
7369 	if (dir->logged_trans == trans->transid)
7370 		return;
7371 
7372 	/*
7373 	 * if the inode we're about to unlink was logged,
7374 	 * the log will be properly updated for any new names
7375 	 */
7376 	if (inode->logged_trans == trans->transid)
7377 		return;
7378 
7379 	/*
7380 	 * when renaming files across directories, if the directory
7381 	 * there we're unlinking from gets fsync'd later on, there's
7382 	 * no way to find the destination directory later and fsync it
7383 	 * properly.  So, we have to be conservative and force commits
7384 	 * so the new name gets discovered.
7385 	 */
7386 	if (for_rename)
7387 		goto record;
7388 
7389 	/* we can safely do the unlink without any special recording */
7390 	return;
7391 
7392 record:
7393 	mutex_lock(&dir->log_mutex);
7394 	dir->last_unlink_trans = trans->transid;
7395 	mutex_unlock(&dir->log_mutex);
7396 }
7397 
7398 /*
7399  * Make sure that if someone attempts to fsync the parent directory of a deleted
7400  * snapshot, it ends up triggering a transaction commit. This is to guarantee
7401  * that after replaying the log tree of the parent directory's root we will not
7402  * see the snapshot anymore and at log replay time we will not see any log tree
7403  * corresponding to the deleted snapshot's root, which could lead to replaying
7404  * it after replaying the log tree of the parent directory (which would replay
7405  * the snapshot delete operation).
7406  *
7407  * Must be called before the actual snapshot destroy operation (updates to the
7408  * parent root and tree of tree roots trees, etc) are done.
7409  */
btrfs_record_snapshot_destroy(struct btrfs_trans_handle * trans,struct btrfs_inode * dir)7410 void btrfs_record_snapshot_destroy(struct btrfs_trans_handle *trans,
7411 				   struct btrfs_inode *dir)
7412 {
7413 	mutex_lock(&dir->log_mutex);
7414 	dir->last_unlink_trans = trans->transid;
7415 	mutex_unlock(&dir->log_mutex);
7416 }
7417 
7418 /**
7419  * Update the log after adding a new name for an inode.
7420  *
7421  * @trans:              Transaction handle.
7422  * @old_dentry:         The dentry associated with the old name and the old
7423  *                      parent directory.
7424  * @old_dir:            The inode of the previous parent directory for the case
7425  *                      of a rename. For a link operation, it must be NULL.
7426  * @old_dir_index:      The index number associated with the old name, meaningful
7427  *                      only for rename operations (when @old_dir is not NULL).
7428  *                      Ignored for link operations.
7429  * @parent:             The dentry associated with the directory under which the
7430  *                      new name is located.
7431  *
7432  * Call this after adding a new name for an inode, as a result of a link or
7433  * rename operation, and it will properly update the log to reflect the new name.
7434  */
btrfs_log_new_name(struct btrfs_trans_handle * trans,struct dentry * old_dentry,struct btrfs_inode * old_dir,u64 old_dir_index,struct dentry * parent)7435 void btrfs_log_new_name(struct btrfs_trans_handle *trans,
7436 			struct dentry *old_dentry, struct btrfs_inode *old_dir,
7437 			u64 old_dir_index, struct dentry *parent)
7438 {
7439 	struct btrfs_inode *inode = BTRFS_I(d_inode(old_dentry));
7440 	struct btrfs_root *root = inode->root;
7441 	struct btrfs_log_ctx ctx;
7442 	bool log_pinned = false;
7443 	int ret;
7444 
7445 	/*
7446 	 * this will force the logging code to walk the dentry chain
7447 	 * up for the file
7448 	 */
7449 	if (!S_ISDIR(inode->vfs_inode.i_mode))
7450 		inode->last_unlink_trans = trans->transid;
7451 
7452 	/*
7453 	 * if this inode hasn't been logged and directory we're renaming it
7454 	 * from hasn't been logged, we don't need to log it
7455 	 */
7456 	ret = inode_logged(trans, inode, NULL);
7457 	if (ret < 0) {
7458 		goto out;
7459 	} else if (ret == 0) {
7460 		if (!old_dir)
7461 			return;
7462 		/*
7463 		 * If the inode was not logged and we are doing a rename (old_dir is not
7464 		 * NULL), check if old_dir was logged - if it was not we can return and
7465 		 * do nothing.
7466 		 */
7467 		ret = inode_logged(trans, old_dir, NULL);
7468 		if (ret < 0)
7469 			goto out;
7470 		else if (ret == 0)
7471 			return;
7472 	}
7473 	ret = 0;
7474 
7475 	/*
7476 	 * If we are doing a rename (old_dir is not NULL) from a directory that
7477 	 * was previously logged, make sure that on log replay we get the old
7478 	 * dir entry deleted. This is needed because we will also log the new
7479 	 * name of the renamed inode, so we need to make sure that after log
7480 	 * replay we don't end up with both the new and old dir entries existing.
7481 	 */
7482 	if (old_dir && old_dir->logged_trans == trans->transid) {
7483 		struct btrfs_root *log = old_dir->root->log_root;
7484 		struct btrfs_path *path;
7485 
7486 		ASSERT(old_dir_index >= BTRFS_DIR_START_INDEX);
7487 
7488 		/*
7489 		 * We have two inodes to update in the log, the old directory and
7490 		 * the inode that got renamed, so we must pin the log to prevent
7491 		 * anyone from syncing the log until we have updated both inodes
7492 		 * in the log.
7493 		 */
7494 		ret = join_running_log_trans(root);
7495 		/*
7496 		 * At least one of the inodes was logged before, so this should
7497 		 * not fail, but if it does, it's not serious, just bail out and
7498 		 * mark the log for a full commit.
7499 		 */
7500 		if (WARN_ON_ONCE(ret < 0))
7501 			goto out;
7502 		log_pinned = true;
7503 
7504 		path = btrfs_alloc_path();
7505 		if (!path) {
7506 			ret = -ENOMEM;
7507 			goto out;
7508 		}
7509 
7510 		/*
7511 		 * Other concurrent task might be logging the old directory,
7512 		 * as it can be triggered when logging other inode that had or
7513 		 * still has a dentry in the old directory. We lock the old
7514 		 * directory's log_mutex to ensure the deletion of the old
7515 		 * name is persisted, because during directory logging we
7516 		 * delete all BTRFS_DIR_LOG_INDEX_KEY keys and the deletion of
7517 		 * the old name's dir index item is in the delayed items, so
7518 		 * it could be missed by an in progress directory logging.
7519 		 */
7520 		mutex_lock(&old_dir->log_mutex);
7521 		ret = del_logged_dentry(trans, log, path, btrfs_ino(old_dir),
7522 					old_dentry->d_name.name,
7523 					old_dentry->d_name.len, old_dir_index);
7524 		if (ret > 0) {
7525 			/*
7526 			 * The dentry does not exist in the log, so record its
7527 			 * deletion.
7528 			 */
7529 			btrfs_release_path(path);
7530 			ret = insert_dir_log_key(trans, log, path,
7531 						 btrfs_ino(old_dir),
7532 						 old_dir_index, old_dir_index);
7533 		}
7534 		mutex_unlock(&old_dir->log_mutex);
7535 
7536 		btrfs_free_path(path);
7537 		if (ret < 0)
7538 			goto out;
7539 	}
7540 
7541 	btrfs_init_log_ctx(&ctx, &inode->vfs_inode);
7542 	ctx.logging_new_name = true;
7543 	/*
7544 	 * We don't care about the return value. If we fail to log the new name
7545 	 * then we know the next attempt to sync the log will fallback to a full
7546 	 * transaction commit (due to a call to btrfs_set_log_full_commit()), so
7547 	 * we don't need to worry about getting a log committed that has an
7548 	 * inconsistent state after a rename operation.
7549 	 */
7550 	btrfs_log_inode_parent(trans, inode, parent, LOG_INODE_EXISTS, &ctx);
7551 	ASSERT(list_empty(&ctx.conflict_inodes));
7552 out:
7553 	/*
7554 	 * If an error happened mark the log for a full commit because it's not
7555 	 * consistent and up to date or we couldn't find out if one of the
7556 	 * inodes was logged before in this transaction. Do it before unpinning
7557 	 * the log, to avoid any races with someone else trying to commit it.
7558 	 */
7559 	if (ret < 0)
7560 		btrfs_set_log_full_commit(trans);
7561 	if (log_pinned)
7562 		btrfs_end_log_trans(root);
7563 }
7564 
7565