1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2007 Oracle.  All rights reserved.
4  */
5 
6 #include <linux/fs.h>
7 #include <linux/slab.h>
8 #include <linux/sched.h>
9 #include <linux/writeback.h>
10 #include <linux/pagemap.h>
11 #include <linux/blkdev.h>
12 #include <linux/uuid.h>
13 #include "misc.h"
14 #include "ctree.h"
15 #include "disk-io.h"
16 #include "transaction.h"
17 #include "locking.h"
18 #include "tree-log.h"
19 #include "volumes.h"
20 #include "dev-replace.h"
21 #include "qgroup.h"
22 #include "block-group.h"
23 #include "space-info.h"
24 #include "zoned.h"
25 
26 #define BTRFS_ROOT_TRANS_TAG 0
27 
28 /*
29  * Transaction states and transitions
30  *
31  * No running transaction (fs tree blocks are not modified)
32  * |
33  * | To next stage:
34  * |  Call start_transaction() variants. Except btrfs_join_transaction_nostart().
35  * V
36  * Transaction N [[TRANS_STATE_RUNNING]]
37  * |
38  * | New trans handles can be attached to transaction N by calling all
39  * | start_transaction() variants.
40  * |
41  * | To next stage:
42  * |  Call btrfs_commit_transaction() on any trans handle attached to
43  * |  transaction N
44  * V
45  * Transaction N [[TRANS_STATE_COMMIT_START]]
46  * |
47  * | Will wait for previous running transaction to completely finish if there
48  * | is one
49  * |
50  * | Then one of the following happes:
51  * | - Wait for all other trans handle holders to release.
52  * |   The btrfs_commit_transaction() caller will do the commit work.
53  * | - Wait for current transaction to be committed by others.
54  * |   Other btrfs_commit_transaction() caller will do the commit work.
55  * |
56  * | At this stage, only btrfs_join_transaction*() variants can attach
57  * | to this running transaction.
58  * | All other variants will wait for current one to finish and attach to
59  * | transaction N+1.
60  * |
61  * | To next stage:
62  * |  Caller is chosen to commit transaction N, and all other trans handle
63  * |  haven been released.
64  * V
65  * Transaction N [[TRANS_STATE_COMMIT_DOING]]
66  * |
67  * | The heavy lifting transaction work is started.
68  * | From running delayed refs (modifying extent tree) to creating pending
69  * | snapshots, running qgroups.
70  * | In short, modify supporting trees to reflect modifications of subvolume
71  * | trees.
72  * |
73  * | At this stage, all start_transaction() calls will wait for this
74  * | transaction to finish and attach to transaction N+1.
75  * |
76  * | To next stage:
77  * |  Until all supporting trees are updated.
78  * V
79  * Transaction N [[TRANS_STATE_UNBLOCKED]]
80  * |						    Transaction N+1
81  * | All needed trees are modified, thus we only    [[TRANS_STATE_RUNNING]]
82  * | need to write them back to disk and update	    |
83  * | super blocks.				    |
84  * |						    |
85  * | At this stage, new transaction is allowed to   |
86  * | start.					    |
87  * | All new start_transaction() calls will be	    |
88  * | attached to transid N+1.			    |
89  * |						    |
90  * | To next stage:				    |
91  * |  Until all tree blocks are super blocks are    |
92  * |  written to block devices			    |
93  * V						    |
94  * Transaction N [[TRANS_STATE_COMPLETED]]	    V
95  *   All tree blocks and super blocks are written.  Transaction N+1
96  *   This transaction is finished and all its	    [[TRANS_STATE_COMMIT_START]]
97  *   data structures will be cleaned up.	    | Life goes on
98  */
99 static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
100 	[TRANS_STATE_RUNNING]		= 0U,
101 	[TRANS_STATE_COMMIT_START]	= (__TRANS_START | __TRANS_ATTACH),
102 	[TRANS_STATE_COMMIT_DOING]	= (__TRANS_START |
103 					   __TRANS_ATTACH |
104 					   __TRANS_JOIN |
105 					   __TRANS_JOIN_NOSTART),
106 	[TRANS_STATE_UNBLOCKED]		= (__TRANS_START |
107 					   __TRANS_ATTACH |
108 					   __TRANS_JOIN |
109 					   __TRANS_JOIN_NOLOCK |
110 					   __TRANS_JOIN_NOSTART),
111 	[TRANS_STATE_SUPER_COMMITTED]	= (__TRANS_START |
112 					   __TRANS_ATTACH |
113 					   __TRANS_JOIN |
114 					   __TRANS_JOIN_NOLOCK |
115 					   __TRANS_JOIN_NOSTART),
116 	[TRANS_STATE_COMPLETED]		= (__TRANS_START |
117 					   __TRANS_ATTACH |
118 					   __TRANS_JOIN |
119 					   __TRANS_JOIN_NOLOCK |
120 					   __TRANS_JOIN_NOSTART),
121 };
122 
btrfs_put_transaction(struct btrfs_transaction * transaction)123 void btrfs_put_transaction(struct btrfs_transaction *transaction)
124 {
125 	WARN_ON(refcount_read(&transaction->use_count) == 0);
126 	if (refcount_dec_and_test(&transaction->use_count)) {
127 		BUG_ON(!list_empty(&transaction->list));
128 		WARN_ON(!RB_EMPTY_ROOT(
129 				&transaction->delayed_refs.href_root.rb_root));
130 		WARN_ON(!RB_EMPTY_ROOT(
131 				&transaction->delayed_refs.dirty_extent_root));
132 		if (transaction->delayed_refs.pending_csums)
133 			btrfs_err(transaction->fs_info,
134 				  "pending csums is %llu",
135 				  transaction->delayed_refs.pending_csums);
136 		/*
137 		 * If any block groups are found in ->deleted_bgs then it's
138 		 * because the transaction was aborted and a commit did not
139 		 * happen (things failed before writing the new superblock
140 		 * and calling btrfs_finish_extent_commit()), so we can not
141 		 * discard the physical locations of the block groups.
142 		 */
143 		while (!list_empty(&transaction->deleted_bgs)) {
144 			struct btrfs_block_group *cache;
145 
146 			cache = list_first_entry(&transaction->deleted_bgs,
147 						 struct btrfs_block_group,
148 						 bg_list);
149 			list_del_init(&cache->bg_list);
150 			btrfs_unfreeze_block_group(cache);
151 			btrfs_put_block_group(cache);
152 		}
153 		WARN_ON(!list_empty(&transaction->dev_update_list));
154 		kfree(transaction);
155 	}
156 }
157 
switch_commit_roots(struct btrfs_trans_handle * trans)158 static noinline void switch_commit_roots(struct btrfs_trans_handle *trans)
159 {
160 	struct btrfs_transaction *cur_trans = trans->transaction;
161 	struct btrfs_fs_info *fs_info = trans->fs_info;
162 	struct btrfs_root *root, *tmp;
163 	struct btrfs_caching_control *caching_ctl, *next;
164 
165 	/*
166 	 * At this point no one can be using this transaction to modify any tree
167 	 * and no one can start another transaction to modify any tree either.
168 	 */
169 	ASSERT(cur_trans->state == TRANS_STATE_COMMIT_DOING);
170 
171 	down_write(&fs_info->commit_root_sem);
172 
173 	if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags))
174 		fs_info->last_reloc_trans = trans->transid;
175 
176 	list_for_each_entry_safe(root, tmp, &cur_trans->switch_commits,
177 				 dirty_list) {
178 		list_del_init(&root->dirty_list);
179 		free_extent_buffer(root->commit_root);
180 		root->commit_root = btrfs_root_node(root);
181 		extent_io_tree_release(&root->dirty_log_pages);
182 		btrfs_qgroup_clean_swapped_blocks(root);
183 	}
184 
185 	/* We can free old roots now. */
186 	spin_lock(&cur_trans->dropped_roots_lock);
187 	while (!list_empty(&cur_trans->dropped_roots)) {
188 		root = list_first_entry(&cur_trans->dropped_roots,
189 					struct btrfs_root, root_list);
190 		list_del_init(&root->root_list);
191 		spin_unlock(&cur_trans->dropped_roots_lock);
192 		btrfs_free_log(trans, root);
193 		btrfs_drop_and_free_fs_root(fs_info, root);
194 		spin_lock(&cur_trans->dropped_roots_lock);
195 	}
196 	spin_unlock(&cur_trans->dropped_roots_lock);
197 
198 	/*
199 	 * We have to update the last_byte_to_unpin under the commit_root_sem,
200 	 * at the same time we swap out the commit roots.
201 	 *
202 	 * This is because we must have a real view of the last spot the caching
203 	 * kthreads were while caching.  Consider the following views of the
204 	 * extent tree for a block group
205 	 *
206 	 * commit root
207 	 * +----+----+----+----+----+----+----+
208 	 * |\\\\|    |\\\\|\\\\|    |\\\\|\\\\|
209 	 * +----+----+----+----+----+----+----+
210 	 * 0    1    2    3    4    5    6    7
211 	 *
212 	 * new commit root
213 	 * +----+----+----+----+----+----+----+
214 	 * |    |    |    |\\\\|    |    |\\\\|
215 	 * +----+----+----+----+----+----+----+
216 	 * 0    1    2    3    4    5    6    7
217 	 *
218 	 * If the cache_ctl->progress was at 3, then we are only allowed to
219 	 * unpin [0,1) and [2,3], because the caching thread has already
220 	 * processed those extents.  We are not allowed to unpin [5,6), because
221 	 * the caching thread will re-start it's search from 3, and thus find
222 	 * the hole from [4,6) to add to the free space cache.
223 	 */
224 	write_lock(&fs_info->block_group_cache_lock);
225 	list_for_each_entry_safe(caching_ctl, next,
226 				 &fs_info->caching_block_groups, list) {
227 		struct btrfs_block_group *cache = caching_ctl->block_group;
228 
229 		if (btrfs_block_group_done(cache)) {
230 			cache->last_byte_to_unpin = (u64)-1;
231 			list_del_init(&caching_ctl->list);
232 			btrfs_put_caching_control(caching_ctl);
233 		} else {
234 			cache->last_byte_to_unpin = caching_ctl->progress;
235 		}
236 	}
237 	write_unlock(&fs_info->block_group_cache_lock);
238 	up_write(&fs_info->commit_root_sem);
239 }
240 
extwriter_counter_inc(struct btrfs_transaction * trans,unsigned int type)241 static inline void extwriter_counter_inc(struct btrfs_transaction *trans,
242 					 unsigned int type)
243 {
244 	if (type & TRANS_EXTWRITERS)
245 		atomic_inc(&trans->num_extwriters);
246 }
247 
extwriter_counter_dec(struct btrfs_transaction * trans,unsigned int type)248 static inline void extwriter_counter_dec(struct btrfs_transaction *trans,
249 					 unsigned int type)
250 {
251 	if (type & TRANS_EXTWRITERS)
252 		atomic_dec(&trans->num_extwriters);
253 }
254 
extwriter_counter_init(struct btrfs_transaction * trans,unsigned int type)255 static inline void extwriter_counter_init(struct btrfs_transaction *trans,
256 					  unsigned int type)
257 {
258 	atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0));
259 }
260 
extwriter_counter_read(struct btrfs_transaction * trans)261 static inline int extwriter_counter_read(struct btrfs_transaction *trans)
262 {
263 	return atomic_read(&trans->num_extwriters);
264 }
265 
266 /*
267  * To be called after doing the chunk btree updates right after allocating a new
268  * chunk (after btrfs_chunk_alloc_add_chunk_item() is called), when removing a
269  * chunk after all chunk btree updates and after finishing the second phase of
270  * chunk allocation (btrfs_create_pending_block_groups()) in case some block
271  * group had its chunk item insertion delayed to the second phase.
272  */
btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle * trans)273 void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans)
274 {
275 	struct btrfs_fs_info *fs_info = trans->fs_info;
276 
277 	if (!trans->chunk_bytes_reserved)
278 		return;
279 
280 	btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv,
281 				trans->chunk_bytes_reserved, NULL);
282 	trans->chunk_bytes_reserved = 0;
283 }
284 
285 /*
286  * either allocate a new transaction or hop into the existing one
287  */
join_transaction(struct btrfs_fs_info * fs_info,unsigned int type)288 static noinline int join_transaction(struct btrfs_fs_info *fs_info,
289 				     unsigned int type)
290 {
291 	struct btrfs_transaction *cur_trans;
292 
293 	spin_lock(&fs_info->trans_lock);
294 loop:
295 	/* The file system has been taken offline. No new transactions. */
296 	if (BTRFS_FS_ERROR(fs_info)) {
297 		spin_unlock(&fs_info->trans_lock);
298 		return -EROFS;
299 	}
300 
301 	cur_trans = fs_info->running_transaction;
302 	if (cur_trans) {
303 		if (TRANS_ABORTED(cur_trans)) {
304 			spin_unlock(&fs_info->trans_lock);
305 			return cur_trans->aborted;
306 		}
307 		if (btrfs_blocked_trans_types[cur_trans->state] & type) {
308 			spin_unlock(&fs_info->trans_lock);
309 			return -EBUSY;
310 		}
311 		refcount_inc(&cur_trans->use_count);
312 		atomic_inc(&cur_trans->num_writers);
313 		extwriter_counter_inc(cur_trans, type);
314 		spin_unlock(&fs_info->trans_lock);
315 		return 0;
316 	}
317 	spin_unlock(&fs_info->trans_lock);
318 
319 	/*
320 	 * If we are ATTACH, we just want to catch the current transaction,
321 	 * and commit it. If there is no transaction, just return ENOENT.
322 	 */
323 	if (type == TRANS_ATTACH)
324 		return -ENOENT;
325 
326 	/*
327 	 * JOIN_NOLOCK only happens during the transaction commit, so
328 	 * it is impossible that ->running_transaction is NULL
329 	 */
330 	BUG_ON(type == TRANS_JOIN_NOLOCK);
331 
332 	cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS);
333 	if (!cur_trans)
334 		return -ENOMEM;
335 
336 	spin_lock(&fs_info->trans_lock);
337 	if (fs_info->running_transaction) {
338 		/*
339 		 * someone started a transaction after we unlocked.  Make sure
340 		 * to redo the checks above
341 		 */
342 		kfree(cur_trans);
343 		goto loop;
344 	} else if (BTRFS_FS_ERROR(fs_info)) {
345 		spin_unlock(&fs_info->trans_lock);
346 		kfree(cur_trans);
347 		return -EROFS;
348 	}
349 
350 	cur_trans->fs_info = fs_info;
351 	atomic_set(&cur_trans->pending_ordered, 0);
352 	init_waitqueue_head(&cur_trans->pending_wait);
353 	atomic_set(&cur_trans->num_writers, 1);
354 	extwriter_counter_init(cur_trans, type);
355 	init_waitqueue_head(&cur_trans->writer_wait);
356 	init_waitqueue_head(&cur_trans->commit_wait);
357 	cur_trans->state = TRANS_STATE_RUNNING;
358 	/*
359 	 * One for this trans handle, one so it will live on until we
360 	 * commit the transaction.
361 	 */
362 	refcount_set(&cur_trans->use_count, 2);
363 	cur_trans->flags = 0;
364 	cur_trans->start_time = ktime_get_seconds();
365 
366 	memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs));
367 
368 	cur_trans->delayed_refs.href_root = RB_ROOT_CACHED;
369 	cur_trans->delayed_refs.dirty_extent_root = RB_ROOT;
370 	atomic_set(&cur_trans->delayed_refs.num_entries, 0);
371 
372 	/*
373 	 * although the tree mod log is per file system and not per transaction,
374 	 * the log must never go across transaction boundaries.
375 	 */
376 	smp_mb();
377 	if (!list_empty(&fs_info->tree_mod_seq_list))
378 		WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n");
379 	if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
380 		WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n");
381 	atomic64_set(&fs_info->tree_mod_seq, 0);
382 
383 	spin_lock_init(&cur_trans->delayed_refs.lock);
384 
385 	INIT_LIST_HEAD(&cur_trans->pending_snapshots);
386 	INIT_LIST_HEAD(&cur_trans->dev_update_list);
387 	INIT_LIST_HEAD(&cur_trans->switch_commits);
388 	INIT_LIST_HEAD(&cur_trans->dirty_bgs);
389 	INIT_LIST_HEAD(&cur_trans->io_bgs);
390 	INIT_LIST_HEAD(&cur_trans->dropped_roots);
391 	mutex_init(&cur_trans->cache_write_mutex);
392 	spin_lock_init(&cur_trans->dirty_bgs_lock);
393 	INIT_LIST_HEAD(&cur_trans->deleted_bgs);
394 	spin_lock_init(&cur_trans->dropped_roots_lock);
395 	INIT_LIST_HEAD(&cur_trans->releasing_ebs);
396 	spin_lock_init(&cur_trans->releasing_ebs_lock);
397 	list_add_tail(&cur_trans->list, &fs_info->trans_list);
398 	extent_io_tree_init(fs_info, &cur_trans->dirty_pages,
399 			IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode);
400 	extent_io_tree_init(fs_info, &cur_trans->pinned_extents,
401 			IO_TREE_FS_PINNED_EXTENTS, NULL);
402 	fs_info->generation++;
403 	cur_trans->transid = fs_info->generation;
404 	fs_info->running_transaction = cur_trans;
405 	cur_trans->aborted = 0;
406 	spin_unlock(&fs_info->trans_lock);
407 
408 	return 0;
409 }
410 
411 /*
412  * This does all the record keeping required to make sure that a shareable root
413  * is properly recorded in a given transaction.  This is required to make sure
414  * the old root from before we joined the transaction is deleted when the
415  * transaction commits.
416  */
record_root_in_trans(struct btrfs_trans_handle * trans,struct btrfs_root * root,int force)417 static int record_root_in_trans(struct btrfs_trans_handle *trans,
418 			       struct btrfs_root *root,
419 			       int force)
420 {
421 	struct btrfs_fs_info *fs_info = root->fs_info;
422 	int ret = 0;
423 
424 	if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) &&
425 	    root->last_trans < trans->transid) || force) {
426 		WARN_ON(!force && root->commit_root != root->node);
427 
428 		/*
429 		 * see below for IN_TRANS_SETUP usage rules
430 		 * we have the reloc mutex held now, so there
431 		 * is only one writer in this function
432 		 */
433 		set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
434 
435 		/* make sure readers find IN_TRANS_SETUP before
436 		 * they find our root->last_trans update
437 		 */
438 		smp_wmb();
439 
440 		spin_lock(&fs_info->fs_roots_radix_lock);
441 		if (root->last_trans == trans->transid && !force) {
442 			spin_unlock(&fs_info->fs_roots_radix_lock);
443 			return 0;
444 		}
445 		radix_tree_tag_set(&fs_info->fs_roots_radix,
446 				   (unsigned long)root->root_key.objectid,
447 				   BTRFS_ROOT_TRANS_TAG);
448 		spin_unlock(&fs_info->fs_roots_radix_lock);
449 		root->last_trans = trans->transid;
450 
451 		/* this is pretty tricky.  We don't want to
452 		 * take the relocation lock in btrfs_record_root_in_trans
453 		 * unless we're really doing the first setup for this root in
454 		 * this transaction.
455 		 *
456 		 * Normally we'd use root->last_trans as a flag to decide
457 		 * if we want to take the expensive mutex.
458 		 *
459 		 * But, we have to set root->last_trans before we
460 		 * init the relocation root, otherwise, we trip over warnings
461 		 * in ctree.c.  The solution used here is to flag ourselves
462 		 * with root IN_TRANS_SETUP.  When this is 1, we're still
463 		 * fixing up the reloc trees and everyone must wait.
464 		 *
465 		 * When this is zero, they can trust root->last_trans and fly
466 		 * through btrfs_record_root_in_trans without having to take the
467 		 * lock.  smp_wmb() makes sure that all the writes above are
468 		 * done before we pop in the zero below
469 		 */
470 		ret = btrfs_init_reloc_root(trans, root);
471 		smp_mb__before_atomic();
472 		clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state);
473 	}
474 	return ret;
475 }
476 
477 
btrfs_add_dropped_root(struct btrfs_trans_handle * trans,struct btrfs_root * root)478 void btrfs_add_dropped_root(struct btrfs_trans_handle *trans,
479 			    struct btrfs_root *root)
480 {
481 	struct btrfs_fs_info *fs_info = root->fs_info;
482 	struct btrfs_transaction *cur_trans = trans->transaction;
483 
484 	/* Add ourselves to the transaction dropped list */
485 	spin_lock(&cur_trans->dropped_roots_lock);
486 	list_add_tail(&root->root_list, &cur_trans->dropped_roots);
487 	spin_unlock(&cur_trans->dropped_roots_lock);
488 
489 	/* Make sure we don't try to update the root at commit time */
490 	spin_lock(&fs_info->fs_roots_radix_lock);
491 	radix_tree_tag_clear(&fs_info->fs_roots_radix,
492 			     (unsigned long)root->root_key.objectid,
493 			     BTRFS_ROOT_TRANS_TAG);
494 	spin_unlock(&fs_info->fs_roots_radix_lock);
495 }
496 
btrfs_record_root_in_trans(struct btrfs_trans_handle * trans,struct btrfs_root * root)497 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
498 			       struct btrfs_root *root)
499 {
500 	struct btrfs_fs_info *fs_info = root->fs_info;
501 	int ret;
502 
503 	if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
504 		return 0;
505 
506 	/*
507 	 * see record_root_in_trans for comments about IN_TRANS_SETUP usage
508 	 * and barriers
509 	 */
510 	smp_rmb();
511 	if (root->last_trans == trans->transid &&
512 	    !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state))
513 		return 0;
514 
515 	mutex_lock(&fs_info->reloc_mutex);
516 	ret = record_root_in_trans(trans, root, 0);
517 	mutex_unlock(&fs_info->reloc_mutex);
518 
519 	return ret;
520 }
521 
is_transaction_blocked(struct btrfs_transaction * trans)522 static inline int is_transaction_blocked(struct btrfs_transaction *trans)
523 {
524 	return (trans->state >= TRANS_STATE_COMMIT_START &&
525 		trans->state < TRANS_STATE_UNBLOCKED &&
526 		!TRANS_ABORTED(trans));
527 }
528 
529 /* wait for commit against the current transaction to become unblocked
530  * when this is done, it is safe to start a new transaction, but the current
531  * transaction might not be fully on disk.
532  */
wait_current_trans(struct btrfs_fs_info * fs_info)533 static void wait_current_trans(struct btrfs_fs_info *fs_info)
534 {
535 	struct btrfs_transaction *cur_trans;
536 
537 	spin_lock(&fs_info->trans_lock);
538 	cur_trans = fs_info->running_transaction;
539 	if (cur_trans && is_transaction_blocked(cur_trans)) {
540 		refcount_inc(&cur_trans->use_count);
541 		spin_unlock(&fs_info->trans_lock);
542 
543 		wait_event(fs_info->transaction_wait,
544 			   cur_trans->state >= TRANS_STATE_UNBLOCKED ||
545 			   TRANS_ABORTED(cur_trans));
546 		btrfs_put_transaction(cur_trans);
547 	} else {
548 		spin_unlock(&fs_info->trans_lock);
549 	}
550 }
551 
may_wait_transaction(struct btrfs_fs_info * fs_info,int type)552 static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type)
553 {
554 	if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))
555 		return 0;
556 
557 	if (type == TRANS_START)
558 		return 1;
559 
560 	return 0;
561 }
562 
need_reserve_reloc_root(struct btrfs_root * root)563 static inline bool need_reserve_reloc_root(struct btrfs_root *root)
564 {
565 	struct btrfs_fs_info *fs_info = root->fs_info;
566 
567 	if (!fs_info->reloc_ctl ||
568 	    !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) ||
569 	    root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
570 	    root->reloc_root)
571 		return false;
572 
573 	return true;
574 }
575 
576 static struct btrfs_trans_handle *
start_transaction(struct btrfs_root * root,unsigned int num_items,unsigned int type,enum btrfs_reserve_flush_enum flush,bool enforce_qgroups)577 start_transaction(struct btrfs_root *root, unsigned int num_items,
578 		  unsigned int type, enum btrfs_reserve_flush_enum flush,
579 		  bool enforce_qgroups)
580 {
581 	struct btrfs_fs_info *fs_info = root->fs_info;
582 	struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv;
583 	struct btrfs_trans_handle *h;
584 	struct btrfs_transaction *cur_trans;
585 	u64 num_bytes = 0;
586 	u64 qgroup_reserved = 0;
587 	bool reloc_reserved = false;
588 	bool do_chunk_alloc = false;
589 	int ret;
590 
591 	if (BTRFS_FS_ERROR(fs_info))
592 		return ERR_PTR(-EROFS);
593 
594 	if (current->journal_info) {
595 		WARN_ON(type & TRANS_EXTWRITERS);
596 		h = current->journal_info;
597 		refcount_inc(&h->use_count);
598 		WARN_ON(refcount_read(&h->use_count) > 2);
599 		h->orig_rsv = h->block_rsv;
600 		h->block_rsv = NULL;
601 		goto got_it;
602 	}
603 
604 	/*
605 	 * Do the reservation before we join the transaction so we can do all
606 	 * the appropriate flushing if need be.
607 	 */
608 	if (num_items && root != fs_info->chunk_root) {
609 		struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv;
610 		u64 delayed_refs_bytes = 0;
611 
612 		qgroup_reserved = num_items * fs_info->nodesize;
613 		ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved,
614 				enforce_qgroups);
615 		if (ret)
616 			return ERR_PTR(ret);
617 
618 		/*
619 		 * We want to reserve all the bytes we may need all at once, so
620 		 * we only do 1 enospc flushing cycle per transaction start.  We
621 		 * accomplish this by simply assuming we'll do 2 x num_items
622 		 * worth of delayed refs updates in this trans handle, and
623 		 * refill that amount for whatever is missing in the reserve.
624 		 */
625 		num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items);
626 		if (flush == BTRFS_RESERVE_FLUSH_ALL &&
627 		    delayed_refs_rsv->full == 0) {
628 			delayed_refs_bytes = num_bytes;
629 			num_bytes <<= 1;
630 		}
631 
632 		/*
633 		 * Do the reservation for the relocation root creation
634 		 */
635 		if (need_reserve_reloc_root(root)) {
636 			num_bytes += fs_info->nodesize;
637 			reloc_reserved = true;
638 		}
639 
640 		ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes, flush);
641 		if (ret)
642 			goto reserve_fail;
643 		if (delayed_refs_bytes) {
644 			btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv,
645 							  delayed_refs_bytes);
646 			num_bytes -= delayed_refs_bytes;
647 		}
648 
649 		if (rsv->space_info->force_alloc)
650 			do_chunk_alloc = true;
651 	} else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL &&
652 		   !delayed_refs_rsv->full) {
653 		/*
654 		 * Some people call with btrfs_start_transaction(root, 0)
655 		 * because they can be throttled, but have some other mechanism
656 		 * for reserving space.  We still want these guys to refill the
657 		 * delayed block_rsv so just add 1 items worth of reservation
658 		 * here.
659 		 */
660 		ret = btrfs_delayed_refs_rsv_refill(fs_info, flush);
661 		if (ret)
662 			goto reserve_fail;
663 	}
664 again:
665 	h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS);
666 	if (!h) {
667 		ret = -ENOMEM;
668 		goto alloc_fail;
669 	}
670 
671 	/*
672 	 * If we are JOIN_NOLOCK we're already committing a transaction and
673 	 * waiting on this guy, so we don't need to do the sb_start_intwrite
674 	 * because we're already holding a ref.  We need this because we could
675 	 * have raced in and did an fsync() on a file which can kick a commit
676 	 * and then we deadlock with somebody doing a freeze.
677 	 *
678 	 * If we are ATTACH, it means we just want to catch the current
679 	 * transaction and commit it, so we needn't do sb_start_intwrite().
680 	 */
681 	if (type & __TRANS_FREEZABLE)
682 		sb_start_intwrite(fs_info->sb);
683 
684 	if (may_wait_transaction(fs_info, type))
685 		wait_current_trans(fs_info);
686 
687 	do {
688 		ret = join_transaction(fs_info, type);
689 		if (ret == -EBUSY) {
690 			wait_current_trans(fs_info);
691 			if (unlikely(type == TRANS_ATTACH ||
692 				     type == TRANS_JOIN_NOSTART))
693 				ret = -ENOENT;
694 		}
695 	} while (ret == -EBUSY);
696 
697 	if (ret < 0)
698 		goto join_fail;
699 
700 	cur_trans = fs_info->running_transaction;
701 
702 	h->transid = cur_trans->transid;
703 	h->transaction = cur_trans;
704 	refcount_set(&h->use_count, 1);
705 	h->fs_info = root->fs_info;
706 
707 	h->type = type;
708 	INIT_LIST_HEAD(&h->new_bgs);
709 
710 	smp_mb();
711 	if (cur_trans->state >= TRANS_STATE_COMMIT_START &&
712 	    may_wait_transaction(fs_info, type)) {
713 		current->journal_info = h;
714 		btrfs_commit_transaction(h);
715 		goto again;
716 	}
717 
718 	if (num_bytes) {
719 		trace_btrfs_space_reservation(fs_info, "transaction",
720 					      h->transid, num_bytes, 1);
721 		h->block_rsv = &fs_info->trans_block_rsv;
722 		h->bytes_reserved = num_bytes;
723 		h->reloc_reserved = reloc_reserved;
724 	}
725 
726 got_it:
727 	if (!current->journal_info)
728 		current->journal_info = h;
729 
730 	/*
731 	 * If the space_info is marked ALLOC_FORCE then we'll get upgraded to
732 	 * ALLOC_FORCE the first run through, and then we won't allocate for
733 	 * anybody else who races in later.  We don't care about the return
734 	 * value here.
735 	 */
736 	if (do_chunk_alloc && num_bytes) {
737 		u64 flags = h->block_rsv->space_info->flags;
738 
739 		btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags),
740 				  CHUNK_ALLOC_NO_FORCE);
741 	}
742 
743 	/*
744 	 * btrfs_record_root_in_trans() needs to alloc new extents, and may
745 	 * call btrfs_join_transaction() while we're also starting a
746 	 * transaction.
747 	 *
748 	 * Thus it need to be called after current->journal_info initialized,
749 	 * or we can deadlock.
750 	 */
751 	ret = btrfs_record_root_in_trans(h, root);
752 	if (ret) {
753 		/*
754 		 * The transaction handle is fully initialized and linked with
755 		 * other structures so it needs to be ended in case of errors,
756 		 * not just freed.
757 		 */
758 		btrfs_end_transaction(h);
759 		return ERR_PTR(ret);
760 	}
761 
762 	return h;
763 
764 join_fail:
765 	if (type & __TRANS_FREEZABLE)
766 		sb_end_intwrite(fs_info->sb);
767 	kmem_cache_free(btrfs_trans_handle_cachep, h);
768 alloc_fail:
769 	if (num_bytes)
770 		btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv,
771 					num_bytes, NULL);
772 reserve_fail:
773 	btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved);
774 	return ERR_PTR(ret);
775 }
776 
btrfs_start_transaction(struct btrfs_root * root,unsigned int num_items)777 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
778 						   unsigned int num_items)
779 {
780 	return start_transaction(root, num_items, TRANS_START,
781 				 BTRFS_RESERVE_FLUSH_ALL, true);
782 }
783 
btrfs_start_transaction_fallback_global_rsv(struct btrfs_root * root,unsigned int num_items)784 struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
785 					struct btrfs_root *root,
786 					unsigned int num_items)
787 {
788 	return start_transaction(root, num_items, TRANS_START,
789 				 BTRFS_RESERVE_FLUSH_ALL_STEAL, false);
790 }
791 
btrfs_join_transaction(struct btrfs_root * root)792 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
793 {
794 	return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH,
795 				 true);
796 }
797 
btrfs_join_transaction_spacecache(struct btrfs_root * root)798 struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root)
799 {
800 	return start_transaction(root, 0, TRANS_JOIN_NOLOCK,
801 				 BTRFS_RESERVE_NO_FLUSH, true);
802 }
803 
804 /*
805  * Similar to regular join but it never starts a transaction when none is
806  * running or after waiting for the current one to finish.
807  */
btrfs_join_transaction_nostart(struct btrfs_root * root)808 struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root)
809 {
810 	return start_transaction(root, 0, TRANS_JOIN_NOSTART,
811 				 BTRFS_RESERVE_NO_FLUSH, true);
812 }
813 
814 /*
815  * btrfs_attach_transaction() - catch the running transaction
816  *
817  * It is used when we want to commit the current the transaction, but
818  * don't want to start a new one.
819  *
820  * Note: If this function return -ENOENT, it just means there is no
821  * running transaction. But it is possible that the inactive transaction
822  * is still in the memory, not fully on disk. If you hope there is no
823  * inactive transaction in the fs when -ENOENT is returned, you should
824  * invoke
825  *     btrfs_attach_transaction_barrier()
826  */
btrfs_attach_transaction(struct btrfs_root * root)827 struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
828 {
829 	return start_transaction(root, 0, TRANS_ATTACH,
830 				 BTRFS_RESERVE_NO_FLUSH, true);
831 }
832 
833 /*
834  * btrfs_attach_transaction_barrier() - catch the running transaction
835  *
836  * It is similar to the above function, the difference is this one
837  * will wait for all the inactive transactions until they fully
838  * complete.
839  */
840 struct btrfs_trans_handle *
btrfs_attach_transaction_barrier(struct btrfs_root * root)841 btrfs_attach_transaction_barrier(struct btrfs_root *root)
842 {
843 	struct btrfs_trans_handle *trans;
844 
845 	trans = start_transaction(root, 0, TRANS_ATTACH,
846 				  BTRFS_RESERVE_NO_FLUSH, true);
847 	if (trans == ERR_PTR(-ENOENT))
848 		btrfs_wait_for_commit(root->fs_info, 0);
849 
850 	return trans;
851 }
852 
853 /* Wait for a transaction commit to reach at least the given state. */
wait_for_commit(struct btrfs_transaction * commit,const enum btrfs_trans_state min_state)854 static noinline void wait_for_commit(struct btrfs_transaction *commit,
855 				     const enum btrfs_trans_state min_state)
856 {
857 	struct btrfs_fs_info *fs_info = commit->fs_info;
858 	u64 transid = commit->transid;
859 	bool put = false;
860 
861 	while (1) {
862 		wait_event(commit->commit_wait, commit->state >= min_state);
863 		if (put)
864 			btrfs_put_transaction(commit);
865 
866 		if (min_state < TRANS_STATE_COMPLETED)
867 			break;
868 
869 		/*
870 		 * A transaction isn't really completed until all of the
871 		 * previous transactions are completed, but with fsync we can
872 		 * end up with SUPER_COMMITTED transactions before a COMPLETED
873 		 * transaction. Wait for those.
874 		 */
875 
876 		spin_lock(&fs_info->trans_lock);
877 		commit = list_first_entry_or_null(&fs_info->trans_list,
878 						  struct btrfs_transaction,
879 						  list);
880 		if (!commit || commit->transid > transid) {
881 			spin_unlock(&fs_info->trans_lock);
882 			break;
883 		}
884 		refcount_inc(&commit->use_count);
885 		put = true;
886 		spin_unlock(&fs_info->trans_lock);
887 	}
888 }
889 
btrfs_wait_for_commit(struct btrfs_fs_info * fs_info,u64 transid)890 int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid)
891 {
892 	struct btrfs_transaction *cur_trans = NULL, *t;
893 	int ret = 0;
894 
895 	if (transid) {
896 		if (transid <= fs_info->last_trans_committed)
897 			goto out;
898 
899 		/* find specified transaction */
900 		spin_lock(&fs_info->trans_lock);
901 		list_for_each_entry(t, &fs_info->trans_list, list) {
902 			if (t->transid == transid) {
903 				cur_trans = t;
904 				refcount_inc(&cur_trans->use_count);
905 				ret = 0;
906 				break;
907 			}
908 			if (t->transid > transid) {
909 				ret = 0;
910 				break;
911 			}
912 		}
913 		spin_unlock(&fs_info->trans_lock);
914 
915 		/*
916 		 * The specified transaction doesn't exist, or we
917 		 * raced with btrfs_commit_transaction
918 		 */
919 		if (!cur_trans) {
920 			if (transid > fs_info->last_trans_committed)
921 				ret = -EINVAL;
922 			goto out;
923 		}
924 	} else {
925 		/* find newest transaction that is committing | committed */
926 		spin_lock(&fs_info->trans_lock);
927 		list_for_each_entry_reverse(t, &fs_info->trans_list,
928 					    list) {
929 			if (t->state >= TRANS_STATE_COMMIT_START) {
930 				if (t->state == TRANS_STATE_COMPLETED)
931 					break;
932 				cur_trans = t;
933 				refcount_inc(&cur_trans->use_count);
934 				break;
935 			}
936 		}
937 		spin_unlock(&fs_info->trans_lock);
938 		if (!cur_trans)
939 			goto out;  /* nothing committing|committed */
940 	}
941 
942 	wait_for_commit(cur_trans, TRANS_STATE_COMPLETED);
943 	btrfs_put_transaction(cur_trans);
944 out:
945 	return ret;
946 }
947 
btrfs_throttle(struct btrfs_fs_info * fs_info)948 void btrfs_throttle(struct btrfs_fs_info *fs_info)
949 {
950 	wait_current_trans(fs_info);
951 }
952 
should_end_transaction(struct btrfs_trans_handle * trans)953 static bool should_end_transaction(struct btrfs_trans_handle *trans)
954 {
955 	struct btrfs_fs_info *fs_info = trans->fs_info;
956 
957 	if (btrfs_check_space_for_delayed_refs(fs_info))
958 		return true;
959 
960 	return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5);
961 }
962 
btrfs_should_end_transaction(struct btrfs_trans_handle * trans)963 bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans)
964 {
965 	struct btrfs_transaction *cur_trans = trans->transaction;
966 
967 	if (cur_trans->state >= TRANS_STATE_COMMIT_START ||
968 	    test_bit(BTRFS_DELAYED_REFS_FLUSHING, &cur_trans->delayed_refs.flags))
969 		return true;
970 
971 	return should_end_transaction(trans);
972 }
973 
btrfs_trans_release_metadata(struct btrfs_trans_handle * trans)974 static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans)
975 
976 {
977 	struct btrfs_fs_info *fs_info = trans->fs_info;
978 
979 	if (!trans->block_rsv) {
980 		ASSERT(!trans->bytes_reserved);
981 		return;
982 	}
983 
984 	if (!trans->bytes_reserved)
985 		return;
986 
987 	ASSERT(trans->block_rsv == &fs_info->trans_block_rsv);
988 	trace_btrfs_space_reservation(fs_info, "transaction",
989 				      trans->transid, trans->bytes_reserved, 0);
990 	btrfs_block_rsv_release(fs_info, trans->block_rsv,
991 				trans->bytes_reserved, NULL);
992 	trans->bytes_reserved = 0;
993 }
994 
__btrfs_end_transaction(struct btrfs_trans_handle * trans,int throttle)995 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
996 				   int throttle)
997 {
998 	struct btrfs_fs_info *info = trans->fs_info;
999 	struct btrfs_transaction *cur_trans = trans->transaction;
1000 	int err = 0;
1001 
1002 	if (refcount_read(&trans->use_count) > 1) {
1003 		refcount_dec(&trans->use_count);
1004 		trans->block_rsv = trans->orig_rsv;
1005 		return 0;
1006 	}
1007 
1008 	btrfs_trans_release_metadata(trans);
1009 	trans->block_rsv = NULL;
1010 
1011 	btrfs_create_pending_block_groups(trans);
1012 
1013 	btrfs_trans_release_chunk_metadata(trans);
1014 
1015 	if (trans->type & __TRANS_FREEZABLE)
1016 		sb_end_intwrite(info->sb);
1017 
1018 	WARN_ON(cur_trans != info->running_transaction);
1019 	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
1020 	atomic_dec(&cur_trans->num_writers);
1021 	extwriter_counter_dec(cur_trans, trans->type);
1022 
1023 	cond_wake_up(&cur_trans->writer_wait);
1024 	btrfs_put_transaction(cur_trans);
1025 
1026 	if (current->journal_info == trans)
1027 		current->journal_info = NULL;
1028 
1029 	if (throttle)
1030 		btrfs_run_delayed_iputs(info);
1031 
1032 	if (TRANS_ABORTED(trans) || BTRFS_FS_ERROR(info)) {
1033 		wake_up_process(info->transaction_kthread);
1034 		if (TRANS_ABORTED(trans))
1035 			err = trans->aborted;
1036 		else
1037 			err = -EROFS;
1038 	}
1039 
1040 	kmem_cache_free(btrfs_trans_handle_cachep, trans);
1041 	return err;
1042 }
1043 
btrfs_end_transaction(struct btrfs_trans_handle * trans)1044 int btrfs_end_transaction(struct btrfs_trans_handle *trans)
1045 {
1046 	return __btrfs_end_transaction(trans, 0);
1047 }
1048 
btrfs_end_transaction_throttle(struct btrfs_trans_handle * trans)1049 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans)
1050 {
1051 	return __btrfs_end_transaction(trans, 1);
1052 }
1053 
1054 /*
1055  * when btree blocks are allocated, they have some corresponding bits set for
1056  * them in one of two extent_io trees.  This is used to make sure all of
1057  * those extents are sent to disk but does not wait on them
1058  */
btrfs_write_marked_extents(struct btrfs_fs_info * fs_info,struct extent_io_tree * dirty_pages,int mark)1059 int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,
1060 			       struct extent_io_tree *dirty_pages, int mark)
1061 {
1062 	int err = 0;
1063 	int werr = 0;
1064 	struct address_space *mapping = fs_info->btree_inode->i_mapping;
1065 	struct extent_state *cached_state = NULL;
1066 	u64 start = 0;
1067 	u64 end;
1068 
1069 	atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers);
1070 	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
1071 				      mark, &cached_state)) {
1072 		bool wait_writeback = false;
1073 
1074 		err = convert_extent_bit(dirty_pages, start, end,
1075 					 EXTENT_NEED_WAIT,
1076 					 mark, &cached_state);
1077 		/*
1078 		 * convert_extent_bit can return -ENOMEM, which is most of the
1079 		 * time a temporary error. So when it happens, ignore the error
1080 		 * and wait for writeback of this range to finish - because we
1081 		 * failed to set the bit EXTENT_NEED_WAIT for the range, a call
1082 		 * to __btrfs_wait_marked_extents() would not know that
1083 		 * writeback for this range started and therefore wouldn't
1084 		 * wait for it to finish - we don't want to commit a
1085 		 * superblock that points to btree nodes/leafs for which
1086 		 * writeback hasn't finished yet (and without errors).
1087 		 * We cleanup any entries left in the io tree when committing
1088 		 * the transaction (through extent_io_tree_release()).
1089 		 */
1090 		if (err == -ENOMEM) {
1091 			err = 0;
1092 			wait_writeback = true;
1093 		}
1094 		if (!err)
1095 			err = filemap_fdatawrite_range(mapping, start, end);
1096 		if (err)
1097 			werr = err;
1098 		else if (wait_writeback)
1099 			werr = filemap_fdatawait_range(mapping, start, end);
1100 		free_extent_state(cached_state);
1101 		cached_state = NULL;
1102 		cond_resched();
1103 		start = end + 1;
1104 	}
1105 	atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers);
1106 	return werr;
1107 }
1108 
1109 /*
1110  * when btree blocks are allocated, they have some corresponding bits set for
1111  * them in one of two extent_io trees.  This is used to make sure all of
1112  * those extents are on disk for transaction or log commit.  We wait
1113  * on all the pages and clear them from the dirty pages state tree
1114  */
__btrfs_wait_marked_extents(struct btrfs_fs_info * fs_info,struct extent_io_tree * dirty_pages)1115 static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info,
1116 				       struct extent_io_tree *dirty_pages)
1117 {
1118 	int err = 0;
1119 	int werr = 0;
1120 	struct address_space *mapping = fs_info->btree_inode->i_mapping;
1121 	struct extent_state *cached_state = NULL;
1122 	u64 start = 0;
1123 	u64 end;
1124 
1125 	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
1126 				      EXTENT_NEED_WAIT, &cached_state)) {
1127 		/*
1128 		 * Ignore -ENOMEM errors returned by clear_extent_bit().
1129 		 * When committing the transaction, we'll remove any entries
1130 		 * left in the io tree. For a log commit, we don't remove them
1131 		 * after committing the log because the tree can be accessed
1132 		 * concurrently - we do it only at transaction commit time when
1133 		 * it's safe to do it (through extent_io_tree_release()).
1134 		 */
1135 		err = clear_extent_bit(dirty_pages, start, end,
1136 				       EXTENT_NEED_WAIT, 0, 0, &cached_state);
1137 		if (err == -ENOMEM)
1138 			err = 0;
1139 		if (!err)
1140 			err = filemap_fdatawait_range(mapping, start, end);
1141 		if (err)
1142 			werr = err;
1143 		free_extent_state(cached_state);
1144 		cached_state = NULL;
1145 		cond_resched();
1146 		start = end + 1;
1147 	}
1148 	if (err)
1149 		werr = err;
1150 	return werr;
1151 }
1152 
btrfs_wait_extents(struct btrfs_fs_info * fs_info,struct extent_io_tree * dirty_pages)1153 static int btrfs_wait_extents(struct btrfs_fs_info *fs_info,
1154 		       struct extent_io_tree *dirty_pages)
1155 {
1156 	bool errors = false;
1157 	int err;
1158 
1159 	err = __btrfs_wait_marked_extents(fs_info, dirty_pages);
1160 	if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags))
1161 		errors = true;
1162 
1163 	if (errors && !err)
1164 		err = -EIO;
1165 	return err;
1166 }
1167 
btrfs_wait_tree_log_extents(struct btrfs_root * log_root,int mark)1168 int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark)
1169 {
1170 	struct btrfs_fs_info *fs_info = log_root->fs_info;
1171 	struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages;
1172 	bool errors = false;
1173 	int err;
1174 
1175 	ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
1176 
1177 	err = __btrfs_wait_marked_extents(fs_info, dirty_pages);
1178 	if ((mark & EXTENT_DIRTY) &&
1179 	    test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags))
1180 		errors = true;
1181 
1182 	if ((mark & EXTENT_NEW) &&
1183 	    test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags))
1184 		errors = true;
1185 
1186 	if (errors && !err)
1187 		err = -EIO;
1188 	return err;
1189 }
1190 
1191 /*
1192  * When btree blocks are allocated the corresponding extents are marked dirty.
1193  * This function ensures such extents are persisted on disk for transaction or
1194  * log commit.
1195  *
1196  * @trans: transaction whose dirty pages we'd like to write
1197  */
btrfs_write_and_wait_transaction(struct btrfs_trans_handle * trans)1198 static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans)
1199 {
1200 	int ret;
1201 	int ret2;
1202 	struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages;
1203 	struct btrfs_fs_info *fs_info = trans->fs_info;
1204 	struct blk_plug plug;
1205 
1206 	blk_start_plug(&plug);
1207 	ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY);
1208 	blk_finish_plug(&plug);
1209 	ret2 = btrfs_wait_extents(fs_info, dirty_pages);
1210 
1211 	extent_io_tree_release(&trans->transaction->dirty_pages);
1212 
1213 	if (ret)
1214 		return ret;
1215 	else if (ret2)
1216 		return ret2;
1217 	else
1218 		return 0;
1219 }
1220 
1221 /*
1222  * this is used to update the root pointer in the tree of tree roots.
1223  *
1224  * But, in the case of the extent allocation tree, updating the root
1225  * pointer may allocate blocks which may change the root of the extent
1226  * allocation tree.
1227  *
1228  * So, this loops and repeats and makes sure the cowonly root didn't
1229  * change while the root pointer was being updated in the metadata.
1230  */
update_cowonly_root(struct btrfs_trans_handle * trans,struct btrfs_root * root)1231 static int update_cowonly_root(struct btrfs_trans_handle *trans,
1232 			       struct btrfs_root *root)
1233 {
1234 	int ret;
1235 	u64 old_root_bytenr;
1236 	u64 old_root_used;
1237 	struct btrfs_fs_info *fs_info = root->fs_info;
1238 	struct btrfs_root *tree_root = fs_info->tree_root;
1239 
1240 	old_root_used = btrfs_root_used(&root->root_item);
1241 
1242 	while (1) {
1243 		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
1244 		if (old_root_bytenr == root->node->start &&
1245 		    old_root_used == btrfs_root_used(&root->root_item))
1246 			break;
1247 
1248 		btrfs_set_root_node(&root->root_item, root->node);
1249 		ret = btrfs_update_root(trans, tree_root,
1250 					&root->root_key,
1251 					&root->root_item);
1252 		if (ret)
1253 			return ret;
1254 
1255 		old_root_used = btrfs_root_used(&root->root_item);
1256 	}
1257 
1258 	return 0;
1259 }
1260 
1261 /*
1262  * update all the cowonly tree roots on disk
1263  *
1264  * The error handling in this function may not be obvious. Any of the
1265  * failures will cause the file system to go offline. We still need
1266  * to clean up the delayed refs.
1267  */
commit_cowonly_roots(struct btrfs_trans_handle * trans)1268 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans)
1269 {
1270 	struct btrfs_fs_info *fs_info = trans->fs_info;
1271 	struct list_head *dirty_bgs = &trans->transaction->dirty_bgs;
1272 	struct list_head *io_bgs = &trans->transaction->io_bgs;
1273 	struct list_head *next;
1274 	struct extent_buffer *eb;
1275 	int ret;
1276 
1277 	/*
1278 	 * At this point no one can be using this transaction to modify any tree
1279 	 * and no one can start another transaction to modify any tree either.
1280 	 */
1281 	ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING);
1282 
1283 	eb = btrfs_lock_root_node(fs_info->tree_root);
1284 	ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
1285 			      0, &eb, BTRFS_NESTING_COW);
1286 	btrfs_tree_unlock(eb);
1287 	free_extent_buffer(eb);
1288 
1289 	if (ret)
1290 		return ret;
1291 
1292 	ret = btrfs_run_dev_stats(trans);
1293 	if (ret)
1294 		return ret;
1295 	ret = btrfs_run_dev_replace(trans);
1296 	if (ret)
1297 		return ret;
1298 	ret = btrfs_run_qgroups(trans);
1299 	if (ret)
1300 		return ret;
1301 
1302 	ret = btrfs_setup_space_cache(trans);
1303 	if (ret)
1304 		return ret;
1305 
1306 again:
1307 	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
1308 		struct btrfs_root *root;
1309 		next = fs_info->dirty_cowonly_roots.next;
1310 		list_del_init(next);
1311 		root = list_entry(next, struct btrfs_root, dirty_list);
1312 		clear_bit(BTRFS_ROOT_DIRTY, &root->state);
1313 
1314 		list_add_tail(&root->dirty_list,
1315 			      &trans->transaction->switch_commits);
1316 		ret = update_cowonly_root(trans, root);
1317 		if (ret)
1318 			return ret;
1319 	}
1320 
1321 	/* Now flush any delayed refs generated by updating all of the roots */
1322 	ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1323 	if (ret)
1324 		return ret;
1325 
1326 	while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) {
1327 		ret = btrfs_write_dirty_block_groups(trans);
1328 		if (ret)
1329 			return ret;
1330 
1331 		/*
1332 		 * We're writing the dirty block groups, which could generate
1333 		 * delayed refs, which could generate more dirty block groups,
1334 		 * so we want to keep this flushing in this loop to make sure
1335 		 * everything gets run.
1336 		 */
1337 		ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1338 		if (ret)
1339 			return ret;
1340 	}
1341 
1342 	if (!list_empty(&fs_info->dirty_cowonly_roots))
1343 		goto again;
1344 
1345 	/* Update dev-replace pointer once everything is committed */
1346 	fs_info->dev_replace.committed_cursor_left =
1347 		fs_info->dev_replace.cursor_left_last_write_of_item;
1348 
1349 	return 0;
1350 }
1351 
1352 /*
1353  * If we had a pending drop we need to see if there are any others left in our
1354  * dead roots list, and if not clear our bit and wake any waiters.
1355  */
btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info * fs_info)1356 void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info)
1357 {
1358 	/*
1359 	 * We put the drop in progress roots at the front of the list, so if the
1360 	 * first entry doesn't have UNFINISHED_DROP set we can wake everybody
1361 	 * up.
1362 	 */
1363 	spin_lock(&fs_info->trans_lock);
1364 	if (!list_empty(&fs_info->dead_roots)) {
1365 		struct btrfs_root *root = list_first_entry(&fs_info->dead_roots,
1366 							   struct btrfs_root,
1367 							   root_list);
1368 		if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) {
1369 			spin_unlock(&fs_info->trans_lock);
1370 			return;
1371 		}
1372 	}
1373 	spin_unlock(&fs_info->trans_lock);
1374 
1375 	btrfs_wake_unfinished_drop(fs_info);
1376 }
1377 
1378 /*
1379  * dead roots are old snapshots that need to be deleted.  This allocates
1380  * a dirty root struct and adds it into the list of dead roots that need to
1381  * be deleted
1382  */
btrfs_add_dead_root(struct btrfs_root * root)1383 void btrfs_add_dead_root(struct btrfs_root *root)
1384 {
1385 	struct btrfs_fs_info *fs_info = root->fs_info;
1386 
1387 	spin_lock(&fs_info->trans_lock);
1388 	if (list_empty(&root->root_list)) {
1389 		btrfs_grab_root(root);
1390 
1391 		/* We want to process the partially complete drops first. */
1392 		if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state))
1393 			list_add(&root->root_list, &fs_info->dead_roots);
1394 		else
1395 			list_add_tail(&root->root_list, &fs_info->dead_roots);
1396 	}
1397 	spin_unlock(&fs_info->trans_lock);
1398 }
1399 
1400 /*
1401  * Update each subvolume root and its relocation root, if it exists, in the tree
1402  * of tree roots. Also free log roots if they exist.
1403  */
commit_fs_roots(struct btrfs_trans_handle * trans)1404 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans)
1405 {
1406 	struct btrfs_fs_info *fs_info = trans->fs_info;
1407 	struct btrfs_root *gang[8];
1408 	int i;
1409 	int ret;
1410 
1411 	/*
1412 	 * At this point no one can be using this transaction to modify any tree
1413 	 * and no one can start another transaction to modify any tree either.
1414 	 */
1415 	ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING);
1416 
1417 	spin_lock(&fs_info->fs_roots_radix_lock);
1418 	while (1) {
1419 		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
1420 						 (void **)gang, 0,
1421 						 ARRAY_SIZE(gang),
1422 						 BTRFS_ROOT_TRANS_TAG);
1423 		if (ret == 0)
1424 			break;
1425 		for (i = 0; i < ret; i++) {
1426 			struct btrfs_root *root = gang[i];
1427 			int ret2;
1428 
1429 			/*
1430 			 * At this point we can neither have tasks logging inodes
1431 			 * from a root nor trying to commit a log tree.
1432 			 */
1433 			ASSERT(atomic_read(&root->log_writers) == 0);
1434 			ASSERT(atomic_read(&root->log_commit[0]) == 0);
1435 			ASSERT(atomic_read(&root->log_commit[1]) == 0);
1436 
1437 			radix_tree_tag_clear(&fs_info->fs_roots_radix,
1438 					(unsigned long)root->root_key.objectid,
1439 					BTRFS_ROOT_TRANS_TAG);
1440 			spin_unlock(&fs_info->fs_roots_radix_lock);
1441 
1442 			btrfs_free_log(trans, root);
1443 			ret2 = btrfs_update_reloc_root(trans, root);
1444 			if (ret2)
1445 				return ret2;
1446 
1447 			/* see comments in should_cow_block() */
1448 			clear_bit(BTRFS_ROOT_FORCE_COW, &root->state);
1449 			smp_mb__after_atomic();
1450 
1451 			if (root->commit_root != root->node) {
1452 				list_add_tail(&root->dirty_list,
1453 					&trans->transaction->switch_commits);
1454 				btrfs_set_root_node(&root->root_item,
1455 						    root->node);
1456 			}
1457 
1458 			ret2 = btrfs_update_root(trans, fs_info->tree_root,
1459 						&root->root_key,
1460 						&root->root_item);
1461 			if (ret2)
1462 				return ret2;
1463 			spin_lock(&fs_info->fs_roots_radix_lock);
1464 			btrfs_qgroup_free_meta_all_pertrans(root);
1465 		}
1466 	}
1467 	spin_unlock(&fs_info->fs_roots_radix_lock);
1468 	return 0;
1469 }
1470 
1471 /*
1472  * defrag a given btree.
1473  * Every leaf in the btree is read and defragged.
1474  */
btrfs_defrag_root(struct btrfs_root * root)1475 int btrfs_defrag_root(struct btrfs_root *root)
1476 {
1477 	struct btrfs_fs_info *info = root->fs_info;
1478 	struct btrfs_trans_handle *trans;
1479 	int ret;
1480 
1481 	if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state))
1482 		return 0;
1483 
1484 	while (1) {
1485 		trans = btrfs_start_transaction(root, 0);
1486 		if (IS_ERR(trans)) {
1487 			ret = PTR_ERR(trans);
1488 			break;
1489 		}
1490 
1491 		ret = btrfs_defrag_leaves(trans, root);
1492 
1493 		btrfs_end_transaction(trans);
1494 		btrfs_btree_balance_dirty(info);
1495 		cond_resched();
1496 
1497 		if (btrfs_fs_closing(info) || ret != -EAGAIN)
1498 			break;
1499 
1500 		if (btrfs_defrag_cancelled(info)) {
1501 			btrfs_debug(info, "defrag_root cancelled");
1502 			ret = -EAGAIN;
1503 			break;
1504 		}
1505 	}
1506 	clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state);
1507 	return ret;
1508 }
1509 
1510 /*
1511  * Do all special snapshot related qgroup dirty hack.
1512  *
1513  * Will do all needed qgroup inherit and dirty hack like switch commit
1514  * roots inside one transaction and write all btree into disk, to make
1515  * qgroup works.
1516  */
qgroup_account_snapshot(struct btrfs_trans_handle * trans,struct btrfs_root * src,struct btrfs_root * parent,struct btrfs_qgroup_inherit * inherit,u64 dst_objectid)1517 static int qgroup_account_snapshot(struct btrfs_trans_handle *trans,
1518 				   struct btrfs_root *src,
1519 				   struct btrfs_root *parent,
1520 				   struct btrfs_qgroup_inherit *inherit,
1521 				   u64 dst_objectid)
1522 {
1523 	struct btrfs_fs_info *fs_info = src->fs_info;
1524 	int ret;
1525 
1526 	/*
1527 	 * Save some performance in the case that qgroups are not
1528 	 * enabled. If this check races with the ioctl, rescan will
1529 	 * kick in anyway.
1530 	 */
1531 	if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags))
1532 		return 0;
1533 
1534 	/*
1535 	 * Ensure dirty @src will be committed.  Or, after coming
1536 	 * commit_fs_roots() and switch_commit_roots(), any dirty but not
1537 	 * recorded root will never be updated again, causing an outdated root
1538 	 * item.
1539 	 */
1540 	ret = record_root_in_trans(trans, src, 1);
1541 	if (ret)
1542 		return ret;
1543 
1544 	/*
1545 	 * btrfs_qgroup_inherit relies on a consistent view of the usage for the
1546 	 * src root, so we must run the delayed refs here.
1547 	 *
1548 	 * However this isn't particularly fool proof, because there's no
1549 	 * synchronization keeping us from changing the tree after this point
1550 	 * before we do the qgroup_inherit, or even from making changes while
1551 	 * we're doing the qgroup_inherit.  But that's a problem for the future,
1552 	 * for now flush the delayed refs to narrow the race window where the
1553 	 * qgroup counters could end up wrong.
1554 	 */
1555 	ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
1556 	if (ret) {
1557 		btrfs_abort_transaction(trans, ret);
1558 		return ret;
1559 	}
1560 
1561 	ret = commit_fs_roots(trans);
1562 	if (ret)
1563 		goto out;
1564 	ret = btrfs_qgroup_account_extents(trans);
1565 	if (ret < 0)
1566 		goto out;
1567 
1568 	/* Now qgroup are all updated, we can inherit it to new qgroups */
1569 	ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid,
1570 				   inherit);
1571 	if (ret < 0)
1572 		goto out;
1573 
1574 	/*
1575 	 * Now we do a simplified commit transaction, which will:
1576 	 * 1) commit all subvolume and extent tree
1577 	 *    To ensure all subvolume and extent tree have a valid
1578 	 *    commit_root to accounting later insert_dir_item()
1579 	 * 2) write all btree blocks onto disk
1580 	 *    This is to make sure later btree modification will be cowed
1581 	 *    Or commit_root can be populated and cause wrong qgroup numbers
1582 	 * In this simplified commit, we don't really care about other trees
1583 	 * like chunk and root tree, as they won't affect qgroup.
1584 	 * And we don't write super to avoid half committed status.
1585 	 */
1586 	ret = commit_cowonly_roots(trans);
1587 	if (ret)
1588 		goto out;
1589 	switch_commit_roots(trans);
1590 	ret = btrfs_write_and_wait_transaction(trans);
1591 	if (ret)
1592 		btrfs_handle_fs_error(fs_info, ret,
1593 			"Error while writing out transaction for qgroup");
1594 
1595 out:
1596 	/*
1597 	 * Force parent root to be updated, as we recorded it before so its
1598 	 * last_trans == cur_transid.
1599 	 * Or it won't be committed again onto disk after later
1600 	 * insert_dir_item()
1601 	 */
1602 	if (!ret)
1603 		ret = record_root_in_trans(trans, parent, 1);
1604 	return ret;
1605 }
1606 
1607 /*
1608  * new snapshots need to be created at a very specific time in the
1609  * transaction commit.  This does the actual creation.
1610  *
1611  * Note:
1612  * If the error which may affect the commitment of the current transaction
1613  * happens, we should return the error number. If the error which just affect
1614  * the creation of the pending snapshots, just return 0.
1615  */
create_pending_snapshot(struct btrfs_trans_handle * trans,struct btrfs_pending_snapshot * pending)1616 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1617 				   struct btrfs_pending_snapshot *pending)
1618 {
1619 
1620 	struct btrfs_fs_info *fs_info = trans->fs_info;
1621 	struct btrfs_key key;
1622 	struct btrfs_root_item *new_root_item;
1623 	struct btrfs_root *tree_root = fs_info->tree_root;
1624 	struct btrfs_root *root = pending->root;
1625 	struct btrfs_root *parent_root;
1626 	struct btrfs_block_rsv *rsv;
1627 	struct inode *parent_inode;
1628 	struct btrfs_path *path;
1629 	struct btrfs_dir_item *dir_item;
1630 	struct dentry *dentry;
1631 	struct extent_buffer *tmp;
1632 	struct extent_buffer *old;
1633 	struct timespec64 cur_time;
1634 	int ret = 0;
1635 	u64 to_reserve = 0;
1636 	u64 index = 0;
1637 	u64 objectid;
1638 	u64 root_flags;
1639 
1640 	ASSERT(pending->path);
1641 	path = pending->path;
1642 
1643 	ASSERT(pending->root_item);
1644 	new_root_item = pending->root_item;
1645 
1646 	pending->error = btrfs_get_free_objectid(tree_root, &objectid);
1647 	if (pending->error)
1648 		goto no_free_objectid;
1649 
1650 	/*
1651 	 * Make qgroup to skip current new snapshot's qgroupid, as it is
1652 	 * accounted by later btrfs_qgroup_inherit().
1653 	 */
1654 	btrfs_set_skip_qgroup(trans, objectid);
1655 
1656 	btrfs_reloc_pre_snapshot(pending, &to_reserve);
1657 
1658 	if (to_reserve > 0) {
1659 		pending->error = btrfs_block_rsv_add(fs_info,
1660 						     &pending->block_rsv,
1661 						     to_reserve,
1662 						     BTRFS_RESERVE_NO_FLUSH);
1663 		if (pending->error)
1664 			goto clear_skip_qgroup;
1665 	}
1666 
1667 	key.objectid = objectid;
1668 	key.offset = (u64)-1;
1669 	key.type = BTRFS_ROOT_ITEM_KEY;
1670 
1671 	rsv = trans->block_rsv;
1672 	trans->block_rsv = &pending->block_rsv;
1673 	trans->bytes_reserved = trans->block_rsv->reserved;
1674 	trace_btrfs_space_reservation(fs_info, "transaction",
1675 				      trans->transid,
1676 				      trans->bytes_reserved, 1);
1677 	dentry = pending->dentry;
1678 	parent_inode = pending->dir;
1679 	parent_root = BTRFS_I(parent_inode)->root;
1680 	ret = record_root_in_trans(trans, parent_root, 0);
1681 	if (ret)
1682 		goto fail;
1683 	cur_time = current_time(parent_inode);
1684 
1685 	/*
1686 	 * insert the directory item
1687 	 */
1688 	ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index);
1689 	BUG_ON(ret); /* -ENOMEM */
1690 
1691 	/* check if there is a file/dir which has the same name. */
1692 	dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
1693 					 btrfs_ino(BTRFS_I(parent_inode)),
1694 					 dentry->d_name.name,
1695 					 dentry->d_name.len, 0);
1696 	if (dir_item != NULL && !IS_ERR(dir_item)) {
1697 		pending->error = -EEXIST;
1698 		goto dir_item_existed;
1699 	} else if (IS_ERR(dir_item)) {
1700 		ret = PTR_ERR(dir_item);
1701 		btrfs_abort_transaction(trans, ret);
1702 		goto fail;
1703 	}
1704 	btrfs_release_path(path);
1705 
1706 	/*
1707 	 * pull in the delayed directory update
1708 	 * and the delayed inode item
1709 	 * otherwise we corrupt the FS during
1710 	 * snapshot
1711 	 */
1712 	ret = btrfs_run_delayed_items(trans);
1713 	if (ret) {	/* Transaction aborted */
1714 		btrfs_abort_transaction(trans, ret);
1715 		goto fail;
1716 	}
1717 
1718 	ret = record_root_in_trans(trans, root, 0);
1719 	if (ret) {
1720 		btrfs_abort_transaction(trans, ret);
1721 		goto fail;
1722 	}
1723 	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
1724 	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1725 	btrfs_check_and_init_root_item(new_root_item);
1726 
1727 	root_flags = btrfs_root_flags(new_root_item);
1728 	if (pending->readonly)
1729 		root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
1730 	else
1731 		root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
1732 	btrfs_set_root_flags(new_root_item, root_flags);
1733 
1734 	btrfs_set_root_generation_v2(new_root_item,
1735 			trans->transid);
1736 	generate_random_guid(new_root_item->uuid);
1737 	memcpy(new_root_item->parent_uuid, root->root_item.uuid,
1738 			BTRFS_UUID_SIZE);
1739 	if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) {
1740 		memset(new_root_item->received_uuid, 0,
1741 		       sizeof(new_root_item->received_uuid));
1742 		memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
1743 		memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
1744 		btrfs_set_root_stransid(new_root_item, 0);
1745 		btrfs_set_root_rtransid(new_root_item, 0);
1746 	}
1747 	btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec);
1748 	btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec);
1749 	btrfs_set_root_otransid(new_root_item, trans->transid);
1750 
1751 	old = btrfs_lock_root_node(root);
1752 	ret = btrfs_cow_block(trans, root, old, NULL, 0, &old,
1753 			      BTRFS_NESTING_COW);
1754 	if (ret) {
1755 		btrfs_tree_unlock(old);
1756 		free_extent_buffer(old);
1757 		btrfs_abort_transaction(trans, ret);
1758 		goto fail;
1759 	}
1760 
1761 	ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1762 	/* clean up in any case */
1763 	btrfs_tree_unlock(old);
1764 	free_extent_buffer(old);
1765 	if (ret) {
1766 		btrfs_abort_transaction(trans, ret);
1767 		goto fail;
1768 	}
1769 	/* see comments in should_cow_block() */
1770 	set_bit(BTRFS_ROOT_FORCE_COW, &root->state);
1771 	smp_wmb();
1772 
1773 	btrfs_set_root_node(new_root_item, tmp);
1774 	/* record when the snapshot was created in key.offset */
1775 	key.offset = trans->transid;
1776 	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1777 	btrfs_tree_unlock(tmp);
1778 	free_extent_buffer(tmp);
1779 	if (ret) {
1780 		btrfs_abort_transaction(trans, ret);
1781 		goto fail;
1782 	}
1783 
1784 	/*
1785 	 * insert root back/forward references
1786 	 */
1787 	ret = btrfs_add_root_ref(trans, objectid,
1788 				 parent_root->root_key.objectid,
1789 				 btrfs_ino(BTRFS_I(parent_inode)), index,
1790 				 dentry->d_name.name, dentry->d_name.len);
1791 	if (ret) {
1792 		btrfs_abort_transaction(trans, ret);
1793 		goto fail;
1794 	}
1795 
1796 	key.offset = (u64)-1;
1797 	pending->snap = btrfs_get_new_fs_root(fs_info, objectid, pending->anon_dev);
1798 	if (IS_ERR(pending->snap)) {
1799 		ret = PTR_ERR(pending->snap);
1800 		pending->snap = NULL;
1801 		btrfs_abort_transaction(trans, ret);
1802 		goto fail;
1803 	}
1804 
1805 	ret = btrfs_reloc_post_snapshot(trans, pending);
1806 	if (ret) {
1807 		btrfs_abort_transaction(trans, ret);
1808 		goto fail;
1809 	}
1810 
1811 	/*
1812 	 * Do special qgroup accounting for snapshot, as we do some qgroup
1813 	 * snapshot hack to do fast snapshot.
1814 	 * To co-operate with that hack, we do hack again.
1815 	 * Or snapshot will be greatly slowed down by a subtree qgroup rescan
1816 	 */
1817 	ret = qgroup_account_snapshot(trans, root, parent_root,
1818 				      pending->inherit, objectid);
1819 	if (ret < 0)
1820 		goto fail;
1821 
1822 	ret = btrfs_insert_dir_item(trans, dentry->d_name.name,
1823 				    dentry->d_name.len, BTRFS_I(parent_inode),
1824 				    &key, BTRFS_FT_DIR, index);
1825 	/* We have check then name at the beginning, so it is impossible. */
1826 	BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
1827 	if (ret) {
1828 		btrfs_abort_transaction(trans, ret);
1829 		goto fail;
1830 	}
1831 
1832 	btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size +
1833 					 dentry->d_name.len * 2);
1834 	parent_inode->i_mtime = parent_inode->i_ctime =
1835 		current_time(parent_inode);
1836 	ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode));
1837 	if (ret) {
1838 		btrfs_abort_transaction(trans, ret);
1839 		goto fail;
1840 	}
1841 	ret = btrfs_uuid_tree_add(trans, new_root_item->uuid,
1842 				  BTRFS_UUID_KEY_SUBVOL,
1843 				  objectid);
1844 	if (ret) {
1845 		btrfs_abort_transaction(trans, ret);
1846 		goto fail;
1847 	}
1848 	if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) {
1849 		ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid,
1850 					  BTRFS_UUID_KEY_RECEIVED_SUBVOL,
1851 					  objectid);
1852 		if (ret && ret != -EEXIST) {
1853 			btrfs_abort_transaction(trans, ret);
1854 			goto fail;
1855 		}
1856 	}
1857 
1858 fail:
1859 	pending->error = ret;
1860 dir_item_existed:
1861 	trans->block_rsv = rsv;
1862 	trans->bytes_reserved = 0;
1863 clear_skip_qgroup:
1864 	btrfs_clear_skip_qgroup(trans);
1865 no_free_objectid:
1866 	kfree(new_root_item);
1867 	pending->root_item = NULL;
1868 	btrfs_free_path(path);
1869 	pending->path = NULL;
1870 
1871 	return ret;
1872 }
1873 
1874 /*
1875  * create all the snapshots we've scheduled for creation
1876  */
create_pending_snapshots(struct btrfs_trans_handle * trans)1877 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans)
1878 {
1879 	struct btrfs_pending_snapshot *pending, *next;
1880 	struct list_head *head = &trans->transaction->pending_snapshots;
1881 	int ret = 0;
1882 
1883 	list_for_each_entry_safe(pending, next, head, list) {
1884 		list_del(&pending->list);
1885 		ret = create_pending_snapshot(trans, pending);
1886 		if (ret)
1887 			break;
1888 	}
1889 	return ret;
1890 }
1891 
update_super_roots(struct btrfs_fs_info * fs_info)1892 static void update_super_roots(struct btrfs_fs_info *fs_info)
1893 {
1894 	struct btrfs_root_item *root_item;
1895 	struct btrfs_super_block *super;
1896 
1897 	super = fs_info->super_copy;
1898 
1899 	root_item = &fs_info->chunk_root->root_item;
1900 	super->chunk_root = root_item->bytenr;
1901 	super->chunk_root_generation = root_item->generation;
1902 	super->chunk_root_level = root_item->level;
1903 
1904 	root_item = &fs_info->tree_root->root_item;
1905 	super->root = root_item->bytenr;
1906 	super->generation = root_item->generation;
1907 	super->root_level = root_item->level;
1908 	if (btrfs_test_opt(fs_info, SPACE_CACHE))
1909 		super->cache_generation = root_item->generation;
1910 	else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags))
1911 		super->cache_generation = 0;
1912 	if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags))
1913 		super->uuid_tree_generation = root_item->generation;
1914 
1915 	if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
1916 		root_item = &fs_info->block_group_root->root_item;
1917 
1918 		super->block_group_root = root_item->bytenr;
1919 		super->block_group_root_generation = root_item->generation;
1920 		super->block_group_root_level = root_item->level;
1921 	}
1922 }
1923 
btrfs_transaction_in_commit(struct btrfs_fs_info * info)1924 int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1925 {
1926 	struct btrfs_transaction *trans;
1927 	int ret = 0;
1928 
1929 	spin_lock(&info->trans_lock);
1930 	trans = info->running_transaction;
1931 	if (trans)
1932 		ret = (trans->state >= TRANS_STATE_COMMIT_START);
1933 	spin_unlock(&info->trans_lock);
1934 	return ret;
1935 }
1936 
btrfs_transaction_blocked(struct btrfs_fs_info * info)1937 int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1938 {
1939 	struct btrfs_transaction *trans;
1940 	int ret = 0;
1941 
1942 	spin_lock(&info->trans_lock);
1943 	trans = info->running_transaction;
1944 	if (trans)
1945 		ret = is_transaction_blocked(trans);
1946 	spin_unlock(&info->trans_lock);
1947 	return ret;
1948 }
1949 
btrfs_commit_transaction_async(struct btrfs_trans_handle * trans)1950 void btrfs_commit_transaction_async(struct btrfs_trans_handle *trans)
1951 {
1952 	struct btrfs_fs_info *fs_info = trans->fs_info;
1953 	struct btrfs_transaction *cur_trans;
1954 
1955 	/* Kick the transaction kthread. */
1956 	set_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags);
1957 	wake_up_process(fs_info->transaction_kthread);
1958 
1959 	/* take transaction reference */
1960 	cur_trans = trans->transaction;
1961 	refcount_inc(&cur_trans->use_count);
1962 
1963 	btrfs_end_transaction(trans);
1964 
1965 	/*
1966 	 * Wait for the current transaction commit to start and block
1967 	 * subsequent transaction joins
1968 	 */
1969 	wait_event(fs_info->transaction_blocked_wait,
1970 		   cur_trans->state >= TRANS_STATE_COMMIT_START ||
1971 		   TRANS_ABORTED(cur_trans));
1972 	btrfs_put_transaction(cur_trans);
1973 }
1974 
cleanup_transaction(struct btrfs_trans_handle * trans,int err)1975 static void cleanup_transaction(struct btrfs_trans_handle *trans, int err)
1976 {
1977 	struct btrfs_fs_info *fs_info = trans->fs_info;
1978 	struct btrfs_transaction *cur_trans = trans->transaction;
1979 
1980 	WARN_ON(refcount_read(&trans->use_count) > 1);
1981 
1982 	btrfs_abort_transaction(trans, err);
1983 
1984 	spin_lock(&fs_info->trans_lock);
1985 
1986 	/*
1987 	 * If the transaction is removed from the list, it means this
1988 	 * transaction has been committed successfully, so it is impossible
1989 	 * to call the cleanup function.
1990 	 */
1991 	BUG_ON(list_empty(&cur_trans->list));
1992 
1993 	if (cur_trans == fs_info->running_transaction) {
1994 		cur_trans->state = TRANS_STATE_COMMIT_DOING;
1995 		spin_unlock(&fs_info->trans_lock);
1996 		wait_event(cur_trans->writer_wait,
1997 			   atomic_read(&cur_trans->num_writers) == 1);
1998 
1999 		spin_lock(&fs_info->trans_lock);
2000 	}
2001 
2002 	/*
2003 	 * Now that we know no one else is still using the transaction we can
2004 	 * remove the transaction from the list of transactions. This avoids
2005 	 * the transaction kthread from cleaning up the transaction while some
2006 	 * other task is still using it, which could result in a use-after-free
2007 	 * on things like log trees, as it forces the transaction kthread to
2008 	 * wait for this transaction to be cleaned up by us.
2009 	 */
2010 	list_del_init(&cur_trans->list);
2011 
2012 	spin_unlock(&fs_info->trans_lock);
2013 
2014 	btrfs_cleanup_one_transaction(trans->transaction, fs_info);
2015 
2016 	spin_lock(&fs_info->trans_lock);
2017 	if (cur_trans == fs_info->running_transaction)
2018 		fs_info->running_transaction = NULL;
2019 	spin_unlock(&fs_info->trans_lock);
2020 
2021 	if (trans->type & __TRANS_FREEZABLE)
2022 		sb_end_intwrite(fs_info->sb);
2023 	btrfs_put_transaction(cur_trans);
2024 	btrfs_put_transaction(cur_trans);
2025 
2026 	trace_btrfs_transaction_commit(fs_info);
2027 
2028 	if (current->journal_info == trans)
2029 		current->journal_info = NULL;
2030 	btrfs_scrub_cancel(fs_info);
2031 
2032 	kmem_cache_free(btrfs_trans_handle_cachep, trans);
2033 }
2034 
2035 /*
2036  * Release reserved delayed ref space of all pending block groups of the
2037  * transaction and remove them from the list
2038  */
btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle * trans)2039 static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans)
2040 {
2041        struct btrfs_fs_info *fs_info = trans->fs_info;
2042        struct btrfs_block_group *block_group, *tmp;
2043 
2044        list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) {
2045                btrfs_delayed_refs_rsv_release(fs_info, 1);
2046                list_del_init(&block_group->bg_list);
2047        }
2048 }
2049 
btrfs_start_delalloc_flush(struct btrfs_fs_info * fs_info)2050 static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)
2051 {
2052 	/*
2053 	 * We use try_to_writeback_inodes_sb() here because if we used
2054 	 * btrfs_start_delalloc_roots we would deadlock with fs freeze.
2055 	 * Currently are holding the fs freeze lock, if we do an async flush
2056 	 * we'll do btrfs_join_transaction() and deadlock because we need to
2057 	 * wait for the fs freeze lock.  Using the direct flushing we benefit
2058 	 * from already being in a transaction and our join_transaction doesn't
2059 	 * have to re-take the fs freeze lock.
2060 	 *
2061 	 * Note that try_to_writeback_inodes_sb() will only trigger writeback
2062 	 * if it can read lock sb->s_umount. It will always be able to lock it,
2063 	 * except when the filesystem is being unmounted or being frozen, but in
2064 	 * those cases sync_filesystem() is called, which results in calling
2065 	 * writeback_inodes_sb() while holding a write lock on sb->s_umount.
2066 	 * Note that we don't call writeback_inodes_sb() directly, because it
2067 	 * will emit a warning if sb->s_umount is not locked.
2068 	 */
2069 	if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))
2070 		try_to_writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC);
2071 	return 0;
2072 }
2073 
btrfs_wait_delalloc_flush(struct btrfs_fs_info * fs_info)2074 static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)
2075 {
2076 	if (btrfs_test_opt(fs_info, FLUSHONCOMMIT))
2077 		btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
2078 }
2079 
2080 /*
2081  * Add a pending snapshot associated with the given transaction handle to the
2082  * respective handle. This must be called after the transaction commit started
2083  * and while holding fs_info->trans_lock.
2084  * This serves to guarantee a caller of btrfs_commit_transaction() that it can
2085  * safely free the pending snapshot pointer in case btrfs_commit_transaction()
2086  * returns an error.
2087  */
add_pending_snapshot(struct btrfs_trans_handle * trans)2088 static void add_pending_snapshot(struct btrfs_trans_handle *trans)
2089 {
2090 	struct btrfs_transaction *cur_trans = trans->transaction;
2091 
2092 	if (!trans->pending_snapshot)
2093 		return;
2094 
2095 	lockdep_assert_held(&trans->fs_info->trans_lock);
2096 	ASSERT(cur_trans->state >= TRANS_STATE_COMMIT_START);
2097 
2098 	list_add(&trans->pending_snapshot->list, &cur_trans->pending_snapshots);
2099 }
2100 
btrfs_commit_transaction(struct btrfs_trans_handle * trans)2101 int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
2102 {
2103 	struct btrfs_fs_info *fs_info = trans->fs_info;
2104 	struct btrfs_transaction *cur_trans = trans->transaction;
2105 	struct btrfs_transaction *prev_trans = NULL;
2106 	int ret;
2107 
2108 	ASSERT(refcount_read(&trans->use_count) == 1);
2109 
2110 	/* Stop the commit early if ->aborted is set */
2111 	if (TRANS_ABORTED(cur_trans)) {
2112 		ret = cur_trans->aborted;
2113 		btrfs_end_transaction(trans);
2114 		return ret;
2115 	}
2116 
2117 	btrfs_trans_release_metadata(trans);
2118 	trans->block_rsv = NULL;
2119 
2120 	/*
2121 	 * We only want one transaction commit doing the flushing so we do not
2122 	 * waste a bunch of time on lock contention on the extent root node.
2123 	 */
2124 	if (!test_and_set_bit(BTRFS_DELAYED_REFS_FLUSHING,
2125 			      &cur_trans->delayed_refs.flags)) {
2126 		/*
2127 		 * Make a pass through all the delayed refs we have so far.
2128 		 * Any running threads may add more while we are here.
2129 		 */
2130 		ret = btrfs_run_delayed_refs(trans, 0);
2131 		if (ret) {
2132 			btrfs_end_transaction(trans);
2133 			return ret;
2134 		}
2135 	}
2136 
2137 	btrfs_create_pending_block_groups(trans);
2138 
2139 	if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) {
2140 		int run_it = 0;
2141 
2142 		/* this mutex is also taken before trying to set
2143 		 * block groups readonly.  We need to make sure
2144 		 * that nobody has set a block group readonly
2145 		 * after a extents from that block group have been
2146 		 * allocated for cache files.  btrfs_set_block_group_ro
2147 		 * will wait for the transaction to commit if it
2148 		 * finds BTRFS_TRANS_DIRTY_BG_RUN set.
2149 		 *
2150 		 * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure
2151 		 * only one process starts all the block group IO.  It wouldn't
2152 		 * hurt to have more than one go through, but there's no
2153 		 * real advantage to it either.
2154 		 */
2155 		mutex_lock(&fs_info->ro_block_group_mutex);
2156 		if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN,
2157 				      &cur_trans->flags))
2158 			run_it = 1;
2159 		mutex_unlock(&fs_info->ro_block_group_mutex);
2160 
2161 		if (run_it) {
2162 			ret = btrfs_start_dirty_block_groups(trans);
2163 			if (ret) {
2164 				btrfs_end_transaction(trans);
2165 				return ret;
2166 			}
2167 		}
2168 	}
2169 
2170 	spin_lock(&fs_info->trans_lock);
2171 	if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
2172 		enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED;
2173 
2174 		add_pending_snapshot(trans);
2175 
2176 		spin_unlock(&fs_info->trans_lock);
2177 		refcount_inc(&cur_trans->use_count);
2178 
2179 		if (trans->in_fsync)
2180 			want_state = TRANS_STATE_SUPER_COMMITTED;
2181 		ret = btrfs_end_transaction(trans);
2182 		wait_for_commit(cur_trans, want_state);
2183 
2184 		if (TRANS_ABORTED(cur_trans))
2185 			ret = cur_trans->aborted;
2186 
2187 		btrfs_put_transaction(cur_trans);
2188 
2189 		return ret;
2190 	}
2191 
2192 	cur_trans->state = TRANS_STATE_COMMIT_START;
2193 	wake_up(&fs_info->transaction_blocked_wait);
2194 
2195 	if (cur_trans->list.prev != &fs_info->trans_list) {
2196 		enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED;
2197 
2198 		if (trans->in_fsync)
2199 			want_state = TRANS_STATE_SUPER_COMMITTED;
2200 
2201 		prev_trans = list_entry(cur_trans->list.prev,
2202 					struct btrfs_transaction, list);
2203 		if (prev_trans->state < want_state) {
2204 			refcount_inc(&prev_trans->use_count);
2205 			spin_unlock(&fs_info->trans_lock);
2206 
2207 			wait_for_commit(prev_trans, want_state);
2208 
2209 			ret = READ_ONCE(prev_trans->aborted);
2210 
2211 			btrfs_put_transaction(prev_trans);
2212 			if (ret)
2213 				goto cleanup_transaction;
2214 		} else {
2215 			spin_unlock(&fs_info->trans_lock);
2216 		}
2217 	} else {
2218 		spin_unlock(&fs_info->trans_lock);
2219 		/*
2220 		 * The previous transaction was aborted and was already removed
2221 		 * from the list of transactions at fs_info->trans_list. So we
2222 		 * abort to prevent writing a new superblock that reflects a
2223 		 * corrupt state (pointing to trees with unwritten nodes/leafs).
2224 		 */
2225 		if (BTRFS_FS_ERROR(fs_info)) {
2226 			ret = -EROFS;
2227 			goto cleanup_transaction;
2228 		}
2229 	}
2230 
2231 	extwriter_counter_dec(cur_trans, trans->type);
2232 
2233 	ret = btrfs_start_delalloc_flush(fs_info);
2234 	if (ret)
2235 		goto cleanup_transaction;
2236 
2237 	ret = btrfs_run_delayed_items(trans);
2238 	if (ret)
2239 		goto cleanup_transaction;
2240 
2241 	wait_event(cur_trans->writer_wait,
2242 		   extwriter_counter_read(cur_trans) == 0);
2243 
2244 	/* some pending stuffs might be added after the previous flush. */
2245 	ret = btrfs_run_delayed_items(trans);
2246 	if (ret)
2247 		goto cleanup_transaction;
2248 
2249 	btrfs_wait_delalloc_flush(fs_info);
2250 
2251 	/*
2252 	 * Wait for all ordered extents started by a fast fsync that joined this
2253 	 * transaction. Otherwise if this transaction commits before the ordered
2254 	 * extents complete we lose logged data after a power failure.
2255 	 */
2256 	wait_event(cur_trans->pending_wait,
2257 		   atomic_read(&cur_trans->pending_ordered) == 0);
2258 
2259 	btrfs_scrub_pause(fs_info);
2260 	/*
2261 	 * Ok now we need to make sure to block out any other joins while we
2262 	 * commit the transaction.  We could have started a join before setting
2263 	 * COMMIT_DOING so make sure to wait for num_writers to == 1 again.
2264 	 */
2265 	spin_lock(&fs_info->trans_lock);
2266 	add_pending_snapshot(trans);
2267 	cur_trans->state = TRANS_STATE_COMMIT_DOING;
2268 	spin_unlock(&fs_info->trans_lock);
2269 	wait_event(cur_trans->writer_wait,
2270 		   atomic_read(&cur_trans->num_writers) == 1);
2271 
2272 	/*
2273 	 * We've started the commit, clear the flag in case we were triggered to
2274 	 * do an async commit but somebody else started before the transaction
2275 	 * kthread could do the work.
2276 	 */
2277 	clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags);
2278 
2279 	if (TRANS_ABORTED(cur_trans)) {
2280 		ret = cur_trans->aborted;
2281 		goto scrub_continue;
2282 	}
2283 	/*
2284 	 * the reloc mutex makes sure that we stop
2285 	 * the balancing code from coming in and moving
2286 	 * extents around in the middle of the commit
2287 	 */
2288 	mutex_lock(&fs_info->reloc_mutex);
2289 
2290 	/*
2291 	 * We needn't worry about the delayed items because we will
2292 	 * deal with them in create_pending_snapshot(), which is the
2293 	 * core function of the snapshot creation.
2294 	 */
2295 	ret = create_pending_snapshots(trans);
2296 	if (ret)
2297 		goto unlock_reloc;
2298 
2299 	/*
2300 	 * We insert the dir indexes of the snapshots and update the inode
2301 	 * of the snapshots' parents after the snapshot creation, so there
2302 	 * are some delayed items which are not dealt with. Now deal with
2303 	 * them.
2304 	 *
2305 	 * We needn't worry that this operation will corrupt the snapshots,
2306 	 * because all the tree which are snapshoted will be forced to COW
2307 	 * the nodes and leaves.
2308 	 */
2309 	ret = btrfs_run_delayed_items(trans);
2310 	if (ret)
2311 		goto unlock_reloc;
2312 
2313 	ret = btrfs_run_delayed_refs(trans, (unsigned long)-1);
2314 	if (ret)
2315 		goto unlock_reloc;
2316 
2317 	/*
2318 	 * make sure none of the code above managed to slip in a
2319 	 * delayed item
2320 	 */
2321 	btrfs_assert_delayed_root_empty(fs_info);
2322 
2323 	WARN_ON(cur_trans != trans->transaction);
2324 
2325 	ret = commit_fs_roots(trans);
2326 	if (ret)
2327 		goto unlock_reloc;
2328 
2329 	/*
2330 	 * Since the transaction is done, we can apply the pending changes
2331 	 * before the next transaction.
2332 	 */
2333 	btrfs_apply_pending_changes(fs_info);
2334 
2335 	/* commit_fs_roots gets rid of all the tree log roots, it is now
2336 	 * safe to free the root of tree log roots
2337 	 */
2338 	btrfs_free_log_root_tree(trans, fs_info);
2339 
2340 	/*
2341 	 * Since fs roots are all committed, we can get a quite accurate
2342 	 * new_roots. So let's do quota accounting.
2343 	 */
2344 	ret = btrfs_qgroup_account_extents(trans);
2345 	if (ret < 0)
2346 		goto unlock_reloc;
2347 
2348 	ret = commit_cowonly_roots(trans);
2349 	if (ret)
2350 		goto unlock_reloc;
2351 
2352 	/*
2353 	 * The tasks which save the space cache and inode cache may also
2354 	 * update ->aborted, check it.
2355 	 */
2356 	if (TRANS_ABORTED(cur_trans)) {
2357 		ret = cur_trans->aborted;
2358 		goto unlock_reloc;
2359 	}
2360 
2361 	cur_trans = fs_info->running_transaction;
2362 
2363 	btrfs_set_root_node(&fs_info->tree_root->root_item,
2364 			    fs_info->tree_root->node);
2365 	list_add_tail(&fs_info->tree_root->dirty_list,
2366 		      &cur_trans->switch_commits);
2367 
2368 	btrfs_set_root_node(&fs_info->chunk_root->root_item,
2369 			    fs_info->chunk_root->node);
2370 	list_add_tail(&fs_info->chunk_root->dirty_list,
2371 		      &cur_trans->switch_commits);
2372 
2373 	if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) {
2374 		btrfs_set_root_node(&fs_info->block_group_root->root_item,
2375 				    fs_info->block_group_root->node);
2376 		list_add_tail(&fs_info->block_group_root->dirty_list,
2377 			      &cur_trans->switch_commits);
2378 	}
2379 
2380 	switch_commit_roots(trans);
2381 
2382 	ASSERT(list_empty(&cur_trans->dirty_bgs));
2383 	ASSERT(list_empty(&cur_trans->io_bgs));
2384 	update_super_roots(fs_info);
2385 
2386 	btrfs_set_super_log_root(fs_info->super_copy, 0);
2387 	btrfs_set_super_log_root_level(fs_info->super_copy, 0);
2388 	memcpy(fs_info->super_for_commit, fs_info->super_copy,
2389 	       sizeof(*fs_info->super_copy));
2390 
2391 	btrfs_commit_device_sizes(cur_trans);
2392 
2393 	clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags);
2394 	clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags);
2395 
2396 	btrfs_trans_release_chunk_metadata(trans);
2397 
2398 	/*
2399 	 * Before changing the transaction state to TRANS_STATE_UNBLOCKED and
2400 	 * setting fs_info->running_transaction to NULL, lock tree_log_mutex to
2401 	 * make sure that before we commit our superblock, no other task can
2402 	 * start a new transaction and commit a log tree before we commit our
2403 	 * superblock. Anyone trying to commit a log tree locks this mutex before
2404 	 * writing its superblock.
2405 	 */
2406 	mutex_lock(&fs_info->tree_log_mutex);
2407 
2408 	spin_lock(&fs_info->trans_lock);
2409 	cur_trans->state = TRANS_STATE_UNBLOCKED;
2410 	fs_info->running_transaction = NULL;
2411 	spin_unlock(&fs_info->trans_lock);
2412 	mutex_unlock(&fs_info->reloc_mutex);
2413 
2414 	wake_up(&fs_info->transaction_wait);
2415 
2416 	ret = btrfs_write_and_wait_transaction(trans);
2417 	if (ret) {
2418 		btrfs_handle_fs_error(fs_info, ret,
2419 				      "Error while writing out transaction");
2420 		mutex_unlock(&fs_info->tree_log_mutex);
2421 		goto scrub_continue;
2422 	}
2423 
2424 	/*
2425 	 * At this point, we should have written all the tree blocks allocated
2426 	 * in this transaction. So it's now safe to free the redirtyied extent
2427 	 * buffers.
2428 	 */
2429 	btrfs_free_redirty_list(cur_trans);
2430 
2431 	ret = write_all_supers(fs_info, 0);
2432 	/*
2433 	 * the super is written, we can safely allow the tree-loggers
2434 	 * to go about their business
2435 	 */
2436 	mutex_unlock(&fs_info->tree_log_mutex);
2437 	if (ret)
2438 		goto scrub_continue;
2439 
2440 	/*
2441 	 * We needn't acquire the lock here because there is no other task
2442 	 * which can change it.
2443 	 */
2444 	cur_trans->state = TRANS_STATE_SUPER_COMMITTED;
2445 	wake_up(&cur_trans->commit_wait);
2446 
2447 	btrfs_finish_extent_commit(trans);
2448 
2449 	if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags))
2450 		btrfs_clear_space_info_full(fs_info);
2451 
2452 	fs_info->last_trans_committed = cur_trans->transid;
2453 	/*
2454 	 * We needn't acquire the lock here because there is no other task
2455 	 * which can change it.
2456 	 */
2457 	cur_trans->state = TRANS_STATE_COMPLETED;
2458 	wake_up(&cur_trans->commit_wait);
2459 
2460 	spin_lock(&fs_info->trans_lock);
2461 	list_del_init(&cur_trans->list);
2462 	spin_unlock(&fs_info->trans_lock);
2463 
2464 	btrfs_put_transaction(cur_trans);
2465 	btrfs_put_transaction(cur_trans);
2466 
2467 	if (trans->type & __TRANS_FREEZABLE)
2468 		sb_end_intwrite(fs_info->sb);
2469 
2470 	trace_btrfs_transaction_commit(fs_info);
2471 
2472 	btrfs_scrub_continue(fs_info);
2473 
2474 	if (current->journal_info == trans)
2475 		current->journal_info = NULL;
2476 
2477 	kmem_cache_free(btrfs_trans_handle_cachep, trans);
2478 
2479 	return ret;
2480 
2481 unlock_reloc:
2482 	mutex_unlock(&fs_info->reloc_mutex);
2483 scrub_continue:
2484 	btrfs_scrub_continue(fs_info);
2485 cleanup_transaction:
2486 	btrfs_trans_release_metadata(trans);
2487 	btrfs_cleanup_pending_block_groups(trans);
2488 	btrfs_trans_release_chunk_metadata(trans);
2489 	trans->block_rsv = NULL;
2490 	btrfs_warn(fs_info, "Skipping commit of aborted transaction.");
2491 	if (current->journal_info == trans)
2492 		current->journal_info = NULL;
2493 	cleanup_transaction(trans, ret);
2494 
2495 	return ret;
2496 }
2497 
2498 /*
2499  * return < 0 if error
2500  * 0 if there are no more dead_roots at the time of call
2501  * 1 there are more to be processed, call me again
2502  *
2503  * The return value indicates there are certainly more snapshots to delete, but
2504  * if there comes a new one during processing, it may return 0. We don't mind,
2505  * because btrfs_commit_super will poke cleaner thread and it will process it a
2506  * few seconds later.
2507  */
btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info * fs_info)2508 int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info)
2509 {
2510 	struct btrfs_root *root;
2511 	int ret;
2512 
2513 	spin_lock(&fs_info->trans_lock);
2514 	if (list_empty(&fs_info->dead_roots)) {
2515 		spin_unlock(&fs_info->trans_lock);
2516 		return 0;
2517 	}
2518 	root = list_first_entry(&fs_info->dead_roots,
2519 			struct btrfs_root, root_list);
2520 	list_del_init(&root->root_list);
2521 	spin_unlock(&fs_info->trans_lock);
2522 
2523 	btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid);
2524 
2525 	btrfs_kill_all_delayed_nodes(root);
2526 
2527 	if (btrfs_header_backref_rev(root->node) <
2528 			BTRFS_MIXED_BACKREF_REV)
2529 		ret = btrfs_drop_snapshot(root, 0, 0);
2530 	else
2531 		ret = btrfs_drop_snapshot(root, 1, 0);
2532 
2533 	btrfs_put_root(root);
2534 	return (ret < 0) ? 0 : 1;
2535 }
2536 
btrfs_apply_pending_changes(struct btrfs_fs_info * fs_info)2537 void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info)
2538 {
2539 	unsigned long prev;
2540 	unsigned long bit;
2541 
2542 	prev = xchg(&fs_info->pending_changes, 0);
2543 	if (!prev)
2544 		return;
2545 
2546 	bit = 1 << BTRFS_PENDING_COMMIT;
2547 	if (prev & bit)
2548 		btrfs_debug(fs_info, "pending commit done");
2549 	prev &= ~bit;
2550 
2551 	if (prev)
2552 		btrfs_warn(fs_info,
2553 			"unknown pending changes left 0x%lx, ignoring", prev);
2554 }
2555