log.c 23.1 KB
Newer Older
David Teigland's avatar
David Teigland committed
1
2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
Bob Peterson's avatar
Bob Peterson committed
3
 * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
David Teigland's avatar
David Teigland committed
4
5
6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
David Teigland's avatar
David Teigland committed
8
9
10
11
12
13
14
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
15
#include <linux/gfs2_ondisk.h>
16
#include <linux/crc32.h>
17
#include <linux/delay.h>
18
19
#include <linux/kthread.h>
#include <linux/freezer.h>
20
#include <linux/bio.h>
David Teigland's avatar
David Teigland committed
21
22

#include "gfs2.h"
23
#include "incore.h"
David Teigland's avatar
David Teigland committed
24
25
26
27
28
#include "bmap.h"
#include "glock.h"
#include "log.h"
#include "lops.h"
#include "meta_io.h"
29
#include "util.h"
30
#include "dir.h"
Steven Whitehouse's avatar
Steven Whitehouse committed
31
#include "trace_gfs2.h"
David Teigland's avatar
David Teigland committed
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#define PULL 1

/**
 * gfs2_struct2blk - compute stuff
 * @sdp: the filesystem
 * @nstruct: the number of structures
 * @ssize: the size of the structures
 *
 * Compute the number of log descriptor blocks needed to hold a certain number
 * of structures of a certain size.
 *
 * Returns: the number of blocks needed (minimum is always 1)
 */

unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
			     unsigned int ssize)
{
	unsigned int blks;
	unsigned int first, second;

	blks = 1;
Steven Whitehouse's avatar
Steven Whitehouse committed
54
	first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize;
David Teigland's avatar
David Teigland committed
55
56

	if (nstruct > first) {
57
58
		second = (sdp->sd_sb.sb_bsize -
			  sizeof(struct gfs2_meta_header)) / ssize;
59
		blks += DIV_ROUND_UP(nstruct - first, second);
David Teigland's avatar
David Teigland committed
60
61
62
63
64
	}

	return blks;
}

65
66
67
68
69
70
71
72
73
/**
 * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters
 * @mapping: The associated mapping (maybe NULL)
 * @bd: The gfs2_bufdata to remove
 *
 * The log lock _must_ be held when calling this function
 *
 */

74
void gfs2_remove_from_ail(struct gfs2_bufdata *bd)
75
76
{
	bd->bd_ail = NULL;
77
78
	list_del_init(&bd->bd_ail_st_list);
	list_del_init(&bd->bd_ail_gl_list);
79
80
81
82
	atomic_dec(&bd->bd_gl->gl_ail_count);
	brelse(bd->bd_bh);
}

83
84
85
86
87
88
89
90
/**
 * gfs2_ail1_start_one - Start I/O on a part of the AIL
 * @sdp: the filesystem
 * @tr: the part of the AIL
 *
 */

static void gfs2_ail1_start_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
91
92
__releases(&sdp->sd_log_lock)
__acquires(&sdp->sd_log_lock)
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
{
	struct gfs2_bufdata *bd, *s;
	struct buffer_head *bh;
	int retry;

	do {
		retry = 0;

		list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
						 bd_ail_st_list) {
			bh = bd->bd_bh;

			gfs2_assert(sdp, bd->bd_ail == ai);

			if (!buffer_busy(bh)) {
108
				if (!buffer_uptodate(bh))
109
110
111
112
113
114
115
116
117
118
					gfs2_io_error_bh(sdp, bh);
				list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
				continue;
			}

			if (!buffer_dirty(bh))
				continue;

			list_move(&bd->bd_ail_st_list, &ai->ai_ail1_list);

119
			get_bh(bh);
120
			gfs2_log_unlock(sdp);
121
122
123
			lock_buffer(bh);
			if (test_clear_buffer_dirty(bh)) {
				bh->b_end_io = end_buffer_write_sync;
Steven Whitehouse's avatar
Steven Whitehouse committed
124
				submit_bh(WRITE_SYNC_PLUG, bh);
125
126
127
128
			} else {
				unlock_buffer(bh);
				brelse(bh);
			}
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
			gfs2_log_lock(sdp);

			retry = 1;
			break;
		}
	} while (retry);
}

/**
 * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
 * @sdp: the filesystem
 * @ai: the AIL entry
 *
 */

