UDF: introduce struct extent_position

Introduce a structure extent_position to store a position of an extent and
the corresponding buffer_head in one place.

Signed-off-by: Jan Kara <jack@suse.cz>
Acked-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 83 insertions, 89 deletions

diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index ea521f846d97..756dbbf0eafd 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -427,9 +427,9 @@ static void udf_table_free_blocks(struct super_block * sb,
 {
         struct udf_sb_info *sbi = UDF_SB(sb);
         uint32_t start, end;
-        uint32_t nextoffset, oextoffset, elen;
-        kernel_lb_addr nbloc, obloc, eloc;
-        struct buffer_head *obh, *nbh;
+        uint32_t elen;
+        kernel_lb_addr eloc;
+        struct extent_position oepos, epos;
         int8_t etype;
         int i;
 
@@ -457,14 +457,13 @@ static void udf_table_free_blocks(struct super_block * sb,
         start = bloc.logicalBlockNum + offset;
         end = bloc.logicalBlockNum + offset + count - 1;
 
-        oextoffset = nextoffset = sizeof(struct unallocSpaceEntry);
+        epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
         elen = 0;
-        obloc = nbloc = UDF_I_LOCATION(table);
-
-        obh = nbh = NULL;
+        epos.block = oepos.block = UDF_I_LOCATION(table);
+        epos.bh = oepos.bh = NULL;
 
         while (count && (etype =
-                udf_next_aext(table, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)
+                udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
         {
                 if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
                         start))
@@ -482,7 +481,7 @@ static void udf_table_free_blocks(struct super_block * sb,
                                 start += count;
                                 count = 0;
                         }
-                        udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);
+                        udf_write_aext(table, &oepos, eloc, elen, 1);
                 }
                 else if (eloc.logicalBlockNum == (end + 1))
                 {
@@ -502,20 +501,20 @@ static void udf_table_free_blocks(struct super_block * sb,
                                 end -= count;
                                 count = 0;
                         }
-                        udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);
+                        udf_write_aext(table, &oepos, eloc, elen, 1);
                 }
 
-                if (nbh != obh)
+                if (epos.bh != oepos.bh)
                 {
                         i = -1;
-                        obloc = nbloc;
-                        udf_release_data(obh);
-                        atomic_inc(&nbh->b_count);
-                        obh = nbh;
-                        oextoffset = 0;
+                        oepos.block = epos.block;
+                        udf_release_data(oepos.bh);
+                        atomic_inc(&epos.bh->b_count);
+                        oepos.bh = epos.bh;
+                        oepos.offset = 0;
                 }
                 else
-                        oextoffset = nextoffset;
+                        oepos.offset = epos.offset;
         }
 
         if (count)
@@ -547,55 +546,53 @@ static void udf_table_free_blocks(struct super_block * sb,
                         adsize = sizeof(long_ad);
                 else
                 {
-                        udf_release_data(obh);
-                        udf_release_data(nbh);
+                        udf_release_data(oepos.bh);
+                        udf_release_data(epos.bh);
                         goto error_return;
                 }
 
-                if (nextoffset + (2 * adsize) > sb->s_blocksize)
+                if (epos.offset + (2 * adsize) > sb->s_blocksize)
                 {
                         char *sptr, *dptr;
                         int loffset;
         
-                        udf_release_data(obh);
-                        obh = nbh;
-                        obloc = nbloc;
-                        oextoffset = nextoffset;
+                        udf_release_data(oepos.bh);
+                        oepos = epos;
 
                         /* Steal a block from the extent being free'd */
-                        nbloc.logicalBlockNum = eloc.logicalBlockNum;
+                        epos.block.logicalBlockNum = eloc.logicalBlockNum;
                         eloc.logicalBlockNum ++;
                         elen -= sb->s_blocksize;
 
-                        if (!(nbh = udf_tread(sb,
-                                udf_get_lb_pblock(sb, nbloc, 0))))
+                        if (!(epos.bh = udf_tread(sb,
+                                udf_get_lb_pblock(sb, epos.block, 0))))
                         {
-                                udf_release_data(obh);
+                                udf_release_data(oepos.bh);
                                 goto error_return;
                         }
-                        aed = (struct allocExtDesc *)(nbh->b_data);
-                        aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
-                        if (nextoffset + adsize > sb->s_blocksize)
+                        aed = (struct allocExtDesc *)(epos.bh->b_data);
+                        aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
+                        if (epos.offset + adsize > sb->s_blocksize)
                         {
-                                loffset = nextoffset;
+                                loffset = epos.offset;
                                 aed->lengthAllocDescs = cpu_to_le32(adsize);
-                                sptr = UDF_I_DATA(inode) + nextoffset -
+                                sptr = UDF_I_DATA(inode) + epos.offset -
                                         udf_file_entry_alloc_offset(inode) +
                                         UDF_I_LENEATTR(inode) - adsize;
-                                dptr = nbh->b_data + sizeof(struct allocExtDesc);
+                                dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
                                 memcpy(dptr, sptr, adsize);
-                                nextoffset = sizeof(struct allocExtDesc) + adsize;
+                                epos.offset = sizeof(struct allocExtDesc) + adsize;
                         }
                         else
                         {
-                                loffset = nextoffset + adsize;
+                                loffset = epos.offset + adsize;
                                 aed->lengthAllocDescs = cpu_to_le32(0);
-                                sptr = (obh)->b_data + nextoffset;
-                                nextoffset = sizeof(struct allocExtDesc);
+                                sptr = oepos.bh->b_data + epos.offset;
+                                epos.offset = sizeof(struct allocExtDesc);
 
-                                if (obh)
+                                if (oepos.bh)
                                 {
-                                        aed = (struct allocExtDesc *)(obh)->b_data;
+                                        aed = (struct allocExtDesc *)oepos.bh->b_data;
                                         aed->lengthAllocDescs =
                                                 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                                 }
@@ -606,11 +603,11 @@ static void udf_table_free_blocks(struct super_block * sb,
                                 }
                         }
                         if (UDF_SB_UDFREV(sb) >= 0x0200)
-                                udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
-                                        nbloc.logicalBlockNum, sizeof(tag));
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
+                                        epos.block.logicalBlockNum, sizeof(tag));
                         else
