SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/gfs2/super.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/bio.h>
  11 #include <linux/sched.h>
  12 #include <linux/slab.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/completion.h>
  15 #include <linux/buffer_head.h>
  16 #include <linux/statfs.h>
  17 #include <linux/seq_file.h>
  18 #include <linux/mount.h>
  19 #include <linux/kthread.h>
  20 #include <linux/delay.h>
  21 #include <linux/gfs2_ondisk.h>
  22 #include <linux/crc32.h>
  23 #include <linux/time.h>
  24 #include <linux/wait.h>
  25
  26 #include "gfs2.h"
  27 #include "incore.h"
  28 #include "bmap.h"
  29 #include "dir.h"
  30 #include "glock.h"
  31 #include "glops.h"
  32 #include "inode.h"
  33 #include "log.h"
  34 #include "meta_io.h"
  35 #include "quota.h"
  36 #include "recovery.h"
  37 #include "rgrp.h"
  38 #include "super.h"
  39 #include "trans.h"
  40 #include "util.h"
  41 #include "sys.h"
  42 #include "xattr.h"
  43
  44 #define args_neq(a1, a2, x) ((a1)->ar_##x != (a2)->ar_##x)
  45
  46 enum {
  47         Opt_lockproto,
  48         Opt_locktable,
  49         Opt_hostdata,
  50         Opt_spectator,
  51         Opt_ignore_local_fs,
  52         Opt_localflocks,
  53         Opt_localcaching,
  54         Opt_debug,
  55         Opt_nodebug,
  56         Opt_upgrade,
  57         Opt_acl,
  58         Opt_noacl,
  59         Opt_quota_off,
  60         Opt_quota_account,
  61         Opt_quota_on,
  62         Opt_quota,
  63         Opt_noquota,
  64         Opt_suiddir,
  65         Opt_nosuiddir,
  66         Opt_data_writeback,
  67         Opt_data_ordered,
  68         Opt_meta,
  69         Opt_discard,
  70         Opt_nodiscard,
  71         Opt_commit,
  72         Opt_err_withdraw,
  73         Opt_err_panic,
  74         Opt_statfs_quantum,
  75         Opt_statfs_percent,
  76         Opt_quota_quantum,
  77         Opt_barrier,
  78         Opt_nobarrier,
  79         Opt_error,
  80 };
  81
  82 static const match_table_t tokens = {
  83         {Opt_lockproto, "lockproto=%s"},
  84         {Opt_locktable, "locktable=%s"},
  85         {Opt_hostdata, "hostdata=%s"},
  86         {Opt_spectator, "spectator"},
  87         {Opt_ignore_local_fs, "ignore_local_fs"},
  88         {Opt_localflocks, "localflocks"},
  89         {Opt_localcaching, "localcaching"},
  90         {Opt_debug, "debug"},
  91         {Opt_nodebug, "nodebug"},
  92         {Opt_upgrade, "upgrade"},
  93         {Opt_acl, "acl"},
  94         {Opt_noacl, "noacl"},
  95         {Opt_quota_off, "quota=off"},
  96         {Opt_quota_account, "quota=account"},
  97         {Opt_quota_on, "quota=on"},
  98         {Opt_quota, "quota"},
  99         {Opt_noquota, "noquota"},
 100         {Opt_suiddir, "suiddir"},
 101         {Opt_nosuiddir, "nosuiddir"},
 102         {Opt_data_writeback, "data=writeback"},
 103         {Opt_data_ordered, "data=ordered"},
 104         {Opt_meta, "meta"},
 105         {Opt_discard, "discard"},
 106         {Opt_nodiscard, "nodiscard"},
 107         {Opt_commit, "commit=%d"},
 108         {Opt_err_withdraw, "errors=withdraw"},
 109         {Opt_err_panic, "errors=panic"},
 110         {Opt_statfs_quantum, "statfs_quantum=%d"},
 111         {Opt_statfs_percent, "statfs_percent=%d"},
 112         {Opt_quota_quantum, "quota_quantum=%d"},
 113         {Opt_barrier, "barrier"},
 114         {Opt_nobarrier, "nobarrier"},
 115         {Opt_error, NULL}
 116 };
 117
 118 /**
 119  * gfs2_mount_args - Parse mount options
 120  * @args: The structure into which the parsed options will be written
 121  * @options: The options to parse
 122  *
 123  * Return: errno
 124  */
 125
 126 int gfs2_mount_args(struct gfs2_args *args, char *options)
 127 {
 128         char *o;
 129         int token;
 130         substring_t tmp[MAX_OPT_ARGS];
 131         int rv;
 132
 133         /* Split the options into tokens with the "," character and
 134            process them */
 135
 136         while (1) {
 137                 o = strsep(&options, ",");
 138                 if (o == NULL)
 139                         break;
 140                 if (*o == '\0')
 141                         continue;
 142
 143                 token = match_token(o, tokens, tmp);
 144                 switch (token) {
 145                 case Opt_lockproto:
 146                         match_strlcpy(args->ar_lockproto, &tmp[0],
 147                                       GFS2_LOCKNAME_LEN);
 148                         break;
 149                 case Opt_locktable:
 150                         match_strlcpy(args->ar_locktable, &tmp[0],
 151                                       GFS2_LOCKNAME_LEN);
 152                         break;
 153                 case Opt_hostdata:
 154                         match_strlcpy(args->ar_hostdata, &tmp[0],
 155                                       GFS2_LOCKNAME_LEN);
 156                         break;
 157                 case Opt_spectator:
 158                         args->ar_spectator = 1;
 159                         break;
 160                 case Opt_ignore_local_fs:
 161                         args->ar_ignore_local_fs = 1;
 162                         break;
 163                 case Opt_localflocks:
 164                         args->ar_localflocks = 1;
 165                         break;
 166                 case Opt_localcaching:
 167                         args->ar_localcaching = 1;
 168                         break;
 169                 case Opt_debug:
 170                         if (args->ar_errors == GFS2_ERRORS_PANIC) {
 171                                 printk(KERN_WARNING "GFS2: -o debug and -o errors=panic "
 172                                        "are mutually exclusive.\n");
 173                                 return -EINVAL;
 174                         }
 175                         args->ar_debug = 1;
 176                         break;
 177                 case Opt_nodebug:
 178                         args->ar_debug = 0;
 179                         break;
 180                 case Opt_upgrade:
 181                         args->ar_upgrade = 1;
 182                         break;
 183                 case Opt_acl:
 184                         args->ar_posix_acl = 1;
 185                         break;
 186                 case Opt_noacl:
 187                         args->ar_posix_acl = 0;
 188                         break;
 189                 case Opt_quota_off:
 190                 case Opt_noquota:
 191                         args->ar_quota = GFS2_QUOTA_OFF;
 192                         break;
 193                 case Opt_quota_account:
 194                         args->ar_quota = GFS2_QUOTA_ACCOUNT;
 195                         break;
 196                 case Opt_quota_on:
 197                 case Opt_quota:
 198                         args->ar_quota = GFS2_QUOTA_ON;
 199                         break;
 200                 case Opt_suiddir:
 201                         args->ar_suiddir = 1;
 202                         break;
 203                 case Opt_nosuiddir:
 204                         args->ar_suiddir = 0;
 205                         break;
 206                 case Opt_data_writeback:
 207                         args->ar_data = GFS2_DATA_WRITEBACK;
 208                         break;
 209                 case Opt_data_ordered:
 210                         args->ar_data = GFS2_DATA_ORDERED;
 211                         break;
 212                 case Opt_meta:
 213                         args->ar_meta = 1;
 214                         break;
 215                 case Opt_discard:
 216                         args->ar_discard = 1;
 217                         break;
 218                 case Opt_nodiscard:
 219                         args->ar_discard = 0;
 220                         break;
 221                 case Opt_commit:
 222                         rv = match_int(&tmp[0], &args->ar_commit);
 223                         if (rv || args->ar_commit <= 0) {
 224                                 printk(KERN_WARNING "GFS2: commit mount option requires a positive numeric argument\n");
 225                                 return rv ? rv : -EINVAL;
 226                         }
 227                         break;
 228                 case Opt_statfs_quantum:
 229                         rv = match_int(&tmp[0], &args->ar_statfs_quantum);
 230                         if (rv || args->ar_statfs_quantum < 0) {
 231                                 printk(KERN_WARNING "GFS2: statfs_quantum mount option requires a non-negative numeric argument\n");
 232                                 return rv ? rv : -EINVAL;
 233                         }
 234                         break;
 235                 case Opt_quota_quantum:
 236                         rv = match_int(&tmp[0], &args->ar_quota_quantum);
 237                         if (rv || args->ar_quota_quantum <= 0) {
 238                                 printk(KERN_WARNING "GFS2: quota_quantum mount option requires a positive numeric argument\n");
 239                                 return rv ? rv : -EINVAL;
 240                         }
 241                         break;
 242                 case Opt_statfs_percent:
 243                         rv = match_int(&tmp[0], &args->ar_statfs_percent);
 244                         if (rv || args->ar_statfs_percent < 0 ||
 245                             args->ar_statfs_percent > 100) {
 246                                 printk(KERN_WARNING "statfs_percent mount option requires a numeric argument between 0 and 100\n");
 247                                 return rv ? rv : -EINVAL;
 248                         }
 249                         break;
 250                 case Opt_err_withdraw:
 251                         args->ar_errors = GFS2_ERRORS_WITHDRAW;
 252                         break;
 253                 case Opt_err_panic:
 254                         if (args->ar_debug) {
 255                                 printk(KERN_WARNING "GFS2: -o debug and -o errors=panic "
 256                                         "are mutually exclusive.\n");
 257                                 return -EINVAL;
 258                         }
 259                         args->ar_errors = GFS2_ERRORS_PANIC;
 260                         break;
 261                 case Opt_barrier:
 262                         args->ar_nobarrier = 0;
 263                         break;
 264                 case Opt_nobarrier:
 265                         args->ar_nobarrier = 1;
 266                         break;
 267                 case Opt_error:
 268                 default:
 269                         printk(KERN_WARNING "GFS2: invalid mount option: %s\n", o);
 270                         return -EINVAL;
 271                 }
 272         }
 273
 274         return 0;
 275 }
 276
 277 /**
 278  * gfs2_jindex_free - Clear all the journal index information
 279  * @sdp: The GFS2 superblock
 280  *
 281  */
 282
 283 void gfs2_jindex_free(struct gfs2_sbd *sdp)
 284 {
 285         struct list_head list, *head;
 286         struct gfs2_jdesc *jd;
 287         struct gfs2_journal_extent *jext;
 288
 289         spin_lock(&sdp->sd_jindex_spin);
 290         list_add(&list, &sdp->sd_jindex_list);
 291         list_del_init(&sdp->sd_jindex_list);
 292         sdp->sd_journals = 0;
 293         spin_unlock(&sdp->sd_jindex_spin);
 294
 295         while (!list_empty(&list)) {
 296                 jd = list_entry(list.next, struct gfs2_jdesc, jd_list);
 297                 head = &jd->extent_list;
 298                 while (!list_empty(head)) {
 299                         jext = list_entry(head->next,
 300                                           struct gfs2_journal_extent,
 301                                           extent_list);
 302                         list_del(&jext->extent_list);
 303                         kfree(jext);
 304                 }
 305                 list_del(&jd->jd_list);
 306                 iput(jd->jd_inode);
 307                 kfree(jd);
 308         }
 309 }
 310
 311 static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid)
 312 {
 313         struct gfs2_jdesc *jd;
 314         int found = 0;
 315
 316         list_for_each_entry(jd, head, jd_list) {
 317                 if (jd->jd_jid == jid) {
 318                         found = 1;
 319                         break;
 320                 }
 321         }
 322
 323         if (!found)
 324                 jd = NULL;
 325
 326         return jd;
 327 }
 328
 329 struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid)
 330 {
 331         struct gfs2_jdesc *jd;
 332
 333         spin_lock(&sdp->sd_jindex_spin);
 334         jd = jdesc_find_i(&sdp->sd_jindex_list, jid);
 335         spin_unlock(&sdp->sd_jindex_spin);
 336
 337         return jd;
 338 }
 339
 340 int gfs2_jdesc_check(struct gfs2_jdesc *jd)
 341 {
 342         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
 343         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
 344         int ar;
 345         int error;
 346
 347         if (ip->i_disksize < (8 << 20) || ip->i_disksize > (1 << 30) ||
 348             (ip->i_disksize & (sdp->sd_sb.sb_bsize - 1))) {
 349                 gfs2_consist_inode(ip);
 350                 return -EIO;
 351         }
 352         jd->jd_blocks = ip->i_disksize >> sdp->sd_sb.sb_bsize_shift;
 353
 354         error = gfs2_write_alloc_required(ip, 0, ip->i_disksize, &ar);
 355         if (!error && ar) {
 356                 gfs2_consist_inode(ip);
 357                 error = -EIO;
 358         }
 359
 360         return error;
 361 }
 362
 363 /**
 364  * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
 365  * @sdp: the filesystem
 366  *
 367  * Returns: errno
 368  */
 369
 370 int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
 371 {
 372         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
 373         struct gfs2_glock *j_gl = ip->i_gl;
 374         struct gfs2_holder t_gh;
 375         struct gfs2_log_header_host head;
 376         int error;
 377
 378         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &t_gh);
 379         if (error)
 380                 return error;
 381
 382         j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
 383
 384         error = gfs2_find_jhead(sdp->sd_jdesc, &head);
 385         if (error)
 386                 goto fail;
 387
 388         if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
 389                 gfs2_consist(sdp);
 390                 error = -EIO;
 391                 goto fail;
 392         }
 393
 394         /*  Initialize some head of the log stuff  */
 395         sdp->sd_log_sequence = head.lh_sequence + 1;
 396         gfs2_log_pointers_init(sdp, head.lh_blkno);
 397
 398         error = gfs2_quota_init(sdp);
 399         if (error)
 400                 goto fail;
 401
 402         set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 403
 404         gfs2_glock_dq_uninit(&t_gh);
 405
 406         return 0;
 407
 408 fail:
 409         t_gh.gh_flags |= GL_NOCACHE;
 410         gfs2_glock_dq_uninit(&t_gh);
 411
 412         return error;
 413 }
 414
 415 void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
 416 {
 417         const struct gfs2_statfs_change *str = buf;
 418
 419         sc->sc_total = be64_to_cpu(str->sc_total);
 420         sc->sc_free = be64_to_cpu(str->sc_free);
 421         sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
 422 }
 423
 424 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
 425 {
 426         struct gfs2_statfs_change *str = buf;
 427
 428         str->sc_total = cpu_to_be64(sc->sc_total);
 429         str->sc_free = cpu_to_be64(sc->sc_free);
 430         str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
 431 }
 432
 433 int gfs2_statfs_init(struct gfs2_sbd *sdp)
 434 {
 435         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
 436         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 437         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 438         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 439         struct buffer_head *m_bh, *l_bh;
 440         struct gfs2_holder gh;
 441         int error;
 442
 443         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
 444                                    &gh);
 445         if (error)
 446                 return error;
 447
 448         error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 449         if (error)
 450                 goto out;
 451
 452         if (sdp->sd_args.ar_spectator) {
 453                 spin_lock(&sdp->sd_statfs_spin);
 454                 gfs2_statfs_change_in(m_sc, m_bh->b_data +
 455                                       sizeof(struct gfs2_dinode));
 456                 spin_unlock(&sdp->sd_statfs_spin);
 457         } else {
 458                 error = gfs2_meta_inode_buffer(l_ip, &l_bh);
 459                 if (error)
 460                         goto out_m_bh;
 461
 462                 spin_lock(&sdp->sd_statfs_spin);
 463                 gfs2_statfs_change_in(m_sc, m_bh->b_data +
 464                                       sizeof(struct gfs2_dinode));
 465                 gfs2_statfs_change_in(l_sc, l_bh->b_data +
 466                                       sizeof(struct gfs2_dinode));
 467                 spin_unlock(&sdp->sd_statfs_spin);
 468
 469                 brelse(l_bh);
 470         }
 471
 472 out_m_bh:
 473         brelse(m_bh);
 474 out:
 475         gfs2_glock_dq_uninit(&gh);
 476         return 0;
 477 }
 478
 479 void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
 480                         s64 dinodes)
 481 {
 482         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 483         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 484         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 485         struct buffer_head *l_bh;
 486         s64 x, y;
 487         int need_sync = 0;
 488         int error;
 489
 490         error = gfs2_meta_inode_buffer(l_ip, &l_bh);
 491         if (error)
 492                 return;
 493
 494         gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
 495
 496         spin_lock(&sdp->sd_statfs_spin);
 497         l_sc->sc_total += total;
 498         l_sc->sc_free += free;
 499         l_sc->sc_dinodes += dinodes;
 500         gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));
 501         if (sdp->sd_args.ar_statfs_percent) {
 502                 x = 100 * l_sc->sc_free;
 503                 y = m_sc->sc_free * sdp->sd_args.ar_statfs_percent;
 504                 if (x >= y || x <= -y)
 505                         need_sync = 1;
 506         }
 507         spin_unlock(&sdp->sd_statfs_spin);
 508
 509         brelse(l_bh);
 510         if (need_sync)
 511                 gfs2_wake_up_statfs(sdp);
 512 }
 513
 514 void update_statfs(struct gfs2_sbd *sdp, struct buffer_head *m_bh,
 515                    struct buffer_head *l_bh)
 516 {
 517         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
 518         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 519         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 520         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 521
 522         gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
 523
 524         spin_lock(&sdp->sd_statfs_spin);
 525         m_sc->sc_total += l_sc->sc_total;
 526         m_sc->sc_free += l_sc->sc_free;
 527         m_sc->sc_dinodes += l_sc->sc_dinodes;
 528         memset(l_sc, 0, sizeof(struct gfs2_statfs_change));
 529         memset(l_bh->b_data + sizeof(struct gfs2_dinode),
 530                0, sizeof(struct gfs2_statfs_change));
 531         spin_unlock(&sdp->sd_statfs_spin);
 532
 533         gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
 534         gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode));
 535 }
 536
 537 int gfs2_statfs_sync(struct super_block *sb, int type)
 538 {
 539         struct gfs2_sbd *sdp = sb->s_fs_info;
 540         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
 541         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 542         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 543         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 544         struct gfs2_holder gh;
 545         struct buffer_head *m_bh, *l_bh;
 546         int error;
 547
 548         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
 549                                    &gh);
 550         if (error)
 551                 return error;
 552
 553         error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 554         if (error)
 555                 goto out;
 556
 557         spin_lock(&sdp->sd_statfs_spin);
 558         gfs2_statfs_change_in(m_sc, m_bh->b_data +
 559                               sizeof(struct gfs2_dinode));
 560         if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {
 561                 spin_unlock(&sdp->sd_statfs_spin);
 562                 goto out_bh;
 563         }
 564         spin_unlock(&sdp->sd_statfs_spin);
 565
 566         error = gfs2_meta_inode_buffer(l_ip, &l_bh);
 567         if (error)
 568                 goto out_bh;
 569
 570         error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
 571         if (error)
 572                 goto out_bh2;
 573
 574         update_statfs(sdp, m_bh, l_bh);
 575         sdp->sd_statfs_force_sync = 0;
 576
 577         gfs2_trans_end(sdp);
 578
 579 out_bh2:
 580         brelse(l_bh);
 581 out_bh:
 582         brelse(m_bh);
 583 out:
 584         gfs2_glock_dq_uninit(&gh);
 585         return error;
 586 }
 587
 588 struct lfcc {
 589         struct list_head list;
 590         struct gfs2_holder gh;
 591 };
 592
 593 /**
 594  * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
 595  *                            journals are clean
 596  * @sdp: the file system
 597  * @state: the state to put the transaction lock into
 598  * @t_gh: the hold on the transaction lock
 599  *
 600  * Returns: errno
 601  */
 602
 603 static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
 604                                     struct gfs2_holder *t_gh)
 605 {
 606         struct gfs2_inode *ip;
 607         struct gfs2_jdesc *jd;
 608         struct lfcc *lfcc;
 609         LIST_HEAD(list);
 610         struct gfs2_log_header_host lh;
 611         int error;
 612
 613         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
 614                 lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
 615                 if (!lfcc) {
 616                         error = -ENOMEM;
 617                         goto out;
 618                 }
 619                 ip = GFS2_I(jd->jd_inode);
 620                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh);
 621                 if (error) {
 622                         kfree(lfcc);
 623                         goto out;
 624                 }
 625                 list_add(&lfcc->list, &list);
 626         }
 627
 628         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,
 629                                    GL_NOCACHE, t_gh);
 630
 631         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
 632                 error = gfs2_jdesc_check(jd);
 633                 if (error)
 634                         break;
 635                 error = gfs2_find_jhead(jd, &lh);
 636                 if (error)
 637                         break;
 638                 if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
 639                         error = -EBUSY;
 640                         break;
 641                 }
 642         }
 643
 644         if (error)
 645                 gfs2_glock_dq_uninit(t_gh);
 646
 647 out:
 648         while (!list_empty(&list)) {
 649                 lfcc = list_entry(list.next, struct lfcc, list);
 650                 list_del(&lfcc->list);
 651                 gfs2_glock_dq_uninit(&lfcc->gh);
 652                 kfree(lfcc);
 653         }
 654         return error;
 655 }
 656
 657 /**
 658  * gfs2_freeze_fs - freezes the file system
 659  * @sdp: the file system
 660  *
 661  * This function flushes data and meta data for all machines by
 662  * aquiring the transaction log exclusively.  All journals are
 663  * ensured to be in a clean state as well.
 664  *
 665  * Returns: errno
 666  */
 667
 668 int gfs2_freeze_fs(struct gfs2_sbd *sdp)
 669 {
 670         int error = 0;
 671
 672         mutex_lock(&sdp->sd_freeze_lock);
 673
 674         if (!sdp->sd_freeze_count++) {
 675                 error = gfs2_lock_fs_check_clean(sdp, &sdp->sd_freeze_gh);
 676                 if (error)
 677                         sdp->sd_freeze_count--;
 678         }
 679
 680         mutex_unlock(&sdp->sd_freeze_lock);
 681
 682         return error;
 683 }
 684
 685 /**
 686  * gfs2_unfreeze_fs - unfreezes the file system
 687  * @sdp: the file system
 688  *
 689  * This function allows the file system to proceed by unlocking
 690  * the exclusively held transaction lock.  Other GFS2 nodes are
 691  * now free to acquire the lock shared and go on with their lives.
 692  *
 693  */
 694
 695 void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)
 696 {
 697         mutex_lock(&sdp->sd_freeze_lock);
 698
 699         if (sdp->sd_freeze_count && !--sdp->sd_freeze_count)
 700                 gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
 701
 702         mutex_unlock(&sdp->sd_freeze_lock);
 703 }
 704
 705
 706 /**
 707  * gfs2_write_inode - Make sure the inode is stable on the disk
 708  * @inode: The inode
 709  * @sync: synchronous write flag
 710  *
 711  * Returns: errno
 712  */
 713
 714 static int gfs2_write_inode(struct inode *inode, int sync)
 715 {
 716         struct gfs2_inode *ip = GFS2_I(inode);
 717         struct gfs2_sbd *sdp = GFS2_SB(inode);
 718         struct gfs2_holder gh;
 719         struct buffer_head *bh;
 720         struct timespec atime;
 721         struct gfs2_dinode *di;
 722         int ret = 0;
 723
 724         /* Check this is a "normal" inode, etc */
 725         if (!test_bit(GIF_USER, &ip->i_flags) ||
 726             (current->flags & PF_MEMALLOC))
 727                 return 0;
 728         ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 729         if (ret)
 730                 goto do_flush;
 731         ret = gfs2_trans_begin(sdp, RES_DINODE, 0);
 732         if (ret)
 733                 goto do_unlock;
 734         ret = gfs2_meta_inode_buffer(ip, &bh);
 735         if (ret == 0) {
 736                 di = (struct gfs2_dinode *)bh->b_data;
 737                 atime.tv_sec = be64_to_cpu(di->di_atime);
 738                 atime.tv_nsec = be32_to_cpu(di->di_atime_nsec);
 739                 if (timespec_compare(&inode->i_atime, &atime) > 0) {
 740                         gfs2_trans_add_bh(ip->i_gl, bh, 1);
 741                         gfs2_dinode_out(ip, bh->b_data);
 742                 }
 743                 brelse(bh);
 744         }
 745         gfs2_trans_end(sdp);
 746 do_unlock:
 747         gfs2_glock_dq_uninit(&gh);
 748 do_flush:
 749         if (sync != 0)
 750                 gfs2_log_flush(GFS2_SB(inode), ip->i_gl);
 751         return ret;
 752 }
 753
 754 /**
 755  * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
 756  * @sdp: the filesystem
 757  *
 758  * Returns: errno
 759  */
 760
 761 static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
 762 {
 763         struct gfs2_holder t_gh;
 764         int error;
 765
 766         flush_workqueue(gfs2_delete_workqueue);
 767         gfs2_quota_sync(sdp->sd_vfs, 0);
 768         gfs2_statfs_sync(sdp->sd_vfs, 0);
 769
 770         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,
 771                                    &t_gh);
 772         if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
 773                 return error;
 774
 775         gfs2_meta_syncfs(sdp);
 776         gfs2_log_shutdown(sdp);
 777
 778         clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 779
 780         if (t_gh.gh_gl)
 781                 gfs2_glock_dq_uninit(&t_gh);
 782
 783         gfs2_quota_cleanup(sdp);
 784
 785         return error;
 786 }
 787
 788 static int gfs2_umount_recovery_wait(void *word)
 789 {
 790         schedule();
 791         return 0;
 792 }
 793
 794 /**
 795  * gfs2_put_super - Unmount the filesystem
 796  * @sb: The VFS superblock
 797  *
 798  */
 799
 800 static void gfs2_put_super(struct super_block *sb)
 801 {
 802         struct gfs2_sbd *sdp = sb->s_fs_info;
 803         int error;
 804         struct gfs2_jdesc *jd;
 805
 806         /*  Unfreeze the filesystem, if we need to  */
 807
 808         mutex_lock(&sdp->sd_freeze_lock);
 809         if (sdp->sd_freeze_count)
 810                 gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
 811         mutex_unlock(&sdp->sd_freeze_lock);
 812
 813         /* No more recovery requests */
 814         set_bit(SDF_NORECOVERY, &sdp->sd_flags);
 815         smp_mb();
 816
 817         /* Wait on outstanding recovery */
 818 restart:
 819         spin_lock(&sdp->sd_jindex_spin);
 820         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
 821                 if (!test_bit(JDF_RECOVERY, &jd->jd_flags))
 822                         continue;
 823                 spin_unlock(&sdp->sd_jindex_spin);
 824                 wait_on_bit(&jd->jd_flags, JDF_RECOVERY,
 825                             gfs2_umount_recovery_wait, TASK_UNINTERRUPTIBLE);
 826                 goto restart;
 827         }
 828         spin_unlock(&sdp->sd_jindex_spin);
 829
 830         kthread_stop(sdp->sd_quotad_process);
 831         kthread_stop(sdp->sd_logd_process);
 832
 833         if (!(sb->s_flags & MS_RDONLY)) {
 834                 error = gfs2_make_fs_ro(sdp);
 835                 if (error)
 836                         gfs2_io_error(sdp);
 837         }
 838         /*  At this point, we're through modifying the disk  */
 839
 840         /*  Release stuff  */
 841
 842         iput(sdp->sd_jindex);
 843         iput(sdp->sd_statfs_inode);
 844         iput(sdp->sd_rindex);
 845         iput(sdp->sd_quota_inode);
 846
 847         gfs2_glock_put(sdp->sd_rename_gl);
 848         gfs2_glock_put(sdp->sd_trans_gl);
 849
 850         if (!sdp->sd_args.ar_spectator) {
 851                 gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
 852                 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
 853                 gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
 854                 gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
 855                 iput(sdp->sd_sc_inode);
 856                 iput(sdp->sd_qc_inode);
 857         }
 858
 859         gfs2_glock_dq_uninit(&sdp->sd_live_gh);
 860         gfs2_clear_rgrpd(sdp);
 861         gfs2_jindex_free(sdp);
 862         /*  Take apart glock structures and buffer lists  */
 863         gfs2_gl_hash_clear(sdp);
 864         /*  Unmount the locking protocol  */
 865         gfs2_lm_unmount(sdp);
 866
 867         /*  At this point, we're through participating in the lockspace  */
 868         gfs2_sys_fs_del(sdp);
 869 }
 870
 871 /**
 872  * gfs2_sync_fs - sync the filesystem
 873  * @sb: the superblock
 874  *
 875  * Flushes the log to disk.
 876  */
 877
 878 static int gfs2_sync_fs(struct super_block *sb, int wait)
 879 {
 880         if (wait && sb->s_fs_info)
 881                 gfs2_log_flush(sb->s_fs_info, NULL);
 882         return 0;
 883 }
 884
 885 /**
 886  * gfs2_freeze - prevent further writes to the filesystem
 887  * @sb: the VFS structure for the filesystem
 888  *
 889  */
 890
 891 static int gfs2_freeze(struct super_block *sb)
 892 {
 893         struct gfs2_sbd *sdp = sb->s_fs_info;
 894         int error;
 895
 896         if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
 897                 return -EINVAL;
 898
 899         for (;;) {
 900                 error = gfs2_freeze_fs(sdp);
 901                 if (!error)
 902                         break;
 903
 904                 switch (error) {
 905                 case -EBUSY:
 906                         fs_err(sdp, "waiting for recovery before freeze\n");
 907                         break;
 908
 909                 default:
 910                         fs_err(sdp, "error freezing FS: %d\n", error);
 911                         break;
 912                 }
 913
 914                 fs_err(sdp, "retrying...\n");
 915                 msleep(1000);
 916         }
 917         return 0;
 918 }
 919
 920 /**
 921  * gfs2_unfreeze - reallow writes to the filesystem
 922  * @sb: the VFS structure for the filesystem
 923  *
 924  */
 925
 926 static int gfs2_unfreeze(struct super_block *sb)
 927 {
 928         gfs2_unfreeze_fs(sb->s_fs_info);
 929         return 0;
 930 }
 931
 932 /**
 933  * statfs_fill - fill in the sg for a given RG
 934  * @rgd: the RG
 935  * @sc: the sc structure
 936  *
 937  * Returns: 0 on success, -ESTALE if the LVB is invalid
 938  */
 939
 940 static int statfs_slow_fill(struct gfs2_rgrpd *rgd,
 941                             struct gfs2_statfs_change_host *sc)
 942 {
 943         gfs2_rgrp_verify(rgd);
 944         sc->sc_total += rgd->rd_data;
 945         sc->sc_free += rgd->rd_free;
 946         sc->sc_dinodes += rgd->rd_dinodes;
 947         return 0;
 948 }
 949
 950 /**
 951  * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
 952  * @sdp: the filesystem
 953  * @sc: the sc info that will be returned
 954  *
 955  * Any error (other than a signal) will cause this routine to fall back
 956  * to the synchronous version.
 957  *
 958  * FIXME: This really shouldn't busy wait like this.
 959  *
 960  * Returns: errno
 961  */
 962
 963 static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)
 964 {
 965         struct gfs2_holder ri_gh;
 966         struct gfs2_rgrpd *rgd_next;
 967         struct gfs2_holder *gha, *gh;
 968         unsigned int slots = 64;
 969         unsigned int x;
 970         int done;
 971         int error = 0, err;
 972
 973         memset(sc, 0, sizeof(struct gfs2_statfs_change_host));
 974         gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);
 975         if (!gha)
 976                 return -ENOMEM;
 977
 978         error = gfs2_rindex_hold(sdp, &ri_gh);
 979         if (error)
 980                 goto out;
 981
 982         rgd_next = gfs2_rgrpd_get_first(sdp);
 983
 984         for (;;) {
 985                 done = 1;
 986
 987                 for (x = 0; x < slots; x++) {
 988                         gh = gha + x;
 989
 990                         if (gh->gh_gl && gfs2_glock_poll(gh)) {
 991                                 err = gfs2_glock_wait(gh);
 992                                 if (err) {
 993                                         gfs2_holder_uninit(gh);
 994                                         error = err;
 995                                 } else {
 996                                         if (!error)
 997                                                 error = statfs_slow_fill(
 998                                                         gh->gh_gl->gl_object, sc);
 999                                         gfs2_glock_dq_uninit(gh);
1000                                 }
1001                         }
1002
1003                         if (gh->gh_gl)
1004                                 done = 0;
1005                         else if (rgd_next && !error) {
1006                                 error = gfs2_glock_nq_init(rgd_next->rd_gl,
1007                                                            LM_ST_SHARED,
1008                                                            GL_ASYNC,
1009                                                            gh);
1010                                 rgd_next = gfs2_rgrpd_get_next(rgd_next);
1011                                 done = 0;
1012                         }
1013
1014                         if (signal_pending(current))
1015                                 error = -ERESTARTSYS;
1016                 }
1017
1018                 if (done)
1019                         break;
1020
1021                 yield();
1022         }
1023
1024         gfs2_glock_dq_uninit(&ri_gh);
1025
1026 out:
1027         kfree(gha);
1028         return error;
1029 }
1030
1031 /**
1032  * gfs2_statfs_i - Do a statfs
1033  * @sdp: the filesystem
1034  * @sg: the sg structure
1035  *
1036  * Returns: errno
1037  */
1038
1039 static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)
1040 {
1041         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
1042         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
1043
1044         spin_lock(&sdp->sd_statfs_spin);
1045
1046         *sc = *m_sc;
1047         sc->sc_total += l_sc->sc_total;
1048         sc->sc_free += l_sc->sc_free;
1049         sc->sc_dinodes += l_sc->sc_dinodes;
1050
1051         spin_unlock(&sdp->sd_statfs_spin);
1052
1053         if (sc->sc_free < 0)
1054                 sc->sc_free = 0;
1055         if (sc->sc_free > sc->sc_total)
1056                 sc->sc_free = sc->sc_total;
1057         if (sc->sc_dinodes < 0)
1058                 sc->sc_dinodes = 0;
1059
1060         return 0;
1061 }
1062
1063 /**
1064  * gfs2_statfs - Gather and return stats about the filesystem
1065  * @sb: The superblock
1066  * @statfsbuf: The buffer
1067  *
1068  * Returns: 0 on success or error code
1069  */
1070
1071 static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
1072 {
1073         struct super_block *sb = dentry->d_inode->i_sb;
1074         struct gfs2_sbd *sdp = sb->s_fs_info;
1075         struct gfs2_statfs_change_host sc;
1076         int error;
1077
1078         if (gfs2_tune_get(sdp, gt_statfs_slow))
1079                 error = gfs2_statfs_slow(sdp, &sc);
1080         else
1081                 error = gfs2_statfs_i(sdp, &sc);
1082
1083         if (error)
1084                 return error;
1085
1086         buf->f_type = GFS2_MAGIC;
1087         buf->f_bsize = sdp->sd_sb.sb_bsize;
1088         buf->f_blocks = sc.sc_total;
1089         buf->f_bfree = sc.sc_free;
1090         buf->f_bavail = sc.sc_free;
1091         buf->f_files = sc.sc_dinodes + sc.sc_free;
1092         buf->f_ffree = sc.sc_free;
1093         buf->f_namelen = GFS2_FNAMESIZE;
1094
1095         return 0;
1096 }
1097
1098 /**
1099  * gfs2_remount_fs - called when the FS is remounted
1100  * @sb:  the filesystem
1101  * @flags:  the remount flags
1102  * @data:  extra data passed in (not used right now)
1103  *
1104  * Returns: errno
1105  */
1106
1107 static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
1108 {
1109         struct gfs2_sbd *sdp = sb->s_fs_info;
1110         struct gfs2_args args = sdp->sd_args; /* Default to current settings */
1111         struct gfs2_tune *gt = &sdp->sd_tune;
1112         int error;
1113
1114         spin_lock(&gt->gt_spin);
1115         args.ar_commit = gt->gt_log_flush_secs;
1116         args.ar_quota_quantum = gt->gt_quota_quantum;
1117         if (gt->gt_statfs_slow)
1118                 args.ar_statfs_quantum = 0;
1119         else
1120                 args.ar_statfs_quantum = gt->gt_statfs_quantum;
1121         spin_unlock(&gt->gt_spin);
1122         error = gfs2_mount_args(&args, data);
1123         if (error)
1124                 return error;
1125
1126         /* Not allowed to change locking details */
1127         if (strcmp(args.ar_lockproto, sdp->sd_args.ar_lockproto) ||
1128             strcmp(args.ar_locktable, sdp->sd_args.ar_locktable) ||
1129             strcmp(args.ar_hostdata, sdp->sd_args.ar_hostdata))
1130                 return -EINVAL;
1131
1132         /* Some flags must not be changed */
1133         if (args_neq(&args, &sdp->sd_args, spectator) ||
1134             args_neq(&args, &sdp->sd_args, ignore_local_fs) ||
1135             args_neq(&args, &sdp->sd_args, localflocks) ||
1136             args_neq(&args, &sdp->sd_args, localcaching) ||
1137             args_neq(&args, &sdp->sd_args, meta))
1138                 return -EINVAL;
1139
1140         if (sdp->sd_args.ar_spectator)
1141                 *flags |= MS_RDONLY;
1142
1143         if ((sb->s_flags ^ *flags) & MS_RDONLY) {
1144                 if (*flags & MS_RDONLY)
1145                         error = gfs2_make_fs_ro(sdp);
1146                 else
1147                         error = gfs2_make_fs_rw(sdp);
1148                 if (error)
1149                         return error;
1150         }
1151
1152         sdp->sd_args = args;
1153         if (sdp->sd_args.ar_posix_acl)
1154                 sb->s_flags |= MS_POSIXACL;
1155         else
1156                 sb->s_flags &= ~MS_POSIXACL;
1157         if (sdp->sd_args.ar_nobarrier)
1158                 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1159         else
1160                 clear_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1161         spin_lock(&gt->gt_spin);
1162         gt->gt_log_flush_secs = args.ar_commit;
1163         gt->gt_quota_quantum = args.ar_quota_quantum;
1164         if (args.ar_statfs_quantum) {
1165                 gt->gt_statfs_slow = 0;
1166                 gt->gt_statfs_quantum = args.ar_statfs_quantum;
1167         }
1168         else {
1169                 gt->gt_statfs_slow = 1;
1170                 gt->gt_statfs_quantum = 30;
1171         }
1172         spin_unlock(&gt->gt_spin);
1173
1174         gfs2_online_uevent(sdp);
1175         return 0;
1176 }
1177
1178 /**
1179  * gfs2_drop_inode - Drop an inode (test for remote unlink)
1180  * @inode: The inode to drop
1181  *
1182  * If we've received a callback on an iopen lock then its because a
1183  * remote node tried to deallocate the inode but failed due to this node
1184  * still having the inode open. Here we mark the link count zero
1185  * since we know that it must have reached zero if the GLF_DEMOTE flag
1186  * is set on the iopen glock. If we didn't do a disk read since the
1187  * remote node removed the final link then we might otherwise miss
1188  * this event. This check ensures that this node will deallocate the
1189  * inode's blocks, or alternatively pass the baton on to another
1190  * node for later deallocation.
1191  */
1192
1193 static void gfs2_drop_inode(struct inode *inode)
1194 {
1195         struct gfs2_inode *ip = GFS2_I(inode);
1196
1197         if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {
1198                 struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
1199                 if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
1200                         clear_nlink(inode);
1201         }
1202         generic_drop_inode(inode);
1203 }
1204
1205 /**
1206  * gfs2_clear_inode - Deallocate an inode when VFS is done with it
1207  * @inode: The VFS inode
1208  *
1209  */
1210
1211 static void gfs2_clear_inode(struct inode *inode)
1212 {
1213         struct gfs2_inode *ip = GFS2_I(inode);
1214
1215         /* This tells us its a "real" inode and not one which only
1216          * serves to contain an address space (see rgrp.c, meta_io.c)
1217          * which therefore doesn't have its own glocks.
1218          */
1219         if (test_bit(GIF_USER, &ip->i_flags)) {
1220                 ip->i_gl->gl_object = NULL;
1221                 gfs2_glock_put(ip->i_gl);
1222                 ip->i_gl = NULL;
1223                 if (ip->i_iopen_gh.gh_gl) {
1224                         ip->i_iopen_gh.gh_gl->gl_object = NULL;
1225                         gfs2_glock_dq_uninit(&ip->i_iopen_gh);
1226                 }
1227         }
1228 }
1229
1230 static int is_ancestor(const struct dentry *d1, const struct dentry *d2)
1231 {
1232         do {
1233                 if (d1 == d2)
1234                         return 1;
1235                 d1 = d1->d_parent;
1236         } while (!IS_ROOT(d1));
1237         return 0;
1238 }
1239
1240 /**
1241  * gfs2_show_options - Show mount options for /proc/mounts
1242  * @s: seq_file structure
1243  * @mnt: vfsmount
1244  *
1245  * Returns: 0 on success or error code
1246  */
1247
1248 static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
1249 {
1250         struct gfs2_sbd *sdp = mnt->mnt_sb->s_fs_info;
1251         struct gfs2_args *args = &sdp->sd_args;
1252         int val;
1253
1254         if (is_ancestor(mnt->mnt_root, sdp->sd_master_dir))
1255                 seq_printf(s, ",meta");
1256         if (args->ar_lockproto[0])
1257                 seq_printf(s, ",lockproto=%s", args->ar_lockproto);
1258         if (args->ar_locktable[0])
1259                 seq_printf(s, ",locktable=%s", args->ar_locktable);
1260         if (args->ar_hostdata[0])
1261                 seq_printf(s, ",hostdata=%s", args->ar_hostdata);
1262         if (args->ar_spectator)
1263                 seq_printf(s, ",spectator");
1264         if (args->ar_ignore_local_fs)
1265                 seq_printf(s, ",ignore_local_fs");
1266         if (args->ar_localflocks)
1267                 seq_printf(s, ",localflocks");
1268         if (args->ar_localcaching)
1269                 seq_printf(s, ",localcaching");
1270         if (args->ar_debug)
1271                 seq_printf(s, ",debug");
1272         if (args->ar_upgrade)
1273                 seq_printf(s, ",upgrade");
1274         if (args->ar_posix_acl)
1275                 seq_printf(s, ",acl");
1276         if (args->ar_quota != GFS2_QUOTA_DEFAULT) {
1277                 char *state;
1278                 switch (args->ar_quota) {
1279                 case GFS2_QUOTA_OFF:
1280                         state = "off";
1281                         break;
1282                 case GFS2_QUOTA_ACCOUNT:
1283                         state = "account";
1284                         break;
1285                 case GFS2_QUOTA_ON:
1286                         state = "on";
1287                         break;
1288                 default:
1289                         state = "unknown";
1290                         break;
1291                 }
1292                 seq_printf(s, ",quota=%s", state);
1293         }
1294         if (args->ar_suiddir)
1295                 seq_printf(s, ",suiddir");
1296         if (args->ar_data != GFS2_DATA_DEFAULT) {
1297                 char *state;
1298                 switch (args->ar_data) {
1299                 case GFS2_DATA_WRITEBACK:
1300                         state = "writeback";
1301                         break;
1302                 case GFS2_DATA_ORDERED:
1303                         state = "ordered";
1304                         break;
1305                 default:
1306                         state = "unknown";
1307                         break;
1308                 }
1309                 seq_printf(s, ",data=%s", state);
1310         }
1311         if (args->ar_discard)
1312                 seq_printf(s, ",discard");
1313         val = sdp->sd_tune.gt_log_flush_secs;
1314         if (val != 60)
1315                 seq_printf(s, ",commit=%d", val);
1316         val = sdp->sd_tune.gt_statfs_quantum;
1317         if (val != 30)
1318                 seq_printf(s, ",statfs_quantum=%d", val);
1319         val = sdp->sd_tune.gt_quota_quantum;
1320         if (val != 60)
1321                 seq_printf(s, ",quota_quantum=%d", val);
1322         if (args->ar_statfs_percent)
1323                 seq_printf(s, ",statfs_percent=%d", args->ar_statfs_percent);
1324         if (args->ar_errors != GFS2_ERRORS_DEFAULT) {
1325                 const char *state;
1326
1327                 switch (args->ar_errors) {
1328                 case GFS2_ERRORS_WITHDRAW:
1329                         state = "withdraw";
1330                         break;
1331                 case GFS2_ERRORS_PANIC:
1332                         state = "panic";
1333                         break;
1334                 default:
1335                         state = "unknown";
1336                         break;
1337                 }
1338                 seq_printf(s, ",errors=%s", state);
1339         }
1340         if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags))
1341                 seq_printf(s, ",nobarrier");
1342
1343         return 0;
1344 }
1345
1346 /*
1347  * We have to (at the moment) hold the inodes main lock to cover
1348  * the gap between unlocking the shared lock on the iopen lock and
1349  * taking the exclusive lock. I'd rather do a shared -> exclusive
1350  * conversion on the iopen lock, but we can change that later. This
1351  * is safe, just less efficient.
1352  */
1353
1354 static void gfs2_delete_inode(struct inode *inode)
1355 {
1356         struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
1357         struct gfs2_inode *ip = GFS2_I(inode);
1358         struct gfs2_holder gh;
1359         int error;
1360
1361         if (!test_bit(GIF_USER, &ip->i_flags))
1362                 goto out;
1363
1364         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1365         if (unlikely(error)) {
1366                 gfs2_glock_dq_uninit(&ip->i_iopen_gh);
1367                 goto out;
1368         }
1369
1370         error = gfs2_check_blk_type(sdp, ip->i_no_addr, GFS2_BLKST_UNLINKED);
1371         if (error)
1372                 goto out_truncate;
1373
1374         gfs2_glock_dq_wait(&ip->i_iopen_gh);
1375         gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, &ip->i_iopen_gh);
1376         error = gfs2_glock_nq(&ip->i_iopen_gh);
1377         if (error)
1378                 goto out_truncate;
1379
1380         if (S_ISDIR(inode->i_mode) &&
1381             (ip->i_diskflags & GFS2_DIF_EXHASH)) {
1382                 error = gfs2_dir_exhash_dealloc(ip);
1383                 if (error)
1384                         goto out_unlock;
1385         }
1386
1387         if (ip->i_eattr) {
1388                 error = gfs2_ea_dealloc(ip);
1389                 if (error)
1390                         goto out_unlock;
1391         }
1392
1393         if (!gfs2_is_stuffed(ip)) {
1394                 error = gfs2_file_dealloc(ip);
1395                 if (error)
1396                         goto out_unlock;
1397         }
1398
1399         error = gfs2_dinode_dealloc(ip);
1400         if (error)
1401                 goto out_unlock;
1402
1403 out_truncate:
1404         error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
1405         if (error)
1406                 goto out_unlock;
1407         /* Needs to be done before glock release & also in a transaction */
1408         truncate_inode_pages(&inode->i_data, 0);
1409         gfs2_trans_end(sdp);
1410
1411 out_unlock:
1412         if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags))
1413                 gfs2_glock_dq(&ip->i_iopen_gh);
1414         gfs2_holder_uninit(&ip->i_iopen_gh);
1415         gfs2_glock_dq_uninit(&gh);
1416         if (error && error != GLR_TRYFAILED && error != -EROFS)
1417                 fs_warn(sdp, "gfs2_delete_inode: %d\n", error);
1418 out:
1419         truncate_inode_pages(&inode->i_data, 0);
1420         clear_inode(inode);
1421 }
1422
1423 static struct inode *gfs2_alloc_inode(struct super_block *sb)
1424 {
1425         struct gfs2_inode *ip;
1426
1427         ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
1428         if (ip) {
1429                 ip->i_flags = 0;
1430                 ip->i_gl = NULL;
1431         }
1432         return &ip->i_inode;
1433 }
1434
1435 static void gfs2_destroy_inode(struct inode *inode)
1436 {
1437         kmem_cache_free(gfs2_inode_cachep, inode);
1438 }
1439
1440 const struct super_operations gfs2_super_ops = {
1441         .alloc_inode            = gfs2_alloc_inode,
1442         .destroy_inode          = gfs2_destroy_inode,
1443         .write_inode            = gfs2_write_inode,
1444         .delete_inode           = gfs2_delete_inode,
1445         .put_super              = gfs2_put_super,
1446         .sync_fs                = gfs2_sync_fs,
1447         .freeze_fs              = gfs2_freeze,
1448         .unfreeze_fs            = gfs2_unfreeze,
1449         .statfs                 = gfs2_statfs,
1450         .remount_fs             = gfs2_remount_fs,
1451         .clear_inode            = gfs2_clear_inode,
1452         .drop_inode             = gfs2_drop_inode,
1453         .show_options           = gfs2_show_options,
1454 };
1455