static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai, int flags)
{
	struct gfs2_bufdata *bd, *s;
	struct buffer_head *bh;

	list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
					 bd_ail_st_list) {
		bh = bd->bd_bh;

		gfs2_assert(sdp, bd->bd_ail == ai);

		if (buffer_busy(bh)) {
			if (flags & DIO_ALL)
				continue;
			else
				break;
		}

		if (!buffer_uptodate(bh))
			gfs2_io_error_bh(sdp, bh);

		list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
	}

	return list_empty(&ai->ai_ail1_list);
}

171
static void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags)
David Teigland's avatar
David Teigland committed
172
{
173
	struct list_head *head;
174
	u64 sync_gen;
175
176
177
	struct list_head *first;
	struct gfs2_ail *first_ai, *ai, *tmp;
	int done = 0;
David Teigland's avatar
David Teigland committed
178
179

	gfs2_log_lock(sdp);
180
	head = &sdp->sd_ail1_list;
David Teigland's avatar
David Teigland committed
181
182
183
184
185
186
187
188
189
	if (list_empty(head)) {
		gfs2_log_unlock(sdp);
		return;
	}
	sync_gen = sdp->sd_ail_sync_gen++;

	first = head->prev;
	first_ai = list_entry(first, struct gfs2_ail, ai_list);
	first_ai->ai_sync_gen = sync_gen;
190
	gfs2_ail1_start_one(sdp, first_ai); /* This may drop log lock */
David Teigland's avatar
David Teigland committed
191
192
193
194

	if (flags & DIO_ALL)
		first = NULL;

195
	while(!done) {
196
197
		if (first && (head->prev != first ||
			      gfs2_ail1_empty_one(sdp, first_ai, 0)))
David Teigland's avatar
David Teigland committed
198
199
			break;

200
201
		done = 1;
		list_for_each_entry_safe_reverse(ai, tmp, head, ai_list) {
David Teigland's avatar
David Teigland committed
202
203
204
			if (ai->ai_sync_gen >= sync_gen)
				continue;
			ai->ai_sync_gen = sync_gen;
205
206
			gfs2_ail1_start_one(sdp, ai); /* This may drop log lock */
			done = 0;
David Teigland's avatar
David Teigland committed
207
208
209
210
211
212
213
			break;
		}
	}

	gfs2_log_unlock(sdp);
}

214
static int gfs2_ail1_empty(struct gfs2_sbd *sdp, int flags)
David Teigland's avatar
David Teigland committed
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
{
	struct gfs2_ail *ai, *s;
	int ret;

	gfs2_log_lock(sdp);

	list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) {
		if (gfs2_ail1_empty_one(sdp, ai, flags))
			list_move(&ai->ai_list, &sdp->sd_ail2_list);
		else if (!(flags & DIO_ALL))
			break;
	}

	ret = list_empty(&sdp->sd_ail1_list);

	gfs2_log_unlock(sdp);

	return ret;
}

235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

/**
 * gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced
 * @sdp: the filesystem
 * @ai: the AIL entry
 *
 */

static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
{
	struct list_head *head = &ai->ai_ail2_list;
	struct gfs2_bufdata *bd;

	while (!list_empty(head)) {
		bd = list_entry(head->prev, struct gfs2_bufdata,
				bd_ail_st_list);
		gfs2_assert(sdp, bd->bd_ail == ai);
252
		gfs2_remove_from_ail(bd);
253
254
255
	}
}

David Teigland's avatar
David Teigland committed
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
{
	struct gfs2_ail *ai, *safe;
	unsigned int old_tail = sdp->sd_log_tail;
	int wrap = (new_tail < old_tail);
	int a, b, rm;

	gfs2_log_lock(sdp);

	list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) {
		a = (old_tail <= ai->ai_first);
		b = (ai->ai_first < new_tail);
		rm = (wrap) ? (a || b) : (a && b);
		if (!rm)
			continue;

		gfs2_ail2_empty_one(sdp, ai);
		list_del(&ai->ai_list);
		gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list));
		gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list));
		kfree(ai);
	}

	gfs2_log_unlock(sdp);
}