-                                udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
-                                        nbloc.logicalBlockNum, sizeof(tag));
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
+                                        epos.block.logicalBlockNum, sizeof(tag));
                         switch (UDF_I_ALLOCTYPE(table))
                         {
                                 case ICBTAG_FLAG_AD_SHORT:
@@ -619,7 +616,7 @@ static void udf_table_free_blocks(struct super_block * sb,
                                         sad->extLength = cpu_to_le32(
                                                 EXT_NEXT_EXTENT_ALLOCDECS |
                                                 sb->s_blocksize);
-                                        sad->extPosition = cpu_to_le32(nbloc.logicalBlockNum);
+                                        sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
                                         break;
                                 }
                                 case ICBTAG_FLAG_AD_LONG:
@@ -628,14 +625,14 @@ static void udf_table_free_blocks(struct super_block * sb,
                                         lad->extLength = cpu_to_le32(
                                                 EXT_NEXT_EXTENT_ALLOCDECS |
                                                 sb->s_blocksize);
-                                        lad->extLocation = cpu_to_lelb(nbloc);
+                                        lad->extLocation = cpu_to_lelb(epos.block);
                                         break;
                                 }
                         }
-                        if (obh)
+                        if (oepos.bh)
                         {
-                                udf_update_tag(obh->b_data, loffset);
-                                mark_buffer_dirty(obh);
+                                udf_update_tag(oepos.bh->b_data, loffset);
+                                mark_buffer_dirty(oepos.bh);
                         }
                         else
                                 mark_inode_dirty(table);
@@ -643,26 +640,26 @@ static void udf_table_free_blocks(struct super_block * sb,
 
                 if (elen) /* It's possible that stealing the block emptied the extent */
                 {
-                        udf_write_aext(table, nbloc, &nextoffset, eloc, elen, nbh, 1);
+                        udf_write_aext(table, &epos, eloc, elen, 1);
 
-                        if (!nbh)
+                        if (!epos.bh)
                         {
                                 UDF_I_LENALLOC(table) += adsize;
                                 mark_inode_dirty(table);
                         }
                         else
                         {
-                                aed = (struct allocExtDesc *)nbh->b_data;
+                                aed = (struct allocExtDesc *)epos.bh->b_data;
                                 aed->lengthAllocDescs =
                                         cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
-                                udf_update_tag(nbh->b_data, nextoffset);
-                                mark_buffer_dirty(nbh);
+                                udf_update_tag(epos.bh->b_data, epos.offset);
+                                mark_buffer_dirty(epos.bh);
                         }
                 }
         }
 
-        udf_release_data(nbh);
-        udf_release_data(obh);
+        udf_release_data(epos.bh);
+        udf_release_data(oepos.bh);
 
 error_return:
         sb->s_dirt = 1;
