super.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293
  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. */
  18. #include <linux/module.h>
  19. #include <linux/string.h>
  20. #include <linux/fs.h>
  21. #include <linux/slab.h>
  22. #include <linux/init.h>
  23. #include <linux/blkdev.h>
  24. #include <linux/parser.h>
  25. #include <linux/random.h>
  26. #include <linux/buffer_head.h>
  27. #include <linux/smp_lock.h>
  28. #include <linux/vfs.h>
  29. #include <linux/seq_file.h>
  30. #include <linux/mount.h>
  31. #include <asm/uaccess.h>
  32. #include "ext2.h"
  33. #include "xattr.h"
  34. #include "acl.h"
  35. #include "xip.h"
  36. static void ext2_sync_super(struct super_block *sb,
  37. struct ext2_super_block *es);
  38. static int ext2_remount (struct super_block * sb, int * flags, char * data);
  39. static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf);
  40. void ext2_error (struct super_block * sb, const char * function,
  41. const char * fmt, ...)
  42. {
  43. va_list args;
  44. struct ext2_sb_info *sbi = EXT2_SB(sb);
  45. struct ext2_super_block *es = sbi->s_es;
  46. if (!(sb->s_flags & MS_RDONLY)) {
  47. sbi->s_mount_state |= EXT2_ERROR_FS;
  48. es->s_state =
  49. cpu_to_le16(le16_to_cpu(es->s_state) | EXT2_ERROR_FS);
  50. ext2_sync_super(sb, es);
  51. }
  52. va_start(args, fmt);
  53. printk(KERN_CRIT "EXT2-fs error (device %s): %s: ",sb->s_id, function);
  54. vprintk(fmt, args);
  55. printk("\n");
  56. va_end(args);
  57. if (test_opt(sb, ERRORS_PANIC))
  58. panic("EXT2-fs panic from previous error\n");
  59. if (test_opt(sb, ERRORS_RO)) {
  60. printk("Remounting filesystem read-only\n");
  61. sb->s_flags |= MS_RDONLY;
  62. }
  63. }
  64. void ext2_warning (struct super_block * sb, const char * function,
  65. const char * fmt, ...)
  66. {
  67. va_list args;
  68. va_start(args, fmt);
  69. printk(KERN_WARNING "EXT2-fs warning (device %s): %s: ",
  70. sb->s_id, function);
  71. vprintk(fmt, args);
  72. printk("\n");
  73. va_end(args);
  74. }
  75. void ext2_update_dynamic_rev(struct super_block *sb)
  76. {
  77. struct ext2_super_block *es = EXT2_SB(sb)->s_es;
  78. if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
  79. return;
  80. ext2_warning(sb, __FUNCTION__,
  81. "updating to rev %d because of new feature flag, "
  82. "running e2fsck is recommended",
  83. EXT2_DYNAMIC_REV);
  84. es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);
  85. es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);
  86. es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);
  87. /* leave es->s_feature_*compat flags alone */
  88. /* es->s_uuid will be set by e2fsck if empty */
  89. /*
  90. * The rest of the superblock fields should be zero, and if not it
  91. * means they are likely already in use, so leave them alone. We
  92. * can leave it up to e2fsck to clean up any inconsistencies there.
  93. */
  94. }
  95. static void ext2_put_super (struct super_block * sb)
  96. {
  97. int db_count;
  98. int i;
  99. struct ext2_sb_info *sbi = EXT2_SB(sb);
  100. ext2_xattr_put_super(sb);
  101. if (!(sb->s_flags & MS_RDONLY)) {
  102. struct ext2_super_block *es = sbi->s_es;
  103. es->s_state = cpu_to_le16(sbi->s_mount_state);
  104. ext2_sync_super(sb, es);
  105. }
  106. db_count = sbi->s_gdb_count;
  107. for (i = 0; i < db_count; i++)
  108. if (sbi->s_group_desc[i])
  109. brelse (sbi->s_group_desc[i]);
  110. kfree(sbi->s_group_desc);
  111. kfree(sbi->s_debts);
  112. percpu_counter_destroy(&sbi->s_freeblocks_counter);
  113. percpu_counter_destroy(&sbi->s_freeinodes_counter);
  114. percpu_counter_destroy(&sbi->s_dirs_counter);
  115. brelse (sbi->s_sbh);
  116. sb->s_fs_info = NULL;
  117. kfree(sbi);
  118. return;
  119. }
  120. static struct kmem_cache * ext2_inode_cachep;
  121. static struct inode *ext2_alloc_inode(struct super_block *sb)
  122. {
  123. struct ext2_inode_info *ei;
  124. ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, GFP_KERNEL);
  125. if (!ei)
  126. return NULL;
  127. #ifdef CONFIG_EXT2_FS_POSIX_ACL
  128. ei->i_acl = EXT2_ACL_NOT_CACHED;
  129. ei->i_default_acl = EXT2_ACL_NOT_CACHED;
  130. #endif
  131. ei->vfs_inode.i_version = 1;
  132. return &ei->vfs_inode;
  133. }
  134. static void ext2_destroy_inode(struct inode *inode)
  135. {
  136. kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
  137. }
  138. static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
  139. {
  140. struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
  141. if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
  142. SLAB_CTOR_CONSTRUCTOR) {
  143. rwlock_init(&ei->i_meta_lock);
  144. #ifdef CONFIG_EXT2_FS_XATTR
  145. init_rwsem(&ei->xattr_sem);
  146. #endif
  147. inode_init_once(&ei->vfs_inode);
  148. }
  149. }
  150. static int init_inodecache(void)
  151. {
  152. ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
  153. sizeof(struct ext2_inode_info),
  154. 0, (SLAB_RECLAIM_ACCOUNT|
  155. SLAB_MEM_SPREAD),
  156. init_once, NULL);
  157. if (ext2_inode_cachep == NULL)
  158. return -ENOMEM;
  159. return 0;
  160. }
  161. static void destroy_inodecache(void)
  162. {
  163. kmem_cache_destroy(ext2_inode_cachep);
  164. }
  165. static void ext2_clear_inode(struct inode *inode)
  166. {
  167. #ifdef CONFIG_EXT2_FS_POSIX_ACL
  168. struct ext2_inode_info *ei = EXT2_I(inode);
  169. if (ei->i_acl && ei->i_acl != EXT2_ACL_NOT_CACHED) {
  170. posix_acl_release(ei->i_acl);
  171. ei->i_acl = EXT2_ACL_NOT_CACHED;
  172. }
  173. if (ei->i_default_acl && ei->i_default_acl != EXT2_ACL_NOT_CACHED) {
  174. posix_acl_release(ei->i_default_acl);
  175. ei->i_default_acl = EXT2_ACL_NOT_CACHED;
  176. }
  177. #endif
  178. }
  179. static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
  180. {
  181. struct ext2_sb_info *sbi = EXT2_SB(vfs->mnt_sb);
  182. if (sbi->s_mount_opt & EXT2_MOUNT_GRPID)
  183. seq_puts(seq, ",grpid");
  184. #if defined(CONFIG_QUOTA)
  185. if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)
  186. seq_puts(seq, ",usrquota");
  187. if (sbi->s_mount_opt & EXT2_MOUNT_GRPQUOTA)
  188. seq_puts(seq, ",grpquota");
  189. #endif
  190. #if defined(CONFIG_EXT2_FS_XIP)
  191. if (sbi->s_mount_opt & EXT2_MOUNT_XIP)
  192. seq_puts(seq, ",xip");
  193. #endif
  194. return 0;
  195. }
  196. #ifdef CONFIG_QUOTA
  197. static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data, size_t len, loff_t off);
  198. static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *data, size_t len, loff_t off);
  199. #endif
  200. static const struct super_operations ext2_sops = {
  201. .alloc_inode = ext2_alloc_inode,
  202. .destroy_inode = ext2_destroy_inode,
  203. .read_inode = ext2_read_inode,
  204. .write_inode = ext2_write_inode,
  205. .put_inode = ext2_put_inode,
  206. .delete_inode = ext2_delete_inode,
  207. .put_super = ext2_put_super,
  208. .write_super = ext2_write_super,
  209. .statfs = ext2_statfs,
  210. .remount_fs = ext2_remount,
  211. .clear_inode = ext2_clear_inode,
  212. .show_options = ext2_show_options,
  213. #ifdef CONFIG_QUOTA
  214. .quota_read = ext2_quota_read,
  215. .quota_write = ext2_quota_write,
  216. #endif
  217. };
  218. static struct dentry *ext2_get_dentry(struct super_block *sb, void *vobjp)
  219. {
  220. __u32 *objp = vobjp;
  221. unsigned long ino = objp[0];
  222. __u32 generation = objp[1];
  223. struct inode *inode;
  224. struct dentry *result;
  225. if (ino < EXT2_FIRST_INO(sb) && ino != EXT2_ROOT_INO)
  226. return ERR_PTR(-ESTALE);
  227. if (ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
  228. return ERR_PTR(-ESTALE);
  229. /* iget isn't really right if the inode is currently unallocated!!
  230. * ext2_read_inode currently does appropriate checks, but
  231. * it might be "neater" to call ext2_get_inode first and check
  232. * if the inode is valid.....
  233. */
  234. inode = iget(sb, ino);
  235. if (inode == NULL)
  236. return ERR_PTR(-ENOMEM);
  237. if (is_bad_inode(inode) ||
  238. (generation && inode->i_generation != generation)) {
  239. /* we didn't find the right inode.. */
  240. iput(inode);
  241. return ERR_PTR(-ESTALE);
  242. }
  243. /* now to find a dentry.
  244. * If possible, get a well-connected one
  245. */
  246. result = d_alloc_anon(inode);
  247. if (!result) {
  248. iput(inode);
  249. return ERR_PTR(-ENOMEM);
  250. }
  251. return result;
  252. }
  253. /* Yes, most of these are left as NULL!!
  254. * A NULL value implies the default, which works with ext2-like file
  255. * systems, but can be improved upon.
  256. * Currently only get_parent is required.
  257. */
  258. static struct export_operations ext2_export_ops = {
  259. .get_parent = ext2_get_parent,
  260. .get_dentry = ext2_get_dentry,
  261. };
  262. static unsigned long get_sb_block(void **data)
  263. {
  264. unsigned long sb_block;
  265. char *options = (char *) *data;
  266. if (!options || strncmp(options, "sb=", 3) != 0)
  267. return 1; /* Default location */
  268. options += 3;
  269. sb_block = simple_strtoul(options, &options, 0);
  270. if (*options && *options != ',') {
  271. printk("EXT2-fs: Invalid sb specification: %s\n",
  272. (char *) *data);
  273. return 1;
  274. }
  275. if (*options == ',')
  276. options++;
  277. *data = (void *) options;
  278. return sb_block;
  279. }
  280. enum {
  281. Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
  282. Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic,
  283. Opt_err_ro, Opt_nouid32, Opt_nocheck, Opt_debug,
  284. Opt_oldalloc, Opt_orlov, Opt_nobh, Opt_user_xattr, Opt_nouser_xattr,
  285. Opt_acl, Opt_noacl, Opt_xip, Opt_ignore, Opt_err, Opt_quota,
  286. Opt_usrquota, Opt_grpquota
  287. };
  288. static match_table_t tokens = {
  289. {Opt_bsd_df, "bsddf"},
  290. {Opt_minix_df, "minixdf"},
  291. {Opt_grpid, "grpid"},
  292. {Opt_grpid, "bsdgroups"},
  293. {Opt_nogrpid, "nogrpid"},
  294. {Opt_nogrpid, "sysvgroups"},
  295. {Opt_resgid, "resgid=%u"},
  296. {Opt_resuid, "resuid=%u"},
  297. {Opt_sb, "sb=%u"},
  298. {Opt_err_cont, "errors=continue"},
  299. {Opt_err_panic, "errors=panic"},
  300. {Opt_err_ro, "errors=remount-ro"},
  301. {Opt_nouid32, "nouid32"},
  302. {Opt_nocheck, "check=none"},
  303. {Opt_nocheck, "nocheck"},
  304. {Opt_debug, "debug"},
  305. {Opt_oldalloc, "oldalloc"},
  306. {Opt_orlov, "orlov"},
  307. {Opt_nobh, "nobh"},
  308. {Opt_user_xattr, "user_xattr"},
  309. {Opt_nouser_xattr, "nouser_xattr"},
  310. {Opt_acl, "acl"},
  311. {Opt_noacl, "noacl"},
  312. {Opt_xip, "xip"},
  313. {Opt_grpquota, "grpquota"},
  314. {Opt_ignore, "noquota"},
  315. {Opt_quota, "quota"},
  316. {Opt_usrquota, "usrquota"},
  317. {Opt_err, NULL}
  318. };
  319. static int parse_options (char * options,
  320. struct ext2_sb_info *sbi)
  321. {
  322. char * p;
  323. substring_t args[MAX_OPT_ARGS];
  324. int option;
  325. if (!options)
  326. return 1;
  327. while ((p = strsep (&options, ",")) != NULL) {
  328. int token;
  329. if (!*p)
  330. continue;
  331. token = match_token(p, tokens, args);
  332. switch (token) {
  333. case Opt_bsd_df:
  334. clear_opt (sbi->s_mount_opt, MINIX_DF);
  335. break;
  336. case Opt_minix_df:
  337. set_opt (sbi->s_mount_opt, MINIX_DF);
  338. break;
  339. case Opt_grpid:
  340. set_opt (sbi->s_mount_opt, GRPID);
  341. break;
  342. case Opt_nogrpid:
  343. clear_opt (sbi->s_mount_opt, GRPID);
  344. break;
  345. case Opt_resuid:
  346. if (match_int(&args[0], &option))
  347. return 0;
  348. sbi->s_resuid = option;
  349. break;
  350. case Opt_resgid:
  351. if (match_int(&args[0], &option))
  352. return 0;
  353. sbi->s_resgid = option;
  354. break;
  355. case Opt_sb:
  356. /* handled by get_sb_block() instead of here */
  357. /* *sb_block = match_int(&args[0]); */
  358. break;
  359. case Opt_err_panic:
  360. clear_opt (sbi->s_mount_opt, ERRORS_CONT);
  361. clear_opt (sbi->s_mount_opt, ERRORS_RO);
  362. set_opt (sbi->s_mount_opt, ERRORS_PANIC);
  363. break;
  364. case Opt_err_ro:
  365. clear_opt (sbi->s_mount_opt, ERRORS_CONT);
  366. clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
  367. set_opt (sbi->s_mount_opt, ERRORS_RO);
  368. break;
  369. case Opt_err_cont:
  370. clear_opt (sbi->s_mount_opt, ERRORS_RO);
  371. clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
  372. set_opt (sbi->s_mount_opt, ERRORS_CONT);
  373. break;
  374. case Opt_nouid32:
  375. set_opt (sbi->s_mount_opt, NO_UID32);
  376. break;
  377. case Opt_nocheck:
  378. clear_opt (sbi->s_mount_opt, CHECK);
  379. break;
  380. case Opt_debug:
  381. set_opt (sbi->s_mount_opt, DEBUG);
  382. break;
  383. case Opt_oldalloc:
  384. set_opt (sbi->s_mount_opt, OLDALLOC);
  385. break;
  386. case Opt_orlov:
  387. clear_opt (sbi->s_mount_opt, OLDALLOC);
  388. break;
  389. case Opt_nobh:
  390. set_opt (sbi->s_mount_opt, NOBH);
  391. break;
  392. #ifdef CONFIG_EXT2_FS_XATTR
  393. case Opt_user_xattr:
  394. set_opt (sbi->s_mount_opt, XATTR_USER);
  395. break;
  396. case Opt_nouser_xattr:
  397. clear_opt (sbi->s_mount_opt, XATTR_USER);
  398. break;
  399. #else
  400. case Opt_user_xattr:
  401. case Opt_nouser_xattr:
  402. printk("EXT2 (no)user_xattr options not supported\n");
  403. break;
  404. #endif
  405. #ifdef CONFIG_EXT2_FS_POSIX_ACL
  406. case Opt_acl:
  407. set_opt(sbi->s_mount_opt, POSIX_ACL);
  408. break;
  409. case Opt_noacl:
  410. clear_opt(sbi->s_mount_opt, POSIX_ACL);
  411. break;
  412. #else
  413. case Opt_acl:
  414. case Opt_noacl:
  415. printk("EXT2 (no)acl options not supported\n");
  416. break;
  417. #endif
  418. case Opt_xip:
  419. #ifdef CONFIG_EXT2_FS_XIP
  420. set_opt (sbi->s_mount_opt, XIP);
  421. #else
  422. printk("EXT2 xip option not supported\n");
  423. #endif
  424. break;
  425. #if defined(CONFIG_QUOTA)
  426. case Opt_quota:
  427. case Opt_usrquota:
  428. set_opt(sbi->s_mount_opt, USRQUOTA);
  429. break;
  430. case Opt_grpquota:
  431. set_opt(sbi->s_mount_opt, GRPQUOTA);
  432. break;
  433. #else
  434. case Opt_quota:
  435. case Opt_usrquota:
  436. case Opt_grpquota:
  437. printk(KERN_ERR
  438. "EXT2-fs: quota operations not supported.\n");
  439. break;
  440. #endif
  441. case Opt_ignore:
  442. break;
  443. default:
  444. return 0;
  445. }
  446. }
  447. return 1;
  448. }
  449. static int ext2_setup_super (struct super_block * sb,
  450. struct ext2_super_block * es,
  451. int read_only)
  452. {
  453. int res = 0;
  454. struct ext2_sb_info *sbi = EXT2_SB(sb);
  455. if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {
  456. printk ("EXT2-fs warning: revision level too high, "
  457. "forcing read-only mode\n");
  458. res = MS_RDONLY;
  459. }
  460. if (read_only)
  461. return res;
  462. if (!(sbi->s_mount_state & EXT2_VALID_FS))
  463. printk ("EXT2-fs warning: mounting unchecked fs, "
  464. "running e2fsck is recommended\n");
  465. else if ((sbi->s_mount_state & EXT2_ERROR_FS))
  466. printk ("EXT2-fs warning: mounting fs with errors, "
  467. "running e2fsck is recommended\n");
  468. else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
  469. le16_to_cpu(es->s_mnt_count) >=
  470. (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
  471. printk ("EXT2-fs warning: maximal mount count reached, "
  472. "running e2fsck is recommended\n");
  473. else if (le32_to_cpu(es->s_checkinterval) &&
  474. (le32_to_cpu(es->s_lastcheck) + le32_to_cpu(es->s_checkinterval) <= get_seconds()))
  475. printk ("EXT2-fs warning: checktime reached, "
  476. "running e2fsck is recommended\n");
  477. if (!le16_to_cpu(es->s_max_mnt_count))
  478. es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
  479. es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
  480. ext2_write_super(sb);
  481. if (test_opt (sb, DEBUG))
  482. printk ("[EXT II FS %s, %s, bs=%lu, fs=%lu, gc=%lu, "
  483. "bpg=%lu, ipg=%lu, mo=%04lx]\n",
  484. EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,
  485. sbi->s_frag_size,
  486. sbi->s_groups_count,
  487. EXT2_BLOCKS_PER_GROUP(sb),
  488. EXT2_INODES_PER_GROUP(sb),
  489. sbi->s_mount_opt);
  490. return res;
  491. }
  492. static int ext2_check_descriptors (struct super_block * sb)
  493. {
  494. int i;
  495. int desc_block = 0;
  496. struct ext2_sb_info *sbi = EXT2_SB(sb);
  497. unsigned long first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
  498. unsigned long last_block;
  499. struct ext2_group_desc * gdp = NULL;
  500. ext2_debug ("Checking group descriptors");
  501. for (i = 0; i < sbi->s_groups_count; i++)
  502. {
  503. if (i == sbi->s_groups_count - 1)
  504. last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
  505. else
  506. last_block = first_block +
  507. (EXT2_BLOCKS_PER_GROUP(sb) - 1);
  508. if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)
  509. gdp = (struct ext2_group_desc *) sbi->s_group_desc[desc_block++]->b_data;
  510. if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
  511. le32_to_cpu(gdp->bg_block_bitmap) > last_block)
  512. {
  513. ext2_error (sb, "ext2_check_descriptors",
  514. "Block bitmap for group %d"
  515. " not in group (block %lu)!",
  516. i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));
  517. return 0;
  518. }
  519. if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
  520. le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
  521. {
  522. ext2_error (sb, "ext2_check_descriptors",
  523. "Inode bitmap for group %d"
  524. " not in group (block %lu)!",
  525. i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));
  526. return 0;
  527. }
  528. if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
  529. le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >
  530. last_block)
  531. {
  532. ext2_error (sb, "ext2_check_descriptors",
  533. "Inode table for group %d"
  534. " not in group (block %lu)!",
  535. i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));
  536. return 0;
  537. }
  538. first_block += EXT2_BLOCKS_PER_GROUP(sb);
  539. gdp++;
  540. }
  541. return 1;
  542. }
  543. /*
  544. * Maximal file size. There is a direct, and {,double-,triple-}indirect
  545. * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
  546. * We need to be 1 filesystem block less than the 2^32 sector limit.
  547. */
  548. static loff_t ext2_max_size(int bits)
  549. {
  550. loff_t res = EXT2_NDIR_BLOCKS;
  551. /* This constant is calculated to be the largest file size for a
  552. * dense, 4k-blocksize file such that the total number of
  553. * sectors in the file, including data and all indirect blocks,
  554. * does not exceed 2^32. */
  555. const loff_t upper_limit = 0x1ff7fffd000LL;
  556. res += 1LL << (bits-2);
  557. res += 1LL << (2*(bits-2));
  558. res += 1LL << (3*(bits-2));
  559. res <<= bits;
  560. if (res > upper_limit)
  561. res = upper_limit;
  562. return res;
  563. }
  564. static unsigned long descriptor_loc(struct super_block *sb,
  565. unsigned long logic_sb_block,
  566. int nr)
  567. {
  568. struct ext2_sb_info *sbi = EXT2_SB(sb);
  569. unsigned long bg, first_data_block, first_meta_bg;
  570. int has_super = 0;
  571. first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
  572. first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
  573. if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_META_BG) ||
  574. nr < first_meta_bg)
  575. return (logic_sb_block + nr + 1);
  576. bg = sbi->s_desc_per_block * nr;
  577. if (ext2_bg_has_super(sb, bg))
  578. has_super = 1;
  579. return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
  580. }
  581. static int ext2_fill_super(struct super_block *sb, void *data, int silent)
  582. {
  583. struct buffer_head * bh;
  584. struct ext2_sb_info * sbi;
  585. struct ext2_super_block * es;
  586. struct inode *root;
  587. unsigned long block;
  588. unsigned long sb_block = get_sb_block(&data);
  589. unsigned long logic_sb_block;
  590. unsigned long offset = 0;
  591. unsigned long def_mount_opts;
  592. int blocksize = BLOCK_SIZE;
  593. int db_count;
  594. int i, j;
  595. __le32 features;
  596. sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
  597. if (!sbi)
  598. return -ENOMEM;
  599. sb->s_fs_info = sbi;
  600. /*
  601. * See what the current blocksize for the device is, and
  602. * use that as the blocksize. Otherwise (or if the blocksize
  603. * is smaller than the default) use the default.
  604. * This is important for devices that have a hardware
  605. * sectorsize that is larger than the default.
  606. */
  607. blocksize = sb_min_blocksize(sb, BLOCK_SIZE);
  608. if (!blocksize) {
  609. printk ("EXT2-fs: unable to set blocksize\n");
  610. goto failed_sbi;
  611. }
  612. /*
  613. * If the superblock doesn't start on a hardware sector boundary,
  614. * calculate the offset.
  615. */
  616. if (blocksize != BLOCK_SIZE) {
  617. logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
  618. offset = (sb_block*BLOCK_SIZE) % blocksize;
  619. } else {
  620. logic_sb_block = sb_block;
  621. }
  622. if (!(bh = sb_bread(sb, logic_sb_block))) {
  623. printk ("EXT2-fs: unable to read superblock\n");
  624. goto failed_sbi;
  625. }
  626. /*
  627. * Note: s_es must be initialized as soon as possible because
  628. * some ext2 macro-instructions depend on its value
  629. */
  630. es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
  631. sbi->s_es = es;
  632. sb->s_magic = le16_to_cpu(es->s_magic);
  633. if (sb->s_magic != EXT2_SUPER_MAGIC)
  634. goto cantfind_ext2;
  635. /* Set defaults before we parse the mount options */
  636. def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
  637. if (def_mount_opts & EXT2_DEFM_DEBUG)
  638. set_opt(sbi->s_mount_opt, DEBUG);
  639. if (def_mount_opts & EXT2_DEFM_BSDGROUPS)
  640. set_opt(sbi->s_mount_opt, GRPID);
  641. if (def_mount_opts & EXT2_DEFM_UID16)
  642. set_opt(sbi->s_mount_opt, NO_UID32);
  643. #ifdef CONFIG_EXT2_FS_XATTR
  644. if (def_mount_opts & EXT2_DEFM_XATTR_USER)
  645. set_opt(sbi->s_mount_opt, XATTR_USER);
  646. #endif
  647. #ifdef CONFIG_EXT2_FS_POSIX_ACL
  648. if (def_mount_opts & EXT2_DEFM_ACL)
  649. set_opt(sbi->s_mount_opt, POSIX_ACL);
  650. #endif
  651. if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)
  652. set_opt(sbi->s_mount_opt, ERRORS_PANIC);
  653. else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_RO)
  654. set_opt(sbi->s_mount_opt, ERRORS_RO);
  655. else
  656. set_opt(sbi->s_mount_opt, ERRORS_CONT);
  657. sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
  658. sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
  659. if (!parse_options ((char *) data, sbi))
  660. goto failed_mount;
  661. sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
  662. ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
  663. MS_POSIXACL : 0);
  664. ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset
  665. EXT2_MOUNT_XIP if not */
  666. if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
  667. (EXT2_HAS_COMPAT_FEATURE(sb, ~0U) ||
  668. EXT2_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
  669. EXT2_HAS_INCOMPAT_FEATURE(sb, ~0U)))
  670. printk("EXT2-fs warning: feature flags set on rev 0 fs, "
  671. "running e2fsck is recommended\n");
  672. /*
  673. * Check feature flags regardless of the revision level, since we
  674. * previously didn't change the revision level when setting the flags,
  675. * so there is a chance incompat flags are set on a rev 0 filesystem.
  676. */
  677. features = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP);
  678. if (features) {
  679. printk("EXT2-fs: %s: couldn't mount because of "
  680. "unsupported optional features (%x).\n",
  681. sb->s_id, le32_to_cpu(features));
  682. goto failed_mount;
  683. }
  684. if (!(sb->s_flags & MS_RDONLY) &&
  685. (features = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){
  686. printk("EXT2-fs: %s: couldn't mount RDWR because of "
  687. "unsupported optional features (%x).\n",
  688. sb->s_id, le32_to_cpu(features));
  689. goto failed_mount;
  690. }
  691. blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
  692. if ((ext2_use_xip(sb)) && ((blocksize != PAGE_SIZE) ||
  693. (sb->s_blocksize != blocksize))) {
  694. if (!silent)
  695. printk("XIP: Unsupported blocksize\n");
  696. goto failed_mount;
  697. }
  698. /* If the blocksize doesn't match, re-read the thing.. */
  699. if (sb->s_blocksize != blocksize) {
  700. brelse(bh);
  701. if (!sb_set_blocksize(sb, blocksize)) {
  702. printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");
  703. goto failed_sbi;
  704. }
  705. logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
  706. offset = (sb_block*BLOCK_SIZE) % blocksize;
  707. bh = sb_bread(sb, logic_sb_block);
  708. if(!bh) {
  709. printk("EXT2-fs: Couldn't read superblock on "
  710. "2nd try.\n");
  711. goto failed_sbi;
  712. }
  713. es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
  714. sbi->s_es = es;
  715. if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
  716. printk ("EXT2-fs: Magic mismatch, very weird !\n");
  717. goto failed_mount;
  718. }
  719. }
  720. sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
  721. if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
  722. sbi->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
  723. sbi->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
  724. } else {
  725. sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
  726. sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
  727. if ((sbi->s_inode_size < EXT2_GOOD_OLD_INODE_SIZE) ||
  728. (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
  729. (sbi->s_inode_size > blocksize)) {
  730. printk ("EXT2-fs: unsupported inode size: %d\n",
  731. sbi->s_inode_size);
  732. goto failed_mount;
  733. }
  734. }
  735. sbi->s_frag_size = EXT2_MIN_FRAG_SIZE <<
  736. le32_to_cpu(es->s_log_frag_size);
  737. if (sbi->s_frag_size == 0)
  738. goto cantfind_ext2;
  739. sbi->s_frags_per_block = sb->s_blocksize / sbi->s_frag_size;
  740. sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
  741. sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
  742. sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
  743. if (EXT2_INODE_SIZE(sb) == 0)
  744. goto cantfind_ext2;
  745. sbi->s_inodes_per_block = sb->s_blocksize / EXT2_INODE_SIZE(sb);
  746. if (sbi->s_inodes_per_block == 0 || sbi->s_inodes_per_group == 0)
  747. goto cantfind_ext2;
  748. sbi->s_itb_per_group = sbi->s_inodes_per_group /
  749. sbi->s_inodes_per_block;
  750. sbi->s_desc_per_block = sb->s_blocksize /
  751. sizeof (struct ext2_group_desc);
  752. sbi->s_sbh = bh;
  753. sbi->s_mount_state = le16_to_cpu(es->s_state);
  754. sbi->s_addr_per_block_bits =
  755. ilog2 (EXT2_ADDR_PER_BLOCK(sb));
  756. sbi->s_desc_per_block_bits =
  757. ilog2 (EXT2_DESC_PER_BLOCK(sb));
  758. if (sb->s_magic != EXT2_SUPER_MAGIC)
  759. goto cantfind_ext2;
  760. if (sb->s_blocksize != bh->b_size) {
  761. if (!silent)
  762. printk ("VFS: Unsupported blocksize on dev "
  763. "%s.\n", sb->s_id);
  764. goto failed_mount;
  765. }
  766. if (sb->s_blocksize != sbi->s_frag_size) {
  767. printk ("EXT2-fs: fragsize %lu != blocksize %lu (not supported yet)\n",
  768. sbi->s_frag_size, sb->s_blocksize);
  769. goto failed_mount;
  770. }
  771. if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
  772. printk ("EXT2-fs: #blocks per group too big: %lu\n",
  773. sbi->s_blocks_per_group);
  774. goto failed_mount;
  775. }
  776. if (sbi->s_frags_per_group > sb->s_blocksize * 8) {
  777. printk ("EXT2-fs: #fragments per group too big: %lu\n",
  778. sbi->s_frags_per_group);
  779. goto failed_mount;
  780. }
  781. if (sbi->s_inodes_per_group > sb->s_blocksize * 8) {
  782. printk ("EXT2-fs: #inodes per group too big: %lu\n",
  783. sbi->s_inodes_per_group);
  784. goto failed_mount;
  785. }
  786. if (EXT2_BLOCKS_PER_GROUP(sb) == 0)
  787. goto cantfind_ext2;
  788. sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
  789. le32_to_cpu(es->s_first_data_block) - 1)
  790. / EXT2_BLOCKS_PER_GROUP(sb)) + 1;
  791. db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
  792. EXT2_DESC_PER_BLOCK(sb);
  793. sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
  794. if (sbi->s_group_desc == NULL) {
  795. printk ("EXT2-fs: not enough memory\n");
  796. goto failed_mount;
  797. }
  798. bgl_lock_init(&sbi->s_blockgroup_lock);
  799. sbi->s_debts = kmalloc(sbi->s_groups_count * sizeof(*sbi->s_debts),
  800. GFP_KERNEL);
  801. if (!sbi->s_debts) {
  802. printk ("EXT2-fs: not enough memory\n");
  803. goto failed_mount_group_desc;
  804. }
  805. memset(sbi->s_debts, 0, sbi->s_groups_count * sizeof(*sbi->s_debts));
  806. for (i = 0; i < db_count; i++) {
  807. block = descriptor_loc(sb, logic_sb_block, i);
  808. sbi->s_group_desc[i] = sb_bread(sb, block);
  809. if (!sbi->s_group_desc[i]) {
  810. for (j = 0; j < i; j++)
  811. brelse (sbi->s_group_desc[j]);
  812. printk ("EXT2-fs: unable to read group descriptors\n");
  813. goto failed_mount_group_desc;
  814. }
  815. }
  816. if (!ext2_check_descriptors (sb)) {
  817. printk ("EXT2-fs: group descriptors corrupted!\n");
  818. goto failed_mount2;
  819. }
  820. sbi->s_gdb_count = db_count;
  821. get_random_bytes(&sbi->s_next_generation, sizeof(u32));
  822. spin_lock_init(&sbi->s_next_gen_lock);
  823. percpu_counter_init(&sbi->s_freeblocks_counter,
  824. ext2_count_free_blocks(sb));
  825. percpu_counter_init(&sbi->s_freeinodes_counter,
  826. ext2_count_free_inodes(sb));
  827. percpu_counter_init(&sbi->s_dirs_counter,
  828. ext2_count_dirs(sb));
  829. /*
  830. * set up enough so that it can read an inode
  831. */
  832. sb->s_op = &ext2_sops;
  833. sb->s_export_op = &ext2_export_ops;
  834. sb->s_xattr = ext2_xattr_handlers;
  835. root = iget(sb, EXT2_ROOT_INO);
  836. sb->s_root = d_alloc_root(root);
  837. if (!sb->s_root) {
  838. iput(root);
  839. printk(KERN_ERR "EXT2-fs: get root inode failed\n");
  840. goto failed_mount3;
  841. }
  842. if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
  843. dput(sb->s_root);
  844. sb->s_root = NULL;
  845. printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
  846. goto failed_mount3;
  847. }
  848. if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
  849. ext2_warning(sb, __FUNCTION__,
  850. "mounting ext3 filesystem as ext2");
  851. ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
  852. return 0;
  853. cantfind_ext2:
  854. if (!silent)
  855. printk("VFS: Can't find an ext2 filesystem on dev %s.\n",
  856. sb->s_id);
  857. goto failed_mount;
  858. failed_mount3:
  859. percpu_counter_destroy(&sbi->s_freeblocks_counter);
  860. percpu_counter_destroy(&sbi->s_freeinodes_counter);
  861. percpu_counter_destroy(&sbi->s_dirs_counter);
  862. failed_mount2:
  863. for (i = 0; i < db_count; i++)
  864. brelse(sbi->s_group_desc[i]);
  865. failed_mount_group_desc:
  866. kfree(sbi->s_group_desc);
  867. kfree(sbi->s_debts);
  868. failed_mount:
  869. brelse(bh);
  870. failed_sbi:
  871. sb->s_fs_info = NULL;
  872. kfree(sbi);
  873. return -EINVAL;
  874. }
  875. static void ext2_commit_super (struct super_block * sb,
  876. struct ext2_super_block * es)
  877. {
  878. es->s_wtime = cpu_to_le32(get_seconds());
  879. mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
  880. sb->s_dirt = 0;
  881. }
  882. static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
  883. {
  884. es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
  885. es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
  886. es->s_wtime = cpu_to_le32(get_seconds());
  887. mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
  888. sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
  889. sb->s_dirt = 0;
  890. }
  891. /*
  892. * In the second extended file system, it is not necessary to
  893. * write the super block since we use a mapping of the
  894. * disk super block in a buffer.
  895. *
  896. * However, this function is still used to set the fs valid
  897. * flags to 0. We need to set this flag to 0 since the fs
  898. * may have been checked while mounted and e2fsck may have
  899. * set s_state to EXT2_VALID_FS after some corrections.
  900. */
  901. void ext2_write_super (struct super_block * sb)
  902. {
  903. struct ext2_super_block * es;
  904. lock_kernel();
  905. if (!(sb->s_flags & MS_RDONLY)) {
  906. es = EXT2_SB(sb)->s_es;
  907. if (le16_to_cpu(es->s_state) & EXT2_VALID_FS) {
  908. ext2_debug ("setting valid to 0\n");
  909. es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) &
  910. ~EXT2_VALID_FS);
  911. es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
  912. es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
  913. es->s_mtime = cpu_to_le32(get_seconds());
  914. ext2_sync_super(sb, es);
  915. } else
  916. ext2_commit_super (sb, es);
  917. }
  918. sb->s_dirt = 0;
  919. unlock_kernel();
  920. }
  921. static int ext2_remount (struct super_block * sb, int * flags, char * data)
  922. {
  923. struct ext2_sb_info * sbi = EXT2_SB(sb);
  924. struct ext2_super_block * es;
  925. unsigned long old_mount_opt = sbi->s_mount_opt;
  926. struct ext2_mount_options old_opts;
  927. unsigned long old_sb_flags;
  928. int err;
  929. /* Store the old options */
  930. old_sb_flags = sb->s_flags;
  931. old_opts.s_mount_opt = sbi->s_mount_opt;
  932. old_opts.s_resuid = sbi->s_resuid;
  933. old_opts.s_resgid = sbi->s_resgid;
  934. /*
  935. * Allow the "check" option to be passed as a remount option.
  936. */
  937. if (!parse_options (data, sbi)) {
  938. err = -EINVAL;
  939. goto restore_opts;
  940. }
  941. sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
  942. ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
  943. es = sbi->s_es;
  944. if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=
  945. (old_mount_opt & EXT2_MOUNT_XIP)) &&
  946. invalidate_inodes(sb))
  947. ext2_warning(sb, __FUNCTION__, "busy inodes while remounting "\
  948. "xip remain in cache (no functional problem)");
  949. if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
  950. return 0;
  951. if (*flags & MS_RDONLY) {
  952. if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
  953. !(sbi->s_mount_state & EXT2_VALID_FS))
  954. return 0;
  955. /*
  956. * OK, we are remounting a valid rw partition rdonly, so set
  957. * the rdonly flag and then mark the partition as valid again.
  958. */
  959. es->s_state = cpu_to_le16(sbi->s_mount_state);
  960. es->s_mtime = cpu_to_le32(get_seconds());
  961. } else {
  962. __le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,
  963. ~EXT2_FEATURE_RO_COMPAT_SUPP);
  964. if (ret) {
  965. printk("EXT2-fs: %s: couldn't remount RDWR because of "
  966. "unsupported optional features (%x).\n",
  967. sb->s_id, le32_to_cpu(ret));
  968. err = -EROFS;
  969. goto restore_opts;
  970. }
  971. /*
  972. * Mounting a RDONLY partition read-write, so reread and
  973. * store the current valid flag. (It may have been changed
  974. * by e2fsck since we originally mounted the partition.)
  975. */
  976. sbi->s_mount_state = le16_to_cpu(es->s_state);
  977. if (!ext2_setup_super (sb, es, 0))
  978. sb->s_flags &= ~MS_RDONLY;
  979. }
  980. ext2_sync_super(sb, es);
  981. return 0;
  982. restore_opts:
  983. sbi->s_mount_opt = old_opts.s_mount_opt;
  984. sbi->s_resuid = old_opts.s_resuid;
  985. sbi->s_resgid = old_opts.s_resgid;
  986. sb->s_flags = old_sb_flags;
  987. return err;
  988. }
  989. static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
  990. {
  991. struct super_block *sb = dentry->d_sb;
  992. struct ext2_sb_info *sbi = EXT2_SB(sb);
  993. struct ext2_super_block *es = sbi->s_es;
  994. unsigned long overhead;
  995. int i;
  996. u64 fsid;
  997. if (test_opt (sb, MINIX_DF))
  998. overhead = 0;
  999. else {
  1000. /*
  1001. * Compute the overhead (FS structures)
  1002. */
  1003. /*
  1004. * All of the blocks before first_data_block are
  1005. * overhead
  1006. */
  1007. overhead = le32_to_cpu(es->s_first_data_block);
  1008. /*
  1009. * Add the overhead attributed to the superblock and
  1010. * block group descriptors. If the sparse superblocks
  1011. * feature is turned on, then not all groups have this.
  1012. */
  1013. for (i = 0; i < sbi->s_groups_count; i++)
  1014. overhead += ext2_bg_has_super(sb, i) +
  1015. ext2_bg_num_gdb(sb, i);
  1016. /*
  1017. * Every block group has an inode bitmap, a block
  1018. * bitmap, and an inode table.
  1019. */
  1020. overhead += (sbi->s_groups_count *
  1021. (2 + sbi->s_itb_per_group));
  1022. }
  1023. buf->f_type = EXT2_SUPER_MAGIC;
  1024. buf->f_bsize = sb->s_blocksize;
  1025. buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
  1026. buf->f_bfree = ext2_count_free_blocks(sb);
  1027. buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
  1028. if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
  1029. buf->f_bavail = 0;
  1030. buf->f_files = le32_to_cpu(es->s_inodes_count);
  1031. buf->f_ffree = ext2_count_free_inodes(sb);
  1032. buf->f_namelen = EXT2_NAME_LEN;
  1033. fsid = le64_to_cpup((void *)es->s_uuid) ^
  1034. le64_to_cpup((void *)es->s_uuid + sizeof(u64));
  1035. buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
  1036. buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
  1037. return 0;
  1038. }
  1039. static int ext2_get_sb(struct file_system_type *fs_type,
  1040. int flags, const char *dev_name, void *data, struct vfsmount *mnt)
  1041. {
  1042. return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super, mnt);
  1043. }
  1044. #ifdef CONFIG_QUOTA
  1045. /* Read data from quotafile - avoid pagecache and such because we cannot afford
  1046. * acquiring the locks... As quota files are never truncated and quota code
  1047. * itself serializes the operations (and noone else should touch the files)
  1048. * we don't have to be afraid of races */
  1049. static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data,
  1050. size_t len, loff_t off)
  1051. {
  1052. struct inode *inode = sb_dqopt(sb)->files[type];
  1053. sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
  1054. int err = 0;
  1055. int offset = off & (sb->s_blocksize - 1);
  1056. int tocopy;
  1057. size_t toread;
  1058. struct buffer_head tmp_bh;
  1059. struct buffer_head *bh;
  1060. loff_t i_size = i_size_read(inode);
  1061. if (off > i_size)
  1062. return 0;
  1063. if (off+len > i_size)
  1064. len = i_size-off;
  1065. toread = len;
  1066. while (toread > 0) {
  1067. tocopy = sb->s_blocksize - offset < toread ?
  1068. sb->s_blocksize - offset : toread;
  1069. tmp_bh.b_state = 0;
  1070. err = ext2_get_block(inode, blk, &tmp_bh, 0);
  1071. if (err)
  1072. return err;
  1073. if (!buffer_mapped(&tmp_bh)) /* A hole? */
  1074. memset(data, 0, tocopy);
  1075. else {
  1076. bh = sb_bread(sb, tmp_bh.b_blocknr);
  1077. if (!bh)
  1078. return -EIO;
  1079. memcpy(data, bh->b_data+offset, tocopy);
  1080. brelse(bh);
  1081. }
  1082. offset = 0;
  1083. toread -= tocopy;
  1084. data += tocopy;
  1085. blk++;
  1086. }
  1087. return len;
  1088. }
  1089. /* Write to quotafile */
  1090. static ssize_t ext2_quota_write(struct super_block *sb, int type,
  1091. const char *data, size_t len, loff_t off)
  1092. {
  1093. struct inode *inode = sb_dqopt(sb)->files[type];
  1094. sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
  1095. int err = 0;
  1096. int offset = off & (sb->s_blocksize - 1);
  1097. int tocopy;
  1098. size_t towrite = len;
  1099. struct buffer_head tmp_bh;
  1100. struct buffer_head *bh;
  1101. mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
  1102. while (towrite > 0) {
  1103. tocopy = sb->s_blocksize - offset < towrite ?
  1104. sb->s_blocksize - offset : towrite;
  1105. tmp_bh.b_state = 0;
  1106. err = ext2_get_block(inode, blk, &tmp_bh, 1);
  1107. if (err)
  1108. goto out;
  1109. if (offset || tocopy != EXT2_BLOCK_SIZE(sb))
  1110. bh = sb_bread(sb, tmp_bh.b_blocknr);
  1111. else
  1112. bh = sb_getblk(sb, tmp_bh.b_blocknr);
  1113. if (!bh) {
  1114. err = -EIO;
  1115. goto out;
  1116. }
  1117. lock_buffer(bh);
  1118. memcpy(bh->b_data+offset, data, tocopy);
  1119. flush_dcache_page(bh->b_page);
  1120. set_buffer_uptodate(bh);
  1121. mark_buffer_dirty(bh);
  1122. unlock_buffer(bh);
  1123. brelse(bh);
  1124. offset = 0;
  1125. towrite -= tocopy;
  1126. data += tocopy;
  1127. blk++;
  1128. }
  1129. out:
  1130. if (len == towrite)
  1131. return err;
  1132. if (inode->i_size < off+len-towrite)
  1133. i_size_write(inode, off+len-towrite);
  1134. inode->i_version++;
  1135. inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  1136. mark_inode_dirty(inode);
  1137. mutex_unlock(&inode->i_mutex);
  1138. return len - towrite;
  1139. }
  1140. #endif
  1141. static struct file_system_type ext2_fs_type = {
  1142. .owner = THIS_MODULE,
  1143. .name = "ext2",
  1144. .get_sb = ext2_get_sb,
  1145. .kill_sb = kill_block_super,
  1146. .fs_flags = FS_REQUIRES_DEV,
  1147. };
  1148. static int __init init_ext2_fs(void)
  1149. {
  1150. int err = init_ext2_xattr();
  1151. if (err)
  1152. return err;
  1153. err = init_inodecache();
  1154. if (err)
  1155. goto out1;
  1156. err = register_filesystem(&ext2_fs_type);
  1157. if (err)
  1158. goto out;
  1159. return 0;
  1160. out:
  1161. destroy_inodecache();
  1162. out1:
  1163. exit_ext2_xattr();
  1164. return err;
  1165. }
  1166. static void __exit exit_ext2_fs(void)
  1167. {
  1168. unregister_filesystem(&ext2_fs_type);
  1169. destroy_inodecache();
  1170. exit_ext2_xattr();
  1171. }
  1172. module_init(init_ext2_fs)
  1173. module_exit(exit_ext2_fs)