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