inode.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628
  1. /*
  2. * linux/fs/minix/inode.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. *
  6. * Copyright (C) 1996 Gertjan van Wingerde (gertjan@cs.vu.nl)
  7. * Minix V2 fs support.
  8. *
  9. * Modified for 680x0 by Andreas Schwab
  10. * Updated to filesystem version 3 by Daniel Aragones
  11. */
  12. #include <linux/module.h>
  13. #include "minix.h"
  14. #include <linux/buffer_head.h>
  15. #include <linux/slab.h>
  16. #include <linux/init.h>
  17. #include <linux/highuid.h>
  18. #include <linux/vfs.h>
  19. static void minix_read_inode(struct inode * inode);
  20. static int minix_write_inode(struct inode * inode, int wait);
  21. static int minix_statfs(struct dentry *dentry, struct kstatfs *buf);
  22. static int minix_remount (struct super_block * sb, int * flags, char * data);
  23. static void minix_delete_inode(struct inode *inode)
  24. {
  25. truncate_inode_pages(&inode->i_data, 0);
  26. inode->i_size = 0;
  27. minix_truncate(inode);
  28. minix_free_inode(inode);
  29. }
  30. static void minix_put_super(struct super_block *sb)
  31. {
  32. int i;
  33. struct minix_sb_info *sbi = minix_sb(sb);
  34. if (!(sb->s_flags & MS_RDONLY)) {
  35. if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
  36. sbi->s_ms->s_state = sbi->s_mount_state;
  37. mark_buffer_dirty(sbi->s_sbh);
  38. }
  39. for (i = 0; i < sbi->s_imap_blocks; i++)
  40. brelse(sbi->s_imap[i]);
  41. for (i = 0; i < sbi->s_zmap_blocks; i++)
  42. brelse(sbi->s_zmap[i]);
  43. brelse (sbi->s_sbh);
  44. kfree(sbi->s_imap);
  45. sb->s_fs_info = NULL;
  46. kfree(sbi);
  47. return;
  48. }
  49. static struct kmem_cache * minix_inode_cachep;
  50. static struct inode *minix_alloc_inode(struct super_block *sb)
  51. {
  52. struct minix_inode_info *ei;
  53. ei = (struct minix_inode_info *)kmem_cache_alloc(minix_inode_cachep, GFP_KERNEL);
  54. if (!ei)
  55. return NULL;
  56. return &ei->vfs_inode;
  57. }
  58. static void minix_destroy_inode(struct inode *inode)
  59. {
  60. kmem_cache_free(minix_inode_cachep, minix_i(inode));
  61. }
  62. static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
  63. {
  64. struct minix_inode_info *ei = (struct minix_inode_info *) foo;
  65. if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
  66. SLAB_CTOR_CONSTRUCTOR)
  67. inode_init_once(&ei->vfs_inode);
  68. }
  69. static int init_inodecache(void)
  70. {
  71. minix_inode_cachep = kmem_cache_create("minix_inode_cache",
  72. sizeof(struct minix_inode_info),
  73. 0, (SLAB_RECLAIM_ACCOUNT|
  74. SLAB_MEM_SPREAD),
  75. init_once, NULL);
  76. if (minix_inode_cachep == NULL)
  77. return -ENOMEM;
  78. return 0;
  79. }
  80. static void destroy_inodecache(void)
  81. {
  82. kmem_cache_destroy(minix_inode_cachep);
  83. }
  84. static const struct super_operations minix_sops = {
  85. .alloc_inode = minix_alloc_inode,
  86. .destroy_inode = minix_destroy_inode,
  87. .read_inode = minix_read_inode,
  88. .write_inode = minix_write_inode,
  89. .delete_inode = minix_delete_inode,
  90. .put_super = minix_put_super,
  91. .statfs = minix_statfs,
  92. .remount_fs = minix_remount,
  93. };
  94. static int minix_remount (struct super_block * sb, int * flags, char * data)
  95. {
  96. struct minix_sb_info * sbi = minix_sb(sb);
  97. struct minix_super_block * ms;
  98. ms = sbi->s_ms;
  99. if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
  100. return 0;
  101. if (*flags & MS_RDONLY) {
  102. if (ms->s_state & MINIX_VALID_FS ||
  103. !(sbi->s_mount_state & MINIX_VALID_FS))
  104. return 0;
  105. /* Mounting a rw partition read-only. */
  106. if (sbi->s_version != MINIX_V3)
  107. ms->s_state = sbi->s_mount_state;
  108. mark_buffer_dirty(sbi->s_sbh);
  109. } else {
  110. /* Mount a partition which is read-only, read-write. */
  111. if (sbi->s_version != MINIX_V3) {
  112. sbi->s_mount_state = ms->s_state;
  113. ms->s_state &= ~MINIX_VALID_FS;
  114. } else {
  115. sbi->s_mount_state = MINIX_VALID_FS;
  116. }
  117. mark_buffer_dirty(sbi->s_sbh);
  118. if (!(sbi->s_mount_state & MINIX_VALID_FS))
  119. printk("MINIX-fs warning: remounting unchecked fs, "
  120. "running fsck is recommended\n");
  121. else if ((sbi->s_mount_state & MINIX_ERROR_FS))
  122. printk("MINIX-fs warning: remounting fs with errors, "
  123. "running fsck is recommended\n");
  124. }
  125. return 0;
  126. }
  127. static int minix_fill_super(struct super_block *s, void *data, int silent)
  128. {
  129. struct buffer_head *bh;
  130. struct buffer_head **map;
  131. struct minix_super_block *ms;
  132. struct minix3_super_block *m3s = NULL;
  133. unsigned long i, block;
  134. struct inode *root_inode;
  135. struct minix_sb_info *sbi;
  136. sbi = kzalloc(sizeof(struct minix_sb_info), GFP_KERNEL);
  137. if (!sbi)
  138. return -ENOMEM;
  139. s->s_fs_info = sbi;
  140. BUILD_BUG_ON(32 != sizeof (struct minix_inode));
  141. BUILD_BUG_ON(64 != sizeof(struct minix2_inode));
  142. if (!sb_set_blocksize(s, BLOCK_SIZE))
  143. goto out_bad_hblock;
  144. if (!(bh = sb_bread(s, 1)))
  145. goto out_bad_sb;
  146. ms = (struct minix_super_block *) bh->b_data;
  147. sbi->s_ms = ms;
  148. sbi->s_sbh = bh;
  149. sbi->s_mount_state = ms->s_state;
  150. sbi->s_ninodes = ms->s_ninodes;
  151. sbi->s_nzones = ms->s_nzones;
  152. sbi->s_imap_blocks = ms->s_imap_blocks;
  153. sbi->s_zmap_blocks = ms->s_zmap_blocks;
  154. sbi->s_firstdatazone = ms->s_firstdatazone;
  155. sbi->s_log_zone_size = ms->s_log_zone_size;
  156. sbi->s_max_size = ms->s_max_size;
  157. s->s_magic = ms->s_magic;
  158. if (s->s_magic == MINIX_SUPER_MAGIC) {
  159. sbi->s_version = MINIX_V1;
  160. sbi->s_dirsize = 16;
  161. sbi->s_namelen = 14;
  162. sbi->s_link_max = MINIX_LINK_MAX;
  163. } else if (s->s_magic == MINIX_SUPER_MAGIC2) {
  164. sbi->s_version = MINIX_V1;
  165. sbi->s_dirsize = 32;
  166. sbi->s_namelen = 30;
  167. sbi->s_link_max = MINIX_LINK_MAX;
  168. } else if (s->s_magic == MINIX2_SUPER_MAGIC) {
  169. sbi->s_version = MINIX_V2;
  170. sbi->s_nzones = ms->s_zones;
  171. sbi->s_dirsize = 16;
  172. sbi->s_namelen = 14;
  173. sbi->s_link_max = MINIX2_LINK_MAX;
  174. } else if (s->s_magic == MINIX2_SUPER_MAGIC2) {
  175. sbi->s_version = MINIX_V2;
  176. sbi->s_nzones = ms->s_zones;
  177. sbi->s_dirsize = 32;
  178. sbi->s_namelen = 30;
  179. sbi->s_link_max = MINIX2_LINK_MAX;
  180. } else if ( *(__u16 *)(bh->b_data + 24) == MINIX3_SUPER_MAGIC) {
  181. m3s = (struct minix3_super_block *) bh->b_data;
  182. s->s_magic = m3s->s_magic;
  183. sbi->s_imap_blocks = m3s->s_imap_blocks;
  184. sbi->s_zmap_blocks = m3s->s_zmap_blocks;
  185. sbi->s_firstdatazone = m3s->s_firstdatazone;
  186. sbi->s_log_zone_size = m3s->s_log_zone_size;
  187. sbi->s_max_size = m3s->s_max_size;
  188. sbi->s_ninodes = m3s->s_ninodes;
  189. sbi->s_nzones = m3s->s_zones;
  190. sbi->s_dirsize = 64;
  191. sbi->s_namelen = 60;
  192. sbi->s_version = MINIX_V3;
  193. sbi->s_link_max = MINIX2_LINK_MAX;
  194. sbi->s_mount_state = MINIX_VALID_FS;
  195. sb_set_blocksize(s, m3s->s_blocksize);
  196. } else
  197. goto out_no_fs;
  198. /*
  199. * Allocate the buffer map to keep the superblock small.
  200. */
  201. if (sbi->s_imap_blocks == 0 || sbi->s_zmap_blocks == 0)
  202. goto out_illegal_sb;
  203. i = (sbi->s_imap_blocks + sbi->s_zmap_blocks) * sizeof(bh);
  204. map = kzalloc(i, GFP_KERNEL);
  205. if (!map)
  206. goto out_no_map;
  207. sbi->s_imap = &map[0];
  208. sbi->s_zmap = &map[sbi->s_imap_blocks];
  209. block=2;
  210. for (i=0 ; i < sbi->s_imap_blocks ; i++) {
  211. if (!(sbi->s_imap[i]=sb_bread(s, block)))
  212. goto out_no_bitmap;
  213. block++;
  214. }
  215. for (i=0 ; i < sbi->s_zmap_blocks ; i++) {
  216. if (!(sbi->s_zmap[i]=sb_bread(s, block)))
  217. goto out_no_bitmap;
  218. block++;
  219. }
  220. minix_set_bit(0,sbi->s_imap[0]->b_data);
  221. minix_set_bit(0,sbi->s_zmap[0]->b_data);
  222. /* set up enough so that it can read an inode */
  223. s->s_op = &minix_sops;
  224. root_inode = iget(s, MINIX_ROOT_INO);
  225. if (!root_inode || is_bad_inode(root_inode))
  226. goto out_no_root;
  227. s->s_root = d_alloc_root(root_inode);
  228. if (!s->s_root)
  229. goto out_iput;
  230. if (!NO_TRUNCATE)
  231. s->s_root->d_op = &minix_dentry_operations;
  232. if (!(s->s_flags & MS_RDONLY)) {
  233. if (sbi->s_version != MINIX_V3) /* s_state is now out from V3 sb */
  234. ms->s_state &= ~MINIX_VALID_FS;
  235. mark_buffer_dirty(bh);
  236. }
  237. if (!(sbi->s_mount_state & MINIX_VALID_FS))
  238. printk("MINIX-fs: mounting unchecked file system, "
  239. "running fsck is recommended\n");
  240. else if (sbi->s_mount_state & MINIX_ERROR_FS)
  241. printk("MINIX-fs: mounting file system with errors, "
  242. "running fsck is recommended\n");
  243. return 0;
  244. out_iput:
  245. iput(root_inode);
  246. goto out_freemap;
  247. out_no_root:
  248. if (!silent)
  249. printk("MINIX-fs: get root inode failed\n");
  250. goto out_freemap;
  251. out_no_bitmap:
  252. printk("MINIX-fs: bad superblock or unable to read bitmaps\n");
  253. out_freemap:
  254. for (i = 0; i < sbi->s_imap_blocks; i++)
  255. brelse(sbi->s_imap[i]);
  256. for (i = 0; i < sbi->s_zmap_blocks; i++)
  257. brelse(sbi->s_zmap[i]);
  258. kfree(sbi->s_imap);
  259. goto out_release;
  260. out_no_map:
  261. if (!silent)
  262. printk("MINIX-fs: can't allocate map\n");
  263. goto out_release;
  264. out_illegal_sb:
  265. if (!silent)
  266. printk("MINIX-fs: bad superblock\n");
  267. goto out_release;
  268. out_no_fs:
  269. if (!silent)
  270. printk("VFS: Can't find a Minix filesystem V1 | V2 | V3 "
  271. "on device %s.\n", s->s_id);
  272. out_release:
  273. brelse(bh);
  274. goto out;
  275. out_bad_hblock:
  276. printk("MINIX-fs: blocksize too small for device\n");
  277. goto out;
  278. out_bad_sb:
  279. printk("MINIX-fs: unable to read superblock\n");
  280. out:
  281. s->s_fs_info = NULL;
  282. kfree(sbi);
  283. return -EINVAL;
  284. }
  285. static int minix_statfs(struct dentry *dentry, struct kstatfs *buf)
  286. {
  287. struct minix_sb_info *sbi = minix_sb(dentry->d_sb);
  288. buf->f_type = dentry->d_sb->s_magic;
  289. buf->f_bsize = dentry->d_sb->s_blocksize;
  290. buf->f_blocks = (sbi->s_nzones - sbi->s_firstdatazone) << sbi->s_log_zone_size;
  291. buf->f_bfree = minix_count_free_blocks(sbi);
  292. buf->f_bavail = buf->f_bfree;
  293. buf->f_files = sbi->s_ninodes;
  294. buf->f_ffree = minix_count_free_inodes(sbi);
  295. buf->f_namelen = sbi->s_namelen;
  296. return 0;
  297. }
  298. static int minix_get_block(struct inode *inode, sector_t block,
  299. struct buffer_head *bh_result, int create)
  300. {
  301. if (INODE_VERSION(inode) == MINIX_V1)
  302. return V1_minix_get_block(inode, block, bh_result, create);
  303. else
  304. return V2_minix_get_block(inode, block, bh_result, create);
  305. }
  306. static int minix_writepage(struct page *page, struct writeback_control *wbc)
  307. {
  308. return block_write_full_page(page, minix_get_block, wbc);
  309. }
  310. static int minix_readpage(struct file *file, struct page *page)
  311. {
  312. return block_read_full_page(page,minix_get_block);
  313. }
  314. static int minix_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
  315. {
  316. return block_prepare_write(page,from,to,minix_get_block);
  317. }
  318. static sector_t minix_bmap(struct address_space *mapping, sector_t block)
  319. {
  320. return generic_block_bmap(mapping,block,minix_get_block);
  321. }
  322. static const struct address_space_operations minix_aops = {
  323. .readpage = minix_readpage,
  324. .writepage = minix_writepage,
  325. .sync_page = block_sync_page,
  326. .prepare_write = minix_prepare_write,
  327. .commit_write = generic_commit_write,
  328. .bmap = minix_bmap
  329. };
  330. static const struct inode_operations minix_symlink_inode_operations = {
  331. .readlink = generic_readlink,
  332. .follow_link = page_follow_link_light,
  333. .put_link = page_put_link,
  334. .getattr = minix_getattr,
  335. };
  336. void minix_set_inode(struct inode *inode, dev_t rdev)
  337. {
  338. if (S_ISREG(inode->i_mode)) {
  339. inode->i_op = &minix_file_inode_operations;
  340. inode->i_fop = &minix_file_operations;
  341. inode->i_mapping->a_ops = &minix_aops;
  342. } else if (S_ISDIR(inode->i_mode)) {
  343. inode->i_op = &minix_dir_inode_operations;
  344. inode->i_fop = &minix_dir_operations;
  345. inode->i_mapping->a_ops = &minix_aops;
  346. } else if (S_ISLNK(inode->i_mode)) {
  347. inode->i_op = &minix_symlink_inode_operations;
  348. inode->i_mapping->a_ops = &minix_aops;
  349. } else
  350. init_special_inode(inode, inode->i_mode, rdev);
  351. }
  352. /*
  353. * The minix V1 function to read an inode.
  354. */
  355. static void V1_minix_read_inode(struct inode * inode)
  356. {
  357. struct buffer_head * bh;
  358. struct minix_inode * raw_inode;
  359. struct minix_inode_info *minix_inode = minix_i(inode);
  360. int i;
  361. raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
  362. if (!raw_inode) {
  363. make_bad_inode(inode);
  364. return;
  365. }
  366. inode->i_mode = raw_inode->i_mode;
  367. inode->i_uid = (uid_t)raw_inode->i_uid;
  368. inode->i_gid = (gid_t)raw_inode->i_gid;
  369. inode->i_nlink = raw_inode->i_nlinks;
  370. inode->i_size = raw_inode->i_size;
  371. inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec = raw_inode->i_time;
  372. inode->i_mtime.tv_nsec = 0;
  373. inode->i_atime.tv_nsec = 0;
  374. inode->i_ctime.tv_nsec = 0;
  375. inode->i_blocks = 0;
  376. for (i = 0; i < 9; i++)
  377. minix_inode->u.i1_data[i] = raw_inode->i_zone[i];
  378. minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
  379. brelse(bh);
  380. }
  381. /*
  382. * The minix V2 function to read an inode.
  383. */
  384. static void V2_minix_read_inode(struct inode * inode)
  385. {
  386. struct buffer_head * bh;
  387. struct minix2_inode * raw_inode;
  388. struct minix_inode_info *minix_inode = minix_i(inode);
  389. int i;
  390. raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
  391. if (!raw_inode) {
  392. make_bad_inode(inode);
  393. return;
  394. }
  395. inode->i_mode = raw_inode->i_mode;
  396. inode->i_uid = (uid_t)raw_inode->i_uid;
  397. inode->i_gid = (gid_t)raw_inode->i_gid;
  398. inode->i_nlink = raw_inode->i_nlinks;
  399. inode->i_size = raw_inode->i_size;
  400. inode->i_mtime.tv_sec = raw_inode->i_mtime;
  401. inode->i_atime.tv_sec = raw_inode->i_atime;
  402. inode->i_ctime.tv_sec = raw_inode->i_ctime;
  403. inode->i_mtime.tv_nsec = 0;
  404. inode->i_atime.tv_nsec = 0;
  405. inode->i_ctime.tv_nsec = 0;
  406. inode->i_blocks = 0;
  407. for (i = 0; i < 10; i++)
  408. minix_inode->u.i2_data[i] = raw_inode->i_zone[i];
  409. minix_set_inode(inode, old_decode_dev(raw_inode->i_zone[0]));
  410. brelse(bh);
  411. }
  412. /*
  413. * The global function to read an inode.
  414. */
  415. static void minix_read_inode(struct inode * inode)
  416. {
  417. if (INODE_VERSION(inode) == MINIX_V1)
  418. V1_minix_read_inode(inode);
  419. else
  420. V2_minix_read_inode(inode);
  421. }
  422. /*
  423. * The minix V1 function to synchronize an inode.
  424. */
  425. static struct buffer_head * V1_minix_update_inode(struct inode * inode)
  426. {
  427. struct buffer_head * bh;
  428. struct minix_inode * raw_inode;
  429. struct minix_inode_info *minix_inode = minix_i(inode);
  430. int i;
  431. raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
  432. if (!raw_inode)
  433. return NULL;
  434. raw_inode->i_mode = inode->i_mode;
  435. raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
  436. raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
  437. raw_inode->i_nlinks = inode->i_nlink;
  438. raw_inode->i_size = inode->i_size;
  439. raw_inode->i_time = inode->i_mtime.tv_sec;
  440. if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  441. raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
  442. else for (i = 0; i < 9; i++)
  443. raw_inode->i_zone[i] = minix_inode->u.i1_data[i];
  444. mark_buffer_dirty(bh);
  445. return bh;
  446. }
  447. /*
  448. * The minix V2 function to synchronize an inode.
  449. */
  450. static struct buffer_head * V2_minix_update_inode(struct inode * inode)
  451. {
  452. struct buffer_head * bh;
  453. struct minix2_inode * raw_inode;
  454. struct minix_inode_info *minix_inode = minix_i(inode);
  455. int i;
  456. raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
  457. if (!raw_inode)
  458. return NULL;
  459. raw_inode->i_mode = inode->i_mode;
  460. raw_inode->i_uid = fs_high2lowuid(inode->i_uid);
  461. raw_inode->i_gid = fs_high2lowgid(inode->i_gid);
  462. raw_inode->i_nlinks = inode->i_nlink;
  463. raw_inode->i_size = inode->i_size;
  464. raw_inode->i_mtime = inode->i_mtime.tv_sec;
  465. raw_inode->i_atime = inode->i_atime.tv_sec;
  466. raw_inode->i_ctime = inode->i_ctime.tv_sec;
  467. if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  468. raw_inode->i_zone[0] = old_encode_dev(inode->i_rdev);
  469. else for (i = 0; i < 10; i++)
  470. raw_inode->i_zone[i] = minix_inode->u.i2_data[i];
  471. mark_buffer_dirty(bh);
  472. return bh;
  473. }
  474. static struct buffer_head *minix_update_inode(struct inode *inode)
  475. {
  476. if (INODE_VERSION(inode) == MINIX_V1)
  477. return V1_minix_update_inode(inode);
  478. else
  479. return V2_minix_update_inode(inode);
  480. }
  481. static int minix_write_inode(struct inode * inode, int wait)
  482. {
  483. brelse(minix_update_inode(inode));
  484. return 0;
  485. }
  486. int minix_sync_inode(struct inode * inode)
  487. {
  488. int err = 0;
  489. struct buffer_head *bh;
  490. bh = minix_update_inode(inode);
  491. if (bh && buffer_dirty(bh))
  492. {
  493. sync_dirty_buffer(bh);
  494. if (buffer_req(bh) && !buffer_uptodate(bh))
  495. {
  496. printk("IO error syncing minix inode [%s:%08lx]\n",
  497. inode->i_sb->s_id, inode->i_ino);
  498. err = -1;
  499. }
  500. }
  501. else if (!bh)
  502. err = -1;
  503. brelse (bh);
  504. return err;
  505. }
  506. int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
  507. {
  508. struct inode *dir = dentry->d_parent->d_inode;
  509. struct super_block *sb = dir->i_sb;
  510. generic_fillattr(dentry->d_inode, stat);
  511. if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
  512. stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
  513. else
  514. stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
  515. stat->blksize = sb->s_blocksize;
  516. return 0;
  517. }
  518. /*
  519. * The function that is called for file truncation.
  520. */
  521. void minix_truncate(struct inode * inode)
  522. {
  523. if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
  524. return;
  525. if (INODE_VERSION(inode) == MINIX_V1)
  526. V1_minix_truncate(inode);
  527. else
  528. V2_minix_truncate(inode);
  529. }
  530. static int minix_get_sb(struct file_system_type *fs_type,
  531. int flags, const char *dev_name, void *data, struct vfsmount *mnt)
  532. {
  533. return get_sb_bdev(fs_type, flags, dev_name, data, minix_fill_super,
  534. mnt);
  535. }
  536. static struct file_system_type minix_fs_type = {
  537. .owner = THIS_MODULE,
  538. .name = "minix",
  539. .get_sb = minix_get_sb,
  540. .kill_sb = kill_block_super,
  541. .fs_flags = FS_REQUIRES_DEV,
  542. };
  543. static int __init init_minix_fs(void)
  544. {
  545. int err = init_inodecache();
  546. if (err)
  547. goto out1;
  548. err = register_filesystem(&minix_fs_type);
  549. if (err)
  550. goto out;
  551. return 0;
  552. out:
  553. destroy_inodecache();
  554. out1:
  555. return err;
  556. }
  557. static void __exit exit_minix_fs(void)
  558. {
  559. unregister_filesystem(&minix_fs_type);
  560. destroy_inodecache();
  561. }
  562. module_init(init_minix_fs)
  563. module_exit(exit_minix_fs)
  564. MODULE_LICENSE("GPL");