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