SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 *udf_tgetblk(struct super_block *sb, int block)
  33 {
  34         if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
  35                 return sb_getblk(sb, udf_fixed_to_variable(block));
  36         else
  37                 return sb_getblk(sb, block);
  38 }
  39
  40 struct buffer_head *udf_tread(struct super_block *sb, int block)
  41 {
  42         if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV))
  43                 return sb_bread(sb, udf_fixed_to_variable(block));
  44         else
  45                 return sb_bread(sb, block);
  46 }
  47
  48 struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
  49                                            uint32_t type, uint8_t loc)
  50 {
  51         uint8_t *ea = NULL, *ad = NULL;
  52         int offset;
  53         uint16_t crclen;
  54         int i;
  55
  56         ea = UDF_I_DATA(inode);
  57         if (UDF_I_LENEATTR(inode)) {
  58                 ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
  59         } else {
  60                 ad = ea;
  61                 size += sizeof(struct extendedAttrHeaderDesc);
  62         }
  63
  64         offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
  65                 UDF_I_LENALLOC(inode);
  66
  67         /* TODO - Check for FreeEASpace */
  68
  69         if (loc & 0x01 && offset >= size) {
  70                 struct extendedAttrHeaderDesc *eahd;
  71                 eahd = (struct extendedAttrHeaderDesc *)ea;
  72
  73                 if (UDF_I_LENALLOC(inode))
  74                         memmove(&ad[size], ad, UDF_I_LENALLOC(inode));
  75
  76                 if (UDF_I_LENEATTR(inode)) {
  77                         /* check checksum/crc */
  78                         if (le16_to_cpu(eahd->descTag.tagIdent) !=
  79                                         TAG_IDENT_EAHD ||
  80                             le32_to_cpu(eahd->descTag.tagLocation) !=
  81                                         UDF_I_LOCATION(inode).logicalBlockNum)
  82                                 return NULL;
  83                 } else {
  84                         struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
  85
  86                         size -= sizeof(struct extendedAttrHeaderDesc);
  87                         UDF_I_LENEATTR(inode) +=
  88                                 sizeof(struct extendedAttrHeaderDesc);
  89                         eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
  90                         if (sbi->s_udfrev >= 0x0200)
  91                                 eahd->descTag.descVersion = cpu_to_le16(3);
  92                         else
  93                                 eahd->descTag.descVersion = cpu_to_le16(2);
  94                         eahd->descTag.tagSerialNum =
  95                                         cpu_to_le16(sbi->s_serial_number);
  96                         eahd->descTag.tagLocation = cpu_to_le32(
  97                                         UDF_I_LOCATION(inode).logicalBlockNum);
  98                         eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
  99                         eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
 100                 }
 101
 102                 offset = UDF_I_LENEATTR(inode);
 103                 if (type < 2048) {
 104                         if (le32_to_cpu(eahd->appAttrLocation) <
 105                                         UDF_I_LENEATTR(inode)) {
 106                                 uint32_t aal =
 107                                         le32_to_cpu(eahd->appAttrLocation);
 108                                 memmove(&ea[offset - aal + size],
 109                                         &ea[aal], offset - aal);
 110                                 offset -= aal;
 111                                 eahd->appAttrLocation =
 112                                                 cpu_to_le32(aal + size);
 113                         }
 114                         if (le32_to_cpu(eahd->impAttrLocation) <
 115                                         UDF_I_LENEATTR(inode)) {
 116                                 uint32_t ial =
 117                                         le32_to_cpu(eahd->impAttrLocation);
 118                                 memmove(&ea[offset - ial + size],
 119                                         &ea[ial], offset - ial);
 120                                 offset -= ial;
 121                                 eahd->impAttrLocation =
 122                                                 cpu_to_le32(ial + size);
 123                         }
 124                 } else if (type < 65536) {
 125                         if (le32_to_cpu(eahd->appAttrLocation) <
 126                                         UDF_I_LENEATTR(inode)) {
 127                                 uint32_t aal =
 128                                         le32_to_cpu(eahd->appAttrLocation);
 129                                 memmove(&ea[offset - aal + size],
 130                                         &ea[aal], offset - aal);
 131                                 offset -= aal;
 132                                 eahd->appAttrLocation =
 133                                                 cpu_to_le32(aal + size);
 134                         }
 135                 }
 136                 /* rewrite CRC + checksum of eahd */
 137                 crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
 138                 eahd->descTag.descCRCLength = cpu_to_le16(crclen);
 139                 eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
 140                                                 sizeof(tag), crclen, 0));
 141                 eahd->descTag.tagChecksum = 0;
 142                 for (i = 0; i < 16; i++)
 143                         if (i != 4)
 144                                 eahd->descTag.tagChecksum +=
 145                                         ((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 *udf_get_extendedattr(struct inode *inode, uint32_t type,
 156                                            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                 struct extendedAttrHeaderDesc *eahd;
 166                 eahd = (struct extendedAttrHeaderDesc *)ea;
 167
 168                 /* check checksum/crc */
 169                 if (le16_to_cpu(eahd->descTag.tagIdent) !=
 170                                 TAG_IDENT_EAHD ||
 171                     le32_to_cpu(eahd->descTag.tagLocation) !=
 172                                 UDF_I_LOCATION(inode).logicalBlockNum)
 173                         return NULL;
 174
 175                 if (type < 2048)
 176                         offset = sizeof(struct extendedAttrHeaderDesc);
 177                 else if (type < 65536)
 178                         offset = le32_to_cpu(eahd->impAttrLocation);
 179                 else
 180                         offset = le32_to_cpu(eahd->appAttrLocation);
 181
 182                 while (offset < UDF_I_LENEATTR(inode)) {
 183                         gaf = (struct genericFormat *)&ea[offset];
 184                         if (le32_to_cpu(gaf->attrType) == type &&
 185                                         gaf->attrSubtype == subtype)
 186                                 return gaf;
 187                         else
 188                                 offset += le32_to_cpu(gaf->attrLength);
 189                 }
 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 *udf_read_tagged(struct super_block *sb, uint32_t block,
 206                                     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         struct udf_sb_info *sbi = UDF_SB(sb);
 213
 214         /* Read the block */
 215         if (block == 0xFFFFFFFF)
 216                 return NULL;
 217
 218         bh = udf_tread(sb, block + sbi->s_session);
 219         if (!bh) {
 220                 udf_debug("block=%d, location=%d: read failed\n",
 221                           block + sbi->s_session, location);
 222                 return NULL;
 223         }
 224
 225         tag_p = (tag *)(bh->b_data);
 226
 227         *ident = le16_to_cpu(tag_p->tagIdent);
 228
 229         if (location != le32_to_cpu(tag_p->tagLocation)) {
 230                 udf_debug("location mismatch block %u, tag %u != %u\n",
 231                           block + sbi->s_session,
 232                           le32_to_cpu(tag_p->tagLocation), location);
 233                 goto error_out;
 234         }
 235
 236         /* Verify the tag checksum */
 237         checksum = 0U;
 238         for (i = 0; i < 4; i++)
 239                 checksum += (uint8_t)(bh->b_data[i]);
 240         for (i = 5; i < 16; i++)
 241                 checksum += (uint8_t)(bh->b_data[i]);
 242         if (checksum != tag_p->tagChecksum) {
 243                 printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
 244                 goto error_out;
 245         }
 246
 247         /* Verify the tag version */
 248         if (le16_to_cpu(tag_p->descVersion) != 0x0002U &&
 249             le16_to_cpu(tag_p->descVersion) != 0x0003U) {
 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                 return bh;
 260
 261         udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
 262                   block + sbi->s_session, le16_to_cpu(tag_p->descCRC),
 263                   le16_to_cpu(tag_p->descCRCLength));
 264
 265 error_out:
 266         brelse(bh);
 267         return NULL;
 268 }
 269
 270 struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
 271                                      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_update_tag(char *data, int length)
 278 {
 279         tag *tptr = (tag *)data;
 280         int i;
 281
 282         length -= sizeof(tag);
 283
 284         tptr->tagChecksum = 0;
 285         tptr->descCRCLength = cpu_to_le16(length);
 286         tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
 287
 288         for (i = 0; i < 16; i++)
 289                 if (i != 4)
 290                         tptr->tagChecksum += (uint8_t)(data[i]);
 291 }
 292
 293 void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
 294                  uint32_t loc, int length)
 295 {
 296         tag *tptr = (tag *)data;
 297         tptr->tagIdent = cpu_to_le16(ident);
 298         tptr->descVersion = cpu_to_le16(version);
 299         tptr->tagSerialNum = cpu_to_le16(snum);
 300         tptr->tagLocation = cpu_to_le32(loc);
 301         udf_update_tag(data, length);
 302 }