Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee13...
[linux-2.6] / fs / gfs2 / super.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/crc32.h>
16 #include <linux/gfs2_ondisk.h>
17 #include <linux/bio.h>
18 #include <linux/lm_interface.h>
19
20 #include "gfs2.h"
21 #include "incore.h"
22 #include "bmap.h"
23 #include "dir.h"
24 #include "glock.h"
25 #include "glops.h"
26 #include "inode.h"
27 #include "log.h"
28 #include "meta_io.h"
29 #include "quota.h"
30 #include "recovery.h"
31 #include "rgrp.h"
32 #include "super.h"
33 #include "trans.h"
34 #include "util.h"
35
36 static const u32 gfs2_old_fs_formats[] = {
37         0
38 };
39
40 static const u32 gfs2_old_multihost_formats[] = {
41         0
42 };
43
44 /**
45  * gfs2_tune_init - Fill a gfs2_tune structure with default values
46  * @gt: tune
47  *
48  */
49
50 void gfs2_tune_init(struct gfs2_tune *gt)
51 {
52         spin_lock_init(&gt->gt_spin);
53
54         gt->gt_ilimit = 100;
55         gt->gt_ilimit_tries = 3;
56         gt->gt_ilimit_min = 1;
57         gt->gt_demote_secs = 300;
58         gt->gt_incore_log_blocks = 1024;
59         gt->gt_log_flush_secs = 60;
60         gt->gt_jindex_refresh_secs = 60;
61         gt->gt_scand_secs = 15;
62         gt->gt_recoverd_secs = 60;
63         gt->gt_logd_secs = 1;
64         gt->gt_quotad_secs = 5;
65         gt->gt_quota_simul_sync = 64;
66         gt->gt_quota_warn_period = 10;
67         gt->gt_quota_scale_num = 1;
68         gt->gt_quota_scale_den = 1;
69         gt->gt_quota_cache_secs = 300;
70         gt->gt_quota_quantum = 60;
71         gt->gt_atime_quantum = 3600;
72         gt->gt_new_files_jdata = 0;
73         gt->gt_new_files_directio = 0;
74         gt->gt_max_atomic_write = 4 << 20;
75         gt->gt_max_readahead = 1 << 18;
76         gt->gt_lockdump_size = 131072;
77         gt->gt_stall_secs = 600;
78         gt->gt_complain_secs = 10;
79         gt->gt_reclaim_limit = 5000;
80         gt->gt_entries_per_readdir = 32;
81         gt->gt_prefetch_secs = 10;
82         gt->gt_greedy_default = HZ / 10;
83         gt->gt_greedy_quantum = HZ / 40;
84         gt->gt_greedy_max = HZ / 4;
85         gt->gt_statfs_quantum = 30;
86         gt->gt_statfs_slow = 0;
87 }
88
89 /**
90  * gfs2_check_sb - Check superblock
91  * @sdp: the filesystem
92  * @sb: The superblock
93  * @silent: Don't print a message if the check fails
94  *
95  * Checks the version code of the FS is one that we understand how to
96  * read and that the sizes of the various on-disk structures have not
97  * changed.
98  */
99
100 int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb *sb, int silent)
101 {
102         unsigned int x;
103
104         if (sb->sb_header.mh_magic != GFS2_MAGIC ||
105             sb->sb_header.mh_type != GFS2_METATYPE_SB) {
106                 if (!silent)
107                         printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n");
108                 return -EINVAL;
109         }
110
111         /*  If format numbers match exactly, we're done.  */
112
113         if (sb->sb_fs_format == GFS2_FORMAT_FS &&
114             sb->sb_multihost_format == GFS2_FORMAT_MULTI)
115                 return 0;
116
117         if (sb->sb_fs_format != GFS2_FORMAT_FS) {
118                 for (x = 0; gfs2_old_fs_formats[x]; x++)
119                         if (gfs2_old_fs_formats[x] == sb->sb_fs_format)
120                                 break;
121
122                 if (!gfs2_old_fs_formats[x]) {
123                         printk(KERN_WARNING
124                                "GFS2: code version (%u, %u) is incompatible "
125                                "with ondisk format (%u, %u)\n",
126                                GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
127                                sb->sb_fs_format, sb->sb_multihost_format);
128                         printk(KERN_WARNING
129                                "GFS2: I don't know how to upgrade this FS\n");
130                         return -EINVAL;
131                 }
132         }
133
134         if (sb->sb_multihost_format != GFS2_FORMAT_MULTI) {
135                 for (x = 0; gfs2_old_multihost_formats[x]; x++)
136                         if (gfs2_old_multihost_formats[x] ==
137                             sb->sb_multihost_format)
138                                 break;
139
140                 if (!gfs2_old_multihost_formats[x]) {
141                         printk(KERN_WARNING
142                                "GFS2: code version (%u, %u) is incompatible "
143                                "with ondisk format (%u, %u)\n",
144                                GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
145                                sb->sb_fs_format, sb->sb_multihost_format);
146                         printk(KERN_WARNING
147                                "GFS2: I don't know how to upgrade this FS\n");
148                         return -EINVAL;
149                 }
150         }
151
152         if (!sdp->sd_args.ar_upgrade) {
153                 printk(KERN_WARNING
154                        "GFS2: code version (%u, %u) is incompatible "
155                        "with ondisk format (%u, %u)\n",
156                        GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
157                        sb->sb_fs_format, sb->sb_multihost_format);
158                 printk(KERN_INFO
159                        "GFS2: Use the \"upgrade\" mount option to upgrade "
160                        "the FS\n");
161                 printk(KERN_INFO "GFS2: See the manual for more details\n");
162                 return -EINVAL;
163         }
164
165         return 0;
166 }
167
168
169 static int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)
170 {
171         struct page *page = bio->bi_private;
172         if (bio->bi_size)
173                 return 1;
174
175         if (!error)
176                 SetPageUptodate(page);
177         else
178                 printk(KERN_WARNING "gfs2: error %d reading superblock\n", error);
179         unlock_page(page);
180         return 0;
181 }
182
183 struct page *gfs2_read_super(struct super_block *sb, sector_t sector)
184 {
185         struct page *page;
186         struct bio *bio;
187
188         page = alloc_page(GFP_KERNEL);
189         if (unlikely(!page))
190                 return NULL;
191
192         ClearPageUptodate(page);
193         ClearPageDirty(page);
194         lock_page(page);
195
196         bio = bio_alloc(GFP_KERNEL, 1);
197         if (unlikely(!bio)) {
198                 __free_page(page);
199                 return NULL;
200         }
201
202         bio->bi_sector = sector;
203         bio->bi_bdev = sb->s_bdev;
204         bio_add_page(bio, page, PAGE_SIZE, 0);
205
206         bio->bi_end_io = end_bio_io_page;
207         bio->bi_private = page;
208         submit_bio(READ_SYNC | (1 << BIO_RW_META), bio);
209         wait_on_page_locked(page);
210         bio_put(bio);
211         if (!PageUptodate(page)) {
212                 __free_page(page);
213                 return NULL;
214         }
215         return page;
216 }
217
218 /**
219  * gfs2_read_sb - Read super block
220  * @sdp: The GFS2 superblock
221  * @gl: the glock for the superblock (assumed to be held)
222  * @silent: Don't print message if mount fails
223  *
224  */
225
226 int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
227 {
228         u32 hash_blocks, ind_blocks, leaf_blocks;
229         u32 tmp_blocks;
230         unsigned int x;
231         int error;
232         struct page *page;
233         char *sb;
234
235         page = gfs2_read_super(sdp->sd_vfs, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
236         if (!page) {
237                 if (!silent)
238                         fs_err(sdp, "can't read superblock\n");
239                 return -EIO;
240         }
241         sb = kmap(page);
242         gfs2_sb_in(&sdp->sd_sb, sb);
243         kunmap(page);
244         __free_page(page);
245
246         error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
247         if (error)
248                 return error;
249
250         sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
251                                GFS2_BASIC_BLOCK_SHIFT;
252         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
253         sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
254                           sizeof(struct gfs2_dinode)) / sizeof(u64);
255         sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
256                           sizeof(struct gfs2_meta_header)) / sizeof(u64);
257         sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
258         sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
259         sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
260         sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
261         sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
262                                 sizeof(struct gfs2_meta_header)) /
263                                 sizeof(struct gfs2_quota_change);
264
265         /* Compute maximum reservation required to add a entry to a directory */
266
267         hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
268                              sdp->sd_jbsize);
269
270         ind_blocks = 0;
271         for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
272                 tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
273                 ind_blocks += tmp_blocks;
274         }
275
276         leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
277
278         sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
279
280         sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
281                                 sizeof(struct gfs2_dinode);
282         sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
283         for (x = 2;; x++) {
284                 u64 space, d;
285                 u32 m;
286
287                 space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
288                 d = space;
289                 m = do_div(d, sdp->sd_inptrs);
290
291                 if (d != sdp->sd_heightsize[x - 1] || m)
292                         break;
293                 sdp->sd_heightsize[x] = space;
294         }
295         sdp->sd_max_height = x;
296         gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
297
298         sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -
299                                  sizeof(struct gfs2_dinode);
300         sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
301         for (x = 2;; x++) {
302                 u64 space, d;
303                 u32 m;
304
305                 space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
306                 d = space;
307                 m = do_div(d, sdp->sd_inptrs);
308
309                 if (d != sdp->sd_jheightsize[x - 1] || m)
310                         break;
311                 sdp->sd_jheightsize[x] = space;
312         }
313         sdp->sd_max_jheight = x;
314         gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);
315
316         return 0;
317 }
318
319 /**
320  * gfs2_jindex_hold - Grab a lock on the jindex
321  * @sdp: The GFS2 superblock
322  * @ji_gh: the holder for the jindex glock
323  *
324  * This is very similar to the gfs2_rindex_hold() function, except that
325  * in general we hold the jindex lock for longer periods of time and
326  * we grab it far less frequently (in general) then the rgrp lock.
327  *
328  * Returns: errno
329  */
330
331 int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
332 {
333         struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
334         struct qstr name;
335         char buf[20];
336         struct gfs2_jdesc *jd;
337         int error;
338
339         name.name = buf;
340
341         mutex_lock(&sdp->sd_jindex_mutex);
342
343         for (;;) {
344                 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED,
345                                            GL_LOCAL_EXCL, ji_gh);
346                 if (error)
347                         break;
348
349                 name.len = sprintf(buf, "journal%u", sdp->sd_journals);
350                 name.hash = gfs2_disk_hash(name.name, name.len);
351
352                 error = gfs2_dir_search(sdp->sd_jindex, &name, NULL, NULL);
353                 if (error == -ENOENT) {
354                         error = 0;
355                         break;
356                 }
357
358                 gfs2_glock_dq_uninit(ji_gh);
359
360                 if (error)
361                         break;
362
363                 error = -ENOMEM;
364                 jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
365                 if (!jd)
366                         break;
367
368                 jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1, NULL);
369                 if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {
370                         if (!jd->jd_inode)
371                                 error = -ENOENT;
372                         else
373                                 error = PTR_ERR(jd->jd_inode);
374                         kfree(jd);
375                         break;
376                 }
377
378                 spin_lock(&sdp->sd_jindex_spin);
379                 jd->jd_jid = sdp->sd_journals++;
380                 list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
381                 spin_unlock(&sdp->sd_jindex_spin);
382         }
383
384         mutex_unlock(&sdp->sd_jindex_mutex);
385
386         return error;
387 }
388
389 /**
390  * gfs2_jindex_free - Clear all the journal index information
391  * @sdp: The GFS2 superblock
392  *
393  */
394
395 void gfs2_jindex_free(struct gfs2_sbd *sdp)
396 {
397         struct list_head list;
398         struct gfs2_jdesc *jd;
399
400         spin_lock(&sdp->sd_jindex_spin);
401         list_add(&list, &sdp->sd_jindex_list);
402         list_del_init(&sdp->sd_jindex_list);
403         sdp->sd_journals = 0;
404         spin_unlock(&sdp->sd_jindex_spin);
405
406         while (!list_empty(&list)) {
407                 jd = list_entry(list.next, struct gfs2_jdesc, jd_list);
408                 list_del(&jd->jd_list);
409                 iput(jd->jd_inode);
410                 kfree(jd);
411         }
412 }
413
414 static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid)
415 {
416         struct gfs2_jdesc *jd;
417         int found = 0;
418
419         list_for_each_entry(jd, head, jd_list) {
420                 if (jd->jd_jid == jid) {
421                         found = 1;
422                         break;
423                 }
424         }
425
426         if (!found)
427                 jd = NULL;
428
429         return jd;
430 }
431
432 struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid)
433 {
434         struct gfs2_jdesc *jd;
435
436         spin_lock(&sdp->sd_jindex_spin);
437         jd = jdesc_find_i(&sdp->sd_jindex_list, jid);
438         spin_unlock(&sdp->sd_jindex_spin);
439
440         return jd;
441 }
442
443 void gfs2_jdesc_make_dirty(struct gfs2_sbd *sdp, unsigned int jid)
444 {
445         struct gfs2_jdesc *jd;
446
447         spin_lock(&sdp->sd_jindex_spin);
448         jd = jdesc_find_i(&sdp->sd_jindex_list, jid);
449         if (jd)
450                 jd->jd_dirty = 1;
451         spin_unlock(&sdp->sd_jindex_spin);
452 }
453
454 struct gfs2_jdesc *gfs2_jdesc_find_dirty(struct gfs2_sbd *sdp)
455 {
456         struct gfs2_jdesc *jd;
457         int found = 0;
458
459         spin_lock(&sdp->sd_jindex_spin);
460
461         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
462                 if (jd->jd_dirty) {
463                         jd->jd_dirty = 0;
464                         found = 1;
465                         break;
466                 }
467         }
468         spin_unlock(&sdp->sd_jindex_spin);
469
470         if (!found)
471                 jd = NULL;
472
473         return jd;
474 }
475
476 int gfs2_jdesc_check(struct gfs2_jdesc *jd)
477 {
478         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
479         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
480         int ar;
481         int error;
482
483         if (ip->i_di.di_size < (8 << 20) || ip->i_di.di_size > (1 << 30) ||
484             (ip->i_di.di_size & (sdp->sd_sb.sb_bsize - 1))) {
485                 gfs2_consist_inode(ip);
486                 return -EIO;
487         }
488         jd->jd_blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
489
490         error = gfs2_write_alloc_required(ip, 0, ip->i_di.di_size, &ar);
491         if (!error && ar) {
492                 gfs2_consist_inode(ip);
493                 error = -EIO;
494         }
495
496         return error;
497 }
498
499 /**
500  * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
501  * @sdp: the filesystem
502  *
503  * Returns: errno
504  */
505
506 int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
507 {
508         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
509         struct gfs2_glock *j_gl = ip->i_gl;
510         struct gfs2_holder t_gh;
511         struct gfs2_log_header head;
512         int error;
513
514         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
515                                    GL_LOCAL_EXCL, &t_gh);
516         if (error)
517                 return error;
518
519         gfs2_meta_cache_flush(ip);
520         j_gl->gl_ops->go_inval(j_gl, DIO_METADATA | DIO_DATA);
521
522         error = gfs2_find_jhead(sdp->sd_jdesc, &head);
523         if (error)
524                 goto fail;
525
526         if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
527                 gfs2_consist(sdp);
528                 error = -EIO;
529                 goto fail;
530         }
531
532         /*  Initialize some head of the log stuff  */
533         sdp->sd_log_sequence = head.lh_sequence + 1;
534         gfs2_log_pointers_init(sdp, head.lh_blkno);
535
536         error = gfs2_quota_init(sdp);
537         if (error)
538                 goto fail;
539
540         set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
541
542         gfs2_glock_dq_uninit(&t_gh);
543
544         return 0;
545
546 fail:
547         t_gh.gh_flags |= GL_NOCACHE;
548         gfs2_glock_dq_uninit(&t_gh);
549
550         return error;
551 }
552
553 /**
554  * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
555  * @sdp: the filesystem
556  *
557  * Returns: errno
558  */
559
560 int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
561 {
562         struct gfs2_holder t_gh;
563         int error;
564
565         gfs2_quota_sync(sdp);
566         gfs2_statfs_sync(sdp);
567
568         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
569                                 GL_LOCAL_EXCL | GL_NOCACHE,
570                                 &t_gh);
571         if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
572                 return error;
573
574         gfs2_meta_syncfs(sdp);
575         gfs2_log_shutdown(sdp);
576
577         clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
578
579         if (t_gh.gh_gl)
580                 gfs2_glock_dq_uninit(&t_gh);
581
582         gfs2_quota_cleanup(sdp);
583
584         return error;
585 }
586
587 int gfs2_statfs_init(struct gfs2_sbd *sdp)
588 {
589         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
590         struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
591         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
592         struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
593         struct buffer_head *m_bh, *l_bh;
594         struct gfs2_holder gh;
595         int error;
596
597         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
598                                    &gh);
599         if (error)
600                 return error;
601
602         error = gfs2_meta_inode_buffer(m_ip, &m_bh);
603         if (error)
604                 goto out;
605
606         if (sdp->sd_args.ar_spectator) {
607                 spin_lock(&sdp->sd_statfs_spin);
608                 gfs2_statfs_change_in(m_sc, m_bh->b_data +
609                                       sizeof(struct gfs2_dinode));
610                 spin_unlock(&sdp->sd_statfs_spin);
611         } else {
612                 error = gfs2_meta_inode_buffer(l_ip, &l_bh);
613                 if (error)
614                         goto out_m_bh;
615
616                 spin_lock(&sdp->sd_statfs_spin);
617                 gfs2_statfs_change_in(m_sc, m_bh->b_data +
618                                       sizeof(struct gfs2_dinode));
619                 gfs2_statfs_change_in(l_sc, l_bh->b_data +
620                                       sizeof(struct gfs2_dinode));
621                 spin_unlock(&sdp->sd_statfs_spin);
622
623                 brelse(l_bh);
624         }
625
626 out_m_bh:
627         brelse(m_bh);
628 out:
629         gfs2_glock_dq_uninit(&gh);
630         return 0;
631 }
632
633 void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
634                         s64 dinodes)
635 {
636         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
637         struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
638         struct buffer_head *l_bh;
639         int error;
640
641         error = gfs2_meta_inode_buffer(l_ip, &l_bh);
642         if (error)
643                 return;
644
645         mutex_lock(&sdp->sd_statfs_mutex);
646         gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
647         mutex_unlock(&sdp->sd_statfs_mutex);
648
649         spin_lock(&sdp->sd_statfs_spin);
650         l_sc->sc_total += total;
651         l_sc->sc_free += free;
652         l_sc->sc_dinodes += dinodes;
653         gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));
654         spin_unlock(&sdp->sd_statfs_spin);
655
656         brelse(l_bh);
657 }
658
659 int gfs2_statfs_sync(struct gfs2_sbd *sdp)
660 {
661         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
662         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
663         struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
664         struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
665         struct gfs2_holder gh;
666         struct buffer_head *m_bh, *l_bh;
667         int error;
668
669         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
670                                    &gh);
671         if (error)
672                 return error;
673
674         error = gfs2_meta_inode_buffer(m_ip, &m_bh);
675         if (error)
676                 goto out;
677
678         spin_lock(&sdp->sd_statfs_spin);
679         gfs2_statfs_change_in(m_sc, m_bh->b_data +
680                               sizeof(struct gfs2_dinode));
681         if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {
682                 spin_unlock(&sdp->sd_statfs_spin);
683                 goto out_bh;
684         }
685         spin_unlock(&sdp->sd_statfs_spin);
686
687         error = gfs2_meta_inode_buffer(l_ip, &l_bh);
688         if (error)
689                 goto out_bh;
690
691         error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
692         if (error)
693                 goto out_bh2;
694
695         mutex_lock(&sdp->sd_statfs_mutex);
696         gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
697         mutex_unlock(&sdp->sd_statfs_mutex);
698
699         spin_lock(&sdp->sd_statfs_spin);
700         m_sc->sc_total += l_sc->sc_total;
701         m_sc->sc_free += l_sc->sc_free;
702         m_sc->sc_dinodes += l_sc->sc_dinodes;
703         memset(l_sc, 0, sizeof(struct gfs2_statfs_change));
704         memset(l_bh->b_data + sizeof(struct gfs2_dinode),
705                0, sizeof(struct gfs2_statfs_change));
706         spin_unlock(&sdp->sd_statfs_spin);
707
708         gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
709         gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode));
710
711         gfs2_trans_end(sdp);
712
713 out_bh2:
714         brelse(l_bh);
715 out_bh:
716         brelse(m_bh);
717 out:
718         gfs2_glock_dq_uninit(&gh);
719         return error;
720 }
721
722 /**
723  * gfs2_statfs_i - Do a statfs
724  * @sdp: the filesystem
725  * @sg: the sg structure
726  *
727  * Returns: errno
728  */
729
730 int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change *sc)
731 {
732         struct gfs2_statfs_change *m_sc = &sdp->sd_statfs_master;
733         struct gfs2_statfs_change *l_sc = &sdp->sd_statfs_local;
734
735         spin_lock(&sdp->sd_statfs_spin);
736
737         *sc = *m_sc;
738         sc->sc_total += l_sc->sc_total;
739         sc->sc_free += l_sc->sc_free;
740         sc->sc_dinodes += l_sc->sc_dinodes;
741
742         spin_unlock(&sdp->sd_statfs_spin);
743
744         if (sc->sc_free < 0)
745                 sc->sc_free = 0;
746         if (sc->sc_free > sc->sc_total)
747                 sc->sc_free = sc->sc_total;
748         if (sc->sc_dinodes < 0)
749                 sc->sc_dinodes = 0;
750
751         return 0;
752 }
753
754 /**
755  * statfs_fill - fill in the sg for a given RG
756  * @rgd: the RG
757  * @sc: the sc structure
758  *
759  * Returns: 0 on success, -ESTALE if the LVB is invalid
760  */
761
762 static int statfs_slow_fill(struct gfs2_rgrpd *rgd,
763                             struct gfs2_statfs_change *sc)
764 {
765         gfs2_rgrp_verify(rgd);
766         sc->sc_total += rgd->rd_ri.ri_data;
767         sc->sc_free += rgd->rd_rg.rg_free;
768         sc->sc_dinodes += rgd->rd_rg.rg_dinodes;
769         return 0;
770 }
771
772 /**
773  * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
774  * @sdp: the filesystem
775  * @sc: the sc info that will be returned
776  *
777  * Any error (other than a signal) will cause this routine to fall back
778  * to the synchronous version.
779  *
780  * FIXME: This really shouldn't busy wait like this.
781  *
782  * Returns: errno
783  */
784
785 int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change *sc)
786 {
787         struct gfs2_holder ri_gh;
788         struct gfs2_rgrpd *rgd_next;
789         struct gfs2_holder *gha, *gh;
790         unsigned int slots = 64;
791         unsigned int x;
792         int done;
793         int error = 0, err;
794
795         memset(sc, 0, sizeof(struct gfs2_statfs_change));
796         gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);
797         if (!gha)
798                 return -ENOMEM;
799
800         error = gfs2_rindex_hold(sdp, &ri_gh);
801         if (error)
802                 goto out;
803
804         rgd_next = gfs2_rgrpd_get_first(sdp);
805
806         for (;;) {
807                 done = 1;
808
809                 for (x = 0; x < slots; x++) {
810                         gh = gha + x;
811
812                         if (gh->gh_gl && gfs2_glock_poll(gh)) {
813                                 err = gfs2_glock_wait(gh);
814                                 if (err) {
815                                         gfs2_holder_uninit(gh);
816                                         error = err;
817                                 } else {
818                                         if (!error)
819                                                 error = statfs_slow_fill(
820                                                         gh->gh_gl->gl_object, sc);
821                                         gfs2_glock_dq_uninit(gh);
822                                 }
823                         }
824
825                         if (gh->gh_gl)
826                                 done = 0;
827                         else if (rgd_next && !error) {
828                                 error = gfs2_glock_nq_init(rgd_next->rd_gl,
829                                                            LM_ST_SHARED,
830                                                            GL_ASYNC,
831                                                            gh);
832                                 rgd_next = gfs2_rgrpd_get_next(rgd_next);
833                                 done = 0;
834                         }
835
836                         if (signal_pending(current))
837                                 error = -ERESTARTSYS;
838                 }
839
840                 if (done)
841                         break;
842
843                 yield();
844         }
845
846         gfs2_glock_dq_uninit(&ri_gh);
847
848 out:
849         kfree(gha);
850         return error;
851 }
852
853 struct lfcc {
854         struct list_head list;
855         struct gfs2_holder gh;
856 };
857
858 /**
859  * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
860  *                            journals are clean
861  * @sdp: the file system
862  * @state: the state to put the transaction lock into
863  * @t_gh: the hold on the transaction lock
864  *
865  * Returns: errno
866  */
867
868 static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
869                                     struct gfs2_holder *t_gh)
870 {
871         struct gfs2_inode *ip;
872         struct gfs2_holder ji_gh;
873         struct gfs2_jdesc *jd;
874         struct lfcc *lfcc;
875         LIST_HEAD(list);
876         struct gfs2_log_header lh;
877         int error;
878
879         error = gfs2_jindex_hold(sdp, &ji_gh);
880         if (error)
881                 return error;
882
883         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
884                 lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
885                 if (!lfcc) {
886                         error = -ENOMEM;
887                         goto out;
888                 }
889                 ip = GFS2_I(jd->jd_inode);
890                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh);
891                 if (error) {
892                         kfree(lfcc);
893                         goto out;
894                 }
895                 list_add(&lfcc->list, &list);
896         }
897
898         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,
899                                LM_FLAG_PRIORITY | GL_NOCACHE,
900                                t_gh);
901
902         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
903                 error = gfs2_jdesc_check(jd);
904                 if (error)
905                         break;
906                 error = gfs2_find_jhead(jd, &lh);
907                 if (error)
908                         break;
909                 if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
910                         error = -EBUSY;
911                         break;
912                 }
913         }
914
915         if (error)
916                 gfs2_glock_dq_uninit(t_gh);
917
918 out:
919         while (!list_empty(&list)) {
920                 lfcc = list_entry(list.next, struct lfcc, list);
921                 list_del(&lfcc->list);
922                 gfs2_glock_dq_uninit(&lfcc->gh);
923                 kfree(lfcc);
924         }
925         gfs2_glock_dq_uninit(&ji_gh);
926         return error;
927 }
928
929 /**
930  * gfs2_freeze_fs - freezes the file system
931  * @sdp: the file system
932  *
933  * This function flushes data and meta data for all machines by
934  * aquiring the transaction log exclusively.  All journals are
935  * ensured to be in a clean state as well.
936  *
937  * Returns: errno
938  */
939
940 int gfs2_freeze_fs(struct gfs2_sbd *sdp)
941 {
942         int error = 0;
943
944         mutex_lock(&sdp->sd_freeze_lock);
945
946         if (!sdp->sd_freeze_count++) {
947                 error = gfs2_lock_fs_check_clean(sdp, &sdp->sd_freeze_gh);
948                 if (error)
949                         sdp->sd_freeze_count--;
950         }
951
952         mutex_unlock(&sdp->sd_freeze_lock);
953
954         return error;
955 }
956
957 /**
958  * gfs2_unfreeze_fs - unfreezes the file system
959  * @sdp: the file system
960  *
961  * This function allows the file system to proceed by unlocking
962  * the exclusively held transaction lock.  Other GFS2 nodes are
963  * now free to acquire the lock shared and go on with their lives.
964  *
965  */
966
967 void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)
968 {
969         mutex_lock(&sdp->sd_freeze_lock);
970
971         if (sdp->sd_freeze_count && !--sdp->sd_freeze_count)
972                 gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
973
974         mutex_unlock(&sdp->sd_freeze_lock);
975 }
976