pilppa.com Git - linux-2.6-omap-h63xx.git/blob

1 /*

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 */

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>

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"

36 static const u32 gfs2_old_fs_formats[] = {

37 0

38 };

40 static const u32 gfs2_old_multihost_formats[] = {

41 0

42 };

44 /**

45 * gfs2_tune_init - Fill a gfs2_tune structure with default values

46 * @gt: tune

47 *

48 */

50 void gfs2_tune_init(struct gfs2_tune *gt)

51 {

52 spin_lock_init(&gt->gt_spin);

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 }

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 */

93 int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent)

94 {

95 unsigned int x;

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 int end_bio_io_page(struct bio *bio, unsigned int bytes_done, int error)

163 {

164 struct page *page = bio->bi_private;

165 if (bio->bi_size)

166 return 1;

167

168 if (!error)

169 SetPageUptodate(page);

170 else

171 printk(KERN_WARNING "gfs2: error %d reading superblock\n", error);

172 unlock_page(page);

173 return 0;

174 }

175

176 static void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)

177 {

178 const struct gfs2_sb *str = buf;

179

180 sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);

181 sb->sb_type = be32_to_cpu(str->sb_header.mh_type);

182 sb->sb_format = be32_to_cpu(str->sb_header.mh_format);

183 sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);

184 sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);

185 sb->sb_bsize = be32_to_cpu(str->sb_bsize);

186 sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);

187 sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);

188 sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);

189 sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);

190 sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);

191

192 memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);

193 memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);

194 }

195

196 /**

197 * gfs2_read_super - Read the gfs2 super block from disk

198 * @sdp: The GFS2 super block

199 * @sector: The location of the super block

200 * @error: The error code to return

201 *

202 * This uses the bio functions to read the super block from disk

203 * because we want to be 100% sure that we never read cached data.

204 * A super block is read twice only during each GFS2 mount and is

205 * never written to by the filesystem. The first time its read no

206 * locks are held, and the only details which are looked at are those

207 * relating to the locking protocol. Once locking is up and working,

208 * the sb is read again under the lock to establish the location of

209 * the master directory (contains pointers to journals etc) and the

210 * root directory.

211 *

212 * Returns: 0 on success or error

213 */

214

215 int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector)

216 {

217 struct super_block *sb = sdp->sd_vfs;

218 struct gfs2_sb *p;

219 struct page *page;

220 struct bio *bio;

221

222 page = alloc_page(GFP_KERNEL);

223 if (unlikely(!page))

224 return -ENOBUFS;

225

226 ClearPageUptodate(page);

227 ClearPageDirty(page);

228 lock_page(page);

229

230 bio = bio_alloc(GFP_KERNEL, 1);

231 if (unlikely(!bio)) {

232 __free_page(page);

233 return -ENOBUFS;

234 }

235

236 bio->bi_sector = sector * (sb->s_blocksize >> 9);

237 bio->bi_bdev = sb->s_bdev;

238 bio_add_page(bio, page, PAGE_SIZE, 0);

239

240 bio->bi_end_io = end_bio_io_page;

241 bio->bi_private = page;

242 submit_bio(READ_SYNC | (1 << BIO_RW_META), bio);

243 wait_on_page_locked(page);

244 bio_put(bio);

245 if (!PageUptodate(page)) {

246 __free_page(page);

247 return -EIO;

248 }

249 p = kmap(page);

250 gfs2_sb_in(&sdp->sd_sb, p);

251 kunmap(page);

252 __free_page(page);

253 return 0;

254 }

255

256 /**

257 * gfs2_read_sb - Read super block

258 * @sdp: The GFS2 superblock

259 * @gl: the glock for the superblock (assumed to be held)

260 * @silent: Don't print message if mount fails

261 *

262 */

263

264 int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)

265 {

266 u32 hash_blocks, ind_blocks, leaf_blocks;

267 u32 tmp_blocks;

268 unsigned int x;

269 int error;

270

271 error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);

272 if (error) {

273 if (!silent)

274 fs_err(sdp, "can't read superblock\n");

275 return error;

276 }

277

278 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);

279 if (error)

280 return error;

281

282 sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -

283 GFS2_BASIC_BLOCK_SHIFT;