/**
 * gfs2_log_reserve - Make a log reservation
 * @sdp: The GFS2 superblock
 * @blks: The number of blocks to reserve
 *
287
 * Note that we never give out the last few blocks of the journal. Thats
288
 * due to the fact that there is a small number of header blocks
289
290
291
292
 * associated with each log flush. The exact number can't be known until
 * flush time, so we ensure that we have just enough free blocks at all
 * times to avoid running out during a log flush.
 *
David Teigland's avatar
David Teigland committed
293
294
295
296
297
298
 * Returns: errno
 */

int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
{
	unsigned int try = 0;
299
	unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);
David Teigland's avatar
David Teigland committed
300
301
302
303
304

	if (gfs2_assert_warn(sdp, blks) ||
	    gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
		return -EINVAL;

305
	mutex_lock(&sdp->sd_log_reserve_mutex);
306
	gfs2_log_lock(sdp);
307
	while(atomic_read(&sdp->sd_log_blks_free) <= (blks + reserved_blks)) {
David Teigland's avatar
David Teigland committed
308
309
		gfs2_log_unlock(sdp);
		gfs2_ail1_empty(sdp, 0);
310
		gfs2_log_flush(sdp, NULL);
David Teigland's avatar
David Teigland committed
311
312
313

		if (try++)
			gfs2_ail1_start(sdp, 0);
314
		gfs2_log_lock(sdp);
David Teigland's avatar
David Teigland committed
315
	}
316
	atomic_sub(blks, &sdp->sd_log_blks_free);
Steven Whitehouse's avatar
Steven Whitehouse committed
317
	trace_gfs2_log_blocks(sdp, -blks);
318
319
320
321
	gfs2_log_unlock(sdp);
	mutex_unlock(&sdp->sd_log_reserve_mutex);

	down_read(&sdp->sd_log_flush_lock);
David Teigland's avatar
David Teigland committed
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336

	return 0;
}

/**
 * gfs2_log_release - Release a given number of log blocks
 * @sdp: The GFS2 superblock
 * @blks: The number of blocks
 *
 */

void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
{

	gfs2_log_lock(sdp);
337
	atomic_add(blks, &sdp->sd_log_blks_free);
Steven Whitehouse's avatar
Steven Whitehouse committed
338
	trace_gfs2_log_blocks(sdp, blks);
David Teigland's avatar
David Teigland committed
339
	gfs2_assert_withdraw(sdp,
340
			     atomic_read(&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);
David Teigland's avatar
David Teigland committed
341
	gfs2_log_unlock(sdp);
342
	up_read(&sdp->sd_log_flush_lock);
David Teigland's avatar
David Teigland committed
343
344
}

345
static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
David Teigland's avatar
David Teigland committed
346
{
Bob Peterson's avatar
Bob Peterson committed
347
348
349
350
	struct gfs2_journal_extent *je;

	list_for_each_entry(je, &sdp->sd_jdesc->extent_list, extent_list) {
		if (lbn >= je->lblock && lbn < je->lblock + je->blocks)
351
			return je->dblock + lbn - je->lblock;
Bob Peterson's avatar
Bob Peterson committed
352
353
354
	}

	return -1;
David Teigland's avatar
David Teigland committed
355
356
357
358
359
360
361
362
363
364
365
366
367
368
}

/**
 * log_distance - Compute distance between two journal blocks
 * @sdp: The GFS2 superblock
 * @newer: The most recent journal block of the pair
 * @older: The older journal block of the pair
 *
 *   Compute the distance (in the journal direction) between two
 *   blocks in the journal
 *
 * Returns: the distance in blocks
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
369
static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
David Teigland's avatar
David Teigland committed
370
371
372
373
374
375
376
377
378
379
380
					unsigned int older)
{
	int dist;

	dist = newer - older;
	if (dist < 0)
		dist += sdp->sd_jdesc->jd_blocks;

	return dist;
}

381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
/**
 * calc_reserved - Calculate the number of blocks to reserve when
 *                 refunding a transaction's unused buffers.
 * @sdp: The GFS2 superblock
 *
 * This is complex.  We need to reserve room for all our currently used
 * metadata buffers (e.g. normal file I/O rewriting file time stamps) and 
 * all our journaled data buffers for journaled files (e.g. files in the 
 * meta_fs like rindex, or files for which chattr +j was done.)
 * If we don't reserve enough space, gfs2_log_refund and gfs2_log_flush
 * will count it as free space (sd_log_blks_free) and corruption will follow.
 *
 * We can have metadata bufs and jdata bufs in the same journal.  So each
 * type gets its own log header, for which we need to reserve a block.
 * In fact, each type has the potential for needing more than one header 
 * in cases where we have more buffers than will fit on a journal page.
 * Metadata journal entries take up half the space of journaled buffer entries.
 * Thus, metadata entries have buf_limit (502) and journaled buffers have
 * databuf_limit (251) before they cause a wrap around.
 *
 * Also, we need to reserve blocks for revoke journal entries and one for an
 * overall header for the lot.
 *
 * Returns: the number of blocks reserved
 */
static unsigned int calc_reserved(struct gfs2_sbd *sdp)
{
	unsigned int reserved = 0;
	unsigned int mbuf_limit, metabufhdrs_needed;
	unsigned int dbuf_limit, databufhdrs_needed;
	unsigned int revokes = 0;

	mbuf_limit = buf_limit(sdp);
	metabufhdrs_needed = (sdp->sd_log_commited_buf +
			      (mbuf_limit - 1)) / mbuf_limit;
	dbuf_limit = databuf_limit(sdp);
	databufhdrs_needed = (sdp->sd_log_commited_databuf +
			      (dbuf_limit - 1)) / dbuf_limit;

420
	if (sdp->sd_log_commited_revoke > 0)
421
422
423
424
425
426
427
428
429
430
431
432
		revokes = gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke,
					  sizeof(u64));

	reserved = sdp->sd_log_commited_buf + metabufhdrs_needed +
		sdp->sd_log_commited_databuf + databufhdrs_needed +
		revokes;
	/* One for the overall header */
	if (reserved)
		reserved++;
	return reserved;
}

