err.no Git - linux-2.6/blob

1 /*

3 *

4 * Trivial changes by Alan Cox to add the LFS fixes

5 *

6 * Trivial Changes:

7 * Rights granted to Hans Reiser to redistribute under other terms providing

8 * he accepts all liability including but not limited to patent, fitness

9 * for purpose, and direct or indirect claims arising from failure to perform.

10 *

11 * NO WARRANTY

12 */

13

14 #include <linux/config.h>

15 #include <linux/module.h>

16 #include <linux/vmalloc.h>

17 #include <linux/time.h>

18 #include <asm/uaccess.h>

19 #include <linux/reiserfs_fs.h>

20 #include <linux/reiserfs_acl.h>

21 #include <linux/reiserfs_xattr.h>

22 #include <linux/smp_lock.h>

23 #include <linux/init.h>

24 #include <linux/blkdev.h>

25 #include <linux/buffer_head.h>

26 #include <linux/vfs.h>

27 #include <linux/namespace.h>

28 #include <linux/mount.h>

29 #include <linux/namei.h>

30 #include <linux/quotaops.h>

31

32 struct file_system_type reiserfs_fs_type;

33

34 static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING;

35 static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING;

36 static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING;

37

38 int is_reiserfs_3_5(struct reiserfs_super_block *rs)

39 {

40 return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,

41 strlen(reiserfs_3_5_magic_string));

42 }

43

44 int is_reiserfs_3_6(struct reiserfs_super_block *rs)

45 {

46 return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,

47 strlen(reiserfs_3_6_magic_string));

48 }

49

50 int is_reiserfs_jr(struct reiserfs_super_block *rs)

51 {

52 return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,

53 strlen(reiserfs_jr_magic_string));

54 }

55

56 static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)

57 {

58 return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||

59 is_reiserfs_jr(rs));

60 }

61

62 static int reiserfs_remount(struct super_block *s, int *flags, char *data);

63 static int reiserfs_statfs(struct super_block *s, struct kstatfs *buf);

64

65 static int reiserfs_sync_fs(struct super_block *s, int wait)

66 {

67 if (!(s->s_flags & MS_RDONLY)) {

68 struct reiserfs_transaction_handle th;

69 reiserfs_write_lock(s);

70 if (!journal_begin(&th, s, 1))

71 if (!journal_end_sync(&th, s, 1))

72 reiserfs_flush_old_commits(s);

73 s->s_dirt = 0; /* Even if it's not true.

74 * We'll loop forever in sync_supers otherwise */

75 reiserfs_write_unlock(s);

76 } else {

77 s->s_dirt = 0;

78 }

79 return 0;

80 }

81

82 static void reiserfs_write_super(struct super_block *s)

83 {

84 reiserfs_sync_fs(s, 1);

85 }

86

87 static void reiserfs_write_super_lockfs(struct super_block *s)

88 {

89 struct reiserfs_transaction_handle th;

90 reiserfs_write_lock(s);

91 if (!(s->s_flags & MS_RDONLY)) {

92 int err = journal_begin(&th, s, 1);

93 if (err) {

94 reiserfs_block_writes(&th);

95 } else {

96 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),

97 1);

98 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));

99 reiserfs_block_writes(&th);

100 journal_end_sync(&th, s, 1);

101 }

102 }

103 s->s_dirt = 0;

104 reiserfs_write_unlock(s);

105 }

106

107 static void reiserfs_unlockfs(struct super_block *s)

108 {

109 reiserfs_allow_writes(s);

110 }

111

112 extern const struct in_core_key MAX_IN_CORE_KEY;

113

114 /* this is used to delete "save link" when there are no items of a

115 file it points to. It can either happen if unlink is completed but

116 "save unlink" removal, or if file has both unlink and truncate

117 pending and as unlink completes first (because key of "save link"

118 protecting unlink is bigger that a key lf "save link" which

119 protects truncate), so there left no items to make truncate

120 completion on */

121 static int remove_save_link_only(struct super_block *s,

122 struct reiserfs_key *key, int oid_free)

123 {

124 struct reiserfs_transaction_handle th;

125 int err;

126

127 /* we are going to do one balancing */

128 err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT);

129 if (err)

130 return err;

131

132 reiserfs_delete_solid_item(&th, NULL, key);

133 if (oid_free)

134 /* removals are protected by direct items */

135 reiserfs_release_objectid(&th, le32_to_cpu(key->k_objectid));

136

137 return journal_end(&th, s, JOURNAL_PER_BALANCE_CNT);

138 }

139

140 #ifdef CONFIG_QUOTA

141 static int reiserfs_quota_on_mount(struct super_block *, int);

142 #endif

143

144 /* look for uncompleted unlinks and truncates and complete them */

145 static int finish_unfinished(struct super_block *s)

146 {

147 INITIALIZE_PATH(path);

148 struct cpu_key max_cpu_key, obj_key;

149 struct reiserfs_key save_link_key;

150 int retval = 0;

151 struct item_head *ih;

152 struct buffer_head *bh;

153 int item_pos;

154 char *item;

155 int done;

156 struct inode *inode;

157 int truncate;

158 #ifdef CONFIG_QUOTA

159 int i;

160 int ms_active_set;

161 #endif

162

163 /* compose key to look for "save" links */

164 max_cpu_key.version = KEY_FORMAT_3_5;

165 max_cpu_key.on_disk_key.k_dir_id = ~0U;

166 max_cpu_key.on_disk_key.k_objectid = ~0U;

167 set_cpu_key_k_offset(&max_cpu_key, ~0U);

168 max_cpu_key.key_length = 3;

169

170 #ifdef CONFIG_QUOTA

171 /* Needed for iput() to work correctly and not trash data */

172 if (s->s_flags & MS_ACTIVE) {

173 ms_active_set = 0;

174 } else {

175 ms_active_set = 1;

176 s->s_flags |= MS_ACTIVE;

177 }

178 /* Turn on quotas so that they are updated correctly */

179 for (i = 0; i < MAXQUOTAS; i++) {

180 if (REISERFS_SB(s)->s_qf_names[i]) {

181 int ret = reiserfs_quota_on_mount(s, i);

182 if (ret < 0)

183 reiserfs_warning(s,

184 "reiserfs: cannot turn on journalled quota: error %d",

185 ret);

186 }

187 }

188 #endif

189

190 done = 0;

191 REISERFS_SB(s)->s_is_unlinked_ok = 1;

192 while (!retval) {

193 retval = search_item(s, &max_cpu_key, &path);

194 if (retval != ITEM_NOT_FOUND) {

195 reiserfs_warning(s,

196 "vs-2140: finish_unfinished: search_by_key returned %d",

197 retval);

198 break;

199 }

200

201 bh = get_last_bh(&path);

202 item_pos = get_item_pos(&path);

203 if (item_pos != B_NR_ITEMS(bh)) {

204 reiserfs_warning(s,

205 "vs-2060: finish_unfinished: wrong position found");

206 break;

207 }

208 item_pos--;

209 ih = B_N_PITEM_HEAD(bh, item_pos);

210

211 if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)

212 /* there are no "save" links anymore */

213 break;

214

215 save_link_key = ih->ih_key;

216 if (is_indirect_le_ih(ih))

217 truncate = 1;

218 else

219 truncate = 0;

220

221 /* reiserfs_iget needs k_dirid and k_objectid only */

222 item = B_I_PITEM(bh, ih);

223 obj_key.on_disk_key.k_dir_id = le32_to_cpu(*(__le32 *) item);

224 obj_key.on_disk_key.k_objectid =

225 le32_to_cpu(ih->ih_key.k_objectid);

226 obj_key.on_disk_key.k_offset = 0;

227 obj_key.on_disk_key.k_type = 0;

228

229 pathrelse(&path);

230

231 inode = reiserfs_iget(s, &obj_key);

232 if (!inode) {

233 /* the unlink almost completed, it just did not manage to remove

234 "save" link and release objectid */

235 reiserfs_warning(s,

236 "vs-2180: finish_unfinished: iget failed for %K",

237 &obj_key);

238 retval = remove_save_link_only(s, &save_link_key, 1);

239 continue;

240 }

241

242 if (!truncate && inode->i_nlink) {

243 /* file is not unlinked */

244 reiserfs_warning(s,

245 "vs-2185: finish_unfinished: file %K is not unlinked",

246 &obj_key);

247 retval = remove_save_link_only(s, &save_link_key, 0);

248 continue;

249 }

250 DQUOT_INIT(inode);

251

252 if (truncate && S_ISDIR(inode->i_mode)) {

253 /* We got a truncate request for a dir which is impossible.

254 The only imaginable way is to execute unfinished truncate request

255 then boot into old kernel, remove the file and create dir with

256 the same key. */

257 reiserfs_warning(s,

258 "green-2101: impossible truncate on a directory %k. Please report",

259 INODE_PKEY(inode));

260 retval = remove_save_link_only(s, &save_link_key, 0);

261 truncate = 0;

262 iput(inode);

263 continue;

264 }

265

266 if (truncate) {

267 REISERFS_I(inode)->i_flags |=

268 i_link_saved_truncate_mask;

269 /* not completed truncate found. New size was committed together

270 with "save" link */

271 reiserfs_info(s, "Truncating %k to %Ld ..",

272 INODE_PKEY(inode), inode->i_size);

273 reiserfs_truncate_file(inode,

274 0

275 /*don't update modification time */

276 );

277 retval = remove_save_link(inode, truncate);

278 } else {

279 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;

280 /* not completed unlink (rmdir) found */

281 reiserfs_info(s, "Removing %k..", INODE_PKEY(inode));

282 /* removal gets completed in iput */

283 retval = 0;

284 }

285

286 iput(inode);

287 printk("done\n");

288 done++;

289 }

290 REISERFS_SB(s)->s_is_unlinked_ok = 0;

291

292 #ifdef CONFIG_QUOTA

293 /* Turn quotas off */

294 for (i = 0; i < MAXQUOTAS; i++) {

295 if (sb_dqopt(s)->files[i])

296 vfs_quota_off_mount(s, i);

297 }

298 if (ms_active_set)

299 /* Restore the flag back */

300 s->s_flags &= ~MS_ACTIVE;

301 #endif

302 pathrelse(&path);

303 if (done)

304 reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "

305 "Completed\n", done);

306 return retval;

307 }

308

