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