From d3179631c9e769f6a8f73367934376d0f3165849 Mon Sep 17 00:00:00 2001 From: Murai Takashi Date: Wed, 7 Oct 2020 19:24:02 +0900 Subject: [PATCH] file_systems/udf: Reduce indent Reduce indent in walk_volume_descriptor_sequence() for readability. Change-Id: Ie4d46fc69ebee3b74f0410639f06010351e71894 Reviewed-on: https://review.haiku-os.org/c/haiku/+/3294 Reviewed-by: waddlesplash --- .../kernel/file_systems/udf/Recognition.cpp | 280 ++++++++++-------- 1 file changed, 150 insertions(+), 130 deletions(-) diff --git a/src/add-ons/kernel/file_systems/udf/Recognition.cpp b/src/add-ons/kernel/file_systems/udf/Recognition.cpp index 12ddee2355..ffa5bcb8a4 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 @@ walk_volume_recognition_sequence(int device, off_t offset, uint32 blockSize, // 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 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length, 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 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length, 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", @@ -239,6 +239,87 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length, RETURN(error); } +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(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, @@ -252,16 +333,16 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence, "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 +350,8 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence, 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 +371,104 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence, case TAGID_PRIMARY_VOLUME_DESCRIPTOR: { - primary_volume_descriptor *primary = reinterpret_cast(tag); - PDUMP(primary); + primary_volume_descriptor *primary = + reinterpret_cast(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(tag); + implementation_use_descriptor *impUse = + reinterpret_cast(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(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(tag); + logical_volume_descriptor *logical = + reinterpret_cast(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(tag); + unallocated_space_descriptor *unallocated = + reinterpret_cast(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(tag); + terminating_descriptor *terminating = + reinterpret_cast(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 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence, \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 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift, 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 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift, 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(chunk.Data()); @@ -513,36 +533,36 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift, 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 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift, FATAL(("found udf revision 0x%x more than max 0x%x\n", highestMinimumUDFReadRevision, UDF_MAX_READ_REVISION)); } - RETURN(error); + RETURN(error); }