David Teigland's avatar
David Teigland committed
433
434
435
436
437
438
439
static unsigned int current_tail(struct gfs2_sbd *sdp)
{
	struct gfs2_ail *ai;
	unsigned int tail;

	gfs2_log_lock(sdp);

Steven Whitehouse's avatar
Steven Whitehouse committed
440
	if (list_empty(&sdp->sd_ail1_list)) {
David Teigland's avatar
David Teigland committed
441
		tail = sdp->sd_log_head;
Steven Whitehouse's avatar
Steven Whitehouse committed
442
443
	} else {
		ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail, ai_list);
David Teigland's avatar
David Teigland committed
444
445
446
447
448
449
450
451
		tail = ai->ai_first;
	}

	gfs2_log_unlock(sdp);

	return tail;
}

452
void gfs2_log_incr_head(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
453
454
{
	if (sdp->sd_log_flush_head == sdp->sd_log_tail)
455
		BUG_ON(sdp->sd_log_flush_head != sdp->sd_log_head);
David Teigland's avatar
David Teigland committed
456
457
458
459
460
461
462

	if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) {
		sdp->sd_log_flush_head = 0;
		sdp->sd_log_flush_wrapped = 1;
	}
}

463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
/**
 * gfs2_log_write_endio - End of I/O for a log buffer
 * @bh: The buffer head
 * @uptodate: I/O Status
 *
 */

static void gfs2_log_write_endio(struct buffer_head *bh, int uptodate)
{
	struct gfs2_sbd *sdp = bh->b_private;
	bh->b_private = NULL;

	end_buffer_write_sync(bh, uptodate);
	if (atomic_dec_and_test(&sdp->sd_log_in_flight))
		wake_up(&sdp->sd_log_flush_wait);
}

David Teigland's avatar
David Teigland committed
480
481
482
483
484
485
486
487
488
/**
 * gfs2_log_get_buf - Get and initialize a buffer to use for log control data
 * @sdp: The GFS2 superblock
 *
 * Returns: the buffer_head
 */

struct buffer_head *gfs2_log_get_buf(struct gfs2_sbd *sdp)
{
489
	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
David Teigland's avatar
David Teigland committed
490
491
	struct buffer_head *bh;

492
	bh = sb_getblk(sdp->sd_vfs, blkno);
David Teigland's avatar
David Teigland committed
493
494
495
496
	lock_buffer(bh);
	memset(bh->b_data, 0, bh->b_size);
	set_buffer_uptodate(bh);
	clear_buffer_dirty(bh);
497
498
499
500
	gfs2_log_incr_head(sdp);
	atomic_inc(&sdp->sd_log_in_flight);
	bh->b_private = sdp;
	bh->b_end_io = gfs2_log_write_endio;
David Teigland's avatar
David Teigland committed
501
502
503
504

