fs/udf/misc.c

   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 }