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/blkdev.h> 16#include <linux/kthread.h> 17#include <linux/namei.h> 18#include <linux/mount.h> 19#include <linux/gfs2_ondisk.h> 20#include <linux/lm_interface.h> 21 22#include "gfs2.h" 23#include "incore.h" 24#include "daemon.h" 25#include "glock.h" 26#include "glops.h" 27#include "inode.h" 28#include "lm.h" 29#include "mount.h" 30#include "ops_export.h" 31#include "ops_fstype.h" 32#include "ops_super.h" 33#include "recovery.h" 34#include "rgrp.h" 35#include "super.h" 36#include "sys.h" 37#include "util.h" 38 39#define DO 0 40#define UNDO 1 41 42extern struct dentry_operations gfs2_dops; 43 44static struct gfs2_sbd *init_sbd(struct super_block *sb) 45{ 46 struct gfs2_sbd *sdp; 47 48 sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL); 49 if (!sdp) 50 return NULL; 51 52 sb->s_fs_info = sdp; 53 sdp->sd_vfs = sb; 54 55 gfs2_tune_init(&sdp->sd_tune); 56 57 INIT_LIST_HEAD(&sdp->sd_reclaim_list); 58 spin_lock_init(&sdp->sd_reclaim_lock); 59 init_waitqueue_head(&sdp->sd_reclaim_wq); 60 61 mutex_init(&sdp->sd_inum_mutex); 62 spin_lock_init(&sdp->sd_statfs_spin); 63 mutex_init(&sdp->sd_statfs_mutex); 64 65 spin_lock_init(&sdp->sd_rindex_spin); 66 mutex_init(&sdp->sd_rindex_mutex); 67 INIT_LIST_HEAD(&sdp->sd_rindex_list); 68 INIT_LIST_HEAD(&sdp->sd_rindex_mru_list); 69 INIT_LIST_HEAD(&sdp->sd_rindex_recent_list); 70 71 INIT_LIST_HEAD(&sdp->sd_jindex_list); 72 spin_lock_init(&sdp->sd_jindex_spin); 73 mutex_init(&sdp->sd_jindex_mutex); 74 75 INIT_LIST_HEAD(&sdp->sd_quota_list); 76 spin_lock_init(&sdp->sd_quota_spin); 77 mutex_init(&sdp->sd_quota_mutex); 78 79 spin_lock_init(&sdp->sd_log_lock); 80 81 INIT_LIST_HEAD(&sdp->sd_log_le_gl); 82 INIT_LIST_HEAD(&sdp->sd_log_le_buf); 83 INIT_LIST_HEAD(&sdp->sd_log_le_revoke); 84 INIT_LIST_HEAD(&sdp->sd_log_le_rg); 85 INIT_LIST_HEAD(&sdp->sd_log_le_databuf); 86 87 mutex_init(&sdp->sd_log_reserve_mutex); 88 INIT_LIST_HEAD(&sdp->sd_ail1_list); 89 INIT_LIST_HEAD(&sdp->sd_ail2_list); 90 91 init_rwsem(&sdp->sd_log_flush_lock); 92 INIT_LIST_HEAD(&sdp->sd_log_flush_list); 93 94 INIT_LIST_HEAD(&sdp->sd_revoke_list); 95 96 mutex_init(&sdp->sd_freeze_lock); 97 98 return sdp; 99} 100 101static void init_vfs(struct super_block *sb, unsigned noatime) 102{ 103 struct gfs2_sbd *sdp = sb->s_fs_info; 104 105 sb->s_magic = GFS2_MAGIC; 106 sb->s_op = &gfs2_super_ops; 107 sb->s_export_op = &gfs2_export_ops; 108 sb->s_maxbytes = MAX_LFS_FILESIZE; 109 110 if (sb->s_flags & (MS_NOATIME | MS_NODIRATIME)) 111 set_bit(noatime, &sdp->sd_flags); 112 113 /* Don't let the VFS update atimes. GFS2 handles this itself. */ 114 sb->s_flags |= MS_NOATIME | MS_NODIRATIME; 115} 116 117static int init_names(struct gfs2_sbd *sdp, int silent) 118{ 119 struct page *page; 120 char *proto, *table; 121 int error = 0; 122 123 proto = sdp->sd_args.ar_lockproto; 124 table = sdp->sd_args.ar_locktable; 125 126 /* Try to autodetect */ 127 128 if (!proto[0] || !table[0]) { 129 struct gfs2_sb *sb; 130 page = gfs2_read_super(sdp->sd_vfs, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift); 131 if (!page) 132 return -ENOBUFS; 133 sb = kmap(page); 134 gfs2_sb_in(&sdp->sd_sb, sb); 135 kunmap(page); 136 __free_page(page); 137 138 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent); 139 if (error) 140 goto out; 141 142 if (!proto[0]) 143 proto = sdp->sd_sb.sb_lockproto; 144 if (!table[0]) 145 table = sdp->sd_sb.sb_locktable; 146 } 147 148 if (!table[0]) 149 table = sdp->sd_vfs->s_id; 150 151 snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto); 152 snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table); 153 154out: 155 return error; 156} 157 158static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh, 159 int undo) 160{ 161 struct task_struct *p; 162 int error = 0; 163 164 if (undo) 165 goto fail_trans; 166 167 p = kthread_run(gfs2_scand, sdp, "gfs2_scand"); 168 error = IS_ERR(p); 169 if (error) { 170 fs_err(sdp, "can't start scand thread: %d\n", error); 171 return error; 172 } 173 sdp->sd_scand_process = p; 174 175 for (sdp->sd_glockd_num = 0; 176 sdp->sd_glockd_num < sdp->sd_args.ar_num_glockd; 177 sdp->sd_glockd_num++) { 178 p = kthread_run(gfs2_glockd, sdp, "gfs2_glockd"); 179 error = IS_ERR(p); 180 if (error) { 181 fs_err(sdp, "can't start glockd thread: %d\n", error); 182 goto fail; 183 } 184 sdp->sd_glockd_process[sdp->sd_glockd_num] = p; 185 } 186 187 error = gfs2_glock_nq_num(sdp, 188 GFS2_MOUNT_LOCK, &gfs2_nondisk_glops, 189 LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE, 190 mount_gh); 191 if (error) { 192 fs_err(sdp, "can't acquire mount glock: %d\n", error); 193 goto fail; 194 } 195 196 error = gfs2_glock_nq_num(sdp, 197 GFS2_LIVE_LOCK, &gfs2_nondisk_glops, 198 LM_ST_SHARED, 199 LM_FLAG_NOEXP | GL_EXACT, 200 &sdp->sd_live_gh); 201 if (error) { 202 fs_err(sdp, "can't acquire live glock: %d\n", error); 203 goto fail_mount; 204 } 205 206 error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops, 207 CREATE, &sdp->sd_rename_gl); 208 if (error) { 209 fs_err(sdp, "can't create rename glock: %d\n", error); 210 goto fail_live; 211 } 212 213 error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops, 214 CREATE, &sdp->sd_trans_gl); 215 if (error) { 216 fs_err(sdp, "can't create transaction glock: %d\n", error); 217 goto fail_rename; 218 } 219 set_bit(GLF_STICKY, &sdp->sd_trans_gl->gl_flags); 220 221 return 0; 222 223fail_trans: 224 gfs2_glock_put(sdp->sd_trans_gl); 225fail_rename: 226 gfs2_glock_put(sdp->sd_rename_gl); 227fail_live: 228 gfs2_glock_dq_uninit(&sdp->sd_live_gh); 229fail_mount: 230 gfs2_glock_dq_uninit(mount_gh); 231fail: 232 while (sdp->sd_glockd_num--) 233 kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]); 234 235 kthread_stop(sdp->sd_scand_process); 236 return error; 237} 238 239static struct inode *gfs2_lookup_root(struct super_block *sb, 240 struct gfs2_inum_host *inum) 241{ 242 return gfs2_inode_lookup(sb, inum, DT_DIR); 243} 244 245static int init_sb(struct gfs2_sbd *sdp, int silent, int undo) 246{ 247 struct super_block *sb = sdp->sd_vfs; 248 struct gfs2_holder sb_gh; 249 struct gfs2_inum_host *inum; 250 struct inode *inode; 251 int error = 0; 252 253 if (undo) { 254 if (sb->s_root) { 255 dput(sb->s_root); 256 sb->s_root = NULL; 257 } 258 return 0; 259 } 260 261 error = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops, 262 LM_ST_SHARED, 0, &sb_gh); 263 if (error) { 264 fs_err(sdp, "can't acquire superblock glock: %d\n", error); 265 return error; 266 } 267 268 error = gfs2_read_sb(sdp, sb_gh.gh_gl, silent); 269 if (error) { 270 fs_err(sdp, "can't read superblock: %d\n", error); 271 goto out; 272 } 273 274 /* Set up the buffer cache and SB for real */ 275 if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) { 276 error = -EINVAL; 277 fs_err(sdp, "FS block size (%u) is too small for device " 278 "block size (%u)\n", 279 sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev)); 280 goto out; 281 } 282 if (sdp->sd_sb.sb_bsize > PAGE_SIZE) { 283 error = -EINVAL; 284 fs_err(sdp, "FS block size (%u) is too big for machine " 285 "page size (%u)\n", 286 sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE); 287 goto out; 288 } 289 sb_set_blocksize(sb, sdp->sd_sb.sb_bsize); 290 291 /* Get the root inode */ 292 inum = &sdp->sd_sb.sb_root_dir; 293 if (sb->s_type == &gfs2meta_fs_type) 294 inum = &sdp->sd_sb.sb_master_dir; 295 inode = gfs2_lookup_root(sb, inum); 296 if (IS_ERR(inode)) { 297 error = PTR_ERR(inode); 298 fs_err(sdp, "can't read in root inode: %d\n", error); 299 goto out; 300 } 301 302 sb->s_root = d_alloc_root(inode); 303 if (!sb->s_root) { 304 fs_err(sdp, "can't get root dentry\n"); 305 error = -ENOMEM; 306 iput(inode); 307 } 308 sb->s_root->d_op = &gfs2_dops; 309out: 310 gfs2_glock_dq_uninit(&sb_gh); 311 return error; 312} 313 314static int init_journal(struct gfs2_sbd *sdp, int undo) 315{ 316 struct gfs2_holder ji_gh; 317 struct task_struct *p; 318 struct gfs2_inode *ip; 319 int jindex = 1; 320 int error = 0; 321 322 if (undo) { 323 jindex = 0; 324 goto fail_recoverd; 325 } 326 327 sdp->sd_jindex = gfs2_lookup_simple(sdp->sd_master_dir, "jindex"); 328 if (IS_ERR(sdp->sd_jindex)) { 329 fs_err(sdp, "can't lookup journal index: %d\n", error); 330 return PTR_ERR(sdp->sd_jindex); 331 } 332 ip = GFS2_I(sdp->sd_jindex); 333 set_bit(GLF_STICKY, &ip->i_gl->gl_flags); 334 335 /* Load in the journal index special file */ 336 337 error = gfs2_jindex_hold(sdp, &ji_gh); 338 if (error) { 339 fs_err(sdp, "can't read journal index: %d\n", error); 340 goto fail; 341 } 342 343 error = -EINVAL; 344 if (!gfs2_jindex_size(sdp)) { 345 fs_err(sdp, "no journals!\n"); 346 goto fail_jindex; 347 } 348 349 if (sdp->sd_args.ar_spectator) { 350 sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0); 351 sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks; 352 } else { 353 if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) { 354 fs_err(sdp, "can't mount journal #%u\n", 355 sdp->sd_lockstruct.ls_jid); 356 fs_err(sdp, "there are only %u journals (0 - %u)\n", 357 gfs2_jindex_size(sdp), 358 gfs2_jindex_size(sdp) - 1); 359 goto fail_jindex; 360 } 361 sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid); 362 363 error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid, 364 &gfs2_journal_glops, 365 LM_ST_EXCLUSIVE, LM_FLAG_NOEXP, 366 &sdp->sd_journal_gh); 367 if (error) { 368 fs_err(sdp, "can't acquire journal glock: %d\n", error); 369 goto fail_jindex; 370 } 371 372 ip = GFS2_I(sdp->sd_jdesc->jd_inode); 373 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 374 LM_FLAG_NOEXP | GL_EXACT, 375 &sdp->sd_jinode_gh); 376 if (error) { 377 fs_err(sdp, "can't acquire journal inode glock: %d\n", 378 error); 379 goto fail_journal_gh; 380 } 381 382 error = gfs2_jdesc_check(sdp->sd_jdesc); 383 if (error) { 384 fs_err(sdp, "my journal (%u) is bad: %d\n", 385 sdp->sd_jdesc->jd_jid, error); 386 goto fail_jinode_gh; 387 } 388 sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks; 389 } 390 391 if (sdp->sd_lockstruct.ls_first) { 392 unsigned int x; 393 for (x = 0; x < sdp->sd_journals; x++) { 394 error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x)); 395 if (error) { 396 fs_err(sdp, "error recovering journal %u: %d\n", 397 x, error); 398 goto fail_jinode_gh; 399 } 400 } 401 402 gfs2_lm_others_may_mount(sdp); 403 } else if (!sdp->sd_args.ar_spectator) { 404 error = gfs2_recover_journal(sdp->sd_jdesc); 405 if (error) { 406 fs_err(sdp, "error recovering my journal: %d\n", error); 407 goto fail_jinode_gh; 408 } 409 } 410 411 set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags); 412 gfs2_glock_dq_uninit(&ji_gh); 413 jindex = 0; 414 415 p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd"); 416 error = IS_ERR(p); 417 if (error) { 418 fs_err(sdp, "can't start recoverd thread: %d\n", error); 419 goto fail_jinode_gh; 420 } 421 sdp->sd_recoverd_process = p; 422 423 return 0; 424 425fail_recoverd: 426 kthread_stop(sdp->sd_recoverd_process); 427fail_jinode_gh: 428 if (!sdp->sd_args.ar_spectator) 429 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh); 430fail_journal_gh: 431 if (!sdp->sd_args.ar_spectator) 432 gfs2_glock_dq_uninit(&sdp->sd_journal_gh); 433fail_jindex: 434 gfs2_jindex_free(sdp); 435 if (jindex) 436 gfs2_glock_dq_uninit(&ji_gh); 437fail: 438 iput(sdp->sd_jindex); 439 return error; 440} 441 442 443static int init_inodes(struct gfs2_sbd *sdp, int undo) 444{ 445 int error = 0; 446 struct gfs2_inode *ip; 447 struct inode *inode; 448 449 if (undo) 450 goto fail_qinode; 451 452 inode = gfs2_lookup_root(sdp->sd_vfs, &sdp->sd_sb.sb_master_dir); 453 if (IS_ERR(inode)) { 454 error = PTR_ERR(inode); 455 fs_err(sdp, "can't read in master directory: %d\n", error); 456 goto fail; 457 } 458 sdp->sd_master_dir = inode; 459 460 error = init_journal(sdp, undo); 461 if (error) 462 goto fail_master; 463 464 /* Read in the master inode number inode */ 465 sdp->sd_inum_inode = gfs2_lookup_simple(sdp->sd_master_dir, "inum"); 466 if (IS_ERR(sdp->sd_inum_inode)) { 467 error = PTR_ERR(sdp->sd_inum_inode); 468 fs_err(sdp, "can't read in inum inode: %d\n", error); 469 goto fail_journal; 470 } 471 472 473 /* Read in the master statfs inode */ 474 sdp->sd_statfs_inode = gfs2_lookup_simple(sdp->sd_master_dir, "statfs"); 475 if (IS_ERR(sdp->sd_statfs_inode)) { 476 error = PTR_ERR(sdp->sd_statfs_inode); 477 fs_err(sdp, "can't read in statfs inode: %d\n", error); 478 goto fail_inum; 479 } 480 481 /* Read in the resource index inode */ 482 sdp->sd_rindex = gfs2_lookup_simple(sdp->sd_master_dir, "rindex"); 483 if (IS_ERR(sdp->sd_rindex)) { 484 error = PTR_ERR(sdp->sd_rindex); 485 fs_err(sdp, "can't get resource index inode: %d\n", error); 486 goto fail_statfs; 487 } 488 ip = GFS2_I(sdp->sd_rindex); 489 set_bit(GLF_STICKY, &ip->i_gl->gl_flags); 490 sdp->sd_rindex_vn = ip->i_gl->gl_vn - 1; 491 492 /* Read in the quota inode */ 493 sdp->sd_quota_inode = gfs2_lookup_simple(sdp->sd_master_dir, "quota"); 494 if (IS_ERR(sdp->sd_quota_inode)) { 495 error = PTR_ERR(sdp->sd_quota_inode); 496 fs_err(sdp, "can't get quota file inode: %d\n", error); 497 goto fail_rindex; 498 } 499 return 0; 500 501fail_qinode: 502 iput(sdp->sd_quota_inode); 503fail_rindex: 504 gfs2_clear_rgrpd(sdp); 505 iput(sdp->sd_rindex); 506fail_statfs: 507 iput(sdp->sd_statfs_inode); 508fail_inum: 509 iput(sdp->sd_inum_inode); 510fail_journal: 511 init_journal(sdp, UNDO); 512fail_master: 513 iput(sdp->sd_master_dir); 514fail: 515 return error; 516} 517 518static int init_per_node(struct gfs2_sbd *sdp, int undo) 519{ 520 struct inode *pn = NULL; 521 char buf[30]; 522 int error = 0; 523 struct gfs2_inode *ip; 524 525 if (sdp->sd_args.ar_spectator) 526 return 0; 527 528 if (undo) 529 goto fail_qc_gh; 530 531 pn = gfs2_lookup_simple(sdp->sd_master_dir, "per_node"); 532 if (IS_ERR(pn)) { 533 error = PTR_ERR(pn); 534 fs_err(sdp, "can't find per_node directory: %d\n", error); 535 return error; 536 } 537 538 sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid); 539 sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf); 540 if (IS_ERR(sdp->sd_ir_inode)) { 541 error = PTR_ERR(sdp->sd_ir_inode); 542 fs_err(sdp, "can't find local \"ir\" file: %d\n", error); 543 goto fail; 544 } 545 546 sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid); 547 sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf); 548 if (IS_ERR(sdp->sd_sc_inode)) { 549 error = PTR_ERR(sdp->sd_sc_inode); 550 fs_err(sdp, "can't find local \"sc\" file: %d\n", error); 551 goto fail_ir_i; 552 } 553 554 sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid); 555 sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf); 556 if (IS_ERR(sdp->sd_qc_inode)) { 557 error = PTR_ERR(sdp->sd_qc_inode); 558 fs_err(sdp, "can't find local \"qc\" file: %d\n", error); 559 goto fail_ut_i; 560 } 561 562 iput(pn); 563 pn = NULL; 564 565 ip = GFS2_I(sdp->sd_ir_inode); 566 error = gfs2_glock_nq_init(ip->i_gl, 567 LM_ST_EXCLUSIVE, 0, 568 &sdp->sd_ir_gh); 569 if (error) { 570 fs_err(sdp, "can't lock local \"ir\" file: %d\n", error); 571 goto fail_qc_i; 572 } 573 574 ip = GFS2_I(sdp->sd_sc_inode); 575 error = gfs2_glock_nq_init(ip->i_gl, 576 LM_ST_EXCLUSIVE, 0, 577 &sdp->sd_sc_gh); 578 if (error) { 579 fs_err(sdp, "can't lock local \"sc\" file: %d\n", error); 580 goto fail_ir_gh; 581 } 582 583 ip = GFS2_I(sdp->sd_qc_inode); 584 error = gfs2_glock_nq_init(ip->i_gl, 585 LM_ST_EXCLUSIVE, 0, 586 &sdp->sd_qc_gh); 587 if (error) { 588 fs_err(sdp, "can't lock local \"qc\" file: %d\n", error); 589 goto fail_ut_gh; 590 } 591 592 return 0; 593 594fail_qc_gh: 595 gfs2_glock_dq_uninit(&sdp->sd_qc_gh); 596fail_ut_gh: 597 gfs2_glock_dq_uninit(&sdp->sd_sc_gh); 598fail_ir_gh: 599 gfs2_glock_dq_uninit(&sdp->sd_ir_gh); 600fail_qc_i: 601 iput(sdp->sd_qc_inode); 602fail_ut_i: 603 iput(sdp->sd_sc_inode); 604fail_ir_i: 605 iput(sdp->sd_ir_inode); 606fail: 607 if (pn) 608 iput(pn); 609 return error; 610} 611 612static int init_threads(struct gfs2_sbd *sdp, int undo) 613{ 614 struct task_struct *p; 615 int error = 0; 616 617 if (undo) 618 goto fail_quotad; 619 620 sdp->sd_log_flush_time = jiffies; 621 sdp->sd_jindex_refresh_time = jiffies; 622 623 p = kthread_run(gfs2_logd, sdp, "gfs2_logd"); 624 error = IS_ERR(p); 625 if (error) { 626 fs_err(sdp, "can't start logd thread: %d\n", error); 627 return error; 628 } 629 sdp->sd_logd_process = p; 630 631 sdp->sd_statfs_sync_time = jiffies; 632 sdp->sd_quota_sync_time = jiffies; 633 634 p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad"); 635 error = IS_ERR(p); 636 if (error) { 637 fs_err(sdp, "can't start quotad thread: %d\n", error); 638 goto fail; 639 } 640 sdp->sd_quotad_process = p; 641 642 return 0; 643 644 645fail_quotad: 646 kthread_stop(sdp->sd_quotad_process); 647fail: 648 kthread_stop(sdp->sd_logd_process); 649 return error; 650} 651 652/** 653 * fill_super - Read in superblock 654 * @sb: The VFS superblock 655 * @data: Mount options 656 * @silent: Don't complain if it's not a GFS2 filesystem 657 * 658 * Returns: errno 659 */ 660 661static int fill_super(struct super_block *sb, void *data, int silent) 662{ 663 struct gfs2_sbd *sdp; 664 struct gfs2_holder mount_gh; 665 int error; 666 667 sdp = init_sbd(sb); 668 if (!sdp) { 669 printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n"); 670 return -ENOMEM; 671 } 672 673 error = gfs2_mount_args(sdp, (char *)data, 0); 674 if (error) { 675 printk(KERN_WARNING "GFS2: can't parse mount arguments\n"); 676 goto fail; 677 } 678 679 init_vfs(sb, SDF_NOATIME); 680 681 /* Set up the buffer cache and fill in some fake block size values 682 to allow us to read-in the on-disk superblock. */ 683 sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK); 684 sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits; 685 sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift - 686 GFS2_BASIC_BLOCK_SHIFT; 687 sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift; 688 689 error = init_names(sdp, silent); 690 if (error) 691 goto fail; 692 693 gfs2_create_debugfs_file(sdp); 694 695 error = gfs2_sys_fs_add(sdp); 696 if (error) 697 goto fail; 698 699 error = gfs2_lm_mount(sdp, silent); 700 if (error) 701 goto fail_sys; 702 703 error = init_locking(sdp, &mount_gh, DO); 704 if (error) 705 goto fail_lm; 706 707 error = init_sb(sdp, silent, DO); 708 if (error) 709 goto fail_locking; 710 711 error = init_inodes(sdp, DO); 712 if (error) 713 goto fail_sb; 714 715 error = init_per_node(sdp, DO); 716 if (error) 717 goto fail_inodes; 718 719 error = gfs2_statfs_init(sdp); 720 if (error) { 721 fs_err(sdp, "can't initialize statfs subsystem: %d\n", error); 722 goto fail_per_node; 723 } 724 725 error = init_threads(sdp, DO); 726 if (error) 727 goto fail_per_node; 728 729 if (!(sb->s_flags & MS_RDONLY)) { 730 error = gfs2_make_fs_rw(sdp); 731 if (error) { 732 fs_err(sdp, "can't make FS RW: %d\n", error); 733 goto fail_threads; 734 } 735 } 736 737 gfs2_glock_dq_uninit(&mount_gh); 738 739 return 0; 740 741fail_threads: 742 init_threads(sdp, UNDO); 743fail_per_node: 744 init_per_node(sdp, UNDO); 745fail_inodes: 746 init_inodes(sdp, UNDO); 747fail_sb: 748 init_sb(sdp, 0, UNDO); 749fail_locking: 750 init_locking(sdp, &mount_gh, UNDO); 751fail_lm: 752 gfs2_gl_hash_clear(sdp, WAIT); 753 gfs2_lm_unmount(sdp); 754 while (invalidate_inodes(sb)) 755 yield(); 756fail_sys: 757 gfs2_sys_fs_del(sdp); 758fail: 759 gfs2_delete_debugfs_file(sdp); 760 kfree(sdp); 761 sb->s_fs_info = NULL; 762 return error; 763} 764 765static int gfs2_get_sb(struct file_system_type *fs_type, int flags, 766 const char *dev_name, void *data, struct vfsmount *mnt) 767{ 768 struct super_block *sb; 769 struct gfs2_sbd *sdp; 770 int error = get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt); 771 if (error) 772 goto out; 773 sb = mnt->mnt_sb; 774 sdp = sb->s_fs_info; 775 sdp->sd_gfs2mnt = mnt; 776out: 777 return error; 778} 779 780static int fill_super_meta(struct super_block *sb, struct super_block *new, 781 void *data, int silent) 782{ 783 struct gfs2_sbd *sdp = sb->s_fs_info; 784 struct inode *inode; 785 int error = 0; 786 787 new->s_fs_info = sdp; 788 sdp->sd_vfs_meta = sb; 789 790 init_vfs(new, SDF_NOATIME); 791 792 /* Get the master inode */ 793 inode = igrab(sdp->sd_master_dir); 794 795 new->s_root = d_alloc_root(inode); 796 if (!new->s_root) { 797 fs_err(sdp, "can't get root dentry\n"); 798 error = -ENOMEM; 799 iput(inode); 800 } else 801 new->s_root->d_op = &gfs2_dops; 802 803 return error; 804} 805 806static int set_bdev_super(struct super_block *s, void *data) 807{ 808 s->s_bdev = data; 809 s->s_dev = s->s_bdev->bd_dev; 810 return 0; 811} 812 813static int test_bdev_super(struct super_block *s, void *data) 814{ 815 return s->s_bdev == data; 816} 817 818static struct super_block* get_gfs2_sb(const char *dev_name) 819{ 820 struct kstat stat; 821 struct nameidata nd; 822 struct file_system_type *fstype; 823 struct super_block *sb = NULL, *s; 824 struct list_head *l; 825 int error; 826 827 error = path_lookup(dev_name, LOOKUP_FOLLOW, &nd); 828 if (error) { 829 printk(KERN_WARNING "GFS2: path_lookup on %s returned error\n", 830 dev_name); 831 goto out; 832 } 833 error = vfs_getattr(nd.mnt, nd.dentry, &stat); 834 835 fstype = get_fs_type("gfs2"); 836 list_for_each(l, &fstype->fs_supers) { 837 s = list_entry(l, struct super_block, s_instances); 838 if ((S_ISBLK(stat.mode) && s->s_dev == stat.rdev) || 839 (S_ISDIR(stat.mode) && s == nd.dentry->d_inode->i_sb)) { 840 sb = s; 841 goto free_nd; 842 } 843 } 844 845 printk(KERN_WARNING "GFS2: Unrecognized block device or " 846 "mount point %s\n", dev_name); 847 848free_nd: 849 path_release(&nd); 850out: 851 return sb; 852} 853 854static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags, 855 const char *dev_name, void *data, struct vfsmount *mnt) 856{ 857 int error = 0; 858 struct super_block *sb = NULL, *new; 859 struct gfs2_sbd *sdp; 860 861 sb = get_gfs2_sb(dev_name); 862 if (!sb) { 863 printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n"); 864 error = -ENOENT; 865 goto error; 866 } 867 sdp = (struct gfs2_sbd*) sb->s_fs_info; 868 if (sdp->sd_vfs_meta) { 869 printk(KERN_WARNING "GFS2: gfs2meta mount already exists\n"); 870 error = -EBUSY; 871 goto error; 872 } 873 down(&sb->s_bdev->bd_mount_sem); 874 new = sget(fs_type, test_bdev_super, set_bdev_super, sb->s_bdev); 875 up(&sb->s_bdev->bd_mount_sem); 876 if (IS_ERR(new)) { 877 error = PTR_ERR(new); 878 goto error; 879 } 880 module_put(fs_type->owner); 881 new->s_flags = flags; 882 strlcpy(new->s_id, sb->s_id, sizeof(new->s_id)); 883 sb_set_blocksize(new, sb->s_blocksize); 884 error = fill_super_meta(sb, new, data, flags & MS_SILENT ? 1 : 0); 885 if (error) { 886 up_write(&new->s_umount); 887 deactivate_super(new); 888 goto error; 889 } 890 891 new->s_flags |= MS_ACTIVE; 892 893 /* Grab a reference to the gfs2 mount point */ 894 atomic_inc(&sdp->sd_gfs2mnt->mnt_count); 895 return simple_set_mnt(mnt, new); 896error: 897 return error; 898} 899 900static void gfs2_kill_sb(struct super_block *sb) 901{ 902 gfs2_delete_debugfs_file(sb->s_fs_info); 903 kill_block_super(sb); 904} 905 906static void gfs2_kill_sb_meta(struct super_block *sb) 907{ 908 struct gfs2_sbd *sdp = sb->s_fs_info; 909 generic_shutdown_super(sb); 910 sdp->sd_vfs_meta = NULL; 911 atomic_dec(&sdp->sd_gfs2mnt->mnt_count); 912} 913 914struct file_system_type gfs2_fs_type = { 915 .name = "gfs2", 916 .fs_flags = FS_REQUIRES_DEV, 917 .get_sb = gfs2_get_sb, 918 .kill_sb = gfs2_kill_sb, 919 .owner = THIS_MODULE, 920}; 921 922struct file_system_type gfs2meta_fs_type = { 923 .name = "gfs2meta", 924 .fs_flags = FS_REQUIRES_DEV, 925 .get_sb = gfs2_get_sb_meta, 926 .kill_sb = gfs2_kill_sb_meta, 927 .owner = THIS_MODULE, 928}; 929