309 /* to protect file being unlinked from getting lost we "safe" link files

310 being unlinked. This link will be deleted in the same transaction with last

311 item of file. mounting the filesytem we scan all these links and remove

312 files which almost got lost */

313 void add_save_link(struct reiserfs_transaction_handle *th,

314 struct inode *inode, int truncate)

315 {

316 INITIALIZE_PATH(path);

317 int retval;

318 struct cpu_key key;

319 struct item_head ih;

320 __le32 link;

321

322 BUG_ON(!th->t_trans_id);

323

324 /* file can only get one "save link" of each kind */

325 RFALSE(truncate &&

326 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask),

327 "saved link already exists for truncated inode %lx",

328 (long)inode->i_ino);

329 RFALSE(!truncate &&

330 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask),

331 "saved link already exists for unlinked inode %lx",

332 (long)inode->i_ino);

333

334 /* setup key of "save" link */

335 key.version = KEY_FORMAT_3_5;

336 key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;

337 key.on_disk_key.k_objectid = inode->i_ino;

338 if (!truncate) {

339 /* unlink, rmdir, rename */

340 set_cpu_key_k_offset(&key, 1 + inode->i_sb->s_blocksize);

341 set_cpu_key_k_type(&key, TYPE_DIRECT);

342

343 /* item head of "safe" link */

344 make_le_item_head(&ih, &key, key.version,

345 1 + inode->i_sb->s_blocksize, TYPE_DIRECT,

346 4 /*length */ , 0xffff /*free space */ );

347 } else {

348 /* truncate */

349 if (S_ISDIR(inode->i_mode))

350 reiserfs_warning(inode->i_sb,

351 "green-2102: Adding a truncate savelink for a directory %k! Please report",

352 INODE_PKEY(inode));

353 set_cpu_key_k_offset(&key, 1);

354 set_cpu_key_k_type(&key, TYPE_INDIRECT);

355

356 /* item head of "safe" link */

357 make_le_item_head(&ih, &key, key.version, 1, TYPE_INDIRECT,

358 4 /*length */ , 0 /*free space */ );

359 }

360 key.key_length = 3;

361

362 /* look for its place in the tree */

363 retval = search_item(inode->i_sb, &key, &path);

364 if (retval != ITEM_NOT_FOUND) {

365 if (retval != -ENOSPC)

366 reiserfs_warning(inode->i_sb, "vs-2100: add_save_link:"

367 "search_by_key (%K) returned %d", &key,

368 retval);

369 pathrelse(&path);

370 return;

371 }

372

373 /* body of "save" link */

374 link = INODE_PKEY(inode)->k_dir_id;

375

376 /* put "save" link inot tree, don't charge quota to anyone */

377 retval =

378 reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);

379 if (retval) {

380 if (retval != -ENOSPC)

381 reiserfs_warning(inode->i_sb,

382 "vs-2120: add_save_link: insert_item returned %d",

383 retval);

384 } else {

385 if (truncate)

386 REISERFS_I(inode)->i_flags |=

387 i_link_saved_truncate_mask;

388 else

389 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;

390 }

391 }

392

393 /* this opens transaction unlike add_save_link */

394 int remove_save_link(struct inode *inode, int truncate)

395 {

396 struct reiserfs_transaction_handle th;

397 struct reiserfs_key key;

398 int err;

399

400 /* we are going to do one balancing only */

401 err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);

402 if (err)

403 return err;

404

405 /* setup key of "save" link */

406 key.k_dir_id = cpu_to_le32(MAX_KEY_OBJECTID);

407 key.k_objectid = INODE_PKEY(inode)->k_objectid;

408 if (!truncate) {

409 /* unlink, rmdir, rename */

410 set_le_key_k_offset(KEY_FORMAT_3_5, &key,

411 1 + inode->i_sb->s_blocksize);

412 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT);

413 } else {

414 /* truncate */

415 set_le_key_k_offset(KEY_FORMAT_3_5, &key, 1);

416 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_INDIRECT);

417 }

418

419 if ((truncate &&

420 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) ||

421 (!truncate &&

422 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask)))

423 /* don't take quota bytes from anywhere */

424 reiserfs_delete_solid_item(&th, NULL, &key);

425 if (!truncate) {

426 reiserfs_release_objectid(&th, inode->i_ino);

427 REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask;

428 } else

429 REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask;

430

431 return journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);

432 }

433

434 static void reiserfs_put_super(struct super_block *s)

435 {

436 int i;

437 struct reiserfs_transaction_handle th;

438 th.t_trans_id = 0;

439

440 if (REISERFS_SB(s)->xattr_root) {

441 d_invalidate(REISERFS_SB(s)->xattr_root);

442 dput(REISERFS_SB(s)->xattr_root);

443 }

444

445 if (REISERFS_SB(s)->priv_root) {

446 d_invalidate(REISERFS_SB(s)->priv_root);

447 dput(REISERFS_SB(s)->priv_root);

448 }

449

450 /* change file system state to current state if it was mounted with read-write permissions */

451 if (!(s->s_flags & MS_RDONLY)) {

452 if (!journal_begin(&th, s, 10)) {

453 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),

454 1);

455 set_sb_umount_state(SB_DISK_SUPER_BLOCK(s),

456 REISERFS_SB(s)->s_mount_state);

457 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));

458 }

459 }

460

461 /* note, journal_release checks for readonly mount, and can decide not

462 ** to do a journal_end

463 */

464 journal_release(&th, s);

465

466 for (i = 0; i < SB_BMAP_NR(s); i++)

467 brelse(SB_AP_BITMAP(s)[i].bh);

468

469 vfree(SB_AP_BITMAP(s));

470

471 brelse(SB_BUFFER_WITH_SB(s));

472

473 print_statistics(s);

474

475 if (REISERFS_SB(s)->reserved_blocks != 0) {

476 reiserfs_warning(s,

477 "green-2005: reiserfs_put_super: reserved blocks left %d",

478 REISERFS_SB(s)->reserved_blocks);

479 }

480

481 reiserfs_proc_info_done(s);

482

483 kfree(s->s_fs_info);

484 s->s_fs_info = NULL;

485

486 return;

487 }

488

489 static kmem_cache_t *reiserfs_inode_cachep;

490

491 static struct inode *reiserfs_alloc_inode(struct super_block *sb)

492 {

493 struct reiserfs_inode_info *ei;

494 ei = (struct reiserfs_inode_info *)

495 kmem_cache_alloc(reiserfs_inode_cachep, SLAB_KERNEL);

496 if (!ei)

497 return NULL;

498 return &ei->vfs_inode;

499 }

500

501 static void reiserfs_destroy_inode(struct inode *inode)

502 {

503 kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));

504 }

505

506 static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)

507 {

508 struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;

509

510 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) ==

511 SLAB_CTOR_CONSTRUCTOR) {

512 INIT_LIST_HEAD(&ei->i_prealloc_list);

513 inode_init_once(&ei->vfs_inode);

514 ei->i_acl_access = NULL;

515 ei->i_acl_default = NULL;

516 }

517 }

518

519 static int init_inodecache(void)

520 {

521 reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",

522 sizeof(struct

523 reiserfs_inode_info),

524 0, SLAB_RECLAIM_ACCOUNT,

525 init_once, NULL);

526 if (reiserfs_inode_cachep == NULL)

527 return -ENOMEM;

528 return 0;

529 }

530

531 static void destroy_inodecache(void)

532 {

533 if (kmem_cache_destroy(reiserfs_inode_cachep))

534 reiserfs_warning(NULL,

535 "reiserfs_inode_cache: not all structures were freed");

536 }

537

538 /* we don't mark inodes dirty, we just log them */

539 static void reiserfs_dirty_inode(struct inode *inode)

540 {

541 struct reiserfs_transaction_handle th;

542

543 int err = 0;

544 if (inode->i_sb->s_flags & MS_RDONLY) {

545 reiserfs_warning(inode->i_sb,

546 "clm-6006: writing inode %lu on readonly FS",

547 inode->i_ino);

548 return;

549 }

550 reiserfs_write_lock(inode->i_sb);

551

552 /* this is really only used for atime updates, so they don't have

553 ** to be included in O_SYNC or fsync

554 */

555 err = journal_begin(&th, inode->i_sb, 1);

556 if (err) {

557 reiserfs_write_unlock(inode->i_sb);

558 return;

559 }

560 reiserfs_update_sd(&th, inode);

561 journal_end(&th, inode->i_sb, 1);

562 reiserfs_write_unlock(inode->i_sb);

563 }

564

565 static void reiserfs_clear_inode(struct inode *inode)

566 {

567 struct posix_acl *acl;

568

569 acl = REISERFS_I(inode)->i_acl_access;

570 if (acl && !IS_ERR(acl))

571 posix_acl_release(acl);

572 REISERFS_I(inode)->i_acl_access = NULL;

573

574 acl = REISERFS_I(inode)->i_acl_default;

575 if (acl && !IS_ERR(acl))

576 posix_acl_release(acl);

577 REISERFS_I(inode)->i_acl_default = NULL;

578 }

579

580 #ifdef CONFIG_QUOTA

581 static ssize_t reiserfs_quota_write(struct super_block *, int, const char *,

582 size_t, loff_t);

583 static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t,

584 loff_t);

585 #endif

586

587 static struct super_operations reiserfs_sops = {

588 .alloc_inode = reiserfs_alloc_inode,

589 .destroy_inode = reiserfs_destroy_inode,

590 .write_inode = reiserfs_write_inode,

591 .dirty_inode = reiserfs_dirty_inode,

592 .delete_inode = reiserfs_delete_inode,

593 .clear_inode = reiserfs_clear_inode,

594 .put_super = reiserfs_put_super,

595 .write_super = reiserfs_write_super,

596 .sync_fs = reiserfs_sync_fs,

597 .write_super_lockfs = reiserfs_write_super_lockfs,

598 .unlockfs = reiserfs_unlockfs,

599 .statfs = reiserfs_statfs,

600 .remount_fs = reiserfs_remount,

601 #ifdef CONFIG_QUOTA

602 .quota_read = reiserfs_quota_read,

603 .quota_write = reiserfs_quota_write,

604 #endif

605 };

606

607 #ifdef CONFIG_QUOTA

608 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")

609

610 static int reiserfs_dquot_initialize(struct inode *, int);

611 static int reiserfs_dquot_drop(struct inode *);