	return bh;
}

505
506
507
508
509
510
511
512
513
514
/**
 * gfs2_fake_write_endio - 
 * @bh: The buffer head
 * @uptodate: The I/O Status
 *
 */

static void gfs2_fake_write_endio(struct buffer_head *bh, int uptodate)
{
	struct buffer_head *real_bh = bh->b_private;
515
516
	struct gfs2_bufdata *bd = real_bh->b_private;
	struct gfs2_sbd *sdp = bd->bd_gl->gl_sbd;
517
518
519
520
521
522
523
524
525

	end_buffer_write_sync(bh, uptodate);
	free_buffer_head(bh);
	unlock_buffer(real_bh);
	brelse(real_bh);
	if (atomic_dec_and_test(&sdp->sd_log_in_flight))
		wake_up(&sdp->sd_log_flush_wait);
}

David Teigland's avatar
David Teigland committed
526
527
528
529
530
531
532
533
534
535
536
/**
 * gfs2_log_fake_buf - Build a fake buffer head to write metadata buffer to log
 * @sdp: the filesystem
 * @data: the data the buffer_head should point to
 *
 * Returns: the log buffer descriptor
 */

struct buffer_head *gfs2_log_fake_buf(struct gfs2_sbd *sdp,
				      struct buffer_head *real)
{
537
	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
David Teigland's avatar
David Teigland committed
538
539
	struct buffer_head *bh;

540
	bh = alloc_buffer_head(GFP_NOFS | __GFP_NOFAIL);
David Teigland's avatar
David Teigland committed
541
	atomic_set(&bh->b_count, 1);
542
	bh->b_state = (1 << BH_Mapped) | (1 << BH_Uptodate) | (1 << BH_Lock);
543
	set_bh_page(bh, real->b_page, bh_offset(real));
David Teigland's avatar
David Teigland committed
544
545
546
	bh->b_blocknr = blkno;
	bh->b_size = sdp->sd_sb.sb_bsize;
	bh->b_bdev = sdp->sd_vfs->s_bdev;
547
548
	bh->b_private = real;
	bh->b_end_io = gfs2_fake_write_endio;
David Teigland's avatar
David Teigland committed
549

550
551
	gfs2_log_incr_head(sdp);
	atomic_inc(&sdp->sd_log_in_flight);
David Teigland's avatar
David Teigland committed
552
553
554
555

	return bh;
}

556
static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail)
David Teigland's avatar
David Teigland committed
557
558
559
560
561
562
{
	unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail);

	ail2_empty(sdp, new_tail);

	gfs2_log_lock(sdp);
563
	atomic_add(dist, &sdp->sd_log_blks_free);
Steven Whitehouse's avatar
Steven Whitehouse committed
564
	trace_gfs2_log_blocks(sdp, dist);
565
	gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);
David Teigland's avatar
David Teigland committed
566
567
568
569
570
571
572
573
574
575
576
577
	gfs2_log_unlock(sdp);

	sdp->sd_log_tail = new_tail;
}

/**
 * log_write_header - Get and initialize a journal header buffer
 * @sdp: The GFS2 superblock
 *
 * Returns: the initialized log buffer descriptor
 */

578
static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull)
David Teigland's avatar
David Teigland committed
579
{
580
	u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
David Teigland's avatar
David Teigland committed
581
582
583
	struct buffer_head *bh;
	struct gfs2_log_header *lh;
	unsigned int tail;
584
	u32 hash;
David Teigland's avatar
David Teigland committed
585
586
587
588
589
590
591
592
593
594
595
596
597

	bh = sb_getblk(sdp->sd_vfs, blkno);
	lock_buffer(bh);
	memset(bh->b_data, 0, bh->b_size);
	set_buffer_uptodate(bh);
	clear_buffer_dirty(bh);

	gfs2_ail1_empty(sdp, 0);
	tail = current_tail(sdp);

	lh = (struct gfs2_log_header *)bh->b_data;
	memset(lh, 0, sizeof(struct gfs2_log_header));
	lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
598
	lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
599
	lh->lh_header.__pad0 = cpu_to_be64(0);
600
	lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
601
	lh->lh_header.mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
602
603
604
605
	lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++);
	lh->lh_flags = cpu_to_be32(flags);
	lh->lh_tail = cpu_to_be32(tail);
	lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head);
