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