612 static int reiserfs_write_dquot(struct dquot *);

613 static int reiserfs_acquire_dquot(struct dquot *);

614 static int reiserfs_release_dquot(struct dquot *);

615 static int reiserfs_mark_dquot_dirty(struct dquot *);

616 static int reiserfs_write_info(struct super_block *, int);

617 static int reiserfs_quota_on(struct super_block *, int, int, char *);

618

619 static struct dquot_operations reiserfs_quota_operations = {

620 .initialize = reiserfs_dquot_initialize,

621 .drop = reiserfs_dquot_drop,

622 .alloc_space = dquot_alloc_space,

623 .alloc_inode = dquot_alloc_inode,

624 .free_space = dquot_free_space,

625 .free_inode = dquot_free_inode,

626 .transfer = dquot_transfer,

627 .write_dquot = reiserfs_write_dquot,

628 .acquire_dquot = reiserfs_acquire_dquot,

629 .release_dquot = reiserfs_release_dquot,

630 .mark_dirty = reiserfs_mark_dquot_dirty,

631 .write_info = reiserfs_write_info,

632 };

633

634 static struct quotactl_ops reiserfs_qctl_operations = {

635 .quota_on = reiserfs_quota_on,

636 .quota_off = vfs_quota_off,

637 .quota_sync = vfs_quota_sync,

638 .get_info = vfs_get_dqinfo,

639 .set_info = vfs_set_dqinfo,

640 .get_dqblk = vfs_get_dqblk,

641 .set_dqblk = vfs_set_dqblk,

642 };

643 #endif

644

645 static struct export_operations reiserfs_export_ops = {

646 .encode_fh = reiserfs_encode_fh,

647 .decode_fh = reiserfs_decode_fh,

648 .get_parent = reiserfs_get_parent,

649 .get_dentry = reiserfs_get_dentry,

650 };

651

652 /* this struct is used in reiserfs_getopt () for containing the value for those

653 mount options that have values rather than being toggles. */

654 typedef struct {

655 char *value;

656 int setmask; /* bitmask which is to set on mount_options bitmask when this

657 value is found, 0 is no bits are to be changed. */

658 int clrmask; /* bitmask which is to clear on mount_options bitmask when this

659 value is found, 0 is no bits are to be changed. This is

660 applied BEFORE setmask */

661 } arg_desc_t;

662

663 /* Set this bit in arg_required to allow empty arguments */

664 #define REISERFS_OPT_ALLOWEMPTY 31

665

666 /* this struct is used in reiserfs_getopt() for describing the set of reiserfs

667 mount options */

668 typedef struct {

669 char *option_name;

670 int arg_required; /* 0 if argument is not required, not 0 otherwise */

671 const arg_desc_t *values; /* list of values accepted by an option */

672 int setmask; /* bitmask which is to set on mount_options bitmask when this

673 value is found, 0 is no bits are to be changed. */

674 int clrmask; /* bitmask which is to clear on mount_options bitmask when this

675 value is found, 0 is no bits are to be changed. This is

676 applied BEFORE setmask */

677 } opt_desc_t;

678

679 /* possible values for -o data= */

680 static const arg_desc_t logging_mode[] = {

681 {"ordered", 1 << REISERFS_DATA_ORDERED,

682 (1 << REISERFS_DATA_LOG | 1 << REISERFS_DATA_WRITEBACK)},

683 {"journal", 1 << REISERFS_DATA_LOG,

684 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)},

685 {"writeback", 1 << REISERFS_DATA_WRITEBACK,

686 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)},

687 {NULL, 0}

688 };

689

690 /* possible values for -o barrier= */

691 static const arg_desc_t barrier_mode[] = {

692 {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},

693 {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},

694 {NULL, 0}

695 };

696

697 /* possible values for "-o block-allocator=" and bits which are to be set in

698 s_mount_opt of reiserfs specific part of in-core super block */

699 static const arg_desc_t balloc[] = {

700 {"noborder", 1 << REISERFS_NO_BORDER, 0},

701 {"border", 0, 1 << REISERFS_NO_BORDER},

702 {"no_unhashed_relocation", 1 << REISERFS_NO_UNHASHED_RELOCATION, 0},

703 {"hashed_relocation", 1 << REISERFS_HASHED_RELOCATION, 0},

704 {"test4", 1 << REISERFS_TEST4, 0},

705 {"notest4", 0, 1 << REISERFS_TEST4},

706 {NULL, 0, 0}

707 };

708

709 static const arg_desc_t tails[] = {

710 {"on", 1 << REISERFS_LARGETAIL, 1 << REISERFS_SMALLTAIL},

711 {"off", 0, (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},

712 {"small", 1 << REISERFS_SMALLTAIL, 1 << REISERFS_LARGETAIL},

713 {NULL, 0, 0}

714 };

715

716 static const arg_desc_t error_actions[] = {

717 {"panic", 1 << REISERFS_ERROR_PANIC,

718 (1 << REISERFS_ERROR_RO | 1 << REISERFS_ERROR_CONTINUE)},

719 {"ro-remount", 1 << REISERFS_ERROR_RO,

720 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_CONTINUE)},

721 #ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG

722 {"continue", 1 << REISERFS_ERROR_CONTINUE,

723 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},

724 #endif

725 {NULL, 0, 0},

726 };

727

728 int reiserfs_default_io_size = 128 * 1024; /* Default recommended I/O size is 128k.

729 There might be broken applications that are

730 confused by this. Use nolargeio mount option

731 to get usual i/o size = PAGE_SIZE.

732 */

733

734 /* proceed only one option from a list *cur - string containing of mount options

735 opts - array of options which are accepted

736 opt_arg - if option is found and requires an argument and if it is specifed

737 in the input - pointer to the argument is stored here

738 bit_flags - if option requires to set a certain bit - it is set here

739 return -1 if unknown option is found, opt->arg_required otherwise */

740 static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,

741 char **opt_arg, unsigned long *bit_flags)

742 {

743 char *p;

744 /* foo=bar,

745 ^ ^ ^

746 | | +-- option_end

747 | +-- arg_start

748 +-- option_start

749 */

750 const opt_desc_t *opt;

751 const arg_desc_t *arg;

752

753 p = *cur;

754

755 /* assume argument cannot contain commas */

756 *cur = strchr(p, ',');

757 if (*cur) {

758 *(*cur) = '\0';

759 (*cur)++;

760 }

761

762 if (!strncmp(p, "alloc=", 6)) {

763 /* Ugly special case, probably we should redo options parser so that

764 it can understand several arguments for some options, also so that

765 it can fill several bitfields with option values. */

766 if (reiserfs_parse_alloc_options(s, p + 6)) {

767 return -1;

768 } else {

769 return 0;

770 }

771 }

772

773 /* for every option in the list */

774 for (opt = opts; opt->option_name; opt++) {

775 if (!strncmp(p, opt->option_name, strlen(opt->option_name))) {

776 if (bit_flags) {

777 if (opt->clrmask ==

778 (1 << REISERFS_UNSUPPORTED_OPT))

779 reiserfs_warning(s, "%s not supported.",

780 p);

781 else

782 *bit_flags &= ~opt->clrmask;

783 if (opt->setmask ==

784 (1 << REISERFS_UNSUPPORTED_OPT))

785 reiserfs_warning(s, "%s not supported.",

786 p);

787 else

788 *bit_flags |= opt->setmask;

789 }

790 break;

791 }

792 }

793 if (!opt->option_name) {

794 reiserfs_warning(s, "unknown mount option \"%s\"", p);

795 return -1;

796 }

797

798 p += strlen(opt->option_name);

799 switch (*p) {

800 case '=':

801 if (!opt->arg_required) {

802 reiserfs_warning(s,

803 "the option \"%s\" does not require an argument",

804 opt->option_name);

805 return -1;

806 }

807 break;

808

809 case 0:

810 if (opt->arg_required) {

811 reiserfs_warning(s,

812 "the option \"%s\" requires an argument",

813 opt->option_name);

814 return -1;

815 }

816 break;

817 default:

818 reiserfs_warning(s, "head of option \"%s\" is only correct",

819 opt->option_name);

820 return -1;

821 }

822

823 /* move to the argument, or to next option if argument is not required */

824 p++;

825

826 if (opt->arg_required

827 && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))

828 && !strlen(p)) {

829 /* this catches "option=," if not allowed */

830 reiserfs_warning(s, "empty argument for \"%s\"",

831 opt->option_name);

832 return -1;

833 }

834

835 if (!opt->values) {

836 /* *=NULLopt_arg contains pointer to argument */

837 *opt_arg = p;

838 return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY);

839 }

840

841 /* values possible for this option are listed in opt->values */

842 for (arg = opt->values; arg->value; arg++) {

843 if (!strcmp(p, arg->value)) {

844 if (bit_flags) {

845 *bit_flags &= ~arg->clrmask;

846 *bit_flags |= arg->setmask;

847 }

848 return opt->arg_required;

849 }

850 }

851

852 reiserfs_warning(s, "bad value \"%s\" for option \"%s\"", p,

853 opt->option_name);

854 return -1;

855 }

856

857 /* returns 0 if something is wrong in option string, 1 - otherwise */

858 static int reiserfs_parse_options(struct super_block *s, char *options, /* string given via mount's -o */

859 unsigned long *mount_options,

860 /* after the parsing phase, contains the

861 collection of bitflags defining what

862 mount options were selected. */

863 unsigned long *blocks, /* strtol-ed from NNN of resize=NNN */

864 char **jdev_name,

865 unsigned int *commit_max_age)

866 {

867 int c;

868 char *arg = NULL;

869 char *pos;

870 opt_desc_t opts[] = {

871 /* Compatibility stuff, so that -o notail for old setups still work */

872 {"tails",.arg_required = 't',.values = tails},

873 {"notail",.clrmask =

874 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},

875 {"conv",.setmask = 1 << REISERFS_CONVERT},

876 {"attrs",.setmask = 1 << REISERFS_ATTRS},

877 {"noattrs",.clrmask = 1 << REISERFS_ATTRS},

878 #ifdef CONFIG_REISERFS_FS_XATTR

879 {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},

880 {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},

881 #else

882 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},

883 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},

884 #endif

885 #ifdef CONFIG_REISERFS_FS_POSIX_ACL

886 {"acl",.setmask = 1 << REISERFS_POSIXACL},

887 {"noacl",.clrmask = 1 << REISERFS_POSIXACL},