David Teigland's avatar
David Teigland committed
606
607
608
	hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header));
	lh->lh_hash = cpu_to_be32(hash);

609
610
611
612
	bh->b_end_io = end_buffer_write_sync;
	if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags))
		goto skip_barrier;
	get_bh(bh);
Steven Whitehouse's avatar
Steven Whitehouse committed
613
	submit_bh(WRITE_SYNC | (1 << BIO_RW_BARRIER) | (1 << BIO_RW_META), bh);
614
615
616
617
618
619
620
621
622
623
624
625
	wait_on_buffer(bh);
	if (buffer_eopnotsupp(bh)) {
		clear_buffer_eopnotsupp(bh);
		set_buffer_uptodate(bh);
		set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
		lock_buffer(bh);
skip_barrier:
		get_bh(bh);
		submit_bh(WRITE_SYNC | (1 << BIO_RW_META), bh);
		wait_on_buffer(bh);
	}
	if (!buffer_uptodate(bh))
David Teigland's avatar
David Teigland committed
626
627
628
629
		gfs2_io_error_bh(sdp, bh);
	brelse(bh);

	if (sdp->sd_log_tail != tail)
630
		log_pull_tail(sdp, tail);
David Teigland's avatar
David Teigland committed
631
632
633
634
	else
		gfs2_assert_withdraw(sdp, !pull);

	sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
635
	gfs2_log_incr_head(sdp);
David Teigland's avatar
David Teigland committed
636
637
638
639
}

static void log_flush_commit(struct gfs2_sbd *sdp)
{
640
641
642
643
644
645
646
647
648
649
	DEFINE_WAIT(wait);

	if (atomic_read(&sdp->sd_log_in_flight)) {
		do {
			prepare_to_wait(&sdp->sd_log_flush_wait, &wait,
					TASK_UNINTERRUPTIBLE);
			if (atomic_read(&sdp->sd_log_in_flight))
				io_schedule();
		} while(atomic_read(&sdp->sd_log_in_flight));
		finish_wait(&sdp->sd_log_flush_wait, &wait);
David Teigland's avatar
David Teigland committed
650
651
	}

652
	log_write_header(sdp, 0, 0);
David Teigland's avatar
David Teigland committed
653
654
}

655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
static void gfs2_ordered_write(struct gfs2_sbd *sdp)
{
	struct gfs2_bufdata *bd;
	struct buffer_head *bh;
	LIST_HEAD(written);

	gfs2_log_lock(sdp);
	while (!list_empty(&sdp->sd_log_le_ordered)) {
		bd = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_bufdata, bd_le.le_list);
		list_move(&bd->bd_le.le_list, &written);
		bh = bd->bd_bh;
		if (!buffer_dirty(bh))
			continue;
		get_bh(bh);
		gfs2_log_unlock(sdp);
		lock_buffer(bh);
671
		if (buffer_mapped(bh) && test_clear_buffer_dirty(bh)) {
672
			bh->b_end_io = end_buffer_write_sync;
Steven Whitehouse's avatar
Steven Whitehouse committed
673
			submit_bh(WRITE_SYNC_PLUG, bh);
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
		} else {
			unlock_buffer(bh);
			brelse(bh);
		}
		gfs2_log_lock(sdp);
	}
	list_splice(&written, &sdp->sd_log_le_ordered);
	gfs2_log_unlock(sdp);
}

static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
{
	struct gfs2_bufdata *bd;
	struct buffer_head *bh;

	gfs2_log_lock(sdp);
	while (!list_empty(&sdp->sd_log_le_ordered)) {
		bd = list_entry(sdp->sd_log_le_ordered.prev, struct gfs2_bufdata, bd_le.le_list);
		bh = bd->bd_bh;
		if (buffer_locked(bh)) {
			get_bh(bh);
			gfs2_log_unlock(sdp);
			wait_on_buffer(bh);
			brelse(bh);
			gfs2_log_lock(sdp);
			continue;
		}
		list_del_init(&bd->bd_le.le_list);
	}
	gfs2_log_unlock(sdp);
}

David Teigland's avatar
David Teigland committed
706
/**
707
 * gfs2_log_flush - flush incore transaction(s)
David Teigland's avatar
David Teigland committed
708
709
710
711
712
 * @sdp: the filesystem
 * @gl: The glock structure to flush.  If NULL, flush the whole incore log
 *
 */

