dir_f.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460
  1. /*
  2. * linux/fs/adfs/dir_f.c
  3. *
  4. * Copyright (C) 1997-1999 Russell King
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License version 2 as
  8. * published by the Free Software Foundation.
  9. *
  10. * E and F format directory handling
  11. */
  12. #include <linux/errno.h>
  13. #include <linux/fs.h>
  14. #include <linux/adfs_fs.h>
  15. #include <linux/time.h>
  16. #include <linux/stat.h>
  17. #include <linux/spinlock.h>
  18. #include <linux/buffer_head.h>
  19. #include <linux/string.h>
  20. #include "adfs.h"
  21. #include "dir_f.h"
  22. static void adfs_f_free(struct adfs_dir *dir);
  23. /*
  24. * Read an (unaligned) value of length 1..4 bytes
  25. */
  26. static inline unsigned int adfs_readval(unsigned char *p, int len)
  27. {
  28. unsigned int val = 0;
  29. switch (len) {
  30. case 4: val |= p[3] << 24;
  31. case 3: val |= p[2] << 16;
  32. case 2: val |= p[1] << 8;
  33. default: val |= p[0];
  34. }
  35. return val;
  36. }
  37. static inline void adfs_writeval(unsigned char *p, int len, unsigned int val)
  38. {
  39. switch (len) {
  40. case 4: p[3] = val >> 24;
  41. case 3: p[2] = val >> 16;
  42. case 2: p[1] = val >> 8;
  43. default: p[0] = val;
  44. }
  45. }
  46. static inline int adfs_readname(char *buf, char *ptr, int maxlen)
  47. {
  48. char *old_buf = buf;
  49. while ((unsigned char)*ptr >= ' ' && maxlen--) {
  50. if (*ptr == '/')
  51. *buf++ = '.';
  52. else
  53. *buf++ = *ptr;
  54. ptr++;
  55. }
  56. *buf = '\0';
  57. return buf - old_buf;
  58. }
  59. #define ror13(v) ((v >> 13) | (v << 19))
  60. #define dir_u8(idx) \
  61. ({ int _buf = idx >> blocksize_bits; \
  62. int _off = idx - (_buf << blocksize_bits);\
  63. *(u8 *)(bh[_buf]->b_data + _off); \
  64. })
  65. #define dir_u32(idx) \
  66. ({ int _buf = idx >> blocksize_bits; \
  67. int _off = idx - (_buf << blocksize_bits);\
  68. *(__le32 *)(bh[_buf]->b_data + _off); \
  69. })
  70. #define bufoff(_bh,_idx) \
  71. ({ int _buf = _idx >> blocksize_bits; \
  72. int _off = _idx - (_buf << blocksize_bits);\
  73. (u8 *)(_bh[_buf]->b_data + _off); \
  74. })
  75. /*
  76. * There are some algorithms that are nice in
  77. * assembler, but a bitch in C... This is one
  78. * of them.
  79. */
  80. static u8
  81. adfs_dir_checkbyte(const struct adfs_dir *dir)
  82. {
  83. struct buffer_head * const *bh = dir->bh;
  84. const int blocksize_bits = dir->sb->s_blocksize_bits;
  85. union { __le32 *ptr32; u8 *ptr8; } ptr, end;
  86. u32 dircheck = 0;
  87. int last = 5 - 26;
  88. int i = 0;
  89. /*
  90. * Accumulate each word up to the last whole
  91. * word of the last directory entry. This
  92. * can spread across several buffer heads.
  93. */
  94. do {
  95. last += 26;
  96. do {
  97. dircheck = le32_to_cpu(dir_u32(i)) ^ ror13(dircheck);
  98. i += sizeof(u32);
  99. } while (i < (last & ~3));
  100. } while (dir_u8(last) != 0);
  101. /*
  102. * Accumulate the last few bytes. These
  103. * bytes will be within the same bh.
  104. */
  105. if (i != last) {
  106. ptr.ptr8 = bufoff(bh, i);
  107. end.ptr8 = ptr.ptr8 + last - i;
  108. do
  109. dircheck = *ptr.ptr8++ ^ ror13(dircheck);
  110. while (ptr.ptr8 < end.ptr8);
  111. }
  112. /*
  113. * The directory tail is in the final bh
  114. * Note that contary to the RISC OS PRMs,
  115. * the first few bytes are NOT included
  116. * in the check. All bytes are in the
  117. * same bh.
  118. */
  119. ptr.ptr8 = bufoff(bh, 2008);
  120. end.ptr8 = ptr.ptr8 + 36;
  121. do {
  122. __le32 v = *ptr.ptr32++;
  123. dircheck = le32_to_cpu(v) ^ ror13(dircheck);
  124. } while (ptr.ptr32 < end.ptr32);
  125. return (dircheck ^ (dircheck >> 8) ^ (dircheck >> 16) ^ (dircheck >> 24)) & 0xff;
  126. }
  127. /*
  128. * Read and check that a directory is valid
  129. */
  130. static int
  131. adfs_dir_read(struct super_block *sb, unsigned long object_id,
  132. unsigned int size, struct adfs_dir *dir)
  133. {
  134. const unsigned int blocksize_bits = sb->s_blocksize_bits;
  135. int blk = 0;
  136. /*
  137. * Directories which are not a multiple of 2048 bytes
  138. * are considered bad v2 [3.6]
  139. */
  140. if (size & 2047)
  141. goto bad_dir;
  142. size >>= blocksize_bits;
  143. dir->nr_buffers = 0;
  144. dir->sb = sb;
  145. for (blk = 0; blk < size; blk++) {
  146. int phys;
  147. phys = __adfs_block_map(sb, object_id, blk);
  148. if (!phys) {
  149. adfs_error(sb, "dir object %lX has a hole at offset %d",
  150. object_id, blk);
  151. goto release_buffers;
  152. }
  153. dir->bh[blk] = sb_bread(sb, phys);
  154. if (!dir->bh[blk])
  155. goto release_buffers;
  156. }
  157. memcpy(&dir->dirhead, bufoff(dir->bh, 0), sizeof(dir->dirhead));
  158. memcpy(&dir->dirtail, bufoff(dir->bh, 2007), sizeof(dir->dirtail));
  159. if (dir->dirhead.startmasseq != dir->dirtail.new.endmasseq ||
  160. memcmp(&dir->dirhead.startname, &dir->dirtail.new.endname, 4))
  161. goto bad_dir;
  162. if (memcmp(&dir->dirhead.startname, "Nick", 4) &&
  163. memcmp(&dir->dirhead.startname, "Hugo", 4))
  164. goto bad_dir;
  165. if (adfs_dir_checkbyte(dir) != dir->dirtail.new.dircheckbyte)
  166. goto bad_dir;
  167. dir->nr_buffers = blk;
  168. return 0;
  169. bad_dir:
  170. adfs_error(sb, "corrupted directory fragment %lX",
  171. object_id);
  172. release_buffers:
  173. for (blk -= 1; blk >= 0; blk -= 1)
  174. brelse(dir->bh[blk]);
  175. dir->sb = NULL;
  176. return -EIO;
  177. }
  178. /*
  179. * convert a disk-based directory entry to a Linux ADFS directory entry
  180. */
  181. static inline void
  182. adfs_dir2obj(struct object_info *obj, struct adfs_direntry *de)
  183. {
  184. obj->name_len = adfs_readname(obj->name, de->dirobname, ADFS_F_NAME_LEN);
  185. obj->file_id = adfs_readval(de->dirinddiscadd, 3);
  186. obj->loadaddr = adfs_readval(de->dirload, 4);
  187. obj->execaddr = adfs_readval(de->direxec, 4);
  188. obj->size = adfs_readval(de->dirlen, 4);
  189. obj->attr = de->newdiratts;
  190. }
  191. /*
  192. * convert a Linux ADFS directory entry to a disk-based directory entry
  193. */
  194. static inline void
  195. adfs_obj2dir(struct adfs_direntry *de, struct object_info *obj)
  196. {
  197. adfs_writeval(de->dirinddiscadd, 3, obj->file_id);
  198. adfs_writeval(de->dirload, 4, obj->loadaddr);
  199. adfs_writeval(de->direxec, 4, obj->execaddr);
  200. adfs_writeval(de->dirlen, 4, obj->size);
  201. de->newdiratts = obj->attr;
  202. }
  203. /*
  204. * get a directory entry. Note that the caller is responsible
  205. * for holding the relevant locks.
  206. */
  207. static int
  208. __adfs_dir_get(struct adfs_dir *dir, int pos, struct object_info *obj)
  209. {
  210. struct super_block *sb = dir->sb;
  211. struct adfs_direntry de;
  212. int thissize, buffer, offset;
  213. buffer = pos >> sb->s_blocksize_bits;
  214. if (buffer > dir->nr_buffers)
  215. return -EINVAL;
  216. offset = pos & (sb->s_blocksize - 1);
  217. thissize = sb->s_blocksize - offset;
  218. if (thissize > 26)
  219. thissize = 26;
  220. memcpy(&de, dir->bh[buffer]->b_data + offset, thissize);
  221. if (thissize != 26)
  222. memcpy(((char *)&de) + thissize, dir->bh[buffer + 1]->b_data,
  223. 26 - thissize);
  224. if (!de.dirobname[0])
  225. return -ENOENT;
  226. adfs_dir2obj(obj, &de);
  227. return 0;
  228. }
  229. static int
  230. __adfs_dir_put(struct adfs_dir *dir, int pos, struct object_info *obj)
  231. {
  232. struct super_block *sb = dir->sb;
  233. struct adfs_direntry de;
  234. int thissize, buffer, offset;
  235. buffer = pos >> sb->s_blocksize_bits;
  236. if (buffer > dir->nr_buffers)
  237. return -EINVAL;
  238. offset = pos & (sb->s_blocksize - 1);
  239. thissize = sb->s_blocksize - offset;
  240. if (thissize > 26)
  241. thissize = 26;
  242. /*
  243. * Get the entry in total
  244. */
  245. memcpy(&de, dir->bh[buffer]->b_data + offset, thissize);
  246. if (thissize != 26)
  247. memcpy(((char *)&de) + thissize, dir->bh[buffer + 1]->b_data,
  248. 26 - thissize);
  249. /*
  250. * update it
  251. */
  252. adfs_obj2dir(&de, obj);
  253. /*
  254. * Put the new entry back
  255. */
  256. memcpy(dir->bh[buffer]->b_data + offset, &de, thissize);
  257. if (thissize != 26)
  258. memcpy(dir->bh[buffer + 1]->b_data, ((char *)&de) + thissize,
  259. 26 - thissize);
  260. return 0;
  261. }
  262. /*
  263. * the caller is responsible for holding the necessary
  264. * locks.
  265. */
  266. static int
  267. adfs_dir_find_entry(struct adfs_dir *dir, unsigned long object_id)
  268. {
  269. int pos, ret;
  270. ret = -ENOENT;
  271. for (pos = 5; pos < ADFS_NUM_DIR_ENTRIES * 26 + 5; pos += 26) {
  272. struct object_info obj;
  273. if (!__adfs_dir_get(dir, pos, &obj))
  274. break;
  275. if (obj.file_id == object_id) {
  276. ret = pos;
  277. break;
  278. }
  279. }
  280. return ret;
  281. }
  282. static int
  283. adfs_f_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir)
  284. {
  285. int ret;
  286. if (sz != ADFS_NEWDIR_SIZE)
  287. return -EIO;
  288. ret = adfs_dir_read(sb, id, sz, dir);
  289. if (ret)
  290. adfs_error(sb, "unable to read directory");
  291. else
  292. dir->parent_id = adfs_readval(dir->dirtail.new.dirparent, 3);
  293. return ret;
  294. }
  295. static int
  296. adfs_f_setpos(struct adfs_dir *dir, unsigned int fpos)
  297. {
  298. if (fpos >= ADFS_NUM_DIR_ENTRIES)
  299. return -ENOENT;
  300. dir->pos = 5 + fpos * 26;
  301. return 0;
  302. }
  303. static int
  304. adfs_f_getnext(struct adfs_dir *dir, struct object_info *obj)
  305. {
  306. unsigned int ret;
  307. ret = __adfs_dir_get(dir, dir->pos, obj);
  308. if (ret == 0)
  309. dir->pos += 26;
  310. return ret;
  311. }
  312. static int
  313. adfs_f_update(struct adfs_dir *dir, struct object_info *obj)
  314. {
  315. struct super_block *sb = dir->sb;
  316. int ret, i;
  317. ret = adfs_dir_find_entry(dir, obj->file_id);
  318. if (ret < 0) {
  319. adfs_error(dir->sb, "unable to locate entry to update");
  320. goto out;
  321. }
  322. __adfs_dir_put(dir, ret, obj);
  323. /*
  324. * Increment directory sequence number
  325. */
  326. dir->bh[0]->b_data[0] += 1;
  327. dir->bh[dir->nr_buffers - 1]->b_data[sb->s_blocksize - 6] += 1;
  328. ret = adfs_dir_checkbyte(dir);
  329. /*
  330. * Update directory check byte
  331. */
  332. dir->bh[dir->nr_buffers - 1]->b_data[sb->s_blocksize - 1] = ret;
  333. #if 1
  334. {
  335. const unsigned int blocksize_bits = sb->s_blocksize_bits;
  336. memcpy(&dir->dirhead, bufoff(dir->bh, 0), sizeof(dir->dirhead));
  337. memcpy(&dir->dirtail, bufoff(dir->bh, 2007), sizeof(dir->dirtail));
  338. if (dir->dirhead.startmasseq != dir->dirtail.new.endmasseq ||
  339. memcmp(&dir->dirhead.startname, &dir->dirtail.new.endname, 4))
  340. goto bad_dir;
  341. if (memcmp(&dir->dirhead.startname, "Nick", 4) &&
  342. memcmp(&dir->dirhead.startname, "Hugo", 4))
  343. goto bad_dir;
  344. if (adfs_dir_checkbyte(dir) != dir->dirtail.new.dircheckbyte)
  345. goto bad_dir;
  346. }
  347. #endif
  348. for (i = dir->nr_buffers - 1; i >= 0; i--)
  349. mark_buffer_dirty(dir->bh[i]);
  350. ret = 0;
  351. out:
  352. return ret;
  353. #if 1
  354. bad_dir:
  355. adfs_error(dir->sb, "whoops! I broke a directory!");
  356. return -EIO;
  357. #endif
  358. }
  359. static void
  360. adfs_f_free(struct adfs_dir *dir)
  361. {
  362. int i;
  363. for (i = dir->nr_buffers - 1; i >= 0; i--) {
  364. brelse(dir->bh[i]);
  365. dir->bh[i] = NULL;
  366. }
  367. dir->nr_buffers = 0;
  368. dir->sb = NULL;
  369. }
  370. struct adfs_dir_ops adfs_f_dir_ops = {
  371. .read = adfs_f_read,
  372. .setpos = adfs_f_setpos,
  373. .getnext = adfs_f_getnext,
  374. .update = adfs_f_update,
  375. .free = adfs_f_free
  376. };