888 #else

889 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},

890 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},

891 #endif

892 {"nolog",}, /* This is unsupported */

893 {"replayonly",.setmask = 1 << REPLAYONLY},

894 {"block-allocator",.arg_required = 'a',.values = balloc},

895 {"data",.arg_required = 'd',.values = logging_mode},

896 {"barrier",.arg_required = 'b',.values = barrier_mode},

897 {"resize",.arg_required = 'r',.values = NULL},

898 {"jdev",.arg_required = 'j',.values = NULL},

899 {"nolargeio",.arg_required = 'w',.values = NULL},

900 {"commit",.arg_required = 'c',.values = NULL},

901 {"usrquota",.setmask = 1 << REISERFS_QUOTA},

902 {"grpquota",.setmask = 1 << REISERFS_QUOTA},

903 {"noquota",.clrmask = 1 << REISERFS_QUOTA},

904 {"errors",.arg_required = 'e',.values = error_actions},

905 {"usrjquota",.arg_required =

906 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},

907 {"grpjquota",.arg_required =

908 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},

909 {"jqfmt",.arg_required = 'f',.values = NULL},

910 {NULL,}

911 };

912

913 *blocks = 0;

914 if (!options || !*options)

915 /* use default configuration: create tails, journaling on, no

916 conversion to newest format */

917 return 1;

918

919 for (pos = options; pos;) {

920 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);

921 if (c == -1)

922 /* wrong option is given */

923 return 0;

924

925 if (c == 'r') {

926 char *p;

927

928 p = NULL;

929 /* "resize=NNN" or "resize=auto" */

930

931 if (!strcmp(arg, "auto")) {

932 /* From JFS code, to auto-get the size. */

933 *blocks =

934 s->s_bdev->bd_inode->i_size >> s->

935 s_blocksize_bits;

936 } else {

937 *blocks = simple_strtoul(arg, &p, 0);

938 if (*p != '\0') {

939 /* NNN does not look like a number */

940 reiserfs_warning(s,

941 "reiserfs_parse_options: bad value %s",

942 arg);

943 return 0;

944 }

945 }

946 }

947

948 if (c == 'c') {

949 char *p = NULL;

950 unsigned long val = simple_strtoul(arg, &p, 0);

951 /* commit=NNN (time in seconds) */

952 if (*p != '\0' || val >= (unsigned int)-1) {

953 reiserfs_warning(s,

954 "reiserfs_parse_options: bad value %s",

955 arg);

956 return 0;

957 }

958 *commit_max_age = (unsigned int)val;

959 }

960

961 if (c == 'w') {

962 char *p = NULL;

963 int val = simple_strtoul(arg, &p, 0);

964

965 if (*p != '\0') {

966 reiserfs_warning(s,

967 "reiserfs_parse_options: non-numeric value %s for nolargeio option",

968 arg);

969 return 0;

970 }

971 if (val)

972 reiserfs_default_io_size = PAGE_SIZE;

973 else

974 reiserfs_default_io_size = 128 * 1024;

975 }

976

977 if (c == 'j') {

978 if (arg && *arg && jdev_name) {

979 if (*jdev_name) { //Hm, already assigned?

980 reiserfs_warning(s,

981 "reiserfs_parse_options: journal device was already specified to be %s",

982 *jdev_name);

983 return 0;

984 }

985 *jdev_name = arg;

986 }

987 }

988 #ifdef CONFIG_QUOTA

989 if (c == 'u' || c == 'g') {

990 int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;

991

992 if (sb_any_quota_enabled(s)) {

993 reiserfs_warning(s,

994 "reiserfs_parse_options: cannot change journalled quota options when quota turned on.");

995 return 0;

996 }

997 if (*arg) { /* Some filename specified? */

998 if (REISERFS_SB(s)->s_qf_names[qtype]

999 && strcmp(REISERFS_SB(s)->s_qf_names[qtype],

1000 arg)) {

1001 reiserfs_warning(s,

1002 "reiserfs_parse_options: %s quota file already specified.",

1003 QTYPE2NAME(qtype));

1004 return 0;

1005 }

1006 if (strchr(arg, '/')) {

1007 reiserfs_warning(s,

1008 "reiserfs_parse_options: quotafile must be on filesystem root.");

1009 return 0;

1010 }

1011 REISERFS_SB(s)->s_qf_names[qtype] =

1012 kmalloc(strlen(arg) + 1, GFP_KERNEL);

1013 if (!REISERFS_SB(s)->s_qf_names[qtype]) {

1014 reiserfs_warning(s,

1015 "reiserfs_parse_options: not enough memory for storing quotafile name.");

1016 return 0;

1017 }

1018 strcpy(REISERFS_SB(s)->s_qf_names[qtype], arg);

1019 *mount_options |= 1 << REISERFS_QUOTA;

1020 } else {

1021 kfree(REISERFS_SB(s)->s_qf_names[qtype]);

1022 REISERFS_SB(s)->s_qf_names[qtype] = NULL;

1023 }

1024 }

1025 if (c == 'f') {

1026 if (!strcmp(arg, "vfsold"))

1027 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_OLD;

1028 else if (!strcmp(arg, "vfsv0"))

1029 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_V0;

1030 else {

1031 reiserfs_warning(s,

1032 "reiserfs_parse_options: unknown quota format specified.");

1033 return 0;

1034 }

1035 }

1036 #else

1037 if (c == 'u' || c == 'g' || c == 'f') {

1038 reiserfs_warning(s,

1039 "reiserfs_parse_options: journalled quota options not supported.");

1040 return 0;

1041 }

1042 #endif

1043 }

1044

1045 #ifdef CONFIG_QUOTA

1046 if (!REISERFS_SB(s)->s_jquota_fmt

1047 && (REISERFS_SB(s)->s_qf_names[USRQUOTA]

1048 || REISERFS_SB(s)->s_qf_names[GRPQUOTA])) {

1049 reiserfs_warning(s,

1050 "reiserfs_parse_options: journalled quota format not specified.");

1051 return 0;

1052 }

1053 /* This checking is not precise wrt the quota type but for our purposes it is sufficient */

1054 if (!(*mount_options & (1 << REISERFS_QUOTA))

1055 && sb_any_quota_enabled(s)) {

1056 reiserfs_warning(s,

1057 "reiserfs_parse_options: quota options must be present when quota is turned on.");

1058 return 0;

1059 }

1060 #endif

1061

1062 return 1;

1063 }

1064

1065 static void switch_data_mode(struct super_block *s, unsigned long mode)

1066 {

1067 REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |

1068 (1 << REISERFS_DATA_ORDERED) |

1069 (1 << REISERFS_DATA_WRITEBACK));

1070 REISERFS_SB(s)->s_mount_opt |= (1 << mode);

1071 }

1072

1073 static void handle_data_mode(struct super_block *s, unsigned long mount_options)

1074 {

1075 if (mount_options & (1 << REISERFS_DATA_LOG)) {

1076 if (!reiserfs_data_log(s)) {

1077 switch_data_mode(s, REISERFS_DATA_LOG);

1078 reiserfs_info(s, "switching to journaled data mode\n");

1079 }

1080 } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {

1081 if (!reiserfs_data_ordered(s)) {

1082 switch_data_mode(s, REISERFS_DATA_ORDERED);

1083 reiserfs_info(s, "switching to ordered data mode\n");

1084 }

1085 } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {

1086 if (!reiserfs_data_writeback(s)) {

1087 switch_data_mode(s, REISERFS_DATA_WRITEBACK);

1088 reiserfs_info(s, "switching to writeback data mode\n");

1089 }

1090 }

1091 }

1092

1093 static void handle_barrier_mode(struct super_block *s, unsigned long bits)

1094 {

1095 int flush = (1 << REISERFS_BARRIER_FLUSH);

1096 int none = (1 << REISERFS_BARRIER_NONE);

1097 int all_barrier = flush | none;

1098

1099 if (bits & all_barrier) {

1100 REISERFS_SB(s)->s_mount_opt &= ~all_barrier;

1101 if (bits & flush) {

1102 REISERFS_SB(s)->s_mount_opt |= flush;

1103 printk("reiserfs: enabling write barrier flush mode\n");

1104 } else if (bits & none) {

1105 REISERFS_SB(s)->s_mount_opt |= none;

1106 printk("reiserfs: write barriers turned off\n");

1107 }

1108 }

1109 }

1110

1111 static void handle_attrs(struct super_block *s)

1112 {

1113 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);

1114

1115 if (reiserfs_attrs(s)) {

1116 if (old_format_only(s)) {

1117 reiserfs_warning(s,

1118 "reiserfs: cannot support attributes on 3.5.x disk format");

1119 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);

1120 return;

1121 }

1122 if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {

1123 reiserfs_warning(s,

1124 "reiserfs: cannot support attributes until flag is set in super-block");

1125 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);

1126 }

1127 } else if (le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared) {

1128 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ATTRS);

1129 }

1130 }

1131

1132 static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)