284 sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;

285 sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -

286 sizeof(struct gfs2_dinode)) / sizeof(u64);

287 sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -

288 sizeof(struct gfs2_meta_header)) / sizeof(u64);

289 sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);

290 sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;

291 sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;

292 sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);

293 sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -

294 sizeof(struct gfs2_meta_header)) /

295 sizeof(struct gfs2_quota_change);

296

297 /* Compute maximum reservation required to add a entry to a directory */

298

299 hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),

300 sdp->sd_jbsize);

301

302 ind_blocks = 0;

303 for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {

304 tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);

305 ind_blocks += tmp_blocks;

306 }

307

308 leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;

309

310 sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;

311

312 sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -

313 sizeof(struct gfs2_dinode);

314 sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;

315 for (x = 2;; x++) {

316 u64 space, d;

317 u32 m;

318

319 space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;

320 d = space;

321 m = do_div(d, sdp->sd_inptrs);

322

323 if (d != sdp->sd_heightsize[x - 1] || m)

324 break;

325 sdp->sd_heightsize[x] = space;

326 }

327 sdp->sd_max_height = x;

328 gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);

329

330 sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -

331 sizeof(struct gfs2_dinode);

332 sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;

333 for (x = 2;; x++) {

334 u64 space, d;

335 u32 m;

336

337 space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;

338 d = space;

339 m = do_div(d, sdp->sd_inptrs);

340

341 if (d != sdp->sd_jheightsize[x - 1] || m)

342 break;

343 sdp->sd_jheightsize[x] = space;

344 }

345 sdp->sd_max_jheight = x;

346 gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);

347

348 return 0;

349 }

350

351 /**

352 * gfs2_jindex_hold - Grab a lock on the jindex

353 * @sdp: The GFS2 superblock

354 * @ji_gh: the holder for the jindex glock

355 *

356 * This is very similar to the gfs2_rindex_hold() function, except that

357 * in general we hold the jindex lock for longer periods of time and

358 * we grab it far less frequently (in general) then the rgrp lock.

359 *

360 * Returns: errno

361 */

362

363 int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)

364 {

365 struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);

366 struct qstr name;

367 char buf[20];

368 struct gfs2_jdesc *jd;

369 int error;

370

371 name.name = buf;

372

373 mutex_lock(&sdp->sd_jindex_mutex);

374

375 for (;;) {

376 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);

377 if (error)

378 break;

379

380 name.len = sprintf(buf, "journal%u", sdp->sd_journals);

381 name.hash = gfs2_disk_hash(name.name, name.len);

382

383 error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);

384 if (error == -ENOENT) {

385 error = 0;

386 break;

387 }

388

389 gfs2_glock_dq_uninit(ji_gh);

390

391 if (error)

392 break;

393

394 error = -ENOMEM;

395 jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);

396 if (!jd)

397 break;

398

399 jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1, NULL);

400 if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {

401 if (!jd->jd_inode)

402 error = -ENOENT;

403 else

404 error = PTR_ERR(jd->jd_inode);

405 kfree(jd);

406 break;

407 }

408

409 spin_lock(&sdp->sd_jindex_spin);

410 jd->jd_jid = sdp->sd_journals++;

411 list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);

412 spin_unlock(&sdp->sd_jindex_spin);

413 }

414

415 mutex_unlock(&sdp->sd_jindex_mutex);

416

417 return error;

418 }

419

420 /**

421 * gfs2_jindex_free - Clear all the journal index information

422 * @sdp: The GFS2 superblock

423 *

424 */

425

426 void gfs2_jindex_free(struct gfs2_sbd *sdp)

427 {

428 struct list_head list;

429 struct gfs2_jdesc *jd;

430

431 spin_lock(&sdp->sd_jindex_spin);

432 list_add(&list, &sdp->sd_jindex_list);

433 list_del_init(&sdp->sd_jindex_list);

434 sdp->sd_journals = 0;

435 spin_unlock(&sdp->sd_jindex_spin);

436

437 while (!list_empty(&list)) {

438 jd = list_entry(list.next, struct gfs2_jdesc, jd_list);

439 list_del(&jd->jd_list);

440 iput(jd->jd_inode);

441 kfree(jd);

442 }

443 }

