[GFS2] Remove all_list from lock_dlm
[linux-2.6.git] / fs / gfs2 / log.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
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>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
17 #include <linux/lm_interface.h>
18 #include <linux/delay.h>
19 #include <linux/kthread.h>
20 #include <linux/freezer.h>
21
22 #include "gfs2.h"
23 #include "incore.h"
24 #include "bmap.h"
25 #include "glock.h"
26 #include "log.h"
27 #include "lops.h"
28 #include "meta_io.h"
29 #include "util.h"
30 #include "dir.h"
31
32 #define PULL 1
33
34 /**
35  * gfs2_struct2blk - compute stuff
36  * @sdp: the filesystem
37  * @nstruct: the number of structures
38  * @ssize: the size of the structures
39  *
40  * Compute the number of log descriptor blocks needed to hold a certain number
41  * of structures of a certain size.
42  *
43  * Returns: the number of blocks needed (minimum is always 1)
44  */
45
46 unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
47                              unsigned int ssize)
48 {
49         unsigned int blks;
50         unsigned int first, second;
51
52         blks = 1;
53         first = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / ssize;
54
55         if (nstruct > first) {
56                 second = (sdp->sd_sb.sb_bsize -
57                           sizeof(struct gfs2_meta_header)) / ssize;
58                 blks += DIV_ROUND_UP(nstruct - first, second);
59         }
60
61         return blks;
62 }
63
64 /**
65  * gfs2_remove_from_ail - Remove an entry from the ail lists, updating counters
66  * @mapping: The associated mapping (maybe NULL)
67  * @bd: The gfs2_bufdata to remove
68  *
69  * The log lock _must_ be held when calling this function
70  *
71  */
72
73 void gfs2_remove_from_ail(struct gfs2_bufdata *bd)
74 {
75         bd->bd_ail = NULL;
76         list_del_init(&bd->bd_ail_st_list);
77         list_del_init(&bd->bd_ail_gl_list);
78         atomic_dec(&bd->bd_gl->gl_ail_count);
79         brelse(bd->bd_bh);
80 }
81
82 /**
83  * gfs2_ail1_start_one - Start I/O on a part of the AIL
84  * @sdp: the filesystem
85  * @tr: the part of the AIL
86  *
87  */
88
89 static void gfs2_ail1_start_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
90 __releases(&sdp->sd_log_lock)
91 __acquires(&sdp->sd_log_lock)
92 {
93         struct gfs2_bufdata *bd, *s;
94         struct buffer_head *bh;
95         int retry;
96
97         do {
98                 retry = 0;
99
100                 list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
101                                                  bd_ail_st_list) {
102                         bh = bd->bd_bh;
103
104                         gfs2_assert(sdp, bd->bd_ail == ai);
105
106                         if (!buffer_busy(bh)) {
107                                 if (!buffer_uptodate(bh))
108                                         gfs2_io_error_bh(sdp, bh);
109                                 list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
110                                 continue;
111                         }
112
113                         if (!buffer_dirty(bh))
114                                 continue;
115
116                         list_move(&bd->bd_ail_st_list, &ai->ai_ail1_list);
117
118                         get_bh(bh);
119                         gfs2_log_unlock(sdp);
120                         lock_buffer(bh);
121                         if (test_clear_buffer_dirty(bh)) {
122                                 bh->b_end_io = end_buffer_write_sync;
123                                 submit_bh(WRITE, bh);
124                         } else {
125                                 unlock_buffer(bh);
126                                 brelse(bh);
127                         }
128                         gfs2_log_lock(sdp);
129
130                         retry = 1;
131                         break;
132                 }
133         } while (retry);
134 }
135
136 /**
137  * gfs2_ail1_empty_one - Check whether or not a trans in the AIL has been synced
138  * @sdp: the filesystem
139  * @ai: the AIL entry
140  *
141  */
142
143 static int gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai, int flags)
144 {
145         struct gfs2_bufdata *bd, *s;
146         struct buffer_head *bh;
147
148         list_for_each_entry_safe_reverse(bd, s, &ai->ai_ail1_list,
149                                          bd_ail_st_list) {
150                 bh = bd->bd_bh;
151
152                 gfs2_assert(sdp, bd->bd_ail == ai);
153
154                 if (buffer_busy(bh)) {
155                         if (flags & DIO_ALL)
156                                 continue;
157                         else
158                                 break;
159                 }
160
161                 if (!buffer_uptodate(bh))
162                         gfs2_io_error_bh(sdp, bh);
163
164                 list_move(&bd->bd_ail_st_list, &ai->ai_ail2_list);
165         }
166
167         return list_empty(&ai->ai_ail1_list);
168 }
169
170 static void gfs2_ail1_start(struct gfs2_sbd *sdp, int flags)
171 {
172         struct list_head *head;
173         u64 sync_gen;
174         struct list_head *first;
175         struct gfs2_ail *first_ai, *ai, *tmp;
176         int done = 0;
177
178         gfs2_log_lock(sdp);
179         head = &sdp->sd_ail1_list;
180         if (list_empty(head)) {
181                 gfs2_log_unlock(sdp);
182                 return;
183         }
184         sync_gen = sdp->sd_ail_sync_gen++;
185
186         first = head->prev;
187         first_ai = list_entry(first, struct gfs2_ail, ai_list);
188         first_ai->ai_sync_gen = sync_gen;
189         gfs2_ail1_start_one(sdp, first_ai); /* This may drop log lock */
190
191         if (flags & DIO_ALL)
192                 first = NULL;
193
194         while(!done) {
195                 if (first && (head->prev != first ||
196                               gfs2_ail1_empty_one(sdp, first_ai, 0)))
197                         break;
198
199                 done = 1;
200                 list_for_each_entry_safe_reverse(ai, tmp, head, ai_list) {
201                         if (ai->ai_sync_gen >= sync_gen)
202                                 continue;
203                         ai->ai_sync_gen = sync_gen;
204                         gfs2_ail1_start_one(sdp, ai); /* This may drop log lock */
205                         done = 0;
206                         break;
207                 }
208         }
209
210         gfs2_log_unlock(sdp);
211 }
212
213 static int gfs2_ail1_empty(struct gfs2_sbd *sdp, int flags)
214 {
215         struct gfs2_ail *ai, *s;
216         int ret;
217
218         gfs2_log_lock(sdp);
219
220         list_for_each_entry_safe_reverse(ai, s, &sdp->sd_ail1_list, ai_list) {
221                 if (gfs2_ail1_empty_one(sdp, ai, flags))
222                         list_move(&ai->ai_list, &sdp->sd_ail2_list);
223                 else if (!(flags & DIO_ALL))
224                         break;
225         }
226
227         ret = list_empty(&sdp->sd_ail1_list);
228
229         gfs2_log_unlock(sdp);
230
231         return ret;
232 }
233
234
235 /**
236  * gfs2_ail2_empty_one - Check whether or not a trans in the AIL has been synced
237  * @sdp: the filesystem
238  * @ai: the AIL entry
239  *
240  */
241
242 static void gfs2_ail2_empty_one(struct gfs2_sbd *sdp, struct gfs2_ail *ai)
243 {
244         struct list_head *head = &ai->ai_ail2_list;
245         struct gfs2_bufdata *bd;
246
247         while (!list_empty(head)) {
248                 bd = list_entry(head->prev, struct gfs2_bufdata,
249                                 bd_ail_st_list);
250                 gfs2_assert(sdp, bd->bd_ail == ai);
251                 gfs2_remove_from_ail(bd);
252         }
253 }
254
255 static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
256 {
257         struct gfs2_ail *ai, *safe;
258         unsigned int old_tail = sdp->sd_log_tail;
259         int wrap = (new_tail < old_tail);
260         int a, b, rm;
261
262         gfs2_log_lock(sdp);
263
264         list_for_each_entry_safe(ai, safe, &sdp->sd_ail2_list, ai_list) {
265                 a = (old_tail <= ai->ai_first);
266                 b = (ai->ai_first < new_tail);
267                 rm = (wrap) ? (a || b) : (a && b);
268                 if (!rm)
269                         continue;
270
271                 gfs2_ail2_empty_one(sdp, ai);
272                 list_del(&ai->ai_list);
273                 gfs2_assert_warn(sdp, list_empty(&ai->ai_ail1_list));
274                 gfs2_assert_warn(sdp, list_empty(&ai->ai_ail2_list));
275                 kfree(ai);
276         }
277
278         gfs2_log_unlock(sdp);
279 }
280
281 /**
282  * gfs2_log_reserve - Make a log reservation
283  * @sdp: The GFS2 superblock
284  * @blks: The number of blocks to reserve
285  *
286  * Note that we never give out the last few blocks of the journal. Thats
287  * due to the fact that there is a small number of header blocks
288  * associated with each log flush. The exact number can't be known until
289  * flush time, so we ensure that we have just enough free blocks at all
290  * times to avoid running out during a log flush.
291  *
292  * Returns: errno
293  */
294
295 int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
296 {
297         unsigned int try = 0;
298         unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);
299
300         if (gfs2_assert_warn(sdp, blks) ||
301             gfs2_assert_warn(sdp, blks <= sdp->sd_jdesc->jd_blocks))
302                 return -EINVAL;
303
304         mutex_lock(&sdp->sd_log_reserve_mutex);
305         gfs2_log_lock(sdp);
306         while(atomic_read(&sdp->sd_log_blks_free) <= (blks + reserved_blks)) {
307                 gfs2_log_unlock(sdp);
308                 gfs2_ail1_empty(sdp, 0);
309                 gfs2_log_flush(sdp, NULL);
310
311                 if (try++)
312                         gfs2_ail1_start(sdp, 0);
313                 gfs2_log_lock(sdp);
314         }
315         atomic_sub(blks, &sdp->sd_log_blks_free);
316         gfs2_log_unlock(sdp);
317         mutex_unlock(&sdp->sd_log_reserve_mutex);
318
319         down_read(&sdp->sd_log_flush_lock);
320
321         return 0;
322 }
323
324 /**
325  * gfs2_log_release - Release a given number of log blocks
326  * @sdp: The GFS2 superblock
327  * @blks: The number of blocks
328  *
329  */
330
331 void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
332 {
333
334         gfs2_log_lock(sdp);
335         atomic_add(blks, &sdp->sd_log_blks_free);
336         gfs2_assert_withdraw(sdp,
337                              atomic_read(&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);
338         gfs2_log_unlock(sdp);
339         up_read(&sdp->sd_log_flush_lock);
340 }
341
342 static u64 log_bmap(struct gfs2_sbd *sdp, unsigned int lbn)
343 {
344         struct gfs2_journal_extent *je;
345
346         list_for_each_entry(je, &sdp->sd_jdesc->extent_list, extent_list) {
347                 if (lbn >= je->lblock && lbn < je->lblock + je->blocks)
348                         return je->dblock + lbn - je->lblock;
349         }
350
351         return -1;
352 }
353
354 /**
355  * log_distance - Compute distance between two journal blocks
356  * @sdp: The GFS2 superblock
357  * @newer: The most recent journal block of the pair
358  * @older: The older journal block of the pair
359  *
360  *   Compute the distance (in the journal direction) between two
361  *   blocks in the journal
362  *
363  * Returns: the distance in blocks
364  */
365
366 static inline unsigned int log_distance(struct gfs2_sbd *sdp, unsigned int newer,
367                                         unsigned int older)
368 {
369         int dist;
370
371         dist = newer - older;
372         if (dist < 0)
373                 dist += sdp->sd_jdesc->jd_blocks;
374
375         return dist;
376 }
377
378 /**
379  * calc_reserved - Calculate the number of blocks to reserve when
380  *                 refunding a transaction's unused buffers.
381  * @sdp: The GFS2 superblock
382  *
383  * This is complex.  We need to reserve room for all our currently used
384  * metadata buffers (e.g. normal file I/O rewriting file time stamps) and 
385  * all our journaled data buffers for journaled files (e.g. files in the 
386  * meta_fs like rindex, or files for which chattr +j was done.)
387  * If we don't reserve enough space, gfs2_log_refund and gfs2_log_flush
388  * will count it as free space (sd_log_blks_free) and corruption will follow.
389  *
390  * We can have metadata bufs and jdata bufs in the same journal.  So each
391  * type gets its own log header, for which we need to reserve a block.
392  * In fact, each type has the potential for needing more than one header 
393  * in cases where we have more buffers than will fit on a journal page.
394  * Metadata journal entries take up half the space of journaled buffer entries.
395  * Thus, metadata entries have buf_limit (502) and journaled buffers have
396  * databuf_limit (251) before they cause a wrap around.
397  *
398  * Also, we need to reserve blocks for revoke journal entries and one for an
399  * overall header for the lot.
400  *
401  * Returns: the number of blocks reserved
402  */
403 static unsigned int calc_reserved(struct gfs2_sbd *sdp)
404 {
405         unsigned int reserved = 0;
406         unsigned int mbuf_limit, metabufhdrs_needed;
407         unsigned int dbuf_limit, databufhdrs_needed;
408         unsigned int revokes = 0;
409
410         mbuf_limit = buf_limit(sdp);
411         metabufhdrs_needed = (sdp->sd_log_commited_buf +
412                               (mbuf_limit - 1)) / mbuf_limit;
413         dbuf_limit = databuf_limit(sdp);
414         databufhdrs_needed = (sdp->sd_log_commited_databuf +
415                               (dbuf_limit - 1)) / dbuf_limit;
416
417         if (sdp->sd_log_commited_revoke)
418                 revokes = gfs2_struct2blk(sdp, sdp->sd_log_commited_revoke,
419                                           sizeof(u64));
420
421         reserved = sdp->sd_log_commited_buf + metabufhdrs_needed +
422                 sdp->sd_log_commited_databuf + databufhdrs_needed +
423                 revokes;
424         /* One for the overall header */
425         if (reserved)
426                 reserved++;
427         return reserved;
428 }
429
430 static unsigned int current_tail(struct gfs2_sbd *sdp)
431 {
432         struct gfs2_ail *ai;
433         unsigned int tail;
434
435         gfs2_log_lock(sdp);
436
437         if (list_empty(&sdp->sd_ail1_list)) {
438                 tail = sdp->sd_log_head;
439         } else {
440                 ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail, ai_list);
441                 tail = ai->ai_first;
442         }
443
444         gfs2_log_unlock(sdp);
445
446         return tail;
447 }
448
449 void gfs2_log_incr_head(struct gfs2_sbd *sdp)
450 {
451         if (sdp->sd_log_flush_head == sdp->sd_log_tail)
452                 BUG_ON(sdp->sd_log_flush_head != sdp->sd_log_head);
453
454         if (++sdp->sd_log_flush_head == sdp->sd_jdesc->jd_blocks) {
455                 sdp->sd_log_flush_head = 0;
456                 sdp->sd_log_flush_wrapped = 1;
457         }
458 }
459
460 /**
461  * gfs2_log_write_endio - End of I/O for a log buffer
462  * @bh: The buffer head
463  * @uptodate: I/O Status
464  *
465  */
466
467 static void gfs2_log_write_endio(struct buffer_head *bh, int uptodate)
468 {
469         struct gfs2_sbd *sdp = bh->b_private;
470         bh->b_private = NULL;
471
472         end_buffer_write_sync(bh, uptodate);
473         if (atomic_dec_and_test(&sdp->sd_log_in_flight))
474                 wake_up(&sdp->sd_log_flush_wait);
475 }
476
477 /**
478  * gfs2_log_get_buf - Get and initialize a buffer to use for log control data
479  * @sdp: The GFS2 superblock
480  *
481  * Returns: the buffer_head
482  */
483
484 struct buffer_head *gfs2_log_get_buf(struct gfs2_sbd *sdp)
485 {
486         u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
487         struct buffer_head *bh;
488
489         bh = sb_getblk(sdp->sd_vfs, blkno);
490         lock_buffer(bh);
491         memset(bh->b_data, 0, bh->b_size);
492         set_buffer_uptodate(bh);
493         clear_buffer_dirty(bh);
494         gfs2_log_incr_head(sdp);
495         atomic_inc(&sdp->sd_log_in_flight);
496         bh->b_private = sdp;
497         bh->b_end_io = gfs2_log_write_endio;
498
499         return bh;
500 }
501
502 /**
503  * gfs2_fake_write_endio - 
504  * @bh: The buffer head
505  * @uptodate: The I/O Status
506  *
507  */
508
509 static void gfs2_fake_write_endio(struct buffer_head *bh, int uptodate)
510 {
511         struct buffer_head *real_bh = bh->b_private;
512         struct gfs2_bufdata *bd = real_bh->b_private;
513         struct gfs2_sbd *sdp = bd->bd_gl->gl_sbd;
514
515         end_buffer_write_sync(bh, uptodate);
516         free_buffer_head(bh);
517         unlock_buffer(real_bh);
518         brelse(real_bh);
519         if (atomic_dec_and_test(&sdp->sd_log_in_flight))
520                 wake_up(&sdp->sd_log_flush_wait);
521 }
522
523 /**
524  * gfs2_log_fake_buf - Build a fake buffer head to write metadata buffer to log
525  * @sdp: the filesystem
526  * @data: the data the buffer_head should point to
527  *
528  * Returns: the log buffer descriptor
529  */
530
531 struct buffer_head *gfs2_log_fake_buf(struct gfs2_sbd *sdp,
532                                       struct buffer_head *real)
533 {
534         u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
535         struct buffer_head *bh;
536
537         bh = alloc_buffer_head(GFP_NOFS | __GFP_NOFAIL);
538         atomic_set(&bh->b_count, 1);
539         bh->b_state = (1 << BH_Mapped) | (1 << BH_Uptodate) | (1 << BH_Lock);
540         set_bh_page(bh, real->b_page, bh_offset(real));
541         bh->b_blocknr = blkno;
542         bh->b_size = sdp->sd_sb.sb_bsize;
543         bh->b_bdev = sdp->sd_vfs->s_bdev;
544         bh->b_private = real;
545         bh->b_end_io = gfs2_fake_write_endio;
546
547         gfs2_log_incr_head(sdp);
548         atomic_inc(&sdp->sd_log_in_flight);
549
550         return bh;
551 }
552
553 static void log_pull_tail(struct gfs2_sbd *sdp, unsigned int new_tail)
554 {
555         unsigned int dist = log_distance(sdp, new_tail, sdp->sd_log_tail);
556
557         ail2_empty(sdp, new_tail);
558
559         gfs2_log_lock(sdp);
560         atomic_add(dist, &sdp->sd_log_blks_free);
561         gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <= sdp->sd_jdesc->jd_blocks);
562         gfs2_log_unlock(sdp);
563
564         sdp->sd_log_tail = new_tail;
565 }
566
567 /**
568  * log_write_header - Get and initialize a journal header buffer
569  * @sdp: The GFS2 superblock
570  *
571  * Returns: the initialized log buffer descriptor
572  */
573
574 static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull)
575 {
576         u64 blkno = log_bmap(sdp, sdp->sd_log_flush_head);
577         struct buffer_head *bh;
578         struct gfs2_log_header *lh;
579         unsigned int tail;
580         u32 hash;
581
582         bh = sb_getblk(sdp->sd_vfs, blkno);
583         lock_buffer(bh);
584         memset(bh->b_data, 0, bh->b_size);
585         set_buffer_uptodate(bh);
586         clear_buffer_dirty(bh);
587         unlock_buffer(bh);
588
589         gfs2_ail1_empty(sdp, 0);
590         tail = current_tail(sdp);
591
592         lh = (struct gfs2_log_header *)bh->b_data;
593         memset(lh, 0, sizeof(struct gfs2_log_header));
594         lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
595         lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
596         lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
597         lh->lh_sequence = cpu_to_be64(sdp->sd_log_sequence++);
598         lh->lh_flags = cpu_to_be32(flags);
599         lh->lh_tail = cpu_to_be32(tail);
600         lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head);
601         hash = gfs2_disk_hash(bh->b_data, sizeof(struct gfs2_log_header));
602         lh->lh_hash = cpu_to_be32(hash);
603
604         set_buffer_dirty(bh);
605         if (sync_dirty_buffer(bh))
606                 gfs2_io_error_bh(sdp, bh);
607         brelse(bh);
608
609         if (sdp->sd_log_tail != tail)
610                 log_pull_tail(sdp, tail);
611         else
612                 gfs2_assert_withdraw(sdp, !pull);
613
614         sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
615         gfs2_log_incr_head(sdp);
616 }
617
618 static void log_flush_commit(struct gfs2_sbd *sdp)
619 {
620         DEFINE_WAIT(wait);
621
622         if (atomic_read(&sdp->sd_log_in_flight)) {
623                 do {
624                         prepare_to_wait(&sdp->sd_log_flush_wait, &wait,
625                                         TASK_UNINTERRUPTIBLE);
626                         if (atomic_read(&sdp->sd_log_in_flight))
627                                 io_schedule();
628                 } while(atomic_read(&sdp->sd_log_in_flight));
629                 finish_wait(&sdp->sd_log_flush_wait, &wait);
630         }
631
632         log_write_header(sdp, 0, 0);
633 }
634
635 static void gfs2_ordered_write(struct gfs2_sbd *sdp)
636 {
637         struct gfs2_bufdata *bd;
638         struct buffer_head *bh;
639         LIST_HEAD(written);
640
641         gfs2_log_lock(sdp);
642         while (!list_empty(&sdp->sd_log_le_ordered)) {
643                 bd = list_entry(sdp->sd_log_le_ordered.next, struct gfs2_bufdata, bd_le.le_list);
644                 list_move(&bd->bd_le.le_list, &written);
645                 bh = bd->bd_bh;
646                 if (!buffer_dirty(bh))
647                         continue;
648                 get_bh(bh);
649                 gfs2_log_unlock(sdp);
650                 lock_buffer(bh);
651                 if (buffer_mapped(bh) && test_clear_buffer_dirty(bh)) {
652                         bh->b_end_io = end_buffer_write_sync;
653                         submit_bh(WRITE, bh);
654                 } else {
655                         unlock_buffer(bh);
656                         brelse(bh);
657                 }
658                 gfs2_log_lock(sdp);
659         }
660         list_splice(&written, &sdp->sd_log_le_ordered);
661         gfs2_log_unlock(sdp);
662 }
663
664 static void gfs2_ordered_wait(struct gfs2_sbd *sdp)
665 {
666         struct gfs2_bufdata *bd;
667         struct buffer_head *bh;
668
669         gfs2_log_lock(sdp);
670         while (!list_empty(&sdp->sd_log_le_ordered)) {
671                 bd = list_entry(sdp->sd_log_le_ordered.prev, struct gfs2_bufdata, bd_le.le_list);
672                 bh = bd->bd_bh;
673                 if (buffer_locked(bh)) {
674                         get_bh(bh);
675                         gfs2_log_unlock(sdp);
676                         wait_on_buffer(bh);
677                         brelse(bh);
678                         gfs2_log_lock(sdp);
679                         continue;
680                 }
681                 list_del_init(&bd->bd_le.le_list);
682         }
683         gfs2_log_unlock(sdp);
684 }
685
686 /**
687  * gfs2_log_flush - flush incore transaction(s)
688  * @sdp: the filesystem
689  * @gl: The glock structure to flush.  If NULL, flush the whole incore log
690  *
691  */
692
693 void __gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)
694 {
695         struct gfs2_ail *ai;
696
697         down_write(&sdp->sd_log_flush_lock);
698
699         /* Log might have been flushed while we waited for the flush lock */
700         if (gl && !test_bit(GLF_LFLUSH, &gl->gl_flags)) {
701                 up_write(&sdp->sd_log_flush_lock);
702                 return;
703         }
704
705         ai = kzalloc(sizeof(struct gfs2_ail), GFP_NOFS | __GFP_NOFAIL);
706         INIT_LIST_HEAD(&ai->ai_ail1_list);
707         INIT_LIST_HEAD(&ai->ai_ail2_list);
708
709         if (sdp->sd_log_num_buf != sdp->sd_log_commited_buf) {
710                 printk(KERN_INFO "GFS2: log buf %u %u\n", sdp->sd_log_num_buf,
711                        sdp->sd_log_commited_buf);
712                 gfs2_assert_withdraw(sdp, 0);
713         }
714         if (sdp->sd_log_num_databuf != sdp->sd_log_commited_databuf) {
715                 printk(KERN_INFO "GFS2: log databuf %u %u\n",
716                        sdp->sd_log_num_databuf, sdp->sd_log_commited_databuf);
717                 gfs2_assert_withdraw(sdp, 0);
718         }
719         gfs2_assert_withdraw(sdp,
720                         sdp->sd_log_num_revoke == sdp->sd_log_commited_revoke);
721
722         sdp->sd_log_flush_head = sdp->sd_log_head;
723         sdp->sd_log_flush_wrapped = 0;
724         ai->ai_first = sdp->sd_log_flush_head;
725
726         gfs2_ordered_write(sdp);
727         lops_before_commit(sdp);
728         gfs2_ordered_wait(sdp);
729
730         if (sdp->sd_log_head != sdp->sd_log_flush_head)
731                 log_flush_commit(sdp);
732         else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){
733                 gfs2_log_lock(sdp);
734                 atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
735                 gfs2_log_unlock(sdp);
736                 log_write_header(sdp, 0, PULL);
737         }
738         lops_after_commit(sdp, ai);
739
740         gfs2_log_lock(sdp);
741         sdp->sd_log_head = sdp->sd_log_flush_head;
742         sdp->sd_log_blks_reserved = 0;
743         sdp->sd_log_commited_buf = 0;
744         sdp->sd_log_commited_databuf = 0;
745         sdp->sd_log_commited_revoke = 0;
746
747         if (!list_empty(&ai->ai_ail1_list)) {
748                 list_add(&ai->ai_list, &sdp->sd_ail1_list);
749                 ai = NULL;
750         }
751         gfs2_log_unlock(sdp);
752
753         sdp->sd_vfs->s_dirt = 0;
754         up_write(&sdp->sd_log_flush_lock);
755
756         kfree(ai);
757 }
758
759 static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
760 {
761         unsigned int reserved;
762         unsigned int unused;
763
764         gfs2_log_lock(sdp);
765
766         sdp->sd_log_commited_buf += tr->tr_num_buf_new - tr->tr_num_buf_rm;
767         sdp->sd_log_commited_databuf += tr->tr_num_databuf_new -
768                 tr->tr_num_databuf_rm;
769         gfs2_assert_withdraw(sdp, (((int)sdp->sd_log_commited_buf) >= 0) ||
770                              (((int)sdp->sd_log_commited_databuf) >= 0));
771         sdp->sd_log_commited_revoke += tr->tr_num_revoke - tr->tr_num_revoke_rm;
772         gfs2_assert_withdraw(sdp, ((int)sdp->sd_log_commited_revoke) >= 0);
773         reserved = calc_reserved(sdp);
774         gfs2_assert_withdraw(sdp, sdp->sd_log_blks_reserved + tr->tr_reserved >= reserved);
775         unused = sdp->sd_log_blks_reserved - reserved + tr->tr_reserved;
776         atomic_add(unused, &sdp->sd_log_blks_free);
777         gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
778                              sdp->sd_jdesc->jd_blocks);
779         sdp->sd_log_blks_reserved = reserved;
780
781         gfs2_log_unlock(sdp);
782 }
783
784 static void buf_lo_incore_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
785 {
786         struct list_head *head = &tr->tr_list_buf;
787         struct gfs2_bufdata *bd;
788
789         gfs2_log_lock(sdp);
790         while (!list_empty(head)) {
791                 bd = list_entry(head->next, struct gfs2_bufdata, bd_list_tr);
792                 list_del_init(&bd->bd_list_tr);
793                 tr->tr_num_buf--;
794         }
795         gfs2_log_unlock(sdp);
796         gfs2_assert_warn(sdp, !tr->tr_num_buf);
797 }
798
799 /**
800  * gfs2_log_commit - Commit a transaction to the log
801  * @sdp: the filesystem
802  * @tr: the transaction
803  *
804  * Returns: errno
805  */
806
807 void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
808 {
809         log_refund(sdp, tr);
810         buf_lo_incore_commit(sdp, tr);
811
812         sdp->sd_vfs->s_dirt = 1;
813         up_read(&sdp->sd_log_flush_lock);
814
815         gfs2_log_lock(sdp);
816         if (sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks))
817                 wake_up_process(sdp->sd_logd_process);
818         gfs2_log_unlock(sdp);
819 }
820
821 /**
822  * gfs2_log_shutdown - write a shutdown header into a journal
823  * @sdp: the filesystem
824  *
825  */
826
827 void gfs2_log_shutdown(struct gfs2_sbd *sdp)
828 {
829         down_write(&sdp->sd_log_flush_lock);
830
831         gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
832         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_buf);
833         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
834         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_rg);
835         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_databuf);
836         gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
837
838         sdp->sd_log_flush_head = sdp->sd_log_head;
839         sdp->sd_log_flush_wrapped = 0;
840
841         log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT,
842                          (sdp->sd_log_tail == current_tail(sdp)) ? 0 : PULL);
843
844         gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks);
845         gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
846         gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
847
848         sdp->sd_log_head = sdp->sd_log_flush_head;
849         sdp->sd_log_tail = sdp->sd_log_head;
850
851         up_write(&sdp->sd_log_flush_lock);
852 }
853
854
855 /**
856  * gfs2_meta_syncfs - sync all the buffers in a filesystem
857  * @sdp: the filesystem
858  *
859  */
860
861 void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
862 {
863         gfs2_log_flush(sdp, NULL);
864         for (;;) {
865                 gfs2_ail1_start(sdp, DIO_ALL);
866                 if (gfs2_ail1_empty(sdp, DIO_ALL))
867                         break;
868                 msleep(10);
869         }
870 }
871
872
873 /**
874  * gfs2_logd - Update log tail as Active Items get flushed to in-place blocks
875  * @sdp: Pointer to GFS2 superblock
876  *
877  * Also, periodically check to make sure that we're using the most recent
878  * journal index.
879  */
880
881 int gfs2_logd(void *data)
882 {
883         struct gfs2_sbd *sdp = data;
884         unsigned long t;
885         int need_flush;
886
887         while (!kthread_should_stop()) {
888                 /* Advance the log tail */
889
890                 t = sdp->sd_log_flush_time +
891                     gfs2_tune_get(sdp, gt_log_flush_secs) * HZ;
892
893                 gfs2_ail1_empty(sdp, DIO_ALL);
894                 gfs2_log_lock(sdp);
895                 need_flush = sdp->sd_log_num_buf > gfs2_tune_get(sdp, gt_incore_log_blocks);
896                 gfs2_log_unlock(sdp);
897                 if (need_flush || time_after_eq(jiffies, t)) {
898                         gfs2_log_flush(sdp, NULL);
899                         sdp->sd_log_flush_time = jiffies;
900                 }
901
902                 t = gfs2_tune_get(sdp, gt_logd_secs) * HZ;
903                 if (freezing(current))
904                         refrigerator();
905                 schedule_timeout_interruptible(t);
906         }
907
908         return 0;
909 }
910