713
void __gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)
David Teigland's avatar
David Teigland committed
714
715
716
{
	struct gfs2_ail *ai;

717
	down_write(&sdp->sd_log_flush_lock);
718

719
720
721
722
	/* Log might have been flushed while we waited for the flush lock */
	if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) {
		up_write(&sdp->sd_log_flush_lock);
		return;
723
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
724
	trace_gfs2_log_flush(sdp, 1);
725

726
727
728
	ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL);
	INIT_LIST_HEAD(&ai->ai_ail1_list);
	INIT_LIST_HEAD(&ai->ai_ail2_list);
David Teigland's avatar
David Teigland committed
729

730
731
732
733
734
735
736
737
738
739
	if (sdp->sd_log_num_buf != sdp->sd_log_commited_buf) {
		printk(KERN_INFO "GFS2: log buf %u %u\n", sdp->sd_log_num_buf,
		       sdp->sd_log_commited_buf);
		gfs2_assert_withdraw(sdp, 0);
	}
	if (sdp->sd_log_num_databuf != sdp->sd_log_commited_databuf) {
		printk(KERN_INFO "GFS2: log databuf %u %u\n",
		       sdp->sd_log_num_databuf, sdp->sd_log_commited_databuf);
		gfs2_assert_withdraw(sdp, 0);
	}
David Teigland's avatar
David Teigland committed
740
741
742
743
744
745
746
	gfs2_assert_withdraw(sdp,
			sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke);

	sdp->sd_log_flush_head = sdp->sd_log_head;
	sdp->sd_log_flush_wrapped = 0;
	ai->ai_first = sdp->sd_log_flush_head;

747
	gfs2_ordered_write(sdp);
David Teigland's avatar
David Teigland committed
748
	lops_before_commit(sdp);
749
750
	gfs2_ordered_wait(sdp);

751
	if (sdp->sd_log_head != sdp->sd_log_flush_head)
David Teigland's avatar
David Teigland committed
752
		log_flush_commit(sdp);
753
754
	else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){
		gfs2_log_lock(sdp);
755
		atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
Steven Whitehouse's avatar
Steven Whitehouse committed
756
		trace_gfs2_log_blocks(sdp, -1);
757
		gfs2_log_unlock(sdp);
David Teigland's avatar
David Teigland committed
758
		log_write_header(sdp, 0, PULL);
759
	}
David Teigland's avatar
David Teigland committed
760
	lops_after_commit(sdp, ai);
761

762
763
	gfs2_log_lock(sdp);
	sdp->sd_log_head = sdp->sd_log_flush_head;
Steven Whitehouse's avatar
Steven Whitehouse committed
764
765
	sdp->sd_log_blks_reserved = 0;
	sdp->sd_log_commited_buf = 0;
766
	sdp->sd_log_commited_databuf = 0;
Steven Whitehouse's avatar
Steven Whitehouse committed
767
	sdp->sd_log_commited_revoke = 0;
David Teigland's avatar
David Teigland committed
768
769
770
771
772
773

	if (!list_empty(&ai->ai_ail1_list)) {
		list_add(&ai->ai_list, &sdp->sd_ail1_list);
		ai = NULL;
	}
	gfs2_log_unlock(sdp);
Steven Whitehouse's avatar
Steven Whitehouse committed
774
	trace_gfs2_log_flush(sdp, 0);
775
	up_write(&sdp->sd_log_flush_lock);
David Teigland's avatar
David Teigland committed
776
777
778
779
780
781

	kfree(ai);
}

static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
{
782
	unsigned int reserved;
783
	unsigned int unused;
David Teigland's avatar
David Teigland committed
784
785
786
787

	gfs2_log_lock(sdp);

	sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm;
788
789
790
791
	sdp->sd_log_commited_databuf += tr->tr_num_databuf_new -
		tr->tr_num_databuf_rm;
	gfs2_assert_withdraw(sdp, (((int)sdp->sd_log_commited_buf) >= 0) ||
			     (((int)sdp->sd_log_commited_databuf) >= 0));
David Teigland's avatar
David Teigland committed
792
	sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;
793
	reserved = calc_reserved(sdp);
794
	gfs2_assert_withdraw(sdp, sdp->sd_log_blks_reserved + tr->tr_reserved >= reserved);
795
796
	unused = sdp->sd_log_blks_reserved - reserved + tr->tr_reserved;
	atomic_add(unused, &sdp->sd_log_blks_free);
Steven Whitehouse's avatar
Steven Whitehouse committed
797
	trace_gfs2_log_blocks(sdp, unused);
798
	gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
799
			     sdp->sd_jdesc->jd_blocks);