444

445 static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid)

446 {

447 struct gfs2_jdesc *jd;

448 int found = 0;

449

450 list_for_each_entry(jd, head, jd_list) {

451 if (jd->jd_jid == jid) {

452 found = 1;

453 break;

454 }

455 }

456

457 if (!found)

458 jd = NULL;

459

460 return jd;

461 }

462

463 struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid)

464 {

465 struct gfs2_jdesc *jd;

466

467 spin_lock(&sdp->sd_jindex_spin);

468 jd = jdesc_find_i(&sdp->sd_jindex_list, jid);

469 spin_unlock(&sdp->sd_jindex_spin);

470

471 return jd;

472 }

473

474 void gfs2_jdesc_make_dirty(struct gfs2_sbd *sdp, unsigned int jid)

475 {

476 struct gfs2_jdesc *jd;

477

478 spin_lock(&sdp->sd_jindex_spin);

479 jd = jdesc_find_i(&sdp->sd_jindex_list, jid);

480 if (jd)

481 jd->jd_dirty = 1;

482 spin_unlock(&sdp->sd_jindex_spin);

483 }

484

485 struct gfs2_jdesc *gfs2_jdesc_find_dirty(struct gfs2_sbd *sdp)

486 {

487 struct gfs2_jdesc *jd;

488 int found = 0;

489

490 spin_lock(&sdp->sd_jindex_spin);

491

492 list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {

493 if (jd->jd_dirty) {

494 jd->jd_dirty = 0;

495 found = 1;

496 break;

497 }

498 }

499 spin_unlock(&sdp->sd_jindex_spin);

500

501 if (!found)

502 jd = NULL;

503

504 return jd;

505 }

506

507 int gfs2_jdesc_check(struct gfs2_jdesc *jd)

508 {

509 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);

510 struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);

511 int ar;

512 int error;

513

514 if (ip->i_di.di_size < (8 << 20) || ip->i_di.di_size > (1 << 30) ||

515 (ip->i_di.di_size & (sdp->sd_sb.sb_bsize - 1))) {

516 gfs2_consist_inode(ip);

517 return -EIO;

518 }

519 jd->jd_blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;

520

521 error = gfs2_write_alloc_required(ip, 0, ip->i_di.di_size, &ar);

522 if (!error && ar) {

523 gfs2_consist_inode(ip);

524 error = -EIO;

525 }

526

527 return error;

528 }

529

530 /**

531 * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one

532 * @sdp: the filesystem

533 *

534 * Returns: errno

535 */

536

537 int gfs2_make_fs_rw(struct gfs2_sbd *sdp)

538 {

539 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);

540 struct gfs2_glock *j_gl = ip->i_gl;

541 struct gfs2_holder t_gh;

542 struct gfs2_log_header_host head;

543 int error;

544

545 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &t_gh);

546 if (error)

547 return error;

548

549 gfs2_meta_cache_flush(ip);

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 mutex_lock(&sdp->sd_statfs_mutex);

693 gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);

694 mutex_unlock(&sdp->sd_statfs_mutex);

695

696 spin_lock(&sdp->sd_statfs_spin);

697 l_sc->sc_total += total;

698 l_sc->sc_free += free;

699 l_sc->sc_dinodes += dinodes;

700 gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));

701 spin_unlock(&sdp->sd_statfs_spin);

702

703 brelse(l_bh);

704 }

705

706 int gfs2_statfs_sync(struct gfs2_sbd *sdp)

707 {

708 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);

709 struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);

710 struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;

711 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;

712 struct gfs2_holder gh;

713 struct buffer_head *m_bh, *l_bh;

714 int error;

715

716 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,

717 &gh);

718 if (error)

719 return error;

720

721 error = gfs2_meta_inode_buffer(m_ip, &m_bh);

722 if (error)

723 goto out;

724

725 spin_lock(&sdp->sd_statfs_spin);

726 gfs2_statfs_change_in(m_sc, m_bh->b_data +

727 sizeof(struct gfs2_dinode));

728 if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {

729 spin_unlock(&sdp->sd_statfs_spin);

730 goto out_bh;

731 }

