inode.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * fs/bfs/inode.c
  4. * BFS superblock and inode operations.
  5. * Copyright (C) 1999-2018 Tigran Aivazian <aivazian.tigran@gmail.com>
  6. * From fs/minix, Copyright (C) 1991, 1992 Linus Torvalds.
  7. * Made endianness-clean by Andrew Stribblehill <ads@wompom.org>, 2005.
  8. */
  9. #include <linux/module.h>
  10. #include <linux/mm.h>
  11. #include <linux/slab.h>
  12. #include <linux/init.h>
  13. #include <linux/fs.h>
  14. #include <linux/buffer_head.h>
  15. #include <linux/vfs.h>
  16. #include <linux/writeback.h>
  17. #include <linux/uio.h>
  18. #include <linux/uaccess.h>
  19. #include "bfs.h"
  20. MODULE_AUTHOR("Tigran Aivazian <aivazian.tigran@gmail.com>");
  21. MODULE_DESCRIPTION("SCO UnixWare BFS filesystem for Linux");
  22. MODULE_LICENSE("GPL");
  23. MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
  24. #undef DEBUG
  25. #ifdef DEBUG
  26. #define dprintf(x...) printf(x)
  27. #else
  28. #define dprintf(x...)
  29. #endif
  30. struct inode *bfs_iget(struct super_block *sb, unsigned long ino)
  31. {
  32. struct bfs_inode *di;
  33. struct inode *inode;
  34. struct buffer_head *bh;
  35. int block, off;
  36. inode = iget_locked(sb, ino);
  37. if (!inode)
  38. return ERR_PTR(-ENOMEM);
  39. if (!(inode->i_state & I_NEW))
  40. return inode;
  41. if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(inode->i_sb)->si_lasti)) {
  42. printf("Bad inode number %s:%08lx\n", inode->i_sb->s_id, ino);
  43. goto error;
  44. }
  45. block = (ino - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1;
  46. bh = sb_bread(inode->i_sb, block);
  47. if (!bh) {
  48. printf("Unable to read inode %s:%08lx\n", inode->i_sb->s_id,
  49. ino);
  50. goto error;
  51. }
  52. off = (ino - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK;
  53. di = (struct bfs_inode *)bh->b_data + off;
  54. inode->i_mode = 0x0000FFFF & le32_to_cpu(di->i_mode);
  55. if (le32_to_cpu(di->i_vtype) == BFS_VDIR) {
  56. inode->i_mode |= S_IFDIR;
  57. inode->i_op = &bfs_dir_inops;
  58. inode->i_fop = &bfs_dir_operations;
  59. } else if (le32_to_cpu(di->i_vtype) == BFS_VREG) {
  60. inode->i_mode |= S_IFREG;
  61. inode->i_op = &bfs_file_inops;
  62. inode->i_fop = &bfs_file_operations;
  63. inode->i_mapping->a_ops = &bfs_aops;
  64. }
  65. BFS_I(inode)->i_sblock = le32_to_cpu(di->i_sblock);
  66. BFS_I(inode)->i_eblock = le32_to_cpu(di->i_eblock);
  67. BFS_I(inode)->i_dsk_ino = le16_to_cpu(di->i_ino);
  68. i_uid_write(inode, le32_to_cpu(di->i_uid));
  69. i_gid_write(inode, le32_to_cpu(di->i_gid));
  70. set_nlink(inode, le32_to_cpu(di->i_nlink));
  71. inode->i_size = BFS_FILESIZE(di);
  72. inode->i_blocks = BFS_FILEBLOCKS(di);
  73. inode->i_atime.tv_sec = le32_to_cpu(di->i_atime);
  74. inode->i_mtime.tv_sec = le32_to_cpu(di->i_mtime);
  75. inode->i_ctime.tv_sec = le32_to_cpu(di->i_ctime);
  76. inode->i_atime.tv_nsec = 0;
  77. inode->i_mtime.tv_nsec = 0;
  78. inode->i_ctime.tv_nsec = 0;
  79. brelse(bh);
  80. unlock_new_inode(inode);
  81. return inode;
  82. error:
  83. iget_failed(inode);
  84. return ERR_PTR(-EIO);
  85. }
  86. static struct bfs_inode *find_inode(struct super_block *sb, u16 ino, struct buffer_head **p)
  87. {
  88. if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(sb)->si_lasti)) {
  89. printf("Bad inode number %s:%08x\n", sb->s_id, ino);
  90. return ERR_PTR(-EIO);
  91. }
  92. ino -= BFS_ROOT_INO;
  93. *p = sb_bread(sb, 1 + ino / BFS_INODES_PER_BLOCK);
  94. if (!*p) {
  95. printf("Unable to read inode %s:%08x\n", sb->s_id, ino);
  96. return ERR_PTR(-EIO);
  97. }
  98. return (struct bfs_inode *)(*p)->b_data + ino % BFS_INODES_PER_BLOCK;
  99. }
  100. static int bfs_write_inode(struct inode *inode, struct writeback_control *wbc)
  101. {
  102. struct bfs_sb_info *info = BFS_SB(inode->i_sb);
  103. unsigned int ino = (u16)inode->i_ino;
  104. unsigned long i_sblock;
  105. struct bfs_inode *di;
  106. struct buffer_head *bh;
  107. int err = 0;
  108. dprintf("ino=%08x\n", ino);
  109. di = find_inode(inode->i_sb, ino, &bh);
  110. if (IS_ERR(di))
  111. return PTR_ERR(di);
  112. mutex_lock(&info->bfs_lock);
  113. if (ino == BFS_ROOT_INO)
  114. di->i_vtype = cpu_to_le32(BFS_VDIR);
  115. else
  116. di->i_vtype = cpu_to_le32(BFS_VREG);
  117. di->i_ino = cpu_to_le16(ino);
  118. di->i_mode = cpu_to_le32(inode->i_mode);
  119. di->i_uid = cpu_to_le32(i_uid_read(inode));
  120. di->i_gid = cpu_to_le32(i_gid_read(inode));
  121. di->i_nlink = cpu_to_le32(inode->i_nlink);
  122. di->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
  123. di->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
  124. di->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
  125. i_sblock = BFS_I(inode)->i_sblock;
  126. di->i_sblock = cpu_to_le32(i_sblock);
  127. di->i_eblock = cpu_to_le32(BFS_I(inode)->i_eblock);
  128. di->i_eoffset = cpu_to_le32(i_sblock * BFS_BSIZE + inode->i_size - 1);
  129. mark_buffer_dirty(bh);
  130. if (wbc->sync_mode == WB_SYNC_ALL) {
  131. sync_dirty_buffer(bh);
  132. if (buffer_req(bh) && !buffer_uptodate(bh))
  133. err = -EIO;
  134. }
  135. brelse(bh);
  136. mutex_unlock(&info->bfs_lock);
  137. return err;
  138. }
  139. static void bfs_evict_inode(struct inode *inode)
  140. {
  141. unsigned long ino = inode->i_ino;
  142. struct bfs_inode *di;
  143. struct buffer_head *bh;
  144. struct super_block *s = inode->i_sb;
  145. struct bfs_sb_info *info = BFS_SB(s);
  146. struct bfs_inode_info *bi = BFS_I(inode);
  147. dprintf("ino=%08lx\n", ino);
  148. truncate_inode_pages_final(&inode->i_data);
  149. invalidate_inode_buffers(inode);
  150. clear_inode(inode);
  151. if (inode->i_nlink)
  152. return;
  153. di = find_inode(s, inode->i_ino, &bh);
  154. if (IS_ERR(di))
  155. return;
  156. mutex_lock(&info->bfs_lock);
  157. /* clear on-disk inode */
  158. memset(di, 0, sizeof(struct bfs_inode));
  159. mark_buffer_dirty(bh);
  160. brelse(bh);
  161. if (bi->i_dsk_ino) {
  162. if (bi->i_sblock)
  163. info->si_freeb += bi->i_eblock + 1 - bi->i_sblock;
  164. info->si_freei++;
  165. clear_bit(ino, info->si_imap);
  166. bfs_dump_imap("evict_inode", s);
  167. }
  168. /*
  169. * If this was the last file, make the previous block
  170. * "last block of the last file" even if there is no
  171. * real file there, saves us 1 gap.
  172. */
  173. if (info->si_lf_eblk == bi->i_eblock)
  174. info->si_lf_eblk = bi->i_sblock - 1;
  175. mutex_unlock(&info->bfs_lock);
  176. }
  177. static void bfs_put_super(struct super_block *s)
  178. {
  179. struct bfs_sb_info *info = BFS_SB(s);
  180. if (!info)
  181. return;
  182. mutex_destroy(&info->bfs_lock);
  183. kfree(info);
  184. s->s_fs_info = NULL;
  185. }
  186. static int bfs_statfs(struct dentry *dentry, struct kstatfs *buf)
  187. {
  188. struct super_block *s = dentry->d_sb;
  189. struct bfs_sb_info *info = BFS_SB(s);
  190. u64 id = huge_encode_dev(s->s_bdev->bd_dev);
  191. buf->f_type = BFS_MAGIC;
  192. buf->f_bsize = s->s_blocksize;
  193. buf->f_blocks = info->si_blocks;
  194. buf->f_bfree = buf->f_bavail = info->si_freeb;
  195. buf->f_files = info->si_lasti + 1 - BFS_ROOT_INO;
  196. buf->f_ffree = info->si_freei;
  197. buf->f_fsid = u64_to_fsid(id);
  198. buf->f_namelen = BFS_NAMELEN;
  199. return 0;
  200. }
  201. static struct kmem_cache *bfs_inode_cachep;
  202. static struct inode *bfs_alloc_inode(struct super_block *sb)
  203. {
  204. struct bfs_inode_info *bi;
  205. bi = kmem_cache_alloc(bfs_inode_cachep, GFP_KERNEL);
  206. if (!bi)
  207. return NULL;
  208. return &bi->vfs_inode;
  209. }
  210. static void bfs_free_inode(struct inode *inode)
  211. {
  212. kmem_cache_free(bfs_inode_cachep, BFS_I(inode));
  213. }
  214. static void init_once(void *foo)
  215. {
  216. struct bfs_inode_info *bi = foo;
  217. inode_init_once(&bi->vfs_inode);
  218. }
  219. static int __init init_inodecache(void)
  220. {
  221. bfs_inode_cachep = kmem_cache_create("bfs_inode_cache",
  222. sizeof(struct bfs_inode_info),
  223. 0, (SLAB_RECLAIM_ACCOUNT|
  224. SLAB_MEM_SPREAD|SLAB_ACCOUNT),
  225. init_once);
  226. if (bfs_inode_cachep == NULL)
  227. return -ENOMEM;
  228. return 0;
  229. }
  230. static void destroy_inodecache(void)
  231. {
  232. /*
  233. * Make sure all delayed rcu free inodes are flushed before we
  234. * destroy cache.
  235. */
  236. rcu_barrier();
  237. kmem_cache_destroy(bfs_inode_cachep);
  238. }
  239. static const struct super_operations bfs_sops = {
  240. .alloc_inode = bfs_alloc_inode,
  241. .free_inode = bfs_free_inode,
  242. .write_inode = bfs_write_inode,
  243. .evict_inode = bfs_evict_inode,
  244. .put_super = bfs_put_super,
  245. .statfs = bfs_statfs,
  246. };
  247. void bfs_dump_imap(const char *prefix, struct super_block *s)
  248. {
  249. #ifdef DEBUG
  250. int i;
  251. char *tmpbuf = (char *)get_zeroed_page(GFP_KERNEL);
  252. if (!tmpbuf)
  253. return;
  254. for (i = BFS_SB(s)->si_lasti; i >= 0; i--) {
  255. if (i > PAGE_SIZE - 100) break;
  256. if (test_bit(i, BFS_SB(s)->si_imap))
  257. strcat(tmpbuf, "1");
  258. else
  259. strcat(tmpbuf, "0");
  260. }
  261. printf("%s: lasti=%08lx <%s>\n", prefix, BFS_SB(s)->si_lasti, tmpbuf);
  262. free_page((unsigned long)tmpbuf);
  263. #endif
  264. }
  265. static int bfs_fill_super(struct super_block *s, void *data, int silent)
  266. {
  267. struct buffer_head *bh, *sbh;
  268. struct bfs_super_block *bfs_sb;
  269. struct inode *inode;
  270. unsigned i;
  271. struct bfs_sb_info *info;
  272. int ret = -EINVAL;
  273. unsigned long i_sblock, i_eblock, i_eoff, s_size;
  274. info = kzalloc(sizeof(*info), GFP_KERNEL);
  275. if (!info)
  276. return -ENOMEM;
  277. mutex_init(&info->bfs_lock);
  278. s->s_fs_info = info;
  279. s->s_time_min = 0;
  280. s->s_time_max = U32_MAX;
  281. sb_set_blocksize(s, BFS_BSIZE);
  282. sbh = sb_bread(s, 0);
  283. if (!sbh)
  284. goto out;
  285. bfs_sb = (struct bfs_super_block *)sbh->b_data;
  286. if (le32_to_cpu(bfs_sb->s_magic) != BFS_MAGIC) {
  287. if (!silent)
  288. printf("No BFS filesystem on %s (magic=%08x)\n", s->s_id, le32_to_cpu(bfs_sb->s_magic));
  289. goto out1;
  290. }
  291. if (BFS_UNCLEAN(bfs_sb, s) && !silent)
  292. printf("%s is unclean, continuing\n", s->s_id);
  293. s->s_magic = BFS_MAGIC;
  294. if (le32_to_cpu(bfs_sb->s_start) > le32_to_cpu(bfs_sb->s_end) ||
  295. le32_to_cpu(bfs_sb->s_start) < sizeof(struct bfs_super_block) + sizeof(struct bfs_dirent)) {
  296. printf("Superblock is corrupted on %s\n", s->s_id);
  297. goto out1;
  298. }
  299. info->si_lasti = (le32_to_cpu(bfs_sb->s_start) - BFS_BSIZE) / sizeof(struct bfs_inode) + BFS_ROOT_INO - 1;
  300. if (info->si_lasti == BFS_MAX_LASTI)
  301. printf("NOTE: filesystem %s was created with 512 inodes, the real maximum is 511, mounting anyway\n", s->s_id);
  302. else if (info->si_lasti > BFS_MAX_LASTI) {
  303. printf("Impossible last inode number %lu > %d on %s\n", info->si_lasti, BFS_MAX_LASTI, s->s_id);
  304. goto out1;
  305. }
  306. for (i = 0; i < BFS_ROOT_INO; i++)
  307. set_bit(i, info->si_imap);
  308. s->s_op = &bfs_sops;
  309. inode = bfs_iget(s, BFS_ROOT_INO);
  310. if (IS_ERR(inode)) {
  311. ret = PTR_ERR(inode);
  312. goto out1;
  313. }
  314. s->s_root = d_make_root(inode);
  315. if (!s->s_root) {
  316. ret = -ENOMEM;
  317. goto out1;
  318. }
  319. info->si_blocks = (le32_to_cpu(bfs_sb->s_end) + 1) >> BFS_BSIZE_BITS;
  320. info->si_freeb = (le32_to_cpu(bfs_sb->s_end) + 1 - le32_to_cpu(bfs_sb->s_start)) >> BFS_BSIZE_BITS;
  321. info->si_freei = 0;
  322. info->si_lf_eblk = 0;
  323. /* can we read the last block? */
  324. bh = sb_bread(s, info->si_blocks - 1);
  325. if (!bh) {
  326. printf("Last block not available on %s: %lu\n", s->s_id, info->si_blocks - 1);
  327. ret = -EIO;
  328. goto out2;
  329. }
  330. brelse(bh);
  331. bh = NULL;
  332. for (i = BFS_ROOT_INO; i <= info->si_lasti; i++) {
  333. struct bfs_inode *di;
  334. int block = (i - BFS_ROOT_INO) / BFS_INODES_PER_BLOCK + 1;
  335. int off = (i - BFS_ROOT_INO) % BFS_INODES_PER_BLOCK;
  336. unsigned long eblock;
  337. if (!off) {
  338. brelse(bh);
  339. bh = sb_bread(s, block);
  340. }
  341. if (!bh)
  342. continue;
  343. di = (struct bfs_inode *)bh->b_data + off;
  344. /* test if filesystem is not corrupted */
  345. i_eoff = le32_to_cpu(di->i_eoffset);
  346. i_sblock = le32_to_cpu(di->i_sblock);
  347. i_eblock = le32_to_cpu(di->i_eblock);
  348. s_size = le32_to_cpu(bfs_sb->s_end);
  349. if (i_sblock > info->si_blocks ||
  350. i_eblock > info->si_blocks ||
  351. i_sblock > i_eblock ||
  352. (i_eoff != le32_to_cpu(-1) && i_eoff > s_size) ||
  353. i_sblock * BFS_BSIZE > i_eoff) {
  354. printf("Inode 0x%08x corrupted on %s\n", i, s->s_id);
  355. brelse(bh);
  356. ret = -EIO;
  357. goto out2;
  358. }
  359. if (!di->i_ino) {
  360. info->si_freei++;
  361. continue;
  362. }
  363. set_bit(i, info->si_imap);
  364. info->si_freeb -= BFS_FILEBLOCKS(di);
  365. eblock = le32_to_cpu(di->i_eblock);
  366. if (eblock > info->si_lf_eblk)
  367. info->si_lf_eblk = eblock;
  368. }
  369. brelse(bh);
  370. brelse(sbh);
  371. bfs_dump_imap("fill_super", s);
  372. return 0;
  373. out2:
  374. dput(s->s_root);
  375. s->s_root = NULL;
  376. out1:
  377. brelse(sbh);
  378. out:
  379. mutex_destroy(&info->bfs_lock);
  380. kfree(info);
  381. s->s_fs_info = NULL;
  382. return ret;
  383. }
  384. static struct dentry *bfs_mount(struct file_system_type *fs_type,
  385. int flags, const char *dev_name, void *data)
  386. {
  387. return mount_bdev(fs_type, flags, dev_name, data, bfs_fill_super);
  388. }
  389. static struct file_system_type bfs_fs_type = {
  390. .owner = THIS_MODULE,
  391. .name = "bfs",
  392. .mount = bfs_mount,
  393. .kill_sb = kill_block_super,
  394. .fs_flags = FS_REQUIRES_DEV,
  395. };
  396. MODULE_ALIAS_FS("bfs");
  397. static int __init init_bfs_fs(void)
  398. {
  399. int err = init_inodecache();
  400. if (err)
  401. goto out1;
  402. err = register_filesystem(&bfs_fs_type);
  403. if (err)
  404. goto out;
  405. return 0;
  406. out:
  407. destroy_inodecache();
  408. out1:
  409. return err;
  410. }
  411. static void __exit exit_bfs_fs(void)
  412. {
  413. unregister_filesystem(&bfs_fs_type);
  414. destroy_inodecache();
  415. }
  416. module_init(init_bfs_fs)
  417. module_exit(exit_bfs_fs)