@@ -677,9 +674,9 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
 {
         struct udf_sb_info *sbi = UDF_SB(sb);
         int alloc_count = 0;
-        uint32_t extoffset, elen, adsize;
-        kernel_lb_addr bloc, eloc;
-        struct buffer_head *bh;
+        uint32_t elen, adsize;
+        kernel_lb_addr eloc;
+        struct extent_position epos;
         int8_t etype = -1;
 
         if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
@@ -693,14 +690,13 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
                 return 0;
 
         mutex_lock(&sbi->s_alloc_mutex);
-        extoffset = sizeof(struct unallocSpaceEntry);
-        bloc = UDF_I_LOCATION(table);
-
-        bh = NULL;
+        epos.offset = sizeof(struct unallocSpaceEntry);
+        epos.block = UDF_I_LOCATION(table);
+        epos.bh = NULL;
         eloc.logicalBlockNum = 0xFFFFFFFF;
 
         while (first_block != eloc.logicalBlockNum && (etype =
-                udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
+                udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
         {
                 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
                         eloc.logicalBlockNum, elen, first_block);
@@ -709,7 +705,7 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
 
         if (first_block == eloc.logicalBlockNum)
         {
-                extoffset -= adsize;
+                epos.offset -= adsize;
 
                 alloc_count = (elen >> sb->s_blocksize_bits);
                 if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count))
@@ -719,15 +715,15 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
                         alloc_count = block_count;
                         eloc.logicalBlockNum += alloc_count;
                         elen -= (alloc_count << sb->s_blocksize_bits);
-                        udf_write_aext(table, bloc, &extoffset, eloc, (etype << 30) | elen, bh, 1);
+                        udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);
                 }
                 else
-                        udf_delete_aext(table, bloc, extoffset, eloc, (etype << 30) | elen, bh);
+                        udf_delete_aext(table, epos, eloc, (etype << 30) | elen);
         }
         else
                 alloc_count = 0;
 
-        udf_release_data(bh);
+        udf_release_data(epos.bh);
 
         if (alloc_count && UDF_SB_LVIDBH(sb))
         {
@@ -747,9 +743,9 @@ static int udf_table_new_block(struct super_block * sb,
         struct udf_sb_info *sbi = UDF_SB(sb);
         uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
         uint32_t newblock = 0, adsize;
-        uint32_t extoffset, goal_extoffset, elen, goal_elen = 0;
-        kernel_lb_addr bloc, goal_bloc, eloc, goal_eloc;
-        struct buffer_head *bh, *goal_bh;
+        uint32_t elen, goal_elen = 0;
+        kernel_lb_addr eloc, goal_eloc;
+        struct extent_position epos, goal_epos;
         int8_t etype;
 
         *err = -ENOSPC;
@@ -770,14 +766,12 @@ static int udf_table_new_block(struct super_block * sb,
            We store the buffer_head, bloc, and extoffset of the current closest
            match and use that when we are done.
         */
-
-        extoffset = sizeof(struct unallocSpaceEntry);
-        bloc = UDF_I_LOCATION(table);
-
-        goal_bh = bh = NULL;
+        epos.offset = sizeof(struct unallocSpaceEntry);
+        epos.block = UDF_I_LOCATION(table);
+        epos.bh = goal_epos.bh = NULL;
 
         while (spread && (etype =
-                udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
+                udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
         {
                 if (goal >= eloc.logicalBlockNum)
                 {
@@ -793,24 +787,24 @@ static int udf_table_new_block(struct super_block * sb,
                 if (nspread < spread)
                 {
                         spread = nspread;
-                        if (goal_bh != bh)
+                        if (goal_epos.bh != epos.bh)
                         {
-                                udf_release_data(goal_bh);
-                                goal_bh = bh;
-                                atomic_inc(&goal_bh->b_count);
+                                udf_release_data(goal_epos.bh);
+                                goal_epos.bh = epos.bh;
+                                atomic_inc(&goal_epos.bh->b_count);
                         }
-                        goal_bloc = bloc;
-                        goal_extoffset = extoffset - adsize;
+                        goal_epos.block = epos.block;
+                        goal_epos.offset = epos.offset - adsize;
                         goal_eloc = eloc;
                         goal_elen = (etype << 30) | elen;
                 }
         }
 
-        udf_release_data(bh);
+        udf_release_data(epos.bh);
 
         if (spread == 0xFFFFFFFF)
         {
-                udf_release_data(goal_bh);
+                udf_release_data(goal_epos.bh);
                 mutex_unlock(&sbi->s_alloc_mutex);
                 return 0;
         }
@@ -826,17 +820,17 @@ static int udf_table_new_block(struct super_block * sb,
 
         if (inode && DQUOT_ALLOC_BLOCK(inode, 1))
         {
-                udf_release_data(goal_bh);
+                udf_release_data(goal_epos.bh);
                 mutex_unlock(&sbi->s_alloc_mutex);
                 *err = -EDQUOT;
                 return 0;
         }
 
         if (goal_elen)
-                udf_write_aext(table, goal_bloc, &goal_extoffset, goal_eloc, goal_elen, goal_bh, 1);
+                udf_write_aext(table, &goal_epos, goal_eloc, goal_elen, 1);
         else
-                udf_delete_aext(table, goal_bloc, goal_extoffset, goal_eloc, goal_elen, goal_bh);
-        udf_release_data(goal_bh);
+                udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
+        udf_release_data(goal_epos.bh);
 
         if (UDF_SB_LVIDBH(sb))
         {