1133 {

1134 struct reiserfs_super_block *rs;

1135 struct reiserfs_transaction_handle th;

1136 unsigned long blocks;

1137 unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;

1138 unsigned long safe_mask = 0;

1139 unsigned int commit_max_age = (unsigned int)-1;

1140 struct reiserfs_journal *journal = SB_JOURNAL(s);

1141 int err;

1142 #ifdef CONFIG_QUOTA

1143 int i;

1144 #endif

1145

1146 rs = SB_DISK_SUPER_BLOCK(s);

1147

1148 if (!reiserfs_parse_options

1149 (s, arg, &mount_options, &blocks, NULL, &commit_max_age)) {

1150 #ifdef CONFIG_QUOTA

1151 for (i = 0; i < MAXQUOTAS; i++) {

1152 kfree(REISERFS_SB(s)->s_qf_names[i]);

1153 REISERFS_SB(s)->s_qf_names[i] = NULL;

1154 }

1155 #endif

1156 return -EINVAL;

1157 }

1158

1159 handle_attrs(s);

1160

1161 /* Add options that are safe here */

1162 safe_mask |= 1 << REISERFS_SMALLTAIL;

1163 safe_mask |= 1 << REISERFS_LARGETAIL;

1164 safe_mask |= 1 << REISERFS_NO_BORDER;

1165 safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;

1166 safe_mask |= 1 << REISERFS_HASHED_RELOCATION;

1167 safe_mask |= 1 << REISERFS_TEST4;

1168 safe_mask |= 1 << REISERFS_ATTRS;

1169 safe_mask |= 1 << REISERFS_XATTRS_USER;

1170 safe_mask |= 1 << REISERFS_POSIXACL;

1171 safe_mask |= 1 << REISERFS_BARRIER_FLUSH;

1172 safe_mask |= 1 << REISERFS_BARRIER_NONE;

1173 safe_mask |= 1 << REISERFS_ERROR_RO;

1174 safe_mask |= 1 << REISERFS_ERROR_CONTINUE;

1175 safe_mask |= 1 << REISERFS_ERROR_PANIC;

1176 safe_mask |= 1 << REISERFS_QUOTA;

1177

1178 /* Update the bitmask, taking care to keep

1179 * the bits we're not allowed to change here */

1180 REISERFS_SB(s)->s_mount_opt =

1181 (REISERFS_SB(s)->

1182 s_mount_opt & ~safe_mask) | (mount_options & safe_mask);

1183

1184 if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {

1185 journal->j_max_commit_age = commit_max_age;

1186 journal->j_max_trans_age = commit_max_age;

1187 } else if (commit_max_age == 0) {

1188 /* 0 means restore defaults. */

1189 journal->j_max_commit_age = journal->j_default_max_commit_age;

1190 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;

1191 }

1192

1193 if (blocks) {

1194 int rc = reiserfs_resize(s, blocks);

1195 if (rc != 0)

1196 return rc;

1197 }

1198

1199 if (*mount_flags & MS_RDONLY) {

1200 reiserfs_xattr_init(s, *mount_flags);

1201 /* remount read-only */

1202 if (s->s_flags & MS_RDONLY)

1203 /* it is read-only already */

1204 return 0;

1205 /* try to remount file system with read-only permissions */

1206 if (sb_umount_state(rs) == REISERFS_VALID_FS

1207 || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {

1208 return 0;

1209 }

1210

1211 err = journal_begin(&th, s, 10);

1212 if (err)

1213 return err;

1214

1215 /* Mounting a rw partition read-only. */

1216 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);

1217 set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);

1218 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));

1219 } else {

1220 /* remount read-write */

1221 if (!(s->s_flags & MS_RDONLY)) {

1222 reiserfs_xattr_init(s, *mount_flags);

1223 return 0; /* We are read-write already */

1224 }

1225

1226 if (reiserfs_is_journal_aborted(journal))

1227 return journal->j_errno;

1228

1229 handle_data_mode(s, mount_options);

1230 handle_barrier_mode(s, mount_options);

1231 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);

1232 s->s_flags &= ~MS_RDONLY; /* now it is safe to call journal_begin */

1233 err = journal_begin(&th, s, 10);

1234 if (err)

1235 return err;

1236

1237 /* Mount a partition which is read-only, read-write */

1238 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);

1239 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);

1240 s->s_flags &= ~MS_RDONLY;

1241 set_sb_umount_state(rs, REISERFS_ERROR_FS);

1242 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */

1243 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));

1244 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;

1245 }

1246 /* this will force a full flush of all journal lists */

1247 SB_JOURNAL(s)->j_must_wait = 1;

1248 err = journal_end(&th, s, 10);

1249 if (err)

1250 return err;

1251 s->s_dirt = 0;

1252

1253 if (!(*mount_flags & MS_RDONLY)) {

1254 finish_unfinished(s);

1255 reiserfs_xattr_init(s, *mount_flags);

1256 }

1257

1258 return 0;

1259 }

1260

1261 /* load_bitmap_info_data - Sets up the reiserfs_bitmap_info structure from disk.

1262 * @sb - superblock for this filesystem

1263 * @bi - the bitmap info to be loaded. Requires that bi->bh is valid.

1264 *

1265 * This routine counts how many free bits there are, finding the first zero

1266 * as a side effect. Could also be implemented as a loop of test_bit() calls, or

1267 * a loop of find_first_zero_bit() calls. This implementation is similar to

1268 * find_first_zero_bit(), but doesn't return after it finds the first bit.

1269 * Should only be called on fs mount, but should be fairly efficient anyways.

1270 *

1271 * bi->first_zero_hint is considered unset if it == 0, since the bitmap itself

1272 * will * invariably occupt block 0 represented in the bitmap. The only

1273 * exception to this is when free_count also == 0, since there will be no

1274 * free blocks at all.

1275 */

1276

1277 static void load_bitmap_info_data(struct super_block *sb,

1278 struct reiserfs_bitmap_info *bi)

1279 {

1280 unsigned long *cur = (unsigned long *)bi->bh->b_data;

1281

1282 while ((char *)cur < (bi->bh->b_data + sb->s_blocksize)) {

1283

1284 /* No need to scan if all 0's or all 1's.

1285 * Since we're only counting 0's, we can simply ignore all 1's */

1286 if (*cur == 0) {

1287 if (bi->first_zero_hint == 0) {

1288 bi->first_zero_hint =

1289 ((char *)cur - bi->bh->b_data) << 3;

1290 }

1291 bi->free_count += sizeof(unsigned long) * 8;

1292 } else if (*cur != ~0L) {

1293 int b;

1294 for (b = 0; b < sizeof(unsigned long) * 8; b++) {

1295 if (!reiserfs_test_le_bit(b, cur)) {

1296 bi->free_count++;

1297 if (bi->first_zero_hint == 0)

1298 bi->first_zero_hint =

1299 (((char *)cur -

1300 bi->bh->b_data) << 3) + b;

1301 }

1302 }

1303 }

1304 cur++;

1305 }

1306

1307 #ifdef CONFIG_REISERFS_CHECK

1308 // This outputs a lot of unneded info on big FSes

1309 // reiserfs_warning ("bitmap loaded from block %d: %d free blocks",

1310 // bi->bh->b_blocknr, bi->free_count);

1311 #endif

1312 }

1313

1314 static int read_bitmaps(struct super_block *s)

1315 {

1316 int i, bmap_nr;

1317

1318 SB_AP_BITMAP(s) =

1319 vmalloc(sizeof(struct reiserfs_bitmap_info) * SB_BMAP_NR(s));

1320 if (SB_AP_BITMAP(s) == 0)

1321 return 1;

1322 memset(SB_AP_BITMAP(s), 0,

1323 sizeof(struct reiserfs_bitmap_info) * SB_BMAP_NR(s));

1324 for (i = 0, bmap_nr =

1325 REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize + 1;

1326 i < SB_BMAP_NR(s); i++, bmap_nr = s->s_blocksize * 8 * i) {

1327 SB_AP_BITMAP(s)[i].bh = sb_getblk(s, bmap_nr);

1328 if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh))

1329 ll_rw_block(READ, 1, &SB_AP_BITMAP(s)[i].bh);

1330 }

1331 for (i = 0; i < SB_BMAP_NR(s); i++) {

1332 wait_on_buffer(SB_AP_BITMAP(s)[i].bh);

1333 if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {

1334 reiserfs_warning(s, "sh-2029: reiserfs read_bitmaps: "

1335 "bitmap block (#%lu) reading failed",

1336 SB_AP_BITMAP(s)[i].bh->b_blocknr);

1337 for (i = 0; i < SB_BMAP_NR(s); i++)

1338 brelse(SB_AP_BITMAP(s)[i].bh);

1339 vfree(SB_AP_BITMAP(s));

1340 SB_AP_BITMAP(s) = NULL;

1341 return 1;

1342 }

1343 load_bitmap_info_data(s, SB_AP_BITMAP(s) + i);

1344 }

1345 return 0;

1346 }

1347

1348 static int read_old_bitmaps(struct super_block *s)

1349 {

1350 int i;

1351 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);

1352 int bmp1 = (REISERFS_OLD_DISK_OFFSET_IN_BYTES / s->s_blocksize) + 1; /* first of bitmap blocks */

1353

1354 /* read true bitmap */

1355 SB_AP_BITMAP(s) =

1356 vmalloc(sizeof(struct reiserfs_buffer_info *) * sb_bmap_nr(rs));

1357 if (SB_AP_BITMAP(s) == 0)

1358 return 1;

1359

1360 memset(SB_AP_BITMAP(s), 0,

1361 sizeof(struct reiserfs_buffer_info *) * sb_bmap_nr(rs));

1362

1363 for (i = 0; i < sb_bmap_nr(rs); i++) {

1364 SB_AP_BITMAP(s)[i].bh = sb_bread(s, bmp1 + i);

1365 if (!SB_AP_BITMAP(s)[i].bh)

1366 return 1;

1367 load_bitmap_info_data(s, SB_AP_BITMAP(s) + i);

1368 }

1369

1370 return 0;

1371 }

1372

1373 static int read_super_block(struct super_block *s, int offset)

