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