amigaffs.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509
  1. /*
  2. * linux/fs/affs/amigaffs.c
  3. *
  4. * (c) 1996 Hans-Joachim Widmaier - Rewritten
  5. *
  6. * (C) 1993 Ray Burr - Amiga FFS filesystem.
  7. *
  8. * Please send bug reports to: hjw@zvw.de
  9. */
  10. #include "affs.h"
  11. extern struct timezone sys_tz;
  12. static char ErrorBuffer[256];
  13. /*
  14. * Functions for accessing Amiga-FFS structures.
  15. */
  16. /* Insert a header block bh into the directory dir
  17. * caller must hold AFFS_DIR->i_hash_lock!
  18. */
  19. int
  20. affs_insert_hash(struct inode *dir, struct buffer_head *bh)
  21. {
  22. struct super_block *sb = dir->i_sb;
  23. struct buffer_head *dir_bh;
  24. u32 ino, hash_ino;
  25. int offset;
  26. ino = bh->b_blocknr;
  27. offset = affs_hash_name(sb, AFFS_TAIL(sb, bh)->name + 1, AFFS_TAIL(sb, bh)->name[0]);
  28. pr_debug("AFFS: insert_hash(dir=%u, ino=%d)\n", (u32)dir->i_ino, ino);
  29. dir_bh = affs_bread(sb, dir->i_ino);
  30. if (!dir_bh)
  31. return -EIO;
  32. hash_ino = be32_to_cpu(AFFS_HEAD(dir_bh)->table[offset]);
  33. while (hash_ino) {
  34. affs_brelse(dir_bh);
  35. dir_bh = affs_bread(sb, hash_ino);
  36. if (!dir_bh)
  37. return -EIO;
  38. hash_ino = be32_to_cpu(AFFS_TAIL(sb, dir_bh)->hash_chain);
  39. }
  40. AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino);
  41. AFFS_TAIL(sb, bh)->hash_chain = 0;
  42. affs_fix_checksum(sb, bh);
  43. if (dir->i_ino == dir_bh->b_blocknr)
  44. AFFS_HEAD(dir_bh)->table[offset] = cpu_to_be32(ino);
  45. else
  46. AFFS_TAIL(sb, dir_bh)->hash_chain = cpu_to_be32(ino);
  47. affs_adjust_checksum(dir_bh, ino);
  48. mark_buffer_dirty_inode(dir_bh, dir);
  49. affs_brelse(dir_bh);
  50. dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
  51. dir->i_version++;
  52. mark_inode_dirty(dir);
  53. return 0;
  54. }
  55. /* Remove a header block from its directory.
  56. * caller must hold AFFS_DIR->i_hash_lock!
  57. */
  58. int
  59. affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh)
  60. {
  61. struct super_block *sb;
  62. struct buffer_head *bh;
  63. u32 rem_ino, hash_ino;
  64. __be32 ino;
  65. int offset, retval;
  66. sb = dir->i_sb;
  67. rem_ino = rem_bh->b_blocknr;
  68. offset = affs_hash_name(sb, AFFS_TAIL(sb, rem_bh)->name+1, AFFS_TAIL(sb, rem_bh)->name[0]);
  69. pr_debug("AFFS: remove_hash(dir=%d, ino=%d, hashval=%d)\n", (u32)dir->i_ino, rem_ino, offset);
  70. bh = affs_bread(sb, dir->i_ino);
  71. if (!bh)
  72. return -EIO;
  73. retval = -ENOENT;
  74. hash_ino = be32_to_cpu(AFFS_HEAD(bh)->table[offset]);
  75. while (hash_ino) {
  76. if (hash_ino == rem_ino) {
  77. ino = AFFS_TAIL(sb, rem_bh)->hash_chain;
  78. if (dir->i_ino == bh->b_blocknr)
  79. AFFS_HEAD(bh)->table[offset] = ino;
  80. else
  81. AFFS_TAIL(sb, bh)->hash_chain = ino;
  82. affs_adjust_checksum(bh, be32_to_cpu(ino) - hash_ino);
  83. mark_buffer_dirty_inode(bh, dir);
  84. AFFS_TAIL(sb, rem_bh)->parent = 0;
  85. retval = 0;
  86. break;
  87. }
  88. affs_brelse(bh);
  89. bh = affs_bread(sb, hash_ino);
  90. if (!bh)
  91. return -EIO;
  92. hash_ino = be32_to_cpu(AFFS_TAIL(sb, bh)->hash_chain);
  93. }
  94. affs_brelse(bh);
  95. dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
  96. dir->i_version++;
  97. mark_inode_dirty(dir);
  98. return retval;
  99. }
  100. static void
  101. affs_fix_dcache(struct dentry *dentry, u32 entry_ino)
  102. {
  103. struct inode *inode = dentry->d_inode;
  104. void *data = dentry->d_fsdata;
  105. struct list_head *head, *next;
  106. spin_lock(&dcache_lock);
  107. head = &inode->i_dentry;
  108. next = head->next;
  109. while (next != head) {
  110. dentry = list_entry(next, struct dentry, d_alias);
  111. if (entry_ino == (u32)(long)dentry->d_fsdata) {
  112. dentry->d_fsdata = data;
  113. break;
  114. }
  115. next = next->next;
  116. }
  117. spin_unlock(&dcache_lock);
  118. }
  119. /* Remove header from link chain */
  120. static int
  121. affs_remove_link(struct dentry *dentry)
  122. {
  123. struct inode *dir, *inode = dentry->d_inode;
  124. struct super_block *sb = inode->i_sb;
  125. struct buffer_head *bh = NULL, *link_bh = NULL;
  126. u32 link_ino, ino;
  127. int retval;
  128. pr_debug("AFFS: remove_link(key=%ld)\n", inode->i_ino);
  129. retval = -EIO;
  130. bh = affs_bread(sb, inode->i_ino);
  131. if (!bh)
  132. goto done;
  133. link_ino = (u32)(long)dentry->d_fsdata;
  134. if (inode->i_ino == link_ino) {
  135. /* we can't remove the head of the link, as its blocknr is still used as ino,
  136. * so we remove the block of the first link instead.
  137. */
  138. link_ino = be32_to_cpu(AFFS_TAIL(sb, bh)->link_chain);
  139. link_bh = affs_bread(sb, link_ino);
  140. if (!link_bh)
  141. goto done;
  142. dir = iget(sb, be32_to_cpu(AFFS_TAIL(sb, link_bh)->parent));
  143. if (!dir)
  144. goto done;
  145. affs_lock_dir(dir);
  146. affs_fix_dcache(dentry, link_ino);
  147. retval = affs_remove_hash(dir, link_bh);
  148. if (retval)
  149. goto done;
  150. mark_buffer_dirty_inode(link_bh, inode);
  151. memcpy(AFFS_TAIL(sb, bh)->name, AFFS_TAIL(sb, link_bh)->name, 32);
  152. retval = affs_insert_hash(dir, bh);
  153. if (retval)
  154. goto done;
  155. mark_buffer_dirty_inode(bh, inode);
  156. affs_unlock_dir(dir);
  157. iput(dir);
  158. } else {
  159. link_bh = affs_bread(sb, link_ino);
  160. if (!link_bh)
  161. goto done;
  162. }
  163. while ((ino = be32_to_cpu(AFFS_TAIL(sb, bh)->link_chain)) != 0) {
  164. if (ino == link_ino) {
  165. __be32 ino2 = AFFS_TAIL(sb, link_bh)->link_chain;
  166. AFFS_TAIL(sb, bh)->link_chain = ino2;
  167. affs_adjust_checksum(bh, be32_to_cpu(ino2) - link_ino);
  168. mark_buffer_dirty_inode(bh, inode);
  169. retval = 0;
  170. /* Fix the link count, if bh is a normal header block without links */
  171. switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
  172. case ST_LINKDIR:
  173. case ST_LINKFILE:
  174. break;
  175. default:
  176. if (!AFFS_TAIL(sb, bh)->link_chain)
  177. inode->i_nlink = 1;
  178. }
  179. affs_free_block(sb, link_ino);
  180. goto done;
  181. }
  182. affs_brelse(bh);
  183. bh = affs_bread(sb, ino);
  184. if (!bh)
  185. goto done;
  186. }
  187. retval = -ENOENT;
  188. done:
  189. affs_brelse(link_bh);
  190. affs_brelse(bh);
  191. return retval;
  192. }
  193. static int
  194. affs_empty_dir(struct inode *inode)
  195. {
  196. struct super_block *sb = inode->i_sb;
  197. struct buffer_head *bh;
  198. int retval, size;
  199. retval = -EIO;
  200. bh = affs_bread(sb, inode->i_ino);
  201. if (!bh)
  202. goto done;
  203. retval = -ENOTEMPTY;
  204. for (size = AFFS_SB(sb)->s_hashsize - 1; size >= 0; size--)
  205. if (AFFS_HEAD(bh)->table[size])
  206. goto not_empty;
  207. retval = 0;
  208. not_empty:
  209. affs_brelse(bh);
  210. done:
  211. return retval;
  212. }
  213. /* Remove a filesystem object. If the object to be removed has
  214. * links to it, one of the links must be changed to inherit
  215. * the file or directory. As above, any inode will do.
  216. * The buffer will not be freed. If the header is a link, the
  217. * block will be marked as free.
  218. * This function returns a negative error number in case of
  219. * an error, else 0 if the inode is to be deleted or 1 if not.
  220. */
  221. int
  222. affs_remove_header(struct dentry *dentry)
  223. {
  224. struct super_block *sb;
  225. struct inode *inode, *dir;
  226. struct buffer_head *bh = NULL;
  227. int retval;
  228. dir = dentry->d_parent->d_inode;
  229. sb = dir->i_sb;
  230. retval = -ENOENT;
  231. inode = dentry->d_inode;
  232. if (!inode)
  233. goto done;
  234. pr_debug("AFFS: remove_header(key=%ld)\n", inode->i_ino);
  235. retval = -EIO;
  236. bh = affs_bread(sb, (u32)(long)dentry->d_fsdata);
  237. if (!bh)
  238. goto done;
  239. affs_lock_link(inode);
  240. affs_lock_dir(dir);
  241. switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) {
  242. case ST_USERDIR:
  243. /* if we ever want to support links to dirs
  244. * i_hash_lock of the inode must only be
  245. * taken after some checks
  246. */
  247. affs_lock_dir(inode);
  248. retval = affs_empty_dir(inode);
  249. affs_unlock_dir(inode);
  250. if (retval)
  251. goto done_unlock;
  252. break;
  253. default:
  254. break;
  255. }
  256. retval = affs_remove_hash(dir, bh);
  257. if (retval)
  258. goto done_unlock;
  259. mark_buffer_dirty_inode(bh, inode);
  260. affs_unlock_dir(dir);
  261. if (inode->i_nlink > 1)
  262. retval = affs_remove_link(dentry);
  263. else
  264. inode->i_nlink = 0;
  265. affs_unlock_link(inode);
  266. inode->i_ctime = CURRENT_TIME_SEC;
  267. mark_inode_dirty(inode);
  268. done:
  269. affs_brelse(bh);
  270. return retval;
  271. done_unlock:
  272. affs_unlock_dir(dir);
  273. affs_unlock_link(inode);
  274. goto done;
  275. }
  276. /* Checksum a block, do various consistency checks and optionally return
  277. the blocks type number. DATA points to the block. If their pointers
  278. are non-null, *PTYPE and *STYPE are set to the primary and secondary
  279. block types respectively, *HASHSIZE is set to the size of the hashtable
  280. (which lets us calculate the block size).
  281. Returns non-zero if the block is not consistent. */
  282. u32
  283. affs_checksum_block(struct super_block *sb, struct buffer_head *bh)
  284. {
  285. __be32 *ptr = (__be32 *)bh->b_data;
  286. u32 sum;
  287. int bsize;
  288. sum = 0;
  289. for (bsize = sb->s_blocksize / sizeof(__be32); bsize > 0; bsize--)
  290. sum += be32_to_cpu(*ptr++);
  291. return sum;
  292. }
  293. /*
  294. * Calculate the checksum of a disk block and store it
  295. * at the indicated position.
  296. */
  297. void
  298. affs_fix_checksum(struct super_block *sb, struct buffer_head *bh)
  299. {
  300. int cnt = sb->s_blocksize / sizeof(__be32);
  301. __be32 *ptr = (__be32 *)bh->b_data;
  302. u32 checksum;
  303. __be32 *checksumptr;
  304. checksumptr = ptr + 5;
  305. *checksumptr = 0;
  306. for (checksum = 0; cnt > 0; ptr++, cnt--)
  307. checksum += be32_to_cpu(*ptr);
  308. *checksumptr = cpu_to_be32(-checksum);
  309. }
  310. void
  311. secs_to_datestamp(time_t secs, struct affs_date *ds)
  312. {
  313. u32 days;
  314. u32 minute;
  315. secs -= sys_tz.tz_minuteswest * 60 + ((8 * 365 + 2) * 24 * 60 * 60);
  316. if (secs < 0)
  317. secs = 0;
  318. days = secs / 86400;
  319. secs -= days * 86400;
  320. minute = secs / 60;
  321. secs -= minute * 60;
  322. ds->days = cpu_to_be32(days);
  323. ds->mins = cpu_to_be32(minute);
  324. ds->ticks = cpu_to_be32(secs * 50);
  325. }
  326. mode_t
  327. prot_to_mode(u32 prot)
  328. {
  329. int mode = 0;
  330. if (!(prot & FIBF_NOWRITE))
  331. mode |= S_IWUSR;
  332. if (!(prot & FIBF_NOREAD))
  333. mode |= S_IRUSR;
  334. if (!(prot & FIBF_NOEXECUTE))
  335. mode |= S_IXUSR;
  336. if (prot & FIBF_GRP_WRITE)
  337. mode |= S_IWGRP;
  338. if (prot & FIBF_GRP_READ)
  339. mode |= S_IRGRP;
  340. if (prot & FIBF_GRP_EXECUTE)
  341. mode |= S_IXGRP;
  342. if (prot & FIBF_OTR_WRITE)
  343. mode |= S_IWOTH;
  344. if (prot & FIBF_OTR_READ)
  345. mode |= S_IROTH;
  346. if (prot & FIBF_OTR_EXECUTE)
  347. mode |= S_IXOTH;
  348. return mode;
  349. }
  350. void
  351. mode_to_prot(struct inode *inode)
  352. {
  353. u32 prot = AFFS_I(inode)->i_protect;
  354. mode_t mode = inode->i_mode;
  355. if (!(mode & S_IXUSR))
  356. prot |= FIBF_NOEXECUTE;
  357. if (!(mode & S_IRUSR))
  358. prot |= FIBF_NOREAD;
  359. if (!(mode & S_IWUSR))
  360. prot |= FIBF_NOWRITE;
  361. if (mode & S_IXGRP)
  362. prot |= FIBF_GRP_EXECUTE;
  363. if (mode & S_IRGRP)
  364. prot |= FIBF_GRP_READ;
  365. if (mode & S_IWGRP)
  366. prot |= FIBF_GRP_WRITE;
  367. if (mode & S_IXOTH)
  368. prot |= FIBF_OTR_EXECUTE;
  369. if (mode & S_IROTH)
  370. prot |= FIBF_OTR_READ;
  371. if (mode & S_IWOTH)
  372. prot |= FIBF_OTR_WRITE;
  373. AFFS_I(inode)->i_protect = prot;
  374. }
  375. void
  376. affs_error(struct super_block *sb, const char *function, const char *fmt, ...)
  377. {
  378. va_list args;
  379. va_start(args,fmt);
  380. vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
  381. va_end(args);
  382. printk(KERN_CRIT "AFFS error (device %s): %s(): %s\n", sb->s_id,
  383. function,ErrorBuffer);
  384. if (!(sb->s_flags & MS_RDONLY))
  385. printk(KERN_WARNING "AFFS: Remounting filesystem read-only\n");
  386. sb->s_flags |= MS_RDONLY;
  387. }
  388. void
  389. affs_warning(struct super_block *sb, const char *function, const char *fmt, ...)
  390. {
  391. va_list args;
  392. va_start(args,fmt);
  393. vsnprintf(ErrorBuffer,sizeof(ErrorBuffer),fmt,args);
  394. va_end(args);
  395. printk(KERN_WARNING "AFFS warning (device %s): %s(): %s\n", sb->s_id,
  396. function,ErrorBuffer);
  397. }
  398. /* Check if the name is valid for a affs object. */
  399. int
  400. affs_check_name(const unsigned char *name, int len)
  401. {
  402. int i;
  403. if (len > 30)
  404. #ifdef AFFS_NO_TRUNCATE
  405. return -ENAMETOOLONG;
  406. #else
  407. len = 30;
  408. #endif
  409. for (i = 0; i < len; i++) {
  410. if (name[i] < ' ' || name[i] == ':'
  411. || (name[i] > 0x7e && name[i] < 0xa0))
  412. return -EINVAL;
  413. }
  414. return 0;
  415. }
  416. /* This function copies name to bstr, with at most 30
  417. * characters length. The bstr will be prepended by
  418. * a length byte.
  419. * NOTE: The name will must be already checked by
  420. * affs_check_name()!
  421. */
  422. int
  423. affs_copy_name(unsigned char *bstr, struct dentry *dentry)
  424. {
  425. int len = min(dentry->d_name.len, 30u);
  426. *bstr++ = len;
  427. memcpy(bstr, dentry->d_name.name, len);
  428. return len;
  429. }