blob: 536e7a6252cd8072835373b928878a4d91fb6e4a [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Petersonda6dd402007-12-11 18:49:21 -06003 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
13#include <linux/completion.h>
14#include <linux/buffer_head.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050015#include <linux/gfs2_ondisk.h>
Steven Whitehouse71b86f52006-03-28 14:14:04 -050016#include <linux/crc32.h>
Steven Whitehousea25311c2006-11-23 11:06:35 -050017#include <linux/delay.h>
Steven Whitehouseec69b182007-11-09 10:01:41 +000018#include <linux/kthread.h>
19#include <linux/freezer.h>
Steven Whitehouse254db572008-09-26 10:23:22 +010020#include <linux/bio.h>
Steven Whitehouse885bcec2014-02-03 09:57:29 +000021#include <linux/blkdev.h>
Steven Whitehouse4667a0e2011-04-18 14:18:09 +010022#include <linux/writeback.h>
Bob Peterson4a36d082012-02-14 14:49:57 -050023#include <linux/list_sort.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000024
25#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050026#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000027#include "bmap.h"
28#include "glock.h"
29#include "log.h"
30#include "lops.h"
31#include "meta_io.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050032#include "util.h"
Steven Whitehouse71b86f52006-03-28 14:14:04 -050033#include "dir.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010034#include "trace_gfs2.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000035
David Teiglandb3b94fa2006-01-16 16:50:04 +000036/**
37 * gfs2_struct2blk - compute stuff
38 * @sdp: the filesystem
39 * @nstruct: the number of structures
40 * @ssize: the size of the 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
48unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
49 unsigned int ssize)
50{
51 unsigned int blks;
52 unsigned int first, second;
53
54 blks = 1;
Steven Whitehousefaa31ce2006-09-13 11:13:27 -040055 first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize;
David Teiglandb3b94fa2006-01-16 16:50:04 +000056
57 if (nstruct > first) {
Steven Whitehouse568f4c92006-02-27 12:00:42 -050058 second = (sdp->sd_sb.sb_bsize -
59 sizeof(struct gfs2_meta_header)) / ssize;
Steven Whitehouse5c676f62006-02-27 17:23:27 -050060 blks += DIV_ROUND_UP(nstruct - first, second);
David Teiglandb3b94fa2006-01-16 16:50:04 +000061 }
62
63 return blks;
64}
65
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040066/**
Steven Whitehouse1e1a3d02007-08-27 09:45:26 +010067 * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters
68 * @mapping: The associated mapping (maybe NULL)
69 * @bd: The gfs2_bufdata to remove
70 *
Steven Whitehousec618e872011-03-14 12:40:29 +000071 * The ail lock _must_ be held when calling this function
Steven Whitehouse1e1a3d02007-08-27 09:45:26 +010072 *
73 */
74
Steven Whitehousef91a0d32007-10-15 16:29:05 +010075void gfs2_remove_from_ail(struct gfs2_bufdata *bd)
Steven Whitehouse1e1a3d02007-08-27 09:45:26 +010076{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -050077 bd->bd_tr = NULL;
Steven Whitehouse1ad38c42007-09-03 11:01:33 +010078 list_del_init(&bd->bd_ail_st_list);
79 list_del_init(&bd->bd_ail_gl_list);
Steven Whitehouse1e1a3d02007-08-27 09:45:26 +010080 atomic_dec(&bd->bd_gl->gl_ail_count);
Steven Whitehouse1e1a3d02007-08-27 09:45:26 +010081 brelse(bd->bd_bh);
82}
83
84/**
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040085 * gfs2_ail1_start_one - Start I/O on a part of the AIL
86 * @sdp: the filesystem
Steven Whitehouse4667a0e2011-04-18 14:18:09 +010087 * @wbc: The writeback control structure
88 * @ai: The ail structure
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040089 *
90 */
91
Steven Whitehouse4f1de012011-04-26 10:23:56 +010092static int gfs2_ail1_start_one(struct gfs2_sbd *sdp,
93 struct writeback_control *wbc,
Benjamin Marzinski16ca9412013-04-05 20:31:46 -050094 struct gfs2_trans *tr)
Dave Chinnerd6a079e2011-03-11 11:52:25 +000095__releases(&sdp->sd_ail_lock)
96__acquires(&sdp->sd_ail_lock)
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040097{
Steven Whitehouse5ac048b2011-03-30 16:25:51 +010098 struct gfs2_glock *gl = NULL;
Steven Whitehouse4667a0e2011-04-18 14:18:09 +010099 struct address_space *mapping;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400100 struct gfs2_bufdata *bd, *s;
101 struct buffer_head *bh;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400102
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500103 list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list, bd_ail_st_list) {
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100104 bh = bd->bd_bh;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400105
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500106 gfs2_assert(sdp, bd->bd_tr == tr);
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400107
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100108 if (!buffer_busy(bh)) {
109 if (!buffer_uptodate(bh))
110 gfs2_io_error_bh(sdp, bh);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500111 list_move(&bd->bd_ail_st_list, &tr->tr_ail2_list);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100112 continue;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400113 }
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100114
115 if (!buffer_dirty(bh))
116 continue;
117 if (gl == bd->bd_gl)
118 continue;
119 gl = bd->bd_gl;
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500120 list_move(&bd->bd_ail_st_list, &tr->tr_ail1_list);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100121 mapping = bh->b_page->mapping;
Steven Whitehouse4f1de012011-04-26 10:23:56 +0100122 if (!mapping)
123 continue;
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100124 spin_unlock(&sdp->sd_ail_lock);
125 generic_writepages(mapping, wbc);
126 spin_lock(&sdp->sd_ail_lock);
127 if (wbc->nr_to_write <= 0)
128 break;
Steven Whitehouse4f1de012011-04-26 10:23:56 +0100129 return 1;
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100130 }
Steven Whitehouse4f1de012011-04-26 10:23:56 +0100131
132 return 0;
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100133}
134
135
136/**
137 * gfs2_ail1_flush - start writeback of some ail1 entries
138 * @sdp: The super block
139 * @wbc: The writeback control structure
140 *
141 * Writes back some ail1 entries, according to the limits in the
142 * writeback control structure
143 */
144
145void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
146{
147 struct list_head *head = &sdp->sd_ail1_list;
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500148 struct gfs2_trans *tr;
Steven Whitehouse885bcec2014-02-03 09:57:29 +0000149 struct blk_plug plug;
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100150
Steven Whitehousec83ae9c2011-04-18 14:18:38 +0100151 trace_gfs2_ail_flush(sdp, wbc, 1);
Steven Whitehouse885bcec2014-02-03 09:57:29 +0000152 blk_start_plug(&plug);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100153 spin_lock(&sdp->sd_ail_lock);
Steven Whitehouse4f1de012011-04-26 10:23:56 +0100154restart:
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500155 list_for_each_entry_reverse(tr, head, tr_list) {
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100156 if (wbc->nr_to_write <= 0)
157 break;
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500158 if (gfs2_ail1_start_one(sdp, wbc, tr))
Steven Whitehouse4f1de012011-04-26 10:23:56 +0100159 goto restart;
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100160 }
161 spin_unlock(&sdp->sd_ail_lock);
Steven Whitehouse885bcec2014-02-03 09:57:29 +0000162 blk_finish_plug(&plug);
Steven Whitehousec83ae9c2011-04-18 14:18:38 +0100163 trace_gfs2_ail_flush(sdp, wbc, 0);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100164}
165
166/**
167 * gfs2_ail1_start - start writeback of all ail1 entries
168 * @sdp: The superblock
169 */
170
171static void gfs2_ail1_start(struct gfs2_sbd *sdp)
172{
173 struct writeback_control wbc = {
174 .sync_mode = WB_SYNC_NONE,
175 .nr_to_write = LONG_MAX,
176 .range_start = 0,
177 .range_end = LLONG_MAX,
178 };
179
180 return gfs2_ail1_flush(sdp, &wbc);
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400181}
182
183/**
184 * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
185 * @sdp: the filesystem
186 * @ai: the AIL entry
187 *
188 */
189
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500190static void gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400191{
192 struct gfs2_bufdata *bd, *s;
193 struct buffer_head *bh;
194
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500195 list_for_each_entry_safe_reverse(bd, s, &tr->tr_ail1_list,
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400196 bd_ail_st_list) {
197 bh = bd->bd_bh;
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500198 gfs2_assert(sdp, bd->bd_tr == tr);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100199 if (buffer_busy(bh))
200 continue;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400201 if (!buffer_uptodate(bh))
202 gfs2_io_error_bh(sdp, bh);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500203 list_move(&bd->bd_ail_st_list, &tr->tr_ail2_list);
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400204 }
205
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400206}
207
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100208/**
209 * gfs2_ail1_empty - Try to empty the ail1 lists
210 * @sdp: The superblock
211 *
212 * Tries to empty the ail1 lists, starting with the oldest first
213 */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000214
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100215static int gfs2_ail1_empty(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000216{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500217 struct gfs2_trans *tr, *s;
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500218 int oldest_tr = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000219 int ret;
220
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000221 spin_lock(&sdp->sd_ail_lock);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500222 list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
223 gfs2_ail1_empty_one(sdp, tr);
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500224 if (list_empty(&tr->tr_ail1_list) && oldest_tr)
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500225 list_move(&tr->tr_list, &sdp->sd_ail2_list);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100226 else
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500227 oldest_tr = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000228 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000229 ret = list_empty(&sdp->sd_ail1_list);
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000230 spin_unlock(&sdp->sd_ail_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000231
232 return ret;
233}
234
Steven Whitehouse26b06a62011-05-21 19:21:07 +0100235static void gfs2_ail1_wait(struct gfs2_sbd *sdp)
236{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500237 struct gfs2_trans *tr;
Steven Whitehouse26b06a62011-05-21 19:21:07 +0100238 struct gfs2_bufdata *bd;
239 struct buffer_head *bh;
240
241 spin_lock(&sdp->sd_ail_lock);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500242 list_for_each_entry_reverse(tr, &sdp->sd_ail1_list, tr_list) {
243 list_for_each_entry(bd, &tr->tr_ail1_list, bd_ail_st_list) {
Steven Whitehouse26b06a62011-05-21 19:21:07 +0100244 bh = bd->bd_bh;
245 if (!buffer_locked(bh))
246 continue;
247 get_bh(bh);
248 spin_unlock(&sdp->sd_ail_lock);
249 wait_on_buffer(bh);
250 brelse(bh);
251 return;
252 }
253 }
254 spin_unlock(&sdp->sd_ail_lock);
255}
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400256
257/**
258 * gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced
259 * @sdp: the filesystem
260 * @ai: the AIL entry
261 *
262 */
263
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500264static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400265{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500266 struct list_head *head = &tr->tr_ail2_list;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400267 struct gfs2_bufdata *bd;
268
269 while (!list_empty(head)) {
270 bd = list_entry(head->prev, struct gfs2_bufdata,
271 bd_ail_st_list);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500272 gfs2_assert(sdp, bd->bd_tr == tr);
Steven Whitehousef91a0d32007-10-15 16:29:05 +0100273 gfs2_remove_from_ail(bd);
Steven Whitehouseddacfaf2006-10-03 11:10:41 -0400274 }
275}
276
David Teiglandb3b94fa2006-01-16 16:50:04 +0000277static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
278{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500279 struct gfs2_trans *tr, *safe;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000280 unsigned int old_tail = sdp->sd_log_tail;
281 int wrap = (new_tail < old_tail);
282 int a, b, rm;
283
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000284 spin_lock(&sdp->sd_ail_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000285
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500286 list_for_each_entry_safe(tr, safe, &sdp->sd_ail2_list, tr_list) {
287 a = (old_tail <= tr->tr_first);
288 b = (tr->tr_first < new_tail);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000289 rm = (wrap) ? (a || b) : (a && b);
290 if (!rm)
291 continue;
292
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500293 gfs2_ail2_empty_one(sdp, tr);
294 list_del(&tr->tr_list);
295 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail1_list));
296 gfs2_assert_warn(sdp, list_empty(&tr->tr_ail2_list));
297 kfree(tr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000298 }
299
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000300 spin_unlock(&sdp->sd_ail_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000301}
302
303/**
Benjamin Marzinski24972552014-05-01 22:26:55 -0500304 * gfs2_log_release - Release a given number of log blocks
305 * @sdp: The GFS2 superblock
306 * @blks: The number of blocks
307 *
308 */
309
310void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
311{
312
313 atomic_add(blks, &sdp->sd_log_blks_free);
314 trace_gfs2_log_blocks(sdp, blks);
315 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
316 sdp->sd_jdesc->jd_blocks);
317 up_read(&sdp->sd_log_flush_lock);
318}
319
320/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000321 * gfs2_log_reserve - Make a log reservation
322 * @sdp: The GFS2 superblock
323 * @blks: The number of blocks to reserve
324 *
Steven Whitehouse89918642007-06-01 15:19:33 +0100325 * Note that we never give out the last few blocks of the journal. Thats
Robert Peterson2332c442007-06-18 14:50:20 -0500326 * due to the fact that there is a small number of header blocks
Steven Whitehouseb0041572006-11-23 10:51:34 -0500327 * associated with each log flush. The exact number can't be known until
328 * flush time, so we ensure that we have just enough free blocks at all
329 * times to avoid running out during a log flush.
330 *
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500331 * We no longer flush the log here, instead we wake up logd to do that
332 * for us. To avoid the thundering herd and to ensure that we deal fairly
333 * with queued waiters, we use an exclusive wait. This means that when we
334 * get woken with enough journal space to get our reservation, we need to
335 * wake the next waiter on the list.
336 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000337 * Returns: errno
338 */
339
340int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
341{
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600342 int ret = 0;
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500343 unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500344 unsigned wanted = blks + reserved_blks;
345 DEFINE_WAIT(wait);
346 int did_wait = 0;
347 unsigned int free_blocks;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000348
349 if (gfs2_assert_warn(sdp, blks) ||
350 gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
351 return -EINVAL;
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500352retry:
353 free_blocks = atomic_read(&sdp->sd_log_blks_free);
354 if (unlikely(free_blocks <= wanted)) {
355 do {
356 prepare_to_wait_exclusive(&sdp->sd_log_waitq, &wait,
357 TASK_UNINTERRUPTIBLE);
358 wake_up(&sdp->sd_logd_waitq);
359 did_wait = 1;
360 if (atomic_read(&sdp->sd_log_blks_free) <= wanted)
361 io_schedule();
362 free_blocks = atomic_read(&sdp->sd_log_blks_free);
363 } while(free_blocks <= wanted);
364 finish_wait(&sdp->sd_log_waitq, &wait);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000365 }
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600366 atomic_inc(&sdp->sd_reserving_log);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500367 if (atomic_cmpxchg(&sdp->sd_log_blks_free, free_blocks,
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600368 free_blocks - blks) != free_blocks) {
369 if (atomic_dec_and_test(&sdp->sd_reserving_log))
370 wake_up(&sdp->sd_reserving_log_wait);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500371 goto retry;
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600372 }
Steven Whitehouse63997772009-06-12 08:49:20 +0100373 trace_gfs2_log_blocks(sdp, -blks);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500374
375 /*
376 * If we waited, then so might others, wake them up _after_ we get
377 * our share of the log.
378 */
379 if (unlikely(did_wait))
380 wake_up(&sdp->sd_log_waitq);
Steven Whitehouse484adff2006-03-29 09:12:12 -0500381
382 down_read(&sdp->sd_log_flush_lock);
Benjamin Marzinski24972552014-05-01 22:26:55 -0500383 if (unlikely(!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))) {
384 gfs2_log_release(sdp, blks);
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600385 ret = -EROFS;
Benjamin Marzinski24972552014-05-01 22:26:55 -0500386 }
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600387 if (atomic_dec_and_test(&sdp->sd_reserving_log))
388 wake_up(&sdp->sd_reserving_log_wait);
389 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000390}
391
David Teiglandb3b94fa2006-01-16 16:50:04 +0000392/**
393 * log_distance - Compute distance between two journal blocks
394 * @sdp: The GFS2 superblock
395 * @newer: The most recent journal block of the pair
396 * @older: The older journal block of the pair
397 *
398 * Compute the distance (in the journal direction) between two
399 * blocks in the journal
400 *
401 * Returns: the distance in blocks
402 */
403
Steven Whitehousefaa31ce2006-09-13 11:13:27 -0400404static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000405 unsigned int older)
406{
407 int dist;
408
409 dist = newer - older;
410 if (dist < 0)
411 dist += sdp->sd_jdesc->jd_blocks;
412
413 return dist;
414}
415
Robert Peterson2332c442007-06-18 14:50:20 -0500416/**
417 * calc_reserved - Calculate the number of blocks to reserve when
418 * refunding a transaction's unused buffers.
419 * @sdp: The GFS2 superblock
420 *
421 * This is complex. We need to reserve room for all our currently used
422 * metadata buffers (e.g. normal file I/O rewriting file time stamps) and
423 * all our journaled data buffers for journaled files (e.g. files in the
424 * meta_fs like rindex, or files for which chattr +j was done.)
425 * If we don't reserve enough space, gfs2_log_refund and gfs2_log_flush
426 * will count it as free space (sd_log_blks_free) and corruption will follow.
427 *
428 * We can have metadata bufs and jdata bufs in the same journal. So each
429 * type gets its own log header, for which we need to reserve a block.
430 * In fact, each type has the potential for needing more than one header
431 * in cases where we have more buffers than will fit on a journal page.
432 * Metadata journal entries take up half the space of journaled buffer entries.
433 * Thus, metadata entries have buf_limit (502) and journaled buffers have
434 * databuf_limit (251) before they cause a wrap around.
435 *
436 * Also, we need to reserve blocks for revoke journal entries and one for an
437 * overall header for the lot.
438 *
439 * Returns: the number of blocks reserved
440 */
441static unsigned int calc_reserved(struct gfs2_sbd *sdp)
442{
443 unsigned int reserved = 0;
Steven Whitehouse022ef4f2014-02-21 21:55:33 +0000444 unsigned int mbuf;
445 unsigned int dbuf;
446 struct gfs2_trans *tr = sdp->sd_log_tr;
Robert Peterson2332c442007-06-18 14:50:20 -0500447
Steven Whitehouse022ef4f2014-02-21 21:55:33 +0000448 if (tr) {
449 mbuf = tr->tr_num_buf_new - tr->tr_num_buf_rm;
450 dbuf = tr->tr_num_databuf_new - tr->tr_num_databuf_rm;
451 reserved = mbuf + dbuf;
452 /* Account for header blocks */
453 reserved += DIV_ROUND_UP(mbuf, buf_limit(sdp));
454 reserved += DIV_ROUND_UP(dbuf, databuf_limit(sdp));
455 }
Robert Peterson2332c442007-06-18 14:50:20 -0500456
Benjamin Marzinski2e95e3f2010-03-10 18:10:19 -0600457 if (sdp->sd_log_commited_revoke > 0)
Steven Whitehouse022ef4f2014-02-21 21:55:33 +0000458 reserved += gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke,
Robert Peterson2332c442007-06-18 14:50:20 -0500459 sizeof(u64));
Robert Peterson2332c442007-06-18 14:50:20 -0500460 /* One for the overall header */
461 if (reserved)
462 reserved++;
463 return reserved;
464}
465
David Teiglandb3b94fa2006-01-16 16:50:04 +0000466static unsigned int current_tail(struct gfs2_sbd *sdp)
467{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500468 struct gfs2_trans *tr;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000469 unsigned int tail;
470
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000471 spin_lock(&sdp->sd_ail_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000472
Steven Whitehousefaa31ce2006-09-13 11:13:27 -0400473 if (list_empty(&sdp->sd_ail1_list)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000474 tail = sdp->sd_log_head;
Steven Whitehousefaa31ce2006-09-13 11:13:27 -0400475 } else {
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500476 tr = list_entry(sdp->sd_ail1_list.prev, struct gfs2_trans,
477 tr_list);
478 tail = tr->tr_first;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000479 }
480
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000481 spin_unlock(&sdp->sd_ail_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000482
483 return tail;
484}
485
Robert Peterson2332c442007-06-18 14:50:20 -0500486static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000487{
488 unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail);
489
490 ail2_empty(sdp, new_tail);
491
Steven Whitehousefd041f02007-11-08 14:55:03 +0000492 atomic_add(dist, &sdp->sd_log_blks_free);
Steven Whitehouse63997772009-06-12 08:49:20 +0100493 trace_gfs2_log_blocks(sdp, dist);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500494 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
495 sdp->sd_jdesc->jd_blocks);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000496
497 sdp->sd_log_tail = new_tail;
498}
499
David Teiglandb3b94fa2006-01-16 16:50:04 +0000500
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000501static void log_flush_wait(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000502{
Steven Whitehouse16615be2007-09-17 10:59:52 +0100503 DEFINE_WAIT(wait);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000504
Steven Whitehouse16615be2007-09-17 10:59:52 +0100505 if (atomic_read(&sdp->sd_log_in_flight)) {
506 do {
507 prepare_to_wait(&sdp->sd_log_flush_wait, &wait,
508 TASK_UNINTERRUPTIBLE);
509 if (atomic_read(&sdp->sd_log_in_flight))
510 io_schedule();
511 } while(atomic_read(&sdp->sd_log_in_flight));
512 finish_wait(&sdp->sd_log_flush_wait, &wait);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000513 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000514}
515
Steven Whitehouse45138992013-01-28 09:30:07 +0000516static int ip_cmp(void *priv, struct list_head *a, struct list_head *b)
Bob Peterson4a36d082012-02-14 14:49:57 -0500517{
Steven Whitehouse45138992013-01-28 09:30:07 +0000518 struct gfs2_inode *ipa, *ipb;
Bob Peterson4a36d082012-02-14 14:49:57 -0500519
Steven Whitehouse45138992013-01-28 09:30:07 +0000520 ipa = list_entry(a, struct gfs2_inode, i_ordered);
521 ipb = list_entry(b, struct gfs2_inode, i_ordered);
Bob Peterson4a36d082012-02-14 14:49:57 -0500522
Steven Whitehouse45138992013-01-28 09:30:07 +0000523 if (ipa->i_no_addr < ipb->i_no_addr)
Bob Peterson4a36d082012-02-14 14:49:57 -0500524 return -1;
Steven Whitehouse45138992013-01-28 09:30:07 +0000525 if (ipa->i_no_addr > ipb->i_no_addr)
Bob Peterson4a36d082012-02-14 14:49:57 -0500526 return 1;
527 return 0;
528}
529
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100530static void gfs2_ordered_write(struct gfs2_sbd *sdp)
531{
Steven Whitehouse45138992013-01-28 09:30:07 +0000532 struct gfs2_inode *ip;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100533 LIST_HEAD(written);
534
Steven Whitehouse45138992013-01-28 09:30:07 +0000535 spin_lock(&sdp->sd_ordered_lock);
536 list_sort(NULL, &sdp->sd_log_le_ordered, &ip_cmp);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100537 while (!list_empty(&sdp->sd_log_le_ordered)) {
Steven Whitehouse45138992013-01-28 09:30:07 +0000538 ip = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_inode, i_ordered);
539 list_move(&ip->i_ordered, &written);
540 if (ip->i_inode.i_mapping->nrpages == 0)
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100541 continue;
Steven Whitehouse45138992013-01-28 09:30:07 +0000542 spin_unlock(&sdp->sd_ordered_lock);
543 filemap_fdatawrite(ip->i_inode.i_mapping);
544 spin_lock(&sdp->sd_ordered_lock);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100545 }
546 list_splice(&written, &sdp->sd_log_le_ordered);
Steven Whitehouse45138992013-01-28 09:30:07 +0000547 spin_unlock(&sdp->sd_ordered_lock);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100548}
549
550static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
551{
Steven Whitehouse45138992013-01-28 09:30:07 +0000552 struct gfs2_inode *ip;
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100553
Steven Whitehouse45138992013-01-28 09:30:07 +0000554 spin_lock(&sdp->sd_ordered_lock);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100555 while (!list_empty(&sdp->sd_log_le_ordered)) {
Steven Whitehouse45138992013-01-28 09:30:07 +0000556 ip = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_inode, i_ordered);
557 list_del(&ip->i_ordered);
558 WARN_ON(!test_and_clear_bit(GIF_ORDERED, &ip->i_flags));
559 if (ip->i_inode.i_mapping->nrpages == 0)
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100560 continue;
Steven Whitehouse45138992013-01-28 09:30:07 +0000561 spin_unlock(&sdp->sd_ordered_lock);
562 filemap_fdatawait(ip->i_inode.i_mapping);
563 spin_lock(&sdp->sd_ordered_lock);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100564 }
Steven Whitehouse45138992013-01-28 09:30:07 +0000565 spin_unlock(&sdp->sd_ordered_lock);
566}
567
568void gfs2_ordered_del_inode(struct gfs2_inode *ip)
569{
570 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
571
572 spin_lock(&sdp->sd_ordered_lock);
573 if (test_and_clear_bit(GIF_ORDERED, &ip->i_flags))
574 list_del(&ip->i_ordered);
575 spin_unlock(&sdp->sd_ordered_lock);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100576}
577
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500578void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
579{
580 struct buffer_head *bh = bd->bd_bh;
581 struct gfs2_glock *gl = bd->bd_gl;
582
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500583 bh->b_private = NULL;
584 bd->bd_blkno = bh->b_blocknr;
Bob Peterson9290a9a2013-12-10 12:06:35 -0500585 gfs2_remove_from_ail(bd); /* drops ref on bh */
586 bd->bd_bh = NULL;
Benjamin Marzinski5d054962013-06-14 11:38:29 -0500587 bd->bd_ops = &gfs2_revoke_lops;
588 sdp->sd_log_num_revoke++;
589 atomic_inc(&gl->gl_revokes);
590 set_bit(GLF_LFLUSH, &gl->gl_flags);
591 list_add(&bd->bd_list, &sdp->sd_log_le_revoke);
592}
593
594void gfs2_write_revokes(struct gfs2_sbd *sdp)
595{
596 struct gfs2_trans *tr;
597 struct gfs2_bufdata *bd, *tmp;
598 int have_revokes = 0;
599 int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
600
601 gfs2_ail1_empty(sdp);
602 spin_lock(&sdp->sd_ail_lock);
603 list_for_each_entry(tr, &sdp->sd_ail1_list, tr_list) {
604 list_for_each_entry(bd, &tr->tr_ail2_list, bd_ail_st_list) {
605 if (list_empty(&bd->bd_list)) {
606 have_revokes = 1;
607 goto done;
608 }
609 }
610 }
611done:
612 spin_unlock(&sdp->sd_ail_lock);
613 if (have_revokes == 0)
614 return;
615 while (sdp->sd_log_num_revoke > max_revokes)
616 max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64);
617 max_revokes -= sdp->sd_log_num_revoke;
618 if (!sdp->sd_log_num_revoke) {
619 atomic_dec(&sdp->sd_log_blks_free);
620 /* If no blocks have been reserved, we need to also
621 * reserve a block for the header */
622 if (!sdp->sd_log_blks_reserved)
623 atomic_dec(&sdp->sd_log_blks_free);
624 }
625 gfs2_log_lock(sdp);
626 spin_lock(&sdp->sd_ail_lock);
627 list_for_each_entry(tr, &sdp->sd_ail1_list, tr_list) {
628 list_for_each_entry_safe(bd, tmp, &tr->tr_ail2_list, bd_ail_st_list) {
629 if (max_revokes == 0)
630 goto out_of_blocks;
631 if (!list_empty(&bd->bd_list))
632 continue;
633 gfs2_add_revoke(sdp, bd);
634 max_revokes--;
635 }
636 }
637out_of_blocks:
638 spin_unlock(&sdp->sd_ail_lock);
639 gfs2_log_unlock(sdp);
640
641 if (!sdp->sd_log_num_revoke) {
642 atomic_inc(&sdp->sd_log_blks_free);
643 if (!sdp->sd_log_blks_reserved)
644 atomic_inc(&sdp->sd_log_blks_free);
645 }
646}
647
David Teiglandb3b94fa2006-01-16 16:50:04 +0000648/**
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000649 * log_write_header - Get and initialize a journal header buffer
650 * @sdp: The GFS2 superblock
651 *
652 * Returns: the initialized log buffer descriptor
653 */
654
Steven Whitehousefdb76a42012-04-02 15:34:36 +0100655static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000656{
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000657 struct gfs2_log_header *lh;
658 unsigned int tail;
659 u32 hash;
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100660 int rw = WRITE_FLUSH_FUA | REQ_META;
661 struct page *page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600662 enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100663 lh = page_address(page);
664 clear_page(lh);
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000665
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600666 gfs2_assert_withdraw(sdp, (state != SFS_FROZEN));
667
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000668 tail = current_tail(sdp);
669
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000670 lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
671 lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
672 lh->lh_header.__pad0 = cpu_to_be64(0);
673 lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
674 lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
675 lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++);
676 lh->lh_flags = cpu_to_be32(flags);
677 lh->lh_tail = cpu_to_be32(tail);
678 lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100679 hash = gfs2_disk_hash(page_address(page), sizeof(struct gfs2_log_header));
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000680 lh->lh_hash = cpu_to_be32(hash);
681
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000682 if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) {
683 gfs2_ordered_wait(sdp);
684 log_flush_wait(sdp);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100685 rw = WRITE_SYNC | REQ_META | REQ_PRIO;
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000686 }
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000687
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100688 sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
689 gfs2_log_write_page(sdp, page);
690 gfs2_log_flush_bio(sdp, rw);
691 log_flush_wait(sdp);
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000692
693 if (sdp->sd_log_tail != tail)
694 log_pull_tail(sdp, tail);
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000695}
696
697/**
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400698 * gfs2_log_flush - flush incore transaction(s)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000699 * @sdp: the filesystem
700 * @gl: The glock structure to flush. If NULL, flush the whole incore log
701 *
702 */
703
Benjamin Marzinski24972552014-05-01 22:26:55 -0500704void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
705 enum gfs2_flush_type type)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000706{
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500707 struct gfs2_trans *tr;
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600708 enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000709
Steven Whitehouse484adff2006-03-29 09:12:12 -0500710 down_write(&sdp->sd_log_flush_lock);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000711
Steven Whitehouse2bcd6102007-11-08 14:25:12 +0000712 /* Log might have been flushed while we waited for the flush lock */
713 if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) {
714 up_write(&sdp->sd_log_flush_lock);
715 return;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000716 }
Steven Whitehouse63997772009-06-12 08:49:20 +0100717 trace_gfs2_log_flush(sdp, 1);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000718
Steven Whitehouseb1ab1e42014-02-25 11:52:20 +0000719 sdp->sd_log_flush_head = sdp->sd_log_head;
720 sdp->sd_log_flush_wrapped = 0;
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500721 tr = sdp->sd_log_tr;
722 if (tr) {
723 sdp->sd_log_tr = NULL;
724 INIT_LIST_HEAD(&tr->tr_ail1_list);
725 INIT_LIST_HEAD(&tr->tr_ail2_list);
Steven Whitehouseb1ab1e42014-02-25 11:52:20 +0000726 tr->tr_first = sdp->sd_log_flush_head;
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600727 if (unlikely (state == SFS_FROZEN))
728 gfs2_assert_withdraw(sdp, !tr->tr_num_buf_new && !tr->tr_num_databuf_new);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500729 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000730
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600731 if (unlikely(state == SFS_FROZEN))
732 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000733 gfs2_assert_withdraw(sdp,
734 sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke);
735
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100736 gfs2_ordered_write(sdp);
Steven Whitehoused69a3c62014-02-21 15:22:35 +0000737 lops_before_commit(sdp, tr);
Steven Whitehousee8c92ed2012-04-16 09:28:31 +0100738 gfs2_log_flush_bio(sdp, WRITE);
Steven Whitehoused7b616e2007-09-02 10:48:13 +0100739
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000740 if (sdp->sd_log_head != sdp->sd_log_flush_head) {
Bob Peterson428fd952014-03-12 10:34:16 -0400741 log_flush_wait(sdp);
Steven Whitehousefdb76a42012-04-02 15:34:36 +0100742 log_write_header(sdp, 0);
Steven Whitehouse34cc1782012-03-09 10:45:56 +0000743 } else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){
Steven Whitehousefd041f02007-11-08 14:55:03 +0000744 atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
Steven Whitehouse63997772009-06-12 08:49:20 +0100745 trace_gfs2_log_blocks(sdp, -1);
Steven Whitehousefdb76a42012-04-02 15:34:36 +0100746 log_write_header(sdp, 0);
Robert Peterson2332c442007-06-18 14:50:20 -0500747 }
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500748 lops_after_commit(sdp, tr);
Steven Whitehousefe1a6982006-10-11 13:34:59 -0400749
750 gfs2_log_lock(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000751 sdp->sd_log_head = sdp->sd_log_flush_head;
Steven Whitehousefaa31ce2006-09-13 11:13:27 -0400752 sdp->sd_log_blks_reserved = 0;
Steven Whitehousefaa31ce2006-09-13 11:13:27 -0400753 sdp->sd_log_commited_revoke = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000754
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000755 spin_lock(&sdp->sd_ail_lock);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500756 if (tr && !list_empty(&tr->tr_ail1_list)) {
757 list_add(&tr->tr_list, &sdp->sd_ail1_list);
758 tr = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000759 }
Dave Chinnerd6a079e2011-03-11 11:52:25 +0000760 spin_unlock(&sdp->sd_ail_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000761 gfs2_log_unlock(sdp);
Benjamin Marzinski24972552014-05-01 22:26:55 -0500762
Benjamin Marzinski24972552014-05-01 22:26:55 -0500763 if (type != NORMAL_FLUSH) {
764 if (!sdp->sd_log_idle) {
765 for (;;) {
766 gfs2_ail1_start(sdp);
767 gfs2_ail1_wait(sdp);
768 if (gfs2_ail1_empty(sdp))
769 break;
770 }
771 atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
772 trace_gfs2_log_blocks(sdp, -1);
773 sdp->sd_log_flush_wrapped = 0;
774 log_write_header(sdp, 0);
775 sdp->sd_log_head = sdp->sd_log_flush_head;
776 }
777 if (type == SHUTDOWN_FLUSH || type == FREEZE_FLUSH)
778 gfs2_log_shutdown(sdp);
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600779 if (type == FREEZE_FLUSH)
780 atomic_set(&sdp->sd_freeze_state, SFS_FROZEN);
Benjamin Marzinski24972552014-05-01 22:26:55 -0500781 }
782
Steven Whitehouse63997772009-06-12 08:49:20 +0100783 trace_gfs2_log_flush(sdp, 0);
Steven Whitehouse484adff2006-03-29 09:12:12 -0500784 up_write(&sdp->sd_log_flush_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000785
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500786 kfree(tr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000787}
788
Steven Whitehoused69a3c62014-02-21 15:22:35 +0000789/**
790 * gfs2_merge_trans - Merge a new transaction into a cached transaction
791 * @old: Original transaction to be expanded
792 * @new: New transaction to be merged
793 */
794
795static void gfs2_merge_trans(struct gfs2_trans *old, struct gfs2_trans *new)
796{
797 WARN_ON_ONCE(old->tr_attached != 1);
798
799 old->tr_num_buf_new += new->tr_num_buf_new;
800 old->tr_num_databuf_new += new->tr_num_databuf_new;
801 old->tr_num_buf_rm += new->tr_num_buf_rm;
802 old->tr_num_databuf_rm += new->tr_num_databuf_rm;
803 old->tr_num_revoke += new->tr_num_revoke;
804 old->tr_num_revoke_rm += new->tr_num_revoke_rm;
805
806 list_splice_tail_init(&new->tr_databuf, &old->tr_databuf);
807 list_splice_tail_init(&new->tr_buf, &old->tr_buf);
808}
809
David Teiglandb3b94fa2006-01-16 16:50:04 +0000810static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
811{
Robert Peterson2332c442007-06-18 14:50:20 -0500812 unsigned int reserved;
Steven Whitehouseac39aad2008-01-10 14:49:43 +0000813 unsigned int unused;
Steven Whitehouse022ef4f2014-02-21 21:55:33 +0000814 unsigned int maxres;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000815
816 gfs2_log_lock(sdp);
817
Steven Whitehoused69a3c62014-02-21 15:22:35 +0000818 if (sdp->sd_log_tr) {
819 gfs2_merge_trans(sdp->sd_log_tr, tr);
820 } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) {
Benjamin Marzinski24972552014-05-01 22:26:55 -0500821 gfs2_assert_withdraw(sdp, tr->tr_alloced);
Benjamin Marzinski16ca9412013-04-05 20:31:46 -0500822 sdp->sd_log_tr = tr;
823 tr->tr_attached = 1;
824 }
Steven Whitehouse022ef4f2014-02-21 21:55:33 +0000825
826 sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;
827 reserved = calc_reserved(sdp);
828 maxres = sdp->sd_log_blks_reserved + tr->tr_reserved;
829 gfs2_assert_withdraw(sdp, maxres >= reserved);
830 unused = maxres - reserved;
831 atomic_add(unused, &sdp->sd_log_blks_free);
832 trace_gfs2_log_blocks(sdp, unused);
833 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
834 sdp->sd_jdesc->jd_blocks);
835 sdp->sd_log_blks_reserved = reserved;
836
David Teiglandb3b94fa2006-01-16 16:50:04 +0000837 gfs2_log_unlock(sdp);
838}
839
840/**
841 * gfs2_log_commit - Commit a transaction to the log
842 * @sdp: the filesystem
843 * @tr: the transaction
844 *
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500845 * We wake up gfs2_logd if the number of pinned blocks exceed thresh1
846 * or the total number of used blocks (pinned blocks plus AIL blocks)
847 * is greater than thresh2.
848 *
849 * At mount time thresh1 is 1/3rd of journal size, thresh2 is 2/3rd of
850 * journal size.
851 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000852 * Returns: errno
853 */
854
855void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
856{
857 log_refund(sdp, tr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000858
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500859 if (atomic_read(&sdp->sd_log_pinned) > atomic_read(&sdp->sd_log_thresh1) ||
860 ((sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free)) >
861 atomic_read(&sdp->sd_log_thresh2)))
862 wake_up(&sdp->sd_logd_waitq);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000863}
864
865/**
866 * gfs2_log_shutdown - write a shutdown header into a journal
867 * @sdp: the filesystem
868 *
869 */
870
871void gfs2_log_shutdown(struct gfs2_sbd *sdp)
872{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000873 gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000874 gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000875 gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
876
877 sdp->sd_log_flush_head = sdp->sd_log_head;
878 sdp->sd_log_flush_wrapped = 0;
879
Steven Whitehousefdb76a42012-04-02 15:34:36 +0100880 log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000881
Steven Whitehousea74604b2006-04-21 15:10:46 -0400882 gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
883 gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000884
885 sdp->sd_log_head = sdp->sd_log_flush_head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000886 sdp->sd_log_tail = sdp->sd_log_head;
Steven Whitehousea25311c2006-11-23 11:06:35 -0500887}
888
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500889static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
890{
Benjamin Marzinski2e60d762014-11-13 20:42:04 -0600891 return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1));
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500892}
893
894static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
895{
896 unsigned int used_blocks = sdp->sd_jdesc->jd_blocks - atomic_read(&sdp->sd_log_blks_free);
897 return used_blocks >= atomic_read(&sdp->sd_log_thresh2);
898}
Steven Whitehouseec69b182007-11-09 10:01:41 +0000899
900/**
901 * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
902 * @sdp: Pointer to GFS2 superblock
903 *
904 * Also, periodically check to make sure that we're using the most recent
905 * journal index.
906 */
907
908int gfs2_logd(void *data)
909{
910 struct gfs2_sbd *sdp = data;
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500911 unsigned long t = 1;
912 DEFINE_WAIT(wait);
Steven Whitehouseec69b182007-11-09 10:01:41 +0000913
914 while (!kthread_should_stop()) {
Steven Whitehouseec69b182007-11-09 10:01:41 +0000915
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500916 if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100917 gfs2_ail1_empty(sdp);
Benjamin Marzinski24972552014-05-01 22:26:55 -0500918 gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
Steven Whitehouseec69b182007-11-09 10:01:41 +0000919 }
920
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500921 if (gfs2_ail_flush_reqd(sdp)) {
922 gfs2_ail1_start(sdp);
Steven Whitehouse26b06a62011-05-21 19:21:07 +0100923 gfs2_ail1_wait(sdp);
Steven Whitehouse4667a0e2011-04-18 14:18:09 +0100924 gfs2_ail1_empty(sdp);
Benjamin Marzinski24972552014-05-01 22:26:55 -0500925 gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500926 }
927
Steven Whitehouse26b06a62011-05-21 19:21:07 +0100928 if (!gfs2_ail_flush_reqd(sdp))
929 wake_up(&sdp->sd_log_waitq);
930
Steven Whitehouseec69b182007-11-09 10:01:41 +0000931 t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
Tejun Heoa0acae02011-11-21 12:32:22 -0800932
933 try_to_freeze();
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500934
935 do {
936 prepare_to_wait(&sdp->sd_logd_waitq, &wait,
Steven Whitehouse5f487492010-09-09 14:45:00 +0100937 TASK_INTERRUPTIBLE);
Benjamin Marzinski5e687ea2010-05-04 14:29:16 -0500938 if (!gfs2_ail_flush_reqd(sdp) &&
939 !gfs2_jrnl_flush_reqd(sdp) &&
940 !kthread_should_stop())
941 t = schedule_timeout(t);
942 } while(t && !gfs2_ail_flush_reqd(sdp) &&
943 !gfs2_jrnl_flush_reqd(sdp) &&
944 !kthread_should_stop());
945 finish_wait(&sdp->sd_logd_waitq, &wait);
Steven Whitehouseec69b182007-11-09 10:01:41 +0000946 }
947
948 return 0;
949}
950