From Murai Takashi <tmurai01@xxxxxxxxx>:
Murai Takashi has uploaded this change for review. (
https://review.haiku-os.org/c/haiku/+/3294 ;)
Change subject: file_systems/udf: Reduce indent
......................................................................
file_systems/udf: Reduce indent
Reduce indent in walk_volume_descriptor_sequence() for readability.
Change-Id: Ie4d46fc69ebee3b74f0410639f06010351e71894
---
M src/add-ons/kernel/file_systems/udf/Recognition.cpp
1 file changed, 150 insertions(+), 130 deletions(-)
git pull ssh://git.haiku-os.org:22/haiku refs/changes/94/3294/1
diff --git a/src/add-ons/kernel/file_systems/udf/Recognition.cpp
b/src/add-ons/kernel/file_systems/udf/Recognition.cpp
index 12ddee2..4008488 100644
--- a/src/add-ons/kernel/file_systems/udf/Recognition.cpp
+++ b/src/add-ons/kernel/file_systems/udf/Recognition.cpp
@@ -166,13 +166,13 @@
// or terminating extended area descriptor with NO ECMA-168
// descriptors, we return B_OK to signal that we should go
// looking for valid anchors.
- return foundECMA167 || (foundExtended && !foundECMA168) ? B_OK :
B_ERROR;
+ return foundECMA167 || (foundExtended && !foundECMA168) ? B_OK :
B_ERROR;
}
static status_t
walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
- uint32 blockSize, uint32 blockShift,
+ uint32 blockSize, uint32 blockShift,
primary_volume_descriptor &primaryVolumeDescriptor,
logical_volume_descriptor &logicalVolumeDescriptor,
partition_descriptor partitionDescriptors[],
@@ -182,7 +182,7 @@
const uint8 avds_location_count = 4;
const off_t avds_locations[avds_location_count]
= { 256, length-1-256, length-1, 512, };
- bool found_vds = false;
+ bool found_vds = false;
for (int32 i = 0; i < avds_location_count; i++) {
off_t block = avds_locations[i];
off_t address = (offset + block) << blockShift;
@@ -222,7 +222,7 @@
anchorErr =
walk_volume_descriptor_sequence(anchor->reserve_vds(),
device, blockSize, blockShift,
primaryVolumeDescriptor,
logicalVolumeDescriptor,
partitionDescriptors,
- partitionDescriptorCount);
+ partitionDescriptorCount);
}
if (!anchorErr) {
PRINT(("block %" B_PRIdOFF ": found valid vds\n",
@@ -241,6 +241,88 @@
static
status_t
+walk_tagid_partition_descriptor(descriptor_tag *tag, off_t block,
+ uint8 uniquePartitions, partition_descriptor* partitionDescriptors)
+{
+ DEBUG_INIT(NULL);
+
+ status_t error = B_OK;
+ partition_descriptor *partition =
+ reinterpret_cast<partition_descriptor*>(tag);
+ PDUMP(partition);
+ if (partition->tag().init_check(block) == B_OK) {
+ // Check for a previously discovered partition descriptor with
+ // the same number as this partition. If found, keep the one
with
+ // the higher vds number.
+ bool foundDuplicate = false;
+ int num;
+ for (num = 0; num < uniquePartitions; num++) {
+ if (partitionDescriptors[num].partition_number()
+ == partition->partition_number()) {
+ foundDuplicate = true;
+ if (partitionDescriptors[num].vds_number()
+ < partition->vds_number()) {
+ partitionDescriptors[num] = *partition;
+ PRINT(("Replacing previous partition
#%d "
+ "(vds_number: %" B_PRIu32 ")
with new partition #%d "
+ "(vds_number: %" B_PRIu32 ")\n",
+
partitionDescriptors[num].partition_number(),
+
partitionDescriptors[num].vds_number(),
+ partition->partition_number(),
+ partition->vds_number()));
+ }
+ break;
+ }
+ }
+ // If we didn't find a duplicate, see if we have any open
descriptor
+ // spaces left.
+ if (!foundDuplicate) {
+ if (num < kMaxPartitionDescriptors) {
+ // At least one more partition descriptor allowed
+ partitionDescriptors[num] = *partition;
+ uniquePartitions++;
+ PRINT(("Adding partition #%d (vds_number: %"
B_PRIu32 ")\n",
+ partition->partition_number(),
+ partition->vds_number()));
+ } else {
+ // We've found more than
kMaxPartitionDescriptor uniquely-
+ // numbered partitions. So, search through the
partitions
+ // we already have again, this time just
looking for a
+ // partition with a lower vds number. If we
find one,
+ // replace it with this one. If we don't,
scream bloody
+ // murder.
+ bool foundReplacement = false;
+ for (int j = 0; j < uniquePartitions; j++) {
+ if (partitionDescriptors[j].vds_number()
+ < partition->vds_number()) {
+ foundReplacement = true;
+ partitionDescriptors[j] =
*partition;
+ PRINT(("Replacing partition #%d
"
+ "(vds_number: %"
B_PRIu32 ") "
+ "with partition #%d "
+ "(vds_number: %"
B_PRIu32 ")\n",
+
partitionDescriptors[j].partition_number(),
+
partitionDescriptors[j].vds_number(),
+
partition->partition_number(),
+
partition->vds_number()));
+ break;
+ }
+ }
+ if (!foundReplacement) {
+ PRINT(("Found more than
kMaxPartitionDescriptors == %d "
+ "unique partition descriptors!\n",
+ kMaxPartitionDescriptors));
+ error = B_BAD_VALUE;
+ }
+ }
+ }
+ }
+
+ RETURN(error);
+}
+
+static
+status_t
walk_volume_descriptor_sequence(extent_address descriptorSequence,
int device, uint32 blockSize, uint32 blockShift,
primary_volume_descriptor &primaryVolumeDescriptor,
@@ -252,16 +334,16 @@
"descriptorSequence.len:%" PRIu32,
descriptorSequence.location(), descriptorSequence.length()));
uint32 count = descriptorSequence.length() >> blockShift;
-
+
bool foundLogicalVolumeDescriptor = false;
bool foundUnallocatedSpaceDescriptor = false;
bool foundUdfImplementationUseDescriptor = false;
uint8 uniquePartitions = 0;
status_t error = B_OK;
-
+
for (uint32 i = 0; i < count; i++) {
off_t block = descriptorSequence.location()+i;
- off_t address = block << blockShift;
+ off_t address = block << blockShift;
MemoryChunk chunk(blockSize);
descriptor_tag *tag = NULL;
@@ -269,7 +351,8 @@
status_t loopError = chunk.InitCheck();
if (!loopError) {
- ssize_t bytesRead = read_pos(device, address,
chunk.Data(), blockSize);
+ ssize_t bytesRead = read_pos(device, address,
chunk.Data(),
+ blockSize);
loopError = bytesRead == (ssize_t)blockSize ? B_OK :
B_IO_ERROR;
if (loopError) {
PRINT(("block %" B_PRIdOFF ": read_pos(pos:%"
B_PRIdOFF ", "
@@ -289,166 +372,103 @@
case TAGID_PRIMARY_VOLUME_DESCRIPTOR:
{
- primary_volume_descriptor *primary =
reinterpret_cast<primary_volume_descriptor*>(tag);
- PDUMP(primary);
+ primary_volume_descriptor *primary =
+
reinterpret_cast<primary_volume_descriptor*>(tag);
+ PDUMP(primary);
primaryVolumeDescriptor = *primary;
break;
}
case TAGID_ANCHOR_VOLUME_DESCRIPTOR_POINTER:
break;
-
+
case TAGID_VOLUME_DESCRIPTOR_POINTER:
break;
case TAGID_IMPLEMENTATION_USE_VOLUME_DESCRIPTOR:
{
- implementation_use_descriptor *impUse =
reinterpret_cast<implementation_use_descriptor*>(tag);
+ implementation_use_descriptor *impUse =
+
reinterpret_cast<implementation_use_descriptor*>(tag);
PDUMP(impUse);
- // Check for a matching implementation
id string (note that the
- // revision version is not checked)
+ // Check for a matching implementation
id string
+ // (note that the revision version is
not checked)
if (impUse->tag().init_check(block) ==
B_OK
- &&
impUse->implementation_id().matches(kLogicalVolumeInfoId201)) {
-
foundUdfImplementationUseDescriptor = true;
+ &&
impUse->implementation_id().matches(
+ kLogicalVolumeInfoId201)) {
+
foundUdfImplementationUseDescriptor = true;
}
break;
}
case TAGID_PARTITION_DESCRIPTOR:
{
- partition_descriptor *partition =
reinterpret_cast<partition_descriptor*>(tag);
- PDUMP(partition);
- if (partition->tag().init_check(block)
== B_OK) {
- // Check for a previously
discovered partition descriptor with
- // the same number as this
partition. If found, keep the one with
- // the higher vds number.
- bool foundDuplicate = false;
- int num;
- for (num = 0; num <
uniquePartitions; num++) {
- if
(partitionDescriptors[num].partition_number()
- ==
partition->partition_number()) {
- foundDuplicate
= true;
- if
(partitionDescriptors[num].vds_number()
- <
partition->vds_number()) {
-
partitionDescriptors[num] = *partition;
-
PRINT(("Replacing previous partition #%d "
-
"(vds_number: %" B_PRIu32 ") "
-
"with new partition #%d "
-
"(vds_number: %" B_PRIu32 ")\n",
-
partitionDescriptors[num].partition_number(),
-
partitionDescriptors[num].vds_number(),
-
partition->partition_number(),
-
partition->vds_number()));
- }
- break;
- }
- }
- // If we didn't find a
duplicate, see if we have any open descriptor
- // spaces left.
- if (!foundDuplicate) {
- if (num <
kMaxPartitionDescriptors) {
- // At least one
more partition descriptor allowed
-
partitionDescriptors[num] = *partition;
-
uniquePartitions++;
- PRINT(("Adding
partition #%d (vds_number: %" B_PRIu32
- ")\n",
-
partition->partition_number(),
-
partition->vds_number()));
- } else {
- // We've found
more than kMaxPartitionDescriptor uniquely-
- // numbered
partitions. So, search through the partitions
- // we already
have again, this time just looking for a
- // partition
with a lower vds number. If we find one,
- // replace it
with this one. If we don't, scream bloody
- // murder.
- bool
foundReplacement = false;
- for (int j = 0;
j < uniquePartitions; j++) {
- if
(partitionDescriptors[j].vds_number()
- <
partition->vds_number()) {
-
foundReplacement = true;
-
partitionDescriptors[j] = *partition;
-
PRINT(("Replacing partition #%d "
-
"(vds_number: %" B_PRIu32 ") "
-
"with partition #%d "
-
"(vds_number: %" B_PRIu32 ")\n",
-
partitionDescriptors[j].partition_number(),
-
partitionDescriptors[j].vds_number(),
-
partition->partition_number(),
-
partition->vds_number()));
-
break;
- }
- }
- if
(!foundReplacement) {
-
PRINT(("Found more than kMaxPartitionDescriptors == %d "
-
"unique partition descriptors!\n",
-
kMaxPartitionDescriptors));
- error =
B_BAD_VALUE;
- break;
- }
- }
- }
- }
+ error = walk_tagid_partition_descriptor(
+ tag, block, uniquePartitions,
partitionDescriptors);
break;
}
-
+
case TAGID_LOGICAL_VOLUME_DESCRIPTOR:
{
- logical_volume_descriptor *logical =
reinterpret_cast<logical_volume_descriptor*>(tag);
+ logical_volume_descriptor *logical =
+
reinterpret_cast<logical_volume_descriptor*>(tag);
PDUMP(logical);
if (foundLogicalVolumeDescriptor) {
// Keep the vd with the highest
vds_number
- if
(logicalVolumeDescriptor.vds_number() < logical->vds_number())
- logicalVolumeDescriptor
= *logical;
+ if
(logicalVolumeDescriptor.vds_number()
+ < logical->vds_number())
+
logicalVolumeDescriptor = *logical;
} else {
logicalVolumeDescriptor =
*logical;
foundLogicalVolumeDescriptor =
true;
}
break;
}
-
+
case TAGID_UNALLOCATED_SPACE_DESCRIPTOR:
{
- unallocated_space_descriptor
*unallocated = reinterpret_cast<unallocated_space_descriptor*>(tag);
+ unallocated_space_descriptor
*unallocated =
+
reinterpret_cast<unallocated_space_descriptor*>(tag);
PDUMP(unallocated);
- foundUnallocatedSpaceDescriptor = true;
- (void)unallocated; // kill the
warning
+ foundUnallocatedSpaceDescriptor = true;
+ (void)unallocated; // kill the
warning
break;
}
-
+
case TAGID_TERMINATING_DESCRIPTOR:
{
- terminating_descriptor *terminating =
reinterpret_cast<terminating_descriptor*>(tag);
+ terminating_descriptor *terminating =
+
reinterpret_cast<terminating_descriptor*>(tag);
PDUMP(terminating);
- (void)terminating; // kill the
warning
+ (void)terminating; // kill the
warning
break;
}
-
+
case TAGID_LOGICAL_VOLUME_INTEGRITY_DESCRIPTOR:
// Not found in this descriptor sequence
break;
default:
- break;
-
+ break;
+
}
}
}
PRINT(("found %d unique partition%s\n", uniquePartitions,
- (uniquePartitions == 1 ? "" : "s")));
-
+ (uniquePartitions == 1 ? "" : "s")));
+
if (!error && !foundUdfImplementationUseDescriptor) {
INFORM(("WARNING: no valid udf implementation use descriptor
found\n"));
}
- if (!error)
+ if (!error)
error = foundLogicalVolumeDescriptor
- && foundUnallocatedSpaceDescriptor
- ? B_OK : B_ERROR;
- if (!error)
+ && foundUnallocatedSpaceDescriptor
+ ? B_OK : B_ERROR;
+ if (!error)
error = uniquePartitions >= 1 ? B_OK : B_ERROR;
- if (!error)
- partitionDescriptorCount = uniquePartitions;
-
+ if (!error)
+ partitionDescriptorCount = uniquePartitions;
+
RETURN(error);
}
@@ -456,27 +476,27 @@
\return
- \c B_OK: Success. the sequence was terminated by a valid, closed
- integrity descriptor.
+ integrity descriptor.
- \c B_ENTRY_NOT_FOUND: The sequence was empty.
- (other error code): The sequence was non-empty and did not end in a
valid,
closed integrity descriptor.
-*/
+*/
static status_t
walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift,
extent_address descriptorSequence, uint32
sequenceNumber)
{
DEBUG_INIT_ETC(NULL,
- ("descriptorSequence.loc:%" B_PRIu32 ", "
- "descriptorSequence.len:%" B_PRIu32 ,
- descriptorSequence.location(), descriptorSequence.length()));
+ ("descriptorSequence.loc:%" B_PRIu32 ", "
+ "descriptorSequence.len:%" B_PRIu32 ,
+ descriptorSequence.location(), descriptorSequence.length()));
uint32 count = descriptorSequence.length() >> blockShift;
-
+
bool lastDescriptorWasClosed = false;
uint16 highestMinimumUDFReadRevision = 0x0000;
status_t error = count > 0 ? B_OK : B_ENTRY_NOT_FOUND;
for (uint32 i = 0; error == B_OK && i < count; i++) {
off_t block = descriptorSequence.location()+i;
- off_t address = block << blockShift;
+ off_t address = block << blockShift;
MemoryChunk chunk(blockSize);
descriptor_tag *tag = NULL;
@@ -490,8 +510,8 @@
loopError = check_size_error(bytesRead, blockSize);
if (loopError) {
PRINT(("block %" B_PRIdOFF": read_pos(pos:%"
B_PRIdOFF
- ", len:%" B_PRIu32 ") failed with error
0x%lx\n",
- block, address, blockSize, bytesRead));
+ ", len:%" B_PRIu32 ") failed with error
0x%lx\n",
+ block, address, blockSize, bytesRead));
}
}
if (!loopError) {
@@ -501,7 +521,7 @@
if (!loopError) {
// Check the descriptor type and see if it's closed.
loopError = tag->id() ==
TAGID_LOGICAL_VOLUME_INTEGRITY_DESCRIPTOR
- ? B_OK : B_BAD_DATA;
+ ? B_OK : B_BAD_DATA;
if (!loopError) {
logical_volume_integrity_descriptor *descriptor
=
reinterpret_cast<logical_volume_integrity_descriptor*>(chunk.Data());
@@ -513,36 +533,36 @@
highestMinimumUDFReadRevision =
minimumRevision;
} else if (minimumRevision <
highestMinimumUDFReadRevision) {
INFORM(("WARNING: found
decreasing minimum udf read revision in integrity "
- "sequence (last
highest: 0x%04x, current: 0x%04x); using higher "
- "revision.\n",
highestMinimumUDFReadRevision, minimumRevision));
+ "sequence (last
highest: 0x%04x, current: 0x%04x); using higher "
+ "revision.\n",
highestMinimumUDFReadRevision, minimumRevision));
}
}
-
+
// Check a continuation extent if necessary.
Note that this effectively
// ends our search through this extent
extent_address &next =
descriptor->next_integrity_extent();
if (next.length() > 0) {
status_t nextError =
walk_integrity_sequence(device, blockSize, blockShift,
-
next, sequenceNumber+1);
+ next, sequenceNumber+1);
if (nextError && nextError !=
B_ENTRY_NOT_FOUND) {
// Continuation proved invalid
error = nextError;
- break;
+ break;
} else {
// Either the continuation was
valid or empty; either way,
// we're done searching.
break;
- }
+ }
}
} else {
PDUMP(tag);
- }
+ }
}
// If we hit an error on the first item, consider the extent
empty,
// otherwise just break out of the loop and assume part of the
// extent is unrecorded
if (loopError) {
- if (i == 0)
+ if (i == 0)
error = B_ENTRY_NOT_FOUND;
else
break;
@@ -556,5 +576,5 @@
FATAL(("found udf revision 0x%x more than max 0x%x\n",
highestMinimumUDFReadRevision, UDF_MAX_READ_REVISION));
}
- RETURN(error);
+ RETURN(error);
}
--
To view, visit https://review.haiku-os.org/c/haiku/+/3294
To unsubscribe, or for help writing mail filters, visit
https://review.haiku-os.org/settings
Gerrit-Project: haiku
Gerrit-Branch: master
Gerrit-Change-Id: Ie4d46fc69ebee3b74f0410639f06010351e71894
Gerrit-Change-Number: 3294
Gerrit-PatchSet: 1
Gerrit-Owner: Murai Takashi <tmurai01@xxxxxxxxx>
Gerrit-MessageType: newchange
