inode.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/affs/inode.c
  4. *
  5. * (c) 1996 Hans-Joachim Widmaier - Rewritten
  6. *
  7. * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem.
  8. *
  9. * (C) 1992 Eric Youngdale Modified for ISO9660 filesystem.
  10. *
  11. * (C) 1991 Linus Torvalds - minix filesystem
  12. */
  13. #include <linux/sched.h>
  14. #include <linux/cred.h>
  15. #include <linux/gfp.h>
  16. #include "affs.h"
  17. struct inode *affs_iget(struct super_block *sb, unsigned long ino)
  18. {
  19. struct affs_sb_info *sbi = AFFS_SB(sb);
  20. struct buffer_head *bh;
  21. struct affs_tail *tail;
  22. struct inode *inode;
  23. u32 block;
  24. u32 size;
  25. u32 prot;
  26. u16 id;
  27. inode = iget_locked(sb, ino);
  28. if (!inode)
  29. return ERR_PTR(-ENOMEM);
  30. if (!(inode->i_state & I_NEW))
  31. return inode;
  32. pr_debug("affs_iget(%lu)\n", inode->i_ino);
  33. block = inode->i_ino;
  34. bh = affs_bread(sb, block);
  35. if (!bh) {
  36. affs_warning(sb, "read_inode", "Cannot read block %d", block);
  37. goto bad_inode;
  38. }
  39. if (affs_checksum_block(sb, bh) || be32_to_cpu(AFFS_HEAD(bh)->ptype) != T_SHORT) {
  40. affs_warning(sb,"read_inode",
  41. "Checksum or type (ptype=%d) error on inode %d",
  42. AFFS_HEAD(bh)->ptype, block);
  43. goto bad_inode;
  44. }
  45. tail = AFFS_TAIL(sb, bh);
  46. prot = be32_to_cpu(tail->protect);
  47. inode->i_size = 0;
  48. set_nlink(inode, 1);
  49. inode->i_mode = 0;
  50. AFFS_I(inode)->i_extcnt = 1;
  51. AFFS_I(inode)->i_ext_last = ~1;
  52. AFFS_I(inode)->i_protect = prot;
  53. atomic_set(&AFFS_I(inode)->i_opencnt, 0);
  54. AFFS_I(inode)->i_blkcnt = 0;
  55. AFFS_I(inode)->i_lc = NULL;
  56. AFFS_I(inode)->i_lc_size = 0;
  57. AFFS_I(inode)->i_lc_shift = 0;
  58. AFFS_I(inode)->i_lc_mask = 0;
  59. AFFS_I(inode)->i_ac = NULL;
  60. AFFS_I(inode)->i_ext_bh = NULL;
  61. AFFS_I(inode)->mmu_private = 0;
  62. AFFS_I(inode)->i_lastalloc = 0;
  63. AFFS_I(inode)->i_pa_cnt = 0;
  64. if (affs_test_opt(sbi->s_flags, SF_SETMODE))
  65. inode->i_mode = sbi->s_mode;
  66. else
  67. inode->i_mode = affs_prot_to_mode(prot);
  68. id = be16_to_cpu(tail->uid);
  69. if (id == 0 || affs_test_opt(sbi->s_flags, SF_SETUID))
  70. inode->i_uid = sbi->s_uid;
  71. else if (id == 0xFFFF && affs_test_opt(sbi->s_flags, SF_MUFS))
  72. i_uid_write(inode, 0);
  73. else
  74. i_uid_write(inode, id);
  75. id = be16_to_cpu(tail->gid);
  76. if (id == 0 || affs_test_opt(sbi->s_flags, SF_SETGID))
  77. inode->i_gid = sbi->s_gid;
  78. else if (id == 0xFFFF && affs_test_opt(sbi->s_flags, SF_MUFS))
  79. i_gid_write(inode, 0);
  80. else
  81. i_gid_write(inode, id);
  82. switch (be32_to_cpu(tail->stype)) {
  83. case ST_ROOT:
  84. inode->i_uid = sbi->s_uid;
  85. inode->i_gid = sbi->s_gid;
  86. fallthrough;
  87. case ST_USERDIR:
  88. if (be32_to_cpu(tail->stype) == ST_USERDIR ||
  89. affs_test_opt(sbi->s_flags, SF_SETMODE)) {
  90. if (inode->i_mode & S_IRUSR)
  91. inode->i_mode |= S_IXUSR;
  92. if (inode->i_mode & S_IRGRP)
  93. inode->i_mode |= S_IXGRP;
  94. if (inode->i_mode & S_IROTH)
  95. inode->i_mode |= S_IXOTH;
  96. inode->i_mode |= S_IFDIR;
  97. } else
  98. inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
  99. /* Maybe it should be controlled by mount parameter? */
  100. //inode->i_mode |= S_ISVTX;
  101. inode->i_op = &affs_dir_inode_operations;
  102. inode->i_fop = &affs_dir_operations;
  103. break;
  104. case ST_LINKDIR:
  105. #if 0
  106. affs_warning(sb, "read_inode", "inode is LINKDIR");
  107. goto bad_inode;
  108. #else
  109. inode->i_mode |= S_IFDIR;
  110. /* ... and leave ->i_op and ->i_fop pointing to empty */
  111. break;
  112. #endif
  113. case ST_LINKFILE:
  114. affs_warning(sb, "read_inode", "inode is LINKFILE");
  115. goto bad_inode;
  116. case ST_FILE:
  117. size = be32_to_cpu(tail->size);
  118. inode->i_mode |= S_IFREG;
  119. AFFS_I(inode)->mmu_private = inode->i_size = size;
  120. if (inode->i_size) {
  121. AFFS_I(inode)->i_blkcnt = (size - 1) /
  122. sbi->s_data_blksize + 1;
  123. AFFS_I(inode)->i_extcnt = (AFFS_I(inode)->i_blkcnt - 1) /
  124. sbi->s_hashsize + 1;
  125. }
  126. if (tail->link_chain)
  127. set_nlink(inode, 2);
  128. inode->i_mapping->a_ops = affs_test_opt(sbi->s_flags, SF_OFS) ?
  129. &affs_aops_ofs : &affs_aops;
  130. inode->i_op = &affs_file_inode_operations;
  131. inode->i_fop = &affs_file_operations;
  132. break;
  133. case ST_SOFTLINK:
  134. inode->i_size = strlen((char *)AFFS_HEAD(bh)->table);
  135. inode->i_mode |= S_IFLNK;
  136. inode_nohighmem(inode);
  137. inode->i_op = &affs_symlink_inode_operations;
  138. inode->i_data.a_ops = &affs_symlink_aops;
  139. break;
  140. }
  141. inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec
  142. = (be32_to_cpu(tail->change.days) * 86400LL +
  143. be32_to_cpu(tail->change.mins) * 60 +
  144. be32_to_cpu(tail->change.ticks) / 50 +
  145. AFFS_EPOCH_DELTA) +
  146. sys_tz.tz_minuteswest * 60;
  147. inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_atime.tv_nsec = 0;
  148. affs_brelse(bh);
  149. unlock_new_inode(inode);
  150. return inode;
  151. bad_inode:
  152. affs_brelse(bh);
  153. iget_failed(inode);
  154. return ERR_PTR(-EIO);
  155. }
  156. int
  157. affs_write_inode(struct inode *inode, struct writeback_control *wbc)
  158. {
  159. struct super_block *sb = inode->i_sb;
  160. struct buffer_head *bh;
  161. struct affs_tail *tail;
  162. uid_t uid;
  163. gid_t gid;
  164. pr_debug("write_inode(%lu)\n", inode->i_ino);
  165. if (!inode->i_nlink)
  166. // possibly free block
  167. return 0;
  168. bh = affs_bread(sb, inode->i_ino);
  169. if (!bh) {
  170. affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino);
  171. return -EIO;
  172. }
  173. tail = AFFS_TAIL(sb, bh);
  174. if (tail->stype == cpu_to_be32(ST_ROOT)) {
  175. affs_secs_to_datestamp(inode->i_mtime.tv_sec,
  176. &AFFS_ROOT_TAIL(sb, bh)->root_change);
  177. } else {
  178. tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect);
  179. tail->size = cpu_to_be32(inode->i_size);
  180. affs_secs_to_datestamp(inode->i_mtime.tv_sec, &tail->change);
  181. if (!(inode->i_ino == AFFS_SB(sb)->s_root_block)) {
  182. uid = i_uid_read(inode);
  183. gid = i_gid_read(inode);
  184. if (affs_test_opt(AFFS_SB(sb)->s_flags, SF_MUFS)) {
  185. if (uid == 0 || uid == 0xFFFF)
  186. uid = uid ^ ~0;
  187. if (gid == 0 || gid == 0xFFFF)
  188. gid = gid ^ ~0;
  189. }
  190. if (!affs_test_opt(AFFS_SB(sb)->s_flags, SF_SETUID))
  191. tail->uid = cpu_to_be16(uid);
  192. if (!affs_test_opt(AFFS_SB(sb)->s_flags, SF_SETGID))
  193. tail->gid = cpu_to_be16(gid);
  194. }
  195. }
  196. affs_fix_checksum(sb, bh);
  197. mark_buffer_dirty_inode(bh, inode);
  198. affs_brelse(bh);
  199. affs_free_prealloc(inode);
  200. return 0;
  201. }
  202. int
  203. affs_notify_change(struct user_namespace *mnt_userns, struct dentry *dentry,
  204. struct iattr *attr)
  205. {
  206. struct inode *inode = d_inode(dentry);
  207. int error;
  208. pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
  209. error = setattr_prepare(&init_user_ns, dentry, attr);
  210. if (error)
  211. goto out;
  212. if (((attr->ia_valid & ATTR_UID) &&
  213. affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_SETUID)) ||
  214. ((attr->ia_valid & ATTR_GID) &&
  215. affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_SETGID)) ||
  216. ((attr->ia_valid & ATTR_MODE) &&
  217. (AFFS_SB(inode->i_sb)->s_flags &
  218. (AFFS_MOUNT_SF_SETMODE | AFFS_MOUNT_SF_IMMUTABLE)))) {
  219. if (!affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_QUIET))
  220. error = -EPERM;
  221. goto out;
  222. }
  223. if ((attr->ia_valid & ATTR_SIZE) &&
  224. attr->ia_size != i_size_read(inode)) {
  225. error = inode_newsize_ok(inode, attr->ia_size);
  226. if (error)
  227. return error;
  228. truncate_setsize(inode, attr->ia_size);
  229. affs_truncate(inode);
  230. }
  231. setattr_copy(&init_user_ns, inode, attr);
  232. mark_inode_dirty(inode);
  233. if (attr->ia_valid & ATTR_MODE)
  234. affs_mode_to_prot(inode);
  235. out:
  236. return error;
  237. }
  238. void
  239. affs_evict_inode(struct inode *inode)
  240. {
  241. unsigned long cache_page;
  242. pr_debug("evict_inode(ino=%lu, nlink=%u)\n",
  243. inode->i_ino, inode->i_nlink);
  244. truncate_inode_pages_final(&inode->i_data);
  245. if (!inode->i_nlink) {
  246. inode->i_size = 0;
  247. affs_truncate(inode);
  248. }
  249. invalidate_inode_buffers(inode);
  250. clear_inode(inode);
  251. affs_free_prealloc(inode);
  252. cache_page = (unsigned long)AFFS_I(inode)->i_lc;
  253. if (cache_page) {
  254. pr_debug("freeing ext cache\n");
  255. AFFS_I(inode)->i_lc = NULL;
  256. AFFS_I(inode)->i_ac = NULL;
  257. free_page(cache_page);
  258. }
  259. affs_brelse(AFFS_I(inode)->i_ext_bh);
  260. AFFS_I(inode)->i_ext_last = ~1;
  261. AFFS_I(inode)->i_ext_bh = NULL;
  262. if (!inode->i_nlink)
  263. affs_free_block(inode->i_sb, inode->i_ino);
  264. }
  265. struct inode *
  266. affs_new_inode(struct inode *dir)
  267. {
  268. struct super_block *sb = dir->i_sb;
  269. struct inode *inode;
  270. u32 block;
  271. struct buffer_head *bh;
  272. if (!(inode = new_inode(sb)))
  273. goto err_inode;
  274. if (!(block = affs_alloc_block(dir, dir->i_ino)))
  275. goto err_block;
  276. bh = affs_getzeroblk(sb, block);
  277. if (!bh)
  278. goto err_bh;
  279. mark_buffer_dirty_inode(bh, inode);
  280. affs_brelse(bh);
  281. inode->i_uid = current_fsuid();
  282. inode->i_gid = current_fsgid();
  283. inode->i_ino = block;
  284. set_nlink(inode, 1);
  285. inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
  286. atomic_set(&AFFS_I(inode)->i_opencnt, 0);
  287. AFFS_I(inode)->i_blkcnt = 0;
  288. AFFS_I(inode)->i_lc = NULL;
  289. AFFS_I(inode)->i_lc_size = 0;
  290. AFFS_I(inode)->i_lc_shift = 0;
  291. AFFS_I(inode)->i_lc_mask = 0;
  292. AFFS_I(inode)->i_ac = NULL;
  293. AFFS_I(inode)->i_ext_bh = NULL;
  294. AFFS_I(inode)->mmu_private = 0;
  295. AFFS_I(inode)->i_protect = 0;
  296. AFFS_I(inode)->i_lastalloc = 0;
  297. AFFS_I(inode)->i_pa_cnt = 0;
  298. AFFS_I(inode)->i_extcnt = 1;
  299. AFFS_I(inode)->i_ext_last = ~1;
  300. insert_inode_hash(inode);
  301. return inode;
  302. err_bh:
  303. affs_free_block(sb, block);
  304. err_block:
  305. iput(inode);
  306. err_inode:
  307. return NULL;
  308. }
  309. /*
  310. * Add an entry to a directory. Create the header block
  311. * and insert it into the hash table.
  312. */
  313. int
  314. affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type)
  315. {
  316. struct super_block *sb = dir->i_sb;
  317. struct buffer_head *inode_bh = NULL;
  318. struct buffer_head *bh;
  319. u32 block = 0;
  320. int retval;
  321. pr_debug("%s(dir=%lu, inode=%lu, \"%pd\", type=%d)\n", __func__,
  322. dir->i_ino, inode->i_ino, dentry, type);
  323. retval = -EIO;
  324. bh = affs_bread(sb, inode->i_ino);
  325. if (!bh)
  326. goto done;
  327. affs_lock_link(inode);
  328. switch (type) {
  329. case ST_LINKFILE:
  330. case ST_LINKDIR:
  331. retval = -ENOSPC;
  332. block = affs_alloc_block(dir, dir->i_ino);
  333. if (!block)
  334. goto err;
  335. retval = -EIO;
  336. inode_bh = bh;
  337. bh = affs_getzeroblk(sb, block);
  338. if (!bh)
  339. goto err;
  340. break;
  341. default:
  342. break;
  343. }
  344. AFFS_HEAD(bh)->ptype = cpu_to_be32(T_SHORT);
  345. AFFS_HEAD(bh)->key = cpu_to_be32(bh->b_blocknr);
  346. affs_copy_name(AFFS_TAIL(sb, bh)->name, dentry);
  347. AFFS_TAIL(sb, bh)->stype = cpu_to_be32(type);
  348. AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino);
  349. if (inode_bh) {
  350. __be32 chain;
  351. chain = AFFS_TAIL(sb, inode_bh)->link_chain;
  352. AFFS_TAIL(sb, bh)->original = cpu_to_be32(inode->i_ino);
  353. AFFS_TAIL(sb, bh)->link_chain = chain;
  354. AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block);
  355. affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));
  356. mark_buffer_dirty_inode(inode_bh, inode);
  357. set_nlink(inode, 2);
  358. ihold(inode);
  359. }
  360. affs_fix_checksum(sb, bh);
  361. mark_buffer_dirty_inode(bh, inode);
  362. dentry->d_fsdata = (void *)(long)bh->b_blocknr;
  363. affs_lock_dir(dir);
  364. retval = affs_insert_hash(dir, bh);
  365. mark_buffer_dirty_inode(bh, inode);
  366. affs_unlock_dir(dir);
  367. affs_unlock_link(inode);
  368. d_instantiate(dentry, inode);
  369. done:
  370. affs_brelse(inode_bh);
  371. affs_brelse(bh);
  372. return retval;
  373. err:
  374. if (block)
  375. affs_free_block(sb, block);
  376. affs_unlock_link(inode);
  377. goto done;
  378. }