super.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504
  1. /*
  2. * linux/fs/hfs/super.c
  3. *
  4. * Copyright (C) 1995-1997 Paul H. Hargrove
  5. * (C) 2003 Ardis Technologies <roman@ardistech.com>
  6. * This file may be distributed under the terms of the GNU General Public License.
  7. *
  8. * This file contains hfs_read_super(), some of the super_ops and
  9. * init_hfs_fs() and exit_hfs_fs(). The remaining super_ops are in
  10. * inode.c since they deal with inodes.
  11. *
  12. * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
  13. */
  14. #include <linux/module.h>
  15. #include <linux/blkdev.h>
  16. #include <linux/backing-dev.h>
  17. #include <linux/mount.h>
  18. #include <linux/init.h>
  19. #include <linux/nls.h>
  20. #include <linux/parser.h>
  21. #include <linux/seq_file.h>
  22. #include <linux/slab.h>
  23. #include <linux/vfs.h>
  24. #include "hfs_fs.h"
  25. #include "btree.h"
  26. static struct kmem_cache *hfs_inode_cachep;
  27. MODULE_LICENSE("GPL");
  28. MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
  29. static int hfs_sync_fs(struct super_block *sb, int wait)
  30. {
  31. hfs_mdb_commit(sb);
  32. return 0;
  33. }
  34. /*
  35. * hfs_put_super()
  36. *
  37. * This is the put_super() entry in the super_operations structure for
  38. * HFS filesystems. The purpose is to release the resources
  39. * associated with the superblock sb.
  40. */
  41. static void hfs_put_super(struct super_block *sb)
  42. {
  43. cancel_delayed_work_sync(&HFS_SB(sb)->mdb_work);
  44. hfs_mdb_close(sb);
  45. /* release the MDB's resources */
  46. hfs_mdb_put(sb);
  47. }
  48. static void flush_mdb(struct work_struct *work)
  49. {
  50. struct hfs_sb_info *sbi;
  51. struct super_block *sb;
  52. sbi = container_of(work, struct hfs_sb_info, mdb_work.work);
  53. sb = sbi->sb;
  54. spin_lock(&sbi->work_lock);
  55. sbi->work_queued = 0;
  56. spin_unlock(&sbi->work_lock);
  57. hfs_mdb_commit(sb);
  58. }
  59. void hfs_mark_mdb_dirty(struct super_block *sb)
  60. {
  61. struct hfs_sb_info *sbi = HFS_SB(sb);
  62. unsigned long delay;
  63. if (sb_rdonly(sb))
  64. return;
  65. spin_lock(&sbi->work_lock);
  66. if (!sbi->work_queued) {
  67. delay = msecs_to_jiffies(dirty_writeback_interval * 10);
  68. queue_delayed_work(system_long_wq, &sbi->mdb_work, delay);
  69. sbi->work_queued = 1;
  70. }
  71. spin_unlock(&sbi->work_lock);
  72. }
  73. /*
  74. * hfs_statfs()
  75. *
  76. * This is the statfs() entry in the super_operations structure for
  77. * HFS filesystems. The purpose is to return various data about the
  78. * filesystem.
  79. *
  80. * changed f_files/f_ffree to reflect the fs_ablock/free_ablocks.
  81. */
  82. static int hfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  83. {
  84. struct super_block *sb = dentry->d_sb;
  85. u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
  86. buf->f_type = HFS_SUPER_MAGIC;
  87. buf->f_bsize = sb->s_blocksize;
  88. buf->f_blocks = (u32)HFS_SB(sb)->fs_ablocks * HFS_SB(sb)->fs_div;
  89. buf->f_bfree = (u32)HFS_SB(sb)->free_ablocks * HFS_SB(sb)->fs_div;
  90. buf->f_bavail = buf->f_bfree;
  91. buf->f_files = HFS_SB(sb)->fs_ablocks;
  92. buf->f_ffree = HFS_SB(sb)->free_ablocks;
  93. buf->f_fsid = u64_to_fsid(id);
  94. buf->f_namelen = HFS_NAMELEN;
  95. return 0;
  96. }
  97. static int hfs_remount(struct super_block *sb, int *flags, char *data)
  98. {
  99. sync_filesystem(sb);
  100. *flags |= SB_NODIRATIME;
  101. if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
  102. return 0;
  103. if (!(*flags & SB_RDONLY)) {
  104. if (!(HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
  105. pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. leaving read-only.\n");
  106. sb->s_flags |= SB_RDONLY;
  107. *flags |= SB_RDONLY;
  108. } else if (HFS_SB(sb)->mdb->drAtrb & cpu_to_be16(HFS_SB_ATTRIB_SLOCK)) {
  109. pr_warn("filesystem is marked locked, leaving read-only.\n");
  110. sb->s_flags |= SB_RDONLY;
  111. *flags |= SB_RDONLY;
  112. }
  113. }
  114. return 0;
  115. }
  116. static int hfs_show_options(struct seq_file *seq, struct dentry *root)
  117. {
  118. struct hfs_sb_info *sbi = HFS_SB(root->d_sb);
  119. if (sbi->s_creator != cpu_to_be32(0x3f3f3f3f))
  120. seq_show_option_n(seq, "creator", (char *)&sbi->s_creator, 4);
  121. if (sbi->s_type != cpu_to_be32(0x3f3f3f3f))
  122. seq_show_option_n(seq, "type", (char *)&sbi->s_type, 4);
  123. seq_printf(seq, ",uid=%u,gid=%u",
  124. from_kuid_munged(&init_user_ns, sbi->s_uid),
  125. from_kgid_munged(&init_user_ns, sbi->s_gid));
  126. if (sbi->s_file_umask != 0133)
  127. seq_printf(seq, ",file_umask=%o", sbi->s_file_umask);
  128. if (sbi->s_dir_umask != 0022)
  129. seq_printf(seq, ",dir_umask=%o", sbi->s_dir_umask);
  130. if (sbi->part >= 0)
  131. seq_printf(seq, ",part=%u", sbi->part);
  132. if (sbi->session >= 0)
  133. seq_printf(seq, ",session=%u", sbi->session);
  134. if (sbi->nls_disk)
  135. seq_printf(seq, ",codepage=%s", sbi->nls_disk->charset);
  136. if (sbi->nls_io)
  137. seq_printf(seq, ",iocharset=%s", sbi->nls_io->charset);
  138. if (sbi->s_quiet)
  139. seq_printf(seq, ",quiet");
  140. return 0;
  141. }
  142. static struct inode *hfs_alloc_inode(struct super_block *sb)
  143. {
  144. struct hfs_inode_info *i;
  145. i = kmem_cache_alloc(hfs_inode_cachep, GFP_KERNEL);
  146. return i ? &i->vfs_inode : NULL;
  147. }
  148. static void hfs_free_inode(struct inode *inode)
  149. {
  150. kmem_cache_free(hfs_inode_cachep, HFS_I(inode));
  151. }
  152. static const struct super_operations hfs_super_operations = {
  153. .alloc_inode = hfs_alloc_inode,
  154. .free_inode = hfs_free_inode,
  155. .write_inode = hfs_write_inode,
  156. .evict_inode = hfs_evict_inode,
  157. .put_super = hfs_put_super,
  158. .sync_fs = hfs_sync_fs,
  159. .statfs = hfs_statfs,
  160. .remount_fs = hfs_remount,
  161. .show_options = hfs_show_options,
  162. };
  163. enum {
  164. opt_uid, opt_gid, opt_umask, opt_file_umask, opt_dir_umask,
  165. opt_part, opt_session, opt_type, opt_creator, opt_quiet,
  166. opt_codepage, opt_iocharset,
  167. opt_err
  168. };
  169. static const match_table_t tokens = {
  170. { opt_uid, "uid=%u" },
  171. { opt_gid, "gid=%u" },
  172. { opt_umask, "umask=%o" },
  173. { opt_file_umask, "file_umask=%o" },
  174. { opt_dir_umask, "dir_umask=%o" },
  175. { opt_part, "part=%u" },
  176. { opt_session, "session=%u" },
  177. { opt_type, "type=%s" },
  178. { opt_creator, "creator=%s" },
  179. { opt_quiet, "quiet" },
  180. { opt_codepage, "codepage=%s" },
  181. { opt_iocharset, "iocharset=%s" },
  182. { opt_err, NULL }
  183. };
  184. static inline int match_fourchar(substring_t *arg, u32 *result)
  185. {
  186. if (arg->to - arg->from != 4)
  187. return -EINVAL;
  188. memcpy(result, arg->from, 4);
  189. return 0;
  190. }
  191. /*
  192. * parse_options()
  193. *
  194. * adapted from linux/fs/msdos/inode.c written 1992,93 by Werner Almesberger
  195. * This function is called by hfs_read_super() to parse the mount options.
  196. */
  197. static int parse_options(char *options, struct hfs_sb_info *hsb)
  198. {
  199. char *p;
  200. substring_t args[MAX_OPT_ARGS];
  201. int tmp, token;
  202. /* initialize the sb with defaults */
  203. hsb->s_uid = current_uid();
  204. hsb->s_gid = current_gid();
  205. hsb->s_file_umask = 0133;
  206. hsb->s_dir_umask = 0022;
  207. hsb->s_type = hsb->s_creator = cpu_to_be32(0x3f3f3f3f); /* == '????' */
  208. hsb->s_quiet = 0;
  209. hsb->part = -1;
  210. hsb->session = -1;
  211. if (!options)
  212. return 1;
  213. while ((p = strsep(&options, ",")) != NULL) {
  214. if (!*p)
  215. continue;
  216. token = match_token(p, tokens, args);
  217. switch (token) {
  218. case opt_uid:
  219. if (match_int(&args[0], &tmp)) {
  220. pr_err("uid requires an argument\n");
  221. return 0;
  222. }
  223. hsb->s_uid = make_kuid(current_user_ns(), (uid_t)tmp);
  224. if (!uid_valid(hsb->s_uid)) {
  225. pr_err("invalid uid %d\n", tmp);
  226. return 0;
  227. }
  228. break;
  229. case opt_gid:
  230. if (match_int(&args[0], &tmp)) {
  231. pr_err("gid requires an argument\n");
  232. return 0;
  233. }
  234. hsb->s_gid = make_kgid(current_user_ns(), (gid_t)tmp);
  235. if (!gid_valid(hsb->s_gid)) {
  236. pr_err("invalid gid %d\n", tmp);
  237. return 0;
  238. }
  239. break;
  240. case opt_umask:
  241. if (match_octal(&args[0], &tmp)) {
  242. pr_err("umask requires a value\n");
  243. return 0;
  244. }
  245. hsb->s_file_umask = (umode_t)tmp;
  246. hsb->s_dir_umask = (umode_t)tmp;
  247. break;
  248. case opt_file_umask:
  249. if (match_octal(&args[0], &tmp)) {
  250. pr_err("file_umask requires a value\n");
  251. return 0;
  252. }
  253. hsb->s_file_umask = (umode_t)tmp;
  254. break;
  255. case opt_dir_umask:
  256. if (match_octal(&args[0], &tmp)) {
  257. pr_err("dir_umask requires a value\n");
  258. return 0;
  259. }
  260. hsb->s_dir_umask = (umode_t)tmp;
  261. break;
  262. case opt_part:
  263. if (match_int(&args[0], &hsb->part)) {
  264. pr_err("part requires an argument\n");
  265. return 0;
  266. }
  267. break;
  268. case opt_session:
  269. if (match_int(&args[0], &hsb->session)) {
  270. pr_err("session requires an argument\n");
  271. return 0;
  272. }
  273. break;
  274. case opt_type:
  275. if (match_fourchar(&args[0], &hsb->s_type)) {
  276. pr_err("type requires a 4 character value\n");
  277. return 0;
  278. }
  279. break;
  280. case opt_creator:
  281. if (match_fourchar(&args[0], &hsb->s_creator)) {
  282. pr_err("creator requires a 4 character value\n");
  283. return 0;
  284. }
  285. break;
  286. case opt_quiet:
  287. hsb->s_quiet = 1;
  288. break;
  289. case opt_codepage:
  290. if (hsb->nls_disk) {
  291. pr_err("unable to change codepage\n");
  292. return 0;
  293. }
  294. p = match_strdup(&args[0]);
  295. if (p)
  296. hsb->nls_disk = load_nls(p);
  297. if (!hsb->nls_disk) {
  298. pr_err("unable to load codepage \"%s\"\n", p);
  299. kfree(p);
  300. return 0;
  301. }
  302. kfree(p);
  303. break;
  304. case opt_iocharset:
  305. if (hsb->nls_io) {
  306. pr_err("unable to change iocharset\n");
  307. return 0;
  308. }
  309. p = match_strdup(&args[0]);
  310. if (p)
  311. hsb->nls_io = load_nls(p);
  312. if (!hsb->nls_io) {
  313. pr_err("unable to load iocharset \"%s\"\n", p);
  314. kfree(p);
  315. return 0;
  316. }
  317. kfree(p);
  318. break;
  319. default:
  320. return 0;
  321. }
  322. }
  323. if (hsb->nls_disk && !hsb->nls_io) {
  324. hsb->nls_io = load_nls_default();
  325. if (!hsb->nls_io) {
  326. pr_err("unable to load default iocharset\n");
  327. return 0;
  328. }
  329. }
  330. hsb->s_dir_umask &= 0777;
  331. hsb->s_file_umask &= 0577;
  332. return 1;
  333. }
  334. /*
  335. * hfs_read_super()
  336. *
  337. * This is the function that is responsible for mounting an HFS
  338. * filesystem. It performs all the tasks necessary to get enough data
  339. * from the disk to read the root inode. This includes parsing the
  340. * mount options, dealing with Macintosh partitions, reading the
  341. * superblock and the allocation bitmap blocks, calling
  342. * hfs_btree_init() to get the necessary data about the extents and
  343. * catalog B-trees and, finally, reading the root inode into memory.
  344. */
  345. static int hfs_fill_super(struct super_block *sb, void *data, int silent)
  346. {
  347. struct hfs_sb_info *sbi;
  348. struct hfs_find_data fd;
  349. hfs_cat_rec rec;
  350. struct inode *root_inode;
  351. int res;
  352. sbi = kzalloc(sizeof(struct hfs_sb_info), GFP_KERNEL);
  353. if (!sbi)
  354. return -ENOMEM;
  355. sbi->sb = sb;
  356. sb->s_fs_info = sbi;
  357. spin_lock_init(&sbi->work_lock);
  358. INIT_DELAYED_WORK(&sbi->mdb_work, flush_mdb);
  359. res = -EINVAL;
  360. if (!parse_options((char *)data, sbi)) {
  361. pr_err("unable to parse mount options\n");
  362. goto bail;
  363. }
  364. sb->s_op = &hfs_super_operations;
  365. sb->s_xattr = hfs_xattr_handlers;
  366. sb->s_flags |= SB_NODIRATIME;
  367. mutex_init(&sbi->bitmap_lock);
  368. res = hfs_mdb_get(sb);
  369. if (res) {
  370. if (!silent)
  371. pr_warn("can't find a HFS filesystem on dev %s\n",
  372. hfs_mdb_name(sb));
  373. res = -EINVAL;
  374. goto bail;
  375. }
  376. /* try to get the root inode */
  377. res = hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
  378. if (res)
  379. goto bail_no_root;
  380. res = hfs_cat_find_brec(sb, HFS_ROOT_CNID, &fd);
  381. if (!res) {
  382. if (fd.entrylength > sizeof(rec) || fd.entrylength < 0) {
  383. res = -EIO;
  384. goto bail_hfs_find;
  385. }
  386. hfs_bnode_read(fd.bnode, &rec, fd.entryoffset, fd.entrylength);
  387. }
  388. if (res)
  389. goto bail_hfs_find;
  390. res = -EINVAL;
  391. root_inode = hfs_iget(sb, &fd.search_key->cat, &rec);
  392. hfs_find_exit(&fd);
  393. if (!root_inode)
  394. goto bail_no_root;
  395. sb->s_d_op = &hfs_dentry_operations;
  396. res = -ENOMEM;
  397. sb->s_root = d_make_root(root_inode);
  398. if (!sb->s_root)
  399. goto bail_no_root;
  400. /* everything's okay */
  401. return 0;
  402. bail_hfs_find:
  403. hfs_find_exit(&fd);
  404. bail_no_root:
  405. pr_err("get root inode failed\n");
  406. bail:
  407. hfs_mdb_put(sb);
  408. return res;
  409. }
  410. static struct dentry *hfs_mount(struct file_system_type *fs_type,
  411. int flags, const char *dev_name, void *data)
  412. {
  413. return mount_bdev(fs_type, flags, dev_name, data, hfs_fill_super);
  414. }
  415. static struct file_system_type hfs_fs_type = {
  416. .owner = THIS_MODULE,
  417. .name = "hfs",
  418. .mount = hfs_mount,
  419. .kill_sb = kill_block_super,
  420. .fs_flags = FS_REQUIRES_DEV,
  421. };
  422. MODULE_ALIAS_FS("hfs");
  423. static void hfs_init_once(void *p)
  424. {
  425. struct hfs_inode_info *i = p;
  426. inode_init_once(&i->vfs_inode);
  427. }
  428. static int __init init_hfs_fs(void)
  429. {
  430. int err;
  431. hfs_inode_cachep = kmem_cache_create("hfs_inode_cache",
  432. sizeof(struct hfs_inode_info), 0,
  433. SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, hfs_init_once);
  434. if (!hfs_inode_cachep)
  435. return -ENOMEM;
  436. err = register_filesystem(&hfs_fs_type);
  437. if (err)
  438. kmem_cache_destroy(hfs_inode_cachep);
  439. return err;
  440. }
  441. static void __exit exit_hfs_fs(void)
  442. {
  443. unregister_filesystem(&hfs_fs_type);
  444. /*
  445. * Make sure all delayed rcu free inodes are flushed before we
  446. * destroy cache.
  447. */
  448. rcu_barrier();
  449. kmem_cache_destroy(hfs_inode_cachep);
  450. }
  451. module_init(init_hfs_fs)
  452. module_exit(exit_hfs_fs)