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