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 22 #include "udfdecl.h" 23 24 #include <linux/fs.h> 25 #include <linux/string.h> 26 #include <linux/udf_fs.h> 27 #include <linux/buffer_head.h> 28 29 #include "udf_i.h" 30 #include "udf_sb.h" 31 32 struct buffer_head * 33 udf_tgetblk(struct super_block *sb, int block) 34 { 35 if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV)) 36 return sb_getblk(sb, udf_fixed_to_variable(block)); 37 else 38 return sb_getblk(sb, block); 39 } 40 41 struct buffer_head * 42 udf_tread(struct super_block *sb, int block) 43 { 44 if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV)) 45 return sb_bread(sb, udf_fixed_to_variable(block)); 46 else 47 return sb_bread(sb, block); 48 } 49 50 struct genericFormat * 51 udf_add_extendedattr(struct inode * inode, uint32_t size, uint32_t type, 52 uint8_t loc) 53 { 54 uint8_t *ea = NULL, *ad = NULL; 55 int offset; 56 uint16_t crclen; 57 int i; 58 59 ea = UDF_I_DATA(inode); 60 if (UDF_I_LENEATTR(inode)) 61 ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode); 62 else 63 { 64 ad = ea; 65 size += sizeof(struct extendedAttrHeaderDesc); 66 } 67 68 offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) - 69 UDF_I_LENALLOC(inode); 70 71 /* TODO - Check for FreeEASpace */ 72 73 if (loc & 0x01 && offset >= size) 74 { 75 struct extendedAttrHeaderDesc *eahd; 76 eahd = (struct extendedAttrHeaderDesc *)ea; 77 78 if (UDF_I_LENALLOC(inode)) 79 { 80 memmove(&ad[size], ad, UDF_I_LENALLOC(inode)); 81 } 82 83 if (UDF_I_LENEATTR(inode)) 84 { 85 /* check checksum/crc */ 86 if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD || 87 le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) 88 { 89 return NULL; 90 } 91 } 92 else 93 { 94 size -= sizeof(struct extendedAttrHeaderDesc); 95 UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc); 96 eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD); 97 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200) 98 eahd->descTag.descVersion = cpu_to_le16(3); 99 else 100 eahd->descTag.descVersion = cpu_to_le16(2); 101 eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb)); 102 eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum); 103 eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF); 104 eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF); 105 } 106 107 offset = UDF_I_LENEATTR(inode); 108 if (type < 2048) 109 { 110 if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) 111 { 112 uint32_t aal = le32_to_cpu(eahd->appAttrLocation); 113 memmove(&ea[offset - aal + size], 114 &ea[aal], offset - aal); 115 offset -= aal; 116 eahd->appAttrLocation = cpu_to_le32(aal + size); 117 } 118 if (le32_to_cpu(eahd->impAttrLocation) < UDF_I_LENEATTR(inode)) 119 { 120 uint32_t ial = le32_to_cpu(eahd->impAttrLocation); 121 memmove(&ea[offset - ial + size], 122 &ea[ial], offset - ial); 123 offset -= ial; 124 eahd->impAttrLocation = cpu_to_le32(ial + size); 125 } 126 } 127 else if (type < 65536) 128 { 129 if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) 130 { 131 uint32_t aal = le32_to_cpu(eahd->appAttrLocation); 132 memmove(&ea[offset - aal + size], 133 &ea[aal], offset - aal); 134 offset -= aal; 135 eahd->appAttrLocation = cpu_to_le32(aal + size); 136 } 137 } 138 /* rewrite CRC + checksum of eahd */ 139 crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag); 140 eahd->descTag.descCRCLength = cpu_to_le16(crclen); 141 eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd + sizeof(tag), crclen, 0)); 142 eahd->descTag.tagChecksum = 0; 143 for (i=0; i<16; i++) 144 if (i != 4) 145 eahd->descTag.tagChecksum += ((uint8_t *)&(eahd->descTag))[i]; 146 UDF_I_LENEATTR(inode) += size; 147 return (struct genericFormat *)&ea[offset]; 148 } 149 if (loc & 0x02) 150 { 151 } 152 return NULL; 153 } 154 155 struct genericFormat * 156 udf_get_extendedattr(struct inode *inode, uint32_t type, uint8_t subtype) 157 { 158 struct genericFormat *gaf; 159 uint8_t *ea = NULL; 160 uint32_t offset; 161 162 ea = UDF_I_DATA(inode); 163 164 if (UDF_I_LENEATTR(inode)) 165 { 166 struct extendedAttrHeaderDesc *eahd; 167 eahd = (struct extendedAttrHeaderDesc *)ea; 168 169 /* check checksum/crc */ 170 if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD || 171 le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) 172 { 173 return NULL; 174 } 175 176 if (type < 2048) 177 offset = sizeof(struct extendedAttrHeaderDesc); 178 else if (type < 65536) 179 offset = le32_to_cpu(eahd->impAttrLocation); 180 else 181 offset = le32_to_cpu(eahd->appAttrLocation); 182 183 while (offset < UDF_I_LENEATTR(inode)) 184 { 185 gaf = (struct genericFormat *)&ea[offset]; 186 if (le32_to_cpu(gaf->attrType) == type && gaf->attrSubtype == subtype) 187 return gaf; 188 else 189 offset += le32_to_cpu(gaf->attrLength); 190 } 191 } 192 return NULL; 193 } 194 195 /* 196 * udf_read_tagged 197 * 198 * PURPOSE 199 * Read the first block of a tagged descriptor. 200 * 201 * HISTORY 202 * July 1, 1997 - Andrew E. Mileski 203 * Written, tested, and released. 204 */ 205 struct buffer_head * 206 udf_read_tagged(struct super_block *sb, uint32_t block, uint32_t location, uint16_t *ident) 207 { 208 tag *tag_p; 209 struct buffer_head *bh = NULL; 210 register uint8_t checksum; 211 register int i; 212 213 /* Read the block */ 214 if (block == 0xFFFFFFFF) 215 return NULL; 216 217 bh = udf_tread(sb, block + UDF_SB_SESSION(sb)); 218 if (!bh) 219 { 220 udf_debug("block=%d, location=%d: read failed\n", block + UDF_SB_SESSION(sb), location); 221 return NULL; 222 } 223 224 tag_p = (tag *)(bh->b_data); 225 226 *ident = le16_to_cpu(tag_p->tagIdent); 227 228 if ( location != le32_to_cpu(tag_p->tagLocation) ) 229 { 230 udf_debug("location mismatch block %u, tag %u != %u\n", 231 block + UDF_SB_SESSION(sb), le32_to_cpu(tag_p->tagLocation), location); 232 goto error_out; 233 } 234 235 /* Verify the tag checksum */ 236 checksum = 0U; 237 for (i = 0; i < 4; i++) 238 checksum += (uint8_t)(bh->b_data[i]); 239 for (i = 5; i < 16; i++) 240 checksum += (uint8_t)(bh->b_data[i]); 241 if (checksum != tag_p->tagChecksum) { 242 printk(KERN_ERR "udf: tag checksum failed block %d\n", block); 243 goto error_out; 244 } 245 246 /* Verify the tag version */ 247 if (le16_to_cpu(tag_p->descVersion) != 0x0002U && 248 le16_to_cpu(tag_p->descVersion) != 0x0003U) 249 { 250 udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n", 251 le16_to_cpu(tag_p->descVersion), block); 252 goto error_out; 253 } 254 255 /* Verify the descriptor CRC */ 256 if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize || 257 le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag), 258 le16_to_cpu(tag_p->descCRCLength), 0)) 259 { 260 return bh; 261 } 262 udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", 263 block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC), le16_to_cpu(tag_p->descCRCLength)); 264 265 error_out: 266 brelse(bh); 267 return NULL; 268 } 269 270 struct buffer_head * 271 udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc, uint32_t offset, uint16_t *ident) 272 { 273 return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset), 274 loc.logicalBlockNum + offset, ident); 275 } 276 277 void udf_release_data(struct buffer_head *bh) 278 { 279 if (bh) 280 brelse(bh); 281 } 282 283 void udf_update_tag(char *data, int length) 284 { 285 tag *tptr = (tag *)data; 286 int i; 287 288 length -= sizeof(tag); 289 290 tptr->tagChecksum = 0; 291 tptr->descCRCLength = cpu_to_le16(length); 292 tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0)); 293 294 for (i=0; i<16; i++) 295 if (i != 4) 296 tptr->tagChecksum += (uint8_t)(data[i]); 297 } 298 299 void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum, 300 uint32_t loc, int length) 301 { 302 tag *tptr = (tag *)data; 303 tptr->tagIdent = cpu_to_le16(ident); 304 tptr->descVersion = cpu_to_le16(version); 305 tptr->tagSerialNum = cpu_to_le16(snum); 306 tptr->tagLocation = cpu_to_le32(loc); 307 udf_update_tag(data, length); 308 } 309