misc.c 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
  1. /*
  2. * misc.c
  3. *
  4. * PURPOSE
  5. * Miscellaneous routines for the OSTA-UDF(tm) filesystem.
  6. *
  7. * COPYRIGHT
  8. * This file is distributed under the terms of the GNU General Public
  9. * License (GPL). Copies of the GPL can be obtained from:
  10. * ftp://prep.ai.mit.edu/pub/gnu/GPL
  11. * Each contributing author retains all rights to their own work.
  12. *
  13. * (C) 1998 Dave Boynton
  14. * (C) 1998-2004 Ben Fennema
  15. * (C) 1999-2000 Stelias Computing Inc
  16. *
  17. * HISTORY
  18. *
  19. * 04/19/99 blf partial support for reading/writing specific EA's
  20. */
  21. #include "udfdecl.h"
  22. #include <linux/fs.h>
  23. #include <linux/string.h>
  24. #include <linux/udf_fs.h>
  25. #include <linux/buffer_head.h>
  26. #include "udf_i.h"
  27. #include "udf_sb.h"
  28. struct buffer_head *
  29. udf_tgetblk(struct super_block *sb, int block)
  30. {
  31. if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
  32. return sb_getblk(sb, udf_fixed_to_variable(block));
  33. else
  34. return sb_getblk(sb, block);
  35. }
  36. struct buffer_head *
  37. udf_tread(struct super_block *sb, int block)
  38. {
  39. if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
  40. return sb_bread(sb, udf_fixed_to_variable(block));
  41. else
  42. return sb_bread(sb, block);
  43. }
  44. struct genericFormat *
  45. udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type,
  46. uint8_t loc)
  47. {
  48. uint8_t *ea = NULL, *ad = NULL;
  49. int offset;
  50. uint16_t crclen;
  51. int i;
  52. ea = UDF_I_DATA(inode);
  53. if (UDF_I_LENEATTR(inode))
  54. ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
  55. else
  56. {
  57. ad = ea;
  58. size += sizeof(struct extendedAttrHeaderDesc);
  59. }
  60. offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
  61. UDF_I_LENALLOC(inode);
  62. /* TODO - Check for FreeEASpace */
  63. if (loc & 0x01 && offset >= size)
  64. {
  65. struct extendedAttrHeaderDesc *eahd;
  66. eahd = (struct extendedAttrHeaderDesc *)ea;
  67. if (UDF_I_LENALLOC(inode))
  68. {
  69. memmove(&ad[size], ad, UDF_I_LENALLOC(inode));
  70. }
  71. if (UDF_I_LENEATTR(inode))
  72. {
  73. /* check checksum/crc */
  74. if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
  75. le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum)
  76. {
  77. return NULL;
  78. }
  79. }
  80. else
  81. {
  82. size -= sizeof(struct extendedAttrHeaderDesc);
  83. UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);
  84. eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
  85. if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
  86. eahd->descTag.descVersion = cpu_to_le16(3);
  87. else
  88. eahd->descTag.descVersion = cpu_to_le16(2);
  89. eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
  90. eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
  91. eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
  92. eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
  93. }
  94. offset = UDF_I_LENEATTR(inode);
  95. if (type < 2048)
  96. {
  97. if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode))
  98. {
  99. uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
  100. memmove(&ea[offset - aal + size],
  101. &ea[aal], offset - aal);
  102. offset -= aal;
  103. eahd->appAttrLocation = cpu_to_le32(aal + size);
  104. }
  105. if (le32_to_cpu(eahd->impAttrLocation) < UDF_I_LENEATTR(inode))
  106. {
  107. uint32_t ial = le32_to_cpu(eahd->impAttrLocation);
  108. memmove(&ea[offset - ial + size],
  109. &ea[ial], offset - ial);
  110. offset -= ial;
  111. eahd->impAttrLocation = cpu_to_le32(ial + size);
  112. }
  113. }
  114. else if (type < 65536)
  115. {
  116. if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode))
  117. {
  118. uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
  119. memmove(&ea[offset - aal + size],
  120. &ea[aal], offset - aal);
  121. offset -= aal;
  122. eahd->appAttrLocation = cpu_to_le32(aal + size);
  123. }
  124. }
  125. /* rewrite CRC + checksum of eahd */
  126. crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
  127. eahd->descTag.descCRCLength = cpu_to_le16(crclen);
  128. eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd + sizeof(tag), crclen, 0));
  129. eahd->descTag.tagChecksum = 0;
  130. for (i=0; i<16; i++)
  131. if (i != 4)
  132. eahd->descTag.tagChecksum += ((uint8_t *)&(eahd->descTag))[i];
  133. UDF_I_LENEATTR(inode) += size;
  134. return (struct genericFormat *)&ea[offset];
  135. }
  136. if (loc & 0x02)
  137. {
  138. }
  139. return NULL;
  140. }
  141. struct genericFormat *
  142. udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype)
  143. {
  144. struct genericFormat *gaf;
  145. uint8_t *ea = NULL;
  146. uint32_t offset;
  147. ea = UDF_I_DATA(inode);
  148. if (UDF_I_LENEATTR(inode))
  149. {
  150. struct extendedAttrHeaderDesc *eahd;
  151. eahd = (struct extendedAttrHeaderDesc *)ea;
  152. /* check checksum/crc */
  153. if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
  154. le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum)
  155. {
  156. return NULL;
  157. }
  158. if (type < 2048)
  159. offset = sizeof(struct extendedAttrHeaderDesc);
  160. else if (type < 65536)
  161. offset = le32_to_cpu(eahd->impAttrLocation);
  162. else
  163. offset = le32_to_cpu(eahd->appAttrLocation);
  164. while (offset < UDF_I_LENEATTR(inode))
  165. {
  166. gaf = (struct genericFormat *)&ea[offset];
  167. if (le32_to_cpu(gaf->attrType) == type && gaf->attrSubtype == subtype)
  168. return gaf;
  169. else
  170. offset += le32_to_cpu(gaf->attrLength);
  171. }
  172. }
  173. return NULL;
  174. }
  175. /*
  176. * udf_read_tagged
  177. *
  178. * PURPOSE
  179. * Read the first block of a tagged descriptor.
  180. *
  181. * HISTORY
  182. * July 1, 1997 - Andrew E. Mileski
  183. * Written, tested, and released.
  184. */
  185. struct buffer_head *
  186. udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint16_t *ident)
  187. {
  188. tag *tag_p;
  189. struct buffer_head *bh = NULL;
  190. register uint8_t checksum;
  191. register int i;
  192. /* Read the block */
  193. if (block == 0xFFFFFFFF)
  194. return NULL;
  195. bh = udf_tread(sb, block + UDF_SB_SESSION(sb));
  196. if (!bh)
  197. {
  198. udf_debug("block=%d, location=%d: read failed\n", block + UDF_SB_SESSION(sb), location);
  199. return NULL;
  200. }
  201. tag_p = (tag *)(bh->b_data);
  202. *ident = le16_to_cpu(tag_p->tagIdent);
  203. if ( location != le32_to_cpu(tag_p->tagLocation) )
  204. {
  205. udf_debug("location mismatch block %u, tag %u != %u\n",
  206. block + UDF_SB_SESSION(sb), le32_to_cpu(tag_p->tagLocation), location);
  207. goto error_out;
  208. }
  209. /* Verify the tag checksum */
  210. checksum = 0U;
  211. for (i = 0; i < 4; i++)
  212. checksum += (uint8_t)(bh->b_data[i]);
  213. for (i = 5; i < 16; i++)
  214. checksum += (uint8_t)(bh->b_data[i]);
  215. if (checksum != tag_p->tagChecksum) {
  216. printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
  217. goto error_out;
  218. }
  219. /* Verify the tag version */
  220. if (le16_to_cpu(tag_p->descVersion) != 0x0002U &&
  221. le16_to_cpu(tag_p->descVersion) != 0x0003U)
  222. {
  223. udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n",
  224. le16_to_cpu(tag_p->descVersion), block);
  225. goto error_out;
  226. }
  227. /* Verify the descriptor CRC */
  228. if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize ||
  229. le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag),
  230. le16_to_cpu(tag_p->descCRCLength), 0))
  231. {
  232. return bh;
  233. }
  234. udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
  235. block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC), le16_to_cpu(tag_p->descCRCLength));
  236. error_out:
  237. brelse(bh);
  238. return NULL;
  239. }
  240. struct buffer_head *
  241. udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc, uint32_t offset, uint16_t *ident)
  242. {
  243. return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset),
  244. loc.logicalBlockNum + offset, ident);
  245. }
  246. void udf_release_data(struct buffer_head *bh)
  247. {
  248. if (bh)
  249. brelse(bh);
  250. }
  251. void udf_update_tag(char *data, int length)
  252. {
  253. tag *tptr = (tag *)data;
  254. int i;
  255. length -= sizeof(tag);
  256. tptr->tagChecksum = 0;
  257. tptr->descCRCLength = cpu_to_le16(length);
  258. tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
  259. for (i=0; i<16; i++)
  260. if (i != 4)
  261. tptr->tagChecksum += (uint8_t)(data[i]);
  262. }
  263. void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
  264. uint32_t loc, int length)
  265. {
  266. tag *tptr = (tag *)data;
  267. tptr->tagIdent = cpu_to_le16(ident);
  268. tptr->descVersion = cpu_to_le16(version);
  269. tptr->tagSerialNum = cpu_to_le16(snum);
  270. tptr->tagLocation = cpu_to_le32(loc);
  271. udf_update_tag(data, length);
  272. }