/fs/ext3/super.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C · 3099 lines · 2409 code · 326 blank · 364 comment · 399 complexity · a10a7d459b0e9de15d1a1f0f0cb117d8 MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * linux/fs/ext3/super.c
  3. *
  4. * Copyright (C) 1992, 1993, 1994, 1995
  5. * Remy Card (card@masi.ibp.fr)
  6. * Laboratoire MASI - Institut Blaise Pascal
  7. * Universite Pierre et Marie Curie (Paris VI)
  8. *
  9. * from
  10. *
  11. * linux/fs/minix/inode.c
  12. *
  13. * Copyright (C) 1991, 1992 Linus Torvalds
  14. *
  15. * Big-endian to little-endian byte-swapping/bitmaps by
  16. * David S. Miller (davem@caip.rutgers.edu), 1995
  17. */
  18. #include <linux/module.h>
  19. #include <linux/string.h>
  20. #include <linux/fs.h>
  21. #include <linux/time.h>
  22. #include <linux/jbd.h>
  23. #include <linux/ext3_fs.h>
  24. #include <linux/ext3_jbd.h>
  25. #include <linux/slab.h>
  26. #include <linux/init.h>
  27. #include <linux/blkdev.h>
  28. #include <linux/parser.h>
  29. #include <linux/buffer_head.h>
  30. #include <linux/exportfs.h>
  31. #include <linux/vfs.h>
  32. #include <linux/random.h>
  33. #include <linux/mount.h>
  34. #include <linux/namei.h>
  35. #include <linux/quotaops.h>
  36. #include <linux/seq_file.h>
  37. #include <linux/log2.h>
  38. #include <linux/cleancache.h>
  39. #include <asm/uaccess.h>
  40. #include "xattr.h"
  41. #include "acl.h"
  42. #include "namei.h"
  43. #define CREATE_TRACE_POINTS
  44. #include <trace/events/ext3.h>
  45. #ifdef CONFIG_EXT3_DEFAULTS_TO_ORDERED
  46. #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_ORDERED_DATA
  47. #else
  48. #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_WRITEBACK_DATA
  49. #endif
  50. static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
  51. unsigned long journal_devnum);
  52. static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
  53. unsigned int);
  54. static int ext3_commit_super(struct super_block *sb,
  55. struct ext3_super_block *es,
  56. int sync);
  57. static void ext3_mark_recovery_complete(struct super_block * sb,
  58. struct ext3_super_block * es);
  59. static void ext3_clear_journal_err(struct super_block * sb,
  60. struct ext3_super_block * es);
  61. static int ext3_sync_fs(struct super_block *sb, int wait);
  62. static const char *ext3_decode_error(struct super_block * sb, int errno,
  63. char nbuf[16]);
  64. static int ext3_remount (struct super_block * sb, int * flags, char * data);
  65. static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf);
  66. static int ext3_unfreeze(struct super_block *sb);
  67. static int ext3_freeze(struct super_block *sb);
  68. /*
  69. * Wrappers for journal_start/end.
  70. *
  71. * The only special thing we need to do here is to make sure that all
  72. * journal_end calls result in the superblock being marked dirty, so
  73. * that sync() will call the filesystem's write_super callback if
  74. * appropriate.
  75. */
  76. handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks)
  77. {
  78. journal_t *journal;
  79. if (sb->s_flags & MS_RDONLY)
  80. return ERR_PTR(-EROFS);
  81. /* Special case here: if the journal has aborted behind our
  82. * backs (eg. EIO in the commit thread), then we still need to
  83. * take the FS itself readonly cleanly. */
  84. journal = EXT3_SB(sb)->s_journal;
  85. if (is_journal_aborted(journal)) {
  86. ext3_abort(sb, __func__,
  87. "Detected aborted journal");
  88. return ERR_PTR(-EROFS);
  89. }
  90. return journal_start(journal, nblocks);
  91. }
  92. /*
  93. * The only special thing we need to do here is to make sure that all
  94. * journal_stop calls result in the superblock being marked dirty, so
  95. * that sync() will call the filesystem's write_super callback if
  96. * appropriate.
  97. */
  98. int __ext3_journal_stop(const char *where, handle_t *handle)
  99. {
  100. struct super_block *sb;
  101. int err;
  102. int rc;
  103. sb = handle->h_transaction->t_journal->j_private;
  104. err = handle->h_err;
  105. rc = journal_stop(handle);
  106. if (!err)
  107. err = rc;
  108. if (err)
  109. __ext3_std_error(sb, where, err);
  110. return err;
  111. }
  112. void ext3_journal_abort_handle(const char *caller, const char *err_fn,
  113. struct buffer_head *bh, handle_t *handle, int err)
  114. {
  115. char nbuf[16];
  116. const char *errstr = ext3_decode_error(NULL, err, nbuf);
  117. if (bh)
  118. BUFFER_TRACE(bh, "abort");
  119. if (!handle->h_err)
  120. handle->h_err = err;
  121. if (is_handle_aborted(handle))
  122. return;
  123. printk(KERN_ERR "EXT3-fs: %s: aborting transaction: %s in %s\n",
  124. caller, errstr, err_fn);
  125. journal_abort_handle(handle);
  126. }
  127. void ext3_msg(struct super_block *sb, const char *prefix,
  128. const char *fmt, ...)
  129. {
  130. struct va_format vaf;
  131. va_list args;
  132. va_start(args, fmt);
  133. vaf.fmt = fmt;
  134. vaf.va = &args;
  135. printk("%sEXT3-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
  136. va_end(args);
  137. }
  138. /* Deal with the reporting of failure conditions on a filesystem such as
  139. * inconsistencies detected or read IO failures.
  140. *
  141. * On ext2, we can store the error state of the filesystem in the
  142. * superblock. That is not possible on ext3, because we may have other
  143. * write ordering constraints on the superblock which prevent us from
  144. * writing it out straight away; and given that the journal is about to
  145. * be aborted, we can't rely on the current, or future, transactions to
  146. * write out the superblock safely.
  147. *
  148. * We'll just use the journal_abort() error code to record an error in
  149. * the journal instead. On recovery, the journal will complain about
  150. * that error until we've noted it down and cleared it.
  151. */
  152. static void ext3_handle_error(struct super_block *sb)
  153. {
  154. struct ext3_super_block *es = EXT3_SB(sb)->s_es;
  155. EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
  156. es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
  157. if (sb->s_flags & MS_RDONLY)
  158. return;
  159. if (!test_opt (sb, ERRORS_CONT)) {
  160. journal_t *journal = EXT3_SB(sb)->s_journal;
  161. set_opt(EXT3_SB(sb)->s_mount_opt, ABORT);
  162. if (journal)
  163. journal_abort(journal, -EIO);
  164. }
  165. if (test_opt (sb, ERRORS_RO)) {
  166. ext3_msg(sb, KERN_CRIT,
  167. "error: remounting filesystem read-only");
  168. sb->s_flags |= MS_RDONLY;
  169. }
  170. ext3_commit_super(sb, es, 1);
  171. if (test_opt(sb, ERRORS_PANIC))
  172. panic("EXT3-fs (%s): panic forced after error\n",
  173. sb->s_id);
  174. }
  175. void ext3_error(struct super_block *sb, const char *function,
  176. const char *fmt, ...)
  177. {
  178. struct va_format vaf;
  179. va_list args;
  180. va_start(args, fmt);
  181. vaf.fmt = fmt;
  182. vaf.va = &args;
  183. printk(KERN_CRIT "EXT3-fs error (device %s): %s: %pV\n",
  184. sb->s_id, function, &vaf);
  185. va_end(args);
  186. ext3_handle_error(sb);
  187. }
  188. static const char *ext3_decode_error(struct super_block * sb, int errno,
  189. char nbuf[16])
  190. {
  191. char *errstr = NULL;
  192. switch (errno) {
  193. case -EIO:
  194. errstr = "IO failure";
  195. break;
  196. case -ENOMEM:
  197. errstr = "Out of memory";
  198. break;
  199. case -EROFS:
  200. if (!sb || EXT3_SB(sb)->s_journal->j_flags & JFS_ABORT)
  201. errstr = "Journal has aborted";
  202. else
  203. errstr = "Readonly filesystem";
  204. break;
  205. default:
  206. /* If the caller passed in an extra buffer for unknown
  207. * errors, textualise them now. Else we just return
  208. * NULL. */
  209. if (nbuf) {
  210. /* Check for truncated error codes... */
  211. if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
  212. errstr = nbuf;
  213. }
  214. break;
  215. }
  216. return errstr;
  217. }
  218. /* __ext3_std_error decodes expected errors from journaling functions
  219. * automatically and invokes the appropriate error response. */
  220. void __ext3_std_error (struct super_block * sb, const char * function,
  221. int errno)
  222. {
  223. char nbuf[16];
  224. const char *errstr;
  225. /* Special case: if the error is EROFS, and we're not already
  226. * inside a transaction, then there's really no point in logging
  227. * an error. */
  228. if (errno == -EROFS && journal_current_handle() == NULL &&
  229. (sb->s_flags & MS_RDONLY))
  230. return;
  231. errstr = ext3_decode_error(sb, errno, nbuf);
  232. ext3_msg(sb, KERN_CRIT, "error in %s: %s", function, errstr);
  233. ext3_handle_error(sb);
  234. }
  235. /*
  236. * ext3_abort is a much stronger failure handler than ext3_error. The
  237. * abort function may be used to deal with unrecoverable failures such
  238. * as journal IO errors or ENOMEM at a critical moment in log management.
  239. *
  240. * We unconditionally force the filesystem into an ABORT|READONLY state,
  241. * unless the error response on the fs has been set to panic in which
  242. * case we take the easy way out and panic immediately.
  243. */
  244. void ext3_abort(struct super_block *sb, const char *function,
  245. const char *fmt, ...)
  246. {
  247. struct va_format vaf;
  248. va_list args;
  249. va_start(args, fmt);
  250. vaf.fmt = fmt;
  251. vaf.va = &args;
  252. printk(KERN_CRIT "EXT3-fs (%s): error: %s: %pV\n",
  253. sb->s_id, function, &vaf);
  254. va_end(args);
  255. if (test_opt(sb, ERRORS_PANIC))
  256. panic("EXT3-fs: panic from previous error\n");
  257. if (sb->s_flags & MS_RDONLY)
  258. return;
  259. ext3_msg(sb, KERN_CRIT,
  260. "error: remounting filesystem read-only");
  261. EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
  262. sb->s_flags |= MS_RDONLY;
  263. set_opt(EXT3_SB(sb)->s_mount_opt, ABORT);
  264. if (EXT3_SB(sb)->s_journal)
  265. journal_abort(EXT3_SB(sb)->s_journal, -EIO);
  266. }
  267. void ext3_warning(struct super_block *sb, const char *function,
  268. const char *fmt, ...)
  269. {
  270. struct va_format vaf;
  271. va_list args;
  272. va_start(args, fmt);
  273. vaf.fmt = fmt;
  274. vaf.va = &args;
  275. printk(KERN_WARNING "EXT3-fs (%s): warning: %s: %pV\n",
  276. sb->s_id, function, &vaf);
  277. va_end(args);
  278. }
  279. void ext3_update_dynamic_rev(struct super_block *sb)
  280. {
  281. struct ext3_super_block *es = EXT3_SB(sb)->s_es;
  282. if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
  283. return;
  284. ext3_msg(sb, KERN_WARNING,
  285. "warning: updating to rev %d because of "
  286. "new feature flag, running e2fsck is recommended",
  287. EXT3_DYNAMIC_REV);
  288. es->s_first_ino = cpu_to_le32(EXT3_GOOD_OLD_FIRST_INO);
  289. es->s_inode_size = cpu_to_le16(EXT3_GOOD_OLD_INODE_SIZE);
  290. es->s_rev_level = cpu_to_le32(EXT3_DYNAMIC_REV);
  291. /* leave es->s_feature_*compat flags alone */
  292. /* es->s_uuid will be set by e2fsck if empty */
  293. /*
  294. * The rest of the superblock fields should be zero, and if not it
  295. * means they are likely already in use, so leave them alone. We
  296. * can leave it up to e2fsck to clean up any inconsistencies there.
  297. */
  298. }
  299. /*
  300. * Open the external journal device
  301. */
  302. static struct block_device *ext3_blkdev_get(dev_t dev, struct super_block *sb)
  303. {
  304. struct block_device *bdev;
  305. char b[BDEVNAME_SIZE];
  306. bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb);
  307. if (IS_ERR(bdev))
  308. goto fail;
  309. return bdev;
  310. fail:
  311. ext3_msg(sb, "error: failed to open journal device %s: %ld",
  312. __bdevname(dev, b), PTR_ERR(bdev));
  313. return NULL;
  314. }
  315. /*
  316. * Release the journal device
  317. */
  318. static int ext3_blkdev_put(struct block_device *bdev)
  319. {
  320. return blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
  321. }
  322. static int ext3_blkdev_remove(struct ext3_sb_info *sbi)
  323. {
  324. struct block_device *bdev;
  325. int ret = -ENODEV;
  326. bdev = sbi->journal_bdev;
  327. if (bdev) {
  328. ret = ext3_blkdev_put(bdev);
  329. sbi->journal_bdev = NULL;
  330. }
  331. return ret;
  332. }
  333. static inline struct inode *orphan_list_entry(struct list_head *l)
  334. {
  335. return &list_entry(l, struct ext3_inode_info, i_orphan)->vfs_inode;
  336. }
  337. static void dump_orphan_list(struct super_block *sb, struct ext3_sb_info *sbi)
  338. {
  339. struct list_head *l;
  340. ext3_msg(sb, KERN_ERR, "error: sb orphan head is %d",
  341. le32_to_cpu(sbi->s_es->s_last_orphan));
  342. ext3_msg(sb, KERN_ERR, "sb_info orphan list:");
  343. list_for_each(l, &sbi->s_orphan) {
  344. struct inode *inode = orphan_list_entry(l);
  345. ext3_msg(sb, KERN_ERR, " "
  346. "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
  347. inode->i_sb->s_id, inode->i_ino, inode,
  348. inode->i_mode, inode->i_nlink,
  349. NEXT_ORPHAN(inode));
  350. }
  351. }
  352. static void ext3_put_super (struct super_block * sb)
  353. {
  354. struct ext3_sb_info *sbi = EXT3_SB(sb);
  355. struct ext3_super_block *es = sbi->s_es;
  356. int i, err;
  357. dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
  358. ext3_xattr_put_super(sb);
  359. err = journal_destroy(sbi->s_journal);
  360. sbi->s_journal = NULL;
  361. if (err < 0)
  362. ext3_abort(sb, __func__, "Couldn't clean up the journal");
  363. if (!(sb->s_flags & MS_RDONLY)) {
  364. EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  365. es->s_state = cpu_to_le16(sbi->s_mount_state);
  366. BUFFER_TRACE(sbi->s_sbh, "marking dirty");
  367. mark_buffer_dirty(sbi->s_sbh);
  368. ext3_commit_super(sb, es, 1);
  369. }
  370. for (i = 0; i < sbi->s_gdb_count; i++)
  371. brelse(sbi->s_group_desc[i]);
  372. kfree(sbi->s_group_desc);
  373. percpu_counter_destroy(&sbi->s_freeblocks_counter);
  374. percpu_counter_destroy(&sbi->s_freeinodes_counter);
  375. percpu_counter_destroy(&sbi->s_dirs_counter);
  376. brelse(sbi->s_sbh);
  377. #ifdef CONFIG_QUOTA
  378. for (i = 0; i < MAXQUOTAS; i++)
  379. kfree(sbi->s_qf_names[i]);
  380. #endif
  381. /* Debugging code just in case the in-memory inode orphan list
  382. * isn't empty. The on-disk one can be non-empty if we've
  383. * detected an error and taken the fs readonly, but the
  384. * in-memory list had better be clean by this point. */
  385. if (!list_empty(&sbi->s_orphan))
  386. dump_orphan_list(sb, sbi);
  387. J_ASSERT(list_empty(&sbi->s_orphan));
  388. invalidate_bdev(sb->s_bdev);
  389. if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
  390. /*
  391. * Invalidate the journal device's buffers. We don't want them
  392. * floating about in memory - the physical journal device may
  393. * hotswapped, and it breaks the `ro-after' testing code.
  394. */
  395. sync_blockdev(sbi->journal_bdev);
  396. invalidate_bdev(sbi->journal_bdev);
  397. ext3_blkdev_remove(sbi);
  398. }
  399. sb->s_fs_info = NULL;
  400. kfree(sbi->s_blockgroup_lock);
  401. kfree(sbi);
  402. }
  403. static struct kmem_cache *ext3_inode_cachep;
  404. /*
  405. * Called inside transaction, so use GFP_NOFS
  406. */
  407. static struct inode *ext3_alloc_inode(struct super_block *sb)
  408. {
  409. struct ext3_inode_info *ei;
  410. ei = kmem_cache_alloc(ext3_inode_cachep, GFP_NOFS);
  411. if (!ei)
  412. return NULL;
  413. ei->i_block_alloc_info = NULL;
  414. ei->vfs_inode.i_version = 1;
  415. atomic_set(&ei->i_datasync_tid, 0);
  416. atomic_set(&ei->i_sync_tid, 0);
  417. return &ei->vfs_inode;
  418. }
  419. static int ext3_drop_inode(struct inode *inode)
  420. {
  421. int drop = generic_drop_inode(inode);
  422. trace_ext3_drop_inode(inode, drop);
  423. return drop;
  424. }
  425. static void ext3_i_callback(struct rcu_head *head)
  426. {
  427. struct inode *inode = container_of(head, struct inode, i_rcu);
  428. INIT_LIST_HEAD(&inode->i_dentry);
  429. kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
  430. }
  431. static void ext3_destroy_inode(struct inode *inode)
  432. {
  433. if (!list_empty(&(EXT3_I(inode)->i_orphan))) {
  434. printk("EXT3 Inode %p: orphan list check failed!\n",
  435. EXT3_I(inode));
  436. print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
  437. EXT3_I(inode), sizeof(struct ext3_inode_info),
  438. false);
  439. dump_stack();
  440. }
  441. call_rcu(&inode->i_rcu, ext3_i_callback);
  442. }
  443. static void init_once(void *foo)
  444. {
  445. struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
  446. INIT_LIST_HEAD(&ei->i_orphan);
  447. #ifdef CONFIG_EXT3_FS_XATTR
  448. init_rwsem(&ei->xattr_sem);
  449. #endif
  450. mutex_init(&ei->truncate_mutex);
  451. inode_init_once(&ei->vfs_inode);
  452. }
  453. static int init_inodecache(void)
  454. {
  455. ext3_inode_cachep = kmem_cache_create("ext3_inode_cache",
  456. sizeof(struct ext3_inode_info),
  457. 0, (SLAB_RECLAIM_ACCOUNT|
  458. SLAB_MEM_SPREAD),
  459. init_once);
  460. if (ext3_inode_cachep == NULL)
  461. return -ENOMEM;
  462. return 0;
  463. }
  464. static void destroy_inodecache(void)
  465. {
  466. kmem_cache_destroy(ext3_inode_cachep);
  467. }
  468. static inline void ext3_show_quota_options(struct seq_file *seq, struct super_block *sb)
  469. {
  470. #if defined(CONFIG_QUOTA)
  471. struct ext3_sb_info *sbi = EXT3_SB(sb);
  472. if (sbi->s_jquota_fmt) {
  473. char *fmtname = "";
  474. switch (sbi->s_jquota_fmt) {
  475. case QFMT_VFS_OLD:
  476. fmtname = "vfsold";
  477. break;
  478. case QFMT_VFS_V0:
  479. fmtname = "vfsv0";
  480. break;
  481. case QFMT_VFS_V1:
  482. fmtname = "vfsv1";
  483. break;
  484. }
  485. seq_printf(seq, ",jqfmt=%s", fmtname);
  486. }
  487. if (sbi->s_qf_names[USRQUOTA])
  488. seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
  489. if (sbi->s_qf_names[GRPQUOTA])
  490. seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
  491. if (test_opt(sb, USRQUOTA))
  492. seq_puts(seq, ",usrquota");
  493. if (test_opt(sb, GRPQUOTA))
  494. seq_puts(seq, ",grpquota");
  495. #endif
  496. }
  497. static char *data_mode_string(unsigned long mode)
  498. {
  499. switch (mode) {
  500. case EXT3_MOUNT_JOURNAL_DATA:
  501. return "journal";
  502. case EXT3_MOUNT_ORDERED_DATA:
  503. return "ordered";
  504. case EXT3_MOUNT_WRITEBACK_DATA:
  505. return "writeback";
  506. }
  507. return "unknown";
  508. }
  509. /*
  510. * Show an option if
  511. * - it's set to a non-default value OR
  512. * - if the per-sb default is different from the global default
  513. */
  514. static int ext3_show_options(struct seq_file *seq, struct vfsmount *vfs)
  515. {
  516. struct super_block *sb = vfs->mnt_sb;
  517. struct ext3_sb_info *sbi = EXT3_SB(sb);
  518. struct ext3_super_block *es = sbi->s_es;
  519. unsigned long def_mount_opts;
  520. def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
  521. if (sbi->s_sb_block != 1)
  522. seq_printf(seq, ",sb=%lu", sbi->s_sb_block);
  523. if (test_opt(sb, MINIX_DF))
  524. seq_puts(seq, ",minixdf");
  525. if (test_opt(sb, GRPID))
  526. seq_puts(seq, ",grpid");
  527. if (!test_opt(sb, GRPID) && (def_mount_opts & EXT3_DEFM_BSDGROUPS))
  528. seq_puts(seq, ",nogrpid");
  529. if (sbi->s_resuid != EXT3_DEF_RESUID ||
  530. le16_to_cpu(es->s_def_resuid) != EXT3_DEF_RESUID) {
  531. seq_printf(seq, ",resuid=%u", sbi->s_resuid);
  532. }
  533. if (sbi->s_resgid != EXT3_DEF_RESGID ||
  534. le16_to_cpu(es->s_def_resgid) != EXT3_DEF_RESGID) {
  535. seq_printf(seq, ",resgid=%u", sbi->s_resgid);
  536. }
  537. if (test_opt(sb, ERRORS_RO)) {
  538. int def_errors = le16_to_cpu(es->s_errors);
  539. if (def_errors == EXT3_ERRORS_PANIC ||
  540. def_errors == EXT3_ERRORS_CONTINUE) {
  541. seq_puts(seq, ",errors=remount-ro");
  542. }
  543. }
  544. if (test_opt(sb, ERRORS_CONT))
  545. seq_puts(seq, ",errors=continue");
  546. if (test_opt(sb, ERRORS_PANIC))
  547. seq_puts(seq, ",errors=panic");
  548. if (test_opt(sb, NO_UID32))
  549. seq_puts(seq, ",nouid32");
  550. if (test_opt(sb, DEBUG))
  551. seq_puts(seq, ",debug");
  552. if (test_opt(sb, OLDALLOC))
  553. seq_puts(seq, ",oldalloc");
  554. #ifdef CONFIG_EXT3_FS_XATTR
  555. if (test_opt(sb, XATTR_USER))
  556. seq_puts(seq, ",user_xattr");
  557. if (!test_opt(sb, XATTR_USER) &&
  558. (def_mount_opts & EXT3_DEFM_XATTR_USER)) {
  559. seq_puts(seq, ",nouser_xattr");
  560. }
  561. #endif
  562. #ifdef CONFIG_EXT3_FS_POSIX_ACL
  563. if (test_opt(sb, POSIX_ACL))
  564. seq_puts(seq, ",acl");
  565. if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT3_DEFM_ACL))
  566. seq_puts(seq, ",noacl");
  567. #endif
  568. if (!test_opt(sb, RESERVATION))
  569. seq_puts(seq, ",noreservation");
  570. if (sbi->s_commit_interval) {
  571. seq_printf(seq, ",commit=%u",
  572. (unsigned) (sbi->s_commit_interval / HZ));
  573. }
  574. /*
  575. * Always display barrier state so it's clear what the status is.
  576. */
  577. seq_puts(seq, ",barrier=");
  578. seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
  579. seq_printf(seq, ",data=%s", data_mode_string(test_opt(sb, DATA_FLAGS)));
  580. if (test_opt(sb, DATA_ERR_ABORT))
  581. seq_puts(seq, ",data_err=abort");
  582. if (test_opt(sb, NOLOAD))
  583. seq_puts(seq, ",norecovery");
  584. ext3_show_quota_options(seq, sb);
  585. return 0;
  586. }
  587. static struct inode *ext3_nfs_get_inode(struct super_block *sb,
  588. u64 ino, u32 generation)
  589. {
  590. struct inode *inode;
  591. if (ino < EXT3_FIRST_INO(sb) && ino != EXT3_ROOT_INO)
  592. return ERR_PTR(-ESTALE);
  593. if (ino > le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count))
  594. return ERR_PTR(-ESTALE);
  595. /* iget isn't really right if the inode is currently unallocated!!
  596. *
  597. * ext3_read_inode will return a bad_inode if the inode had been
  598. * deleted, so we should be safe.
  599. *
  600. * Currently we don't know the generation for parent directory, so
  601. * a generation of 0 means "accept any"
  602. */
  603. inode = ext3_iget(sb, ino);
  604. if (IS_ERR(inode))
  605. return ERR_CAST(inode);
  606. if (generation && inode->i_generation != generation) {
  607. iput(inode);
  608. return ERR_PTR(-ESTALE);
  609. }
  610. return inode;
  611. }
  612. static struct dentry *ext3_fh_to_dentry(struct super_block *sb, struct fid *fid,
  613. int fh_len, int fh_type)
  614. {
  615. return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
  616. ext3_nfs_get_inode);
  617. }
  618. static struct dentry *ext3_fh_to_parent(struct super_block *sb, struct fid *fid,
  619. int fh_len, int fh_type)
  620. {
  621. return generic_fh_to_parent(sb, fid, fh_len, fh_type,
  622. ext3_nfs_get_inode);
  623. }
  624. /*
  625. * Try to release metadata pages (indirect blocks, directories) which are
  626. * mapped via the block device. Since these pages could have journal heads
  627. * which would prevent try_to_free_buffers() from freeing them, we must use
  628. * jbd layer's try_to_free_buffers() function to release them.
  629. */
  630. static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
  631. gfp_t wait)
  632. {
  633. journal_t *journal = EXT3_SB(sb)->s_journal;
  634. WARN_ON(PageChecked(page));
  635. if (!page_has_buffers(page))
  636. return 0;
  637. if (journal)
  638. return journal_try_to_free_buffers(journal, page,
  639. wait & ~__GFP_WAIT);
  640. return try_to_free_buffers(page);
  641. }
  642. #ifdef CONFIG_QUOTA
  643. #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
  644. #define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
  645. static int ext3_write_dquot(struct dquot *dquot);
  646. static int ext3_acquire_dquot(struct dquot *dquot);
  647. static int ext3_release_dquot(struct dquot *dquot);
  648. static int ext3_mark_dquot_dirty(struct dquot *dquot);
  649. static int ext3_write_info(struct super_block *sb, int type);
  650. static int ext3_quota_on(struct super_block *sb, int type, int format_id,
  651. struct path *path);
  652. static int ext3_quota_on_mount(struct super_block *sb, int type);
  653. static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
  654. size_t len, loff_t off);
  655. static ssize_t ext3_quota_write(struct super_block *sb, int type,
  656. const char *data, size_t len, loff_t off);
  657. static const struct dquot_operations ext3_quota_operations = {
  658. .write_dquot = ext3_write_dquot,
  659. .acquire_dquot = ext3_acquire_dquot,
  660. .release_dquot = ext3_release_dquot,
  661. .mark_dirty = ext3_mark_dquot_dirty,
  662. .write_info = ext3_write_info,
  663. .alloc_dquot = dquot_alloc,
  664. .destroy_dquot = dquot_destroy,
  665. };
  666. static const struct quotactl_ops ext3_qctl_operations = {
  667. .quota_on = ext3_quota_on,
  668. .quota_off = dquot_quota_off,
  669. .quota_sync = dquot_quota_sync,
  670. .get_info = dquot_get_dqinfo,
  671. .set_info = dquot_set_dqinfo,
  672. .get_dqblk = dquot_get_dqblk,
  673. .set_dqblk = dquot_set_dqblk
  674. };
  675. #endif
  676. static const struct super_operations ext3_sops = {
  677. .alloc_inode = ext3_alloc_inode,
  678. .destroy_inode = ext3_destroy_inode,
  679. .write_inode = ext3_write_inode,
  680. .dirty_inode = ext3_dirty_inode,
  681. .drop_inode = ext3_drop_inode,
  682. .evict_inode = ext3_evict_inode,
  683. .put_super = ext3_put_super,
  684. .sync_fs = ext3_sync_fs,
  685. .freeze_fs = ext3_freeze,
  686. .unfreeze_fs = ext3_unfreeze,
  687. .statfs = ext3_statfs,
  688. .remount_fs = ext3_remount,
  689. .show_options = ext3_show_options,
  690. #ifdef CONFIG_QUOTA
  691. .quota_read = ext3_quota_read,
  692. .quota_write = ext3_quota_write,
  693. #endif
  694. .bdev_try_to_free_page = bdev_try_to_free_page,
  695. };
  696. static const struct export_operations ext3_export_ops = {
  697. .fh_to_dentry = ext3_fh_to_dentry,
  698. .fh_to_parent = ext3_fh_to_parent,
  699. .get_parent = ext3_get_parent,
  700. };
  701. enum {
  702. Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
  703. Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
  704. Opt_nouid32, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
  705. Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
  706. Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
  707. Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
  708. Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
  709. Opt_data_err_abort, Opt_data_err_ignore,
  710. Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
  711. Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
  712. Opt_noquota, Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err,
  713. Opt_resize, Opt_usrquota, Opt_grpquota
  714. };
  715. static const match_table_t tokens = {
  716. {Opt_bsd_df, "bsddf"},
  717. {Opt_minix_df, "minixdf"},
  718. {Opt_grpid, "grpid"},
  719. {Opt_grpid, "bsdgroups"},
  720. {Opt_nogrpid, "nogrpid"},
  721. {Opt_nogrpid, "sysvgroups"},
  722. {Opt_resgid, "resgid=%u"},
  723. {Opt_resuid, "resuid=%u"},
  724. {Opt_sb, "sb=%u"},
  725. {Opt_err_cont, "errors=continue"},
  726. {Opt_err_panic, "errors=panic"},
  727. {Opt_err_ro, "errors=remount-ro"},
  728. {Opt_nouid32, "nouid32"},
  729. {Opt_nocheck, "nocheck"},
  730. {Opt_nocheck, "check=none"},
  731. {Opt_debug, "debug"},
  732. {Opt_oldalloc, "oldalloc"},
  733. {Opt_orlov, "orlov"},
  734. {Opt_user_xattr, "user_xattr"},
  735. {Opt_nouser_xattr, "nouser_xattr"},
  736. {Opt_acl, "acl"},
  737. {Opt_noacl, "noacl"},
  738. {Opt_reservation, "reservation"},
  739. {Opt_noreservation, "noreservation"},
  740. {Opt_noload, "noload"},
  741. {Opt_noload, "norecovery"},
  742. {Opt_nobh, "nobh"},
  743. {Opt_bh, "bh"},
  744. {Opt_commit, "commit=%u"},
  745. {Opt_journal_update, "journal=update"},
  746. {Opt_journal_inum, "journal=%u"},
  747. {Opt_journal_dev, "journal_dev=%u"},
  748. {Opt_abort, "abort"},
  749. {Opt_data_journal, "data=journal"},
  750. {Opt_data_ordered, "data=ordered"},
  751. {Opt_data_writeback, "data=writeback"},
  752. {Opt_data_err_abort, "data_err=abort"},
  753. {Opt_data_err_ignore, "data_err=ignore"},
  754. {Opt_offusrjquota, "usrjquota="},
  755. {Opt_usrjquota, "usrjquota=%s"},
  756. {Opt_offgrpjquota, "grpjquota="},
  757. {Opt_grpjquota, "grpjquota=%s"},
  758. {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
  759. {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
  760. {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
  761. {Opt_grpquota, "grpquota"},
  762. {Opt_noquota, "noquota"},
  763. {Opt_quota, "quota"},
  764. {Opt_usrquota, "usrquota"},
  765. {Opt_barrier, "barrier=%u"},
  766. {Opt_barrier, "barrier"},
  767. {Opt_nobarrier, "nobarrier"},
  768. {Opt_resize, "resize"},
  769. {Opt_err, NULL},
  770. };
  771. static ext3_fsblk_t get_sb_block(void **data, struct super_block *sb)
  772. {
  773. ext3_fsblk_t sb_block;
  774. char *options = (char *) *data;
  775. if (!options || strncmp(options, "sb=", 3) != 0)
  776. return 1; /* Default location */
  777. options += 3;
  778. /*todo: use simple_strtoll with >32bit ext3 */
  779. sb_block = simple_strtoul(options, &options, 0);
  780. if (*options && *options != ',') {
  781. ext3_msg(sb, "error: invalid sb specification: %s",
  782. (char *) *data);
  783. return 1;
  784. }
  785. if (*options == ',')
  786. options++;
  787. *data = (void *) options;
  788. return sb_block;
  789. }
  790. #ifdef CONFIG_QUOTA
  791. static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
  792. {
  793. struct ext3_sb_info *sbi = EXT3_SB(sb);
  794. char *qname;
  795. if (sb_any_quota_loaded(sb) &&
  796. !sbi->s_qf_names[qtype]) {
  797. ext3_msg(sb, KERN_ERR,
  798. "Cannot change journaled "
  799. "quota options when quota turned on");
  800. return 0;
  801. }
  802. qname = match_strdup(args);
  803. if (!qname) {
  804. ext3_msg(sb, KERN_ERR,
  805. "Not enough memory for storing quotafile name");
  806. return 0;
  807. }
  808. if (sbi->s_qf_names[qtype] &&
  809. strcmp(sbi->s_qf_names[qtype], qname)) {
  810. ext3_msg(sb, KERN_ERR,
  811. "%s quota file already specified", QTYPE2NAME(qtype));
  812. kfree(qname);
  813. return 0;
  814. }
  815. sbi->s_qf_names[qtype] = qname;
  816. if (strchr(sbi->s_qf_names[qtype], '/')) {
  817. ext3_msg(sb, KERN_ERR,
  818. "quotafile must be on filesystem root");
  819. kfree(sbi->s_qf_names[qtype]);
  820. sbi->s_qf_names[qtype] = NULL;
  821. return 0;
  822. }
  823. set_opt(sbi->s_mount_opt, QUOTA);
  824. return 1;
  825. }
  826. static int clear_qf_name(struct super_block *sb, int qtype) {
  827. struct ext3_sb_info *sbi = EXT3_SB(sb);
  828. if (sb_any_quota_loaded(sb) &&
  829. sbi->s_qf_names[qtype]) {
  830. ext3_msg(sb, KERN_ERR, "Cannot change journaled quota options"
  831. " when quota turned on");
  832. return 0;
  833. }
  834. /*
  835. * The space will be released later when all options are confirmed
  836. * to be correct
  837. */
  838. sbi->s_qf_names[qtype] = NULL;
  839. return 1;
  840. }
  841. #endif
  842. static int parse_options (char *options, struct super_block *sb,
  843. unsigned int *inum, unsigned long *journal_devnum,
  844. ext3_fsblk_t *n_blocks_count, int is_remount)
  845. {
  846. struct ext3_sb_info *sbi = EXT3_SB(sb);
  847. char * p;
  848. substring_t args[MAX_OPT_ARGS];
  849. int data_opt = 0;
  850. int option;
  851. #ifdef CONFIG_QUOTA
  852. int qfmt;
  853. #endif
  854. if (!options)
  855. return 1;
  856. while ((p = strsep (&options, ",")) != NULL) {
  857. int token;
  858. if (!*p)
  859. continue;
  860. /*
  861. * Initialize args struct so we know whether arg was
  862. * found; some options take optional arguments.
  863. */
  864. args[0].to = args[0].from = 0;
  865. token = match_token(p, tokens, args);
  866. switch (token) {
  867. case Opt_bsd_df:
  868. clear_opt (sbi->s_mount_opt, MINIX_DF);
  869. break;
  870. case Opt_minix_df:
  871. set_opt (sbi->s_mount_opt, MINIX_DF);
  872. break;
  873. case Opt_grpid:
  874. set_opt (sbi->s_mount_opt, GRPID);
  875. break;
  876. case Opt_nogrpid:
  877. clear_opt (sbi->s_mount_opt, GRPID);
  878. break;
  879. case Opt_resuid:
  880. if (match_int(&args[0], &option))
  881. return 0;
  882. sbi->s_resuid = option;
  883. break;
  884. case Opt_resgid:
  885. if (match_int(&args[0], &option))
  886. return 0;
  887. sbi->s_resgid = option;
  888. break;
  889. case Opt_sb:
  890. /* handled by get_sb_block() instead of here */
  891. /* *sb_block = match_int(&args[0]); */
  892. break;
  893. case Opt_err_panic:
  894. clear_opt (sbi->s_mount_opt, ERRORS_CONT);
  895. clear_opt (sbi->s_mount_opt, ERRORS_RO);
  896. set_opt (sbi->s_mount_opt, ERRORS_PANIC);
  897. break;
  898. case Opt_err_ro:
  899. clear_opt (sbi->s_mount_opt, ERRORS_CONT);
  900. clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
  901. set_opt (sbi->s_mount_opt, ERRORS_RO);
  902. break;
  903. case Opt_err_cont:
  904. clear_opt (sbi->s_mount_opt, ERRORS_RO);
  905. clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
  906. set_opt (sbi->s_mount_opt, ERRORS_CONT);
  907. break;
  908. case Opt_nouid32:
  909. set_opt (sbi->s_mount_opt, NO_UID32);
  910. break;
  911. case Opt_nocheck:
  912. clear_opt (sbi->s_mount_opt, CHECK);
  913. break;
  914. case Opt_debug:
  915. set_opt (sbi->s_mount_opt, DEBUG);
  916. break;
  917. case Opt_oldalloc:
  918. set_opt (sbi->s_mount_opt, OLDALLOC);
  919. break;
  920. case Opt_orlov:
  921. clear_opt (sbi->s_mount_opt, OLDALLOC);
  922. break;
  923. #ifdef CONFIG_EXT3_FS_XATTR
  924. case Opt_user_xattr:
  925. set_opt (sbi->s_mount_opt, XATTR_USER);
  926. break;
  927. case Opt_nouser_xattr:
  928. clear_opt (sbi->s_mount_opt, XATTR_USER);
  929. break;
  930. #else
  931. case Opt_user_xattr:
  932. case Opt_nouser_xattr:
  933. ext3_msg(sb, KERN_INFO,
  934. "(no)user_xattr options not supported");
  935. break;
  936. #endif
  937. #ifdef CONFIG_EXT3_FS_POSIX_ACL
  938. case Opt_acl:
  939. set_opt(sbi->s_mount_opt, POSIX_ACL);
  940. break;
  941. case Opt_noacl:
  942. clear_opt(sbi->s_mount_opt, POSIX_ACL);
  943. break;
  944. #else
  945. case Opt_acl:
  946. case Opt_noacl:
  947. ext3_msg(sb, KERN_INFO,
  948. "(no)acl options not supported");
  949. break;
  950. #endif
  951. case Opt_reservation:
  952. set_opt(sbi->s_mount_opt, RESERVATION);
  953. break;
  954. case Opt_noreservation:
  955. clear_opt(sbi->s_mount_opt, RESERVATION);
  956. break;
  957. case Opt_journal_update:
  958. /* @@@ FIXME */
  959. /* Eventually we will want to be able to create
  960. a journal file here. For now, only allow the
  961. user to specify an existing inode to be the
  962. journal file. */
  963. if (is_remount) {
  964. ext3_msg(sb, KERN_ERR, "error: cannot specify "
  965. "journal on remount");
  966. return 0;
  967. }
  968. set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
  969. break;
  970. case Opt_journal_inum:
  971. if (is_remount) {
  972. ext3_msg(sb, KERN_ERR, "error: cannot specify "
  973. "journal on remount");
  974. return 0;
  975. }
  976. if (match_int(&args[0], &option))
  977. return 0;
  978. *inum = option;
  979. break;
  980. case Opt_journal_dev:
  981. if (is_remount) {
  982. ext3_msg(sb, KERN_ERR, "error: cannot specify "
  983. "journal on remount");
  984. return 0;
  985. }
  986. if (match_int(&args[0], &option))
  987. return 0;
  988. *journal_devnum = option;
  989. break;
  990. case Opt_noload:
  991. set_opt (sbi->s_mount_opt, NOLOAD);
  992. break;
  993. case Opt_commit:
  994. if (match_int(&args[0], &option))
  995. return 0;
  996. if (option < 0)
  997. return 0;
  998. if (option == 0)
  999. option = JBD_DEFAULT_MAX_COMMIT_AGE;
  1000. sbi->s_commit_interval = HZ * option;
  1001. break;
  1002. case Opt_data_journal:
  1003. data_opt = EXT3_MOUNT_JOURNAL_DATA;
  1004. goto datacheck;
  1005. case Opt_data_ordered:
  1006. data_opt = EXT3_MOUNT_ORDERED_DATA;
  1007. goto datacheck;
  1008. case Opt_data_writeback:
  1009. data_opt = EXT3_MOUNT_WRITEBACK_DATA;
  1010. datacheck:
  1011. if (is_remount) {
  1012. if (test_opt(sb, DATA_FLAGS) == data_opt)
  1013. break;
  1014. ext3_msg(sb, KERN_ERR,
  1015. "error: cannot change "
  1016. "data mode on remount. The filesystem "
  1017. "is mounted in data=%s mode and you "
  1018. "try to remount it in data=%s mode.",
  1019. data_mode_string(test_opt(sb,
  1020. DATA_FLAGS)),
  1021. data_mode_string(data_opt));
  1022. return 0;
  1023. } else {
  1024. clear_opt(sbi->s_mount_opt, DATA_FLAGS);
  1025. sbi->s_mount_opt |= data_opt;
  1026. }
  1027. break;
  1028. case Opt_data_err_abort:
  1029. set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
  1030. break;
  1031. case Opt_data_err_ignore:
  1032. clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
  1033. break;
  1034. #ifdef CONFIG_QUOTA
  1035. case Opt_usrjquota:
  1036. if (!set_qf_name(sb, USRQUOTA, &args[0]))
  1037. return 0;
  1038. break;
  1039. case Opt_grpjquota:
  1040. if (!set_qf_name(sb, GRPQUOTA, &args[0]))
  1041. return 0;
  1042. break;
  1043. case Opt_offusrjquota:
  1044. if (!clear_qf_name(sb, USRQUOTA))
  1045. return 0;
  1046. break;
  1047. case Opt_offgrpjquota:
  1048. if (!clear_qf_name(sb, GRPQUOTA))
  1049. return 0;
  1050. break;
  1051. case Opt_jqfmt_vfsold:
  1052. qfmt = QFMT_VFS_OLD;
  1053. goto set_qf_format;
  1054. case Opt_jqfmt_vfsv0:
  1055. qfmt = QFMT_VFS_V0;
  1056. goto set_qf_format;
  1057. case Opt_jqfmt_vfsv1:
  1058. qfmt = QFMT_VFS_V1;
  1059. set_qf_format:
  1060. if (sb_any_quota_loaded(sb) &&
  1061. sbi->s_jquota_fmt != qfmt) {
  1062. ext3_msg(sb, KERN_ERR, "error: cannot change "
  1063. "journaled quota options when "
  1064. "quota turned on.");
  1065. return 0;
  1066. }
  1067. sbi->s_jquota_fmt = qfmt;
  1068. break;
  1069. case Opt_quota:
  1070. case Opt_usrquota:
  1071. set_opt(sbi->s_mount_opt, QUOTA);
  1072. set_opt(sbi->s_mount_opt, USRQUOTA);
  1073. break;
  1074. case Opt_grpquota:
  1075. set_opt(sbi->s_mount_opt, QUOTA);
  1076. set_opt(sbi->s_mount_opt, GRPQUOTA);
  1077. break;
  1078. case Opt_noquota:
  1079. if (sb_any_quota_loaded(sb)) {
  1080. ext3_msg(sb, KERN_ERR, "error: cannot change "
  1081. "quota options when quota turned on.");
  1082. return 0;
  1083. }
  1084. clear_opt(sbi->s_mount_opt, QUOTA);
  1085. clear_opt(sbi->s_mount_opt, USRQUOTA);
  1086. clear_opt(sbi->s_mount_opt, GRPQUOTA);
  1087. break;
  1088. #else
  1089. case Opt_quota:
  1090. case Opt_usrquota:
  1091. case Opt_grpquota:
  1092. ext3_msg(sb, KERN_ERR,
  1093. "error: quota options not supported.");
  1094. break;
  1095. case Opt_usrjquota:
  1096. case Opt_grpjquota:
  1097. case Opt_offusrjquota:
  1098. case Opt_offgrpjquota:
  1099. case Opt_jqfmt_vfsold:
  1100. case Opt_jqfmt_vfsv0:
  1101. case Opt_jqfmt_vfsv1:
  1102. ext3_msg(sb, KERN_ERR,
  1103. "error: journaled quota options not "
  1104. "supported.");
  1105. break;
  1106. case Opt_noquota:
  1107. break;
  1108. #endif
  1109. case Opt_abort:
  1110. set_opt(sbi->s_mount_opt, ABORT);
  1111. break;
  1112. case Opt_nobarrier:
  1113. clear_opt(sbi->s_mount_opt, BARRIER);
  1114. break;
  1115. case Opt_barrier:
  1116. if (args[0].from) {
  1117. if (match_int(&args[0], &option))
  1118. return 0;
  1119. } else
  1120. option = 1; /* No argument, default to 1 */
  1121. if (option)
  1122. set_opt(sbi->s_mount_opt, BARRIER);
  1123. else
  1124. clear_opt(sbi->s_mount_opt, BARRIER);
  1125. break;
  1126. case Opt_ignore:
  1127. break;
  1128. case Opt_resize:
  1129. if (!is_remount) {
  1130. ext3_msg(sb, KERN_ERR,
  1131. "error: resize option only available "
  1132. "for remount");
  1133. return 0;
  1134. }
  1135. if (match_int(&args[0], &option) != 0)
  1136. return 0;
  1137. *n_blocks_count = option;
  1138. break;
  1139. case Opt_nobh:
  1140. ext3_msg(sb, KERN_WARNING,
  1141. "warning: ignoring deprecated nobh option");
  1142. break;
  1143. case Opt_bh:
  1144. ext3_msg(sb, KERN_WARNING,
  1145. "warning: ignoring deprecated bh option");
  1146. break;
  1147. default:
  1148. ext3_msg(sb, KERN_ERR,
  1149. "error: unrecognized mount option \"%s\" "
  1150. "or missing value", p);
  1151. return 0;
  1152. }
  1153. }
  1154. #ifdef CONFIG_QUOTA
  1155. if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
  1156. if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA])
  1157. clear_opt(sbi->s_mount_opt, USRQUOTA);
  1158. if (test_opt(sb, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA])
  1159. clear_opt(sbi->s_mount_opt, GRPQUOTA);
  1160. if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
  1161. ext3_msg(sb, KERN_ERR, "error: old and new quota "
  1162. "format mixing.");
  1163. return 0;
  1164. }
  1165. if (!sbi->s_jquota_fmt) {
  1166. ext3_msg(sb, KERN_ERR, "error: journaled quota format "
  1167. "not specified.");
  1168. return 0;
  1169. }
  1170. } else {
  1171. if (sbi->s_jquota_fmt) {
  1172. ext3_msg(sb, KERN_ERR, "error: journaled quota format "
  1173. "specified with no journaling "
  1174. "enabled.");
  1175. return 0;
  1176. }
  1177. }
  1178. #endif
  1179. return 1;
  1180. }
  1181. static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
  1182. int read_only)
  1183. {
  1184. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1185. int res = 0;
  1186. if (le32_to_cpu(es->s_rev_level) > EXT3_MAX_SUPP_REV) {
  1187. ext3_msg(sb, KERN_ERR,
  1188. "error: revision level too high, "
  1189. "forcing read-only mode");
  1190. res = MS_RDONLY;
  1191. }
  1192. if (read_only)
  1193. return res;
  1194. if (!(sbi->s_mount_state & EXT3_VALID_FS))
  1195. ext3_msg(sb, KERN_WARNING,
  1196. "warning: mounting unchecked fs, "
  1197. "running e2fsck is recommended");
  1198. else if ((sbi->s_mount_state & EXT3_ERROR_FS))
  1199. ext3_msg(sb, KERN_WARNING,
  1200. "warning: mounting fs with errors, "
  1201. "running e2fsck is recommended");
  1202. else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
  1203. le16_to_cpu(es->s_mnt_count) >=
  1204. le16_to_cpu(es->s_max_mnt_count))
  1205. ext3_msg(sb, KERN_WARNING,
  1206. "warning: maximal mount count reached, "
  1207. "running e2fsck is recommended");
  1208. else if (le32_to_cpu(es->s_checkinterval) &&
  1209. (le32_to_cpu(es->s_lastcheck) +
  1210. le32_to_cpu(es->s_checkinterval) <= get_seconds()))
  1211. ext3_msg(sb, KERN_WARNING,
  1212. "warning: checktime reached, "
  1213. "running e2fsck is recommended");
  1214. #if 0
  1215. /* @@@ We _will_ want to clear the valid bit if we find
  1216. inconsistencies, to force a fsck at reboot. But for
  1217. a plain journaled filesystem we can keep it set as
  1218. valid forever! :) */
  1219. es->s_state &= cpu_to_le16(~EXT3_VALID_FS);
  1220. #endif
  1221. if (!le16_to_cpu(es->s_max_mnt_count))
  1222. es->s_max_mnt_count = cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
  1223. le16_add_cpu(&es->s_mnt_count, 1);
  1224. es->s_mtime = cpu_to_le32(get_seconds());
  1225. ext3_update_dynamic_rev(sb);
  1226. EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
  1227. ext3_commit_super(sb, es, 1);
  1228. if (test_opt(sb, DEBUG))
  1229. ext3_msg(sb, KERN_INFO, "[bs=%lu, gc=%lu, "
  1230. "bpg=%lu, ipg=%lu, mo=%04lx]",
  1231. sb->s_blocksize,
  1232. sbi->s_groups_count,
  1233. EXT3_BLOCKS_PER_GROUP(sb),
  1234. EXT3_INODES_PER_GROUP(sb),
  1235. sbi->s_mount_opt);
  1236. if (EXT3_SB(sb)->s_journal->j_inode == NULL) {
  1237. char b[BDEVNAME_SIZE];
  1238. ext3_msg(sb, KERN_INFO, "using external journal on %s",
  1239. bdevname(EXT3_SB(sb)->s_journal->j_dev, b));
  1240. } else {
  1241. ext3_msg(sb, KERN_INFO, "using internal journal");
  1242. }
  1243. cleancache_init_fs(sb);
  1244. return res;
  1245. }
  1246. /* Called at mount-time, super-block is locked */
  1247. static int ext3_check_descriptors(struct super_block *sb)
  1248. {
  1249. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1250. int i;
  1251. ext3_debug ("Checking group descriptors");
  1252. for (i = 0; i < sbi->s_groups_count; i++) {
  1253. struct ext3_group_desc *gdp = ext3_get_group_desc(sb, i, NULL);
  1254. ext3_fsblk_t first_block = ext3_group_first_block_no(sb, i);
  1255. ext3_fsblk_t last_block;
  1256. if (i == sbi->s_groups_count - 1)
  1257. last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
  1258. else
  1259. last_block = first_block +
  1260. (EXT3_BLOCKS_PER_GROUP(sb) - 1);
  1261. if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
  1262. le32_to_cpu(gdp->bg_block_bitmap) > last_block)
  1263. {
  1264. ext3_error (sb, "ext3_check_descriptors",
  1265. "Block bitmap for group %d"
  1266. " not in group (block %lu)!",
  1267. i, (unsigned long)
  1268. le32_to_cpu(gdp->bg_block_bitmap));
  1269. return 0;
  1270. }
  1271. if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
  1272. le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
  1273. {
  1274. ext3_error (sb, "ext3_check_descriptors",
  1275. "Inode bitmap for group %d"
  1276. " not in group (block %lu)!",
  1277. i, (unsigned long)
  1278. le32_to_cpu(gdp->bg_inode_bitmap));
  1279. return 0;
  1280. }
  1281. if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
  1282. le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 >
  1283. last_block)
  1284. {
  1285. ext3_error (sb, "ext3_check_descriptors",
  1286. "Inode table for group %d"
  1287. " not in group (block %lu)!",
  1288. i, (unsigned long)
  1289. le32_to_cpu(gdp->bg_inode_table));
  1290. return 0;
  1291. }
  1292. }
  1293. sbi->s_es->s_free_blocks_count=cpu_to_le32(ext3_count_free_blocks(sb));
  1294. sbi->s_es->s_free_inodes_count=cpu_to_le32(ext3_count_free_inodes(sb));
  1295. return 1;
  1296. }
  1297. /* ext3_orphan_cleanup() walks a singly-linked list of inodes (starting at
  1298. * the superblock) which were deleted from all directories, but held open by
  1299. * a process at the time of a crash. We walk the list and try to delete these
  1300. * inodes at recovery time (only with a read-write filesystem).
  1301. *
  1302. * In order to keep the orphan inode chain consistent during traversal (in
  1303. * case of crash during recovery), we link each inode into the superblock
  1304. * orphan list_head and handle it the same way as an inode deletion during
  1305. * normal operation (which journals the operations for us).
  1306. *
  1307. * We only do an iget() and an iput() on each inode, which is very safe if we
  1308. * accidentally point at an in-use or already deleted inode. The worst that
  1309. * can happen in this case is that we get a "bit already cleared" message from
  1310. * ext3_free_inode(). The only reason we would point at a wrong inode is if
  1311. * e2fsck was run on this filesystem, and it must have already done the orphan
  1312. * inode cleanup for us, so we can safely abort without any further action.
  1313. */
  1314. static void ext3_orphan_cleanup (struct super_block * sb,
  1315. struct ext3_super_block * es)
  1316. {
  1317. unsigned int s_flags = sb->s_flags;
  1318. int nr_orphans = 0, nr_truncates = 0;
  1319. #ifdef CONFIG_QUOTA
  1320. int i;
  1321. #endif
  1322. if (!es->s_last_orphan) {
  1323. jbd_debug(4, "no orphan inodes to clean up\n");
  1324. return;
  1325. }
  1326. if (bdev_read_only(sb->s_bdev)) {
  1327. ext3_msg(sb, KERN_ERR, "error: write access "
  1328. "unavailable, skipping orphan cleanup.");
  1329. return;
  1330. }
  1331. /* Check if feature set allows readwrite operations */
  1332. if (EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP)) {
  1333. ext3_msg(sb, KERN_INFO, "Skipping orphan cleanup due to "
  1334. "unknown ROCOMPAT features");
  1335. return;
  1336. }
  1337. if (EXT3_SB(sb)->s_mount_state & EXT3_ERROR_FS) {
  1338. if (es->s_last_orphan)
  1339. jbd_debug(1, "Errors on filesystem, "
  1340. "clearing orphan list.\n");
  1341. es->s_last_orphan = 0;
  1342. jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
  1343. return;
  1344. }
  1345. if (s_flags & MS_RDONLY) {
  1346. ext3_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
  1347. sb->s_flags &= ~MS_RDONLY;
  1348. }
  1349. #ifdef CONFIG_QUOTA
  1350. /* Needed for iput() to work correctly and not trash data */
  1351. sb->s_flags |= MS_ACTIVE;
  1352. /* Turn on quotas so that they are updated correctly */
  1353. for (i = 0; i < MAXQUOTAS; i++) {
  1354. if (EXT3_SB(sb)->s_qf_names[i]) {
  1355. int ret = ext3_quota_on_mount(sb, i);
  1356. if (ret < 0)
  1357. ext3_msg(sb, KERN_ERR,
  1358. "error: cannot turn on journaled "
  1359. "quota: %d", ret);
  1360. }
  1361. }
  1362. #endif
  1363. while (es->s_last_orphan) {
  1364. struct inode *inode;
  1365. inode = ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
  1366. if (IS_ERR(inode)) {
  1367. es->s_last_orphan = 0;
  1368. break;
  1369. }
  1370. list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
  1371. dquot_initialize(inode);
  1372. if (inode->i_nlink) {
  1373. printk(KERN_DEBUG
  1374. "%s: truncating inode %lu to %Ld bytes\n",
  1375. __func__, inode->i_ino, inode->i_size);
  1376. jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
  1377. inode->i_ino, inode->i_size);
  1378. ext3_truncate(inode);
  1379. nr_truncates++;
  1380. } else {
  1381. printk(KERN_DEBUG
  1382. "%s: deleting unreferenced inode %lu\n",
  1383. __func__, inode->i_ino);
  1384. jbd_debug(2, "deleting unreferenced inode %lu\n",
  1385. inode->i_ino);
  1386. nr_orphans++;
  1387. }
  1388. iput(inode); /* The delete magic happens here! */
  1389. }
  1390. #define PLURAL(x) (x), ((x)==1) ? "" : "s"
  1391. if (nr_orphans)
  1392. ext3_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
  1393. PLURAL(nr_orphans));
  1394. if (nr_truncates)
  1395. ext3_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
  1396. PLURAL(nr_truncates));
  1397. #ifdef CONFIG_QUOTA
  1398. /* Turn quotas off */
  1399. for (i = 0; i < MAXQUOTAS; i++) {
  1400. if (sb_dqopt(sb)->files[i])
  1401. dquot_quota_off(sb, i);
  1402. }
  1403. #endif
  1404. sb->s_flags = s_flags; /* Restore MS_RDONLY status */
  1405. }
  1406. /*
  1407. * Maximal file size. There is a direct, and {,double-,triple-}indirect
  1408. * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
  1409. * We need to be 1 filesystem block less than the 2^32 sector limit.
  1410. */
  1411. static loff_t ext3_max_size(int bits)
  1412. {
  1413. loff_t res = EXT3_NDIR_BLOCKS;
  1414. int meta_blocks;
  1415. loff_t upper_limit;
  1416. /* This is calculated to be the largest file size for a
  1417. * dense, file such that the total number of
  1418. * sectors in the file, including data and all indirect blocks,
  1419. * does not exceed 2^32 -1
  1420. * __u32 i_blocks representing the total number of
  1421. * 512 bytes blocks of the file
  1422. */
  1423. upper_limit = (1LL << 32) - 1;
  1424. /* total blocks in file system block size */
  1425. upper_limit >>= (bits - 9);
  1426. /* indirect blocks */
  1427. meta_blocks = 1;
  1428. /* double indirect blocks */
  1429. meta_blocks += 1 + (1LL << (bits-2));
  1430. /* tripple indirect blocks */
  1431. meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
  1432. upper_limit -= meta_blocks;
  1433. upper_limit <<= bits;
  1434. res += 1LL << (bits-2);
  1435. res += 1LL << (2*(bits-2));
  1436. res += 1LL << (3*(bits-2));
  1437. res <<= bits;
  1438. if (res > upper_limit)
  1439. res = upper_limit;
  1440. if (res > MAX_LFS_FILESIZE)
  1441. res = MAX_LFS_FILESIZE;
  1442. return res;
  1443. }
  1444. static ext3_fsblk_t descriptor_loc(struct super_block *sb,
  1445. ext3_fsblk_t logic_sb_block,
  1446. int nr)
  1447. {
  1448. struct ext3_sb_info *sbi = EXT3_SB(sb);
  1449. unsigned long bg, first_meta_bg;
  1450. int has_super = 0;
  1451. first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
  1452. if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
  1453. nr < first_meta_bg)
  1454. return (logic_sb_block + nr + 1);
  1455. bg = sbi->s_desc_per_block * nr;
  1456. if (ext3_bg_has_super(sb, bg))
  1457. has_super = 1;
  1458. return (has_super + ext3_group_first_block_no(sb, bg));
  1459. }
  1460. static int ext3_fill_super (struct super_block *sb, void *data, int silent)
  1461. {
  1462. struct buffer_head * bh;
  1463. struct ext3_super_block *es = NULL;
  1464. struct ext3_sb_info *sbi;
  1465. ext3_fsblk_t block;
  1466. ext3_fsblk_t sb_block = get_sb_block(&data, sb);
  1467. ext3_fsblk_t logic_sb_block;
  1468. unsigned long offset = 0;
  1469. unsigned int journal_inum = 0;
  1470. unsigned long journal_devnum = 0;
  1471. unsigned long def_mount_opts;
  1472. struct inode *root;
  1473. int blocksize;
  1474. int hblock;
  1475. int db_count;
  1476. int i;
  1477. int needs_recovery;
  1478. int ret = -EINVAL;
  1479. __le32 features;
  1480. int err;
  1481. sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
  1482. if (!sbi)
  1483. return -ENOMEM;
  1484. sbi->s_blockgroup_lock =
  1485. kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
  1486. if (!sbi->s_blockgroup_lock) {
  1487. kfree(sbi);
  1488. return -ENOMEM;
  1489. }
  1490. sb->s_fs_info = sbi;
  1491. sbi->s_mount_opt = 0;
  1492. sbi->s_resuid = EXT3_DEF_RESUID;
  1493. sbi->s_resgid = EXT3_DEF_RESGID;
  1494. sbi->s_sb_block = sb_block;
  1495. blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
  1496. if (!blocksize) {
  1497. ext3_msg(sb, KERN_ERR, "error: unable to set blocksize");
  1498. goto out_fail;
  1499. }
  1500. /*
  1501. * The ext3 superblock will not be buffer aligned for other than 1kB
  1502. * block sizes. We need to calculate the offset from buffer start.
  1503. */
  1504. if (blocksize != EXT3_MIN_BLOCK_SIZE) {
  1505. logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
  1506. offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
  1507. } else {
  1508. logic_sb_block = sb_block;
  1509. }
  1510. if (!(bh = sb_bread(sb, logic_sb_block))) {
  1511. ext3_msg(sb, KERN_ERR, "error: unable to read superblock");
  1512. goto out_fail;
  1513. }
  1514. /*
  1515. * Note: s_es must be initialized as soon as possible because
  1516. * some ext3 macro-instructions depend on its value
  1517. */
  1518. es = (struct ext3_super_block *) (bh->b_data + offset);
  1519. sbi->s_es = es;
  1520. sb->s_magic = le16_to_cpu(es->s_magic);
  1521. if (sb->s_magic != EXT3_SUPER_MAGIC)
  1522. goto cantfind_ext3;
  1523. /* Set defaults before we parse the mount options */
  1524. def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
  1525. if (def_mount_opts & EXT3_DEFM_DEBUG)
  1526. set_opt(sbi->s_mount_opt, DEBUG);
  1527. if (def_mount_opts & EXT3_DEFM_BSDGROUPS)
  1528. set_opt(sbi->s_mount_opt, GRPID);
  1529. if (def_mount_opts & EXT3_DEFM_UID16)
  1530. set_opt(sbi->s_mount_opt, NO_UID32);
  1531. #ifdef CONFIG_EXT3_FS_XATTR
  1532. if (def_mount_opts & EXT3_DEFM_XATTR_USER)
  1533. set_opt(sbi->s_mount_opt, XATTR_USER);
  1534. #endif
  1535. #ifdef CONFIG_EXT3_FS_POSIX_ACL
  1536. if (def_mount_opts & EXT3_DEFM_ACL)
  1537. set_opt(sbi->s_mount_opt, POSIX_ACL);
  1538. #endif
  1539. if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_DATA)
  1540. set_opt(sbi->s_mount_opt, JOURNAL_DATA);
  1541. else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_ORDERED)
  1542. set_opt(sbi->s_mount_opt, ORDERED_DATA);
  1543. else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_WBACK)
  1544. set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
  1545. if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_PANIC)
  1546. set_opt(sbi->s_mount_opt, ERRORS_PANIC);
  1547. else if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_CONTINUE)
  1548. set_opt(sbi->s_mount_opt, ERRORS_CONT);
  1549. else
  1550. set_opt(sbi->s_mount_opt, ERRORS_RO);
  1551. sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
  1552. sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
  1553. /* enable barriers by default */
  1554. set_opt(sbi->s_mount_opt, BARRIER);
  1555. set_opt(sbi->s_mount_opt, RESERVATION);
  1556. if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
  1557. NULL, 0))
  1558. goto failed_mount;
  1559. sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
  1560. (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
  1561. if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV &&
  1562. (EXT3_HAS_COMPAT_FEATURE(sb, ~0U) ||
  1563. EXT3_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
  1564. EXT3_HAS_INCOMPAT_FEATURE(sb, ~0U)))
  1565. ext3_msg(sb, KERN_WARNING,
  1566. "warning: feature flags set on rev 0 fs, "
  1567. "running e2fsck is recommended");
  1568. /*
  1569. * Check feature flags regardless of the revision level, since we
  1570. * previously didn't change the revision level when setting the flags,
  1571. * so there is a chance incompat flags are set on a rev 0 filesystem.
  1572. */
  1573. features = EXT3_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP);
  1574. if (features) {
  1575. ext3_msg(sb, KERN_ERR,
  1576. "error: couldn't mount because of unsupported "
  1577. "optional features (%x)", le32_to_cpu(features));
  1578. goto failed_mount;
  1579. }
  1580. features = EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP);
  1581. if (!(sb->s_flags & MS_RDONLY) && features) {
  1582. ext3_msg(sb, KERN_ERR,
  1583. "error: couldn't mount RDWR because of unsupported "
  1584. "optional features (%x)", le32_to_cpu(features));
  1585. goto failed_mount;
  1586. }
  1587. blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
  1588. if (blocksize < EXT3_MIN_BLOCK_SIZE ||
  1589. blocksize > EXT3_MAX_BLOCK_SIZE) {
  1590. ext3_msg(sb, KERN_ERR,
  1591. "error: couldn't mount because of unsupported "
  1592. "filesystem blocksize %d", blocksize);
  1593. goto failed_mount;
  1594. }
  1595. hblock = bdev_logical_block_size(sb->s_bdev);
  1596. if (sb->s_blocksize != blocksize) {
  1597. /*
  1598. * Make sure the blocksize for the filesystem is larger
  1599. * than the hardware sectorsize for the machine.
  1600. */
  1601. if (blocksize < hblock) {
  1602. ext3_msg(sb, KERN_ERR,
  1603. "error: fsblocksize %d too small for "
  1604. "hardware sectorsize %d", blocksize, hblock);
  1605. goto failed_mount;
  1606. }
  1607. brelse (bh);
  1608. if (!sb_set_blocksize(sb, blocksize)) {
  1609. ext3_msg(sb, KERN_ERR,
  1610. "error: bad blocksize %d", blocksize);
  1611. goto out_fail;
  1612. }
  1613. logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
  1614. offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
  1615. bh = sb_bread(sb, logic_sb_block);
  1616. if (!bh) {
  1617. ext3_msg(sb, KERN_ERR,
  1618. "error: can't read superblock on 2nd try");
  1619. goto