vxfs_inode.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2000-2001 Christoph Hellwig.
  4. * Copyright (c) 2016 Krzysztof Blaszkowski
  5. */
  6. /*
  7. * Veritas filesystem driver - inode routines.
  8. */
  9. #include <linux/fs.h>
  10. #include <linux/buffer_head.h>
  11. #include <linux/pagemap.h>
  12. #include <linux/kernel.h>
  13. #include <linux/slab.h>
  14. #include <linux/namei.h>
  15. #include "vxfs.h"
  16. #include "vxfs_inode.h"
  17. #include "vxfs_extern.h"
  18. #ifdef DIAGNOSTIC
  19. /*
  20. * Dump inode contents (partially).
  21. */
  22. void
  23. vxfs_dumpi(struct vxfs_inode_info *vip, ino_t ino)
  24. {
  25. printk(KERN_DEBUG "\n\n");
  26. if (ino)
  27. printk(KERN_DEBUG "dumping vxfs inode %ld\n", ino);
  28. else
  29. printk(KERN_DEBUG "dumping unknown vxfs inode\n");
  30. printk(KERN_DEBUG "---------------------------\n");
  31. printk(KERN_DEBUG "mode is %x\n", vip->vii_mode);
  32. printk(KERN_DEBUG "nlink:%u, uid:%u, gid:%u\n",
  33. vip->vii_nlink, vip->vii_uid, vip->vii_gid);
  34. printk(KERN_DEBUG "size:%Lx, blocks:%u\n",
  35. vip->vii_size, vip->vii_blocks);
  36. printk(KERN_DEBUG "orgtype:%u\n", vip->vii_orgtype);
  37. }
  38. #endif
  39. /**
  40. * vxfs_transmod - mode for a VxFS inode
  41. * @vip: VxFS inode
  42. *
  43. * Description:
  44. * vxfs_transmod returns a Linux mode_t for a given
  45. * VxFS inode structure.
  46. */
  47. static __inline__ umode_t
  48. vxfs_transmod(struct vxfs_inode_info *vip)
  49. {
  50. umode_t ret = vip->vii_mode & ~VXFS_TYPE_MASK;
  51. if (VXFS_ISFIFO(vip))
  52. ret |= S_IFIFO;
  53. if (VXFS_ISCHR(vip))
  54. ret |= S_IFCHR;
  55. if (VXFS_ISDIR(vip))
  56. ret |= S_IFDIR;
  57. if (VXFS_ISBLK(vip))
  58. ret |= S_IFBLK;
  59. if (VXFS_ISLNK(vip))
  60. ret |= S_IFLNK;
  61. if (VXFS_ISREG(vip))
  62. ret |= S_IFREG;
  63. if (VXFS_ISSOC(vip))
  64. ret |= S_IFSOCK;
  65. return (ret);
  66. }
  67. static inline void dip2vip_cpy(struct vxfs_sb_info *sbi,
  68. struct vxfs_inode_info *vip, struct vxfs_dinode *dip)
  69. {
  70. struct inode *inode = &vip->vfs_inode;
  71. vip->vii_mode = fs32_to_cpu(sbi, dip->vdi_mode);
  72. vip->vii_nlink = fs32_to_cpu(sbi, dip->vdi_nlink);
  73. vip->vii_uid = fs32_to_cpu(sbi, dip->vdi_uid);
  74. vip->vii_gid = fs32_to_cpu(sbi, dip->vdi_gid);
  75. vip->vii_size = fs64_to_cpu(sbi, dip->vdi_size);
  76. vip->vii_atime = fs32_to_cpu(sbi, dip->vdi_atime);
  77. vip->vii_autime = fs32_to_cpu(sbi, dip->vdi_autime);
  78. vip->vii_mtime = fs32_to_cpu(sbi, dip->vdi_mtime);
  79. vip->vii_mutime = fs32_to_cpu(sbi, dip->vdi_mutime);
  80. vip->vii_ctime = fs32_to_cpu(sbi, dip->vdi_ctime);
  81. vip->vii_cutime = fs32_to_cpu(sbi, dip->vdi_cutime);
  82. vip->vii_orgtype = dip->vdi_orgtype;
  83. vip->vii_blocks = fs32_to_cpu(sbi, dip->vdi_blocks);
  84. vip->vii_gen = fs32_to_cpu(sbi, dip->vdi_gen);
  85. if (VXFS_ISDIR(vip))
  86. vip->vii_dotdot = fs32_to_cpu(sbi, dip->vdi_dotdot);
  87. else if (!VXFS_ISREG(vip) && !VXFS_ISLNK(vip))
  88. vip->vii_rdev = fs32_to_cpu(sbi, dip->vdi_rdev);
  89. /* don't endian swap the fields that differ by orgtype */
  90. memcpy(&vip->vii_org, &dip->vdi_org, sizeof(vip->vii_org));
  91. inode->i_mode = vxfs_transmod(vip);
  92. i_uid_write(inode, (uid_t)vip->vii_uid);
  93. i_gid_write(inode, (gid_t)vip->vii_gid);
  94. set_nlink(inode, vip->vii_nlink);
  95. inode->i_size = vip->vii_size;
  96. inode->i_atime.tv_sec = vip->vii_atime;
  97. inode->i_ctime.tv_sec = vip->vii_ctime;
  98. inode->i_mtime.tv_sec = vip->vii_mtime;
  99. inode->i_atime.tv_nsec = 0;
  100. inode->i_ctime.tv_nsec = 0;
  101. inode->i_mtime.tv_nsec = 0;
  102. inode->i_blocks = vip->vii_blocks;
  103. inode->i_generation = vip->vii_gen;
  104. }
  105. /**
  106. * vxfs_blkiget - find inode based on extent #
  107. * @sbp: superblock of the filesystem we search in
  108. * @extent: number of the extent to search
  109. * @ino: inode number to search
  110. *
  111. * Description:
  112. * vxfs_blkiget searches inode @ino in the filesystem described by
  113. * @sbp in the extent @extent.
  114. * Returns the matching VxFS inode on success, else a NULL pointer.
  115. *
  116. * NOTE:
  117. * While __vxfs_iget uses the pagecache vxfs_blkiget uses the
  118. * buffercache. This function should not be used outside the
  119. * read_super() method, otherwise the data may be incoherent.
  120. */
  121. struct inode *
  122. vxfs_blkiget(struct super_block *sbp, u_long extent, ino_t ino)
  123. {
  124. struct buffer_head *bp;
  125. struct inode *inode;
  126. u_long block, offset;
  127. inode = new_inode(sbp);
  128. if (!inode)
  129. return NULL;
  130. inode->i_ino = get_next_ino();
  131. block = extent + ((ino * VXFS_ISIZE) / sbp->s_blocksize);
  132. offset = ((ino % (sbp->s_blocksize / VXFS_ISIZE)) * VXFS_ISIZE);
  133. bp = sb_bread(sbp, block);
  134. if (bp && buffer_mapped(bp)) {
  135. struct vxfs_inode_info *vip = VXFS_INO(inode);
  136. struct vxfs_dinode *dip;
  137. dip = (struct vxfs_dinode *)(bp->b_data + offset);
  138. dip2vip_cpy(VXFS_SBI(sbp), vip, dip);
  139. vip->vfs_inode.i_mapping->a_ops = &vxfs_aops;
  140. #ifdef DIAGNOSTIC
  141. vxfs_dumpi(vip, ino);
  142. #endif
  143. brelse(bp);
  144. return inode;
  145. }
  146. printk(KERN_WARNING "vxfs: unable to read block %ld\n", block);
  147. brelse(bp);
  148. iput(inode);
  149. return NULL;
  150. }
  151. /**
  152. * __vxfs_iget - generic find inode facility
  153. * @ilistp: inode list
  154. * @vip: VxFS inode to fill in
  155. * @ino: inode number
  156. *
  157. * Description:
  158. * Search the for inode number @ino in the filesystem
  159. * described by @sbp. Use the specified inode table (@ilistp).
  160. * Returns the matching inode on success, else an error code.
  161. */
  162. static int
  163. __vxfs_iget(struct inode *ilistp, struct vxfs_inode_info *vip, ino_t ino)
  164. {
  165. struct page *pp;
  166. u_long offset;
  167. offset = (ino % (PAGE_SIZE / VXFS_ISIZE)) * VXFS_ISIZE;
  168. pp = vxfs_get_page(ilistp->i_mapping, ino * VXFS_ISIZE / PAGE_SIZE);
  169. if (!IS_ERR(pp)) {
  170. struct vxfs_dinode *dip;
  171. caddr_t kaddr = (char *)page_address(pp);
  172. dip = (struct vxfs_dinode *)(kaddr + offset);
  173. dip2vip_cpy(VXFS_SBI(ilistp->i_sb), vip, dip);
  174. vip->vfs_inode.i_mapping->a_ops = &vxfs_aops;
  175. #ifdef DIAGNOSTIC
  176. vxfs_dumpi(vip, ino);
  177. #endif
  178. vxfs_put_page(pp);
  179. return 0;
  180. }
  181. printk(KERN_WARNING "vxfs: error on page 0x%p for inode %ld\n",
  182. pp, (unsigned long)ino);
  183. return PTR_ERR(pp);
  184. }
  185. /**
  186. * vxfs_stiget - find inode using the structural inode list
  187. * @sbp: VFS superblock
  188. * @ino: inode #
  189. *
  190. * Description:
  191. * Find inode @ino in the filesystem described by @sbp using
  192. * the structural inode list.
  193. * Returns the matching inode on success, else a NULL pointer.
  194. */
  195. struct inode *
  196. vxfs_stiget(struct super_block *sbp, ino_t ino)
  197. {
  198. struct inode *inode;
  199. int error;
  200. inode = new_inode(sbp);
  201. if (!inode)
  202. return NULL;
  203. inode->i_ino = get_next_ino();
  204. error = __vxfs_iget(VXFS_SBI(sbp)->vsi_stilist, VXFS_INO(inode), ino);
  205. if (error) {
  206. iput(inode);
  207. return NULL;
  208. }
  209. return inode;
  210. }
  211. /**
  212. * vxfs_iget - get an inode
  213. * @sbp: the superblock to get the inode for
  214. * @ino: the number of the inode to get
  215. *
  216. * Description:
  217. * vxfs_read_inode creates an inode, reads the disk inode for @ino and fills
  218. * in all relevant fields in the new inode.
  219. */
  220. struct inode *
  221. vxfs_iget(struct super_block *sbp, ino_t ino)
  222. {
  223. struct vxfs_inode_info *vip;
  224. const struct address_space_operations *aops;
  225. struct inode *ip;
  226. int error;
  227. ip = iget_locked(sbp, ino);
  228. if (!ip)
  229. return ERR_PTR(-ENOMEM);
  230. if (!(ip->i_state & I_NEW))
  231. return ip;
  232. vip = VXFS_INO(ip);
  233. error = __vxfs_iget(VXFS_SBI(sbp)->vsi_ilist, vip, ino);
  234. if (error) {
  235. iget_failed(ip);
  236. return ERR_PTR(error);
  237. }
  238. if (VXFS_ISIMMED(vip))
  239. aops = &vxfs_immed_aops;
  240. else
  241. aops = &vxfs_aops;
  242. if (S_ISREG(ip->i_mode)) {
  243. ip->i_fop = &generic_ro_fops;
  244. ip->i_mapping->a_ops = aops;
  245. } else if (S_ISDIR(ip->i_mode)) {
  246. ip->i_op = &vxfs_dir_inode_ops;
  247. ip->i_fop = &vxfs_dir_operations;
  248. ip->i_mapping->a_ops = aops;
  249. } else if (S_ISLNK(ip->i_mode)) {
  250. if (!VXFS_ISIMMED(vip)) {
  251. ip->i_op = &page_symlink_inode_operations;
  252. inode_nohighmem(ip);
  253. ip->i_mapping->a_ops = &vxfs_aops;
  254. } else {
  255. ip->i_op = &simple_symlink_inode_operations;
  256. ip->i_link = vip->vii_immed.vi_immed;
  257. nd_terminate_link(ip->i_link, ip->i_size,
  258. sizeof(vip->vii_immed.vi_immed) - 1);
  259. }
  260. } else
  261. init_special_inode(ip, ip->i_mode, old_decode_dev(vip->vii_rdev));
  262. unlock_new_inode(ip);
  263. return ip;
  264. }
  265. /**
  266. * vxfs_evict_inode - remove inode from main memory
  267. * @ip: inode to discard.
  268. *
  269. * Description:
  270. * vxfs_evict_inode() is called on the final iput and frees the private
  271. * inode area.
  272. */
  273. void
  274. vxfs_evict_inode(struct inode *ip)
  275. {
  276. truncate_inode_pages_final(&ip->i_data);
  277. clear_inode(ip);
  278. }