inode.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/adfs/inode.c
  4. *
  5. * Copyright (C) 1997-1999 Russell King
  6. */
  7. #include <linux/buffer_head.h>
  8. #include <linux/writeback.h>
  9. #include "adfs.h"
  10. /*
  11. * Lookup/Create a block at offset 'block' into 'inode'. We currently do
  12. * not support creation of new blocks, so we return -EIO for this case.
  13. */
  14. static int
  15. adfs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh,
  16. int create)
  17. {
  18. if (!create) {
  19. if (block >= inode->i_blocks)
  20. goto abort_toobig;
  21. block = __adfs_block_map(inode->i_sb, ADFS_I(inode)->indaddr,
  22. block);
  23. if (block)
  24. map_bh(bh, inode->i_sb, block);
  25. return 0;
  26. }
  27. /* don't support allocation of blocks yet */
  28. return -EIO;
  29. abort_toobig:
  30. return 0;
  31. }
  32. static int adfs_writepage(struct page *page, struct writeback_control *wbc)
  33. {
  34. return block_write_full_page(page, adfs_get_block, wbc);
  35. }
  36. static int adfs_read_folio(struct file *file, struct folio *folio)
  37. {
  38. return block_read_full_folio(folio, adfs_get_block);
  39. }
  40. static void adfs_write_failed(struct address_space *mapping, loff_t to)
  41. {
  42. struct inode *inode = mapping->host;
  43. if (to > inode->i_size)
  44. truncate_pagecache(inode, inode->i_size);
  45. }
  46. static int adfs_write_begin(struct file *file, struct address_space *mapping,
  47. loff_t pos, unsigned len,
  48. struct page **pagep, void **fsdata)
  49. {
  50. int ret;
  51. *pagep = NULL;
  52. ret = cont_write_begin(file, mapping, pos, len, pagep, fsdata,
  53. adfs_get_block,
  54. &ADFS_I(mapping->host)->mmu_private);
  55. if (unlikely(ret))
  56. adfs_write_failed(mapping, pos + len);
  57. return ret;
  58. }
  59. static sector_t _adfs_bmap(struct address_space *mapping, sector_t block)
  60. {
  61. return generic_block_bmap(mapping, block, adfs_get_block);
  62. }
  63. static const struct address_space_operations adfs_aops = {
  64. .dirty_folio = block_dirty_folio,
  65. .invalidate_folio = block_invalidate_folio,
  66. .read_folio = adfs_read_folio,
  67. .writepage = adfs_writepage,
  68. .write_begin = adfs_write_begin,
  69. .write_end = generic_write_end,
  70. .bmap = _adfs_bmap
  71. };
  72. /*
  73. * Convert ADFS attributes and filetype to Linux permission.
  74. */
  75. static umode_t
  76. adfs_atts2mode(struct super_block *sb, struct inode *inode)
  77. {
  78. unsigned int attr = ADFS_I(inode)->attr;
  79. umode_t mode, rmask;
  80. struct adfs_sb_info *asb = ADFS_SB(sb);
  81. if (attr & ADFS_NDA_DIRECTORY) {
  82. mode = S_IRUGO & asb->s_owner_mask;
  83. return S_IFDIR | S_IXUGO | mode;
  84. }
  85. switch (adfs_filetype(ADFS_I(inode)->loadaddr)) {
  86. case 0xfc0: /* LinkFS */
  87. return S_IFLNK|S_IRWXUGO;
  88. case 0xfe6: /* UnixExec */
  89. rmask = S_IRUGO | S_IXUGO;
  90. break;
  91. default:
  92. rmask = S_IRUGO;
  93. }
  94. mode = S_IFREG;
  95. if (attr & ADFS_NDA_OWNER_READ)
  96. mode |= rmask & asb->s_owner_mask;
  97. if (attr & ADFS_NDA_OWNER_WRITE)
  98. mode |= S_IWUGO & asb->s_owner_mask;
  99. if (attr & ADFS_NDA_PUBLIC_READ)
  100. mode |= rmask & asb->s_other_mask;
  101. if (attr & ADFS_NDA_PUBLIC_WRITE)
  102. mode |= S_IWUGO & asb->s_other_mask;
  103. return mode;
  104. }
  105. /*
  106. * Convert Linux permission to ADFS attribute. We try to do the reverse
  107. * of atts2mode, but there is not a 1:1 translation.
  108. */
  109. static int adfs_mode2atts(struct super_block *sb, struct inode *inode,
  110. umode_t ia_mode)
  111. {
  112. struct adfs_sb_info *asb = ADFS_SB(sb);
  113. umode_t mode;
  114. int attr;
  115. /* FIXME: should we be able to alter a link? */
  116. if (S_ISLNK(inode->i_mode))
  117. return ADFS_I(inode)->attr;
  118. /* Directories do not have read/write permissions on the media */
  119. if (S_ISDIR(inode->i_mode))
  120. return ADFS_NDA_DIRECTORY;
  121. attr = 0;
  122. mode = ia_mode & asb->s_owner_mask;
  123. if (mode & S_IRUGO)
  124. attr |= ADFS_NDA_OWNER_READ;
  125. if (mode & S_IWUGO)
  126. attr |= ADFS_NDA_OWNER_WRITE;
  127. mode = ia_mode & asb->s_other_mask;
  128. mode &= ~asb->s_owner_mask;
  129. if (mode & S_IRUGO)
  130. attr |= ADFS_NDA_PUBLIC_READ;
  131. if (mode & S_IWUGO)
  132. attr |= ADFS_NDA_PUBLIC_WRITE;
  133. return attr;
  134. }
  135. static const s64 nsec_unix_epoch_diff_risc_os_epoch = 2208988800000000000LL;
  136. /*
  137. * Convert an ADFS time to Unix time. ADFS has a 40-bit centi-second time
  138. * referenced to 1 Jan 1900 (til 2248) so we need to discard 2208988800 seconds
  139. * of time to convert from RISC OS epoch to Unix epoch.
  140. */
  141. static void
  142. adfs_adfs2unix_time(struct timespec64 *tv, struct inode *inode)
  143. {
  144. unsigned int high, low;
  145. /* 01 Jan 1970 00:00:00 (Unix epoch) as nanoseconds since
  146. * 01 Jan 1900 00:00:00 (RISC OS epoch)
  147. */
  148. s64 nsec;
  149. if (!adfs_inode_is_stamped(inode))
  150. goto cur_time;
  151. high = ADFS_I(inode)->loadaddr & 0xFF; /* top 8 bits of timestamp */
  152. low = ADFS_I(inode)->execaddr; /* bottom 32 bits of timestamp */
  153. /* convert 40-bit centi-seconds to 32-bit seconds
  154. * going via nanoseconds to retain precision
  155. */
  156. nsec = (((s64) high << 32) | (s64) low) * 10000000; /* cs to ns */
  157. /* Files dated pre 01 Jan 1970 00:00:00. */
  158. if (nsec < nsec_unix_epoch_diff_risc_os_epoch)
  159. goto too_early;
  160. /* convert from RISC OS to Unix epoch */
  161. nsec -= nsec_unix_epoch_diff_risc_os_epoch;
  162. *tv = ns_to_timespec64(nsec);
  163. return;
  164. cur_time:
  165. *tv = current_time(inode);
  166. return;
  167. too_early:
  168. tv->tv_sec = tv->tv_nsec = 0;
  169. return;
  170. }
  171. /* Convert an Unix time to ADFS time for an entry that is already stamped. */
  172. static void adfs_unix2adfs_time(struct inode *inode,
  173. const struct timespec64 *ts)
  174. {
  175. s64 cs, nsec = timespec64_to_ns(ts);
  176. /* convert from Unix to RISC OS epoch */
  177. nsec += nsec_unix_epoch_diff_risc_os_epoch;
  178. /* convert from nanoseconds to centiseconds */
  179. cs = div_s64(nsec, 10000000);
  180. cs = clamp_t(s64, cs, 0, 0xffffffffff);
  181. ADFS_I(inode)->loadaddr &= ~0xff;
  182. ADFS_I(inode)->loadaddr |= (cs >> 32) & 0xff;
  183. ADFS_I(inode)->execaddr = cs;
  184. }
  185. /*
  186. * Fill in the inode information from the object information.
  187. *
  188. * Note that this is an inode-less filesystem, so we can't use the inode
  189. * number to reference the metadata on the media. Instead, we use the
  190. * inode number to hold the object ID, which in turn will tell us where
  191. * the data is held. We also save the parent object ID, and with these
  192. * two, we can locate the metadata.
  193. *
  194. * This does mean that we rely on an objects parent remaining the same at
  195. * all times - we cannot cope with a cross-directory rename (yet).
  196. */
  197. struct inode *
  198. adfs_iget(struct super_block *sb, struct object_info *obj)
  199. {
  200. struct inode *inode;
  201. inode = new_inode(sb);
  202. if (!inode)
  203. goto out;
  204. inode->i_uid = ADFS_SB(sb)->s_uid;
  205. inode->i_gid = ADFS_SB(sb)->s_gid;
  206. inode->i_ino = obj->indaddr;
  207. inode->i_size = obj->size;
  208. set_nlink(inode, 2);
  209. inode->i_blocks = (inode->i_size + sb->s_blocksize - 1) >>
  210. sb->s_blocksize_bits;
  211. /*
  212. * we need to save the parent directory ID so that
  213. * write_inode can update the directory information
  214. * for this file. This will need special handling
  215. * for cross-directory renames.
  216. */
  217. ADFS_I(inode)->parent_id = obj->parent_id;
  218. ADFS_I(inode)->indaddr = obj->indaddr;
  219. ADFS_I(inode)->loadaddr = obj->loadaddr;
  220. ADFS_I(inode)->execaddr = obj->execaddr;
  221. ADFS_I(inode)->attr = obj->attr;
  222. inode->i_mode = adfs_atts2mode(sb, inode);
  223. adfs_adfs2unix_time(&inode->i_mtime, inode);
  224. inode->i_atime = inode->i_mtime;
  225. inode->i_ctime = inode->i_mtime;
  226. if (S_ISDIR(inode->i_mode)) {
  227. inode->i_op = &adfs_dir_inode_operations;
  228. inode->i_fop = &adfs_dir_operations;
  229. } else if (S_ISREG(inode->i_mode)) {
  230. inode->i_op = &adfs_file_inode_operations;
  231. inode->i_fop = &adfs_file_operations;
  232. inode->i_mapping->a_ops = &adfs_aops;
  233. ADFS_I(inode)->mmu_private = inode->i_size;
  234. }
  235. inode_fake_hash(inode);
  236. out:
  237. return inode;
  238. }
  239. /*
  240. * Validate and convert a changed access mode/time to their ADFS equivalents.
  241. * adfs_write_inode will actually write the information back to the directory
  242. * later.
  243. */
  244. int
  245. adfs_notify_change(struct user_namespace *mnt_userns, struct dentry *dentry,
  246. struct iattr *attr)
  247. {
  248. struct inode *inode = d_inode(dentry);
  249. struct super_block *sb = inode->i_sb;
  250. unsigned int ia_valid = attr->ia_valid;
  251. int error;
  252. error = setattr_prepare(&init_user_ns, dentry, attr);
  253. /*
  254. * we can't change the UID or GID of any file -
  255. * we have a global UID/GID in the superblock
  256. */
  257. if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, ADFS_SB(sb)->s_uid)) ||
  258. (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, ADFS_SB(sb)->s_gid)))
  259. error = -EPERM;
  260. if (error)
  261. goto out;
  262. /* XXX: this is missing some actual on-disk truncation.. */
  263. if (ia_valid & ATTR_SIZE)
  264. truncate_setsize(inode, attr->ia_size);
  265. if (ia_valid & ATTR_MTIME && adfs_inode_is_stamped(inode)) {
  266. adfs_unix2adfs_time(inode, &attr->ia_mtime);
  267. adfs_adfs2unix_time(&inode->i_mtime, inode);
  268. }
  269. /*
  270. * FIXME: should we make these == to i_mtime since we don't
  271. * have the ability to represent them in our filesystem?
  272. */
  273. if (ia_valid & ATTR_ATIME)
  274. inode->i_atime = attr->ia_atime;
  275. if (ia_valid & ATTR_CTIME)
  276. inode->i_ctime = attr->ia_ctime;
  277. if (ia_valid & ATTR_MODE) {
  278. ADFS_I(inode)->attr = adfs_mode2atts(sb, inode, attr->ia_mode);
  279. inode->i_mode = adfs_atts2mode(sb, inode);
  280. }
  281. /*
  282. * FIXME: should we be marking this inode dirty even if
  283. * we don't have any metadata to write back?
  284. */
  285. if (ia_valid & (ATTR_SIZE | ATTR_MTIME | ATTR_MODE))
  286. mark_inode_dirty(inode);
  287. out:
  288. return error;
  289. }
  290. /*
  291. * write an existing inode back to the directory, and therefore the disk.
  292. * The adfs-specific inode data has already been updated by
  293. * adfs_notify_change()
  294. */
  295. int adfs_write_inode(struct inode *inode, struct writeback_control *wbc)
  296. {
  297. struct super_block *sb = inode->i_sb;
  298. struct object_info obj;
  299. obj.indaddr = ADFS_I(inode)->indaddr;
  300. obj.name_len = 0;
  301. obj.parent_id = ADFS_I(inode)->parent_id;
  302. obj.loadaddr = ADFS_I(inode)->loadaddr;
  303. obj.execaddr = ADFS_I(inode)->execaddr;
  304. obj.attr = ADFS_I(inode)->attr;
  305. obj.size = inode->i_size;
  306. return adfs_dir_update(sb, &obj, wbc->sync_mode == WB_SYNC_ALL);
  307. }