732 spin_unlock(&sdp->sd_statfs_spin);

733

734 error = gfs2_meta_inode_buffer(l_ip, &l_bh);

735 if (error)

736 goto out_bh;

737

738 error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);

739 if (error)

740 goto out_bh2;

741

742 mutex_lock(&sdp->sd_statfs_mutex);

743 gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);

744 mutex_unlock(&sdp->sd_statfs_mutex);

745

746 spin_lock(&sdp->sd_statfs_spin);

747 m_sc->sc_total += l_sc->sc_total;

748 m_sc->sc_free += l_sc->sc_free;

749 m_sc->sc_dinodes += l_sc->sc_dinodes;

750 memset(l_sc, 0, sizeof(struct gfs2_statfs_change));

751 memset(l_bh->b_data + sizeof(struct gfs2_dinode),

752 0, sizeof(struct gfs2_statfs_change));

753 spin_unlock(&sdp->sd_statfs_spin);

754

755 gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);

756 gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode));

757

758 gfs2_trans_end(sdp);

759

760 out_bh2:

761 brelse(l_bh);

762 out_bh:

763 brelse(m_bh);

764 out:

765 gfs2_glock_dq_uninit(&gh);

766 return error;

767 }

768

769 /**

770 * gfs2_statfs_i - Do a statfs

771 * @sdp: the filesystem

772 * @sg: the sg structure

773 *

774 * Returns: errno

775 */

776

777 int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)

778 {

779 struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;

780 struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;

781

782 spin_lock(&sdp->sd_statfs_spin);

783

784 *sc = *m_sc;

785 sc->sc_total += l_sc->sc_total;

786 sc->sc_free += l_sc->sc_free;

787 sc->sc_dinodes += l_sc->sc_dinodes;

788

789 spin_unlock(&sdp->sd_statfs_spin);

790

791 if (sc->sc_free < 0)

792 sc->sc_free = 0;

793 if (sc->sc_free > sc->sc_total)

794 sc->sc_free = sc->sc_total;

795 if (sc->sc_dinodes < 0)

796 sc->sc_dinodes = 0;

797

798 return 0;

799 }

800

801 /**

802 * statfs_fill - fill in the sg for a given RG

803 * @rgd: the RG

804 * @sc: the sc structure

805 *

806 * Returns: 0 on success, -ESTALE if the LVB is invalid

807 */

808

809 static int statfs_slow_fill(struct gfs2_rgrpd *rgd,

810 struct gfs2_statfs_change_host *sc)

811 {

812 gfs2_rgrp_verify(rgd);

813 sc->sc_total += rgd->rd_data;

814 sc->sc_free += rgd->rd_rg.rg_free;

815 sc->sc_dinodes += rgd->rd_rg.rg_dinodes;

816 return 0;

817 }

818

819 /**

820 * gfs2_statfs_slow - Stat a filesystem using asynchronous locking

821 * @sdp: the filesystem

822 * @sc: the sc info that will be returned

823 *

824 * Any error (other than a signal) will cause this routine to fall back

825 * to the synchronous version.

826 *

827 * FIXME: This really shouldn't busy wait like this.

828 *

829 * Returns: errno

830 */

831

832 int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)

833 {

834 struct gfs2_holder ri_gh;

835 struct gfs2_rgrpd *rgd_next;

836 struct gfs2_holder *gha, *gh;

837 unsigned int slots = 64;

838 unsigned int x;

839 int done;

840 int error = 0, err;

841

842 memset(sc, 0, sizeof(struct gfs2_statfs_change_host));

843 gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);

844 if (!gha)

845 return -ENOMEM;

846

847 error = gfs2_rindex_hold(sdp, &ri_gh);

848 if (error)

849 goto out;

850

851 rgd_next = gfs2_rgrpd_get_first(sdp);

852

