inode.c 10 KB

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