udf: Standardize return values in mount sequence
Change all function used in filesystem discovery during mount to user standard kernel return values - -errno on error, 0 on success instead of 1 on failure and 0 on success. This allows us to pass error number (not just failure / success) so we can abort device scanning earlier in case of errors like EIO or ENOMEM . Also we will be able to return EROFS in case writeable mount is requested but writing isn't supported. Signed-off-by: Jan Kara <jack@suse.cz>
This commit is contained in:
Jan Kara
parent
17b7f7cf58
commit
d759bfa4e7
298
fs/udf/super.c
298
fs/udf/super.c
|
|
@ -843,27 +843,38 @@ static int udf_find_fileset(struct super_block *sb,
|
|||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Load primary Volume Descriptor Sequence
|
||||
*
|
||||
* Return <0 on error, 0 on success. -EAGAIN is special meaning next sequence
|
||||
* should be tried.
|
||||
*/
|
||||
static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
|
||||
{
|
||||
struct primaryVolDesc *pvoldesc;
|
||||
struct ustr *instr, *outstr;
|
||||
struct buffer_head *bh;
|
||||
uint16_t ident;
|
||||
int ret = 1;
|
||||
int ret = -ENOMEM;
|
||||
|
||||
instr = kmalloc(sizeof(struct ustr), GFP_NOFS);
|
||||
if (!instr)
|
||||
return 1;
|
||||
return -ENOMEM;
|
||||
|
||||
outstr = kmalloc(sizeof(struct ustr), GFP_NOFS);
|
||||
if (!outstr)
|
||||
goto out1;
|
||||
|
||||
bh = udf_read_tagged(sb, block, block, &ident);
|
||||
if (!bh)
|
||||
if (!bh) {
|
||||
ret = -EAGAIN;
|
||||
goto out2;
|
||||
}
|
||||
|
||||
BUG_ON(ident != TAG_IDENT_PVD);
|
||||
if (ident != TAG_IDENT_PVD) {
|
||||
ret = -EIO;
|
||||
goto out_bh;
|
||||
}
|
||||
|
||||
pvoldesc = (struct primaryVolDesc *)bh->b_data;
|
||||
|
||||
|
|
@ -889,8 +900,9 @@ static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
|
|||
if (udf_CS0toUTF8(outstr, instr))
|
||||
udf_debug("volSetIdent[] = '%s'\n", outstr->u_name);
|
||||
|
||||
brelse(bh);
|
||||
ret = 0;
|
||||
out_bh:
|
||||
brelse(bh);
|
||||
out2:
|
||||
kfree(outstr);
|
||||
out1:
|
||||
|
|
@ -947,7 +959,7 @@ static int udf_load_metadata_files(struct super_block *sb, int partition)
|
|||
|
||||
if (mdata->s_mirror_fe == NULL) {
|
||||
udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n");
|
||||
goto error_exit;
|
||||
return -EIO;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -964,23 +976,18 @@ static int udf_load_metadata_files(struct super_block *sb, int partition)
|
|||
addr.logicalBlockNum, addr.partitionReferenceNum);
|
||||
|
||||
mdata->s_bitmap_fe = udf_iget(sb, &addr);
|
||||
|
||||
if (mdata->s_bitmap_fe == NULL) {
|
||||
if (sb->s_flags & MS_RDONLY)
|
||||
udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n");
|
||||
else {
|
||||
udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n");
|
||||
goto error_exit;
|
||||
return -EIO;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
udf_debug("udf_load_metadata_files Ok\n");
|
||||
|
||||
return 0;
|
||||
|
||||
error_exit:
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
|
||||
|
|
@ -1069,7 +1076,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
|
|||
if (!map->s_uspace.s_table) {
|
||||
udf_debug("cannot load unallocSpaceTable (part %d)\n",
|
||||
p_index);
|
||||
return 1;
|
||||
return -EIO;
|
||||
}
|
||||
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
|
||||
udf_debug("unallocSpaceTable (part %d) @ %ld\n",
|
||||
|
|
@ -1079,7 +1086,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
|
|||
if (phd->unallocSpaceBitmap.extLength) {
|
||||
struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
|
||||
if (!bitmap)
|
||||
return 1;
|
||||
return -ENOMEM;
|
||||
map->s_uspace.s_bitmap = bitmap;
|
||||
bitmap->s_extPosition = le32_to_cpu(
|
||||
phd->unallocSpaceBitmap.extPosition);
|
||||
|
|
@ -1102,7 +1109,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
|
|||
if (!map->s_fspace.s_table) {
|
||||
udf_debug("cannot load freedSpaceTable (part %d)\n",
|
||||
p_index);
|
||||
return 1;
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
|
||||
|
|
@ -1113,7 +1120,7 @@ static int udf_fill_partdesc_info(struct super_block *sb,
|
|||
if (phd->freedSpaceBitmap.extLength) {
|
||||
struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
|
||||
if (!bitmap)
|
||||
return 1;
|
||||
return -ENOMEM;
|
||||
map->s_fspace.s_bitmap = bitmap;
|
||||
bitmap->s_extPosition = le32_to_cpu(
|
||||
phd->freedSpaceBitmap.extPosition);
|
||||
|
|
@ -1165,7 +1172,7 @@ static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
|
|||
udf_find_vat_block(sb, p_index, type1_index, blocks - 1);
|
||||
}
|
||||
if (!sbi->s_vat_inode)
|
||||
return 1;
|
||||
return -EIO;
|
||||
|
||||
if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
|
||||
map->s_type_specific.s_virtual.s_start_offset = 0;
|
||||
|
|
@ -1177,7 +1184,7 @@ static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
|
|||
pos = udf_block_map(sbi->s_vat_inode, 0);
|
||||
bh = sb_bread(sb, pos);
|
||||
if (!bh)
|
||||
return 1;
|
||||
return -EIO;
|
||||
vat20 = (struct virtualAllocationTable20 *)bh->b_data;
|
||||
} else {
|
||||
vat20 = (struct virtualAllocationTable20 *)
|
||||
|
|
@ -1195,6 +1202,12 @@ static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Load partition descriptor block
|
||||
*
|
||||
* Returns <0 on error, 0 on success, -EAGAIN is special - try next descriptor
|
||||
* sequence.
|
||||
*/
|
||||
static int udf_load_partdesc(struct super_block *sb, sector_t block)
|
||||
{
|
||||
struct buffer_head *bh;
|
||||
|
|
@ -1204,13 +1217,15 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
|
|||
int i, type1_idx;
|
||||
uint16_t partitionNumber;
|
||||
uint16_t ident;
|
||||
int ret = 0;
|
||||
int ret;
|
||||
|
||||
bh = udf_read_tagged(sb, block, block, &ident);
|
||||
if (!bh)
|
||||
return 1;
|
||||
if (ident != TAG_IDENT_PD)
|
||||
return -EAGAIN;
|
||||
if (ident != TAG_IDENT_PD) {
|
||||
ret = 0;
|
||||
goto out_bh;
|
||||
}
|
||||
|
||||
p = (struct partitionDesc *)bh->b_data;
|
||||
partitionNumber = le16_to_cpu(p->partitionNumber);
|
||||
|
|
@ -1229,10 +1244,13 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
|
|||
if (i >= sbi->s_partitions) {
|
||||
udf_debug("Partition (%d) not found in partition map\n",
|
||||
partitionNumber);
|
||||
ret = 0;
|
||||
goto out_bh;
|
||||
}
|
||||
|
||||
ret = udf_fill_partdesc_info(sb, p, i);
|
||||
if (ret < 0)
|
||||
goto out_bh;
|
||||
|
||||
/*
|
||||
* Now rescan for VIRTUAL or METADATA partitions when SPARABLE and
|
||||
|
|
@ -1249,23 +1267,25 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
|
|||
break;
|
||||
}
|
||||
|
||||
if (i >= sbi->s_partitions)
|
||||
if (i >= sbi->s_partitions) {
|
||||
ret = 0;
|
||||
goto out_bh;
|
||||
}
|
||||
|
||||
ret = udf_fill_partdesc_info(sb, p, i);
|
||||
if (ret)
|
||||
if (ret < 0)
|
||||
goto out_bh;
|
||||
|
||||
if (map->s_partition_type == UDF_METADATA_MAP25) {
|
||||
ret = udf_load_metadata_files(sb, i);
|
||||
if (ret) {
|
||||
if (ret < 0) {
|
||||
udf_err(sb, "error loading MetaData partition map %d\n",
|
||||
i);
|
||||
goto out_bh;
|
||||
}
|
||||
} else {
|
||||
ret = udf_load_vat(sb, i, type1_idx);
|
||||
if (ret)
|
||||
if (ret < 0)
|
||||
goto out_bh;
|
||||
/*
|
||||
* Mark filesystem read-only if we have a partition with
|
||||
|
|
@ -1275,6 +1295,7 @@ static int udf_load_partdesc(struct super_block *sb, sector_t block)
|
|||
sb->s_flags |= MS_RDONLY;
|
||||
pr_notice("Filesystem marked read-only because writing to pseudooverwrite partition is not implemented\n");
|
||||
}
|
||||
ret = 0;
|
||||
out_bh:
|
||||
/* In case loading failed, we handle cleanup in udf_fill_super */
|
||||
brelse(bh);
|
||||
|
|
@ -1340,11 +1361,11 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
|
|||
uint16_t ident;
|
||||
struct buffer_head *bh;
|
||||
unsigned int table_len;
|
||||
int ret = 0;
|
||||
int ret;
|
||||
|
||||
bh = udf_read_tagged(sb, block, block, &ident);
|
||||
if (!bh)
|
||||
return 1;
|
||||
return -EAGAIN;
|
||||
BUG_ON(ident != TAG_IDENT_LVD);
|
||||
lvd = (struct logicalVolDesc *)bh->b_data;
|
||||
table_len = le32_to_cpu(lvd->mapTableLength);
|
||||
|
|
@ -1352,7 +1373,7 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
|
|||
udf_err(sb, "error loading logical volume descriptor: "
|
||||
"Partition table too long (%u > %lu)\n", table_len,
|
||||
sb->s_blocksize - sizeof(*lvd));
|
||||
ret = 1;
|
||||
ret = -EIO;
|
||||
goto out_bh;
|
||||
}
|
||||
|
||||
|
|
@ -1396,11 +1417,10 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
|
|||
} else if (!strncmp(upm2->partIdent.ident,
|
||||
UDF_ID_SPARABLE,
|
||||
strlen(UDF_ID_SPARABLE))) {
|
||||
if (udf_load_sparable_map(sb, map,
|
||||
(struct sparablePartitionMap *)gpm) < 0) {
|
||||
ret = 1;
|
||||
ret = udf_load_sparable_map(sb, map,
|
||||
(struct sparablePartitionMap *)gpm);
|
||||
if (ret < 0)
|
||||
goto out_bh;
|
||||
}
|
||||
} else if (!strncmp(upm2->partIdent.ident,
|
||||
UDF_ID_METADATA,
|
||||
strlen(UDF_ID_METADATA))) {
|
||||
|
|
@ -1465,7 +1485,7 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
|
|||
}
|
||||
if (lvd->integritySeqExt.extLength)
|
||||
udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
|
||||
|
||||
ret = 0;
|
||||
out_bh:
|
||||
brelse(bh);
|
||||
return ret;
|
||||
|
|
@ -1503,22 +1523,18 @@ static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_
|
|||
}
|
||||
|
||||
/*
|
||||
* udf_process_sequence
|
||||
* Process a main/reserve volume descriptor sequence.
|
||||
* @block First block of first extent of the sequence.
|
||||
* @lastblock Lastblock of first extent of the sequence.
|
||||
* @fileset There we store extent containing root fileset
|
||||
*
|
||||
* PURPOSE
|
||||
* Process a main/reserve volume descriptor sequence.
|
||||
*
|
||||
* PRE-CONDITIONS
|
||||
* sb Pointer to _locked_ superblock.
|
||||
* block First block of first extent of the sequence.
|
||||
* lastblock Lastblock of first extent of the sequence.
|
||||
*
|
||||
* HISTORY
|
||||
* July 1, 1997 - Andrew E. Mileski
|
||||
* Written, tested, and released.
|
||||
* Returns <0 on error, 0 on success. -EAGAIN is special - try next descriptor
|
||||
* sequence
|
||||
*/
|
||||
static noinline int udf_process_sequence(struct super_block *sb, long block,
|
||||
long lastblock, struct kernel_lb_addr *fileset)
|
||||
static noinline int udf_process_sequence(
|
||||
struct super_block *sb,
|
||||
sector_t block, sector_t lastblock,
|
||||
struct kernel_lb_addr *fileset)
|
||||
{
|
||||
struct buffer_head *bh = NULL;
|
||||
struct udf_vds_record vds[VDS_POS_LENGTH];
|
||||
|
|
@ -1529,6 +1545,7 @@ static noinline 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);
|
||||
|
||||
|
|
@ -1543,7 +1560,7 @@ static noinline int udf_process_sequence(struct super_block *sb, long block,
|
|||
udf_err(sb,
|
||||
"Block %llu of volume descriptor sequence is corrupted or we could not read it\n",
|
||||
(unsigned long long)block);
|
||||
return 1;
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
/* Process each descriptor (ISO 13346 3/8.3-8.4) */
|
||||
|
|
@ -1616,14 +1633,19 @@ static noinline int udf_process_sequence(struct super_block *sb, long block,
|
|||
*/
|
||||
if (!vds[VDS_POS_PRIMARY_VOL_DESC].block) {
|
||||
udf_err(sb, "Primary Volume Descriptor not found!\n");
|
||||
return 1;
|
||||
return -EAGAIN;
|
||||
}
|
||||
if (udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block))
|
||||
return 1;
|
||||
ret = udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (vds[VDS_POS_LOGICAL_VOL_DESC].block && udf_load_logicalvol(sb,
|
||||
vds[VDS_POS_LOGICAL_VOL_DESC].block, fileset))
|
||||
return 1;
|
||||
if (vds[VDS_POS_LOGICAL_VOL_DESC].block) {
|
||||
ret = udf_load_logicalvol(sb,
|
||||
vds[VDS_POS_LOGICAL_VOL_DESC].block,
|
||||
fileset);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (vds[VDS_POS_PARTITION_DESC].block) {
|
||||
/*
|
||||
|
|
@ -1632,19 +1654,27 @@ static noinline int udf_process_sequence(struct super_block *sb, long block,
|
|||
*/
|
||||
for (block = vds[VDS_POS_PARTITION_DESC].block;
|
||||
block < vds[VDS_POS_TERMINATING_DESC].block;
|
||||
block++)
|
||||
if (udf_load_partdesc(sb, block))
|
||||
return 1;
|
||||
block++) {
|
||||
ret = udf_load_partdesc(sb, block);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Load Volume Descriptor Sequence described by anchor in bh
|
||||
*
|
||||
* Returns <0 on error, 0 on success
|
||||
*/
|
||||
static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
|
||||
struct kernel_lb_addr *fileset)
|
||||
{
|
||||
struct anchorVolDescPtr *anchor;
|
||||
long main_s, main_e, reserve_s, reserve_e;
|
||||
sector_t main_s, main_e, reserve_s, reserve_e;
|
||||
int ret;
|
||||
|
||||
anchor = (struct anchorVolDescPtr *)bh->b_data;
|
||||
|
||||
|
|
@ -1662,18 +1692,26 @@ static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
|
|||
|
||||
/* Process the main & reserve sequences */
|
||||
/* responsible for finding the PartitionDesc(s) */
|
||||
if (!udf_process_sequence(sb, main_s, main_e, fileset))
|
||||
return 1;
|
||||
ret = udf_process_sequence(sb, main_s, main_e, fileset);
|
||||
if (ret != -EAGAIN)
|
||||
return ret;
|
||||
udf_sb_free_partitions(sb);
|
||||
if (!udf_process_sequence(sb, reserve_s, reserve_e, fileset))
|
||||
return 1;
|
||||
udf_sb_free_partitions(sb);
|
||||
return 0;
|
||||
ret = udf_process_sequence(sb, reserve_s, reserve_e, fileset);
|
||||
if (ret < 0) {
|
||||
udf_sb_free_partitions(sb);
|
||||
/* No sequence was OK, return -EIO */
|
||||
if (ret == -EAGAIN)
|
||||
ret = -EIO;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check whether there is an anchor block in the given block and
|
||||
* load Volume Descriptor Sequence if so.
|
||||
*
|
||||
* Returns <0 on error, 0 on success, -EAGAIN is special - try next anchor
|
||||
* block
|
||||
*/
|
||||
static int udf_check_anchor_block(struct super_block *sb, sector_t block,
|
||||
struct kernel_lb_addr *fileset)
|
||||
|
|
@ -1685,33 +1723,40 @@ static int udf_check_anchor_block(struct super_block *sb, sector_t block,
|
|||
if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV) &&
|
||||
udf_fixed_to_variable(block) >=
|
||||
sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits)
|
||||
return 0;
|
||||
return -EAGAIN;
|
||||
|
||||
bh = udf_read_tagged(sb, block, block, &ident);
|
||||
if (!bh)
|
||||
return 0;
|
||||
return -EAGAIN;
|
||||
if (ident != TAG_IDENT_AVDP) {
|
||||
brelse(bh);
|
||||
return 0;
|
||||
return -EAGAIN;
|
||||
}
|
||||
ret = udf_load_sequence(sb, bh, fileset);
|
||||
brelse(bh);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Search for an anchor volume descriptor pointer */
|
||||
static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock,
|
||||
struct kernel_lb_addr *fileset)
|
||||
/*
|
||||
* Search for an anchor volume descriptor pointer.
|
||||
*
|
||||
* Returns < 0 on error, 0 on success. -EAGAIN is special - try next set
|
||||
* of anchors.
|
||||
*/
|
||||
static int udf_scan_anchors(struct super_block *sb, sector_t *lastblock,
|
||||
struct kernel_lb_addr *fileset)
|
||||
{
|
||||
sector_t last[6];
|
||||
int i;
|
||||
struct udf_sb_info *sbi = UDF_SB(sb);
|
||||
int last_count = 0;
|
||||
int ret;
|
||||
|
||||
/* First try user provided anchor */
|
||||
if (sbi->s_anchor) {
|
||||
if (udf_check_anchor_block(sb, sbi->s_anchor, fileset))
|
||||
return lastblock;
|
||||
ret = udf_check_anchor_block(sb, sbi->s_anchor, fileset);
|
||||
if (ret != -EAGAIN)
|
||||
return ret;
|
||||
}
|
||||
/*
|
||||
* according to spec, anchor is in either:
|
||||
|
|
@ -1720,39 +1765,46 @@ static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock,
|
|||
* lastblock
|
||||
* however, if the disc isn't closed, it could be 512.
|
||||
*/
|
||||
if (udf_check_anchor_block(sb, sbi->s_session + 256, fileset))
|
||||
return lastblock;
|
||||
ret = udf_check_anchor_block(sb, sbi->s_session + 256, fileset);
|
||||
if (ret != -EAGAIN)
|
||||
return ret;
|
||||
/*
|
||||
* The trouble is which block is the last one. Drives often misreport
|
||||
* this so we try various possibilities.
|
||||
*/
|
||||
last[last_count++] = lastblock;
|
||||
if (lastblock >= 1)
|
||||
last[last_count++] = lastblock - 1;
|
||||
last[last_count++] = lastblock + 1;
|
||||
if (lastblock >= 2)
|
||||
last[last_count++] = lastblock - 2;
|
||||
if (lastblock >= 150)
|
||||
last[last_count++] = lastblock - 150;
|
||||
if (lastblock >= 152)
|
||||
last[last_count++] = lastblock - 152;
|
||||
last[last_count++] = *lastblock;
|
||||
if (*lastblock >= 1)
|
||||
last[last_count++] = *lastblock - 1;
|
||||
last[last_count++] = *lastblock + 1;
|
||||
if (*lastblock >= 2)
|
||||
last[last_count++] = *lastblock - 2;
|
||||
if (*lastblock >= 150)
|
||||
last[last_count++] = *lastblock - 150;
|
||||
if (*lastblock >= 152)
|
||||
last[last_count++] = *lastblock - 152;
|
||||
|
||||
for (i = 0; i < last_count; i++) {
|
||||
if (last[i] >= sb->s_bdev->bd_inode->i_size >>
|
||||
sb->s_blocksize_bits)
|
||||
continue;
|
||||
if (udf_check_anchor_block(sb, last[i], fileset))
|
||||
return last[i];
|
||||
ret = udf_check_anchor_block(sb, last[i], fileset);
|
||||
if (ret != -EAGAIN) {
|
||||
if (!ret)
|
||||
*lastblock = last[i];
|
||||
return ret;
|
||||
}
|
||||
if (last[i] < 256)
|
||||
continue;
|
||||
if (udf_check_anchor_block(sb, last[i] - 256, fileset))
|
||||
return last[i];
|
||||
ret = udf_check_anchor_block(sb, last[i] - 256, fileset);
|
||||
if (ret != -EAGAIN) {
|
||||
if (!ret)
|
||||
*lastblock = last[i];
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
/* Finally try block 512 in case media is open */
|
||||
if (udf_check_anchor_block(sb, sbi->s_session + 512, fileset))
|
||||
return last[0];
|
||||
return 0;
|
||||
return udf_check_anchor_block(sb, sbi->s_session + 512, fileset);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1760,54 +1812,59 @@ static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock,
|
|||
* area specified by it. The function expects sbi->s_lastblock to be the last
|
||||
* block on the media.
|
||||
*
|
||||
* Return 1 if ok, 0 if not found.
|
||||
*
|
||||
* Return <0 on error, 0 if anchor found. -EAGAIN is special meaning anchor
|
||||
* was not found.
|
||||
*/
|
||||
static int udf_find_anchor(struct super_block *sb,
|
||||
struct kernel_lb_addr *fileset)
|
||||
{
|
||||
sector_t lastblock;
|
||||
struct udf_sb_info *sbi = UDF_SB(sb);
|
||||
sector_t lastblock = sbi->s_last_block;
|
||||
int ret;
|
||||
|
||||
lastblock = udf_scan_anchors(sb, sbi->s_last_block, fileset);
|
||||
if (lastblock)
|
||||
ret = udf_scan_anchors(sb, &lastblock, fileset);
|
||||
if (ret != -EAGAIN)
|
||||
goto out;
|
||||
|
||||
/* No anchor found? Try VARCONV conversion of block numbers */
|
||||
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
|
||||
lastblock = udf_variable_to_fixed(sbi->s_last_block);
|
||||
/* Firstly, we try to not convert number of the last block */
|
||||
lastblock = udf_scan_anchors(sb,
|
||||
udf_variable_to_fixed(sbi->s_last_block),
|
||||
fileset);
|
||||
if (lastblock)
|
||||
ret = udf_scan_anchors(sb, &lastblock, fileset);
|
||||
if (ret != -EAGAIN)
|
||||
goto out;
|
||||
|
||||
lastblock = sbi->s_last_block;
|
||||
/* Secondly, we try with converted number of the last block */
|
||||
lastblock = udf_scan_anchors(sb, sbi->s_last_block, fileset);
|
||||
if (!lastblock) {
|
||||
ret = udf_scan_anchors(sb, &lastblock, fileset);
|
||||
if (ret < 0) {
|
||||
/* VARCONV didn't help. Clear it. */
|
||||
UDF_CLEAR_FLAG(sb, UDF_FLAG_VARCONV);
|
||||
return 0;
|
||||
}
|
||||
out:
|
||||
sbi->s_last_block = lastblock;
|
||||
return 1;
|
||||
if (ret == 0)
|
||||
sbi->s_last_block = lastblock;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check Volume Structure Descriptor, find Anchor block and load Volume
|
||||
* Descriptor Sequence
|
||||
* Descriptor Sequence.
|
||||
*
|
||||
* Returns < 0 on error, 0 on success. -EAGAIN is special meaning anchor
|
||||
* block was not found.
|
||||
*/
|
||||
static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
|
||||
int silent, struct kernel_lb_addr *fileset)
|
||||
{
|
||||
struct udf_sb_info *sbi = UDF_SB(sb);
|
||||
loff_t nsr_off;
|
||||
int ret;
|
||||
|
||||
if (!sb_set_blocksize(sb, uopt->blocksize)) {
|
||||
if (!silent)
|
||||
udf_warn(sb, "Bad block size\n");
|
||||
return 0;
|
||||
return -EINVAL;
|
||||
}
|
||||
sbi->s_last_block = uopt->lastblock;
|
||||
if (!uopt->novrs) {
|
||||
|
|
@ -1828,12 +1885,13 @@ static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
|
|||
|
||||
/* Look for anchor block and load Volume Descriptor Sequence */
|
||||
sbi->s_anchor = uopt->anchor;
|
||||
if (!udf_find_anchor(sb, fileset)) {
|
||||
if (!silent)
|
||||
ret = udf_find_anchor(sb, fileset);
|
||||
if (ret < 0) {
|
||||
if (!silent && ret == -EAGAIN)
|
||||
udf_warn(sb, "No anchor found\n");
|
||||
return 0;
|
||||
return ret;
|
||||
}
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void udf_open_lvid(struct super_block *sb)
|
||||
|
|
@ -1939,7 +1997,7 @@ u64 lvid_get_unique_id(struct super_block *sb)
|
|||
|
||||
static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
||||
{
|
||||
int ret;
|
||||
int ret = -EINVAL;
|
||||
struct inode *inode = NULL;
|
||||
struct udf_options uopt;
|
||||
struct kernel_lb_addr rootdir, fileset;
|
||||
|
|
@ -2011,7 +2069,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
} else {
|
||||
uopt.blocksize = bdev_logical_block_size(sb->s_bdev);
|
||||
ret = udf_load_vrs(sb, &uopt, silent, &fileset);
|
||||
if (!ret && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
|
||||
if (ret == -EAGAIN && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
|
||||
if (!silent)
|
||||
pr_notice("Rescanning with blocksize %d\n",
|
||||
UDF_DEFAULT_BLOCKSIZE);
|
||||
|
|
@ -2021,8 +2079,11 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
ret = udf_load_vrs(sb, &uopt, silent, &fileset);
|
||||
}
|
||||
}
|
||||
if (!ret) {
|
||||
udf_warn(sb, "No partition found (1)\n");
|
||||
if (ret < 0) {
|
||||
if (ret == -EAGAIN) {
|
||||
udf_warn(sb, "No partition found (1)\n");
|
||||
ret = -EINVAL;
|
||||
}
|
||||
goto error_out;
|
||||
}
|
||||
|
||||
|
|
@ -2040,6 +2101,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
udf_err(sb, "minUDFReadRev=%x (max is %x)\n",
|
||||
le16_to_cpu(lvidiu->minUDFReadRev),
|
||||
UDF_MAX_READ_VERSION);
|
||||
ret = -EINVAL;
|
||||
goto error_out;
|
||||
} else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
|
||||
sb->s_flags |= MS_RDONLY;
|
||||
|
|
@ -2054,6 +2116,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
|
||||
if (!sbi->s_partitions) {
|
||||
udf_warn(sb, "No partition found (2)\n");
|
||||
ret = -EINVAL;
|
||||
goto error_out;
|
||||
}
|
||||
|
||||
|
|
@ -2065,6 +2128,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
|
||||
if (udf_find_fileset(sb, &fileset, &rootdir)) {
|
||||
udf_warn(sb, "No fileset found\n");
|
||||
ret = -EINVAL;
|
||||
goto error_out;
|
||||
}
|
||||
|
||||
|
|
@ -2086,6 +2150,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
if (!inode) {
|
||||
udf_err(sb, "Error in udf_iget, block=%d, partition=%d\n",
|
||||
rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
|
||||
ret = -EIO;
|
||||
goto error_out;
|
||||
}
|
||||
|
||||
|
|
@ -2093,6 +2158,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|||
sb->s_root = d_make_root(inode);
|
||||
if (!sb->s_root) {
|
||||
udf_err(sb, "Couldn't allocate root dentry\n");
|
||||
ret = -ENOMEM;
|
||||
goto error_out;
|
||||
}
|
||||
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
||||
|
|
@ -2113,7 +2179,7 @@ error_out:
|
|||
kfree(sbi);
|
||||
sb->s_fs_info = NULL;
|
||||
|
||||
return -EINVAL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void _udf_err(struct super_block *sb, const char *function,
|
||||
|
|
|
|||
Loading…
Reference in New Issue