853 for (;;) {

854 done = 1;

855

856 for (x = 0; x < slots; x++) {

857 gh = gha + x;

858

859 if (gh->gh_gl && gfs2_glock_poll(gh)) {

860 err = gfs2_glock_wait(gh);

861 if (err) {

862 gfs2_holder_uninit(gh);

863 error = err;

864 } else {

865 if (!error)

866 error = statfs_slow_fill(

867 gh->gh_gl->gl_object, sc);

868 gfs2_glock_dq_uninit(gh);

869 }

870 }

871

872 if (gh->gh_gl)

873 done = 0;

874 else if (rgd_next && !error) {

875 error = gfs2_glock_nq_init(rgd_next->rd_gl,

876 LM_ST_SHARED,

877 GL_ASYNC,

878 gh);

879 rgd_next = gfs2_rgrpd_get_next(rgd_next);

880 done = 0;

881 }

882

883 if (signal_pending(current))

884 error = -ERESTARTSYS;

885 }

886

887 if (done)

888 break;

889

890 yield();

891 }

892

893 gfs2_glock_dq_uninit(&ri_gh);

894

895 out:

896 kfree(gha);

897 return error;

898 }

899

900 struct lfcc {

901 struct list_head list;

902 struct gfs2_holder gh;

903 };

904

905 /**

906 * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all

907 * journals are clean

908 * @sdp: the file system

909 * @state: the state to put the transaction lock into

910 * @t_gh: the hold on the transaction lock

911 *

912 * Returns: errno

913 */

914

915 static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,

916 struct gfs2_holder *t_gh)

917 {

918 struct gfs2_inode *ip;

919 struct gfs2_holder ji_gh;

920 struct gfs2_jdesc *jd;

921 struct lfcc *lfcc;

922 LIST_HEAD(list);

923 struct gfs2_log_header_host lh;

924 int error;

925

926 error = gfs2_jindex_hold(sdp, &ji_gh);

927 if (error)

928 return error;

929

930 list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {

931 lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);

932 if (!lfcc) {

933 error = -ENOMEM;

934 goto out;

935 }

936 ip = GFS2_I(jd->jd_inode);

937 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh);

938 if (error) {

939 kfree(lfcc);

940 goto out;

941 }

942 list_add(&lfcc->list, &list);

943 }

944

945 error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,

946 LM_FLAG_PRIORITY | GL_NOCACHE,

947 t_gh);

948

949 list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {

950 error = gfs2_jdesc_check(jd);

951 if (error)

952 break;

953 error = gfs2_find_jhead(jd, &lh);

954 if (error)

955 break;

956 if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {

957 error = -EBUSY;

958 break;

959 }

960 }

961

962 if (error)

963 gfs2_glock_dq_uninit(t_gh);

964

965 out:

966 while (!list_empty(&list)) {

967 lfcc = list_entry(list.next, struct lfcc, list);

968 list_del(&lfcc->list);

969 gfs2_glock_dq_uninit(&lfcc->gh);

970 kfree(lfcc);

971 }

972 gfs2_glock_dq_uninit(&ji_gh);

973 return error;

974 }

975

976 /**

977 * gfs2_freeze_fs - freezes the file system

978 * @sdp: the file system

979 *

980 * This function flushes data and meta data for all machines by

981 * aquiring the transaction log exclusively. All journals are

982 * ensured to be in a clean state as well.

983 *

984 * Returns: errno

985 */

986

987 int gfs2_freeze_fs(struct gfs2_sbd *sdp)

988 {

989 int error = 0;

990

991 mutex_lock(&sdp->sd_freeze_lock);

992

993 if (!sdp->sd_freeze_count++) {

994 error = gfs2_lock_fs_check_clean(sdp, &sdp->sd_freeze_gh);

995 if (error)

996 sdp->sd_freeze_count--;

997 }

998

999 mutex_unlock(&sdp->sd_freeze_lock);

1000

1001 return error;

1002 }

1003

1004 /**

1005 * gfs2_unfreeze_fs - unfreezes the file system

1006 * @sdp: the file system

1007 *

1008 * This function allows the file system to proceed by unlocking

1009 * the exclusively held transaction lock. Other GFS2 nodes are

1010 * now free to acquire the lock shared and go on with their lives.

1011 *

1012 */

1013

1014 void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)

1015 {

1016 mutex_lock(&sdp->sd_freeze_lock);

1017

1018 if (sdp->sd_freeze_count && !--sdp->sd_freeze_count)

1019 gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);

1020

1021 mutex_unlock(&sdp->sd_freeze_lock);

1022 }

1023