1374 {

1375 struct buffer_head *bh;

1376 struct reiserfs_super_block *rs;

1377 int fs_blocksize;

1378

1379 bh = sb_bread(s, offset / s->s_blocksize);

1380 if (!bh) {

1381 reiserfs_warning(s, "sh-2006: read_super_block: "

1382 "bread failed (dev %s, block %lu, size %lu)",

1383 reiserfs_bdevname(s), offset / s->s_blocksize,

1384 s->s_blocksize);

1385 return 1;

1386 }

1387

1388 rs = (struct reiserfs_super_block *)bh->b_data;

1389 if (!is_any_reiserfs_magic_string(rs)) {

1390 brelse(bh);

1391 return 1;

1392 }

1393 //

1394 // ok, reiserfs signature (old or new) found in at the given offset

1395 //

1396 fs_blocksize = sb_blocksize(rs);

1397 brelse(bh);

1398 sb_set_blocksize(s, fs_blocksize);

1399

1400 bh = sb_bread(s, offset / s->s_blocksize);

1401 if (!bh) {

1402 reiserfs_warning(s, "sh-2007: read_super_block: "

1403 "bread failed (dev %s, block %lu, size %lu)\n",

1404 reiserfs_bdevname(s), offset / s->s_blocksize,

1405 s->s_blocksize);

1406 return 1;

1407 }

1408

1409 rs = (struct reiserfs_super_block *)bh->b_data;

1410 if (sb_blocksize(rs) != s->s_blocksize) {

1411 reiserfs_warning(s, "sh-2011: read_super_block: "

1412 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n",

1413 reiserfs_bdevname(s),

1414 (unsigned long long)bh->b_blocknr,

1415 s->s_blocksize);

1416 brelse(bh);

1417 return 1;

1418 }

1419

1420 if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {

1421 brelse(bh);

1422 reiserfs_warning(s,

1423 "Unfinished reiserfsck --rebuild-tree run detected. Please run\n"

1424 "reiserfsck --rebuild-tree and wait for a completion. If that fails\n"

1425 "get newer reiserfsprogs package");

1426 return 1;

1427 }

1428

1429 SB_BUFFER_WITH_SB(s) = bh;

1430 SB_DISK_SUPER_BLOCK(s) = rs;

1431

1432 if (is_reiserfs_jr(rs)) {

1433 /* magic is of non-standard journal filesystem, look at s_version to

1434 find which format is in use */

1435 if (sb_version(rs) == REISERFS_VERSION_2)

1436 reiserfs_warning(s,

1437 "read_super_block: found reiserfs format \"3.6\""

1438 " with non-standard journal");

1439 else if (sb_version(rs) == REISERFS_VERSION_1)

1440 reiserfs_warning(s,

1441 "read_super_block: found reiserfs format \"3.5\""

1442 " with non-standard journal");

1443 else {

1444 reiserfs_warning(s,

1445 "sh-2012: read_super_block: found unknown "

1446 "format \"%u\" of reiserfs with non-standard magic",

1447 sb_version(rs));

1448 return 1;

1449 }

1450 } else

1451 /* s_version of standard format may contain incorrect information,

1452 so we just look at the magic string */

1453 reiserfs_info(s,

1454 "found reiserfs format \"%s\" with standard journal\n",

1455 is_reiserfs_3_5(rs) ? "3.5" : "3.6");

1456

1457 s->s_op = &reiserfs_sops;

1458 s->s_export_op = &reiserfs_export_ops;

1459 #ifdef CONFIG_QUOTA

1460 s->s_qcop = &reiserfs_qctl_operations;

1461 s->dq_op = &reiserfs_quota_operations;

1462 #endif

1463

1464 /* new format is limited by the 32 bit wide i_blocks field, want to

1465 ** be one full block below that.

1466 */

1467 s->s_maxbytes = (512LL << 32) - s->s_blocksize;

1468 return 0;

1469 }

1470

1471 /* after journal replay, reread all bitmap and super blocks */

1472 static int reread_meta_blocks(struct super_block *s)

1473 {

1474 int i;

1475 ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));

1476 wait_on_buffer(SB_BUFFER_WITH_SB(s));

1477 if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {

1478 reiserfs_warning(s,

1479 "reread_meta_blocks, error reading the super");

1480 return 1;

1481 }

1482

1483 for (i = 0; i < SB_BMAP_NR(s); i++) {

1484 ll_rw_block(READ, 1, &(SB_AP_BITMAP(s)[i].bh));

1485 wait_on_buffer(SB_AP_BITMAP(s)[i].bh);

1486 if (!buffer_uptodate(SB_AP_BITMAP(s)[i].bh)) {

1487 reiserfs_warning(s,

1488 "reread_meta_blocks, error reading bitmap block number %d at %llu",

1489 i,

1490 (unsigned long long)SB_AP_BITMAP(s)[i].

1491 bh->b_blocknr);

1492 return 1;

1493 }

1494 }

1495 return 0;

1496

1497 }

1498

1499 /////////////////////////////////////////////////////

1500 // hash detection stuff

1501

1502 // if root directory is empty - we set default - Yura's - hash and

1503 // warn about it

1504 // FIXME: we look for only one name in a directory. If tea and yura

1505 // bith have the same value - we ask user to send report to the

1506 // mailing list

1507 static __u32 find_hash_out(struct super_block *s)

1508 {

1509 int retval;

1510 struct inode *inode;

1511 struct cpu_key key;

1512 INITIALIZE_PATH(path);

1513 struct reiserfs_dir_entry de;

1514 __u32 hash = DEFAULT_HASH;

1515

1516 inode = s->s_root->d_inode;

1517

1518 do { // Some serious "goto"-hater was there ;)

1519 u32 teahash, r5hash, yurahash;

1520

1521 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);

1522 retval = search_by_entry_key(s, &key, &path, &de);

1523 if (retval == IO_ERROR) {

1524 pathrelse(&path);

1525 return UNSET_HASH;

1526 }

1527 if (retval == NAME_NOT_FOUND)

1528 de.de_entry_num--;

1529 set_de_name_and_namelen(&de);

1530 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {

1531 /* allow override in this case */

1532 if (reiserfs_rupasov_hash(s)) {

1533 hash = YURA_HASH;

1534 }

1535 reiserfs_warning(s, "FS seems to be empty, autodetect "

1536 "is using the default hash");

1537 break;

1538 }

1539 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));

1540 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));

1541 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));

1542 if (((teahash == r5hash)

1543 &&

1544 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))

1545 == r5hash)) || ((teahash == yurahash)

1546 && (yurahash ==

1547 GET_HASH_VALUE(deh_offset

1548 (&

1549 (de.

1550 de_deh[de.

1551 de_entry_num])))))

1552 || ((r5hash == yurahash)

1553 && (yurahash ==

1554 GET_HASH_VALUE(deh_offset

1555 (&(de.de_deh[de.de_entry_num])))))) {

1556 reiserfs_warning(s,

1557 "Unable to automatically detect hash function. "

1558 "Please mount with -o hash={tea,rupasov,r5}",

1559 reiserfs_bdevname(s));

1560 hash = UNSET_HASH;

1561 break;

1562 }

1563 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==

1564 yurahash)

1565 hash = YURA_HASH;

1566 else if (GET_HASH_VALUE

1567 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)

1568 hash = TEA_HASH;

1569 else if (GET_HASH_VALUE

1570 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)

1571 hash = R5_HASH;

1572 else {

1573 reiserfs_warning(s, "Unrecognised hash function");

1574 hash = UNSET_HASH;

1575 }

1576 } while (0);

1577

1578 pathrelse(&path);

1579 return hash;

1580 }

1581

1582 // finds out which hash names are sorted with

1583 static int what_hash(struct super_block *s)

1584 {

1585 __u32 code;

1586

1587 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));

1588

1589 /* reiserfs_hash_detect() == true if any of the hash mount options

1590 ** were used. We must check them to make sure the user isn't

1591 ** using a bad hash value

1592 */

1593 if (code == UNSET_HASH || reiserfs_hash_detect(s))

1594 code = find_hash_out(s);

1595

1596 if (code != UNSET_HASH && reiserfs_hash_detect(s)) {

1597 /* detection has found the hash, and we must check against the

1598 ** mount options

1599 */

1600 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {

1601 reiserfs_warning(s, "Error, %s hash detected, "

1602 "unable to force rupasov hash",

1603 reiserfs_hashname(code));

1604 code = UNSET_HASH;

1605 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) {

1606 reiserfs_warning(s, "Error, %s hash detected, "

1607 "unable to force tea hash",

1608 reiserfs_hashname(code));

1609 code = UNSET_HASH;

1610 } else if (reiserfs_r5_hash(s) && code != R5_HASH) {

1611 reiserfs_warning(s, "Error, %s hash detected, "

1612 "unable to force r5 hash",

1613 reiserfs_hashname(code));

1614 code = UNSET_HASH;

1615 }

1616 } else {

1617 /* find_hash_out was not called or could not determine the hash */

1618 if (reiserfs_rupasov_hash(s)) {

1619 code = YURA_HASH;

1620 } else if (reiserfs_tea_hash(s)) {

1621 code = TEA_HASH;

1622 } else if (reiserfs_r5_hash(s)) {

1623 code = R5_HASH;

1624 }

1625 }

1626

1627 /* if we are mounted RW, and we have a new valid hash code, update

1628 ** the super

1629 */

1630 if (code != UNSET_HASH &&

1631 !(s->s_flags & MS_RDONLY) &&

1632 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {

1633 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);

1634 }

1635 return code;

1636 }

1637

1638 // return pointer to appropriate function

1639 static hashf_t hash_function(struct super_block *s)

1640 {

1641 switch (what_hash(s)) {

1642 case TEA_HASH:

1643 reiserfs_info(s, "Using tea hash to sort names\n");

1644 return keyed_hash;

1645 case YURA_HASH:

1646 reiserfs_info(s, "Using rupasov hash to sort names\n");

1647 return yura_hash;

1648 case R5_HASH:

1649 reiserfs_info(s, "Using r5 hash to sort names\n");

1650 return r5_hash;

1651 }

1652 return NULL;

1653 }

1654

1655 // this is used to set up correct value for old partitions

1656 static int function2code(hashf_t func)

1657 {

1658 if (func == keyed_hash)

1659 return TEA_HASH;

1660 if (func == yura_hash)

1661 return YURA_HASH;

1662 if (func == r5_hash)

1663 return R5_HASH;

1664

1665 BUG(); // should never happen

1666

1667 return 0;

1668 }

1669

1670 #define SWARN(silent, s, ...) \

1671 if (!(silent)) \

1672 reiserfs_warning (s, __VA_ARGS__)

1673

1674 static int reiserfs_fill_super(struct super_block *s, void *data, int silent)

1675 {

1676 struct inode *root_inode;

1677 int j;

1678 struct reiserfs_transaction_handle th;

1679 int old_format = 0;

1680 unsigned long blocks;

1681 unsigned int commit_max_age = 0;

1682 int jinit_done = 0;

1683 struct reiserfs_iget_args args;

1684 struct reiserfs_super_block *rs;

1685 char *jdev_name;

1686 struct reiserfs_sb_info *sbi;

1687 int errval = -EINVAL;

1688

1689 sbi = kmalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);

1690 if (!sbi) {

1691 errval = -ENOMEM;

1692 goto error;

1693 }

1694 s->s_fs_info = sbi;

1695 memset(sbi, 0, sizeof(struct reiserfs_sb_info));

1696 /* Set default values for options: non-aggressive tails, RO on errors */

1697 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);

1698 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);

1699 /* no preallocation minimum, be smart in

1700 reiserfs_file_write instead */

1701 REISERFS_SB(s)->s_alloc_options.preallocmin = 0;

1702 /* Preallocate by 16 blocks (17-1) at once */

1703 REISERFS_SB(s)->s_alloc_options.preallocsize = 17;

1704 /* Initialize the rwsem for xattr dir */

1705 init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);

1706

