Merge branch 'omap-fixes'

[linux-2.6-omap-h63xx.git] / fs / udf / misc.c

diff --git a/fs/udf/misc.c b/fs/udf/misc.c
index 581b6e4cc591906d06e94a0a618663cea6b428a7..9215700c00a4448eedd1e5306cb2c3410f3f4b45 100644 (file)
--- a/fs/udf/misc.c
+++ b/fs/udf/misc.c
@@ -24,6 +24,7 @@
 #include <linux/fs.h>
 #include <linux/string.h>
 #include <linux/buffer_head.h>
+#include <linux/crc-itu-t.h>
 
 #include "udf_i.h"
 #include "udf_sb.h"
@@ -133,10 +134,10 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                        }
                }
                /* rewrite CRC + checksum of eahd */
-               crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
+               crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(struct tag);
                eahd->descTag.descCRCLength = cpu_to_le16(crclen);
-               eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
-                                               sizeof(tag), crclen, 0));
+               eahd->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)eahd +
+                                               sizeof(struct tag), crclen));
                eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
                iinfo->i_lenEAttr += size;
                return (struct genericFormat *)&ea[offset];
@@ -201,29 +202,27 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
 struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
                                    uint32_t location, uint16_t *ident)
 {
-       tag *tag_p;
+       struct tag *tag_p;
        struct buffer_head *bh = NULL;
-       struct udf_sb_info *sbi = UDF_SB(sb);
 
        /* Read the block */
        if (block == 0xFFFFFFFF)
                return NULL;
 
-       bh = udf_tread(sb, block + sbi->s_session);
+       bh = udf_tread(sb, block);
        if (!bh) {
                udf_debug("block=%d, location=%d: read failed\n",
-                         block + sbi->s_session, location);
+                         block, location);
                return NULL;
        }
 
-       tag_p = (tag *)(bh->b_data);
+       tag_p = (struct tag *)(bh->b_data);
 
        *ident = le16_to_cpu(tag_p->tagIdent);
 
        if (location != le32_to_cpu(tag_p->tagLocation)) {
                udf_debug("location mismatch block %u, tag %u != %u\n",
-                         block + sbi->s_session,
-                         le32_to_cpu(tag_p->tagLocation), location);
+                         block, le32_to_cpu(tag_p->tagLocation), location);
                goto error_out;
        }
 
@@ -242,41 +241,42 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
        }
 
        /* Verify the descriptor CRC */
-       if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize ||
-           le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag),
-                                       le16_to_cpu(tag_p->descCRCLength), 0))
+       if (le16_to_cpu(tag_p->descCRCLength) + sizeof(struct tag) > sb->s_blocksize ||
+           le16_to_cpu(tag_p->descCRC) == crc_itu_t(0,
+                                       bh->b_data + sizeof(struct tag),
+                                       le16_to_cpu(tag_p->descCRCLength)))
                return bh;
 
-       udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
-                 block + sbi->s_session, le16_to_cpu(tag_p->descCRC),
-                 le16_to_cpu(tag_p->descCRCLength));
+       udf_debug("Crc failure block %d: crc = %d, crclen = %d\n", block,
+           le16_to_cpu(tag_p->descCRC), le16_to_cpu(tag_p->descCRCLength));
 
 error_out:
        brelse(bh);
        return NULL;
 }
 
-struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
+struct buffer_head *udf_read_ptagged(struct super_block *sb,
+                                    struct kernel_lb_addr *loc,
                                     uint32_t offset, uint16_t *ident)
 {
        return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset),
-                              loc.logicalBlockNum + offset, ident);
+                              loc->logicalBlockNum + offset, ident);
 }
 
 void udf_update_tag(char *data, int length)
 {
-       tag *tptr = (tag *)data;
-       length -= sizeof(tag);
+       struct tag *tptr = (struct tag *)data;
+       length -= sizeof(struct tag);
 
        tptr->descCRCLength = cpu_to_le16(length);
-       tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
+       tptr->descCRC = cpu_to_le16(crc_itu_t(0, data + sizeof(struct tag), length));
        tptr->tagChecksum = udf_tag_checksum(tptr);
 }
 
 void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
                 uint32_t loc, int length)
 {
-       tag *tptr = (tag *)data;
+       struct tag *tptr = (struct tag *)data;
        tptr->tagIdent = cpu_to_le16(ident);
        tptr->descVersion = cpu_to_le16(version);
        tptr->tagSerialNum = cpu_to_le16(snum);
@@ -284,12 +284,12 @@ void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
        udf_update_tag(data, length);
 }
 
-u8 udf_tag_checksum(const tag *t)
+u8 udf_tag_checksum(const struct tag *t)
 {
        u8 *data = (u8 *)t;
        u8 checksum = 0;
        int i;
-       for (i = 0; i < sizeof(tag); ++i)
+       for (i = 0; i < sizeof(struct tag); ++i)
                if (i != 4) /* position of checksum */
                        checksum += data[i];
        return checksum;