1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
4  * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
5  */
6 
7 #include <linux/sched.h>
8 #include <linux/slab.h>
9 #include <linux/spinlock.h>
10 #include <linux/completion.h>
11 #include <linux/buffer_head.h>
12 #include <linux/gfs2_ondisk.h>
13 #include <linux/crc32.h>
14 #include <linux/crc32c.h>
15 #include <linux/delay.h>
16 #include <linux/kthread.h>
17 #include <linux/freezer.h>
18 #include <linux/bio.h>
19 #include <linux/blkdev.h>
20 #include <linux/writeback.h>
21 #include <linux/list_sort.h>
22 
23 #include "gfs2.h"
24 #include "incore.h"
25 #include "bmap.h"
26 #include "glock.h"
27 #include "log.h"
28 #include "lops.h"
29 #include "meta_io.h"
30 #include "util.h"
31 #include "dir.h"
32 #include "trace_gfs2.h"
33 #include "trans.h"
34 
35 static void gfs2_log_shutdown(struct gfs2_sbd *sdp);
36 
37 /**
38  * gfs2_struct2blk - compute stuff
39  * @sdp: the filesystem
40  * @nstruct: the number of structures
41  *
42  * Compute the number of log descriptor blocks needed to hold a certain number
43  * of structures of a certain size.
44  *
45  * Returns: the number of blocks needed (minimum is always 1)
46  */
47 
gfs2_struct2blk(struct gfs2_sbd * sdp,unsigned int nstruct)48 unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct)
49 {
50 	unsigned int blks;
51 	unsigned int first, second;
52 
53 	/* The initial struct gfs2_log_descriptor block */
54 	blks = 1;
55 	first = sdp->sd_ldptrs;
56 
57 	if (nstruct > first) {
58 		/* Subsequent struct gfs2_meta_header blocks */
59 		second = sdp->sd_inptrs;
60 		blks += DIV_ROUND_UP(nstruct - first, second);
61 	}
62 
63 	return blks;
64 }
65 
66 /**
67  * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters
68  * @bd: The gfs2_bufdata to remove
69  *
70  * The ail lock _must_ be held when calling this function
71  *
72  */
73 
gfs2_remove_from_ail(struct gfs2_bufdata * bd)74 void gfs2_remove_from_ail(struct gfs2_bufdata *bd)
75 {
76 	bd->bd_tr = NULL;
77 	list_del_init(&bd->bd_ail_st_list);
78 	list_del_init(&bd->bd_ail_gl_list);
79 	atomic_dec(&bd->bd_gl->gl_ail_count);
80 	brelse(bd->bd_bh);
81 }
82 
__gfs2_writepage(struct folio * folio,struct writeback_control * wbc,void * data)83 static int __gfs2_writepage(struct folio *folio, struct writeback_control *wbc,
84 		       void *data)
85 {
86 	struct address_space *mapping = data;
87 	int ret = mapping->a_ops->writepage(&folio->page, wbc);
88 	mapping_set_error(mapping, ret);
89 	return ret;
90 }
91 
92 /**
93  * gfs2_ail1_start_one - Start I/O on a transaction
94  * @sdp: The superblock
95  * @wbc: The writeback control structure
96  * @tr: The transaction to start I/O on
97  * @plug: The block plug currently active
98  */
99 
gfs2_ail1_start_one(struct gfs2_sbd * sdp,struct writeback_control * wbc,struct gfs2_trans * tr,struct blk_plug * plug)100 static int gfs2_ail1_start_one(struct gfs2_sbd *sdp,
101 			       struct writeback_control *wbc,
102 			       struct gfs2_trans *tr, struct blk_plug *plug)
103 __releases(&sdp->sd_ail_lock)
104 __acquires(&sdp->sd_ail_lock)
105 {
106 	struct gfs2_glock *gl = NULL;
107 	struct address_space *mapping;
108 	struct gfs2_bufdata *bd, *s;
109 	struct buffer_head *bh;
110 	int ret = 0;
111 
112 	list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list, bd_ail_st_list) {
113 		bh = bd->bd_bh;
114 
115 		gfs2_assert(sdp, bd->bd_tr == tr);
116 
117 		if (!buffer_busy(bh)) {
118 			if (buffer_uptodate(bh)) {
119 				list_move(&bd->bd_ail_st_list,
120 					  &tr->tr_ail2_list);
121 				continue;
122 			}
123 			if (!cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
124 				gfs2_io_error_bh(sdp, bh);
125 				gfs2_withdraw_delayed(sdp);
126 			}
127 		}
128 
129 		if (gfs2_withdrawn(sdp)) {
130 			gfs2_remove_from_ail(bd);
131 			continue;
132 		}
133 		if (!buffer_dirty(bh))
134 			continue;
135 		if (gl == bd->bd_gl)
136 			continue;
137 		gl = bd->bd_gl;
138 		list_move(&bd->bd_ail_st_list, &tr->tr_ail1_list);
139 		mapping = bh->b_folio->mapping;
140 		if (!mapping)
141 			continue;
142 		spin_unlock(&sdp->sd_ail_lock);
143 		ret = write_cache_pages(mapping, wbc, __gfs2_writepage, mapping);
144 		if (need_resched()) {
145 			blk_finish_plug(plug);
146 			cond_resched();
147 			blk_start_plug(plug);
148 		}
149 		spin_lock(&sdp->sd_ail_lock);
150 		if (ret == -ENODATA) /* if a jdata write into a new hole */
151 			ret = 0; /* ignore it */
152 		if (ret || wbc->nr_to_write <= 0)
153 			break;
154 		return -EBUSY;
155 	}
156 
157 	return ret;
158 }
159 
dump_ail_list(struct gfs2_sbd * sdp)160 static void dump_ail_list(struct gfs2_sbd *sdp)
161 {
162 	struct gfs2_trans *tr;
163 	struct gfs2_bufdata *bd;
164 	struct buffer_head *bh;
165 
166 	list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
167 		list_for_each_entry_reverse(bd, &tr->tr_ail1_list,
168 					    bd_ail_st_list) {
169 			bh = bd->bd_bh;
170 			fs_err(sdp, "bd %p: blk:0x%llx bh=%p ", bd,
171 			       (unsigned long long)bd->bd_blkno, bh);
172 			if (!bh) {
173 				fs_err(sdp, "\n");
174 				continue;
175 			}
176 			fs_err(sdp, "0x%llx up2:%d dirt:%d lkd:%d req:%d "
177 			       "map:%d new:%d ar:%d aw:%d delay:%d "
178 			       "io err:%d unwritten:%d dfr:%d pin:%d esc:%d\n",
179 			       (unsigned long long)bh->b_blocknr,
180 			       buffer_uptodate(bh), buffer_dirty(bh),
181 			       buffer_locked(bh), buffer_req(bh),
182 			       buffer_mapped(bh), buffer_new(bh),
183 			       buffer_async_read(bh), buffer_async_write(bh),
184 			       buffer_delay(bh), buffer_write_io_error(bh),
185 			       buffer_unwritten(bh),
186 			       buffer_defer_completion(bh),
187 			       buffer_pinned(bh), buffer_escaped(bh));
188 		}
189 	}
190 }
191 
192 /**
193  * gfs2_ail1_flush - start writeback of some ail1 entries
194  * @sdp: The super block
195  * @wbc: The writeback control structure
196  *
197  * Writes back some ail1 entries, according to the limits in the
198  * writeback control structure
199  */
200 
gfs2_ail1_flush(struct gfs2_sbd * sdp,struct writeback_control * wbc)201 void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
202 {
203 	struct list_head *head = &sdp->sd_ail1_list;
204 	struct gfs2_trans *tr;
205 	struct blk_plug plug;
206 	int ret;
207 	unsigned long flush_start = jiffies;
208 
209 	trace_gfs2_ail_flush(sdp, wbc, 1);
210 	blk_start_plug(&plug);
211 	spin_lock(&sdp->sd_ail_lock);
212 restart:
213 	ret = 0;
214 	if (time_after(jiffies, flush_start + (HZ * 600))) {
215 		fs_err(sdp, "Error: In %s for ten minutes! t=%d\n",
216 		       __func__, current->journal_info ? 1 : 0);
217 		dump_ail_list(sdp);
218 		goto out;
219 	}
220 	list_for_each_entry_reverse(tr, head, tr_list) {
221 		if (wbc->nr_to_write <= 0)
222 			break;
223 		ret = gfs2_ail1_start_one(sdp, wbc, tr, &plug);
224 		if (ret) {
225 			if (ret == -EBUSY)
226 				goto restart;
227 			break;
228 		}
229 	}
230 out:
231 	spin_unlock(&sdp->sd_ail_lock);
232 	blk_finish_plug(&plug);
233 	if (ret) {
234 		gfs2_lm(sdp, "gfs2_ail1_start_one returned: %d\n", ret);
235 		gfs2_withdraw(sdp);
236 	}
237 	trace_gfs2_ail_flush(sdp, wbc, 0);
238 }
239 
240 /**
241  * gfs2_ail1_start - start writeback of all ail1 entries
242  * @sdp: The superblock
243  */
244 
gfs2_ail1_start(struct gfs2_sbd * sdp)245 static void gfs2_ail1_start(struct gfs2_sbd *sdp)
246 {
247 	struct writeback_control wbc = {
248 		.sync_mode = WB_SYNC_NONE,
249 		.nr_to_write = LONG_MAX,
250 		.range_start = 0,
251 		.range_end = LLONG_MAX,
252 	};
253 
254 	return gfs2_ail1_flush(sdp, &wbc);
255 }
256 
gfs2_log_update_flush_tail(struct gfs2_sbd * sdp)257 static void gfs2_log_update_flush_tail(struct gfs2_sbd *sdp)
258 {
259 	unsigned int new_flush_tail = sdp->sd_log_head;
260 	struct gfs2_trans *tr;
261 
262 	if (!list_empty(&sdp->sd_ail1_list)) {
263 		tr = list_last_entry(&sdp->sd_ail1_list,
264 				     struct gfs2_trans, tr_list);
265 		new_flush_tail = tr->tr_first;
266 	}
267 	sdp->sd_log_flush_tail = new_flush_tail;
268 }
269 
gfs2_log_update_head(struct gfs2_sbd * sdp)270 static void gfs2_log_update_head(struct gfs2_sbd *sdp)
271 {
272 	unsigned int new_head = sdp->sd_log_flush_head;
273 
274 	if (sdp->sd_log_flush_tail == sdp->sd_log_head)
275 		sdp->sd_log_flush_tail = new_head;
276 	sdp->sd_log_head = new_head;
277 }
278 
279 /*
280  * gfs2_ail_empty_tr - empty one of the ail lists of a transaction
281  */
282 
gfs2_ail_empty_tr(struct gfs2_sbd * sdp,struct gfs2_trans * tr,struct list_head * head)283 static void gfs2_ail_empty_tr(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
284 			      struct list_head *head)
285 {
286 	struct gfs2_bufdata *bd;
287 
288 	while (!list_empty(head)) {
289 		bd = list_first_entry(head, struct gfs2_bufdata,
290 				      bd_ail_st_list);
291 		gfs2_assert(sdp, bd->bd_tr == tr);
292 		gfs2_remove_from_ail(bd);
293 	}
294 }
295 
296 /**
297  * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
298  * @sdp: the filesystem
299  * @tr: the transaction
300  * @max_revokes: If nonzero, issue revokes for the bd items for written buffers
301  *
302  * returns: the transaction's count of remaining active items
303  */
304 
gfs2_ail1_empty_one(struct gfs2_sbd * sdp,struct gfs2_trans * tr,int * max_revokes)305 static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
306 				int *max_revokes)
307 {
308 	struct gfs2_bufdata *bd, *s;
309 	struct buffer_head *bh;
310 	int active_count = 0;
311 
312 	list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list,
313 					 bd_ail_st_list) {
314 		bh = bd->bd_bh;
315 		gfs2_assert(sdp, bd->bd_tr == tr);
316 		/*
317 		 * If another process flagged an io error, e.g. writing to the
318 		 * journal, error all other bhs and move them off the ail1 to
319 		 * prevent a tight loop when unmount tries to flush ail1,
320 		 * regardless of whether they're still busy. If no outside
321 		 * errors were found and the buffer is busy, move to the next.
322 		 * If the ail buffer is not busy and caught an error, flag it
323 		 * for others.
324 		 */
325 		if (!sdp->sd_log_error && buffer_busy(bh)) {
326 			active_count++;
327 			continue;
328 		}
329 		if (!buffer_uptodate(bh) &&
330 		    !cmpxchg(&sdp->sd_log_error, 0, -EIO)) {
331 			gfs2_io_error_bh(sdp, bh);
332 			gfs2_withdraw_delayed(sdp);
333 		}
334 		/*
335 		 * If we have space for revokes and the bd is no longer on any
336 		 * buf list, we can just add a revoke for it immediately and
337 		 * avoid having to put it on the ail2 list, where it would need
338 		 * to be revoked later.
339 		 */
340 		if (*max_revokes && list_empty(&bd->bd_list)) {
341 			gfs2_add_revoke(sdp, bd);
342 			(*max_revokes)--;
343 			continue;
344 		}
345 		list_move(&bd->bd_ail_st_list, &tr->tr_ail2_list);
346 	}
347 	return active_count;
348 }
349 
350 /**
351  * gfs2_ail1_empty - Try to empty the ail1 lists
352  * @sdp: The superblock
353  * @max_revokes: If non-zero, add revokes where appropriate
354  *
355  * Tries to empty the ail1 lists, starting with the oldest first
356  */
357 
gfs2_ail1_empty(struct gfs2_sbd * sdp,int max_revokes)358 static int gfs2_ail1_empty(struct gfs2_sbd *sdp, int max_revokes)
359 {
360 	struct gfs2_trans *tr, *s;
361 	int oldest_tr = 1;
362 	int ret;
363 
364 	spin_lock(&sdp->sd_ail_lock);
365 	list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
366 		if (!gfs2_ail1_empty_one(sdp, tr, &max_revokes) && oldest_tr)
367 			list_move(&tr->tr_list, &sdp->sd_ail2_list);
368 		else
369 			oldest_tr = 0;
370 	}
371 	gfs2_log_update_flush_tail(sdp);
372 	ret = list_empty(&sdp->sd_ail1_list);
373 	spin_unlock(&sdp->sd_ail_lock);
374 
375 	if (test_bit(SDF_WITHDRAWING, &sdp->sd_flags)) {
376 		gfs2_lm(sdp, "fatal: I/O error(s)\n");
377 		gfs2_withdraw(sdp);
378 	}
379 
380 	return ret;
381 }
382 
gfs2_ail1_wait(struct gfs2_sbd * sdp)383 static void gfs2_ail1_wait(struct gfs2_sbd *sdp)
384 {
385 	struct gfs2_trans *tr;
386 	struct gfs2_bufdata *bd;
387 	struct buffer_head *bh;
388 
389 	spin_lock(&sdp->sd_ail_lock);
390 	list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
391 		list_for_each_entry(bd, &tr->tr_ail1_list, bd_ail_st_list) {
392 			bh = bd->bd_bh;
393 			if (!buffer_locked(bh))
394 				continue;
395 			get_bh(bh);
396 			spin_unlock(&sdp->sd_ail_lock);
397 			wait_on_buffer(bh);
398 			brelse(bh);
399 			return;
400 		}
401 	}
402 	spin_unlock(&sdp->sd_ail_lock);
403 }
404 
__ail2_empty(struct gfs2_sbd * sdp,struct gfs2_trans * tr)405 static void __ail2_empty(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
406 {
407 	gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
408 	list_del(&tr->tr_list);
409 	gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list));
410 	gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list));
411 	gfs2_trans_free(sdp, tr);
412 }
413 
ail2_empty(struct gfs2_sbd * sdp,unsigned int new_tail)414 static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
415 {
416 	struct list_head *ail2_list = &sdp->sd_ail2_list;
417 	unsigned int old_tail = sdp->sd_log_tail;
418 	struct gfs2_trans *tr, *safe;
419 
420 	spin_lock(&sdp->sd_ail_lock);
421 	if (old_tail <= new_tail) {
422 		list_for_each_entry_safe(tr, safe, ail2_list, tr_list) {
423 			if (old_tail <= tr->tr_first && tr->tr_first < new_tail)
424 				__ail2_empty(sdp, tr);
425 		}
426 	} else {
427 		list_for_each_entry_safe(tr, safe, ail2_list, tr_list) {
428 			if (old_tail <= tr->tr_first || tr->tr_first < new_tail)
429 				__ail2_empty(sdp, tr);
430 		}
431 	}
432 	spin_unlock(&sdp->sd_ail_lock);
433 }
434 
435 /**
436  * gfs2_log_is_empty - Check if the log is empty
437  * @sdp: The GFS2 superblock
438  */
439 
gfs2_log_is_empty(struct gfs2_sbd * sdp)440 bool gfs2_log_is_empty(struct gfs2_sbd *sdp) {
441 	return atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks;
442 }
443 
__gfs2_log_try_reserve_revokes(struct gfs2_sbd * sdp,unsigned int revokes)444 static bool __gfs2_log_try_reserve_revokes(struct gfs2_sbd *sdp, unsigned int revokes)
445 {
446 	unsigned int available;
447 
448 	available = atomic_read(&sdp->sd_log_revokes_available);
449 	while (available >= revokes) {
450 		if (atomic_try_cmpxchg(&sdp->sd_log_revokes_available,
451 				       &available, available - revokes))
452 			return true;
453 	}
454 	return false;
455 }
456 
457 /**
458  * gfs2_log_release_revokes - Release a given number of revokes
459  * @sdp: The GFS2 superblock
460  * @revokes: The number of revokes to release
461  *
462  * sdp->sd_log_flush_lock must be held.
463  */
gfs2_log_release_revokes(struct gfs2_sbd * sdp,unsigned int revokes)464 void gfs2_log_release_revokes(struct gfs2_sbd *sdp, unsigned int revokes)
465 {
466 	if (revokes)
467 		atomic_add(revokes, &sdp->sd_log_revokes_available);
468 }
469 
470 /**
471  * gfs2_log_release - Release a given number of log blocks
472  * @sdp: The GFS2 superblock
473  * @blks: The number of blocks
474  *
475  */
476 
gfs2_log_release(struct gfs2_sbd * sdp,unsigned int blks)477 void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
478 {
479 	atomic_add(blks, &sdp->sd_log_blks_free);
480 	trace_gfs2_log_blocks(sdp, blks);
481 	gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
482 				  sdp->sd_jdesc->jd_blocks);
483 	if (atomic_read(&sdp->sd_log_blks_needed))
484 		wake_up(&sdp->sd_log_waitq);
485 }
486 
487 /**
488  * __gfs2_log_try_reserve - Try to make a log reservation
489  * @sdp: The GFS2 superblock
490  * @blks: The number of blocks to reserve
491  * @taboo_blks: The number of blocks to leave free
492  *
493  * Try to do the same as __gfs2_log_reserve(), but fail if no more log
494  * space is immediately available.
495  */
__gfs2_log_try_reserve(struct gfs2_sbd * sdp,unsigned int blks,unsigned int taboo_blks)496 static bool __gfs2_log_try_reserve(struct gfs2_sbd *sdp, unsigned int blks,
497 				   unsigned int taboo_blks)
498 {
499 	unsigned wanted = blks + taboo_blks;
500 	unsigned int free_blocks;
501 
502 	free_blocks = atomic_read(&sdp->sd_log_blks_free);
503 	while (free_blocks >= wanted) {
504 		if (atomic_try_cmpxchg(&sdp->sd_log_blks_free, &free_blocks,
505 				       free_blocks - blks)) {
506 			trace_gfs2_log_blocks(sdp, -blks);
507 			return true;
508 		}
509 	}
510 	return false;
511 }
512 
513 /**
514  * __gfs2_log_reserve - Make a log reservation
515  * @sdp: The GFS2 superblock
516  * @blks: The number of blocks to reserve
517  * @taboo_blks: The number of blocks to leave free
518  *
519  * @taboo_blks is set to 0 for logd, and to GFS2_LOG_FLUSH_MIN_BLOCKS
520  * for all other processes.  This ensures that when the log is almost full,
521  * logd will still be able to call gfs2_log_flush one more time  without
522  * blocking, which will advance the tail and make some more log space
523  * available.
524  *
525  * We no longer flush the log here, instead we wake up logd to do that
526  * for us. To avoid the thundering herd and to ensure that we deal fairly
527  * with queued waiters, we use an exclusive wait. This means that when we
528  * get woken with enough journal space to get our reservation, we need to
529  * wake the next waiter on the list.
530  */
531 
__gfs2_log_reserve(struct gfs2_sbd * sdp,unsigned int blks,unsigned int taboo_blks)532 static void __gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks,
533 			       unsigned int taboo_blks)
534 {
535 	unsigned wanted = blks + taboo_blks;
536 	unsigned int free_blocks;
537 
538 	atomic_add(blks, &sdp->sd_log_blks_needed);
539 	for (;;) {
540 		if (current != sdp->sd_logd_process)
541 			wake_up(&sdp->sd_logd_waitq);
542 		io_wait_event(sdp->sd_log_waitq,
543 			(free_blocks = atomic_read(&sdp->sd_log_blks_free),
544 			 free_blocks >= wanted));
545 		do {
546 			if (atomic_try_cmpxchg(&sdp->sd_log_blks_free,
547 					       &free_blocks,
548 					       free_blocks - blks))
549 				goto reserved;
550 		} while (free_blocks >= wanted);
551 	}
552 
553 reserved:
554 	trace_gfs2_log_blocks(sdp, -blks);
555 	if (atomic_sub_return(blks, &sdp->sd_log_blks_needed))
556 		wake_up(&sdp->sd_log_waitq);
557 }
558 
559 /**
560  * gfs2_log_try_reserve - Try to make a log reservation
561  * @sdp: The GFS2 superblock
562  * @tr: The transaction
563  * @extra_revokes: The number of additional revokes reserved (output)
564  *
565  * This is similar to gfs2_log_reserve, but sdp->sd_log_flush_lock must be
566  * held for correct revoke accounting.
567  */
568 
gfs2_log_try_reserve(struct gfs2_sbd * sdp,struct gfs2_trans * tr,unsigned int * extra_revokes)569 bool gfs2_log_try_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
570 			  unsigned int *extra_revokes)
571 {
572 	unsigned int blks = tr->tr_reserved;
573 	unsigned int revokes = tr->tr_revokes;
574 	unsigned int revoke_blks = 0;
575 
576 	*extra_revokes = 0;
577 	if (revokes && !__gfs2_log_try_reserve_revokes(sdp, revokes)) {
578 		revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);
579 		*extra_revokes = revoke_blks * sdp->sd_inptrs - revokes;
580 		blks += revoke_blks;
581 	}
582 	if (!blks)
583 		return true;
584 	if (__gfs2_log_try_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS))
585 		return true;
586 	if (!revoke_blks)
587 		gfs2_log_release_revokes(sdp, revokes);
588 	return false;
589 }
590 
591 /**
592  * gfs2_log_reserve - Make a log reservation
593  * @sdp: The GFS2 superblock
594  * @tr: The transaction
595  * @extra_revokes: The number of additional revokes reserved (output)
596  *
597  * sdp->sd_log_flush_lock must not be held.
598  */
599 
gfs2_log_reserve(struct gfs2_sbd * sdp,struct gfs2_trans * tr,unsigned int * extra_revokes)600 void gfs2_log_reserve(struct gfs2_sbd *sdp, struct gfs2_trans *tr,
601 		      unsigned int *extra_revokes)
602 {
603 	unsigned int blks = tr->tr_reserved;
604 	unsigned int revokes = tr->tr_revokes;
605 	unsigned int revoke_blks;
606 
607 	*extra_revokes = 0;
608 	if (revokes) {
609 		revoke_blks = DIV_ROUND_UP(revokes, sdp->sd_inptrs);
610 		*extra_revokes = revoke_blks * sdp->sd_inptrs - revokes;
611 		blks += revoke_blks;
612 	}
613 	__gfs2_log_reserve(sdp, blks, GFS2_LOG_FLUSH_MIN_BLOCKS);
614 }
615 
616 /**
617  * log_distance - Compute distance between two journal blocks
618  * @sdp: The GFS2 superblock
619  * @newer: The most recent journal block of the pair
620  * @older: The older journal block of the pair
621  *
622  *   Compute the distance (in the journal direction) between two
623  *   blocks in the journal
624  *
625  * Returns: the distance in blocks
626  */
627 
log_distance(struct gfs2_sbd * sdp,unsigned int newer,unsigned int older)628 static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
629 					unsigned int older)
630 {
631 	int dist;
632 
633 	dist = newer - older;
634 	if (dist < 0)
635 		dist += sdp->sd_jdesc->jd_blocks;
636 
637 	return dist;
638 }
639 
640 /**
641  * calc_reserved - Calculate the number of blocks to keep reserved
642  * @sdp: The GFS2 superblock
643  *
644  * This is complex.  We need to reserve room for all our currently used
645  * metadata blocks (e.g. normal file I/O rewriting file time stamps) and
646  * all our journaled data blocks for journaled files (e.g. files in the
647  * meta_fs like rindex, or files for which chattr +j was done.)
648  * If we don't reserve enough space, corruption will follow.
649  *
650  * We can have metadata blocks and jdata blocks in the same journal.  Each
651  * type gets its own log descriptor, for which we need to reserve a block.
652  * In fact, each type has the potential for needing more than one log descriptor
653  * in cases where we have more blocks than will fit in a log descriptor.
654  * Metadata journal entries take up half the space of journaled buffer entries.
655  *
656  * Also, we need to reserve blocks for revoke journal entries and one for an
657  * overall header for the lot.
658  *
659  * Returns: the number of blocks reserved
660  */
calc_reserved(struct gfs2_sbd * sdp)661 static unsigned int calc_reserved(struct gfs2_sbd *sdp)
662 {
663 	unsigned int reserved = GFS2_LOG_FLUSH_MIN_BLOCKS;
664 	unsigned int blocks;
665 	struct gfs2_trans *tr = sdp->sd_log_tr;
666 
667 	if (tr) {
668 		blocks = tr->tr_num_buf_new - tr->tr_num_buf_rm;
669 		reserved += blocks + DIV_ROUND_UP(blocks, buf_limit(sdp));
670 		blocks = tr->tr_num_databuf_new - tr->tr_num_databuf_rm;
671 		reserved += blocks + DIV_ROUND_UP(blocks, databuf_limit(sdp));
672 	}
673 	return reserved;
674 }
675 
log_pull_tail(struct gfs2_sbd * sdp)676 static void log_pull_tail(struct gfs2_sbd *sdp)
677 {
678 	unsigned int new_tail = sdp->sd_log_flush_tail;
679 	unsigned int dist;
680 
681 	if (new_tail == sdp->sd_log_tail)
682 		return;
683 	dist = log_distance(sdp, new_tail, sdp->sd_log_tail);
684 	ail2_empty(sdp, new_tail);
685 	gfs2_log_release(sdp, dist);
686 	sdp->sd_log_tail = new_tail;
687 }
688 
689 
log_flush_wait(struct gfs2_sbd * sdp)690 void log_flush_wait(struct gfs2_sbd *sdp)
691 {
692 	DEFINE_WAIT(wait);
693 
694 	if (atomic_read(&sdp->sd_log_in_flight)) {
695 		do {
696 			prepare_to_wait(&sdp->sd_log_flush_wait, &wait,
697 					TASK_UNINTERRUPTIBLE);
698 			if (atomic_read(&sdp->sd_log_in_flight))
699 				io_schedule();
700 		} while(atomic_read(&sdp->sd_log_in_flight));
701 		finish_wait(&sdp->sd_log_flush_wait, &wait);
702 	}
703 }
704 
ip_cmp(void * priv,const struct list_head * a,const struct list_head * b)705 static int ip_cmp(void *priv, const struct list_head *a, const struct list_head *b)
706 {
707 	struct gfs2_inode *ipa, *ipb;
708 
709 	ipa = list_entry(a, struct gfs2_inode, i_ordered);
710 	ipb = list_entry(b, struct gfs2_inode, i_ordered);
711 
712 	if (ipa->i_no_addr < ipb->i_no_addr)
713 		return -1;
714 	if (ipa->i_no_addr > ipb->i_no_addr)
715 		return 1;
716 	return 0;
717 }
718 
__ordered_del_inode(struct gfs2_inode * ip)719 static void __ordered_del_inode(struct gfs2_inode *ip)
720 {
721 	if (!list_empty(&ip->i_ordered))
722 		list_del_init(&ip->i_ordered);
723 }
724 
gfs2_ordered_write(struct gfs2_sbd * sdp)725 static void gfs2_ordered_write(struct gfs2_sbd *sdp)
726 {
727 	struct gfs2_inode *ip;
728 	LIST_HEAD(written);
729 
730 	spin_lock(&sdp->sd_ordered_lock);
731 	list_sort(NULL, &sdp->sd_log_ordered, &ip_cmp);
732 	while (!list_empty(&sdp->sd_log_ordered)) {
733 		ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
734 		if (ip->i_inode.i_mapping->nrpages == 0) {
735 			__ordered_del_inode(ip);
736 			continue;
737 		}
738 		list_move(&ip->i_ordered, &written);
739 		spin_unlock(&sdp->sd_ordered_lock);
740 		filemap_fdatawrite(ip->i_inode.i_mapping);
741 		spin_lock(&sdp->sd_ordered_lock);
742 	}
743 	list_splice(&written, &sdp->sd_log_ordered);
744 	spin_unlock(&sdp->sd_ordered_lock);
745 }
746 
gfs2_ordered_wait(struct gfs2_sbd * sdp)747 static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
748 {
749 	struct gfs2_inode *ip;
750 
751 	spin_lock(&sdp->sd_ordered_lock);
752 	while (!list_empty(&sdp->sd_log_ordered)) {
753 		ip = list_first_entry(&sdp->sd_log_ordered, struct gfs2_inode, i_ordered);
754 		__ordered_del_inode(ip);
755 		if (ip->i_inode.i_mapping->nrpages == 0)
756 			continue;
757 		spin_unlock(&sdp->sd_ordered_lock);
758 		filemap_fdatawait(ip->i_inode.i_mapping);
759 		spin_lock(&sdp->sd_ordered_lock);
760 	}
761 	spin_unlock(&sdp->sd_ordered_lock);
762 }
763 
gfs2_ordered_del_inode(struct gfs2_inode * ip)764 void gfs2_ordered_del_inode(struct gfs2_inode *ip)
765 {
766 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
767 
768 	spin_lock(&sdp->sd_ordered_lock);
769 	__ordered_del_inode(ip);
770 	spin_unlock(&sdp->sd_ordered_lock);
771 }
772 
gfs2_add_revoke(struct gfs2_sbd * sdp,struct gfs2_bufdata * bd)773 void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
774 {
775 	struct buffer_head *bh = bd->bd_bh;
776 	struct gfs2_glock *gl = bd->bd_gl;
777 
778 	sdp->sd_log_num_revoke++;
779 	if (atomic_inc_return(&gl->gl_revokes) == 1)
780 		gfs2_glock_hold(gl);
781 	bh->b_private = NULL;
782 	bd->bd_blkno = bh->b_blocknr;
783 	gfs2_remove_from_ail(bd); /* drops ref on bh */
784 	bd->bd_bh = NULL;
785 	set_bit(GLF_LFLUSH, &gl->gl_flags);
786 	list_add(&bd->bd_list, &sdp->sd_log_revokes);
787 }
788 
gfs2_glock_remove_revoke(struct gfs2_glock * gl)789 void gfs2_glock_remove_revoke(struct gfs2_glock *gl)
790 {
791 	if (atomic_dec_return(&gl->gl_revokes) == 0) {
792 		clear_bit(GLF_LFLUSH, &gl->gl_flags);
793 		gfs2_glock_queue_put(gl);
794 	}
795 }
796 
797 /**
798  * gfs2_flush_revokes - Add as many revokes to the system transaction as we can
799  * @sdp: The GFS2 superblock
800  *
801  * Our usual strategy is to defer writing revokes as much as we can in the hope
802  * that we'll eventually overwrite the journal, which will make those revokes
803  * go away.  This changes when we flush the log: at that point, there will
804  * likely be some left-over space in the last revoke block of that transaction.
805  * We can fill that space with additional revokes for blocks that have already
806  * been written back.  This will basically come at no cost now, and will save
807  * us from having to keep track of those blocks on the AIL2 list later.
808  */
gfs2_flush_revokes(struct gfs2_sbd * sdp)809 void gfs2_flush_revokes(struct gfs2_sbd *sdp)
810 {
811 	/* number of revokes we still have room for */
812 	unsigned int max_revokes = atomic_read(&sdp->sd_log_revokes_available);
813 
814 	gfs2_log_lock(sdp);
815 	gfs2_ail1_empty(sdp, max_revokes);
816 	gfs2_log_unlock(sdp);
817 }
818 
819 /**
820  * gfs2_write_log_header - Write a journal log header buffer at lblock
821  * @sdp: The GFS2 superblock
822  * @jd: journal descriptor of the journal to which we are writing
823  * @seq: sequence number
824  * @tail: tail of the log
825  * @lblock: value for lh_blkno (block number relative to start of journal)
826  * @flags: log header flags GFS2_LOG_HEAD_*
827  * @op_flags: flags to pass to the bio
828  *
829  * Returns: the initialized log buffer descriptor
830  */
831 
gfs2_write_log_header(struct gfs2_sbd * sdp,struct gfs2_jdesc * jd,u64 seq,u32 tail,u32 lblock,u32 flags,blk_opf_t op_flags)832 void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
833 			   u64 seq, u32 tail, u32 lblock, u32 flags,
834 			   blk_opf_t op_flags)
835 {
836 	struct gfs2_log_header *lh;
837 	u32 hash, crc;
838 	struct page *page;
839 	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
840 	struct timespec64 tv;
841 	struct super_block *sb = sdp->sd_vfs;
842 	u64 dblock;
843 
844 	if (gfs2_withdrawn(sdp))
845 		return;
846 
847 	page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
848 	lh = page_address(page);
849 	clear_page(lh);
850 
851 	lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
852 	lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
853 	lh->lh_header.__pad0 = cpu_to_be64(0);
854 	lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
855 	lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
856 	lh->lh_sequence = cpu_to_be64(seq);
857 	lh->lh_flags = cpu_to_be32(flags);
858 	lh->lh_tail = cpu_to_be32(tail);
859 	lh->lh_blkno = cpu_to_be32(lblock);
860 	hash = ~crc32(~0, lh, LH_V1_SIZE);
861 	lh->lh_hash = cpu_to_be32(hash);
862 
863 	ktime_get_coarse_real_ts64(&tv);
864 	lh->lh_nsec = cpu_to_be32(tv.tv_nsec);
865 	lh->lh_sec = cpu_to_be64(tv.tv_sec);
866 	if (!list_empty(&jd->extent_list))
867 		dblock = gfs2_log_bmap(jd, lblock);
868 	else {
869 		unsigned int extlen;
870 		int ret;
871 
872 		extlen = 1;
873 		ret = gfs2_get_extent(jd->jd_inode, lblock, &dblock, &extlen);
874 		if (gfs2_assert_withdraw(sdp, ret == 0))
875 			return;
876 	}
877 	lh->lh_addr = cpu_to_be64(dblock);
878 	lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr);
879 
880 	/* We may only write local statfs, quota, etc., when writing to our
881 	   own journal. The values are left 0 when recovering a journal
882 	   different from our own. */
883 	if (!(flags & GFS2_LOG_HEAD_RECOVERY)) {
884 		lh->lh_statfs_addr =
885 			cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr);
886 		lh->lh_quota_addr =
887 			cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr);
888 
889 		spin_lock(&sdp->sd_statfs_spin);
890 		lh->lh_local_total = cpu_to_be64(l_sc->sc_total);
891 		lh->lh_local_free = cpu_to_be64(l_sc->sc_free);
892 		lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes);
893 		spin_unlock(&sdp->sd_statfs_spin);
894 	}
895 
896 	BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE);
897 
898 	crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4,
899 		     sb->s_blocksize - LH_V1_SIZE - 4);
900 	lh->lh_crc = cpu_to_be32(crc);
901 
902 	gfs2_log_write(sdp, jd, page, sb->s_blocksize, 0, dblock);
903 	gfs2_log_submit_bio(&jd->jd_log_bio, REQ_OP_WRITE | op_flags);
904 }
905 
906 /**
907  * log_write_header - Get and initialize a journal header buffer
908  * @sdp: The GFS2 superblock
909  * @flags: The log header flags, including log header origin
910  *
911  * Returns: the initialized log buffer descriptor
912  */
913 
log_write_header(struct gfs2_sbd * sdp,u32 flags)914 static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
915 {
916 	blk_opf_t op_flags = REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC;
917 
918 	gfs2_assert_withdraw(sdp, !test_bit(SDF_FROZEN, &sdp->sd_flags));
919 
920 	if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) {
921 		gfs2_ordered_wait(sdp);
922 		log_flush_wait(sdp);
923 		op_flags = REQ_SYNC | REQ_META | REQ_PRIO;
924 	}
925 	sdp->sd_log_idle = (sdp->sd_log_flush_tail == sdp->sd_log_flush_head);
926 	gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++,
927 			      sdp->sd_log_flush_tail, sdp->sd_log_flush_head,
928 			      flags, op_flags);
929 	gfs2_log_incr_head(sdp);
930 	log_flush_wait(sdp);
931 	log_pull_tail(sdp);
932 	gfs2_log_update_head(sdp);
933 }
934 
935 /**
936  * gfs2_ail_drain - drain the ail lists after a withdraw
937  * @sdp: Pointer to GFS2 superblock
938  */
gfs2_ail_drain(struct gfs2_sbd * sdp)939 void gfs2_ail_drain(struct gfs2_sbd *sdp)
940 {
941 	struct gfs2_trans *tr;
942 
943 	spin_lock(&sdp->sd_ail_lock);
944 	/*
945 	 * For transactions on the sd_ail1_list we need to drain both the
946 	 * ail1 and ail2 lists. That's because function gfs2_ail1_start_one
947 	 * (temporarily) moves items from its tr_ail1 list to tr_ail2 list
948 	 * before revokes are sent for that block. Items on the sd_ail2_list
949 	 * should have already gotten beyond that point, so no need.
950 	 */
951 	while (!list_empty(&sdp->sd_ail1_list)) {
952 		tr = list_first_entry(&sdp->sd_ail1_list, struct gfs2_trans,
953 				      tr_list);
954 		gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail1_list);
955 		gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
956 		list_del(&tr->tr_list);
957 		gfs2_trans_free(sdp, tr);
958 	}
959 	while (!list_empty(&sdp->sd_ail2_list)) {
960 		tr = list_first_entry(&sdp->sd_ail2_list, struct gfs2_trans,
961 				      tr_list);
962 		gfs2_ail_empty_tr(sdp, tr, &tr->tr_ail2_list);
963 		list_del(&tr->tr_list);
964 		gfs2_trans_free(sdp, tr);
965 	}
966 	gfs2_drain_revokes(sdp);
967 	spin_unlock(&sdp->sd_ail_lock);
968 }
969 
970 /**
971  * empty_ail1_list - try to start IO and empty the ail1 list
972  * @sdp: Pointer to GFS2 superblock
973  */
empty_ail1_list(struct gfs2_sbd * sdp)974 static void empty_ail1_list(struct gfs2_sbd *sdp)
975 {
976 	unsigned long start = jiffies;
977 
978 	for (;;) {
979 		if (time_after(jiffies, start + (HZ * 600))) {
980 			fs_err(sdp, "Error: In %s for 10 minutes! t=%d\n",
981 			       __func__, current->journal_info ? 1 : 0);
982 			dump_ail_list(sdp);
983 			return;
984 		}
985 		gfs2_ail1_start(sdp);
986 		gfs2_ail1_wait(sdp);
987 		if (gfs2_ail1_empty(sdp, 0))
988 			return;
989 	}
990 }
991 
992 /**
993  * trans_drain - drain the buf and databuf queue for a failed transaction
994  * @tr: the transaction to drain
995  *
996  * When this is called, we're taking an error exit for a log write that failed
997  * but since we bypassed the after_commit functions, we need to remove the
998  * items from the buf and databuf queue.
999  */
trans_drain(struct gfs2_trans * tr)1000 static void trans_drain(struct gfs2_trans *tr)
1001 {
1002 	struct gfs2_bufdata *bd;
1003 	struct list_head *head;
1004 
1005 	if (!tr)
1006 		return;
1007 
1008 	head = &tr->tr_buf;
1009 	while (!list_empty(head)) {
1010 		bd = list_first_entry(head, struct gfs2_bufdata, bd_list);
1011 		list_del_init(&bd->bd_list);
1012 		if (!list_empty(&bd->bd_ail_st_list))
1013 			gfs2_remove_from_ail(bd);
1014 		kmem_cache_free(gfs2_bufdata_cachep, bd);
1015 	}
1016 	head = &tr->tr_databuf;
1017 	while (!list_empty(head)) {
1018 		bd = list_first_entry(head, struct gfs2_bufdata, bd_list);
1019 		list_del_init(&bd->bd_list);
1020 		if (!list_empty(&bd->bd_ail_st_list))
1021 			gfs2_remove_from_ail(bd);
1022 		kmem_cache_free(gfs2_bufdata_cachep, bd);
1023 	}
1024 }
1025 
1026 /**
1027  * gfs2_log_flush - flush incore transaction(s)
1028  * @sdp: The filesystem
1029  * @gl: The glock structure to flush.  If NULL, flush the whole incore log
1030  * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_* and debug flags
1031  *
1032  */
1033 
gfs2_log_flush(struct gfs2_sbd * sdp,struct gfs2_glock * gl,u32 flags)1034 void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
1035 {
1036 	struct gfs2_trans *tr = NULL;
1037 	unsigned int reserved_blocks = 0, used_blocks = 0;
1038 	bool frozen = test_bit(SDF_FROZEN, &sdp->sd_flags);
1039 	unsigned int first_log_head;
1040 	unsigned int reserved_revokes = 0;
1041 
1042 	down_write(&sdp->sd_log_flush_lock);
1043 	trace_gfs2_log_flush(sdp, 1, flags);
1044 
1045 repeat:
1046 	/*
1047 	 * Do this check while holding the log_flush_lock to prevent new
1048 	 * buffers from being added to the ail via gfs2_pin()
1049 	 */
1050 	if (gfs2_withdrawn(sdp) || !test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1051 		goto out;
1052 
1053 	/* Log might have been flushed while we waited for the flush lock */
1054 	if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags))
1055 		goto out;
1056 
1057 	first_log_head = sdp->sd_log_head;
1058 	sdp->sd_log_flush_head = first_log_head;
1059 
1060 	tr = sdp->sd_log_tr;
1061 	if (tr || sdp->sd_log_num_revoke) {
1062 		if (reserved_blocks)
1063 			gfs2_log_release(sdp, reserved_blocks);
1064 		reserved_blocks = sdp->sd_log_blks_reserved;
1065 		reserved_revokes = sdp->sd_log_num_revoke;
1066 		if (tr) {
1067 			sdp->sd_log_tr = NULL;
1068 			tr->tr_first = first_log_head;
1069 			if (unlikely(frozen)) {
1070 				if (gfs2_assert_withdraw_delayed(sdp,
1071 				       !tr->tr_num_buf_new && !tr->tr_num_databuf_new))
1072 					goto out_withdraw;
1073 			}
1074 		}
1075 	} else if (!reserved_blocks) {
1076 		unsigned int taboo_blocks = GFS2_LOG_FLUSH_MIN_BLOCKS;
1077 
1078 		reserved_blocks = GFS2_LOG_FLUSH_MIN_BLOCKS;
1079 		if (current == sdp->sd_logd_process)
1080 			taboo_blocks = 0;
1081 
1082 		if (!__gfs2_log_try_reserve(sdp, reserved_blocks, taboo_blocks)) {
1083 			up_write(&sdp->sd_log_flush_lock);
1084 			__gfs2_log_reserve(sdp, reserved_blocks, taboo_blocks);
1085 			down_write(&sdp->sd_log_flush_lock);
1086 			goto repeat;
1087 		}
1088 		BUG_ON(sdp->sd_log_num_revoke);
1089 	}
1090 
1091 	if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN)
1092 		clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
1093 
1094 	if (unlikely(frozen))
1095 		if (gfs2_assert_withdraw_delayed(sdp, !reserved_revokes))
1096 			goto out_withdraw;
1097 
1098 	gfs2_ordered_write(sdp);
1099 	if (gfs2_withdrawn(sdp))
1100 		goto out_withdraw;
1101 	lops_before_commit(sdp, tr);
1102 	if (gfs2_withdrawn(sdp))
1103 		goto out_withdraw;
1104 	gfs2_log_submit_bio(&sdp->sd_jdesc->jd_log_bio, REQ_OP_WRITE);
1105 	if (gfs2_withdrawn(sdp))
1106 		goto out_withdraw;
1107 
1108 	if (sdp->sd_log_head != sdp->sd_log_flush_head) {
1109 		log_write_header(sdp, flags);
1110 	} else if (sdp->sd_log_tail != sdp->sd_log_flush_tail && !sdp->sd_log_idle) {
1111 		log_write_header(sdp, flags);
1112 	}
1113 	if (gfs2_withdrawn(sdp))
1114 		goto out_withdraw;
1115 	lops_after_commit(sdp, tr);
1116 
1117 	gfs2_log_lock(sdp);
1118 	sdp->sd_log_blks_reserved = 0;
1119 
1120 	spin_lock(&sdp->sd_ail_lock);
1121 	if (tr && !list_empty(&tr->tr_ail1_list)) {
1122 		list_add(&tr->tr_list, &sdp->sd_ail1_list);
1123 		tr = NULL;
1124 	}
1125 	spin_unlock(&sdp->sd_ail_lock);
1126 	gfs2_log_unlock(sdp);
1127 
1128 	if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) {
1129 		if (!sdp->sd_log_idle) {
1130 			empty_ail1_list(sdp);
1131 			if (gfs2_withdrawn(sdp))
1132 				goto out_withdraw;
1133 			log_write_header(sdp, flags);
1134 		}
1135 		if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN |
1136 			     GFS2_LOG_HEAD_FLUSH_FREEZE))
1137 			gfs2_log_shutdown(sdp);
1138 	}
1139 
1140 out_end:
1141 	used_blocks = log_distance(sdp, sdp->sd_log_flush_head, first_log_head);
1142 	reserved_revokes += atomic_read(&sdp->sd_log_revokes_available);
1143 	atomic_set(&sdp->sd_log_revokes_available, sdp->sd_ldptrs);
1144 	gfs2_assert_withdraw(sdp, reserved_revokes % sdp->sd_inptrs == sdp->sd_ldptrs);
1145 	if (reserved_revokes > sdp->sd_ldptrs)
1146 		reserved_blocks += (reserved_revokes - sdp->sd_ldptrs) / sdp->sd_inptrs;
1147 out:
1148 	if (used_blocks != reserved_blocks) {
1149 		gfs2_assert_withdraw_delayed(sdp, used_blocks < reserved_blocks);
1150 		gfs2_log_release(sdp, reserved_blocks - used_blocks);
1151 	}
1152 	up_write(&sdp->sd_log_flush_lock);
1153 	gfs2_trans_free(sdp, tr);
1154 	if (gfs2_withdrawing(sdp))
1155 		gfs2_withdraw(sdp);
1156 	trace_gfs2_log_flush(sdp, 0, flags);
1157 	return;
1158 
1159 out_withdraw:
1160 	trans_drain(tr);
1161 	/**
1162 	 * If the tr_list is empty, we're withdrawing during a log
1163 	 * flush that targets a transaction, but the transaction was
1164 	 * never queued onto any of the ail lists. Here we add it to
1165 	 * ail1 just so that ail_drain() will find and free it.
1166 	 */
1167 	spin_lock(&sdp->sd_ail_lock);
1168 	if (tr && list_empty(&tr->tr_list))
1169 		list_add(&tr->tr_list, &sdp->sd_ail1_list);
1170 	spin_unlock(&sdp->sd_ail_lock);
1171 	tr = NULL;
1172 	goto out_end;
1173 }
1174 
1175 /**
1176  * gfs2_merge_trans - Merge a new transaction into a cached transaction
1177  * @sdp: the filesystem
1178  * @new: New transaction to be merged
1179  */
1180 
gfs2_merge_trans(struct gfs2_sbd * sdp,struct gfs2_trans * new)1181 static void gfs2_merge_trans(struct gfs2_sbd *sdp, struct gfs2_trans *new)
1182 {
1183 	struct gfs2_trans *old = sdp->sd_log_tr;
1184 
1185 	WARN_ON_ONCE(!test_bit(TR_ATTACHED, &old->tr_flags));
1186 
1187 	old->tr_num_buf_new	+= new->tr_num_buf_new;
1188 	old->tr_num_databuf_new	+= new->tr_num_databuf_new;
1189 	old->tr_num_buf_rm	+= new->tr_num_buf_rm;
1190 	old->tr_num_databuf_rm	+= new->tr_num_databuf_rm;
1191 	old->tr_revokes		+= new->tr_revokes;
1192 	old->tr_num_revoke	+= new->tr_num_revoke;
1193 
1194 	list_splice_tail_init(&new->tr_databuf, &old->tr_databuf);
1195 	list_splice_tail_init(&new->tr_buf, &old->tr_buf);
1196 
1197 	spin_lock(&sdp->sd_ail_lock);
1198 	list_splice_tail_init(&new->tr_ail1_list, &old->tr_ail1_list);
1199 	list_splice_tail_init(&new->tr_ail2_list, &old->tr_ail2_list);
1200 	spin_unlock(&sdp->sd_ail_lock);
1201 }
1202 
log_refund(struct gfs2_sbd * sdp,struct gfs2_trans * tr)1203 static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1204 {
1205 	unsigned int reserved;
1206 	unsigned int unused;
1207 	unsigned int maxres;
1208 
1209 	gfs2_log_lock(sdp);
1210 
1211 	if (sdp->sd_log_tr) {
1212 		gfs2_merge_trans(sdp, tr);
1213 	} else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) {
1214 		gfs2_assert_withdraw(sdp, !test_bit(TR_ONSTACK, &tr->tr_flags));
1215 		sdp->sd_log_tr = tr;
1216 		set_bit(TR_ATTACHED, &tr->tr_flags);
1217 	}
1218 
1219 	reserved = calc_reserved(sdp);
1220 	maxres = sdp->sd_log_blks_reserved + tr->tr_reserved;
1221 	gfs2_assert_withdraw(sdp, maxres >= reserved);
1222 	unused = maxres - reserved;
1223 	if (unused)
1224 		gfs2_log_release(sdp, unused);
1225 	sdp->sd_log_blks_reserved = reserved;
1226 
1227 	gfs2_log_unlock(sdp);
1228 }
1229 
gfs2_jrnl_flush_reqd(struct gfs2_sbd * sdp)1230 static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
1231 {
1232 	return atomic_read(&sdp->sd_log_pinned) +
1233 	       atomic_read(&sdp->sd_log_blks_needed) >=
1234 	       atomic_read(&sdp->sd_log_thresh1);
1235 }
1236 
gfs2_ail_flush_reqd(struct gfs2_sbd * sdp)1237 static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
1238 {
1239 	return sdp->sd_jdesc->jd_blocks -
1240 	       atomic_read(&sdp->sd_log_blks_free) +
1241 	       atomic_read(&sdp->sd_log_blks_needed) >=
1242 	       atomic_read(&sdp->sd_log_thresh2);
1243 }
1244 
1245 /**
1246  * gfs2_log_commit - Commit a transaction to the log
1247  * @sdp: the filesystem
1248  * @tr: the transaction
1249  *
1250  * We wake up gfs2_logd if the number of pinned blocks exceed thresh1
1251  * or the total number of used blocks (pinned blocks plus AIL blocks)
1252  * is greater than thresh2.
1253  *
1254  * At mount time thresh1 is 2/5ths of journal size, thresh2 is 4/5ths of
1255  * journal size.
1256  *
1257  * Returns: errno
1258  */
1259 
gfs2_log_commit(struct gfs2_sbd * sdp,struct gfs2_trans * tr)1260 void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
1261 {
1262 	log_refund(sdp, tr);
1263 
1264 	if (gfs2_ail_flush_reqd(sdp) || gfs2_jrnl_flush_reqd(sdp))
1265 		wake_up(&sdp->sd_logd_waitq);
1266 }
1267 
1268 /**
1269  * gfs2_log_shutdown - write a shutdown header into a journal
1270  * @sdp: the filesystem
1271  *
1272  */
1273 
gfs2_log_shutdown(struct gfs2_sbd * sdp)1274 static void gfs2_log_shutdown(struct gfs2_sbd *sdp)
1275 {
1276 	gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
1277 	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
1278 	gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
1279 
1280 	log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT | GFS2_LFC_SHUTDOWN);
1281 	log_pull_tail(sdp);
1282 
1283 	gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
1284 	gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
1285 }
1286 
1287 /**
1288  * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
1289  * @data: Pointer to GFS2 superblock
1290  *
1291  * Also, periodically check to make sure that we're using the most recent
1292  * journal index.
1293  */
1294 
gfs2_logd(void * data)1295 int gfs2_logd(void *data)
1296 {
1297 	struct gfs2_sbd *sdp = data;
1298 	unsigned long t = 1;
1299 
1300 	while (!kthread_should_stop()) {
1301 		if (gfs2_withdrawn(sdp))
1302 			break;
1303 
1304 		/* Check for errors writing to the journal */
1305 		if (sdp->sd_log_error) {
1306 			gfs2_lm(sdp,
1307 				"GFS2: fsid=%s: error %d: "
1308 				"withdrawing the file system to "
1309 				"prevent further damage.\n",
1310 				sdp->sd_fsname, sdp->sd_log_error);
1311 			gfs2_withdraw(sdp);
1312 			break;
1313 		}
1314 
1315 		if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
1316 			gfs2_ail1_empty(sdp, 0);
1317 			gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1318 						  GFS2_LFC_LOGD_JFLUSH_REQD);
1319 		}
1320 
1321 		if (test_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags) ||
1322 		    gfs2_ail_flush_reqd(sdp)) {
1323 			clear_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags);
1324 			gfs2_ail1_start(sdp);
1325 			gfs2_ail1_wait(sdp);
1326 			gfs2_ail1_empty(sdp, 0);
1327 			gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
1328 						  GFS2_LFC_LOGD_AIL_FLUSH_REQD);
1329 		}
1330 
1331 		t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
1332 
1333 		try_to_freeze();
1334 
1335 		t = wait_event_interruptible_timeout(sdp->sd_logd_waitq,
1336 				test_bit(SDF_FORCE_AIL_FLUSH, &sdp->sd_flags) ||
1337 				gfs2_ail_flush_reqd(sdp) ||
1338 				gfs2_jrnl_flush_reqd(sdp) ||
1339 				sdp->sd_log_error ||
1340 				gfs2_withdrawn(sdp) ||
1341 				kthread_should_stop(),
1342 				t);
1343 	}
1344 
1345 	return 0;
1346 }
1347 
1348