super.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669
  1. /* Block- or MTD-based romfs
  2. *
  3. * Copyright © 2007 Red Hat, Inc. All Rights Reserved.
  4. * Written by David Howells (dhowells@redhat.com)
  5. *
  6. * Derived from: ROMFS file system, Linux implementation
  7. *
  8. * Copyright © 1997-1999 Janos Farkas <chexum@shadow.banki.hu>
  9. *
  10. * Using parts of the minix filesystem
  11. * Copyright © 1991, 1992 Linus Torvalds
  12. *
  13. * and parts of the affs filesystem additionally
  14. * Copyright © 1993 Ray Burr
  15. * Copyright © 1996 Hans-Joachim Widmaier
  16. *
  17. * Changes
  18. * Changed for 2.1.19 modules
  19. * Jan 1997 Initial release
  20. * Jun 1997 2.1.43+ changes
  21. * Proper page locking in readpage
  22. * Changed to work with 2.1.45+ fs
  23. * Jul 1997 Fixed follow_link
  24. * 2.1.47
  25. * lookup shouldn't return -ENOENT
  26. * from Horst von Brand:
  27. * fail on wrong checksum
  28. * double unlock_super was possible
  29. * correct namelen for statfs
  30. * spotted by Bill Hawes:
  31. * readlink shouldn't iput()
  32. * Jun 1998 2.1.106 from Avery Pennarun: glibc scandir()
  33. * exposed a problem in readdir
  34. * 2.1.107 code-freeze spellchecker run
  35. * Aug 1998 2.1.118+ VFS changes
  36. * Sep 1998 2.1.122 another VFS change (follow_link)
  37. * Apr 1999 2.2.7 no more EBADF checking in
  38. * lookup/readdir, use ERR_PTR
  39. * Jun 1999 2.3.6 d_alloc_root use changed
  40. * 2.3.9 clean up usage of ENOENT/negative
  41. * dentries in lookup
  42. * clean up page flags setting
  43. * (error, uptodate, locking) in
  44. * in readpage
  45. * use init_special_inode for
  46. * fifos/sockets (and streamline) in
  47. * read_inode, fix _ops table order
  48. * Aug 1999 2.3.16 __initfunc() => __init change
  49. * Oct 1999 2.3.24 page->owner hack obsoleted
  50. * Nov 1999 2.3.27 2.3.25+ page->offset => index change
  51. *
  52. *
  53. * This program is free software; you can redistribute it and/or
  54. * modify it under the terms of the GNU General Public Licence
  55. * as published by the Free Software Foundation; either version
  56. * 2 of the Licence, or (at your option) any later version.
  57. */
  58. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  59. #include <linux/module.h>
  60. #include <linux/string.h>
  61. #include <linux/fs.h>
  62. #include <linux/time.h>
  63. #include <linux/slab.h>
  64. #include <linux/init.h>
  65. #include <linux/blkdev.h>
  66. #include <linux/fs_context.h>
  67. #include <linux/mount.h>
  68. #include <linux/namei.h>
  69. #include <linux/statfs.h>
  70. #include <linux/mtd/super.h>
  71. #include <linux/ctype.h>
  72. #include <linux/highmem.h>
  73. #include <linux/pagemap.h>
  74. #include <linux/uaccess.h>
  75. #include <linux/major.h>
  76. #include "internal.h"
  77. static struct kmem_cache *romfs_inode_cachep;
  78. static const umode_t romfs_modemap[8] = {
  79. 0, /* hard link */
  80. S_IFDIR | 0644, /* directory */
  81. S_IFREG | 0644, /* regular file */
  82. S_IFLNK | 0777, /* symlink */
  83. S_IFBLK | 0600, /* blockdev */
  84. S_IFCHR | 0600, /* chardev */
  85. S_IFSOCK | 0644, /* socket */
  86. S_IFIFO | 0644 /* FIFO */
  87. };
  88. static const unsigned char romfs_dtype_table[] = {
  89. DT_UNKNOWN, DT_DIR, DT_REG, DT_LNK, DT_BLK, DT_CHR, DT_SOCK, DT_FIFO
  90. };
  91. static struct inode *romfs_iget(struct super_block *sb, unsigned long pos);
  92. /*
  93. * read a page worth of data from the image
  94. */
  95. static int romfs_readpage(struct file *file, struct page *page)
  96. {
  97. struct inode *inode = page->mapping->host;
  98. loff_t offset, size;
  99. unsigned long fillsize, pos;
  100. void *buf;
  101. int ret;
  102. buf = kmap(page);
  103. if (!buf)
  104. return -ENOMEM;
  105. /* 32 bit warning -- but not for us :) */
  106. offset = page_offset(page);
  107. size = i_size_read(inode);
  108. fillsize = 0;
  109. ret = 0;
  110. if (offset < size) {
  111. size -= offset;
  112. fillsize = size > PAGE_SIZE ? PAGE_SIZE : size;
  113. pos = ROMFS_I(inode)->i_dataoffset + offset;
  114. ret = romfs_dev_read(inode->i_sb, pos, buf, fillsize);
  115. if (ret < 0) {
  116. SetPageError(page);
  117. fillsize = 0;
  118. ret = -EIO;
  119. }
  120. }
  121. if (fillsize < PAGE_SIZE)
  122. memset(buf + fillsize, 0, PAGE_SIZE - fillsize);
  123. if (ret == 0)
  124. SetPageUptodate(page);
  125. flush_dcache_page(page);
  126. kunmap(page);
  127. unlock_page(page);
  128. return ret;
  129. }
  130. static const struct address_space_operations romfs_aops = {
  131. .readpage = romfs_readpage
  132. };
  133. /*
  134. * read the entries from a directory
  135. */
  136. static int romfs_readdir(struct file *file, struct dir_context *ctx)
  137. {
  138. struct inode *i = file_inode(file);
  139. struct romfs_inode ri;
  140. unsigned long offset, maxoff;
  141. int j, ino, nextfh;
  142. char fsname[ROMFS_MAXFN]; /* XXX dynamic? */
  143. int ret;
  144. maxoff = romfs_maxsize(i->i_sb);
  145. offset = ctx->pos;
  146. if (!offset) {
  147. offset = i->i_ino & ROMFH_MASK;
  148. ret = romfs_dev_read(i->i_sb, offset, &ri, ROMFH_SIZE);
  149. if (ret < 0)
  150. goto out;
  151. offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
  152. }
  153. /* Not really failsafe, but we are read-only... */
  154. for (;;) {
  155. if (!offset || offset >= maxoff) {
  156. offset = maxoff;
  157. ctx->pos = offset;
  158. goto out;
  159. }
  160. ctx->pos = offset;
  161. /* Fetch inode info */
  162. ret = romfs_dev_read(i->i_sb, offset, &ri, ROMFH_SIZE);
  163. if (ret < 0)
  164. goto out;
  165. j = romfs_dev_strnlen(i->i_sb, offset + ROMFH_SIZE,
  166. sizeof(fsname) - 1);
  167. if (j < 0)
  168. goto out;
  169. ret = romfs_dev_read(i->i_sb, offset + ROMFH_SIZE, fsname, j);
  170. if (ret < 0)
  171. goto out;
  172. fsname[j] = '\0';
  173. ino = offset;
  174. nextfh = be32_to_cpu(ri.next);
  175. if ((nextfh & ROMFH_TYPE) == ROMFH_HRD)
  176. ino = be32_to_cpu(ri.spec);
  177. if (!dir_emit(ctx, fsname, j, ino,
  178. romfs_dtype_table[nextfh & ROMFH_TYPE]))
  179. goto out;
  180. offset = nextfh & ROMFH_MASK;
  181. }
  182. out:
  183. return 0;
  184. }
  185. /*
  186. * look up an entry in a directory
  187. */
  188. static struct dentry *romfs_lookup(struct inode *dir, struct dentry *dentry,
  189. unsigned int flags)
  190. {
  191. unsigned long offset, maxoff;
  192. struct inode *inode = NULL;
  193. struct romfs_inode ri;
  194. const char *name; /* got from dentry */
  195. int len, ret;
  196. offset = dir->i_ino & ROMFH_MASK;
  197. ret = romfs_dev_read(dir->i_sb, offset, &ri, ROMFH_SIZE);
  198. if (ret < 0)
  199. goto error;
  200. /* search all the file entries in the list starting from the one
  201. * pointed to by the directory's special data */
  202. maxoff = romfs_maxsize(dir->i_sb);
  203. offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
  204. name = dentry->d_name.name;
  205. len = dentry->d_name.len;
  206. for (;;) {
  207. if (!offset || offset >= maxoff)
  208. break;
  209. ret = romfs_dev_read(dir->i_sb, offset, &ri, sizeof(ri));
  210. if (ret < 0)
  211. goto error;
  212. /* try to match the first 16 bytes of name */
  213. ret = romfs_dev_strcmp(dir->i_sb, offset + ROMFH_SIZE, name,
  214. len);
  215. if (ret < 0)
  216. goto error;
  217. if (ret == 1) {
  218. /* Hard link handling */
  219. if ((be32_to_cpu(ri.next) & ROMFH_TYPE) == ROMFH_HRD)
  220. offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
  221. inode = romfs_iget(dir->i_sb, offset);
  222. break;
  223. }
  224. /* next entry */
  225. offset = be32_to_cpu(ri.next) & ROMFH_MASK;
  226. }
  227. return d_splice_alias(inode, dentry);
  228. error:
  229. return ERR_PTR(ret);
  230. }
  231. static const struct file_operations romfs_dir_operations = {
  232. .read = generic_read_dir,
  233. .iterate_shared = romfs_readdir,
  234. .llseek = generic_file_llseek,
  235. };
  236. static const struct inode_operations romfs_dir_inode_operations = {
  237. .lookup = romfs_lookup,
  238. };
  239. /*
  240. * get a romfs inode based on its position in the image (which doubles as the
  241. * inode number)
  242. */
  243. static struct inode *romfs_iget(struct super_block *sb, unsigned long pos)
  244. {
  245. struct romfs_inode_info *inode;
  246. struct romfs_inode ri;
  247. struct inode *i;
  248. unsigned long nlen;
  249. unsigned nextfh;
  250. int ret;
  251. umode_t mode;
  252. /* we might have to traverse a chain of "hard link" file entries to get
  253. * to the actual file */
  254. for (;;) {
  255. ret = romfs_dev_read(sb, pos, &ri, sizeof(ri));
  256. if (ret < 0)
  257. goto error;
  258. /* XXX: do romfs_checksum here too (with name) */
  259. nextfh = be32_to_cpu(ri.next);
  260. if ((nextfh & ROMFH_TYPE) != ROMFH_HRD)
  261. break;
  262. pos = be32_to_cpu(ri.spec) & ROMFH_MASK;
  263. }
  264. /* determine the length of the filename */
  265. nlen = romfs_dev_strnlen(sb, pos + ROMFH_SIZE, ROMFS_MAXFN);
  266. if (IS_ERR_VALUE(nlen))
  267. goto eio;
  268. /* get an inode for this image position */
  269. i = iget_locked(sb, pos);
  270. if (!i)
  271. return ERR_PTR(-ENOMEM);
  272. if (!(i->i_state & I_NEW))
  273. return i;
  274. /* precalculate the data offset */
  275. inode = ROMFS_I(i);
  276. inode->i_metasize = (ROMFH_SIZE + nlen + 1 + ROMFH_PAD) & ROMFH_MASK;
  277. inode->i_dataoffset = pos + inode->i_metasize;
  278. set_nlink(i, 1); /* Hard to decide.. */
  279. i->i_size = be32_to_cpu(ri.size);
  280. i->i_mtime.tv_sec = i->i_atime.tv_sec = i->i_ctime.tv_sec = 0;
  281. i->i_mtime.tv_nsec = i->i_atime.tv_nsec = i->i_ctime.tv_nsec = 0;
  282. /* set up mode and ops */
  283. mode = romfs_modemap[nextfh & ROMFH_TYPE];
  284. switch (nextfh & ROMFH_TYPE) {
  285. case ROMFH_DIR:
  286. i->i_size = ROMFS_I(i)->i_metasize;
  287. i->i_op = &romfs_dir_inode_operations;
  288. i->i_fop = &romfs_dir_operations;
  289. if (nextfh & ROMFH_EXEC)
  290. mode |= S_IXUGO;
  291. break;
  292. case ROMFH_REG:
  293. i->i_fop = &romfs_ro_fops;
  294. i->i_data.a_ops = &romfs_aops;
  295. if (nextfh & ROMFH_EXEC)
  296. mode |= S_IXUGO;
  297. break;
  298. case ROMFH_SYM:
  299. i->i_op = &page_symlink_inode_operations;
  300. inode_nohighmem(i);
  301. i->i_data.a_ops = &romfs_aops;
  302. mode |= S_IRWXUGO;
  303. break;
  304. default:
  305. /* depending on MBZ for sock/fifos */
  306. nextfh = be32_to_cpu(ri.spec);
  307. init_special_inode(i, mode, MKDEV(nextfh >> 16,
  308. nextfh & 0xffff));
  309. break;
  310. }
  311. i->i_mode = mode;
  312. i->i_blocks = (i->i_size + 511) >> 9;
  313. unlock_new_inode(i);
  314. return i;
  315. eio:
  316. ret = -EIO;
  317. error:
  318. pr_err("read error for inode 0x%lx\n", pos);
  319. return ERR_PTR(ret);
  320. }
  321. /*
  322. * allocate a new inode
  323. */
  324. static struct inode *romfs_alloc_inode(struct super_block *sb)
  325. {
  326. struct romfs_inode_info *inode;
  327. inode = kmem_cache_alloc(romfs_inode_cachep, GFP_KERNEL);
  328. return inode ? &inode->vfs_inode : NULL;
  329. }
  330. /*
  331. * return a spent inode to the slab cache
  332. */
  333. static void romfs_free_inode(struct inode *inode)
  334. {
  335. kmem_cache_free(romfs_inode_cachep, ROMFS_I(inode));
  336. }
  337. /*
  338. * get filesystem statistics
  339. */
  340. static int romfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  341. {
  342. struct super_block *sb = dentry->d_sb;
  343. u64 id = 0;
  344. /* When calling huge_encode_dev(),
  345. * use sb->s_bdev->bd_dev when,
  346. * - CONFIG_ROMFS_ON_BLOCK defined
  347. * use sb->s_dev when,
  348. * - CONFIG_ROMFS_ON_BLOCK undefined and
  349. * - CONFIG_ROMFS_ON_MTD defined
  350. * leave id as 0 when,
  351. * - CONFIG_ROMFS_ON_BLOCK undefined and
  352. * - CONFIG_ROMFS_ON_MTD undefined
  353. */
  354. if (sb->s_bdev)
  355. id = huge_encode_dev(sb->s_bdev->bd_dev);
  356. else if (sb->s_dev)
  357. id = huge_encode_dev(sb->s_dev);
  358. buf->f_type = ROMFS_MAGIC;
  359. buf->f_namelen = ROMFS_MAXFN;
  360. buf->f_bsize = ROMBSIZE;
  361. buf->f_bfree = buf->f_bavail = buf->f_ffree;
  362. buf->f_blocks =
  363. (romfs_maxsize(dentry->d_sb) + ROMBSIZE - 1) >> ROMBSBITS;
  364. buf->f_fsid = u64_to_fsid(id);
  365. return 0;
  366. }
  367. /*
  368. * remounting must involve read-only
  369. */
  370. static int romfs_reconfigure(struct fs_context *fc)
  371. {
  372. sync_filesystem(fc->root->d_sb);
  373. fc->sb_flags |= SB_RDONLY;
  374. return 0;
  375. }
  376. static const struct super_operations romfs_super_ops = {
  377. .alloc_inode = romfs_alloc_inode,
  378. .free_inode = romfs_free_inode,
  379. .statfs = romfs_statfs,
  380. };
  381. /*
  382. * checksum check on part of a romfs filesystem
  383. */
  384. static __u32 romfs_checksum(const void *data, int size)
  385. {
  386. const __be32 *ptr = data;
  387. __u32 sum;
  388. sum = 0;
  389. size >>= 2;
  390. while (size > 0) {
  391. sum += be32_to_cpu(*ptr++);
  392. size--;
  393. }
  394. return sum;
  395. }
  396. /*
  397. * fill in the superblock
  398. */
  399. static int romfs_fill_super(struct super_block *sb, struct fs_context *fc)
  400. {
  401. struct romfs_super_block *rsb;
  402. struct inode *root;
  403. unsigned long pos, img_size;
  404. const char *storage;
  405. size_t len;
  406. int ret;
  407. #ifdef CONFIG_BLOCK
  408. if (!sb->s_mtd) {
  409. sb_set_blocksize(sb, ROMBSIZE);
  410. } else {
  411. sb->s_blocksize = ROMBSIZE;
  412. sb->s_blocksize_bits = blksize_bits(ROMBSIZE);
  413. }
  414. #endif
  415. sb->s_maxbytes = 0xFFFFFFFF;
  416. sb->s_magic = ROMFS_MAGIC;
  417. sb->s_flags |= SB_RDONLY | SB_NOATIME;
  418. sb->s_time_min = 0;
  419. sb->s_time_max = 0;
  420. sb->s_op = &romfs_super_ops;
  421. #ifdef CONFIG_ROMFS_ON_MTD
  422. /* Use same dev ID from the underlying mtdblock device */
  423. if (sb->s_mtd)
  424. sb->s_dev = MKDEV(MTD_BLOCK_MAJOR, sb->s_mtd->index);
  425. #endif
  426. /* read the image superblock and check it */
  427. rsb = kmalloc(512, GFP_KERNEL);
  428. if (!rsb)
  429. return -ENOMEM;
  430. sb->s_fs_info = (void *) 512;
  431. ret = romfs_dev_read(sb, 0, rsb, 512);
  432. if (ret < 0)
  433. goto error_rsb;
  434. img_size = be32_to_cpu(rsb->size);
  435. if (sb->s_mtd && img_size > sb->s_mtd->size)
  436. goto error_rsb_inval;
  437. sb->s_fs_info = (void *) img_size;
  438. if (rsb->word0 != ROMSB_WORD0 || rsb->word1 != ROMSB_WORD1 ||
  439. img_size < ROMFH_SIZE) {
  440. if (!(fc->sb_flags & SB_SILENT))
  441. errorf(fc, "VFS: Can't find a romfs filesystem on dev %s.\n",
  442. sb->s_id);
  443. goto error_rsb_inval;
  444. }
  445. if (romfs_checksum(rsb, min_t(size_t, img_size, 512))) {
  446. pr_err("bad initial checksum on dev %s.\n", sb->s_id);
  447. goto error_rsb_inval;
  448. }
  449. storage = sb->s_mtd ? "MTD" : "the block layer";
  450. len = strnlen(rsb->name, ROMFS_MAXFN);
  451. if (!(fc->sb_flags & SB_SILENT))
  452. pr_notice("Mounting image '%*.*s' through %s\n",
  453. (unsigned) len, (unsigned) len, rsb->name, storage);
  454. kfree(rsb);
  455. rsb = NULL;
  456. /* find the root directory */
  457. pos = (ROMFH_SIZE + len + 1 + ROMFH_PAD) & ROMFH_MASK;
  458. root = romfs_iget(sb, pos);
  459. if (IS_ERR(root))
  460. return PTR_ERR(root);
  461. sb->s_root = d_make_root(root);
  462. if (!sb->s_root)
  463. return -ENOMEM;
  464. return 0;
  465. error_rsb_inval:
  466. ret = -EINVAL;
  467. error_rsb:
  468. kfree(rsb);
  469. return ret;
  470. }
  471. /*
  472. * get a superblock for mounting
  473. */
  474. static int romfs_get_tree(struct fs_context *fc)
  475. {
  476. int ret = -EINVAL;
  477. #ifdef CONFIG_ROMFS_ON_MTD
  478. ret = get_tree_mtd(fc, romfs_fill_super);
  479. #endif
  480. #ifdef CONFIG_ROMFS_ON_BLOCK
  481. if (ret == -EINVAL)
  482. ret = get_tree_bdev(fc, romfs_fill_super);
  483. #endif
  484. return ret;
  485. }
  486. static const struct fs_context_operations romfs_context_ops = {
  487. .get_tree = romfs_get_tree,
  488. .reconfigure = romfs_reconfigure,
  489. };
  490. /*
  491. * Set up the filesystem mount context.
  492. */
  493. static int romfs_init_fs_context(struct fs_context *fc)
  494. {
  495. fc->ops = &romfs_context_ops;
  496. return 0;
  497. }
  498. /*
  499. * destroy a romfs superblock in the appropriate manner
  500. */
  501. static void romfs_kill_sb(struct super_block *sb)
  502. {
  503. #ifdef CONFIG_ROMFS_ON_MTD
  504. if (sb->s_mtd) {
  505. kill_mtd_super(sb);
  506. return;
  507. }
  508. #endif
  509. #ifdef CONFIG_ROMFS_ON_BLOCK
  510. if (sb->s_bdev) {
  511. kill_block_super(sb);
  512. return;
  513. }
  514. #endif
  515. }
  516. static struct file_system_type romfs_fs_type = {
  517. .owner = THIS_MODULE,
  518. .name = "romfs",
  519. .init_fs_context = romfs_init_fs_context,
  520. .kill_sb = romfs_kill_sb,
  521. .fs_flags = FS_REQUIRES_DEV,
  522. };
  523. MODULE_ALIAS_FS("romfs");
  524. /*
  525. * inode storage initialiser
  526. */
  527. static void romfs_i_init_once(void *_inode)
  528. {
  529. struct romfs_inode_info *inode = _inode;
  530. inode_init_once(&inode->vfs_inode);
  531. }
  532. /*
  533. * romfs module initialisation
  534. */
  535. static int __init init_romfs_fs(void)
  536. {
  537. int ret;
  538. pr_info("ROMFS MTD (C) 2007 Red Hat, Inc.\n");
  539. romfs_inode_cachep =
  540. kmem_cache_create("romfs_i",
  541. sizeof(struct romfs_inode_info), 0,
  542. SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
  543. SLAB_ACCOUNT, romfs_i_init_once);
  544. if (!romfs_inode_cachep) {
  545. pr_err("Failed to initialise inode cache\n");
  546. return -ENOMEM;
  547. }
  548. ret = register_filesystem(&romfs_fs_type);
  549. if (ret) {
  550. pr_err("Failed to register filesystem\n");
  551. goto error_register;
  552. }
  553. return 0;
  554. error_register:
  555. kmem_cache_destroy(romfs_inode_cachep);
  556. return ret;
  557. }
  558. /*
  559. * romfs module removal
  560. */
  561. static void __exit exit_romfs_fs(void)
  562. {
  563. unregister_filesystem(&romfs_fs_type);
  564. /*
  565. * Make sure all delayed rcu free inodes are flushed before we
  566. * destroy cache.
  567. */
  568. rcu_barrier();
  569. kmem_cache_destroy(romfs_inode_cachep);
  570. }
  571. module_init(init_romfs_fs);
  572. module_exit(exit_romfs_fs);
  573. MODULE_DESCRIPTION("Direct-MTD Capable RomFS");
  574. MODULE_AUTHOR("Red Hat, Inc.");
  575. MODULE_LICENSE("GPL"); /* Actually dual-licensed, but it doesn't matter for */
  576. MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);