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