ea.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * linux/fs/hpfs/ea.c
  4. *
  5. * Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
  6. *
  7. * handling extended attributes
  8. */
  9. #include "hpfs_fn.h"
  10. /* Remove external extended attributes. ano specifies whether a is a
  11. direct sector where eas starts or an anode */
  12. void hpfs_ea_ext_remove(struct super_block *s, secno a, int ano, unsigned len)
  13. {
  14. unsigned pos = 0;
  15. while (pos < len) {
  16. char ex[4 + 255 + 1 + 8];
  17. struct extended_attribute *ea = (struct extended_attribute *)ex;
  18. if (pos + 4 > len) {
  19. hpfs_error(s, "EAs don't end correctly, %s %08x, len %08x",
  20. ano ? "anode" : "sectors", a, len);
  21. return;
  22. }
  23. if (hpfs_ea_read(s, a, ano, pos, 4, ex)) return;
  24. if (ea_indirect(ea)) {
  25. if (ea_valuelen(ea) != 8) {
  26. hpfs_error(s, "ea_indirect(ea) set while ea->valuelen!=8, %s %08x, pos %08x",
  27. ano ? "anode" : "sectors", a, pos);
  28. return;
  29. }
  30. if (hpfs_ea_read(s, a, ano, pos + 4, ea->namelen + 9, ex+4))
  31. return;
  32. hpfs_ea_remove(s, ea_sec(ea), ea_in_anode(ea), ea_len(ea));
  33. }
  34. pos += ea->namelen + ea_valuelen(ea) + 5;
  35. }
  36. if (!ano) hpfs_free_sectors(s, a, (len+511) >> 9);
  37. else {
  38. struct buffer_head *bh;
  39. struct anode *anode;
  40. if ((anode = hpfs_map_anode(s, a, &bh))) {
  41. hpfs_remove_btree(s, &anode->btree);
  42. brelse(bh);
  43. hpfs_free_sectors(s, a, 1);
  44. }
  45. }
  46. }
  47. static char *get_indirect_ea(struct super_block *s, int ano, secno a, int size)
  48. {
  49. char *ret;
  50. if (!(ret = kmalloc(size + 1, GFP_NOFS))) {
  51. pr_err("out of memory for EA\n");
  52. return NULL;
  53. }
  54. if (hpfs_ea_read(s, a, ano, 0, size, ret)) {
  55. kfree(ret);
  56. return NULL;
  57. }
  58. ret[size] = 0;
  59. return ret;
  60. }
  61. static void set_indirect_ea(struct super_block *s, int ano, secno a,
  62. const char *data, int size)
  63. {
  64. hpfs_ea_write(s, a, ano, 0, size, data);
  65. }
  66. /* Read an extended attribute named 'key' into the provided buffer */
  67. int hpfs_read_ea(struct super_block *s, struct fnode *fnode, char *key,
  68. char *buf, int size)
  69. {
  70. unsigned pos;
  71. int ano, len;
  72. secno a;
  73. char ex[4 + 255 + 1 + 8];
  74. struct extended_attribute *ea;
  75. struct extended_attribute *ea_end = fnode_end_ea(fnode);
  76. for (ea = fnode_ea(fnode); ea < ea_end; ea = next_ea(ea))
  77. if (!strcmp(ea->name, key)) {
  78. if (ea_indirect(ea))
  79. goto indirect;
  80. if (ea_valuelen(ea) >= size)
  81. return -EINVAL;
  82. memcpy(buf, ea_data(ea), ea_valuelen(ea));
  83. buf[ea_valuelen(ea)] = 0;
  84. return 0;
  85. }
  86. a = le32_to_cpu(fnode->ea_secno);
  87. len = le32_to_cpu(fnode->ea_size_l);
  88. ano = fnode_in_anode(fnode);
  89. pos = 0;
  90. while (pos < len) {
  91. ea = (struct extended_attribute *)ex;
  92. if (pos + 4 > len) {
  93. hpfs_error(s, "EAs don't end correctly, %s %08x, len %08x",
  94. ano ? "anode" : "sectors", a, len);
  95. return -EIO;
  96. }
  97. if (hpfs_ea_read(s, a, ano, pos, 4, ex)) return -EIO;
  98. if (hpfs_ea_read(s, a, ano, pos + 4, ea->namelen + 1 + (ea_indirect(ea) ? 8 : 0), ex + 4))
  99. return -EIO;
  100. if (!strcmp(ea->name, key)) {
  101. if (ea_indirect(ea))
  102. goto indirect;
  103. if (ea_valuelen(ea) >= size)
  104. return -EINVAL;
  105. if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea_valuelen(ea), buf))
  106. return -EIO;
  107. buf[ea_valuelen(ea)] = 0;
  108. return 0;
  109. }
  110. pos += ea->namelen + ea_valuelen(ea) + 5;
  111. }
  112. return -ENOENT;
  113. indirect:
  114. if (ea_len(ea) >= size)
  115. return -EINVAL;
  116. if (hpfs_ea_read(s, ea_sec(ea), ea_in_anode(ea), 0, ea_len(ea), buf))
  117. return -EIO;
  118. buf[ea_len(ea)] = 0;
  119. return 0;
  120. }
  121. /* Read an extended attribute named 'key' */
  122. char *hpfs_get_ea(struct super_block *s, struct fnode *fnode, char *key, int *size)
  123. {
  124. char *ret;
  125. unsigned pos;
  126. int ano, len;
  127. secno a;
  128. struct extended_attribute *ea;
  129. struct extended_attribute *ea_end = fnode_end_ea(fnode);
  130. for (ea = fnode_ea(fnode); ea < ea_end; ea = next_ea(ea))
  131. if (!strcmp(ea->name, key)) {
  132. if (ea_indirect(ea))
  133. return get_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), *size = ea_len(ea));
  134. if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
  135. pr_err("out of memory for EA\n");
  136. return NULL;
  137. }
  138. memcpy(ret, ea_data(ea), ea_valuelen(ea));
  139. ret[ea_valuelen(ea)] = 0;
  140. return ret;
  141. }
  142. a = le32_to_cpu(fnode->ea_secno);
  143. len = le32_to_cpu(fnode->ea_size_l);
  144. ano = fnode_in_anode(fnode);
  145. pos = 0;
  146. while (pos < len) {
  147. char ex[4 + 255 + 1 + 8];
  148. ea = (struct extended_attribute *)ex;
  149. if (pos + 4 > len) {
  150. hpfs_error(s, "EAs don't end correctly, %s %08x, len %08x",
  151. ano ? "anode" : "sectors", a, len);
  152. return NULL;
  153. }
  154. if (hpfs_ea_read(s, a, ano, pos, 4, ex)) return NULL;
  155. if (hpfs_ea_read(s, a, ano, pos + 4, ea->namelen + 1 + (ea_indirect(ea) ? 8 : 0), ex + 4))
  156. return NULL;
  157. if (!strcmp(ea->name, key)) {
  158. if (ea_indirect(ea))
  159. return get_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), *size = ea_len(ea));
  160. if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
  161. pr_err("out of memory for EA\n");
  162. return NULL;
  163. }
  164. if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea_valuelen(ea), ret)) {
  165. kfree(ret);
  166. return NULL;
  167. }
  168. ret[ea_valuelen(ea)] = 0;
  169. return ret;
  170. }
  171. pos += ea->namelen + ea_valuelen(ea) + 5;
  172. }
  173. return NULL;
  174. }
  175. /*
  176. * Update or create extended attribute 'key' with value 'data'. Note that
  177. * when this ea exists, it MUST have the same size as size of data.
  178. * This driver can't change sizes of eas ('cause I just don't need it).
  179. */
  180. void hpfs_set_ea(struct inode *inode, struct fnode *fnode, const char *key,
  181. const char *data, int size)
  182. {
  183. fnode_secno fno = inode->i_ino;
  184. struct super_block *s = inode->i_sb;
  185. unsigned pos;
  186. int ano, len;
  187. secno a;
  188. unsigned char h[4];
  189. struct extended_attribute *ea;
  190. struct extended_attribute *ea_end = fnode_end_ea(fnode);
  191. for (ea = fnode_ea(fnode); ea < ea_end; ea = next_ea(ea))
  192. if (!strcmp(ea->name, key)) {
  193. if (ea_indirect(ea)) {
  194. if (ea_len(ea) == size)
  195. set_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), data, size);
  196. } else if (ea_valuelen(ea) == size) {
  197. memcpy(ea_data(ea), data, size);
  198. }
  199. return;
  200. }
  201. a = le32_to_cpu(fnode->ea_secno);
  202. len = le32_to_cpu(fnode->ea_size_l);
  203. ano = fnode_in_anode(fnode);
  204. pos = 0;
  205. while (pos < len) {
  206. char ex[4 + 255 + 1 + 8];
  207. ea = (struct extended_attribute *)ex;
  208. if (pos + 4 > len) {
  209. hpfs_error(s, "EAs don't end correctly, %s %08x, len %08x",
  210. ano ? "anode" : "sectors", a, len);
  211. return;
  212. }
  213. if (hpfs_ea_read(s, a, ano, pos, 4, ex)) return;
  214. if (hpfs_ea_read(s, a, ano, pos + 4, ea->namelen + 1 + (ea_indirect(ea) ? 8 : 0), ex + 4))
  215. return;
  216. if (!strcmp(ea->name, key)) {
  217. if (ea_indirect(ea)) {
  218. if (ea_len(ea) == size)
  219. set_indirect_ea(s, ea_in_anode(ea), ea_sec(ea), data, size);
  220. }
  221. else {
  222. if (ea_valuelen(ea) == size)
  223. hpfs_ea_write(s, a, ano, pos + 4 + ea->namelen + 1, size, data);
  224. }
  225. return;
  226. }
  227. pos += ea->namelen + ea_valuelen(ea) + 5;
  228. }
  229. if (!le16_to_cpu(fnode->ea_offs)) {
  230. /*if (le16_to_cpu(fnode->ea_size_s)) {
  231. hpfs_error(s, "fnode %08x: ea_size_s == %03x, ea_offs == 0",
  232. inode->i_ino, le16_to_cpu(fnode->ea_size_s));
  233. return;
  234. }*/
  235. fnode->ea_offs = cpu_to_le16(0xc4);
  236. }
  237. if (le16_to_cpu(fnode->ea_offs) < 0xc4 || le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s) > 0x200) {
  238. hpfs_error(s, "fnode %08lx: ea_offs == %03x, ea_size_s == %03x",
  239. (unsigned long)inode->i_ino,
  240. le16_to_cpu(fnode->ea_offs), le16_to_cpu(fnode->ea_size_s));
  241. return;
  242. }
  243. if ((le16_to_cpu(fnode->ea_size_s) || !le32_to_cpu(fnode->ea_size_l)) &&
  244. le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s) + strlen(key) + size + 5 <= 0x200) {
  245. ea = fnode_end_ea(fnode);
  246. *(char *)ea = 0;
  247. ea->namelen = strlen(key);
  248. ea->valuelen_lo = size;
  249. ea->valuelen_hi = size >> 8;
  250. strcpy(ea->name, key);
  251. memcpy(ea_data(ea), data, size);
  252. fnode->ea_size_s = cpu_to_le16(le16_to_cpu(fnode->ea_size_s) + strlen(key) + size + 5);
  253. goto ret;
  254. }
  255. /* Most the code here is 99.9993422% unused. I hope there are no bugs.
  256. But what .. HPFS.IFS has also bugs in ea management. */
  257. if (le16_to_cpu(fnode->ea_size_s) && !le32_to_cpu(fnode->ea_size_l)) {
  258. secno n;
  259. struct buffer_head *bh;
  260. char *data;
  261. if (!(n = hpfs_alloc_sector(s, fno, 1, 0))) return;
  262. if (!(data = hpfs_get_sector(s, n, &bh))) {
  263. hpfs_free_sectors(s, n, 1);
  264. return;
  265. }
  266. memcpy(data, fnode_ea(fnode), le16_to_cpu(fnode->ea_size_s));
  267. fnode->ea_size_l = cpu_to_le32(le16_to_cpu(fnode->ea_size_s));
  268. fnode->ea_size_s = cpu_to_le16(0);
  269. fnode->ea_secno = cpu_to_le32(n);
  270. fnode->flags &= ~FNODE_anode;
  271. mark_buffer_dirty(bh);
  272. brelse(bh);
  273. }
  274. pos = le32_to_cpu(fnode->ea_size_l) + 5 + strlen(key) + size;
  275. len = (le32_to_cpu(fnode->ea_size_l) + 511) >> 9;
  276. if (pos >= 30000) goto bail;
  277. while (((pos + 511) >> 9) > len) {
  278. if (!len) {
  279. secno q = hpfs_alloc_sector(s, fno, 1, 0);
  280. if (!q) goto bail;
  281. fnode->ea_secno = cpu_to_le32(q);
  282. fnode->flags &= ~FNODE_anode;
  283. len++;
  284. } else if (!fnode_in_anode(fnode)) {
  285. if (hpfs_alloc_if_possible(s, le32_to_cpu(fnode->ea_secno) + len)) {
  286. len++;
  287. } else {
  288. /* Aargh... don't know how to create ea anodes :-( */
  289. /*struct buffer_head *bh;
  290. struct anode *anode;
  291. anode_secno a_s;
  292. if (!(anode = hpfs_alloc_anode(s, fno, &a_s, &bh)))
  293. goto bail;
  294. anode->up = cpu_to_le32(fno);
  295. anode->btree.fnode_parent = 1;
  296. anode->btree.n_free_nodes--;
  297. anode->btree.n_used_nodes++;
  298. anode->btree.first_free = cpu_to_le16(le16_to_cpu(anode->btree.first_free) + 12);
  299. anode->u.external[0].disk_secno = cpu_to_le32(le32_to_cpu(fnode->ea_secno));
  300. anode->u.external[0].file_secno = cpu_to_le32(0);
  301. anode->u.external[0].length = cpu_to_le32(len);
  302. mark_buffer_dirty(bh);
  303. brelse(bh);
  304. fnode->flags |= FNODE_anode;
  305. fnode->ea_secno = cpu_to_le32(a_s);*/
  306. secno new_sec;
  307. int i;
  308. if (!(new_sec = hpfs_alloc_sector(s, fno, 1, 1 - ((pos + 511) >> 9))))
  309. goto bail;
  310. for (i = 0; i < len; i++) {
  311. struct buffer_head *bh1, *bh2;
  312. void *b1, *b2;
  313. if (!(b1 = hpfs_map_sector(s, le32_to_cpu(fnode->ea_secno) + i, &bh1, len - i - 1))) {
  314. hpfs_free_sectors(s, new_sec, (pos + 511) >> 9);
  315. goto bail;
  316. }
  317. if (!(b2 = hpfs_get_sector(s, new_sec + i, &bh2))) {
  318. brelse(bh1);
  319. hpfs_free_sectors(s, new_sec, (pos + 511) >> 9);
  320. goto bail;
  321. }
  322. memcpy(b2, b1, 512);
  323. brelse(bh1);
  324. mark_buffer_dirty(bh2);
  325. brelse(bh2);
  326. }
  327. hpfs_free_sectors(s, le32_to_cpu(fnode->ea_secno), len);
  328. fnode->ea_secno = cpu_to_le32(new_sec);
  329. len = (pos + 511) >> 9;
  330. }
  331. }
  332. if (fnode_in_anode(fnode)) {
  333. if (hpfs_add_sector_to_btree(s, le32_to_cpu(fnode->ea_secno),
  334. 0, len) != -1) {
  335. len++;
  336. } else {
  337. goto bail;
  338. }
  339. }
  340. }
  341. h[0] = 0;
  342. h[1] = strlen(key);
  343. h[2] = size & 0xff;
  344. h[3] = size >> 8;
  345. if (hpfs_ea_write(s, le32_to_cpu(fnode->ea_secno), fnode_in_anode(fnode), le32_to_cpu(fnode->ea_size_l), 4, h)) goto bail;
  346. if (hpfs_ea_write(s, le32_to_cpu(fnode->ea_secno), fnode_in_anode(fnode), le32_to_cpu(fnode->ea_size_l) + 4, h[1] + 1, key)) goto bail;
  347. if (hpfs_ea_write(s, le32_to_cpu(fnode->ea_secno), fnode_in_anode(fnode), le32_to_cpu(fnode->ea_size_l) + 5 + h[1], size, data)) goto bail;
  348. fnode->ea_size_l = cpu_to_le32(pos);
  349. ret:
  350. hpfs_i(inode)->i_ea_size += 5 + strlen(key) + size;
  351. return;
  352. bail:
  353. if (le32_to_cpu(fnode->ea_secno))
  354. if (fnode_in_anode(fnode)) hpfs_truncate_btree(s, le32_to_cpu(fnode->ea_secno), 1, (le32_to_cpu(fnode->ea_size_l) + 511) >> 9);
  355. else hpfs_free_sectors(s, le32_to_cpu(fnode->ea_secno) + ((le32_to_cpu(fnode->ea_size_l) + 511) >> 9), len - ((le32_to_cpu(fnode->ea_size_l) + 511) >> 9));
  356. else fnode->ea_secno = fnode->ea_size_l = cpu_to_le32(0);
  357. }