David Teigland's avatar
David Teigland committed
800
801
802
803
804
	sdp->sd_log_blks_reserved = reserved;

	gfs2_log_unlock(sdp);
}

805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
{
	struct list_head *head = &tr->tr_list_buf;
	struct gfs2_bufdata *bd;

	gfs2_log_lock(sdp);
	while (!list_empty(head)) {
		bd = list_entry(head->next, struct gfs2_bufdata, bd_list_tr);
		list_del_init(&bd->bd_list_tr);
		tr->tr_num_buf--;
	}
	gfs2_log_unlock(sdp);
	gfs2_assert_warn(sdp, !tr->tr_num_buf);
}

David Teigland's avatar
David Teigland committed
820
821
822
823
824
825
826
827
828
829
830
/**
 * gfs2_log_commit - Commit a transaction to the log
 * @sdp: the filesystem
 * @tr: the transaction
 *
 * Returns: errno
 */

void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
{
	log_refund(sdp, tr);
831
	buf_lo_incore_commit(sdp, tr);
David Teigland's avatar
David Teigland committed
832

833
	up_read(&sdp->sd_log_flush_lock);
David Teigland's avatar
David Teigland committed
834
835

	gfs2_log_lock(sdp);
836
837
838
	if (sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks))
		wake_up_process(sdp->sd_logd_process);
	gfs2_log_unlock(sdp);
David Teigland's avatar
David Teigland committed
839
840
841
842
843
844
845
846
847
848
}

/**
 * gfs2_log_shutdown - write a shutdown header into a journal
 * @sdp: the filesystem
 *
 */

void gfs2_log_shutdown(struct gfs2_sbd *sdp)
{
849
	down_write(&sdp->sd_log_flush_lock);
David Teigland's avatar
David Teigland committed
850
851
852
853
854
855
856
857
858
859
860

	gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg);
	gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf);
	gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));

	sdp->sd_log_flush_head = sdp->sd_log_head;
	sdp->sd_log_flush_wrapped = 0;

861
862
	log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT,
			 (sdp->sd_log_tail == current_tail(sdp)) ? 0 : PULL);
David Teigland's avatar
David Teigland committed
863

864
	gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks);
865
866
	gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
	gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
David Teigland's avatar
David Teigland committed
867
868
869
870

	sdp->sd_log_head = sdp->sd_log_flush_head;
	sdp->sd_log_tail = sdp->sd_log_head;

871
	up_write(&sdp->sd_log_flush_lock);
David Teigland's avatar
David Teigland committed
872
873
}

874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891

/**
 * gfs2_meta_syncfs - sync all the buffers in a filesystem
 * @sdp: the filesystem
 *
 */

void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
{
	gfs2_log_flush(sdp, NULL);
	for (;;) {
		gfs2_ail1_start(sdp, DIO_ALL);
		if (gfs2_ail1_empty(sdp, DIO_ALL))
			break;
		msleep(10);
	}
}

892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930

/**
 * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
 * @sdp: Pointer to GFS2 superblock
 *
 * Also, periodically check to make sure that we're using the most recent
 * journal index.
 */

int gfs2_logd(void *data)
{
	struct gfs2_sbd *sdp = data;
	unsigned long t;
	int need_flush;

	while (!kthread_should_stop()) {
		/* Advance the log tail */

		t = sdp->sd_log_flush_time +
		    gfs2_tune_get(sdp, gt_log_flush_secs) * HZ;

		gfs2_ail1_empty(sdp, DIO_ALL);
		gfs2_log_lock(sdp);
		need_flush = sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks);
		gfs2_log_unlock(sdp);
		if (need_flush || time_after_eq(jiffies, t)) {
			gfs2_log_flush(sdp, NULL);
			sdp->sd_log_flush_time = jiffies;
		}

		t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
		if (freezing(current))
			refrigerator();
		schedule_timeout_interruptible(t);
	}

	return 0;
}