1707 /* setup default block allocator options */

1708 reiserfs_init_alloc_options(s);

1709

1710 jdev_name = NULL;

1711 if (reiserfs_parse_options

1712 (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,

1713 &commit_max_age) == 0) {

1714 goto error;

1715 }

1716

1717 if (blocks) {

1718 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option "

1719 "for remount only");

1720 goto error;

1721 }

1722

1723 /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */

1724 if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))

1725 old_format = 1;

1726 /* try new format (64-th 1k block), which can contain reiserfs super block */

1727 else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {

1728 SWARN(silent, s,

1729 "sh-2021: reiserfs_fill_super: can not find reiserfs on %s",

1730 reiserfs_bdevname(s));

1731 goto error;

1732 }

1733

1734 rs = SB_DISK_SUPER_BLOCK(s);

1735 /* Let's do basic sanity check to verify that underlying device is not

1736 smaller than the filesystem. If the check fails then abort and scream,

1737 because bad stuff will happen otherwise. */

1738 if (s->s_bdev && s->s_bdev->bd_inode

1739 && i_size_read(s->s_bdev->bd_inode) <

1740 sb_block_count(rs) * sb_blocksize(rs)) {

1741 SWARN(silent, s,

1742 "Filesystem on %s cannot be mounted because it is bigger than the device",

1743 reiserfs_bdevname(s));

1744 SWARN(silent, s,

1745 "You may need to run fsck or increase size of your LVM partition");

1746 SWARN(silent, s,

1747 "Or may be you forgot to reboot after fdisk when it told you to");

1748 goto error;

1749 }

1750

1751 sbi->s_mount_state = SB_REISERFS_STATE(s);

1752 sbi->s_mount_state = REISERFS_VALID_FS;

1753

1754 if (old_format ? read_old_bitmaps(s) : read_bitmaps(s)) {

1755 SWARN(silent, s,

1756 "jmacd-8: reiserfs_fill_super: unable to read bitmap");

1757 goto error;

1758 }

1759 #ifdef CONFIG_REISERFS_CHECK

1760 SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON");

1761 SWARN(silent, s, "- it is slow mode for debugging.");

1762 #endif

1763

1764 /* make data=ordered the default */

1765 if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&

1766 !reiserfs_data_writeback(s)) {

1767 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);

1768 }

1769

1770 if (reiserfs_data_log(s)) {

1771 reiserfs_info(s, "using journaled data mode\n");

1772 } else if (reiserfs_data_ordered(s)) {

1773 reiserfs_info(s, "using ordered data mode\n");

1774 } else {

1775 reiserfs_info(s, "using writeback data mode\n");

1776 }

1777 if (reiserfs_barrier_flush(s)) {

1778 printk("reiserfs: using flush barriers\n");

1779 }

1780 // set_device_ro(s->s_dev, 1) ;

1781 if (journal_init(s, jdev_name, old_format, commit_max_age)) {

1782 SWARN(silent, s,

1783 "sh-2022: reiserfs_fill_super: unable to initialize journal space");

1784 goto error;

1785 } else {

1786 jinit_done = 1; /* once this is set, journal_release must be called

1787 ** if we error out of the mount

1788 */

1789 }

1790 if (reread_meta_blocks(s)) {

1791 SWARN(silent, s,

1792 "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init");

1793 goto error;

1794 }

1795

1796 if (replay_only(s))

1797 goto error;

1798

1799 if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {

1800 SWARN(silent, s,

1801 "clm-7000: Detected readonly device, marking FS readonly");

1802 s->s_flags |= MS_RDONLY;

1803 }

1804 args.objectid = REISERFS_ROOT_OBJECTID;

1805 args.dirid = REISERFS_ROOT_PARENT_OBJECTID;

1806 root_inode =

1807 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,

1808 reiserfs_init_locked_inode, (void *)(&args));

1809 if (!root_inode) {

1810 SWARN(silent, s,

1811 "jmacd-10: reiserfs_fill_super: get root inode failed");

1812 goto error;

1813 }

1814

1815 if (root_inode->i_state & I_NEW) {

1816 reiserfs_read_locked_inode(root_inode, &args);

1817 unlock_new_inode(root_inode);

1818 }

1819

1820 s->s_root = d_alloc_root(root_inode);

1821 if (!s->s_root) {

1822 iput(root_inode);

1823 goto error;

1824 }

1825 // define and initialize hash function

1826 sbi->s_hash_function = hash_function(s);

1827 if (sbi->s_hash_function == NULL) {

1828 dput(s->s_root);

1829 s->s_root = NULL;

1830 goto error;

1831 }

1832

1833 if (is_reiserfs_3_5(rs)

1834 || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))

1835 set_bit(REISERFS_3_5, &(sbi->s_properties));

1836 else

1837 set_bit(REISERFS_3_6, &(sbi->s_properties));

1838

1839 if (!(s->s_flags & MS_RDONLY)) {

1840

1841 errval = journal_begin(&th, s, 1);

1842 if (errval) {

1843 dput(s->s_root);

1844 s->s_root = NULL;

1845 goto error;

1846 }

1847 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);

1848

1849 set_sb_umount_state(rs, REISERFS_ERROR_FS);

1850 set_sb_fs_state(rs, 0);

1851

1852 if (old_format_only(s)) {

1853 /* filesystem of format 3.5 either with standard or non-standard

1854 journal */

1855 if (convert_reiserfs(s)) {

1856 /* and -o conv is given */

1857 if (!silent)

1858 reiserfs_info(s,

1859 "converting 3.5 filesystem to the 3.6 format");

1860

1861 if (is_reiserfs_3_5(rs))

1862 /* put magic string of 3.6 format. 2.2 will not be able to

1863 mount this filesystem anymore */

1864 memcpy(rs->s_v1.s_magic,

1865 reiserfs_3_6_magic_string,

1866 sizeof

1867 (reiserfs_3_6_magic_string));

1868

1869 set_sb_version(rs, REISERFS_VERSION_2);

1870 reiserfs_convert_objectid_map_v1(s);

1871 set_bit(REISERFS_3_6, &(sbi->s_properties));

1872 clear_bit(REISERFS_3_5, &(sbi->s_properties));

1873 } else if (!silent) {

1874 reiserfs_info(s, "using 3.5.x disk format\n");

1875 }

1876 }

1877

1878 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));

1879 errval = journal_end(&th, s, 1);

1880 if (errval) {

1881 dput(s->s_root);

1882 s->s_root = NULL;

1883 goto error;

1884 }

1885

1886 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {

1887 dput(s->s_root);

1888 s->s_root = NULL;

1889 goto error;

1890 }

1891

1892 /* look for files which were to be removed in previous session */

1893 finish_unfinished(s);

1894 } else {

1895 if (old_format_only(s) && !silent) {

1896 reiserfs_info(s, "using 3.5.x disk format\n");

1897 }

1898

1899 if ((errval = reiserfs_xattr_init(s, s->s_flags))) {

1900 dput(s->s_root);

1901 s->s_root = NULL;

1902 goto error;

1903 }

1904 }

1905 // mark hash in super block: it could be unset. overwrite should be ok

1906 set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));

1907

1908 handle_attrs(s);

1909

1910 reiserfs_proc_info_init(s);

1911

1912 init_waitqueue_head(&(sbi->s_wait));

1913 spin_lock_init(&sbi->bitmap_lock);

1914

1915 return (0);

1916

1917 error:

1918 if (jinit_done) { /* kill the commit thread, free journal ram */

1919 journal_release_error(NULL, s);

1920 }

1921 if (SB_DISK_SUPER_BLOCK(s)) {

1922 for (j = 0; j < SB_BMAP_NR(s); j++) {

1923 if (SB_AP_BITMAP(s))

1924 brelse(SB_AP_BITMAP(s)[j].bh);

1925 }

1926 vfree(SB_AP_BITMAP(s));

1927 }

1928 if (SB_BUFFER_WITH_SB(s))

1929 brelse(SB_BUFFER_WITH_SB(s));

1930 #ifdef CONFIG_QUOTA

1931 for (j = 0; j < MAXQUOTAS; j++) {

1932 kfree(sbi->s_qf_names[j]);

1933 sbi->s_qf_names[j] = NULL;

1934 }

1935 #endif

1936 kfree(sbi);

1937

1938 s->s_fs_info = NULL;

1939 return errval;

1940 }

1941

1942 static int reiserfs_statfs(struct super_block *s, struct kstatfs *buf)

1943 {

1944 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);

1945

1946 buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));

1947 buf->f_bfree = sb_free_blocks(rs);

1948 buf->f_bavail = buf->f_bfree;

1949 buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;

1950 buf->f_bsize = s->s_blocksize;

1951 /* changed to accommodate gcc folks. */

1952 buf->f_type = REISERFS_SUPER_MAGIC;

1953 return 0;

1954 }

1955

1956 #ifdef CONFIG_QUOTA

1957 static int reiserfs_dquot_initialize(struct inode *inode, int type)

1958 {

1959 struct reiserfs_transaction_handle th;

1960 int ret, err;

1961

1962 /* We may create quota structure so we need to reserve enough blocks */

1963 reiserfs_write_lock(inode->i_sb);

1964 ret =

1965 journal_begin(&th, inode->i_sb,

1966 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));

1967 if (ret)

1968 goto out;

1969 ret = dquot_initialize(inode, type);

1970 err =

1971 journal_end(&th, inode->i_sb,

1972 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb));

1973 if (!ret && err)

1974 ret = err;

1975 out:

1976 reiserfs_write_unlock(inode->i_sb);

1977 return ret;

1978 }

1979

1980 static int reiserfs_dquot_drop(struct inode *inode)

1981 {

1982 struct reiserfs_transaction_handle th;

1983 int ret, err;

1984

1985 /* We may delete quota structure so we need to reserve enough blocks */

1986 reiserfs_write_lock(inode->i_sb);

1987 ret =

1988 journal_begin(&th, inode->i_sb,

1989 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));

1990 if (ret)

1991 goto out;

1992 ret = dquot_drop(inode);

1993 err =

1994 journal_end(&th, inode->i_sb,

1995 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb));

1996 if (!ret && err)

1997 ret = err;

1998 out:

1999 reiserfs_write_unlock(inode->i_sb);

2000 return ret;

2001 }

2002

2003 static int reiserfs_write_dquot(struct dquot *dquot)

