[IPV6] route: kill some bloat

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

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 382be7be5ae34e66b6619d5c7bab8e20852edd48..4360c7a05743727a3f7b94753057a5a831eb2b0b 100644 (file)
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -89,7 +89,7 @@ static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
 static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
 static void udf_load_fileset(struct super_block *, struct buffer_head *,
                             kernel_lb_addr *);
-static void udf_load_partdesc(struct super_block *, struct buffer_head *);
+static int udf_load_partdesc(struct super_block *, struct buffer_head *);
 static void udf_open_lvid(struct super_block *);
 static void udf_close_lvid(struct super_block *);
 static unsigned int udf_count_free(struct super_block *);
@@ -134,7 +134,7 @@ static void udf_destroy_inode(struct inode *inode)
        kmem_cache_free(udf_inode_cachep, UDF_I(inode));
 }
 
-static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
+static void init_once(struct kmem_cache *cachep, void *foo)
 {
        struct udf_inode_info *ei = (struct udf_inode_info *)foo;
 
@@ -877,7 +877,7 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
                  root->logicalBlockNum, root->partitionReferenceNum);
 }
 
-static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
+static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 {
        struct partitionDesc *p;
        int i;
@@ -912,6 +912,10 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 
                                        UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
                                                udf_iget(sb, loc);
+                                       if (!UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table) {
+                                               udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
+                                               return 1;
+                                       }
                                        UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE;
                                        udf_debug("unallocSpaceTable (part %d) @ %ld\n",
                                                  i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
@@ -938,6 +942,10 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 
                                        UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
                                                udf_iget(sb, loc);
+                                       if (!UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table) {
+                                               udf_debug("cannot load freedSpaceTable (part %d)\n", i);
+                                               return 1;
+                                       }
                                        UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
                                        udf_debug("freedSpaceTable (part %d) @ %ld\n",
                                                  i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
@@ -966,6 +974,7 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
                          le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i),
                          UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
        }
+       return 0;
 }
 
 static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
@@ -1177,12 +1186,19 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo
                                udf_load_logicalvol(sb, bh, fileset);
                        } else if (i == VDS_POS_PARTITION_DESC) {
                                struct buffer_head *bh2 = NULL;
-                               udf_load_partdesc(sb, bh);
+                               if (udf_load_partdesc(sb, bh)) {
+                                       brelse(bh);
+                                       return 1;
+                               }
                                for (j = vds[i].block + 1; j <  vds[VDS_POS_TERMINATING_DESC].block; j++) {
                                        bh2 = udf_read_tagged(sb, j, j, &ident);
                                        gd = (struct generic_desc *)bh2->b_data;
                                        if (ident == TAG_IDENT_PD)
-                                               udf_load_partdesc(sb, bh2);
+                                               if (udf_load_partdesc(sb, bh2)) {
+                                                       brelse(bh);
+                                                       brelse(bh2);
+                                                       return 1;
+                                               }
                                        brelse(bh2);
                                }
                        }
@@ -1275,19 +1291,16 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
 
                        if (!UDF_SB_LASTBLOCK(sb)) {
                                udf_debug("Unable to determine Lastblock (For "
-                                               "Virtual Partition)\n");
+                                         "Virtual Partition)\n");
                                return 1;
                        }
 
                        for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
-                               if (j != i && UDF_SB_PARTVSN(sb, i) ==
-                                       UDF_SB_PARTVSN(sb, j) &&
-                                       UDF_SB_PARTNUM(sb, i) ==
-                                               UDF_SB_PARTNUM(sb, j)) {
+                               if (j != i &&
+                                   UDF_SB_PARTVSN(sb, i) == UDF_SB_PARTVSN(sb, j) &&
+                                   UDF_SB_PARTNUM(sb, i) == UDF_SB_PARTNUM(sb, j)) {
                                        ino.partitionReferenceNum = j;
-                                       ino.logicalBlockNum =
-                                           UDF_SB_LASTBLOCK(sb) -
-                                           UDF_SB_PARTROOT(sb, j);
+                                       ino.logicalBlockNum = UDF_SB_LASTBLOCK(sb) - UDF_SB_PARTROOT(sb, j);
                                        break;
                                }
                        }
@@ -1300,9 +1313,9 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
 
                        if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
                                UDF_SB_TYPEVIRT(sb, i).s_start_offset =
-                                   udf_ext0_offset(UDF_SB_VAT(sb));
+                                       udf_ext0_offset(UDF_SB_VAT(sb));
                                UDF_SB_TYPEVIRT(sb, i).s_num_entries =
-                                   (UDF_SB_VAT(sb)->i_size - 36) >> 2;
+                                       (UDF_SB_VAT(sb)->i_size - 36) >> 2;
                        } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
                                struct buffer_head *bh = NULL;
                                uint32_t pos;
@@ -1312,19 +1325,15 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
                                if (!bh)
                                        return 1;
                                UDF_SB_TYPEVIRT(sb, i).s_start_offset =
-                                   le16_to_cpu(((struct
-                                       virtualAllocationTable20 *)bh->b_data +
-                                         udf_ext0_offset(UDF_SB_VAT(sb)))->
-                                               lengthHeader) +
-                                         udf_ext0_offset(UDF_SB_VAT(sb));
-                               UDF_SB_TYPEVIRT(sb, i).s_num_entries =
-                                   (UDF_SB_VAT(sb)->i_size -
-                                    UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
+                                       le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data +
+                                                    udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
+                                       udf_ext0_offset(UDF_SB_VAT(sb));
+                               UDF_SB_TYPEVIRT(sb, i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
+                                                                       UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
                                brelse(bh);
                        }
                        UDF_SB_PARTROOT(sb, i) = udf_get_pblock(sb, 0, i, 0);
-                       UDF_SB_PARTLEN(sb, i) = UDF_SB_PARTLEN(sb,
-                                               ino.partitionReferenceNum);
+                       UDF_SB_PARTLEN(sb, i) = UDF_SB_PARTLEN(sb, ino.partitionReferenceNum);
                }
        }
        return 0;
@@ -1339,21 +1348,17 @@ static void udf_open_lvid(struct super_block *sb)
                UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
                UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
                if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
-                       UDF_SB_LVID(sb)->recordingDateAndTime =
-                           cpu_to_lets(cpu_time);
+                       UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
                UDF_SB_LVID(sb)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
 
-               UDF_SB_LVID(sb)->descTag.descCRC =
-                   cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
-                                       le16_to_cpu(UDF_SB_LVID(sb)->descTag.
-                                                   descCRCLength), 0));
+               UDF_SB_LVID(sb)->descTag.descCRC = cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
+                                                                      le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
 
                UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
                for (i = 0; i < 16; i++)
                        if (i != 4)
                                UDF_SB_LVID(sb)->descTag.tagChecksum +=
-                                   ((uint8_t *) &
-                                    (UDF_SB_LVID(sb)->descTag))[i];
+                                       ((uint8_t *) &(UDF_SB_LVID(sb)->descTag))[i];
 
                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
        }