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