Skip to content

Commit

Permalink
UDF: introduce struct extent_position
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
Jan Kara authored and Linus Torvalds committed May 8, 2007
1 parent 60448b1 commit ff116fc
Show file tree
Hide file tree
Showing 8 changed files with 434 additions and 445 deletions.
172 changes: 83 additions & 89 deletions fs/udf/balloc.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down Expand Up @@ -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))
Expand All @@ -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))
{
Expand All @@ -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)
Expand Down Expand Up @@ -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);
}
Expand All @@ -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:
Expand All @@ -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:
Expand All @@ -628,41 +625,41 @@ 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);
}

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;
Expand All @@ -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))
Expand All @@ -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);
Expand All @@ -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))
Expand All @@ -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))
{
Expand All @@ -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;
Expand All @@ -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)
{
Expand All @@ -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;
}
Expand All @@ -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))
{
Expand Down
Loading

0 comments on commit ff116fc

Please sign in to comment.