2004 {

2005 struct reiserfs_transaction_handle th;

2006 int ret, err;

2007

2008 reiserfs_write_lock(dquot->dq_sb);

2009 ret =

2010 journal_begin(&th, dquot->dq_sb,

2011 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));

2012 if (ret)

2013 goto out;

2014 ret = dquot_commit(dquot);

2015 err =

2016 journal_end(&th, dquot->dq_sb,

2017 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));

2018 if (!ret && err)

2019 ret = err;

2020 out:

2021 reiserfs_write_unlock(dquot->dq_sb);

2022 return ret;

2023 }

2024

2025 static int reiserfs_acquire_dquot(struct dquot *dquot)

2026 {

2027 struct reiserfs_transaction_handle th;

2028 int ret, err;

2029

2030 reiserfs_write_lock(dquot->dq_sb);

2031 ret =

2032 journal_begin(&th, dquot->dq_sb,

2033 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));

2034 if (ret)

2035 goto out;

2036 ret = dquot_acquire(dquot);

2037 err =

2038 journal_end(&th, dquot->dq_sb,

2039 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));

2040 if (!ret && err)

2041 ret = err;

2042 out:

2043 reiserfs_write_unlock(dquot->dq_sb);

2044 return ret;

2045 }

2046

2047 static int reiserfs_release_dquot(struct dquot *dquot)

2048 {

2049 struct reiserfs_transaction_handle th;

2050 int ret, err;

2051

2052 reiserfs_write_lock(dquot->dq_sb);

2053 ret =

2054 journal_begin(&th, dquot->dq_sb,

2055 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));

2056 if (ret)

2057 goto out;

2058 ret = dquot_release(dquot);

2059 err =

2060 journal_end(&th, dquot->dq_sb,

2061 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));

2062 if (!ret && err)

2063 ret = err;

2064 out:

2065 reiserfs_write_unlock(dquot->dq_sb);

2066 return ret;

2067 }

2068

2069 static int reiserfs_mark_dquot_dirty(struct dquot *dquot)

2070 {

2071 /* Are we journalling quotas? */

2072 if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||

2073 REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {

2074 dquot_mark_dquot_dirty(dquot);

2075 return reiserfs_write_dquot(dquot);

2076 } else

2077 return dquot_mark_dquot_dirty(dquot);

2078 }

2079

2080 static int reiserfs_write_info(struct super_block *sb, int type)

2081 {

2082 struct reiserfs_transaction_handle th;

2083 int ret, err;

2084

2085 /* Data block + inode block */

2086 reiserfs_write_lock(sb);

2087 ret = journal_begin(&th, sb, 2);

2088 if (ret)

2089 goto out;

2090 ret = dquot_commit_info(sb, type);

2091 err = journal_end(&th, sb, 2);

2092 if (!ret && err)

2093 ret = err;

2094 out:

2095 reiserfs_write_unlock(sb);

2096 return ret;

2097 }

2098

2099 /*

2100 * Turn on quotas during mount time - we need to find the quota file and such...

2101 */

2102 static int reiserfs_quota_on_mount(struct super_block *sb, int type)

2103 {

2104 return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],

2105 REISERFS_SB(sb)->s_jquota_fmt, type);

2106 }

2107

2108 /*

2109 * Standard function to be called on quota_on

2110 */

2111 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,

2112 char *path)

2113 {

2114 int err;

2115 struct nameidata nd;

2116

2117 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))

2118 return -EINVAL;

2119 err = path_lookup(path, LOOKUP_FOLLOW, &nd);

2120 if (err)

2121 return err;

2122 /* Quotafile not on the same filesystem? */

2123 if (nd.mnt->mnt_sb != sb) {

2124 path_release(&nd);

2125 return -EXDEV;

2126 }

2127 /* We must not pack tails for quota files on reiserfs for quota IO to work */

2128 if (!REISERFS_I(nd.dentry->d_inode)->i_flags & i_nopack_mask) {

2129 reiserfs_warning(sb,

2130 "reiserfs: Quota file must have tail packing disabled.");

2131 path_release(&nd);

2132 return -EINVAL;

2133 }

2134 /* Not journalling quota? No more tests needed... */

2135 if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] &&

2136 !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) {

2137 path_release(&nd);

2138 return vfs_quota_on(sb, type, format_id, path);

2139 }

2140 /* Quotafile not of fs root? */

2141 if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode)

2142 reiserfs_warning(sb,

2143 "reiserfs: Quota file not on filesystem root. "

2144 "Journalled quota will not work.");

2145 path_release(&nd);

2146 return vfs_quota_on(sb, type, format_id, path);

2147 }

2148

2149 /* Read data from quotafile - avoid pagecache and such because we cannot afford

2150 * acquiring the locks... As quota files are never truncated and quota code

2151 * itself serializes the operations (and noone else should touch the files)

2152 * we don't have to be afraid of races */

2153 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,

2154 size_t len, loff_t off)

2155 {

2156 struct inode *inode = sb_dqopt(sb)->files[type];

2157 unsigned long blk = off >> sb->s_blocksize_bits;

2158 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;

2159 size_t toread;

2160 struct buffer_head tmp_bh, *bh;

2161 loff_t i_size = i_size_read(inode);

2162

2163 if (off > i_size)

2164 return 0;

2165 if (off + len > i_size)

2166 len = i_size - off;

2167 toread = len;

2168 while (toread > 0) {

2169 tocopy =

2170 sb->s_blocksize - offset <

2171 toread ? sb->s_blocksize - offset : toread;

2172 tmp_bh.b_state = 0;

2173 /* Quota files are without tails so we can safely use this function */

2174 reiserfs_write_lock(sb);

2175 err = reiserfs_get_block(inode, blk, &tmp_bh, 0);

2176 reiserfs_write_unlock(sb);

2177 if (err)

2178 return err;

2179 if (!buffer_mapped(&tmp_bh)) /* A hole? */

2180 memset(data, 0, tocopy);

2181 else {

2182 bh = sb_bread(sb, tmp_bh.b_blocknr);

2183 if (!bh)

2184 return -EIO;

2185 memcpy(data, bh->b_data + offset, tocopy);

2186 brelse(bh);

2187 }

2188 offset = 0;

2189 toread -= tocopy;

2190 data += tocopy;

2191 blk++;

2192 }

2193 return len;

2194 }

2195

2196 /* Write to quotafile (we know the transaction is already started and has

2197 * enough credits) */

2198 static ssize_t reiserfs_quota_write(struct super_block *sb, int type,

2199 const char *data, size_t len, loff_t off)

2200 {

2201 struct inode *inode = sb_dqopt(sb)->files[type];

2202 unsigned long blk = off >> sb->s_blocksize_bits;

2203 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;

2204 int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;

2205 size_t towrite = len;

2206 struct buffer_head tmp_bh, *bh;

2207

2208 mutex_lock(&inode->i_mutex);

2209 while (towrite > 0) {

2210 tocopy = sb->s_blocksize - offset < towrite ?

2211 sb->s_blocksize - offset : towrite;

2212 tmp_bh.b_state = 0;

2213 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);

2214 if (err)

2215 goto out;

2216 if (offset || tocopy != sb->s_blocksize)

2217 bh = sb_bread(sb, tmp_bh.b_blocknr);

2218 else

2219 bh = sb_getblk(sb, tmp_bh.b_blocknr);

2220 if (!bh) {

2221 err = -EIO;

2222 goto out;

2223 }

2224 lock_buffer(bh);

2225 memcpy(bh->b_data + offset, data, tocopy);

2226 flush_dcache_page(bh->b_page);

2227 set_buffer_uptodate(bh);

2228 unlock_buffer(bh);

2229 reiserfs_prepare_for_journal(sb, bh, 1);

2230 journal_mark_dirty(current->journal_info, sb, bh);

2231 if (!journal_quota)

2232 reiserfs_add_ordered_list(inode, bh);

2233 brelse(bh);

2234 offset = 0;

2235 towrite -= tocopy;

2236 data += tocopy;

2237 blk++;

2238 }

2239 out:

2240 if (len == towrite)

2241 return err;

2242 if (inode->i_size < off + len - towrite)

2243 i_size_write(inode, off + len - towrite);

2244 inode->i_version++;

2245 inode->i_mtime = inode->i_ctime = CURRENT_TIME;

2246 mark_inode_dirty(inode);

2247 mutex_unlock(&inode->i_mutex);

2248 return len - towrite;

2249 }

2250

2251 #endif

2252

2253 static struct super_block *get_super_block(struct file_system_type *fs_type,

2254 int flags, const char *dev_name,

2255 void *data)

2256 {

2257 return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);

2258 }

2259

2260 static int __init init_reiserfs_fs(void)

2261 {

2262 int ret;

2263

2264 if ((ret = init_inodecache())) {

2265 return ret;

2266 }

2267

2268 if ((ret = reiserfs_xattr_register_handlers()))

2269 goto failed_reiserfs_xattr_register_handlers;

2270

2271 reiserfs_proc_info_global_init();

2272 reiserfs_proc_register_global("version",

2273 reiserfs_global_version_in_proc);

2274

2275 ret = register_filesystem(&reiserfs_fs_type);

2276

2277 if (ret == 0) {

2278 return 0;

2279 }

2280

2281 reiserfs_xattr_unregister_handlers();

2282

2283 failed_reiserfs_xattr_register_handlers:

2284 reiserfs_proc_unregister_global("version");

2285 reiserfs_proc_info_global_done();

2286 destroy_inodecache();

2287

2288 return ret;

2289 }

2290

2291 static void __exit exit_reiserfs_fs(void)

2292 {

2293 reiserfs_xattr_unregister_handlers();

2294 reiserfs_proc_unregister_global("version");

2295 reiserfs_proc_info_global_done();

2296 unregister_filesystem(&reiserfs_fs_type);

2297 destroy_inodecache();

2298 }

2299

2300 struct file_system_type reiserfs_fs_type = {

2301 .owner = THIS_MODULE,

2302 .name = "reiserfs",

2303 .get_sb = get_super_block,

2304 .kill_sb = kill_block_super,

2305 .fs_flags = FS_REQUIRES_DEV,

2306 };

2307

2308 MODULE_DESCRIPTION("ReiserFS journaled filesystem");

2309 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");

2310 MODULE_LICENSE("GPL");

2311

2312 module_init(init_reiserfs_fs);

2313 module_exit(exit_reiserfs_fs);