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