[PATCH 00/24] udf: convert super_block macros to functions - Kernel

This is a discussion on [PATCH 00/24] udf: convert super_block macros to functions - Kernel ; Hi This patchset converts macros related to super_block handling into functions. Besides that it fixes some sparse warnings (23rd and 24th), improves coding style (1st) and fixes error handling (19th). Note that udf files has really long lines and these ...

+ Reply to Thread
Page 1 of 2 1 2 LastLast
Results 1 to 20 of 33

Thread: [PATCH 00/24] udf: convert super_block macros to functions

  1. [PATCH 00/24] udf: convert super_block macros to functions

    Hi
    This patchset converts macros related to super_block handling into
    functions. Besides that it fixes some sparse warnings (23rd and 24th),
    improves coding style (1st) and fixes error handling (19th).

    Note that udf files has really long lines and these patches won't validate
    by checkpatch. I'm going to do more cleanups later.

    PS: This is the first time I use git-send-email - tell me if I do something wrong.

    Marcin Slusarz
    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  2. [PATCH 18/24] udf: convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function

    - change UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps inline function
    - convert kmalloc + memset to kzalloc
    - check if kzalloc failed (partially)

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 6 ++++--
    fs/udf/udf_sb.h | 27 +++++++++++++++------------
    2 files changed, 19 insertions(+), 14 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index dcab9e8..4aef612 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1013,7 +1013,9 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,

    lvd = (struct logicalVolDesc *)bh->b_data;

    - UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));
    + i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
    + if (i != 0)
    + return i;

    for (i = 0, offset = 0;
    i < udf_sb_num_parts(sb) && offset < le32_to_cpu(lvd->mapTableLength);
    @@ -1214,7 +1216,7 @@ static int udf_process_sequence(struct super_block *sb, long block,
    if (i == VDS_POS_PRIMARY_VOL_DESC) {
    udf_load_pvoldesc(sb, bh);
    } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
    - udf_load_logicalvol(sb, bh, fileset);
    + udf_load_logicalvol(sb, bh, fileset); /* TODO: check return value */
    } else if (i == VDS_POS_PARTITION_DESC) {
    struct buffer_head *bh2 = NULL;
    if (udf_load_partdesc(sb, bh)) {
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index fa09d50..565c9ef 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -1,6 +1,8 @@
    #ifndef __LINUX_UDF_SB_H
    #define __LINUX_UDF_SB_H

    +#include
    +
    /* Since UDF 2.01 is ISO 13346 based... */
    #define UDF_SUPER_MAGIC 0x15013346

    @@ -46,6 +48,19 @@ static inline struct udf_part_map *udf_sb_partmaps(struct super_block *sb)
    return udf_sb(sb)->s_partmaps;
    }

    +static inline int __must_check udf_sb_alloc_partition_maps(struct super_block *sb, __u32 count)
    +{
    + struct udf_sb_info *info = udf_sb(sb);
    + info->s_partmaps = kzalloc(sizeof(struct udf_part_map) * count, GFP_KERNEL);
    + if (info->s_partmaps != NULL)
    + info->s_partitions = count;
    + else {
    + info->s_partitions = 0;
    + udf_error(sb, __FUNCTION__, "Unable to allocate space for %d partition maps", count);
    + }
    + return info->s_partmaps != NULL ? 0 : -ENOMEM;
    +}
    +
    static inline void udf_sb_free(struct super_block *sb)
    {
    struct udf_sb_info *sb_info = udf_sb(sb);
    @@ -123,18 +138,6 @@ static inline struct inode *udf_sb_vat_inode(struct super_block *sb)
    return udf_sb(sb)->s_vat_inode;
    }

    -#define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    -{\
    - udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    - if (udf_sb_partmaps(X) != NULL) {\
    - udf_sb(X)->s_partitions = Y;\
    - memset(udf_sb_partmaps(X), 0x00, sizeof(struct udf_part_map) * Y);\
    - } else {\
    - udf_sb(X)->s_partitions = 0;\
    - udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
    - }\
    -}
    -
    #define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
    {\
    int nr_groups = ((UDF_SB_PARTLEN((X),(Y)) + (sizeof(struct spaceBitmapDesc) << 3) +\
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  3. [PATCH 19/24] udf: check if udf_load_logicalvol failed

    udf_load_logicalvol may fail eg in out of memory conditions - check it
    and propagate error further

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 7 ++++++-
    1 files changed, 6 insertions(+), 1 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 4aef612..f8c5794 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1141,6 +1141,7 @@ static int udf_process_sequence(struct super_block *sb, long block,
    uint32_t vdsn;
    uint16_t ident;
    long next_s = 0, next_e = 0;
    + int ret;

    memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);

    @@ -1216,7 +1217,11 @@ static int udf_process_sequence(struct super_block *sb, long block,
    if (i == VDS_POS_PRIMARY_VOL_DESC) {
    udf_load_pvoldesc(sb, bh);
    } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
    - udf_load_logicalvol(sb, bh, fileset); /* TODO: check return value */
    + ret = udf_load_logicalvol(sb, bh, fileset);
    + if (ret != 0) {
    + brelse(bh);
    + return ret;
    + }
    } else if (i == VDS_POS_PARTITION_DESC) {
    struct buffer_head *bh2 = NULL;
    if (udf_load_partdesc(sb, bh)) {
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  4. [PATCH 08/24] udf: convert UDF_SB_ANCHOR macro to udf_sb_anchor function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 44 ++++++++++++++++++++++----------------------
    fs/udf/udf_sb.h | 6 +++++-
    2 files changed, 27 insertions(+), 23 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 903c0ec..0120ac6 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -677,20 +677,20 @@ static void udf_find_anchor(struct super_block *sb)
    if (ident == TAG_IDENT_AVDP) {
    if (location == last[i] - udf_sb_session(sb)) {
    lastblock = last[i] - udf_sb_session(sb);
    - UDF_SB_ANCHOR(sb)[0] = lastblock;
    - UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
    + udf_sb_anchor(sb)[0] = lastblock;
    + udf_sb_anchor(sb)[1] = lastblock - 256;
    } else if (location == udf_variable_to_fixed(last[i]) - udf_sb_session(sb)) {
    UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
    lastblock = udf_variable_to_fixed(last[i]) - udf_sb_session(sb);
    - UDF_SB_ANCHOR(sb)[0] = lastblock;
    - UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - udf_sb_session(sb);
    + udf_sb_anchor(sb)[0] = lastblock;
    + udf_sb_anchor(sb)[1] = lastblock - 256 - udf_sb_session(sb);
    } else {
    udf_debug("Anchor found at block %d, location mismatch %d.\n",
    last[i], location);
    }
    } else if (ident == TAG_IDENT_FE || ident == TAG_IDENT_EFE) {
    lastblock = last[i];
    - UDF_SB_ANCHOR(sb)[3] = 512;
    + udf_sb_anchor(sb)[3] = 512;
    } else {
    ident = location = 0;
    if (last[i] >= 256) {
    @@ -706,7 +706,7 @@ static void udf_find_anchor(struct super_block *sb)
    if (ident == TAG_IDENT_AVDP &&
    location == last[i] - 256 - udf_sb_session(sb)) {
    lastblock = last[i];
    - UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
    + udf_sb_anchor(sb)[1] = last[i] - 256;
    } else {
    ident = location = 0;
    if (last[i] >= 312 + udf_sb_session(sb)) {
    @@ -723,7 +723,7 @@ static void udf_find_anchor(struct super_block *sb)
    location == udf_variable_to_fixed(last[i]) - 256) {
    UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
    lastblock = udf_variable_to_fixed(last[i]);
    - UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
    + udf_sb_anchor(sb)[1] = lastblock - 256;
    }
    }
    }
    @@ -744,17 +744,17 @@ static void udf_find_anchor(struct super_block *sb)
    }
    }

    - for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
    - if (UDF_SB_ANCHOR(sb)[i]) {
    - bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
    - UDF_SB_ANCHOR(sb)[i], &ident);
    + for (i = 0; i < ARRAY_SIZE(udf_sb(sb)->s_anchor); i++) {
    + if (udf_sb_anchor(sb)[i]) {
    + bh = udf_read_tagged(sb, udf_sb_anchor(sb)[i],
    + udf_sb_anchor(sb)[i], &ident);
    if (!bh)
    - UDF_SB_ANCHOR(sb)[i] = 0;
    + udf_sb_anchor(sb)[i] = 0;
    else {
    brelse(bh);
    if ((ident != TAG_IDENT_AVDP) &&
    (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
    - UDF_SB_ANCHOR(sb)[i] = 0;
    + udf_sb_anchor(sb)[i] = 0;
    }
    }
    }
    @@ -1280,10 +1280,10 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    if (!sb)
    return 1;

    - for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
    - if (UDF_SB_ANCHOR(sb)[i] &&
    - (bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
    - UDF_SB_ANCHOR(sb)[i], &ident))) {
    + for (i = 0; i < ARRAY_SIZE(udf_sb(sb)->s_anchor); i++) {
    + if (udf_sb_anchor(sb)[i] &&
    + (bh = udf_read_tagged(sb, udf_sb_anchor(sb)[i],
    + udf_sb_anchor(sb)[i], &ident))) {
    anchor = (struct anchorVolDescPtr *)bh->b_data;

    /* Locate the main sequence */
    @@ -1308,11 +1308,11 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    }
    }

    - if (i == ARRAY_SIZE(UDF_SB_ANCHOR(sb))) {
    + if (i == ARRAY_SIZE(udf_sb(sb)->s_anchor)) {
    udf_debug("No Anchor block found\n");
    return 1;
    } else
    - udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
    + udf_debug("Using anchor in block %d\n", udf_sb_anchor(sb)[i]);

    for (i = 0; i < udf_sb_num_parts(sb); i++) {
    kernel_lb_addr uninitialized_var(ino);
    @@ -1513,9 +1513,9 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    udf_debug("Multi-session=%d\n", udf_sb_session(sb));

    UDF_SB_LASTBLOCK(sb) = uopt.lastblock;
    - UDF_SB_ANCHOR(sb)[0] = UDF_SB_ANCHOR(sb)[1] = 0;
    - UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
    - UDF_SB_ANCHOR(sb)[3] = 256;
    + udf_sb_anchor(sb)[0] = udf_sb_anchor(sb)[1] = 0;
    + udf_sb_anchor(sb)[2] = uopt.anchor;
    + udf_sb_anchor(sb)[3] = 256;

    if (udf_check_valid(sb, uopt.novrs, silent)) {
    /* read volume recognition sequences */
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index f33d38e..f00524f 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -75,6 +75,11 @@ static inline __s32 udf_sb_session(struct super_block *sb)
    return udf_sb(sb)->s_session;
    }

    +static inline __u32 *udf_sb_anchor(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_anchor;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -139,7 +144,6 @@ static inline __s32 udf_sb_session(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_ANCHOR(X) ( udf_sb(X)->s_anchor )
    #define UDF_SB_LASTBLOCK(X) ( udf_sb(X)->s_lastblock )
    #define UDF_SB_LVIDBH(X) ( udf_sb(X)->s_lvidbh )
    #define UDF_SB_LVID(X) ( (struct logicalVolIntegrityDesc *)UDF_SB_LVIDBH(X)->b_data )
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  5. [PATCH 05/24] udf: convert UDF_SB_NUMPARTS macro to udf_sb_num_parts function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/partition.c | 6 +++---
    fs/udf/super.c | 20 ++++++++++----------
    fs/udf/udf_sb.h | 10 +++++++---
    3 files changed, 20 insertions(+), 16 deletions(-)

    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index aaab24c..c904ddf 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -31,7 +31,7 @@
    inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
    uint16_t partition, uint32_t offset)
    {
    - if (partition >= UDF_SB_NUMPARTS(sb)) {
    + if (partition >= udf_sb_num_parts(sb)) {
    udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
    block, partition, offset);
    return 0xFFFFFFFF;
    @@ -133,7 +133,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    uint32_t packet;
    int i, j, k, l;

    - for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    + for (i = 0; i < udf_sb_num_parts(sb); i++) {
    if (old_block > UDF_SB_PARTROOT(sb,i) &&
    old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
    sdata = &UDF_SB_TYPESPAR(sb,i);
    @@ -194,7 +194,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    } /* if old_block */
    }

    - if (i == UDF_SB_NUMPARTS(sb)) {
    + if (i == udf_sb_num_parts(sb)) {
    /* outside of partitions */
    /* for now, fail =) */
    return 1;
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 42de326..10eaba7 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -790,7 +790,7 @@ static int udf_find_fileset(struct super_block *sb,
    /* --> cvg: FIXME - is it reasonable? */
    return 1;

    - for (newfileset.partitionReferenceNum = UDF_SB_NUMPARTS(sb) - 1;
    + for (newfileset.partitionReferenceNum = udf_sb_num_parts(sb) - 1;
    (newfileset.partitionReferenceNum != 0xFFFF &&
    fileset->logicalBlockNum == 0xFFFFFFFF &&
    fileset->partitionReferenceNum == 0xFFFF);
    @@ -907,7 +907,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)

    p = (struct partitionDesc *)bh->b_data;

    - for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    + for (i = 0; i < udf_sb_num_parts(sb); i++) {
    udf_debug("Searching map: (%d == %d)\n",
    udf_sb_partmaps(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
    if (udf_sb_partmaps(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
    @@ -991,7 +991,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    break;
    }
    }
    - if (i == UDF_SB_NUMPARTS(sb)) {
    + if (i == udf_sb_num_parts(sb)) {
    udf_debug("Partition (%d) not found in partition map\n",
    le16_to_cpu(p->partitionNumber));
    } else {
    @@ -1016,7 +1016,7 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));

    for (i = 0, offset = 0;
    - i < UDF_SB_NUMPARTS(sb) && offset < le32_to_cpu(lvd->mapTableLength);
    + i < udf_sb_num_parts(sb) && offset < le32_to_cpu(lvd->mapTableLength);
    i++, offset += ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) {
    type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
    if (type == 1) {
    @@ -1314,7 +1314,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    } else
    udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);

    - for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    + for (i = 0; i < udf_sb_num_parts(sb); i++) {
    kernel_lb_addr uninitialized_var(ino);
    switch (UDF_SB_PARTTYPE(sb, i)) {
    case UDF_VIRTUAL_MAP15:
    @@ -1330,7 +1330,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    return 1;
    }

    - for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
    + for (j = 0; j < udf_sb_num_parts(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)) {
    @@ -1340,7 +1340,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    }
    }

    - if (j == UDF_SB_NUMPARTS(sb))
    + if (j == udf_sb_num_parts(sb))
    return 1;

    UDF_SB_VAT(sb) = udf_iget(sb, ino);
    @@ -1561,7 +1561,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
    }

    - if (!UDF_SB_NUMPARTS(sb)) {
    + if (!udf_sb_num_parts(sb)) {
    printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
    goto error_out;
    }
    @@ -1611,7 +1611,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    error_out:
    if (UDF_SB_VAT(sb))
    iput(UDF_SB_VAT(sb));
    - if (UDF_SB_NUMPARTS(sb)) {
    + if (udf_sb_num_parts(sb)) {
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    iput(udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    @@ -1686,7 +1686,7 @@ static void udf_put_super(struct super_block *sb)

    if (UDF_SB_VAT(sb))
    iput(UDF_SB_VAT(sb));
    - if (UDF_SB_NUMPARTS(sb)) {
    + if (udf_sb_num_parts(sb)) {
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    iput(udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index fa7fdff..983565d 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -60,14 +60,19 @@ static inline __u8 *udf_sb_volume_ident(struct super_block *sb)
    return udf_sb(sb)->s_volume_ident;
    }

    +static inline __u16 udf_sb_num_parts(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_partitions;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    if (udf_sb_partmaps(X) != NULL) {\
    - UDF_SB_NUMPARTS(X) = Y;\
    + udf_sb(X)->s_partitions = Y;\
    memset(udf_sb_partmaps(X), 0x00, sizeof(struct udf_part_map) * Y);\
    } else {\
    - UDF_SB_NUMPARTS(X) = 0;\
    + udf_sb(X)->s_partitions = 0;\
    udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
    }\
    }
    @@ -124,7 +129,6 @@ static inline __u8 *udf_sb_volume_ident(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_NUMPARTS(X) ( udf_sb(X)->s_partitions )
    #define UDF_SB_PARTITION(X) ( udf_sb(X)->s_partition )
    #define UDF_SB_SESSION(X) ( udf_sb(X)->s_session )
    #define UDF_SB_ANCHOR(X) ( udf_sb(X)->s_anchor )
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  6. [PATCH 12/24] udf: convert UDF_SB_LVIDIU macro to udf_sb_lvidiu function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/ialloc.c | 16 ++++++++--------
    fs/udf/super.c | 34 +++++++++++++++++-----------------
    fs/udf/udf_sb.h | 10 ++++++++--
    3 files changed, 33 insertions(+), 27 deletions(-)

    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index ddbf1e6..269f588 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -45,11 +45,11 @@ void udf_free_inode(struct inode *inode)
    mutex_lock(&sbi->s_alloc_mutex);
    if (sbi->s_lvid_bh) {
    if (S_ISDIR(inode->i_mode))
    - UDF_SB_LVIDIU(sb)->numDirs =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1);
    + udf_sb_lvidiu(sb)->numDirs =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvidiu(sb)->numDirs) - 1);
    else
    - UDF_SB_LVIDIU(sb)->numFiles =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);
    + udf_sb_lvidiu(sb)->numFiles =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvidiu(sb)->numFiles) - 1);

    mark_buffer_dirty(sbi->s_lvid_bh);
    }
    @@ -93,11 +93,11 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    uint64_t uniqueID;
    lvhd = (struct logicalVolHeaderDesc *)(udf_sb_lvid(sb)->logicalVolContentsUse);
    if (S_ISDIR(mode))
    - UDF_SB_LVIDIU(sb)->numDirs =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);
    + udf_sb_lvidiu(sb)->numDirs =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvidiu(sb)->numDirs) + 1);
    else
    - UDF_SB_LVIDIU(sb)->numFiles =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1);
    + udf_sb_lvidiu(sb)->numFiles =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvidiu(sb)->numFiles) + 1);
    UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
    if (!(++uniqueID & 0x00000000FFFFFFFFUL))
    uniqueID += 16;
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index f9109c5..6c14c4d 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -476,7 +476,7 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
    udf_sb(sb)->s_umask = uopt.umask;

    if (udf_sb_lvid_bh(sb)) {
    - int write_rev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
    + int write_rev = le16_to_cpu(udf_sb_lvidiu(sb)->minUDFWriteRev);
    if (write_rev > UDF_MAX_WRITE_VERSION)
    *flags |= MS_RDONLY;
    }
    @@ -1381,8 +1381,8 @@ static void udf_open_lvid(struct super_block *sb)
    int i;
    kernel_timestamp cpu_time;

    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
    + 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)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
    @@ -1407,16 +1407,16 @@ static void udf_close_lvid(struct super_block *sb)

    if (udf_sb_lvid_bh(sb) &&
    udf_sb_lvid(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
    - UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
    + 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);
    - if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
    - UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
    - if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
    - UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    - if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
    - UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    + if (UDF_MAX_WRITE_VERSION > le16_to_cpu(udf_sb_lvidiu(sb)->maxUDFWriteRev))
    + udf_sb_lvidiu(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
    + if (UDF_SB_UDFREV(sb) > le16_to_cpu(udf_sb_lvidiu(sb)->minUDFReadRev))
    + udf_sb_lvidiu(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    + if (UDF_SB_UDFREV(sb) > le16_to_cpu(udf_sb_lvidiu(sb)->minUDFWriteRev))
    + udf_sb_lvidiu(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    udf_sb_lvid(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);

    udf_sb_lvid(sb)->descTag.descCRC =
    @@ -1540,13 +1540,13 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    udf_debug("Lastblock=%d\n", udf_sb_last_block(sb));

    if (udf_sb_lvid_bh(sb)) {
    - uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
    - uint16_t minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
    - /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
    + uint16_t minUDFReadRev = le16_to_cpu(udf_sb_lvidiu(sb)->minUDFReadRev);
    + uint16_t minUDFWriteRev = le16_to_cpu(udf_sb_lvidiu(sb)->minUDFWriteRev);
    + /* uint16_t maxUDFWriteRev = le16_to_cpu(udf_sb_lvidiu(sb)->maxUDFWriteRev); */

    if (minUDFReadRev > UDF_MAX_READ_VERSION) {
    printk(KERN_ERR "UDF-fs: minUDFReadRev=%x (max is %x)\n",
    - le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev),
    + le16_to_cpu(udf_sb_lvidiu(sb)->minUDFReadRev),
    UDF_MAX_READ_VERSION);
    goto error_out;
    } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) {
    @@ -1735,8 +1735,8 @@ static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
    buf->f_bfree = udf_count_free(sb);
    buf->f_bavail = buf->f_bfree;
    buf->f_files = (udf_sb_lvid_bh(sb) ?
    - (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
    - le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;
    + (le32_to_cpu(udf_sb_lvidiu(sb)->numFiles) +
    + le32_to_cpu(udf_sb_lvidiu(sb)->numDirs)) : 0) + buf->f_bfree;
    buf->f_ffree = buf->f_bfree;
    /* __kernel_fsid_t f_fsid */
    buf->f_namelen = UDF_NAME_LEN - 2;
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index ac222f6..a9ff8fb 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -95,6 +95,14 @@ static inline struct logicalVolIntegrityDesc *udf_sb_lvid(struct super_block *sb
    return (struct logicalVolIntegrityDesc *)udf_sb_lvid_bh(sb)->b_data;
    }

    +static inline struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct super_block *sb)
    +{
    + struct logicalVolIntegrityDesc *lvid = udf_sb_lvid(sb);
    + __u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
    + __u32 offset = number_of_partitions * 2 * sizeof(uint32_t)/sizeof(uint8_t);
    + return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -159,8 +167,6 @@ static inline struct logicalVolIntegrityDesc *udf_sb_lvid(struct super_block *sb
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(udf_sb_lvid(X)->impUse[le32_to_cpu(udf_sb_lvid(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )
    -
    #define UDF_SB_UMASK(X) ( udf_sb(X)->s_umask )
    #define UDF_SB_GID(X) ( udf_sb(X)->s_gid )
    #define UDF_SB_UID(X) ( udf_sb(X)->s_uid )
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  7. [PATCH 17/24] udf: convert UDF_SB_VAT macro to udf_sb_vat_inode function

    - change UDF_SB_VAT macro to udf_sb_vat_inode inline function
    - rename s_vat field to s_vat_inode

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/partition.c | 6 +++---
    fs/udf/super.c | 24 ++++++++++++------------
    fs/udf/udf_sb.h | 6 +++++-
    include/linux/udf_fs_sb.h | 2 +-
    4 files changed, 21 insertions(+), 17 deletions(-)

    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index c904ddf..99640a6 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -67,7 +67,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
    }

    - loc = udf_block_map(UDF_SB_VAT(sb), newblock);
    + loc = udf_block_map(udf_sb_vat_inode(sb), newblock);

    if (!(bh = sb_bread(sb, loc))) {
    udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
    @@ -79,13 +79,13 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,

    brelse(bh);

    - if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReference Num == partition) {
    + if (UDF_I_LOCATION(udf_sb_vat_inode(sb)).partitionRef erenceNum == partition) {
    udf_debug("recursive call to udf_get_pblock!\n");
    return 0xFFFFFFFF;
    }

    return udf_get_pblock(sb, loc,
    - UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceN um,
    + UDF_I_LOCATION(udf_sb_vat_inode(sb)).partitionRefe renceNum,
    offset);
    }

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index c520543..dcab9e8 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1343,28 +1343,28 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    if (j == udf_sb_num_parts(sb))
    return 1;

    - UDF_SB_VAT(sb) = udf_iget(sb, ino);
    - if (!UDF_SB_VAT(sb))
    + udf_sb(sb)->s_vat_inode = udf_iget(sb, ino);
    + if (!udf_sb_vat_inode(sb))
    return 1;

    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_inode(sb));
    UDF_SB_TYPEVIRT(sb, i).s_num_entries =
    - (UDF_SB_VAT(sb)->i_size - 36) >> 2;
    + (udf_sb_vat_inode(sb)->i_size - 36) >> 2;
    } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
    struct buffer_head *bh = NULL;
    uint32_t pos;

    - pos = udf_block_map(UDF_SB_VAT(sb), 0);
    + pos = udf_block_map(udf_sb_vat_inode(sb), 0);
    bh = sb_bread(sb, pos);
    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_ext0_offset(udf_sb_vat_inode(sb)))->lengthHeader) +
    + udf_ext0_offset(udf_sb_vat_inode(sb));
    + UDF_SB_TYPEVIRT(sb, i).s_num_entries = (udf_sb_vat_inode(sb)->i_size -
    UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
    brelse(bh);
    }
    @@ -1609,8 +1609,8 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    return 0;

    error_out:
    - if (UDF_SB_VAT(sb))
    - iput(UDF_SB_VAT(sb));
    + if (udf_sb_vat_inode(sb))
    + iput(udf_sb_vat_inode(sb));
    if (udf_sb_num_parts(sb)) {
    if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    iput(udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_uspace.s_table);
    @@ -1684,8 +1684,8 @@ static void udf_put_super(struct super_block *sb)
    {
    int i;

    - if (UDF_SB_VAT(sb))
    - iput(UDF_SB_VAT(sb));
    + if (udf_sb_vat_inode(sb))
    + iput(udf_sb_vat_inode(sb));
    if (udf_sb_num_parts(sb)) {
    if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    iput(udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_uspace.s_table);
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index 53d77fc..fa09d50 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -118,6 +118,11 @@ static inline __u16 udf_sb_revision(struct super_block *sb)
    return udf_sb(sb)->s_udfrev;
    }

    +static inline struct inode *udf_sb_vat_inode(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_vat_inode;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -182,6 +187,5 @@ static inline __u16 udf_sb_revision(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_VAT(X) ( udf_sb(X)->s_vat )

    #endif /* __LINUX_UDF_SB_H */
    diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
    index dd16deb..9bc4735 100644
    --- a/include/linux/udf_fs_sb.h
    +++ b/include/linux/udf_fs_sb.h
    @@ -109,7 +109,7 @@ struct udf_sb_info
    struct nls_table *s_nls_map;

    /* VAT inode */
    - struct inode *s_vat;
    + struct inode *s_vat_inode;

    struct mutex s_alloc_mutex;
    };
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  8. [PATCH 22/24] udf: convert UDF_SB_ALLOC_BITMAP macro to udf_sb_alloc_bitmap function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 4 ++--
    fs/udf/udf_sb.h | 37 ++++++++++++++++++++-----------------
    2 files changed, 22 insertions(+), 19 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 33ccf66..1afea58 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -949,7 +949,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    i, map->s_uspace.s_table->i_ino);
    }
    if (phd->unallocSpaceBitmap.extLength) {
    - UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
    + map->s_uspace.s_bitmap = udf_sb_alloc_bitmap(sb, i);
    if (map->s_uspace.s_bitmap != NULL) {
    map->s_uspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->unallocSpaceBitmap.extLength);
    @@ -979,7 +979,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    i, map->s_fspace.s_table->i_ino);
    }
    if (phd->freedSpaceBitmap.extLength) {
    - UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
    + map->s_fspace.s_bitmap = udf_sb_alloc_bitmap(sb, i);
    if (map->s_fspace.s_bitmap != NULL) {
    map->s_fspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->freedSpaceBitmap.extLength);
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index a5805c5..4cf91f2 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -2,6 +2,7 @@
    #define __LINUX_UDF_SB_H

    #include
    +#include

    /* Since UDF 2.01 is ISO 13346 based... */
    #define UDF_SUPER_MAGIC 0x15013346
    @@ -149,23 +150,25 @@ static inline void udf_update_revision(struct super_block *sb, __u16 revision)
    udf_sb(sb)->s_udfrev = revision;
    }

    -#define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
    -{\
    - int nr_groups = ((udf_sb_partmap((X),(Y))->s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +\
    - ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
    - int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    - if (size <= PAGE_SIZE)\
    - udf_sb_partmaps(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
    - else\
    - udf_sb_partmaps(X)[(Y)].Z.s_bitmap = vmalloc(size);\
    - if (udf_sb_partmaps(X)[(Y)].Z.s_bitmap != NULL) {\
    - memset(udf_sb_partmaps(X)[(Y)].Z.s_bitmap, 0x00, size);\
    - udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
    - (struct buffer_head **)(udf_sb_partmaps(X)[(Y)].Z.s_bitmap + 1);\
    - udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
    - } else {\
    - udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
    - }\
    +static inline struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, __u32 index)
    +{
    + struct udf_part_map *map = udf_sb_partmap(sb, index);
    + int nr_groups = (map->s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +
    + (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
    + int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);
    + struct udf_bitmap *bitmap;
    +
    + if (size <= PAGE_SIZE)
    + bitmap = kmalloc(size, GFP_KERNEL);
    + else
    + bitmap = vmalloc(size);
    + if (bitmap != NULL) {
    + memset(bitmap, 0x00, size);
    + bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1);
    + bitmap->s_nr_groups = nr_groups;
    + } else
    + udf_error(sb, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);
    + return bitmap;
    }

    #define UDF_SB_FREE_BITMAP(X,Y,Z)\
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  9. [PATCH 01/24] udf: fix coding style of super.c

    fix coding style errors found by checkpatch:
    - assignments in if conditions
    - braces {} around single statement blocks
    - no spaces after commas
    - printks without KERN_*
    - lines longer than 80 characters
    before: total: 50 errors, 207 warnings, 1835 lines checked
    after: total: 0 errors, 164 warnings, 1872 lines checked

    all 164 warnings left are lines longer than 80 characters;
    this file has too much indentation with really long expressions
    to break all those lines

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 295 +++++++++++++++++++++++++++++++------------------------
    1 files changed, 166 insertions(+), 129 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 4360c7a..57788f1 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -33,8 +33,8 @@
    * 10/17/98 added freespace count for "df"
    * 11/11/98 gr added novrs option
    * 11/26/98 dgb added fileset,anchor mount options
    - * 12/06/98 blf really hosed things royally. vat/sparing support. sequenced vol descs
    - * rewrote option handling based on isofs
    + * 12/06/98 blf really hosed things royally. vat/sparing support. sequenced
    + * vol descs. rewrote option handling based on isofs
    * 12/20/98 find the free space bitmap (if it exists)
    */

    @@ -116,7 +116,7 @@ static struct kmem_cache *udf_inode_cachep;
    static struct inode *udf_alloc_inode(struct super_block *sb)
    {
    struct udf_inode_info *ei;
    - ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
    + ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
    if (!ei)
    return NULL;

    @@ -561,47 +561,52 @@ static int udf_vrs(struct super_block *sb, int silent)

    /* Look for ISO descriptors */
    vsd = (struct volStructDesc *)(bh->b_data +
    - (sector & (sb->s_blocksize - 1)));
    + (sector & (sb->s_blocksize - 1)));

    if (vsd->stdIdent[0] == 0) {
    brelse(bh);
    break;
    - } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) {
    + } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
    + VSD_STD_ID_LEN)) {
    iso9660 = sector;
    switch (vsd->structType) {
    case 0:
    udf_debug("ISO9660 Boot Record found\n");
    break;
    case 1:
    - udf_debug
    - ("ISO9660 Primary Volume Descriptor found\n");
    + udf_debug("ISO9660 Primary Volume Descriptor "
    + "found\n");
    break;
    case 2:
    - udf_debug
    - ("ISO9660 Supplementary Volume Descriptor found\n");
    + udf_debug("ISO9660 Supplementary Volume "
    + "Descriptor found\n");
    break;
    case 3:
    - udf_debug
    - ("ISO9660 Volume Partition Descriptor found\n");
    + udf_debug("ISO9660 Volume Partition Descriptor "
    + "found\n");
    break;
    case 255:
    - udf_debug
    - ("ISO9660 Volume Descriptor Set Terminator found\n");
    + udf_debug("ISO9660 Volume Descriptor Set "
    + "Terminator found\n");
    break;
    default:
    udf_debug("ISO9660 VRS (%u) found\n",
    vsd->structType);
    break;
    }
    - } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) {
    - } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN)) {
    + } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
    + VSD_STD_ID_LEN))
    + ; /* nothing */
    + else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
    + VSD_STD_ID_LEN)) {
    brelse(bh);
    break;
    - } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) {
    + } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
    + VSD_STD_ID_LEN))
    nsr02 = sector;
    - } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) {
    + else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
    + VSD_STD_ID_LEN))
    nsr03 = sector;
    - }
    brelse(bh);
    }

    @@ -658,21 +663,26 @@ static void udf_find_anchor(struct super_block *sb)
    * however, if the disc isn't closed, it could be 512 */

    for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
    - if (last[i] < 0 || !(bh = sb_bread(sb, last[i]))) {
    - ident = location = 0;
    - } else {
    - ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
    - location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
    - brelse(bh);
    + ident = location = 0;
    + if (last[i] >= 0) {
    + bh = sb_bread(sb, last[i]);
    + if (bh) {
    + tag *t = (tag *)bh->b_data;
    + ident = le16_to_cpu(t->tagIdent);
    + location = le32_to_cpu(t->tagLocation);
    + brelse(bh);
    + }
    }

    if (ident == TAG_IDENT_AVDP) {
    if (location == last[i] - UDF_SB_SESSION(sb)) {
    - lastblock = UDF_SB_ANCHOR(sb)[0] = last[i] - UDF_SB_SESSION(sb);
    - UDF_SB_ANCHOR(sb)[1] = last[i] - 256 - UDF_SB_SESSION(sb);
    + lastblock = last[i] - UDF_SB_SESSION(sb);
    + UDF_SB_ANCHOR(sb)[0] = lastblock;
    + UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
    } else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb)) {
    UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
    - lastblock = UDF_SB_ANCHOR(sb)[0] = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb);
    + lastblock = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb);
    + UDF_SB_ANCHOR(sb)[0] = lastblock;
    UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - UDF_SB_SESSION(sb);
    } else {
    udf_debug("Anchor found at block %d, location mismatch %d.\n",
    @@ -682,12 +692,15 @@ static void udf_find_anchor(struct super_block *sb)
    lastblock = last[i];
    UDF_SB_ANCHOR(sb)[3] = 512;
    } else {
    - if (last[i] < 256 || !(bh = sb_bread(sb, last[i] - 256))) {
    - ident = location = 0;
    - } else {
    - ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
    - location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
    - brelse(bh);
    + ident = location = 0;
    + if (last[i] >= 256) {
    + bh = sb_bread(sb, last[i] - 256);
    + if (bh) {
    + tag *t = (tag *)bh->b_data;
    + ident = le16_to_cpu(t->tagIdent);
    + location = le32_to_cpu(t->tagLocation);
    + brelse(bh);
    + }
    }

    if (ident == TAG_IDENT_AVDP &&
    @@ -695,13 +708,15 @@ static void udf_find_anchor(struct super_block *sb)
    lastblock = last[i];
    UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
    } else {
    - if (last[i] < 312 + UDF_SB_SESSION(sb) ||
    - !(bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb)))) {
    - ident = location = 0;
    - } else {
    - ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
    - location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
    - brelse(bh);
    + ident = location = 0;
    + if (last[i] >= 312 + UDF_SB_SESSION(sb)) {
    + bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb));
    + if (bh) {
    + tag *t = (tag *)bh->b_data;
    + ident = le16_to_cpu(t->tagIdent);
    + location = le32_to_cpu(t->tagLocation);
    + brelse(bh);
    + }
    }

    if (ident == TAG_IDENT_AVDP &&
    @@ -716,10 +731,12 @@ static void udf_find_anchor(struct super_block *sb)
    }

    if (!lastblock) {
    - /* We havn't found the lastblock. check 312 */
    - if ((bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb)))) {
    - ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
    - location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
    + /* We haven't found the lastblock. check 312 */
    + bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb));
    + if (bh) {
    + tag *t = (tag *)bh->b_data;
    + ident = le16_to_cpu(t->tagIdent);
    + location = le32_to_cpu(t->tagLocation);
    brelse(bh);

    if (ident == TAG_IDENT_AVDP && location == 256)
    @@ -729,15 +746,15 @@ static void udf_find_anchor(struct super_block *sb)

    for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
    if (UDF_SB_ANCHOR(sb)[i]) {
    - if (!(bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
    - UDF_SB_ANCHOR(sb)[i], &ident))) {
    + bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
    + UDF_SB_ANCHOR(sb)[i], &ident);
    + if (!bh)
    UDF_SB_ANCHOR(sb)[i] = 0;
    - } else {
    + else {
    brelse(bh);
    if ((ident != TAG_IDENT_AVDP) &&
    - (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE))) {
    + (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
    UDF_SB_ANCHOR(sb)[i] = 0;
    - }
    }
    }
    }
    @@ -745,7 +762,9 @@ static void udf_find_anchor(struct super_block *sb)
    UDF_SB_LASTBLOCK(sb) = lastblock;
    }

    -static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr *root)
    +static int udf_find_fileset(struct super_block *sb,
    + kernel_lb_addr *fileset,
    + kernel_lb_addr *root)
    {
    struct buffer_head *bh = NULL;
    long lastblock;
    @@ -764,7 +783,8 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker

    }

    - if (!bh) { /* Search backwards through the partitions */
    + if (!bh) {
    + /* Search backwards through the partitions */
    kernel_lb_addr newfileset;

    /* --> cvg: FIXME - is it reasonable? */
    @@ -775,11 +795,13 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker
    fileset->logicalBlockNum == 0xFFFFFFFF &&
    fileset->partitionReferenceNum == 0xFFFF);
    newfileset.partitionReferenceNum--) {
    - lastblock = UDF_SB_PARTLEN(sb, newfileset.partitionReferenceNum);
    + lastblock = UDF_SB_PARTLEN(sb,
    + newfileset.partitionReferenceNum);
    newfileset.logicalBlockNum = 0;

    do {
    - bh = udf_read_ptagged(sb, newfileset, 0, &ident);
    + bh = udf_read_ptagged(sb, newfileset, 0,
    + &ident);
    if (!bh) {
    newfileset.logicalBlockNum++;
    continue;
    @@ -840,7 +862,8 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
    lets_to_cpu(pvoldesc->recordingDateAndTime))) {
    kernel_timestamp ts;
    ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
    - udf_debug("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n",
    + udf_debug("recording time %ld/%ld, %04u/%02u/%02u"
    + " %02u:%02u (%x)\n",
    recording, recording_usec,
    ts.year, ts.month, ts.day, ts.hour,
    ts.minute, ts.typeAndTimezone);
    @@ -888,19 +911,21 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    udf_debug("Searching map: (%d == %d)\n",
    UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
    if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
    - UDF_SB_PARTLEN(sb,i) = le32_to_cpu(p->partitionLength); /* blocks */
    - UDF_SB_PARTROOT(sb,i) = le32_to_cpu(p->partitionStartingLocation);
    + UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength); /* blocks */
    + UDF_SB_PARTROOT(sb, i) = le32_to_cpu(p->partitionStartingLocation);
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_READ_ONLY;
    + UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_READ_ONLY;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE)
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_WRITE_ONCE;
    + UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_WRITE_ONCE;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE)
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_REWRITABLE;
    + UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_REWRITABLE;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE)
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_OVERWRITABLE;
    + UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_OVERWRITABLE;

    - if (!strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) ||
    - !strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03)) {
    + if (!strcmp(p->partitionContents.ident,
    + PD_PARTITION_CONTENTS_NSR02) ||
    + !strcmp(p->partitionContents.ident,
    + PD_PARTITION_CONTENTS_NSR03)) {
    struct partitionHeaderDesc *phd;

    phd = (struct partitionHeaderDesc *)(p->partitionContentsUse);
    @@ -916,7 +941,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
    return 1;
    }
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE;
    + 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);
    }
    @@ -927,7 +952,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    le32_to_cpu(phd->unallocSpaceBitmap.extLength);
    UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
    + UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
    udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
    i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
    }
    @@ -946,7 +971,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    udf_debug("cannot load freedSpaceTable (part %d)\n", i);
    return 1;
    }
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
    + 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);
    }
    @@ -957,7 +982,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    le32_to_cpu(phd->freedSpaceBitmap.extLength);
    UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->freedSpaceBitmap.extPosition);
    - UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_BITMAP;
    + UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_BITMAP;
    udf_debug("freedSpaceBitmap (part %d) @ %d\n",
    i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
    }
    @@ -970,9 +995,11 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    udf_debug("Partition (%d) not found in partition map\n",
    le16_to_cpu(p->partitionNumber));
    } else {
    - udf_debug("Partition (%d:%d type %x) starts at physical %d, block length %d\n",
    - le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i),
    - UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
    + udf_debug("Partition (%d:%d type %x) starts at physical %d, "
    + "block length %d\n",
    + le16_to_cpu(p->partitionNumber), i,
    + UDF_SB_PARTTYPE(sb, i), UDF_SB_PARTROOT(sb, i),
    + UDF_SB_PARTLEN(sb, i));
    }
    return 0;
    }
    @@ -994,19 +1021,19 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
    if (type == 1) {
    struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]);
    - UDF_SB_PARTTYPE(sb,i) = UDF_TYPE1_MAP15;
    - UDF_SB_PARTVSN(sb,i) = le16_to_cpu(gpm1->volSeqNum);
    - UDF_SB_PARTNUM(sb,i) = le16_to_cpu(gpm1->partitionNum);
    - UDF_SB_PARTFUNC(sb,i) = NULL;
    + UDF_SB_PARTTYPE(sb, i) = UDF_TYPE1_MAP15;
    + UDF_SB_PARTVSN(sb, i) = le16_to_cpu(gpm1->volSeqNum);
    + UDF_SB_PARTNUM(sb, i) = le16_to_cpu(gpm1->partitionNum);
    + UDF_SB_PARTFUNC(sb, i) = NULL;
    } else if (type == 2) {
    struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);
    if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) {
    if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) {
    - UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP15;
    - UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt15;
    + UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP15;
    + UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt15;
    } else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) {
    - UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP20;
    - UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt20;
    + UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP20;
    + UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt20;
    }
    } else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) {
    uint32_t loc;
    @@ -1014,39 +1041,41 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    struct sparingTable *st;
    struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]);

    - UDF_SB_PARTTYPE(sb,i) = UDF_SPARABLE_MAP15;
    - UDF_SB_TYPESPAR(sb,i).s_packet_len = le16_to_cpu(spm->packetLength);
    + UDF_SB_PARTTYPE(sb, i) = UDF_SPARABLE_MAP15;
    + UDF_SB_TYPESPAR(sb, i).s_packet_len = le16_to_cpu(spm->packetLength);
    for (j = 0; j < spm->numSparingTables; j++) {
    loc = le32_to_cpu(spm->locSparingTable[j]);
    - UDF_SB_TYPESPAR(sb,i).s_spar_map[j] =
    + UDF_SB_TYPESPAR(sb, i).s_spar_map[j] =
    udf_read_tagged(sb, loc, loc, &ident);
    - if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
    - st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,i).s_spar_map[j]->b_data;
    + if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] != NULL) {
    + st = (struct sparingTable *)UDF_SB_TYPESPAR(sb, i).s_spar_map[j]->b_data;
    if (ident != 0 ||
    strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) {
    - brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
    - UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
    + brelse(UDF_SB_TYPESPAR(sb, i).s_spar_map[j]);
    + UDF_SB_TYPESPAR(sb, i).s_spar_map[j] = NULL;
    }
    }
    }
    - UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_spar15;
    + UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_spar15;
    } else {
    - udf_debug("Unknown ident: %s\n", upm2->partIdent.ident);
    + udf_debug("Unknown ident: %s\n",
    + upm2->partIdent.ident);
    continue;
    }
    - UDF_SB_PARTVSN(sb,i) = le16_to_cpu(upm2->volSeqNum);
    - UDF_SB_PARTNUM(sb,i) = le16_to_cpu(upm2->partitionNum);
    + UDF_SB_PARTVSN(sb, i) = le16_to_cpu(upm2->volSeqNum);
    + UDF_SB_PARTNUM(sb, i) = le16_to_cpu(upm2->partitionNum);
    }
    udf_debug("Partition (%d:%d) type %d on volume %d\n",
    - i, UDF_SB_PARTNUM(sb,i), type, UDF_SB_PARTVSN(sb,i));
    + i, UDF_SB_PARTNUM(sb, i), type,
    + UDF_SB_PARTVSN(sb, i));
    }

    if (fileset) {
    long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);

    *fileset = lelb_to_cpu(la->extLocation);
    - udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
    - fileset->logicalBlockNum,
    + udf_debug("FileSet found in LogicalVolDesc at block=%d, "
    + "partition=%d\n", fileset->logicalBlockNum,
    fileset->partitionReferenceNum);
    }
    if (lvd->integritySeqExt.extLength)
    @@ -1071,7 +1100,8 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
    UDF_SB_LVIDBH(sb) = bh;

    if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
    - udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
    + udf_load_logicalvolint(sb,
    + leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));

    if (UDF_SB_LVIDBH(sb) != bh)
    brelse(bh);
    @@ -1097,8 +1127,8 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
    * July 1, 1997 - Andrew E. Mileski
    * Written, tested, and released.
    */
    -static int udf_process_sequence(struct super_block *sb, long block, long lastblock,
    - kernel_lb_addr *fileset)
    +static int udf_process_sequence(struct super_block *sb, long block,
    + long lastblock, kernel_lb_addr *fileset)
    {
    struct buffer_head *bh = NULL;
    struct udf_vds_record vds[VDS_POS_LENGTH];
    @@ -1178,7 +1208,8 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo
    }
    for (i = 0; i < VDS_POS_LENGTH; i++) {
    if (vds[i].block) {
    - bh = udf_read_tagged(sb, vds[i].block, vds[i].block, &ident);
    + bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
    + &ident);

    if (i == VDS_POS_PRIMARY_VOL_DESC) {
    udf_load_pvoldesc(sb, bh);
    @@ -1190,11 +1221,14 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo
    brelse(bh);
    return 1;
    }
    - for (j = vds[i].block + 1; j < vds[VDS_POS_TERMINATING_DESC].block; j++) {
    + 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)
    - if (udf_load_partdesc(sb, bh2)) {
    + if (udf_load_partdesc(sb,
    + bh2)) {
    brelse(bh);
    brelse(bh2);
    return 1;
    @@ -1222,14 +1256,16 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent)
    }
    /* Check that it is NSR02 compliant */
    /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
    - else if ((block = udf_vrs(sb, silent)) == -1) {
    - udf_debug("Failed to read byte 32768. Assuming open disc. "
    - "Skipping validity check\n");
    - if (!UDF_SB_LASTBLOCK(sb))
    - UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
    - return 0;
    - } else {
    - return !block;
    + else {
    + block = udf_vrs(sb, silent);
    + if (block == -1) {
    + udf_debug("Failed to read byte 32768. Assuming open "
    + "disc. Skipping validity check\n");
    + if (!UDF_SB_LASTBLOCK(sb))
    + UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
    + return 0;
    + } else
    + return !block;
    }
    }

    @@ -1252,7 +1288,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)

    /* Locate the main sequence */
    main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
    - main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength );
    + main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
    main_e = main_e >> sb->s_blocksize_bits;
    main_e += main_s;

    @@ -1267,9 +1303,8 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    /* Process the main & reserve sequences */
    /* responsible for finding the PartitionDesc(s) */
    if (!(udf_process_sequence(sb, main_s, main_e, fileset) &&
    - udf_process_sequence(sb, reserve_s, reserve_e, fileset))) {
    + udf_process_sequence(sb, reserve_s, reserve_e, fileset)))
    break;
    - }
    }
    }

    @@ -1308,7 +1343,8 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    if (j == UDF_SB_NUMPARTS(sb))
    return 1;

    - if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino)))
    + UDF_SB_VAT(sb) = udf_iget(sb, ino);
    + if (!UDF_SB_VAT(sb))
    return 1;

    if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
    @@ -1481,8 +1517,9 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
    UDF_SB_ANCHOR(sb)[3] = 256;

    - if (udf_check_valid(sb, uopt.novrs, silent)) { /* read volume recognition sequences */
    - printk("UDF-fs: No VRS found\n");
    + if (udf_check_valid(sb, uopt.novrs, silent)) {
    + /* read volume recognition sequences */
    + printk(KERN_WARNING "UDF-fs: No VRS found\n");
    goto error_out;
    }

    @@ -1496,7 +1533,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    sb->s_time_gran = 1000;

    if (udf_load_partition(sb, &fileset)) {
    - printk("UDF-fs: No partition found (1)\n");
    + printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
    goto error_out;
    }

    @@ -1508,7 +1545,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */

    if (minUDFReadRev > UDF_MAX_READ_VERSION) {
    - printk("UDF-fs: minUDFReadRev=%x (max is %x)\n",
    + printk(KERN_ERR "UDF-fs: minUDFReadRev=%x (max is %x)\n",
    le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev),
    UDF_MAX_READ_VERSION);
    goto error_out;
    @@ -1525,17 +1562,17 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    }

    if (!UDF_SB_NUMPARTS(sb)) {
    - printk("UDF-fs: No partition found (2)\n");
    + printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
    goto error_out;
    }

    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
    - printk("UDF-fs: Partition marked readonly; forcing readonly mount\n");
    + printk(KERN_NOTICE "UDF-fs: Partition marked readonly; forcing readonly mount\n");
    sb->s_flags |= MS_RDONLY;
    }

    if (udf_find_fileset(sb, &fileset, &rootdir)) {
    - printk("UDF-fs: No fileset found\n");
    + printk(KERN_WARNING "UDF-fs: No fileset found\n");
    goto error_out;
    }

    @@ -1556,7 +1593,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    /* perhaps it's not extensible enough, but for now ... */
    inode = udf_iget(sb, rootdir);
    if (!inode) {
    - printk("UDF-fs: Error in udf_iget, block=%d, partition=%d\n",
    + printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, partition=%d\n",
    rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
    goto error_out;
    }
    @@ -1564,7 +1601,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    /* Allocate a dentry for the root inode */
    sb->s_root = d_alloc_root(inode);
    if (!sb->s_root) {
    - printk("UDF-fs: Couldn't allocate root dentry\n");
    + printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
    iput(inode);
    goto error_out;
    }
    @@ -1580,9 +1617,9 @@ error_out:
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    - UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_uspace);
    + UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    - UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_fspace);
    + UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
    if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
    for (i = 0; i < 4; i++)
    brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
    @@ -1614,7 +1651,7 @@ void udf_error(struct super_block *sb, const char *function,
    va_start(args, fmt);
    vsnprintf(error_buf, sizeof(error_buf), fmt, args);
    va_end(args);
    - printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
    + printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
    sb->s_id, function, error_buf);
    }

    @@ -1655,9 +1692,9 @@ static void udf_put_super(struct super_block *sb)
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    - UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_uspace);
    + UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    - UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_fspace);
    + UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
    if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
    for (i = 0; i < 4; i++)
    brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
    @@ -1786,9 +1823,9 @@ static unsigned int udf_count_free_table(struct super_block *sb, struct inode *t
    epos.offset = sizeof(struct unallocSpaceEntry);
    epos.bh = NULL;

    - while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
    + while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
    accum += (elen >> table->i_sb->s_blocksize_bits);
    - }
    +
    brelse(epos.bh);

    unlock_kernel();
    @@ -1811,22 +1848,22 @@ static unsigned int udf_count_free(struct super_block *sb)
    if (accum)
    return accum;

    - if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
    }
    - if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
    + if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
    }
    if (accum)
    return accum;

    - if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
    accum += udf_count_free_table(sb,
    UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    }
    - if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
    + if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
    accum += udf_count_free_table(sb,
    UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    }
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  10. [PATCH 16/24] udf: convert UDF_SB_UDFREV macro to udf_sb_revision function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/balloc.c | 2 +-
    fs/udf/inode.c | 14 +++++++-------
    fs/udf/misc.c | 2 +-
    fs/udf/namei.c | 2 +-
    fs/udf/super.c | 10 +++++-----
    fs/udf/truncate.c | 6 +++---
    fs/udf/udf_sb.h | 8 ++++++--
    7 files changed, 24 insertions(+), 20 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index 4c31666..23aae18 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -559,7 +559,7 @@ static void udf_table_free_blocks(struct super_block *sb,
    }
    epos.offset = sizeof(struct allocExtDesc);
    }
    - if (UDF_SB_UDFREV(sb) >= 0x0200)
    + if (udf_sb_revision(sb) >= 0x0200)
    udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
    epos.block.logicalBlockNum, sizeof(tag));
    else
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 46cf40c..1cdb381 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1537,7 +1537,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));

    fe->icbTag.flags = cpu_to_le16(icbflags);
    - if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
    + if (udf_sb_revision(inode->i_sb) >= 0x0200)
    fe->descTag.descVersion = cpu_to_le16(3);
    else
    fe->descTag.descVersion = cpu_to_le16(2);
    @@ -1667,7 +1667,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
    mark_inode_dirty(inode);
    }
    }
    - if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
    + if (udf_sb_revision(inode->i_sb) >= 0x0200)
    udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
    epos->block.logicalBlockNum, sizeof(tag));
    else
    @@ -1690,7 +1690,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
    }
    if (epos->bh) {
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + udf_sb_revision(inode->i_sb) >= 0x0201)
    udf_update_tag(epos->bh->b_data, loffset);
    else
    udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
    @@ -1711,7 +1711,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
    aed = (struct allocExtDesc *)epos->bh->b_data;
    aed->lengthAllocDescs =
    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
    - if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_sb_revision(inode->i_sb) >= 0x0201)
    udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
    else
    udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
    @@ -1754,7 +1754,7 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,

    if (epos->bh) {
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201) {
    + udf_sb_revision(inode->i_sb) >= 0x0201) {
    struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
    udf_update_tag(epos->bh->b_data,
    le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
    @@ -1907,7 +1907,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
    aed->lengthAllocDescs =
    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize));
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + udf_sb_revision(inode->i_sb) >= 0x0201)
    udf_update_tag(oepos.bh->b_data, oepos.offset - (2 * adsize));
    else
    udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
    @@ -1923,7 +1923,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
    aed->lengthAllocDescs =
    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + udf_sb_revision(inode->i_sb) >= 0x0201)
    udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
    else
    udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index 42d731a..4854573 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -84,7 +84,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    size -= sizeof(struct extendedAttrHeaderDesc);
    UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);
    eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
    - if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
    + if (udf_sb_revision(inode->i_sb) >= 0x0200)
    eahd->descTag.descVersion = cpu_to_le16(3);
    else
    eahd->descTag.descVersion = cpu_to_le16(2);
    diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    index 4a18bfc..d5ef33a 100644
    --- a/fs/udf/namei.c
    +++ b/fs/udf/namei.c
    @@ -535,7 +535,7 @@ add:
    }

    memset(cfi, 0, sizeof(struct fileIdentDesc));
    - if (UDF_SB_UDFREV(sb) >= 0x0200)
    + if (udf_sb_revision(sb) >= 0x0200)
    udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag));
    else
    udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag));
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 5a2c474..c520543 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1413,10 +1413,10 @@ static void udf_close_lvid(struct super_block *sb)
    udf_sb_lvid(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
    if (UDF_MAX_WRITE_VERSION > le16_to_cpu(udf_sb_lvidiu(sb)->maxUDFWriteRev))
    udf_sb_lvidiu(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
    - if (UDF_SB_UDFREV(sb) > le16_to_cpu(udf_sb_lvidiu(sb)->minUDFReadRev))
    - udf_sb_lvidiu(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    - if (UDF_SB_UDFREV(sb) > le16_to_cpu(udf_sb_lvidiu(sb)->minUDFWriteRev))
    - udf_sb_lvidiu(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    + if (udf_sb_revision(sb) > le16_to_cpu(udf_sb_lvidiu(sb)->minUDFReadRev))
    + udf_sb_lvidiu(sb)->minUDFReadRev = cpu_to_le16(udf_sb_revision(sb));
    + if (udf_sb_revision(sb) > le16_to_cpu(udf_sb_lvidiu(sb)->minUDFWriteRev))
    + udf_sb_lvidiu(sb)->minUDFWriteRev = cpu_to_le16(udf_sb_revision(sb));
    udf_sb_lvid(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);

    udf_sb_lvid(sb)->descTag.descCRC =
    @@ -1553,7 +1553,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    sb->s_flags |= MS_RDONLY;
    }

    - UDF_SB_UDFREV(sb) = minUDFWriteRev;
    + udf_sb(sb)->s_udfrev = minUDFWriteRev;

    if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
    UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
    diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
    index 7fc3912..79ba205 100644
    --- a/fs/udf/truncate.c
    +++ b/fs/udf/truncate.c
    @@ -163,7 +163,7 @@ void udf_discard_prealloc(struct inode *inode)
    cpu_to_le32(epos.offset -
    sizeof(struct allocExtDesc));
    if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
    + udf_sb_revision(inode->i_sb) >= 0x0201)
    udf_update_tag(epos.bh->b_data, epos.offset);
    else
    udf_update_tag(epos.bh->b_data,
    @@ -232,7 +232,7 @@ void udf_truncate_extents(struct inode *inode)
    aed->lengthAllocDescs =
    cpu_to_le32(lenalloc);
    if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(sb) >= 0x0201)
    + udf_sb_revision(sb) >= 0x0201)
    udf_update_tag(epos.bh->b_data,
    lenalloc +
    sizeof(struct allocExtDesc));
    @@ -271,7 +271,7 @@ void udf_truncate_extents(struct inode *inode)
    (struct allocExtDesc *)(epos.bh->b_data);
    aed->lengthAllocDescs = cpu_to_le32(lenalloc);
    if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
    - UDF_SB_UDFREV(sb) >= 0x0201)
    + udf_sb_revision(sb) >= 0x0201)
    udf_update_tag(epos.bh->b_data,
    lenalloc + sizeof(struct allocExtDesc));
    else
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index bae6a74..53d77fc 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -113,6 +113,11 @@ static inline __u16 udf_sb_serial_number(struct super_block *sb)
    return udf_sb(sb)->s_serial_number;
    }

    +static inline __u16 udf_sb_revision(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_udfrev;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -163,7 +168,7 @@ static inline __u16 udf_sb_serial_number(struct super_block *sb)
    #define UDF_SET_FLAG(X,Y) ( udf_sb(X)->s_flags |= ( 1 << (Y) ) )
    #define UDF_CLEAR_FLAG(X,Y) ( udf_sb(X)->s_flags &= ~( 1 << (Y) ) )

    -#define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > UDF_SB_UDFREV(X)) ? UDF_SB_UDFREV(X) = (Y) : UDF_SB_UDFREV(X) )
    +#define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > udf_sb_revision(X)) ? udf_sb(X)->s_udfrev = (Y) : udf_sb_revision(X) )

    #define UDF_SB_PARTTYPE(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_type )
    #define UDF_SB_PARTROOT(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_root )
    @@ -177,7 +182,6 @@ static inline __u16 udf_sb_serial_number(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_UDFREV(X) ( udf_sb(X)->s_udfrev )
    #define UDF_SB_VAT(X) ( udf_sb(X)->s_vat )

    #endif /* __LINUX_UDF_SB_H */
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  11. [PATCH 11/24] udf: convert UDF_SB_LVID macro to udf_sb_lvid function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/balloc.c | 24 ++++++++++++------------
    fs/udf/ialloc.c | 2 +-
    fs/udf/namei.c | 4 ++--
    fs/udf/super.c | 40 ++++++++++++++++++++--------------------
    fs/udf/udf_sb.h | 8 ++++++--
    5 files changed, 41 insertions(+), 37 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index d689d16..4c31666 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -189,8 +189,8 @@ do_more:
    if (inode)
    DQUOT_FREE_BLOCK(inode, 1);
    if (udf_sb_lvid_bh(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[udf_sb_partition(sb)] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[udf_sb_partition(sb)]) + 1);
    + udf_sb_lvid(sb)->freeSpaceTable[udf_sb_partition(sb)] =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[udf_sb_partition(sb)]) + 1);
    }
    }
    }
    @@ -262,8 +262,8 @@ repeat:
    goto repeat;
    out:
    if (udf_sb_lvid_bh(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
    + udf_sb_lvid(sb)->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[partition]) - alloc_count);
    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    }
    sb->s_dirt = 1;
    @@ -390,8 +390,8 @@ got_block:
    mark_buffer_dirty(bh);

    if (udf_sb_lvid_bh(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
    + udf_sb_lvid(sb)->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[partition]) - 1);
    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    }
    sb->s_dirt = 1;
    @@ -433,8 +433,8 @@ static void udf_table_free_blocks(struct super_block *sb,
    if (inode)
    DQUOT_FREE_BLOCK(inode, count);
    if (udf_sb_lvid_bh(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[udf_sb_partition(sb)] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[udf_sb_partition(sb)]) + count);
    + udf_sb_lvid(sb)->freeSpaceTable[udf_sb_partition(sb)] =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[udf_sb_partition(sb)]) + count);
    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    }

    @@ -671,8 +671,8 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
    brelse(epos.bh);

    if (alloc_count && udf_sb_lvid_bh(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
    + udf_sb_lvid(sb)->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[partition]) - alloc_count);
    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    sb->s_dirt = 1;
    }
    @@ -772,8 +772,8 @@ static int udf_table_new_block(struct super_block *sb,
    brelse(goal_epos.bh);

    if (udf_sb_lvid_bh(sb)) {
    - UDF_SB_LVID(sb)->freeSpaceTable[partition] =
    - cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
    + udf_sb_lvid(sb)->freeSpaceTable[partition] =
    + cpu_to_le32(le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[partition]) - 1);
    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    }

    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index 5cfac06..ddbf1e6 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -91,7 +91,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    if (udf_sb_lvid_bh(sb)) {
    struct logicalVolHeaderDesc *lvhd;
    uint64_t uniqueID;
    - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse);
    + lvhd = (struct logicalVolHeaderDesc *)(udf_sb_lvid(sb)->logicalVolContentsUse);
    if (S_ISDIR(mode))
    UDF_SB_LVIDIU(sb)->numDirs =
    cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);
    diff --git a/fs/udf/namei.c b/fs/udf/namei.c
    index 4122d2b..4a18bfc 100644
    --- a/fs/udf/namei.c
    +++ b/fs/udf/namei.c
    @@ -1017,7 +1017,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
    if (udf_sb_lvid_bh(inode->i_sb)) {
    struct logicalVolHeaderDesc *lvhd;
    uint64_t uniqueID;
    - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
    + lvhd = (struct logicalVolHeaderDesc *)(udf_sb_lvid(inode->i_sb)->logicalVolContentsUse);
    uniqueID = le64_to_cpu(lvhd->uniqueID);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
    @@ -1069,7 +1069,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
    if (udf_sb_lvid_bh(inode->i_sb)) {
    struct logicalVolHeaderDesc *lvhd;
    uint64_t uniqueID;
    - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
    + lvhd = (struct logicalVolHeaderDesc *)(udf_sb_lvid(inode->i_sb)->logicalVolContentsUse);
    uniqueID = le64_to_cpu(lvhd->uniqueID);
    *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
    cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index b1f02a4..f9109c5 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1099,9 +1099,9 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
    ident == TAG_IDENT_LVID) {
    udf_sb(sb)->s_lvid_bh = bh;

    - if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
    + if (udf_sb_lvid(sb)->nextIntegrityExt.extLength)
    udf_load_logicalvolint(sb,
    - leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
    + leea_to_cpu(udf_sb_lvid(sb)->nextIntegrityExt));

    if (udf_sb_lvid_bh(sb) != bh)
    brelse(bh);
    @@ -1384,17 +1384,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)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
    + 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;
    + 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];
    + udf_sb_lvid(sb)->descTag.tagChecksum +=
    + ((uint8_t *) &(udf_sb_lvid(sb)->descTag))[i];

    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    }
    @@ -1406,28 +1406,28 @@ static void udf_close_lvid(struct super_block *sb)
    int i;

    if (udf_sb_lvid_bh(sb) &&
    - UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
    + udf_sb_lvid(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
    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);
    if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
    UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
    if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
    UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
    UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
    - UDF_SB_LVID(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
    + udf_sb_lvid(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);

    - 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;
    + 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];
    + udf_sb_lvid(sb)->descTag.tagChecksum +=
    + ((uint8_t *)&(udf_sb_lvid(sb)->descTag))[i];

    mark_buffer_dirty(udf_sb_lvid_bh(sb));
    }
    @@ -1838,8 +1838,8 @@ static unsigned int udf_count_free(struct super_block *sb)
    unsigned int accum = 0;

    if (udf_sb_lvid_bh(sb)) {
    - if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > udf_sb_partition(sb)) {
    - accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[udf_sb_partition(sb)]);
    + if (le32_to_cpu(udf_sb_lvid(sb)->numOfPartitions) > udf_sb_partition(sb)) {
    + accum = le32_to_cpu(udf_sb_lvid(sb)->freeSpaceTable[udf_sb_partition(sb)]);
    if (accum == 0xFFFFFFFF)
    accum = 0;
    }
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index dd0ba67..ac222f6 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -90,6 +90,11 @@ static inline struct buffer_head *udf_sb_lvid_bh(struct super_block *sb)
    return udf_sb(sb)->s_lvid_bh;
    }

    +static inline struct logicalVolIntegrityDesc *udf_sb_lvid(struct super_block *sb)
    +{
    + return (struct logicalVolIntegrityDesc *)udf_sb_lvid_bh(sb)->b_data;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -154,8 +159,7 @@ static inline struct buffer_head *udf_sb_lvid_bh(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_LVID(X) ( (struct logicalVolIntegrityDesc *)udf_sb_lvid_bh(X)->b_data )
    -#define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(UDF_SB_LVID(X)->impUse[le32_to_cpu(UDF_SB_LVID(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )
    +#define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(udf_sb_lvid(X)->impUse[le32_to_cpu(udf_sb_lvid(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )

    #define UDF_SB_UMASK(X) ( udf_sb(X)->s_umask )
    #define UDF_SB_GID(X) ( udf_sb(X)->s_gid )
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  12. [PATCH 15/24] udf: convert UDF_SB_SERIALNUM macro to udf_sb_serial_number function

    - change UDF_SB_SERIALNUM macro to udf_sb_serial_number inline function
    - rename s_serialnum field to s_serial_number

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/inode.c | 2 +-
    fs/udf/misc.c | 2 +-
    fs/udf/super.c | 2 +-
    fs/udf/udf_sb.h | 6 +++++-
    include/linux/udf_fs_sb.h | 2 +-
    5 files changed, 9 insertions(+), 5 deletions(-)

    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 8c725e2..46cf40c 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1541,7 +1541,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
    fe->descTag.descVersion = cpu_to_le16(3);
    else
    fe->descTag.descVersion = cpu_to_le16(2);
    - fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
    + fe->descTag.tagSerialNum = cpu_to_le16(udf_sb_serial_number(inode->i_sb));
    fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum) ;
    crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
    fe->descTag.descCRCLength = cpu_to_le16(crclen);
    diff --git a/fs/udf/misc.c b/fs/udf/misc.c
    index 95baad5..42d731a 100644
    --- a/fs/udf/misc.c
    +++ b/fs/udf/misc.c
    @@ -88,7 +88,7 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
    eahd->descTag.descVersion = cpu_to_le16(3);
    else
    eahd->descTag.descVersion = cpu_to_le16(2);
    - eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
    + eahd->descTag.tagSerialNum = cpu_to_le16(udf_sb_serial_number(inode->i_sb));
    eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum) ;
    eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
    eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index eb01f25..5a2c474 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -894,7 +894,7 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,

    *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);

    - UDF_SB_SERIALNUM(sb) = le16_to_cpu(fset->descTag.tagSerialNum);
    + udf_sb(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);

    udf_debug("Rootdir at block=%d, partition=%d\n",
    root->logicalBlockNum, root->partitionReferenceNum);
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index e9346c2..bae6a74 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -108,6 +108,11 @@ static inline struct timespec udf_sb_record_time(struct super_block *sb)
    return udf_sb(sb)->s_record_time;
    }

    +static inline __u16 udf_sb_serial_number(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_serial_number;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -172,7 +177,6 @@ static inline struct timespec udf_sb_record_time(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_SERIALNUM(X) ( udf_sb(X)->s_serialnum )
    #define UDF_SB_UDFREV(X) ( udf_sb(X)->s_udfrev )
    #define UDF_SB_VAT(X) ( udf_sb(X)->s_vat )

    diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
    index adfecc6..dd16deb 100644
    --- a/include/linux/udf_fs_sb.h
    +++ b/include/linux/udf_fs_sb.h
    @@ -97,7 +97,7 @@ struct udf_sb_info
    struct timespec s_record_time;

    /* Fileset Info */
    - __u16 s_serialnum;
    + __u16 s_serial_number;

    /* highest UDF revision we have recorded to this media */
    __u16 s_udfrev;
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  13. [PATCH 02/24] udf: rename UDF_SB to udf_sb

    rename UDF_SB function to udf_sb

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/balloc.c | 12 ++++++------
    fs/udf/ialloc.c | 4 ++--
    fs/udf/inode.c | 6 +++---
    fs/udf/super.c | 32 ++++++++++++++++----------------
    fs/udf/udf_sb.h | 42 +++++++++++++++++++++---------------------
    fs/udf/unicode.c | 4 ++--
    6 files changed, 50 insertions(+), 50 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index ab26176..8374c91 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -144,7 +144,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
    kernel_lb_addr bloc, uint32_t offset,
    uint32_t count)
    {
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    struct buffer_head *bh = NULL;
    unsigned long block;
    unsigned long block_group;
    @@ -214,7 +214,7 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    uint16_t partition, uint32_t first_block,
    uint32_t block_count)
    {
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    int alloc_count = 0;
    int bit, block, block_group, group_start;
    int nr_groups, bitmap_nr;
    @@ -276,7 +276,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
    struct udf_bitmap *bitmap, uint16_t partition,
    uint32_t goal, int *err)
    {
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    int newbit, bit = 0, block, block_group, group_start;
    int end_goal, nr_groups, bitmap_nr, i;
    struct buffer_head *bh = NULL;
    @@ -411,7 +411,7 @@ static void udf_table_free_blocks(struct super_block *sb,
    kernel_lb_addr bloc, uint32_t offset,
    uint32_t count)
    {
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    uint32_t start, end;
    uint32_t elen;
    kernel_lb_addr eloc;
    @@ -620,7 +620,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
    struct inode *table, uint16_t partition,
    uint32_t first_block, uint32_t block_count)
    {
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    int alloc_count = 0;
    uint32_t elen, adsize;
    kernel_lb_addr eloc;
    @@ -685,7 +685,7 @@ static int udf_table_new_block(struct super_block *sb,
    struct inode *table, uint16_t partition,
    uint32_t goal, int *err)
    {
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
    uint32_t newblock = 0, adsize;
    uint32_t elen, goal_elen = 0;
    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index 636d8f6..92dc9ae 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -31,7 +31,7 @@
    void udf_free_inode(struct inode *inode)
    {
    struct super_block *sb = inode->i_sb;
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);

    /*
    * Note: we must free any quota before locking the superblock,
    @@ -61,7 +61,7 @@ void udf_free_inode(struct inode *inode)
    struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    {
    struct super_block *sb = dir->i_sb;
    - struct udf_sb_info *sbi = UDF_SB(sb);
    + struct udf_sb_info *sbi = udf_sb(sb);
    struct inode *inode;
    int block;
    uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum;
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 1178ae0..5afa19e 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1133,13 +1133,13 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    if (inode->i_uid == -1 ||
    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_IGNORE) ||
    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
    - inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
    + inode->i_uid = udf_sb(inode->i_sb)->s_uid;

    inode->i_gid = le32_to_cpu(fe->gid);
    if (inode->i_gid == -1 ||
    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) ||
    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
    - inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
    + inode->i_gid = udf_sb(inode->i_sb)->s_gid;

    inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
    if (!inode->i_nlink)
    @@ -1149,7 +1149,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
    UDF_I_LENEXTENTS(inode) = inode->i_size;

    inode->i_mode = udf_convert_permissions(fe);
    - inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
    + inode->i_mode &= ~udf_sb(inode->i_sb)->s_umask;

    if (UDF_I_EFE(inode) == 0) {
    inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 57788f1..76c7dc4 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -462,18 +462,18 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
    {
    struct udf_options uopt;

    - uopt.flags = UDF_SB(sb)->s_flags;
    - uopt.uid = UDF_SB(sb)->s_uid;
    - uopt.gid = UDF_SB(sb)->s_gid;
    - uopt.umask = UDF_SB(sb)->s_umask;
    + uopt.flags = udf_sb(sb)->s_flags;
    + uopt.uid = udf_sb(sb)->s_uid;
    + uopt.gid = udf_sb(sb)->s_gid;
    + uopt.umask = udf_sb(sb)->s_umask;

    if (!udf_parse_options(options, &uopt))
    return -EINVAL;

    - UDF_SB(sb)->s_flags = uopt.flags;
    - UDF_SB(sb)->s_uid = uopt.uid;
    - UDF_SB(sb)->s_gid = uopt.gid;
    - UDF_SB(sb)->s_umask = uopt.umask;
    + udf_sb(sb)->s_flags = uopt.flags;
    + udf_sb(sb)->s_uid = uopt.uid;
    + udf_sb(sb)->s_gid = uopt.gid;
    + udf_sb(sb)->s_umask = uopt.umask;

    if (UDF_SB_LVIDBH(sb)) {
    int write_rev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
    @@ -1467,7 +1467,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    return -ENOMEM;

    sb->s_fs_info = sbi;
    - memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));
    + memset(udf_sb(sb), 0x00, sizeof(struct udf_sb_info));

    mutex_init(&sbi->s_alloc_mutex);

    @@ -1495,11 +1495,11 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    fileset.logicalBlockNum = 0xFFFFFFFF;
    fileset.partitionReferenceNum = 0xFFFF;

    - UDF_SB(sb)->s_flags = uopt.flags;
    - UDF_SB(sb)->s_uid = uopt.uid;
    - UDF_SB(sb)->s_gid = uopt.gid;
    - UDF_SB(sb)->s_umask = uopt.umask;
    - UDF_SB(sb)->s_nls_map = uopt.nls_map;
    + udf_sb(sb)->s_flags = uopt.flags;
    + udf_sb(sb)->s_uid = uopt.uid;
    + udf_sb(sb)->s_gid = uopt.gid;
    + udf_sb(sb)->s_umask = uopt.umask;
    + udf_sb(sb)->s_nls_map = uopt.nls_map;

    /* Set the block size for all transfers */
    if (!udf_set_blocksize(sb, uopt.blocksize))
    @@ -1627,7 +1627,7 @@ error_out:
    }
    #ifdef CONFIG_UDF_NLS
    if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
    - unload_nls(UDF_SB(sb)->s_nls_map);
    + unload_nls(udf_sb(sb)->s_nls_map);
    #endif
    if (!(sb->s_flags & MS_RDONLY))
    udf_close_lvid(sb);
    @@ -1702,7 +1702,7 @@ static void udf_put_super(struct super_block *sb)
    }
    #ifdef CONFIG_UDF_NLS
    if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
    - unload_nls(UDF_SB(sb)->s_nls_map);
    + unload_nls(udf_sb(sb)->s_nls_map);
    #endif
    if (!(sb->s_flags & MS_RDONLY))
    udf_close_lvid(sb);
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index 3c29820..e3cc83b 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -36,14 +36,14 @@
    #define UDF_PART_FLAG_REWRITABLE 0x0040
    #define UDF_PART_FLAG_OVERWRITABLE 0x0080

    -static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    +static inline struct udf_sb_info *udf_sb(struct super_block *sb)
    {
    return sb->s_fs_info;
    }

    #define UDF_SB_FREE(X)\
    {\
    - if (UDF_SB(X)) {\
    + if (udf_sb(X)) {\
    kfree(UDF_SB_PARTMAPS(X));\
    UDF_SB_PARTMAPS(X) = NULL;\
    }\
    @@ -95,13 +95,13 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    vfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
    }

    -#define UDF_QUERY_FLAG(X,Y) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )
    -#define UDF_SET_FLAG(X,Y) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )
    -#define UDF_CLEAR_FLAG(X,Y) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) )
    +#define UDF_QUERY_FLAG(X,Y) ( udf_sb(X)->s_flags & ( 1 << (Y) ) )
    +#define UDF_SET_FLAG(X,Y) ( udf_sb(X)->s_flags |= ( 1 << (Y) ) )
    +#define UDF_CLEAR_FLAG(X,Y) ( udf_sb(X)->s_flags &= ~( 1 << (Y) ) )

    #define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > UDF_SB_UDFREV(X)) ? UDF_SB_UDFREV(X) = (Y) : UDF_SB_UDFREV(X) )

    -#define UDF_SB_PARTMAPS(X) ( UDF_SB(X)->s_partmaps )
    +#define UDF_SB_PARTMAPS(X) ( udf_sb(X)->s_partmaps )
    #define UDF_SB_PARTTYPE(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_type )
    #define UDF_SB_PARTROOT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_root )
    #define UDF_SB_PARTLEN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_len )
    @@ -114,23 +114,23 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_VOLIDENT(X) ( UDF_SB(X)->s_volident )
    -#define UDF_SB_NUMPARTS(X) ( UDF_SB(X)->s_partitions )
    -#define UDF_SB_PARTITION(X) ( UDF_SB(X)->s_partition )
    -#define UDF_SB_SESSION(X) ( UDF_SB(X)->s_session )
    -#define UDF_SB_ANCHOR(X) ( UDF_SB(X)->s_anchor )
    -#define UDF_SB_LASTBLOCK(X) ( UDF_SB(X)->s_lastblock )
    -#define UDF_SB_LVIDBH(X) ( UDF_SB(X)->s_lvidbh )
    +#define UDF_SB_VOLIDENT(X) ( udf_sb(X)->s_volident )
    +#define UDF_SB_NUMPARTS(X) ( udf_sb(X)->s_partitions )
    +#define UDF_SB_PARTITION(X) ( udf_sb(X)->s_partition )
    +#define UDF_SB_SESSION(X) ( udf_sb(X)->s_session )
    +#define UDF_SB_ANCHOR(X) ( udf_sb(X)->s_anchor )
    +#define UDF_SB_LASTBLOCK(X) ( udf_sb(X)->s_lastblock )
    +#define UDF_SB_LVIDBH(X) ( udf_sb(X)->s_lvidbh )
    #define UDF_SB_LVID(X) ( (struct logicalVolIntegrityDesc *)UDF_SB_LVIDBH(X)->b_data )
    #define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(UDF_SB_LVID(X)->impUse[le32_to_cpu(UDF_SB_LVID(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )

    -#define UDF_SB_UMASK(X) ( UDF_SB(X)->s_umask )
    -#define UDF_SB_GID(X) ( UDF_SB(X)->s_gid )
    -#define UDF_SB_UID(X) ( UDF_SB(X)->s_uid )
    -#define UDF_SB_RECORDTIME(X) ( UDF_SB(X)->s_recordtime )
    -#define UDF_SB_SERIALNUM(X) ( UDF_SB(X)->s_serialnum )
    -#define UDF_SB_UDFREV(X) ( UDF_SB(X)->s_udfrev )
    -#define UDF_SB_FLAGS(X) ( UDF_SB(X)->s_flags )
    -#define UDF_SB_VAT(X) ( UDF_SB(X)->s_vat )
    +#define UDF_SB_UMASK(X) ( udf_sb(X)->s_umask )
    +#define UDF_SB_GID(X) ( udf_sb(X)->s_gid )
    +#define UDF_SB_UID(X) ( udf_sb(X)->s_uid )
    +#define UDF_SB_RECORDTIME(X) ( udf_sb(X)->s_recordtime )
    +#define UDF_SB_SERIALNUM(X) ( udf_sb(X)->s_serialnum )
    +#define UDF_SB_UDFREV(X) ( udf_sb(X)->s_udfrev )
    +#define UDF_SB_FLAGS(X) ( udf_sb(X)->s_flags )
    +#define UDF_SB_VAT(X) ( udf_sb(X)->s_vat )

    #endif /* __LINUX_UDF_SB_H */
    diff --git a/fs/udf/unicode.c b/fs/udf/unicode.c
    index 9e6099c..a050727 100644
    --- a/fs/udf/unicode.c
    +++ b/fs/udf/unicode.c
    @@ -340,7 +340,7 @@ int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname,
    return 0;
    }
    } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
    - if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
    + if (!udf_CS0toNLS(udf_sb(sb)->s_nls_map, &filename, &unifilename)) {
    udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
    return 0;
    }
    @@ -373,7 +373,7 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname,
    return 0;
    }
    } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
    - namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN);
    + namelen = udf_NLStoCS0(udf_sb(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN);
    if (!namelen) {
    return 0;
    }
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  14. [PATCH 04/24] udf: convert UDF_SB_VOLIDENT macro to udf_sb_volume_ident function

    - change UDF_SB_VOLIDENT macro to udf_sb_volume_ident inline function
    - rename s_volident field to s_volume_ident

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/file.c | 2 +-
    fs/udf/super.c | 6 +++---
    fs/udf/udf_sb.h | 6 +++++-
    include/linux/udf_fs_sb.h | 2 +-
    4 files changed, 10 insertions(+), 6 deletions(-)

    diff --git a/fs/udf/file.c b/fs/udf/file.c
    index 7c7a1b3..7b61dae 100644
    --- a/fs/udf/file.c
    +++ b/fs/udf/file.c
    @@ -192,7 +192,7 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
    switch (cmd) {
    case UDF_GETVOLIDENT:
    return copy_to_user((char __user *)arg,
    - UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
    + udf_sb_volume_ident(inode->i_sb), 32) ? -EFAULT : 0;
    case UDF_RELOCATE_BLOCKS:
    if (!capable(CAP_SYS_ADMIN))
    return -EACCES;
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 2c68272..42de326 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -873,9 +873,9 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)

    if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) {
    if (udf_CS0toUTF8(&outstr, &instr)) {
    - strncpy(UDF_SB_VOLIDENT(sb), outstr.u_name,
    + strncpy(udf_sb_volume_ident(sb), outstr.u_name,
    outstr.u_len > 31 ? 31 : outstr.u_len);
    - udf_debug("volIdent[] = '%s'\n", UDF_SB_VOLIDENT(sb));
    + udf_debug("volIdent[] = '%s'\n", udf_sb_volume_ident(sb));
    }
    }

    @@ -1582,7 +1582,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    udf_info("UDF %s (%s) Mounting volume '%s', "
    "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
    UDFFS_VERSION, UDFFS_DATE,
    - UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
    + udf_sb_volume_ident(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
    ts.typeAndTimezone);
    }
    if (!(sb->s_flags & MS_RDONLY))
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index 46ddfb0..fa7fdff 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -55,6 +55,11 @@ static inline void udf_sb_free(struct super_block *sb)
    }
    }

    +static inline __u8 *udf_sb_volume_ident(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_volume_ident;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -119,7 +124,6 @@ static inline void udf_sb_free(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_VOLIDENT(X) ( udf_sb(X)->s_volident )
    #define UDF_SB_NUMPARTS(X) ( udf_sb(X)->s_partitions )
    #define UDF_SB_PARTITION(X) ( udf_sb(X)->s_partition )
    #define UDF_SB_SESSION(X) ( udf_sb(X)->s_session )
    diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
    index 80ae9ef..a1addf6 100644
    --- a/include/linux/udf_fs_sb.h
    +++ b/include/linux/udf_fs_sb.h
    @@ -75,7 +75,7 @@ struct udf_part_map
    struct udf_sb_info
    {
    struct udf_part_map *s_partmaps;
    - __u8 s_volident[32];
    + __u8 s_volume_ident[32];

    /* Overall info */
    __u16 s_partitions;
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  15. [PATCH 03/24] udf: convert some macros to inline functions

    macro UDF_SB_PARTMAPS -> function udf_sb_partmaps
    macro UDF_SB_FREE -> function udf_sb_free

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/balloc.c | 24 ++++++++++----------
    fs/udf/super.c | 52 ++++++++++++++++++++++----------------------
    fs/udf/udf_sb.h | 65 +++++++++++++++++++++++++++++-------------------------
    3 files changed, 73 insertions(+), 68 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index 8374c91..b5d09ae 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -792,19 +792,19 @@ inline void udf_free_blocks(struct super_block *sb,

    if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    return udf_bitmap_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
    + udf_sb_partmaps(sb)[partition].s_uspace.s_bitmap,
    bloc, offset, count);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
    + udf_sb_partmaps(sb)[partition].s_uspace.s_table,
    bloc, offset, count);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
    + udf_sb_partmaps(sb)[partition].s_fspace.s_bitmap,
    bloc, offset, count);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_free_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
    + udf_sb_partmaps(sb)[partition].s_fspace.s_table,
    bloc, offset, count);
    } else {
    return;
    @@ -818,19 +818,19 @@ inline int udf_prealloc_blocks(struct super_block *sb,
    {
    if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    return udf_bitmap_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
    + udf_sb_partmaps(sb)[partition].s_uspace.s_bitmap,
    partition, first_block, block_count);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
    + udf_sb_partmaps(sb)[partition].s_uspace.s_table,
    partition, first_block, block_count);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
    + udf_sb_partmaps(sb)[partition].s_fspace.s_bitmap,
    partition, first_block, block_count);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_prealloc_blocks(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
    + udf_sb_partmaps(sb)[partition].s_fspace.s_table,
    partition, first_block, block_count);
    } else {
    return 0;
    @@ -845,20 +845,20 @@ inline int udf_new_block(struct super_block *sb,

    if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    ret = udf_bitmap_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
    + udf_sb_partmaps(sb)[partition].s_uspace.s_bitmap,
    partition, goal, err);
    return ret;
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
    + udf_sb_partmaps(sb)[partition].s_uspace.s_table,
    partition, goal, err);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
    + udf_sb_partmaps(sb)[partition].s_fspace.s_bitmap,
    partition, goal, err);
    } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_new_block(sb, inode,
    - UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
    + udf_sb_partmaps(sb)[partition].s_fspace.s_table,
    partition, goal, err);
    } else {
    *err = -EIO;
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 76c7dc4..2c68272 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -909,8 +909,8 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)

    for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
    udf_debug("Searching map: (%d == %d)\n",
    - UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
    - if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
    + udf_sb_partmaps(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
    + if (udf_sb_partmaps(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
    UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength); /* blocks */
    UDF_SB_PARTROOT(sb, i) = le32_to_cpu(p->partitionStartingLocation);
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
    @@ -935,26 +935,26 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    .partitionReferenceNum = i,
    };

    - UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
    + udf_sb_partmaps(sb)[i].s_uspace.s_table =
    udf_iget(sb, loc);
    - if (!UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table) {
    + 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);
    + i, udf_sb_partmaps(sb)[i].s_uspace.s_table->i_ino);
    }
    if (phd->unallocSpaceBitmap.extLength) {
    UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
    - if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL) {
    - UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength =
    + if (udf_sb_partmaps(sb)[i].s_uspace.s_bitmap != NULL) {
    + udf_sb_partmaps(sb)[i].s_uspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->unallocSpaceBitmap.extLength);
    - UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
    + udf_sb_partmaps(sb)[i].s_uspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
    UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
    udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
    - i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
    + i, udf_sb_partmaps(sb)[i].s_uspace.s_bitmap->s_extPosition);
    }
    }
    if (phd->partitionIntegrityTable.extLength)
    @@ -965,26 +965,26 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    .partitionReferenceNum = i,
    };

    - UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
    + udf_sb_partmaps(sb)[i].s_fspace.s_table =
    udf_iget(sb, loc);
    - if (!UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table) {
    + 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);
    + i, udf_sb_partmaps(sb)[i].s_fspace.s_table->i_ino);
    }
    if (phd->freedSpaceBitmap.extLength) {
    UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
    - if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL) {
    - UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength =
    + if (udf_sb_partmaps(sb)[i].s_fspace.s_bitmap != NULL) {
    + udf_sb_partmaps(sb)[i].s_fspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->freedSpaceBitmap.extLength);
    - UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
    + udf_sb_partmaps(sb)[i].s_fspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->freedSpaceBitmap.extPosition);
    UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_BITMAP;
    udf_debug("freedSpaceBitmap (part %d) @ %d\n",
    - i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
    + i, udf_sb_partmaps(sb)[i].s_fspace.s_bitmap->s_extPosition);
    }
    }
    }
    @@ -1613,9 +1613,9 @@ error_out:
    iput(UDF_SB_VAT(sb));
    if (UDF_SB_NUMPARTS(sb)) {
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    + iput(udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    + iput(udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    @@ -1632,7 +1632,7 @@ error_out:
    if (!(sb->s_flags & MS_RDONLY))
    udf_close_lvid(sb);
    brelse(UDF_SB_LVIDBH(sb));
    - UDF_SB_FREE(sb);
    + udf_sb_free(sb);
    kfree(sbi);
    sb->s_fs_info = NULL;

    @@ -1688,9 +1688,9 @@ static void udf_put_super(struct super_block *sb)
    iput(UDF_SB_VAT(sb));
    if (UDF_SB_NUMPARTS(sb)) {
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    + iput(udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
    - iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    + iput(udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    @@ -1707,7 +1707,7 @@ static void udf_put_super(struct super_block *sb)
    if (!(sb->s_flags & MS_RDONLY))
    udf_close_lvid(sb);
    brelse(UDF_SB_LVIDBH(sb));
    - UDF_SB_FREE(sb);
    + udf_sb_free(sb);
    kfree(sb->s_fs_info);
    sb->s_fs_info = NULL;
    }
    @@ -1850,22 +1850,22 @@ static unsigned int udf_count_free(struct super_block *sb)

    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
    + udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
    }
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
    + udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
    }
    if (accum)
    return accum;

    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
    accum += udf_count_free_table(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    + udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
    }
    if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
    accum += udf_count_free_table(sb,
    - UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    + udf_sb_partmaps(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
    }

    return accum;
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index e3cc83b..46ddfb0 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -41,20 +41,26 @@ static inline struct udf_sb_info *udf_sb(struct super_block *sb)
    return sb->s_fs_info;
    }

    -#define UDF_SB_FREE(X)\
    -{\
    - if (udf_sb(X)) {\
    - kfree(UDF_SB_PARTMAPS(X));\
    - UDF_SB_PARTMAPS(X) = NULL;\
    - }\
    +static inline struct udf_part_map *udf_sb_partmaps(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_partmaps;
    +}
    +
    +static inline void udf_sb_free(struct super_block *sb)
    +{
    + struct udf_sb_info *sb_info = udf_sb(sb);
    + if (sb_info) {
    + kfree(sb_info->s_partmaps);
    + sb_info->s_partmaps = NULL;
    + }
    }

    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    - UDF_SB_PARTMAPS(X) = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    - if (UDF_SB_PARTMAPS(X) != NULL) {\
    + udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    + if (udf_sb_partmaps(X) != NULL) {\
    UDF_SB_NUMPARTS(X) = Y;\
    - memset(UDF_SB_PARTMAPS(X), 0x00, sizeof(struct udf_part_map) * Y);\
    + memset(udf_sb_partmaps(X), 0x00, sizeof(struct udf_part_map) * Y);\
    } else {\
    UDF_SB_NUMPARTS(X) = 0;\
    udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
    @@ -67,14 +73,14 @@ static inline struct udf_sb_info *udf_sb(struct super_block *sb)
    ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
    int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    if (size <= PAGE_SIZE)\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
    + udf_sb_partmaps(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
    else\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = vmalloc(size);\
    - if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL) {\
    - memset(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap, 0x00, size);\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
    - (struct buffer_head **)(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap + 1);\
    - UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
    + udf_sb_partmaps(X)[(Y)].Z.s_bitmap = vmalloc(size);\
    + if (udf_sb_partmaps(X)[(Y)].Z.s_bitmap != NULL) {\
    + memset(udf_sb_partmaps(X)[(Y)].Z.s_bitmap, 0x00, size);\
    + udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
    + (struct buffer_head **)(udf_sb_partmaps(X)[(Y)].Z.s_bitmap + 1);\
    + udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
    } else {\
    udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
    }\
    @@ -90,9 +96,9 @@ static inline struct udf_sb_info *udf_sb(struct super_block *sb)
    brelse(UDF_SB_BITMAP(X,Y,Z,i));\
    }\
    if (size <= PAGE_SIZE)\
    - kfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
    + kfree(udf_sb_partmaps(X)[Y].Z.s_bitmap);\
    else\
    - vfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
    + vfree(udf_sb_partmaps(X)[Y].Z.s_bitmap);\
    }

    #define UDF_QUERY_FLAG(X,Y) ( udf_sb(X)->s_flags & ( 1 << (Y) ) )
    @@ -101,18 +107,17 @@ static inline struct udf_sb_info *udf_sb(struct super_block *sb)

    #define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > UDF_SB_UDFREV(X)) ? UDF_SB_UDFREV(X) = (Y) : UDF_SB_UDFREV(X) )

    -#define UDF_SB_PARTMAPS(X) ( udf_sb(X)->s_partmaps )
    -#define UDF_SB_PARTTYPE(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_type )
    -#define UDF_SB_PARTROOT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_root )
    -#define UDF_SB_PARTLEN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_len )
    -#define UDF_SB_PARTVSN(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_volumeseqnum )
    -#define UDF_SB_PARTNUM(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_num )
    -#define UDF_SB_TYPESPAR(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_sparing )
    -#define UDF_SB_TYPEVIRT(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_virtual )
    -#define UDF_SB_PARTFUNC(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_func )
    -#define UDF_SB_PARTFLAGS(X,Y) ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_flags )
    -#define UDF_SB_BITMAP(X,Y,Z,I) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    -#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups )
    +#define UDF_SB_PARTTYPE(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_type )
    +#define UDF_SB_PARTROOT(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_root )
    +#define UDF_SB_PARTLEN(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_len )
    +#define UDF_SB_PARTVSN(X,Y) ( udf_sb_partmaps(X)[(Y)].s_volumeseqnum )
    +#define UDF_SB_PARTNUM(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_num )
    +#define UDF_SB_TYPESPAR(X,Y) ( udf_sb_partmaps(X)[(Y)].s_type_specific.s_sparing )
    +#define UDF_SB_TYPEVIRT(X,Y) ( udf_sb_partmaps(X)[(Y)].s_type_specific.s_virtual )
    +#define UDF_SB_PARTFUNC(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_func )
    +#define UDF_SB_PARTFLAGS(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_flags )
    +#define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    +#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    #define UDF_SB_VOLIDENT(X) ( udf_sb(X)->s_volident )
    #define UDF_SB_NUMPARTS(X) ( udf_sb(X)->s_partitions )
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  16. [PATCH 20/24] udf: convert UDF_UPDATE_UDFREV macro to udf_update_revision function

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/ialloc.c | 2 +-
    fs/udf/udf_sb.h | 8 ++++++--
    2 files changed, 7 insertions(+), 3 deletions(-)

    diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
    index 269f588..4d1684c 100644
    --- a/fs/udf/ialloc.c
    +++ b/fs/udf/ialloc.c
    @@ -123,7 +123,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
    UDF_I_USE(inode) = 0;
    if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
    UDF_I_EFE(inode) = 1;
    - UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
    + udf_update_revision(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
    UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
    } else {
    UDF_I_EFE(inode) = 0;
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index 565c9ef..aee5942 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -138,6 +138,12 @@ static inline struct inode *udf_sb_vat_inode(struct super_block *sb)
    return udf_sb(sb)->s_vat_inode;
    }

    +static inline void udf_update_revision(struct super_block *sb, __u16 revision)
    +{
    + if (revision > udf_sb_revision(sb))
    + udf_sb(sb)->s_udfrev = revision;
    +}
    +
    #define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
    {\
    int nr_groups = ((UDF_SB_PARTLEN((X),(Y)) + (sizeof(struct spaceBitmapDesc) << 3) +\
    @@ -176,8 +182,6 @@ static inline struct inode *udf_sb_vat_inode(struct super_block *sb)
    #define UDF_SET_FLAG(X,Y) ( udf_sb(X)->s_flags |= ( 1 << (Y) ) )
    #define UDF_CLEAR_FLAG(X,Y) ( udf_sb(X)->s_flags &= ~( 1 << (Y) ) )

    -#define UDF_UPDATE_UDFREV(X,Y) ( ((Y) > udf_sb_revision(X)) ? udf_sb(X)->s_udfrev = (Y) : udf_sb_revision(X) )
    -
    #define UDF_SB_PARTTYPE(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_type )
    #define UDF_SB_PARTROOT(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_root )
    #define UDF_SB_PARTLEN(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_len )
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  17. [PATCH 21/24] udf: remove some UDF_SB_* macros

    remove macros:
    - UDF_SB_PARTTYPE
    - UDF_SB_PARTROOT
    - UDF_SB_PARTLEN
    - UDF_SB_PARTVSN
    - UDF_SB_PARTNUM
    - UDF_SB_TYPESPAR
    - UDF_SB_TYPEVIRT
    - UDF_SB_PARTFUNC
    - UDF_SB_PARTFLAGS
    and replace all uses

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/balloc.c | 76 +++++++++++----------
    fs/udf/inode.c | 2 +-
    fs/udf/partition.c | 49 ++++++++------
    fs/udf/super.c | 191 ++++++++++++++++++++++++++++------------------------
    fs/udf/udf_sb.h | 16 ++---
    5 files changed, 179 insertions(+), 155 deletions(-)

    diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
    index 23aae18..4fe8635 100644
    --- a/fs/udf/balloc.c
    +++ b/fs/udf/balloc.c
    @@ -155,10 +155,10 @@ static void udf_bitmap_free_blocks(struct super_block *sb,

    mutex_lock(&sbi->s_alloc_mutex);
    if (bloc.logicalBlockNum < 0 ||
    - (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
    + (bloc.logicalBlockNum + count) > udf_sb_partmap(sb, bloc.partitionReferenceNum)->s_partition_len) {
    udf_debug("%d < %d || %d + %d > %d\n",
    bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
    - UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
    + udf_sb_partmap(sb, bloc.partitionReferenceNum)->s_partition_len);
    goto error_return;
    }

    @@ -219,16 +219,18 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
    int bit, block, block_group, group_start;
    int nr_groups, bitmap_nr;
    struct buffer_head *bh;
    + __u32 part_len;

    mutex_lock(&sbi->s_alloc_mutex);
    - if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
    + part_len = udf_sb_partmap(sb, partition)->s_partition_len;
    + if (first_block < 0 || first_block >= part_len)
    goto out;

    - if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
    - block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
    + if (first_block + block_count > part_len)
    + block_count = part_len - first_block;

    repeat:
    - nr_groups = (UDF_SB_PARTLEN(sb, partition) +
    + nr_groups = (udf_sb_partmap(sb, partition)->s_partition_len +
    (sizeof(struct spaceBitmapDesc) << 3) +
    (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
    block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
    @@ -287,7 +289,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
    mutex_lock(&sbi->s_alloc_mutex);

    repeat:
    - if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
    + if (goal < 0 || goal >= udf_sb_partmap(sb, partition)->s_partition_len)
    goal = 0;

    nr_groups = bitmap->s_nr_groups;
    @@ -421,10 +423,10 @@ static void udf_table_free_blocks(struct super_block *sb,

    mutex_lock(&sbi->s_alloc_mutex);
    if (bloc.logicalBlockNum < 0 ||
    - (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
    + (bloc.logicalBlockNum + count) > udf_sb_partmap(sb, bloc.partitionReferenceNum)->s_partition_len) {
    udf_debug("%d < %d || %d + %d > %d\n",
    bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
    - UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
    + udf_sb_partmap(sb, bloc.partitionReferenceNum)->s_partition_len);
    goto error_return;
    }

    @@ -627,7 +629,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
    struct extent_position epos;
    int8_t etype = -1;

    - if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
    + if (first_block < 0 || first_block >= udf_sb_partmap(sb, partition)->s_partition_len)
    return 0;

    if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
    @@ -703,7 +705,7 @@ static int udf_table_new_block(struct super_block *sb,
    return newblock;

    mutex_lock(&sbi->s_alloc_mutex);
    - if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
    + if (goal < 0 || goal >= udf_sb_partmap(sb, partition)->s_partition_len)
    goal = 0;

    /* We search for the closest matching block to goal. If we find a exact hit,
    @@ -789,22 +791,23 @@ inline void udf_free_blocks(struct super_block *sb,
    uint32_t count)
    {
    uint16_t partition = bloc.partitionReferenceNum;
    + struct udf_part_map *map = udf_sb_partmap(sb, partition);

    - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    return udf_bitmap_free_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_uspace.s_bitmap,
    + map->s_uspace.s_bitmap,
    bloc, offset, count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_free_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_uspace.s_table,
    + map->s_uspace.s_table,
    bloc, offset, count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_free_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_fspace.s_bitmap,
    + map->s_fspace.s_bitmap,
    bloc, offset, count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_free_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_fspace.s_table,
    + map->s_fspace.s_table,
    bloc, offset, count);
    } else {
    return;
    @@ -816,21 +819,23 @@ inline int udf_prealloc_blocks(struct super_block *sb,
    uint16_t partition, uint32_t first_block,
    uint32_t block_count)
    {
    - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + struct udf_part_map *map = udf_sb_partmap(sb, partition);
    +
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    return udf_bitmap_prealloc_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_uspace.s_bitmap,
    + map->s_uspace.s_bitmap,
    partition, first_block, block_count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_prealloc_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_uspace.s_table,
    + map->s_uspace.s_table,
    partition, first_block, block_count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_prealloc_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_fspace.s_bitmap,
    + map->s_fspace.s_bitmap,
    partition, first_block, block_count);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_prealloc_blocks(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_fspace.s_table,
    + map->s_fspace.s_table,
    partition, first_block, block_count);
    } else {
    return 0;
    @@ -842,23 +847,24 @@ inline int udf_new_block(struct super_block *sb,
    uint16_t partition, uint32_t goal, int *err)
    {
    int ret;
    + struct udf_part_map *map = udf_sb_partmap(sb, partition);

    - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    ret = udf_bitmap_new_block(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_uspace.s_bitmap,
    + map->s_uspace.s_bitmap,
    partition, goal, err);
    return ret;
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    return udf_table_new_block(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_uspace.s_table,
    + map->s_uspace.s_table,
    partition, goal, err);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    return udf_bitmap_new_block(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_fspace.s_bitmap,
    + map->s_fspace.s_bitmap,
    partition, goal, err);
    - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
    + } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    return udf_table_new_block(sb, inode,
    - udf_sb_partmaps(sb)[partition].s_fspace.s_table,
    + map->s_fspace.s_table,
    partition, goal, err);
    } else {
    *err = -EIO;
    diff --git a/fs/udf/inode.c b/fs/udf/inode.c
    index 1cdb381..8aa0fc6 100644
    --- a/fs/udf/inode.c
    +++ b/fs/udf/inode.c
    @@ -1585,7 +1585,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
    if (is_bad_inode(inode))
    goto out_iput;

    - if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
    + if (ino.logicalBlockNum >= udf_sb_partmap(sb, ino.partitionReferenceNum)->s_partition_len) {
    udf_debug("block=%d, partition=%d out of range\n",
    ino.logicalBlockNum, ino.partitionReferenceNum);
    make_bad_inode(inode);
    diff --git a/fs/udf/partition.c b/fs/udf/partition.c
    index 99640a6..4959d53 100644
    --- a/fs/udf/partition.c
    +++ b/fs/udf/partition.c
    @@ -31,15 +31,17 @@
    inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
    uint16_t partition, uint32_t offset)
    {
    + struct udf_part_map *map;
    if (partition >= udf_sb_num_parts(sb)) {
    udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
    block, partition, offset);
    return 0xFFFFFFFF;
    }
    - if (UDF_SB_PARTFUNC(sb, partition))
    - return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
    + map = udf_sb_partmap(sb, partition);
    + if (map->s_partition_func)
    + return map->s_partition_func(sb, block, partition, offset);
    else
    - return UDF_SB_PARTROOT(sb, partition) + block + offset;
    + return map->s_partition_root + block + offset;
    }

    uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    @@ -49,12 +51,14 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    uint32_t newblock;
    uint32_t index;
    uint32_t loc;
    + struct udf_part_map *map;

    - index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
    + map = udf_sb_partmap(sb, partition);
    + index = (sb->s_blocksize - map->s_type_specific.s_virtual.s_start_offset) / sizeof(uint32_t);

    - if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
    + if (block > map->s_type_specific.s_virtual.s_num_entries) {
    udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
    - block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
    + block, map->s_type_specific.s_virtual.s_num_entries);
    return 0xFFFFFFFF;
    }

    @@ -64,7 +68,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
    index = block % (sb->s_blocksize / sizeof(uint32_t));
    } else {
    newblock = 0;
    - index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
    + index = map->s_type_specific.s_virtual.s_start_offset / sizeof(uint32_t) + block;
    }

    loc = udf_block_map(udf_sb_vat_inode(sb), newblock);
    @@ -100,11 +104,15 @@ uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
    {
    int i;
    struct sparingTable *st = NULL;
    - uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
    + struct udf_part_map *map;
    + uint32_t packet;
    +
    + map = udf_sb_partmap(sb, partition);
    + packet = (block + offset) & ~(map->s_type_specific.s_sparing.s_packet_len - 1);

    for (i = 0; i < 4; i++) {
    - if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
    - st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
    + if (map->s_type_specific.s_sparing.s_spar_map[i] != NULL) {
    + st = (struct sparingTable *)map->s_type_specific.s_sparing.s_spar_map[i]->b_data;
    break;
    }
    }
    @@ -115,14 +123,14 @@ uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
    break;
    } else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
    return le32_to_cpu(st->mapEntry[i].mappedLocation) +
    - ((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
    + ((block + offset) & (map->s_type_specific.s_sparing.s_packet_len - 1));
    } else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
    break;
    }
    }
    }

    - return UDF_SB_PARTROOT(sb,partition) + block + offset;
    + return map->s_partition_root + block + offset;
    }

    int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    @@ -134,13 +142,14 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    int i, j, k, l;

    for (i = 0; i < udf_sb_num_parts(sb); i++) {
    - if (old_block > UDF_SB_PARTROOT(sb,i) &&
    - old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
    - sdata = &UDF_SB_TYPESPAR(sb,i);
    - packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
    + struct udf_part_map *map = udf_sb_partmap(sb, i);
    + if (old_block > map->s_partition_root &&
    + old_block < map->s_partition_root + map->s_partition_len) {
    + sdata = &map->s_type_specific.s_sparing;
    + packet = (old_block - map->s_partition_root) & ~(sdata->s_packet_len - 1);

    for (j = 0; j < 4; j++) {
    - if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
    + if (map->s_type_specific.s_sparing.s_spar_map[j] != NULL) {
    st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
    break;
    }
    @@ -160,11 +169,11 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    }
    }
    *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
    - ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
    + ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
    return 0;
    } else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
    *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
    - ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
    + ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
    return 0;
    } else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
    break;
    @@ -185,7 +194,7 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
    }
    }
    *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
    - ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
    + ((old_block - map->s_partition_root) & (sdata->s_packet_len - 1));
    return 0;
    }
    }
    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index f8c5794..33ccf66 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -795,8 +795,9 @@ static int udf_find_fileset(struct super_block *sb,
    fileset->logicalBlockNum == 0xFFFFFFFF &&
    fileset->partitionReferenceNum == 0xFFFF);
    newfileset.partitionReferenceNum--) {
    - lastblock = UDF_SB_PARTLEN(sb,
    - newfileset.partitionReferenceNum);
    + lastblock = udf_sb_partmap(sb,
    + newfileset.partitionReferenceNum)->
    + s_partition_len;
    newfileset.logicalBlockNum = 0;

    do {
    @@ -904,23 +905,25 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    {
    struct partitionDesc *p;
    int i;
    + struct udf_part_map *map;

    p = (struct partitionDesc *)bh->b_data;

    for (i = 0; i < udf_sb_num_parts(sb); i++) {
    + map = udf_sb_partmap(sb, i);
    udf_debug("Searching map: (%d == %d)\n",
    - udf_sb_partmaps(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
    - if (udf_sb_partmaps(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
    - UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength); /* blocks */
    - UDF_SB_PARTROOT(sb, i) = le32_to_cpu(p->partitionStartingLocation);
    + map->s_partition_num, le16_to_cpu(p->partitionNumber));
    + if (map->s_partition_num == le16_to_cpu(p->partitionNumber)) {
    + map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */
    + map->s_partition_root = le32_to_cpu(p->partitionStartingLocation);
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_READ_ONLY;
    + map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_WRITE_ONCE;
    + map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_REWRITABLE;
    + map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE;
    if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE)
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_OVERWRITABLE;
    + map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;

    if (!strcmp(p->partitionContents.ident,
    PD_PARTITION_CONTENTS_NSR02) ||
    @@ -935,26 +938,26 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    .partitionReferenceNum = i,
    };

    - udf_sb_partmaps(sb)[i].s_uspace.s_table =
    + map->s_uspace.s_table =
    udf_iget(sb, loc);
    - if (!udf_sb_partmaps(sb)[i].s_uspace.s_table) {
    + if (!map->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;
    + map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
    udf_debug("unallocSpaceTable (part %d) @ %ld\n",
    - i, udf_sb_partmaps(sb)[i].s_uspace.s_table->i_ino);
    + i, map->s_uspace.s_table->i_ino);
    }
    if (phd->unallocSpaceBitmap.extLength) {
    UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
    - if (udf_sb_partmaps(sb)[i].s_uspace.s_bitmap != NULL) {
    - udf_sb_partmaps(sb)[i].s_uspace.s_bitmap->s_extLength =
    + if (map->s_uspace.s_bitmap != NULL) {
    + map->s_uspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->unallocSpaceBitmap.extLength);
    - udf_sb_partmaps(sb)[i].s_uspace.s_bitmap->s_extPosition =
    + map->s_uspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
    + map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
    udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
    - i, udf_sb_partmaps(sb)[i].s_uspace.s_bitmap->s_extPosition);
    + i, map->s_uspace.s_bitmap->s_extPosition);
    }
    }
    if (phd->partitionIntegrityTable.extLength)
    @@ -965,26 +968,26 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    .partitionReferenceNum = i,
    };

    - udf_sb_partmaps(sb)[i].s_fspace.s_table =
    + map->s_fspace.s_table =
    udf_iget(sb, loc);
    - if (!udf_sb_partmaps(sb)[i].s_fspace.s_table) {
    + if (!map->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;
    + map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
    udf_debug("freedSpaceTable (part %d) @ %ld\n",
    - i, udf_sb_partmaps(sb)[i].s_fspace.s_table->i_ino);
    + i, map->s_fspace.s_table->i_ino);
    }
    if (phd->freedSpaceBitmap.extLength) {
    UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
    - if (udf_sb_partmaps(sb)[i].s_fspace.s_bitmap != NULL) {
    - udf_sb_partmaps(sb)[i].s_fspace.s_bitmap->s_extLength =
    + if (map->s_fspace.s_bitmap != NULL) {
    + map->s_fspace.s_bitmap->s_extLength =
    le32_to_cpu(phd->freedSpaceBitmap.extLength);
    - udf_sb_partmaps(sb)[i].s_fspace.s_bitmap->s_extPosition =
    + map->s_fspace.s_bitmap->s_extPosition =
    le32_to_cpu(phd->freedSpaceBitmap.extPosition);
    - UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_BITMAP;
    + map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
    udf_debug("freedSpaceBitmap (part %d) @ %d\n",
    - i, udf_sb_partmaps(sb)[i].s_fspace.s_bitmap->s_extPosition);
    + i, map->s_fspace.s_bitmap->s_extPosition);
    }
    }
    }
    @@ -998,8 +1001,9 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
    udf_debug("Partition (%d:%d type %x) starts at physical %d, "
    "block length %d\n",
    le16_to_cpu(p->partitionNumber), i,
    - UDF_SB_PARTTYPE(sb, i), UDF_SB_PARTROOT(sb, i),
    - UDF_SB_PARTLEN(sb, i));
    + map->s_partition_type,
    + map->s_partition_root,
    + map->s_partition_len);
    }
    return 0;
    }
    @@ -1020,22 +1024,23 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    for (i = 0, offset = 0;
    i < udf_sb_num_parts(sb) && offset < le32_to_cpu(lvd->mapTableLength);
    i++, offset += ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) {
    + struct udf_part_map *map = udf_sb_partmap(sb, i);
    type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
    if (type == 1) {
    struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]);
    - UDF_SB_PARTTYPE(sb, i) = UDF_TYPE1_MAP15;
    - UDF_SB_PARTVSN(sb, i) = le16_to_cpu(gpm1->volSeqNum);
    - UDF_SB_PARTNUM(sb, i) = le16_to_cpu(gpm1->partitionNum);
    - UDF_SB_PARTFUNC(sb, i) = NULL;
    + map->s_partition_type = UDF_TYPE1_MAP15;
    + map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
    + map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
    + map->s_partition_func = NULL;
    } else if (type == 2) {
    struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);
    if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) {
    if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) {
    - UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP15;
    - UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt15;
    + map->s_partition_type = UDF_VIRTUAL_MAP15;
    + map->s_partition_func = udf_get_pblock_virt15;
    } else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) {
    - UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP20;
    - UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt20;
    + map->s_partition_type = UDF_VIRTUAL_MAP20;
    + map->s_partition_func = udf_get_pblock_virt20;
    }
    } else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) {
    uint32_t loc;
    @@ -1043,33 +1048,33 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
    struct sparingTable *st;
    struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]);

    - UDF_SB_PARTTYPE(sb, i) = UDF_SPARABLE_MAP15;
    - UDF_SB_TYPESPAR(sb, i).s_packet_len = le16_to_cpu(spm->packetLength);
    + map->s_partition_type = UDF_SPARABLE_MAP15;
    + map->s_type_specific.s_sparing.s_packet_len = le16_to_cpu(spm->packetLength);
    for (j = 0; j < spm->numSparingTables; j++) {
    loc = le32_to_cpu(spm->locSparingTable[j]);
    - UDF_SB_TYPESPAR(sb, i).s_spar_map[j] =
    + map->s_type_specific.s_sparing.s_spar_map[j] =
    udf_read_tagged(sb, loc, loc, &ident);
    - if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] != NULL) {
    - st = (struct sparingTable *)UDF_SB_TYPESPAR(sb, i).s_spar_map[j]->b_data;
    + if (map->s_type_specific.s_sparing.s_spar_map[j] != NULL) {
    + st = (struct sparingTable *)map->s_type_specific.s_sparing.s_spar_map[j]->b_data;
    if (ident != 0 ||
    strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) {
    - brelse(UDF_SB_TYPESPAR(sb, i).s_spar_map[j]);
    - UDF_SB_TYPESPAR(sb, i).s_spar_map[j] = NULL;
    + brelse(map->s_type_specific.s_sparing.s_spar_map[j]);
    + map->s_type_specific.s_sparing.s_spar_map[j] = NULL;
    }
    }
    }
    - UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_spar15;
    + map->s_partition_func = udf_get_pblock_spar15;
    } else {
    udf_debug("Unknown ident: %s\n",
    upm2->partIdent.ident);
    continue;
    }
    - UDF_SB_PARTVSN(sb, i) = le16_to_cpu(upm2->volSeqNum);
    - UDF_SB_PARTNUM(sb, i) = le16_to_cpu(upm2->partitionNum);
    + map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
    + map->s_partition_num = le16_to_cpu(upm2->partitionNum);
    }
    udf_debug("Partition (%d:%d) type %d on volume %d\n",
    - i, UDF_SB_PARTNUM(sb, i), type,
    - UDF_SB_PARTVSN(sb, i));
    + i, map->s_partition_num, type,
    + map->s_volumeseqnum);
    }

    if (fileset) {
    @@ -1323,7 +1328,8 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)

    for (i = 0; i < udf_sb_num_parts(sb); i++) {
    kernel_lb_addr uninitialized_var(ino);
    - switch (UDF_SB_PARTTYPE(sb, i)) {
    + struct udf_part_map *map = udf_sb_partmap(sb, i);
    + switch (map->s_partition_type) {
    case UDF_VIRTUAL_MAP15:
    case UDF_VIRTUAL_MAP20:
    if (!udf_sb_last_block(sb)) {
    @@ -1338,11 +1344,12 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    }

    for (j = 0; j < udf_sb_num_parts(sb); j++) {
    + struct udf_part_map *map2 = udf_sb_partmap(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)) {
    + map->s_volumeseqnum == map2->s_volumeseqnum &&
    + map->s_partition_num == map2->s_partition_num) {
    ino.partitionReferenceNum = j;
    - ino.logicalBlockNum = udf_sb_last_block(sb) - UDF_SB_PARTROOT(sb, j);
    + ino.logicalBlockNum = udf_sb_last_block(sb) - map2->s_partition_root;
    break;
    }
    }
    @@ -1354,12 +1361,12 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    if (!udf_sb_vat_inode(sb))
    return 1;

    - if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
    - UDF_SB_TYPEVIRT(sb, i).s_start_offset =
    + if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
    + map->s_type_specific.s_virtual.s_start_offset =
    udf_ext0_offset(udf_sb_vat_inode(sb));
    - UDF_SB_TYPEVIRT(sb, i).s_num_entries =
    + map->s_type_specific.s_virtual.s_num_entries =
    (udf_sb_vat_inode(sb)->i_size - 36) >> 2;
    - } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
    + } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
    struct buffer_head *bh = NULL;
    uint32_t pos;

    @@ -1367,16 +1374,18 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    bh = sb_bread(sb, pos);
    if (!bh)
    return 1;
    - UDF_SB_TYPEVIRT(sb, i).s_start_offset =
    + map->s_type_specific.s_virtual.s_start_offset =
    le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data +
    udf_ext0_offset(udf_sb_vat_inode(sb)))->lengthHeader) +
    udf_ext0_offset(udf_sb_vat_inode(sb));
    - UDF_SB_TYPEVIRT(sb, i).s_num_entries = (udf_sb_vat_inode(sb)->i_size -
    - UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
    + map->s_type_specific.s_virtual.s_num_entries = (udf_sb_vat_inode(sb)->i_size -
    + map->s_type_specific.s_virtual.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);
    + map->s_partition_root = udf_get_pblock(sb, 0, i, 0);
    + map->s_partition_len =
    + udf_sb_partmap(sb, ino.partitionReferenceNum)->
    + s_partition_len;
    }
    }
    return 0;
    @@ -1573,7 +1582,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    goto error_out;
    }

    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_READ_ONLY) {
    + if (udf_sb_partmap(sb, udf_sb_partition(sb))->s_partition_flags & UDF_PART_FLAG_READ_ONLY) {
    printk(KERN_NOTICE "UDF-fs: Partition marked readonly; forcing readonly mount\n");
    sb->s_flags |= MS_RDONLY;
    }
    @@ -1619,17 +1628,18 @@ error_out:
    if (udf_sb_vat_inode(sb))
    iput(udf_sb_vat_inode(sb));
    if (udf_sb_num_parts(sb)) {
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    - iput(udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_uspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_FREED_TABLE)
    - iput(udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_fspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    + struct udf_part_map *map = udf_sb_partmap(sb, udf_sb_partition(sb));
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
    + iput(map->s_uspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    + iput(map->s_fspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_uspace);
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_fspace);
    - if (UDF_SB_PARTTYPE(sb, udf_sb_partition(sb)) == UDF_SPARABLE_MAP15) {
    + if (map->s_partition_type == UDF_SPARABLE_MAP15) {
    for (i = 0; i < 4; i++)
    - brelse(UDF_SB_TYPESPAR(sb, udf_sb_partition(sb)).s_spar_map[i]);
    + brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    }
    }
    #ifdef CONFIG_UDF_NLS
    @@ -1694,17 +1704,18 @@ static void udf_put_super(struct super_block *sb)
    if (udf_sb_vat_inode(sb))
    iput(udf_sb_vat_inode(sb));
    if (udf_sb_num_parts(sb)) {
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
    - iput(udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_uspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_FREED_TABLE)
    - iput(udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_fspace.s_table);
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
    + struct udf_part_map *map = udf_sb_partmap(sb, udf_sb_partition(sb));
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
    + iput(map->s_uspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    + iput(map->s_fspace.s_table);
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_uspace);
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_FREED_BITMAP)
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_fspace);
    - if (UDF_SB_PARTTYPE(sb, udf_sb_partition(sb)) == UDF_SPARABLE_MAP15) {
    + if (map->s_partition_type == UDF_SPARABLE_MAP15) {
    for (i = 0; i < 4; i++)
    - brelse(UDF_SB_TYPESPAR(sb, udf_sb_partition(sb)).s_spar_map[i]);
    + brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    }
    }
    #ifdef CONFIG_UDF_NLS
    @@ -1738,7 +1749,7 @@ static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)

    buf->f_type = UDF_SUPER_MAGIC;
    buf->f_bsize = sb->s_blocksize;
    - buf->f_blocks = UDF_SB_PARTLEN(sb, udf_sb_partition(sb));
    + buf->f_blocks = udf_sb_partmap(sb, udf_sb_partition(sb))->s_partition_len;
    buf->f_bfree = udf_count_free(sb);
    buf->f_bavail = buf->f_bfree;
    buf->f_files = (udf_sb_lvid_bh(sb) ?
    @@ -1843,6 +1854,7 @@ static unsigned int udf_count_free_table(struct super_block *sb, struct inode *t
    static unsigned int udf_count_free(struct super_block *sb)
    {
    unsigned int accum = 0;
    + struct udf_part_map *map;

    if (udf_sb_lvid_bh(sb)) {
    if (le32_to_cpu(udf_sb_lvid(sb)->numOfPartitions) > udf_sb_partition(sb)) {
    @@ -1855,24 +1867,25 @@ static unsigned int udf_count_free(struct super_block *sb)
    if (accum)
    return accum;

    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
    + map = udf_sb_partmap(sb, udf_sb_partition(sb));
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    - udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_uspace.s_bitmap);
    + map->s_uspace.s_bitmap);
    }
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
    accum += udf_count_free_bitmap(sb,
    - udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_fspace.s_bitmap);
    + map->s_fspace.s_bitmap);
    }
    if (accum)
    return accum;

    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
    + if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
    accum += udf_count_free_table(sb,
    - udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_uspace.s_table);
    + map->s_uspace.s_table);
    }
    - if (UDF_SB_PARTFLAGS(sb, udf_sb_partition(sb)) & UDF_PART_FLAG_FREED_TABLE) {
    + if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
    accum += udf_count_free_table(sb,
    - udf_sb_partmaps(sb)[udf_sb_partition(sb)].s_fspace.s_table);
    + map->s_fspace.s_table);
    }

    return accum;
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index aee5942..a5805c5 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -48,6 +48,11 @@ static inline struct udf_part_map *udf_sb_partmaps(struct super_block *sb)
    return udf_sb(sb)->s_partmaps;
    }

    +static inline struct udf_part_map *udf_sb_partmap(struct super_block *sb, __u32 index)
    +{
    + return udf_sb_partmaps(sb) + index;
    +}
    +
    static inline int __must_check udf_sb_alloc_partition_maps(struct super_block *sb, __u32 count)
    {
    struct udf_sb_info *info = udf_sb(sb);
    @@ -146,7 +151,7 @@ static inline void udf_update_revision(struct super_block *sb, __u16 revision)

    #define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
    {\
    - int nr_groups = ((UDF_SB_PARTLEN((X),(Y)) + (sizeof(struct spaceBitmapDesc) << 3) +\
    + int nr_groups = ((udf_sb_partmap((X),(Y))->s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +\
    ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
    int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    if (size <= PAGE_SIZE)\
    @@ -182,15 +187,6 @@ static inline void udf_update_revision(struct super_block *sb, __u16 revision)
    #define UDF_SET_FLAG(X,Y) ( udf_sb(X)->s_flags |= ( 1 << (Y) ) )
    #define UDF_CLEAR_FLAG(X,Y) ( udf_sb(X)->s_flags &= ~( 1 << (Y) ) )

    -#define UDF_SB_PARTTYPE(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_type )
    -#define UDF_SB_PARTROOT(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_root )
    -#define UDF_SB_PARTLEN(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_len )
    -#define UDF_SB_PARTVSN(X,Y) ( udf_sb_partmaps(X)[(Y)].s_volumeseqnum )
    -#define UDF_SB_PARTNUM(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_num )
    -#define UDF_SB_TYPESPAR(X,Y) ( udf_sb_partmaps(X)[(Y)].s_type_specific.s_sparing )
    -#define UDF_SB_TYPEVIRT(X,Y) ( udf_sb_partmaps(X)[(Y)].s_type_specific.s_virtual )
    -#define UDF_SB_PARTFUNC(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_func )
    -#define UDF_SB_PARTFLAGS(X,Y) ( udf_sb_partmaps(X)[(Y)].s_partition_flags )
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  18. [PATCH 24/24] udf: fix sparse warnings (shadowing & mismatch between declaration and definition)

    fix warnings:
    fs/udf/super.c:1370:24: warning: symbol 'bh' shadows an earlier one
    fs/udf/super.c:1288:21: originally declared here
    fs/udf/super.c:450:6: warning: symbol 'udf_write_super' was not declared. Should it be static?

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 3 +--
    1 files changed, 1 insertions(+), 2 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index f6c911b..da68130 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -447,7 +447,7 @@ static int udf_parse_options(char *options, struct udf_options *uopt)
    return 1;
    }

    -void udf_write_super(struct super_block *sb)
    +static void udf_write_super(struct super_block *sb)
    {
    lock_kernel();

    @@ -1367,7 +1367,6 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    map->s_type_specific.s_virtual.s_num_entries =
    (udf_sb_vat_inode(sb)->i_size - 36) >> 2;
    } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
    - struct buffer_head *bh = NULL;
    uint32_t pos;

    pos = udf_block_map(udf_sb_vat_inode(sb), 0);
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  19. [PATCH 09/24] udf: convert UDF_SB_LASTBLOCK macro to udf_sb_last_block function

    - change UDF_SB_LASTBLOCK macro to udf_sb_last_block inline function
    - rename s_lastblock field to s_last_block

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 20 ++++++++++----------
    fs/udf/udf_sb.h | 6 +++++-
    include/linux/udf_fs_sb.h | 2 +-
    3 files changed, 16 insertions(+), 12 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 0120ac6..e641d8f 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -639,7 +639,7 @@ static int udf_vrs(struct super_block *sb, int silent)
    */
    static void udf_find_anchor(struct super_block *sb)
    {
    - int lastblock = UDF_SB_LASTBLOCK(sb);
    + int lastblock = udf_sb_last_block(sb);
    struct buffer_head *bh = NULL;
    uint16_t ident;
    uint32_t location;
    @@ -759,7 +759,7 @@ static void udf_find_anchor(struct super_block *sb)
    }
    }

    - UDF_SB_LASTBLOCK(sb) = lastblock;
    + udf_sb(sb)->s_last_block = lastblock;
    }

    static int udf_find_fileset(struct super_block *sb,
    @@ -1261,8 +1261,8 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent)
    if (block == -1) {
    udf_debug("Failed to read byte 32768. Assuming open "
    "disc. Skipping validity check\n");
    - if (!UDF_SB_LASTBLOCK(sb))
    - UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
    + if (!udf_sb_last_block(sb))
    + udf_sb(sb)->s_last_block = udf_get_last_block(sb);
    return 0;
    } else
    return !block;
    @@ -1319,12 +1319,12 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    switch (UDF_SB_PARTTYPE(sb, i)) {
    case UDF_VIRTUAL_MAP15:
    case UDF_VIRTUAL_MAP20:
    - if (!UDF_SB_LASTBLOCK(sb)) {
    - UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
    + if (!udf_sb_last_block(sb)) {
    + udf_sb(sb)->s_last_block = udf_get_last_block(sb);
    udf_find_anchor(sb);
    }

    - if (!UDF_SB_LASTBLOCK(sb)) {
    + if (!udf_sb_last_block(sb)) {
    udf_debug("Unable to determine Lastblock (For "
    "Virtual Partition)\n");
    return 1;
    @@ -1335,7 +1335,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
    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_last_block(sb) - UDF_SB_PARTROOT(sb, j);
    break;
    }
    }
    @@ -1512,7 +1512,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)

    udf_debug("Multi-session=%d\n", udf_sb_session(sb));

    - UDF_SB_LASTBLOCK(sb) = uopt.lastblock;
    + udf_sb(sb)->s_last_block = uopt.lastblock;
    udf_sb_anchor(sb)[0] = udf_sb_anchor(sb)[1] = 0;
    udf_sb_anchor(sb)[2] = uopt.anchor;
    udf_sb_anchor(sb)[3] = 256;
    @@ -1537,7 +1537,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
    goto error_out;
    }

    - udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));
    + udf_debug("Lastblock=%d\n", udf_sb_last_block(sb));

    if (UDF_SB_LVIDBH(sb)) {
    uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index f00524f..ea4ec0f 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -80,6 +80,11 @@ static inline __u32 *udf_sb_anchor(struct super_block *sb)
    return udf_sb(sb)->s_anchor;
    }

    +static inline __u32 udf_sb_last_block(struct super_block *sb)
    +{
    + return udf_sb(sb)->s_last_block;
    +}
    +
    #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
    {\
    udf_sb(X)->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
    @@ -144,7 +149,6 @@ static inline __u32 *udf_sb_anchor(struct super_block *sb)
    #define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    #define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )

    -#define UDF_SB_LASTBLOCK(X) ( udf_sb(X)->s_lastblock )
    #define UDF_SB_LVIDBH(X) ( udf_sb(X)->s_lvidbh )
    #define UDF_SB_LVID(X) ( (struct logicalVolIntegrityDesc *)UDF_SB_LVIDBH(X)->b_data )
    #define UDF_SB_LVIDIU(X) ( (struct logicalVolIntegrityDescImpUse *)&(UDF_SB_LVID(X)->impUse[le32_to_cpu(UDF_SB_LVID(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )
    diff --git a/include/linux/udf_fs_sb.h b/include/linux/udf_fs_sb.h
    index a1addf6..2f46ce6 100644
    --- a/include/linux/udf_fs_sb.h
    +++ b/include/linux/udf_fs_sb.h
    @@ -84,7 +84,7 @@ struct udf_sb_info
    /* Sector headers */
    __s32 s_session;
    __u32 s_anchor[4];
    - __u32 s_lastblock;
    + __u32 s_last_block;

    struct buffer_head *s_lvidbh;

    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  20. [PATCH 23/24] udf: convert UDF_SB_FREE_BITMAP macro to udf_sb_free_bitmap function

    additionally fix sparse warnings:
    fs/udf/super.c:1636:4: warning: symbol 'i' shadows an earlier one
    fs/udf/super.c:1469:6: originally declared here
    fs/udf/super.c:1638:4: warning: symbol 'i' shadows an earlier one
    fs/udf/super.c:1469:6: originally declared here
    fs/udf/super.c:1712:4: warning: symbol 'i' shadows an earlier one
    fs/udf/super.c:1701:6: originally declared here
    fs/udf/super.c:1714:4: warning: symbol 'i' shadows an earlier one
    fs/udf/super.c:1701:6: originally declared here

    Signed-off-by: Marcin Slusarz
    CC: Ben Fennema
    CC: Jan Kara
    ---
    fs/udf/super.c | 8 ++++----
    fs/udf/udf_sb.h | 31 ++++++++++++++-----------------
    2 files changed, 18 insertions(+), 21 deletions(-)

    diff --git a/fs/udf/super.c b/fs/udf/super.c
    index 1afea58..f6c911b 100644
    --- a/fs/udf/super.c
    +++ b/fs/udf/super.c
    @@ -1634,9 +1634,9 @@ error_out:
    if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    iput(map->s_fspace.s_table);
    if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_uspace);
    + udf_sb_free_bitmap(map->s_uspace.s_bitmap);
    if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_fspace);
    + udf_sb_free_bitmap(map->s_fspace.s_bitmap);
    if (map->s_partition_type == UDF_SPARABLE_MAP15) {
    for (i = 0; i < 4; i++)
    brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    @@ -1710,9 +1710,9 @@ static void udf_put_super(struct super_block *sb)
    if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
    iput(map->s_fspace.s_table);
    if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_uspace);
    + udf_sb_free_bitmap(map->s_uspace.s_bitmap);
    if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
    - UDF_SB_FREE_BITMAP(sb, udf_sb_partition(sb), s_fspace);
    + udf_sb_free_bitmap(map->s_fspace.s_bitmap);
    if (map->s_partition_type == UDF_SPARABLE_MAP15) {
    for (i = 0; i < 4; i++)
    brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
    diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
    index 4cf91f2..8fc2be9 100644
    --- a/fs/udf/udf_sb.h
    +++ b/fs/udf/udf_sb.h
    @@ -171,27 +171,24 @@ static inline struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, __u
    return bitmap;
    }

    -#define UDF_SB_FREE_BITMAP(X,Y,Z)\
    -{\
    - int i;\
    - int nr_groups = UDF_SB_BITMAP_NR_GROUPS(X,Y,Z);\
    - int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
    - for (i = 0; i < nr_groups; i++) {\
    - if (UDF_SB_BITMAP(X,Y,Z,i))\
    - brelse(UDF_SB_BITMAP(X,Y,Z,i));\
    - }\
    - if (size <= PAGE_SIZE)\
    - kfree(udf_sb_partmaps(X)[Y].Z.s_bitmap);\
    - else\
    - vfree(udf_sb_partmaps(X)[Y].Z.s_bitmap);\
    +static inline void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
    +{
    + int i;
    + int nr_groups = bitmap->s_nr_groups;
    + int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);
    +
    + for (i = 0; i < nr_groups; i++) {
    + if (bitmap->s_block_bitmap[i])
    + brelse(bitmap->s_block_bitmap[i]);
    + }
    + if (size <= PAGE_SIZE)
    + kfree(bitmap);
    + else
    + vfree(bitmap);
    }

    #define UDF_QUERY_FLAG(X,Y) ( udf_sb(X)->s_flags & ( 1 << (Y) ) )
    #define UDF_SET_FLAG(X,Y) ( udf_sb(X)->s_flags |= ( 1 << (Y) ) )
    #define UDF_CLEAR_FLAG(X,Y) ( udf_sb(X)->s_flags &= ~( 1 << (Y) ) )

    -#define UDF_SB_BITMAP(X,Y,Z,I) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
    -#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z) ( udf_sb_partmaps(X)[(Y)].Z.s_bitmap->s_nr_groups )
    -
    -
    #endif /* __LINUX_UDF_SB_H */
    --
    1.5.3.4

    --
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

+ Reply to Thread
Page 1 of 2 1 2 LastLast