开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
super.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：25k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

super.c：源码内容
  1. /*
  2.  *  linux/fs/ext2/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.  */
  19. #include <linux/config.h>
  20. #include <linux/module.h>
  21. #include <linux/string.h>
  22. #include <linux/fs.h>
  23. #include <linux/ext2_fs.h>
  24. #include <linux/slab.h>
  25. #include <linux/init.h>
  26. #include <linux/locks.h>
  27. #include <linux/blkdev.h>
  28. #include <asm/uaccess.h>
  31. static void ext2_sync_super(struct super_block *sb,
  32.     struct ext2_super_block *es);
  34. static char error_buf[1024];
  36. void ext2_error (struct super_block * sb, const char * function,
  37.  const char * fmt, ...)
  38. {
  39. va_list args;
  40. struct ext2_super_block *es = EXT2_SB(sb)->s_es;
  42. if (!(sb->s_flags & MS_RDONLY)) {
  43. sb->u.ext2_sb.s_mount_state |= EXT2_ERROR_FS;
  44. es->s_state =
  45. cpu_to_le16(le16_to_cpu(es->s_state) | EXT2_ERROR_FS);
  46. ext2_sync_super(sb, es);
  47. }
  48. va_start (args, fmt);
  49. vsprintf (error_buf, fmt, args);
  50. va_end (args);
  51. if (test_opt (sb, ERRORS_PANIC) ||
  52.     (le16_to_cpu(sb->u.ext2_sb.s_es->s_errors) == EXT2_ERRORS_PANIC &&
  53.      !test_opt (sb, ERRORS_CONT) && !test_opt (sb, ERRORS_RO)))
  54. panic ("EXT2-fs panic (device %s): %s: %sn",
  55.        bdevname(sb->s_dev), function, error_buf);
  56. printk (KERN_CRIT "EXT2-fs error (device %s): %s: %sn",
  57. bdevname(sb->s_dev), function, error_buf);
  58. if (test_opt (sb, ERRORS_RO) ||
  59.     (le16_to_cpu(sb->u.ext2_sb.s_es->s_errors) == EXT2_ERRORS_RO &&
  60.      !test_opt (sb, ERRORS_CONT) && !test_opt (sb, ERRORS_PANIC))) {
  61. printk ("Remounting filesystem read-onlyn");
  62. sb->s_flags |= MS_RDONLY;
  63. }
  64. }
  66. NORET_TYPE void ext2_panic (struct super_block * sb, const char * function,
  67.     const char * fmt, ...)
  68. {
  69. va_list args;
  71. if (!(sb->s_flags & MS_RDONLY)) {
  72. sb->u.ext2_sb.s_mount_state |= EXT2_ERROR_FS;
  73. sb->u.ext2_sb.s_es->s_state =
  74. cpu_to_le16(le16_to_cpu(sb->u.ext2_sb.s_es->s_state) | EXT2_ERROR_FS);
  75. mark_buffer_dirty(sb->u.ext2_sb.s_sbh);
  76. sb->s_dirt = 1;
  77. }
  78. va_start (args, fmt);
  79. vsprintf (error_buf, fmt, args);
  80. va_end (args);
  81. sb->s_flags |= MS_RDONLY;
  82. panic ("EXT2-fs panic (device %s): %s: %sn",
  83.        bdevname(sb->s_dev), function, error_buf);
  84. }
  86. void ext2_warning (struct super_block * sb, const char * function,
  87.    const char * fmt, ...)
  88. {
  89. va_list args;
  91. va_start (args, fmt);
  92. vsprintf (error_buf, fmt, args);
  93. va_end (args);
  94. printk (KERN_WARNING "EXT2-fs warning (device %s): %s: %sn",
  95. bdevname(sb->s_dev), function, error_buf);
  96. }
  98. void ext2_update_dynamic_rev(struct super_block *sb)
  99. {
  100. struct ext2_super_block *es = EXT2_SB(sb)->s_es;
  102. if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
  103. return;
  105. ext2_warning(sb, __FUNCTION__,
  106.      "updating to rev %d because of new feature flag, "
  107.      "running e2fsck is recommended",
  108.      EXT2_DYNAMIC_REV);
  110. es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);
  111. es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);
  112. es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);
  113. /* leave es->s_feature_*compat flags alone */
  114. /* es->s_uuid will be set by e2fsck if empty */
  116. /*
  117.  * The rest of the superblock fields should be zero, and if not it
  118.  * means they are likely already in use, so leave them alone.  We
  119.  * can leave it up to e2fsck to clean up any inconsistencies there.
  120.  */
  121. }
  123. void ext2_put_super (struct super_block * sb)
  124. {
  125. int db_count;
  126. int i;
  128. if (!(sb->s_flags & MS_RDONLY)) {
  129. struct ext2_super_block *es = EXT2_SB(sb)->s_es;
  131. es->s_state = le16_to_cpu(EXT2_SB(sb)->s_mount_state);
  132. ext2_sync_super(sb, es);
  133. }
  134. db_count = EXT2_SB(sb)->s_gdb_count;
  135. for (i = 0; i < db_count; i++)
  136. if (sb->u.ext2_sb.s_group_desc[i])
  137. brelse (sb->u.ext2_sb.s_group_desc[i]);
  138. kfree(sb->u.ext2_sb.s_group_desc);
  139. for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)
  140. if (sb->u.ext2_sb.s_inode_bitmap[i])
  141. brelse (sb->u.ext2_sb.s_inode_bitmap[i]);
  142. for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++)
  143. if (sb->u.ext2_sb.s_block_bitmap[i])
  144. brelse (sb->u.ext2_sb.s_block_bitmap[i]);
  145. brelse (sb->u.ext2_sb.s_sbh);
  147. return;
  148. }
  150. static struct super_operations ext2_sops = {
  151. read_inode: ext2_read_inode,
  152. write_inode: ext2_write_inode,
  153. put_inode: ext2_put_inode,
  154. delete_inode: ext2_delete_inode,
  155. put_super: ext2_put_super,
  156. write_super: ext2_write_super,
  157. statfs: ext2_statfs,
  158. remount_fs: ext2_remount,
  159. };
  161. /*
  162.  * This function has been shamelessly adapted from the msdos fs
  163.  */
  164. static int parse_options (char * options, unsigned long * sb_block,
  165.   unsigned short *resuid, unsigned short * resgid,
  166.   unsigned long * mount_options)
  167. {
  168. char * this_char;
  169. char * value;
  171. if (!options)
  172. return 1;
  173. for (this_char = strtok (options, ",");
  174.      this_char != NULL;
  175.      this_char = strtok (NULL, ",")) {
  176. if ((value = strchr (this_char, '=')) != NULL)
  177. *value++ = 0;
  178. if (!strcmp (this_char, "bsddf"))
  179. clear_opt (*mount_options, MINIX_DF);
  180. else if (!strcmp (this_char, "nouid32")) {
  181. set_opt (*mount_options, NO_UID32);
  182. }
  183. else if (!strcmp (this_char, "check")) {
  184. if (!value || !*value || !strcmp (value, "none"))
  185. clear_opt (*mount_options, CHECK);
  186. else
  187. #ifdef CONFIG_EXT2_CHECK
  188. set_opt (*mount_options, CHECK);
  189. #else
  190. printk("EXT2 Check option not supportedn");
  191. #endif
  192. }
  193. else if (!strcmp (this_char, "debug"))
  194. set_opt (*mount_options, DEBUG);
  195. else if (!strcmp (this_char, "errors")) {
  196. if (!value || !*value) {
  197. printk ("EXT2-fs: the errors option requires "
  198. "an argumentn");
  199. return 0;
  200. }
  201. if (!strcmp (value, "continue")) {
  202. clear_opt (*mount_options, ERRORS_RO);
  203. clear_opt (*mount_options, ERRORS_PANIC);
  204. set_opt (*mount_options, ERRORS_CONT);
  205. }
  206. else if (!strcmp (value, "remount-ro")) {
  207. clear_opt (*mount_options, ERRORS_CONT);
  208. clear_opt (*mount_options, ERRORS_PANIC);
  209. set_opt (*mount_options, ERRORS_RO);
  210. }
  211. else if (!strcmp (value, "panic")) {
  212. clear_opt (*mount_options, ERRORS_CONT);
  213. clear_opt (*mount_options, ERRORS_RO);
  214. set_opt (*mount_options, ERRORS_PANIC);
  215. }
  216. else {
  217. printk ("EXT2-fs: Invalid errors option: %sn",
  218. value);
  219. return 0;
  220. }
  221. }
  222. else if (!strcmp (this_char, "grpid") ||
  223.  !strcmp (this_char, "bsdgroups"))
  224. set_opt (*mount_options, GRPID);
  225. else if (!strcmp (this_char, "minixdf"))
  226. set_opt (*mount_options, MINIX_DF);
  227. else if (!strcmp (this_char, "nocheck"))
  228. clear_opt (*mount_options, CHECK);
  229. else if (!strcmp (this_char, "nogrpid") ||
  230.  !strcmp (this_char, "sysvgroups"))
  231. clear_opt (*mount_options, GRPID);
  232. else if (!strcmp (this_char, "resgid")) {
  233. if (!value || !*value) {
  234. printk ("EXT2-fs: the resgid option requires "
  235. "an argumentn");
  236. return 0;
  237. }
  238. *resgid = simple_strtoul (value, &value, 0);
  239. if (*value) {
  240. printk ("EXT2-fs: Invalid resgid option: %sn",
  241. value);
  242. return 0;
  243. }
  244. }
  245. else if (!strcmp (this_char, "resuid")) {
  246. if (!value || !*value) {
  247. printk ("EXT2-fs: the resuid option requires "
  248. "an argument");
  249. return 0;
  250. }
  251. *resuid = simple_strtoul (value, &value, 0);
  252. if (*value) {
  253. printk ("EXT2-fs: Invalid resuid option: %sn",
  254. value);
  255. return 0;
  256. }
  257. }
  258. else if (!strcmp (this_char, "sb")) {
  259. if (!value || !*value) {
  260. printk ("EXT2-fs: the sb option requires "
  261. "an argument");
  262. return 0;
  263. }
  264. *sb_block = simple_strtoul (value, &value, 0);
  265. if (*value) {
  266. printk ("EXT2-fs: Invalid sb option: %sn",
  267. value);
  268. return 0;
  269. }
  270. }
  271. /* Silently ignore the quota options */
  272. else if (!strcmp (this_char, "grpquota")
  273.          || !strcmp (this_char, "noquota")
  274.          || !strcmp (this_char, "quota")
  275.          || !strcmp (this_char, "usrquota"))
  276. /* Don't do anything ;-) */ ;
  277. else {
  278. printk ("EXT2-fs: Unrecognized mount option %sn", this_char);
  279. return 0;
  280. }
  281. }
  282. return 1;
  283. }
  285. static int ext2_setup_super (struct super_block * sb,
  286.       struct ext2_super_block * es,
  287.       int read_only)
  288. {
  289. int res = 0;
  290. if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {
  291. printk ("EXT2-fs warning: revision level too high, "
  292. "forcing read-only moden");
  293. res = MS_RDONLY;
  294. }
  295. if (read_only)
  296. return res;
  297. if (!(sb->u.ext2_sb.s_mount_state & EXT2_VALID_FS))
  298. printk ("EXT2-fs warning: mounting unchecked fs, "
  299. "running e2fsck is recommendedn");
  300. else if ((sb->u.ext2_sb.s_mount_state & EXT2_ERROR_FS))
  301. printk ("EXT2-fs warning: mounting fs with errors, "
  302. "running e2fsck is recommendedn");
  303. else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
  304.  le16_to_cpu(es->s_mnt_count) >=
  305.  (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
  306. printk ("EXT2-fs warning: maximal mount count reached, "
  307. "running e2fsck is recommendedn");
  308. else if (le32_to_cpu(es->s_checkinterval) &&
  309. (le32_to_cpu(es->s_lastcheck) + le32_to_cpu(es->s_checkinterval) <= CURRENT_TIME))
  310. printk ("EXT2-fs warning: checktime reached, "
  311. "running e2fsck is recommendedn");
  312. if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
  313. es->s_max_mnt_count = (__s16) cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
  314. es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
  315. ext2_write_super(sb);
  316. if (test_opt (sb, DEBUG))
  317. printk ("[EXT II FS %s, %s, bs=%lu, fs=%lu, gc=%lu, "
  318. "bpg=%lu, ipg=%lu, mo=%04lx]n",
  319. EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,
  320. sb->u.ext2_sb.s_frag_size,
  321. sb->u.ext2_sb.s_groups_count,
  322. EXT2_BLOCKS_PER_GROUP(sb),
  323. EXT2_INODES_PER_GROUP(sb),
  324. sb->u.ext2_sb.s_mount_opt);
  325. #ifdef CONFIG_EXT2_CHECK
  326. if (test_opt (sb, CHECK)) {
  327. ext2_check_blocks_bitmap (sb);
  328. ext2_check_inodes_bitmap (sb);
  329. }
  330. #endif
  331. return res;
  332. }
  334. static int ext2_check_descriptors (struct super_block * sb)
  335. {
  336. int i;
  337. int desc_block = 0;
  338. unsigned long block = le32_to_cpu(sb->u.ext2_sb.s_es->s_first_data_block);
  339. struct ext2_group_desc * gdp = NULL;
  341. ext2_debug ("Checking group descriptors");
  343. for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++)
  344. {
  345. if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)
  346. gdp = (struct ext2_group_desc *) sb->u.ext2_sb.s_group_desc[desc_block++]->b_data;
  347. if (le32_to_cpu(gdp->bg_block_bitmap) < block ||
  348.     le32_to_cpu(gdp->bg_block_bitmap) >= block + EXT2_BLOCKS_PER_GROUP(sb))
  349. {
  350. ext2_error (sb, "ext2_check_descriptors",
  351.     "Block bitmap for group %d"
  352.     " not in group (block %lu)!",
  353.     i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));
  354. return 0;
  355. }
  356. if (le32_to_cpu(gdp->bg_inode_bitmap) < block ||
  357.     le32_to_cpu(gdp->bg_inode_bitmap) >= block + EXT2_BLOCKS_PER_GROUP(sb))
  358. {
  359. ext2_error (sb, "ext2_check_descriptors",
  360.     "Inode bitmap for group %d"
  361.     " not in group (block %lu)!",
  362.     i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));
  363. return 0;
  364. }
  365. if (le32_to_cpu(gdp->bg_inode_table) < block ||
  366.     le32_to_cpu(gdp->bg_inode_table) + sb->u.ext2_sb.s_itb_per_group >=
  367.     block + EXT2_BLOCKS_PER_GROUP(sb))
  368. {
  369. ext2_error (sb, "ext2_check_descriptors",
  370.     "Inode table for group %d"
  371.     " not in group (block %lu)!",
  372.     i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));
  373. return 0;
  374. }
  375. block += EXT2_BLOCKS_PER_GROUP(sb);
  376. gdp++;
  377. }
  378. return 1;
  379. }
  381. #define log2(n) ffz(~(n))
  382.  
  383. /*
  384.  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
  385.  * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
  386.  * We need to be 1 filesystem block less than the 2^32 sector limit.
  387.  */
  388. static loff_t ext2_max_size(int bits)
  389. {
  390. loff_t res = EXT2_NDIR_BLOCKS;
  391. res += 1LL << (bits-2);
  392. res += 1LL << (2*(bits-2));
  393. res += 1LL << (3*(bits-2));
  394. res <<= bits;
  395. if (res > (512LL << 32) - (1 << bits))
  396. res = (512LL << 32) - (1 << bits);
  397. return res;
  398. }
  400. struct super_block * ext2_read_super (struct super_block * sb, void * data,
  401.       int silent)
  402. {
  403. struct buffer_head * bh;
  404. struct ext2_super_block * es;
  405. unsigned long sb_block = 1;
  406. unsigned short resuid = EXT2_DEF_RESUID;
  407. unsigned short resgid = EXT2_DEF_RESGID;
  408. unsigned long logic_sb_block = 1;
  409. unsigned long offset = 0;
  410. kdev_t dev = sb->s_dev;
  411. int blocksize = BLOCK_SIZE;
  412. int db_count;
  413. int i, j;
  415. /*
  416.  * See what the current blocksize for the device is, and
  417.  * use that as the blocksize.  Otherwise (or if the blocksize
  418.  * is smaller than the default) use the default.
  419.  * This is important for devices that have a hardware
  420.  * sectorsize that is larger than the default.
  421.  */
  422. blocksize = get_hardsect_size(dev);
  423. if(blocksize < BLOCK_SIZE )
  424.     blocksize = BLOCK_SIZE;
  426. sb->u.ext2_sb.s_mount_opt = 0;
  427. if (!parse_options ((char *) data, &sb_block, &resuid, &resgid,
  428.     &sb->u.ext2_sb.s_mount_opt)) {
  429. return NULL;
  430. }
  432. if (set_blocksize(dev, blocksize) < 0) {
  433. printk ("EXT2-fs: unable to set blocksize %dn", blocksize);
  434. return NULL;
  435. }
  436. sb->s_blocksize = blocksize;
  438. /*
  439.  * If the superblock doesn't start on a sector boundary,
  440.  * calculate the offset.  FIXME(eric) this doesn't make sense
  441.  * that we would have to do this.
  442.  */
  443. if (blocksize != BLOCK_SIZE) {
  444. logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
  445. offset = (sb_block*BLOCK_SIZE) % blocksize;
  446. }
  448. if (!(bh = sb_bread(sb, logic_sb_block))) {
  449. printk ("EXT2-fs: unable to read superblockn");
  450. return NULL;
  451. }
  452. /*
  453.  * Note: s_es must be initialized as soon as possible because
  454.  *       some ext2 macro-instructions depend on its value
  455.  */
  456. es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
  457. sb->u.ext2_sb.s_es = es;
  458. sb->s_magic = le16_to_cpu(es->s_magic);
  459. if (sb->s_magic != EXT2_SUPER_MAGIC) {
  460. if (!silent)
  461. printk ("VFS: Can't find ext2 filesystem on dev %s.n",
  462. bdevname(dev));
  463. goto failed_mount;
  464. }
  465. if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
  466.     (EXT2_HAS_COMPAT_FEATURE(sb, ~0U) ||
  467.      EXT2_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
  468.      EXT2_HAS_INCOMPAT_FEATURE(sb, ~0U)))
  469. printk("EXT2-fs warning: feature flags set on rev 0 fs, "
  470.        "running e2fsck is recommendedn");
  471. /*
  472.  * Check feature flags regardless of the revision level, since we
  473.  * previously didn't change the revision level when setting the flags,
  474.  * so there is a chance incompat flags are set on a rev 0 filesystem.
  475.  */
  476. if ((i = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP))) {
  477. printk("EXT2-fs: %s: couldn't mount because of "
  478.        "unsupported optional features (%x).n",
  479.        bdevname(dev), i);
  480. goto failed_mount;
  481. }
  482. if (!(sb->s_flags & MS_RDONLY) &&
  483.     (i = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){
  484. printk("EXT2-fs: %s: couldn't mount RDWR because of "
  485.        "unsupported optional features (%x).n",
  486.        bdevname(dev), i);
  487. goto failed_mount;
  488. }
  489. sb->s_blocksize_bits =
  490. le32_to_cpu(EXT2_SB(sb)->s_es->s_log_block_size) + 10;
  491. sb->s_blocksize = 1 << sb->s_blocksize_bits;
  493. sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
  495. /* If the blocksize doesn't match, re-read the thing.. */
  496. if (sb->s_blocksize != blocksize) {
  497. blocksize = sb->s_blocksize;
  498. brelse(bh);
  500. if (set_blocksize(dev, blocksize) < 0) {
  501. printk(KERN_ERR "EXT2-fs: blocksize too small for device.n");
  502. return NULL;
  503. }
  505. logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
  506. offset = (sb_block*BLOCK_SIZE) % blocksize;
  507. bh = sb_bread(sb, logic_sb_block);
  508. if(!bh) {
  509. printk("EXT2-fs: Couldn't read superblock on "
  510.        "2nd try.n");
  511. goto failed_mount;
  512. }
  513. es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
  514. sb->u.ext2_sb.s_es = es;
  515. if (es->s_magic != le16_to_cpu(EXT2_SUPER_MAGIC)) {
  516. printk ("EXT2-fs: Magic mismatch, very weird !n");
  517. goto failed_mount;
  518. }
  519. }
  521. if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
  522. sb->u.ext2_sb.s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
  523. sb->u.ext2_sb.s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
  524. } else {
  525. sb->u.ext2_sb.s_inode_size = le16_to_cpu(es->s_inode_size);
  526. sb->u.ext2_sb.s_first_ino = le32_to_cpu(es->s_first_ino);
  527. if (sb->u.ext2_sb.s_inode_size != EXT2_GOOD_OLD_INODE_SIZE) {
  528. printk ("EXT2-fs: unsupported inode size: %dn",
  529. sb->u.ext2_sb.s_inode_size);
  530. goto failed_mount;
  531. }
  532. }
  533. sb->u.ext2_sb.s_frag_size = EXT2_MIN_FRAG_SIZE <<
  534.    le32_to_cpu(es->s_log_frag_size);
  535. if (sb->u.ext2_sb.s_frag_size)
  536. sb->u.ext2_sb.s_frags_per_block = sb->s_blocksize /
  537.   sb->u.ext2_sb.s_frag_size;
  538. else
  539. sb->s_magic = 0;
  540. sb->u.ext2_sb.s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
  541. sb->u.ext2_sb.s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
  542. sb->u.ext2_sb.s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
  543. sb->u.ext2_sb.s_inodes_per_block = sb->s_blocksize /
  544.    EXT2_INODE_SIZE(sb);
  545. sb->u.ext2_sb.s_itb_per_group = sb->u.ext2_sb.s_inodes_per_group /
  546.         sb->u.ext2_sb.s_inodes_per_block;
  547. sb->u.ext2_sb.s_desc_per_block = sb->s_blocksize /
  548.  sizeof (struct ext2_group_desc);
  549. sb->u.ext2_sb.s_sbh = bh;
  550. if (resuid != EXT2_DEF_RESUID)
  551. sb->u.ext2_sb.s_resuid = resuid;
  552. else
  553. sb->u.ext2_sb.s_resuid = le16_to_cpu(es->s_def_resuid);
  554. if (resgid != EXT2_DEF_RESGID)
  555. sb->u.ext2_sb.s_resgid = resgid;
  556. else
  557. sb->u.ext2_sb.s_resgid = le16_to_cpu(es->s_def_resgid);
  558. sb->u.ext2_sb.s_mount_state = le16_to_cpu(es->s_state);
  559. sb->u.ext2_sb.s_addr_per_block_bits =
  560. log2 (EXT2_ADDR_PER_BLOCK(sb));
  561. sb->u.ext2_sb.s_desc_per_block_bits =
  562. log2 (EXT2_DESC_PER_BLOCK(sb));
  563. if (sb->s_magic != EXT2_SUPER_MAGIC) {
  564. if (!silent)
  565. printk ("VFS: Can't find an ext2 filesystem on dev "
  566. "%s.n",
  567. bdevname(dev));
  568. goto failed_mount;
  569. }
  570. if (sb->s_blocksize != bh->b_size) {
  571. if (!silent)
  572. printk ("VFS: Unsupported blocksize on dev "
  573. "%s.n", bdevname(dev));
  574. goto failed_mount;
  575. }
  577. if (sb->s_blocksize != sb->u.ext2_sb.s_frag_size) {
  578. printk ("EXT2-fs: fragsize %lu != blocksize %lu (not supported yet)n",
  579. sb->u.ext2_sb.s_frag_size, sb->s_blocksize);
  580. goto failed_mount;
  581. }
  583. if (sb->u.ext2_sb.s_blocks_per_group > sb->s_blocksize * 8) {
  584. printk ("EXT2-fs: #blocks per group too big: %lun",
  585. sb->u.ext2_sb.s_blocks_per_group);
  586. goto failed_mount;
  587. }
  588. if (sb->u.ext2_sb.s_frags_per_group > sb->s_blocksize * 8) {
  589. printk ("EXT2-fs: #fragments per group too big: %lun",
  590. sb->u.ext2_sb.s_frags_per_group);
  591. goto failed_mount;
  592. }
  593. if (sb->u.ext2_sb.s_inodes_per_group > sb->s_blocksize * 8) {
  594. printk ("EXT2-fs: #inodes per group too big: %lun",
  595. sb->u.ext2_sb.s_inodes_per_group);
  596. goto failed_mount;
  597. }
  599. sb->u.ext2_sb.s_groups_count = (le32_to_cpu(es->s_blocks_count) -
  600.         le32_to_cpu(es->s_first_data_block) +
  601.        EXT2_BLOCKS_PER_GROUP(sb) - 1) /
  602.        EXT2_BLOCKS_PER_GROUP(sb);
  603. db_count = (sb->u.ext2_sb.s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
  604.    EXT2_DESC_PER_BLOCK(sb);
  605. sb->u.ext2_sb.s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
  606. if (sb->u.ext2_sb.s_group_desc == NULL) {
  607. printk ("EXT2-fs: not enough memoryn");
  608. goto failed_mount;
  609. }
  610. for (i = 0; i < db_count; i++) {
  611. sb->u.ext2_sb.s_group_desc[i] = sb_bread(sb, logic_sb_block + i + 1);
  612. if (!sb->u.ext2_sb.s_group_desc[i]) {
  613. for (j = 0; j < i; j++)
  614. brelse (sb->u.ext2_sb.s_group_desc[j]);
  615. kfree(sb->u.ext2_sb.s_group_desc);
  616. printk ("EXT2-fs: unable to read group descriptorsn");
  617. goto failed_mount;
  618. }
  619. }
  620. if (!ext2_check_descriptors (sb)) {
  621. printk ("EXT2-fs: group descriptors corrupted!n");
  622. db_count = i;
  623. goto failed_mount2;
  624. }
  625. for (i = 0; i < EXT2_MAX_GROUP_LOADED; i++) {
  626. sb->u.ext2_sb.s_inode_bitmap_number[i] = 0;
  627. sb->u.ext2_sb.s_inode_bitmap[i] = NULL;
  628. sb->u.ext2_sb.s_block_bitmap_number[i] = 0;
  629. sb->u.ext2_sb.s_block_bitmap[i] = NULL;
  630. }
  631. sb->u.ext2_sb.s_loaded_inode_bitmaps = 0;
  632. sb->u.ext2_sb.s_loaded_block_bitmaps = 0;
  633. sb->u.ext2_sb.s_gdb_count = db_count;
  634. /*
  635.  * set up enough so that it can read an inode
  636.  */
  637. sb->s_op = &ext2_sops;
  638. sb->s_root = d_alloc_root(iget(sb, EXT2_ROOT_INO));
  639. if (!sb->s_root || !S_ISDIR(sb->s_root->d_inode->i_mode) ||
  640.     !sb->s_root->d_inode->i_blocks || !sb->s_root->d_inode->i_size) {
  641. if (sb->s_root) {
  642. dput(sb->s_root);
  643. sb->s_root = NULL;
  644. printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsckn");
  645. } else
  646. printk(KERN_ERR "EXT2-fs: get root inode failedn");
  647. goto failed_mount2;
  648. }
  649. ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
  650. return sb;
  651. failed_mount2:
  652. for (i = 0; i < db_count; i++)
  653. brelse(sb->u.ext2_sb.s_group_desc[i]);
  654. kfree(sb->u.ext2_sb.s_group_desc);
  655. failed_mount:
  656. brelse(bh);
  657. return NULL;
  658. }
  660. static void ext2_commit_super (struct super_block * sb,
  661.        struct ext2_super_block * es)
  662. {
  663. es->s_wtime = cpu_to_le32(CURRENT_TIME);
  664. mark_buffer_dirty(sb->u.ext2_sb.s_sbh);
  665. sb->s_dirt = 0;
  666. }
  668. static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
  669. {
  670. es->s_wtime = cpu_to_le32(CURRENT_TIME);
  671. mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
  672. ll_rw_block(WRITE, 1, &EXT2_SB(sb)->s_sbh);
  673. wait_on_buffer(EXT2_SB(sb)->s_sbh);
  674. sb->s_dirt = 0;
  675. }
  677. /*
  678.  * In the second extended file system, it is not necessary to
  679.  * write the super block since we use a mapping of the
  680.  * disk super block in a buffer.
  681.  *
  682.  * However, this function is still used to set the fs valid
  683.  * flags to 0.  We need to set this flag to 0 since the fs
  684.  * may have been checked while mounted and e2fsck may have
  685.  * set s_state to EXT2_VALID_FS after some corrections.
  686.  */
  688. void ext2_write_super (struct super_block * sb)
  689. {
  690. struct ext2_super_block * es;
  692. if (!(sb->s_flags & MS_RDONLY)) {
  693. es = sb->u.ext2_sb.s_es;
  695. if (le16_to_cpu(es->s_state) & EXT2_VALID_FS) {
  696. ext2_debug ("setting valid to 0n");
  697. es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) &
  698.   ~EXT2_VALID_FS);
  699. es->s_mtime = cpu_to_le32(CURRENT_TIME);
  700. ext2_sync_super(sb, es);
  701. } else
  702. ext2_commit_super (sb, es);
  703. }
  704. sb->s_dirt = 0;
  705. }
  707. int ext2_remount (struct super_block * sb, int * flags, char * data)
  708. {
  709. struct ext2_super_block * es;
  710. unsigned short resuid = sb->u.ext2_sb.s_resuid;
  711. unsigned short resgid = sb->u.ext2_sb.s_resgid;
  712. unsigned long new_mount_opt;
  713. unsigned long tmp;
  715. /*
  716.  * Allow the "check" option to be passed as a remount option.
  717.  */
  718. new_mount_opt = sb->u.ext2_sb.s_mount_opt;
  719. if (!parse_options (data, &tmp, &resuid, &resgid,
  720.     &new_mount_opt))
  721. return -EINVAL;
  723. sb->u.ext2_sb.s_mount_opt = new_mount_opt;
  724. sb->u.ext2_sb.s_resuid = resuid;
  725. sb->u.ext2_sb.s_resgid = resgid;
  726. es = sb->u.ext2_sb.s_es;
  727. if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
  728. return 0;
  729. if (*flags & MS_RDONLY) {
  730. if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
  731.     !(sb->u.ext2_sb.s_mount_state & EXT2_VALID_FS))
  732. return 0;
  733. /*
  734.  * OK, we are remounting a valid rw partition rdonly, so set
  735.  * the rdonly flag and then mark the partition as valid again.
  736.  */
  737. es->s_state = cpu_to_le16(sb->u.ext2_sb.s_mount_state);
  738. es->s_mtime = cpu_to_le32(CURRENT_TIME);
  739. } else {
  740. int ret;
  741. if ((ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,
  742.        ~EXT2_FEATURE_RO_COMPAT_SUPP))) {
  743. printk("EXT2-fs: %s: couldn't remount RDWR because of "
  744.        "unsupported optional features (%x).n",
  745.        bdevname(sb->s_dev), ret);
  746. return -EROFS;
  747. }
  748. /*
  749.  * Mounting a RDONLY partition read-write, so reread and
  750.  * store the current valid flag.  (It may have been changed
  751.  * by e2fsck since we originally mounted the partition.)
  752.  */
  753. sb->u.ext2_sb.s_mount_state = le16_to_cpu(es->s_state);
  754. if (!ext2_setup_super (sb, es, 0))
  755. sb->s_flags &= ~MS_RDONLY;
  756. }
  757. ext2_sync_super(sb, es);
  758. return 0;
  759. }
  761. int ext2_statfs (struct super_block * sb, struct statfs * buf)
  762. {
  763. unsigned long overhead;
  764. int i;
  766. if (test_opt (sb, MINIX_DF))
  767. overhead = 0;
  768. else {
  769. /*
  770.  * Compute the overhead (FS structures)
  771.  */
  773. /*
  774.  * All of the blocks before first_data_block are
  775.  * overhead
  776.  */
  777. overhead = le32_to_cpu(sb->u.ext2_sb.s_es->s_first_data_block);
  779. /*
  780.  * Add the overhead attributed to the superblock and
  781.  * block group descriptors.  If the sparse superblocks
  782.  * feature is turned on, then not all groups have this.
  783.  */
  784. for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++)
  785. overhead += ext2_bg_has_super(sb, i) +
  786. ext2_bg_num_gdb(sb, i);
  788. /*
  789.  * Every block group has an inode bitmap, a block
  790.  * bitmap, and an inode table.
  791.  */
  792. overhead += (sb->u.ext2_sb.s_groups_count *
  793.      (2 + sb->u.ext2_sb.s_itb_per_group));
  794. }
  796. buf->f_type = EXT2_SUPER_MAGIC;
  797. buf->f_bsize = sb->s_blocksize;
  798. buf->f_blocks = le32_to_cpu(sb->u.ext2_sb.s_es->s_blocks_count) - overhead;
  799. buf->f_bfree = ext2_count_free_blocks (sb);
  800. buf->f_bavail = buf->f_bfree - le32_to_cpu(sb->u.ext2_sb.s_es->s_r_blocks_count);
  801. if (buf->f_bfree < le32_to_cpu(sb->u.ext2_sb.s_es->s_r_blocks_count))
  802. buf->f_bavail = 0;
  803. buf->f_files = le32_to_cpu(sb->u.ext2_sb.s_es->s_inodes_count);
  804. buf->f_ffree = ext2_count_free_inodes (sb);
  805. buf->f_namelen = EXT2_NAME_LEN;
  806. return 0;
  807. }
  809. static DECLARE_FSTYPE_DEV(ext2_fs_type, "ext2", ext2_read_super);
  811. static int __init init_ext2_fs(void)
  812. {
  813.         return register_filesystem(&ext2_fs_type);
  814. }
  816. static void __exit exit_ext2_fs(void)
  817. {
  818. unregister_filesystem(&ext2_fs_type);
  819. }
  821. EXPORT_NO_SYMBOLS;
  823. module_init(init_ext2_fs)
  824. module_exit(exit_ext2_fs)