i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed "udf_" prefix from udf on-disk data structures, as they already

Browse Source 
live in the Udf:: namespace, and I'll be referencing them fully qualified in
makeudfimage and don't feel like typing udf twice each time.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@5474 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Tyler Dauwalder
2003-11-25 00:12:50 +00:00
parent 65a98eb199
commit 1379caca11
14 changed files with 409 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/udf/AllocationDescriptorList.h
+3 -3
View File
@@ -61,7 +61,7 @@ public:
\param isEmpty If set to true, indicates that the given extent is unrecorded \param isEmpty If set to true, indicates that the given extent is unrecorded
and thus its contents should be interpreted as all zeros. and thus its contents should be interpreted as all zeros.
*/ */
status_t FindExtent(off_t start, udf_long_address *extent, bool *isEmpty) { status_t FindExtent(off_t start, long_address *extent, bool *isEmpty) {
DEBUG_INIT_ETC(CF_PUBLIC | CF_FILE_OPS | CF_HIGH_VOLUME, "AllocationDescriptorList<>", DEBUG_INIT_ETC(CF_PUBLIC | CF_FILE_OPS | CF_HIGH_VOLUME, "AllocationDescriptorList<>",
("start: %Ld, extent: %p, isEmpty: %p", start, extent, isEmpty)); ("start: %Ld, extent: %p, isEmpty: %p", start, extent, isEmpty));
off_t startBlock = start >> fVolume->BlockShift(); off_t startBlock = start >> fVolume->BlockShift();
@@ -213,7 +213,7 @@ public:
{ {
} }
typedef udf_short_address DescriptorType; typedef short_address DescriptorType;
inline uint8 GetType(DescriptorType &descriptor) const { inline uint8 GetType(DescriptorType &descriptor) const {
return descriptor.type(); return descriptor.type();
@@ -236,7 +236,7 @@ private:
class LongDescriptorAccessor { class LongDescriptorAccessor {
public: public:
typedef udf_long_address DescriptorType; typedef long_address DescriptorType;
inline uint8 GetType(DescriptorType &descriptor) const { inline uint8 GetType(DescriptorType &descriptor) const {
return descriptor.type(); return descriptor.type();
src/add-ons/kernel/file_systems/udf/CachedBlock.h
+4 -4
View File
@@ -43,7 +43,7 @@ class CachedBlock {
inline void Keep(); inline void Keep();
inline void Unset(); inline void Unset();
inline uint8 *SetTo(off_t block, bool empty = false); inline uint8 *SetTo(off_t block, bool empty = false);
inline uint8 *SetTo(udf_long_address address, bool empty = false); inline uint8 *SetTo(long_address address, bool empty = false);
template <class Accessor, class Descriptor> template <class Accessor, class Descriptor>
inline uint8* SetTo(Accessor &accessor, Descriptor &descriptor, inline uint8* SetTo(Accessor &accessor, Descriptor &descriptor,
bool empty = false); bool empty = false);
@@ -126,7 +126,7 @@ CachedBlock::SetTo(off_t block, bool empty = false)
} }
inline uint8 * inline uint8 *
CachedBlock::SetTo(udf_long_address address, bool empty = false) CachedBlock::SetTo(long_address address, bool empty = false)
{ {
off_t block; off_t block;
if (fVolume->MapBlock(address, &block) == B_OK) if (fVolume->MapBlock(address, &block) == B_OK)
@@ -139,8 +139,8 @@ template <class Accessor, class Descriptor>
inline uint8* inline uint8*
CachedBlock::SetTo(Accessor &accessor, Descriptor &descriptor, bool empty = false) CachedBlock::SetTo(Accessor &accessor, Descriptor &descriptor, bool empty = false)
{ {
// Make a udf_long_address out of the descriptor and call it a day // Make a long_address out of the descriptor and call it a day
udf_long_address address; long_address address;
address.set_to(accessor.GetBlock(descriptor), address.set_to(accessor.GetBlock(descriptor),
accessor.GetPartition(descriptor)); accessor.GetPartition(descriptor));
return SetTo(address, empty); return SetTo(address, empty);
src/add-ons/kernel/file_systems/udf/DirectoryIterator.cpp
+2 -2
View File
@@ -41,7 +41,7 @@ DirectoryIterator::GetNextEntry(char *name, uint32 *length, vnode_id *id)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
uint8 data[kMaxFileIdSize]; uint8 data[kMaxFileIdSize];
udf_file_id_descriptor *entry = reinterpret_cast<udf_file_id_descriptor*>(data); file_id_descriptor *entry = reinterpret_cast<file_id_descriptor*>(data);
uint32 block = 0; uint32 block = 0;
off_t offset = fPosition; off_t offset = fPosition;
@@ -51,7 +51,7 @@ DirectoryIterator::GetNextEntry(char *name, uint32 *length, vnode_id *id)
// then, based on the information therein, read in the variable // then, based on the information therein, read in the variable
// length tail portion as well. // length tail portion as well.
error = Parent()->Read(offset, entry, &entryLength, &block); error = Parent()->Read(offset, entry, &entryLength, &block);
if (!error && entryLength >= sizeof(udf_file_id_descriptor) && entry->tag().init_check(block) == B_OK) { if (!error && entryLength >= sizeof(file_id_descriptor) && entry->tag().init_check(block) == B_OK) {
PDUMP(entry); PDUMP(entry);
offset += entry->total_length(); offset += entry->total_length();
src/add-ons/kernel/file_systems/udf/DiskStructures.cpp
+72 -72
View File
@@ -37,16 +37,16 @@ const char* Udf::kVSDID_ECMA167_2 = "NSR02";
const char* Udf::kVSDID_ECMA167_3 = "NSR03"; const char* Udf::kVSDID_ECMA167_3 = "NSR03";
const char* Udf::kVSDID_ECMA168 = "CDW02"; const char* Udf::kVSDID_ECMA168 = "CDW02";
// udf_entity_ids // entity_ids
const udf_entity_id Udf::kMetadataPartitionMapId(0, "*UDF Metadata Partition"); const entity_id Udf::kMetadataPartitionMapId(0, "*UDF Metadata Partition");
const udf_entity_id Udf::kSparablePartitionMapId(0, "*UDF Sparable Partition"); const entity_id Udf::kSparablePartitionMapId(0, "*UDF Sparable Partition");
const udf_entity_id Udf::kVirtualPartitionMapId(0, "*UDF Virtual Partition"); const entity_id Udf::kVirtualPartitionMapId(0, "*UDF Virtual Partition");
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Helper functions // Helper functions
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const char *Udf::udf_tag_id_to_string(udf_tag_id id) const char *Udf::tag_id_to_string(tag_id id)
{ {
switch (id) { switch (id) {
case TAGID_UNDEFINED: case TAGID_UNDEFINED:
@@ -103,39 +103,39 @@ const char *Udf::udf_tag_id_to_string(udf_tag_id id)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_volume_structure_descriptor_header // volume_structure_descriptor_header
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/*! \brief Returns true if the given \a id matches the header's id. /*! \brief Returns true if the given \a id matches the header's id.
*/ */
bool bool
udf_volume_structure_descriptor_header::id_matches(const char *id) volume_structure_descriptor_header::id_matches(const char *id)
{ {
return strncmp(this->id, id, 5) == 0; return strncmp(this->id, id, 5) == 0;
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_charspec // charspec
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_charspec::dump() const charspec::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_charspec"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "charspec");
PRINT(("character_set_type: %d\n", character_set_type())); PRINT(("character_set_type: %d\n", character_set_type()));
PRINT(("character_set_info: `%s'\n", character_set_info())); PRINT(("character_set_info: `%s'\n", character_set_info()));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_timestamp // timestamp
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_timestamp::dump() const timestamp::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_timestamp"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "timestamp");
PRINT(("type: %d\n", type())); PRINT(("type: %d\n", type()));
PRINT(("timezone: %d\n", timezone())); PRINT(("timezone: %d\n", timezone()));
PRINT(("year: %d\n", year())); PRINT(("year: %d\n", year()));
@@ -150,10 +150,10 @@ udf_timestamp::dump() const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_entity_id // entity_id
//---------------------------------------------------------------------- //----------------------------------------------------------------------
udf_entity_id::udf_entity_id(uint8 flags, char *identifier, char *identifier_suffix) entity_id::entity_id(uint8 flags, char *identifier, char *identifier_suffix)
: _flags(flags) : _flags(flags)
{ {
if (identifier) if (identifier)
@@ -167,19 +167,19 @@ udf_entity_id::udf_entity_id(uint8 flags, char *identifier, char *identifier_suf
} }
void void
udf_entity_id::dump() const entity_id::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_entity_id"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "entity_id");
PRINT(("flags: %d\n", flags())); PRINT(("flags: %d\n", flags()));
PRINT(("identifier: `%.23s'\n", identifier())); PRINT(("identifier: `%.23s'\n", identifier()));
PRINT(("identifier_suffix: `%s'\n", identifier_suffix())); PRINT(("identifier_suffix: `%s'\n", identifier_suffix()));
} }
bool bool
udf_entity_id::matches(const udf_entity_id &id) const entity_id::matches(const entity_id &id) const
{ {
bool result = true; bool result = true;
for (int i = 0; i < udf_entity_id::kIdentifierLength; i++) { for (int i = 0; i < entity_id::kIdentifierLength; i++) {
if (identifier()[i] != id.identifier()[i]) { if (identifier()[i] != id.identifier()[i]) {
result = false; result = false;
break; break;
@@ -189,29 +189,29 @@ udf_entity_id::matches(const udf_entity_id &id) const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_extent_address // extent_address
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_extent_address::dump() const extent_address::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_extent_address"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "extent_address");
PRINT(("length: %ld\n", length())); PRINT(("length: %ld\n", length()));
PRINT(("location: %ld\n", location())); PRINT(("location: %ld\n", location()));
} }
void void
udf_logical_block_address::dump() const logical_block_address::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_logical_block_address"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "logical_block_address");
PRINT(("block: %ld\n", block())); PRINT(("block: %ld\n", block()));
PRINT(("partition: %d\n", partition())); PRINT(("partition: %d\n", partition()));
} }
void void
udf_long_address::dump() const long_address::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_long_address"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "long_address");
PRINT(("length: %ld\n", length())); PRINT(("length: %ld\n", length()));
PRINT(("block: %ld\n", block())); PRINT(("block: %ld\n", block()));
PRINT(("partiton: %d\n", partition())); PRINT(("partiton: %d\n", partition()));
@@ -220,14 +220,14 @@ udf_long_address::dump() const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_tag // descriptor_tag
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_tag::dump() const descriptor_tag ::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_descriptor_tag"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "descriptor_tag");
PRINT(("id: %d (%s)\n", id(), udf_tag_id_to_string(udf_tag_id(id())))); PRINT(("id: %d (%s)\n", id(), tag_id_to_string(tag_id(id()))));
PRINT(("version: %d\n", version())); PRINT(("version: %d\n", version()));
PRINT(("checksum: %d\n", checksum())); PRINT(("checksum: %d\n", checksum()));
PRINT(("serial_number: %d\n", serial_number())); PRINT(("serial_number: %d\n", serial_number()));
@@ -243,9 +243,9 @@ udf_tag::dump() const
\todo Calc the CRC. \todo Calc the CRC.
*/ */
status_t status_t
udf_tag::init_check(uint32 diskBlock) descriptor_tag ::init_check(uint32 diskBlock)
{ {
DEBUG_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_HIGH_VOLUME, "udf_descriptor_tag"); DEBUG_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_HIGH_VOLUME, "descriptor_tag");
PRINT(("location (paramater) == %ld\n", diskBlock)); PRINT(("location (paramater) == %ld\n", diskBlock));
PRINT(("location (in structure) == %ld\n", location())); PRINT(("location (in structure) == %ld\n", location()));
status_t error = (diskBlock == location()) ? B_OK : B_NO_INIT; status_t error = (diskBlock == location()) ? B_OK : B_NO_INIT;
@@ -265,13 +265,13 @@ udf_tag::init_check(uint32 diskBlock)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_primary_descriptor // primary_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_primary_descriptor::dump() const primary_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_primary_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "primary_descriptor");
CS0String string; CS0String string;
@@ -309,13 +309,13 @@ udf_primary_descriptor::dump() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_anchor_volume_descriptor_pointer // anchor_volume_descriptor_pointer
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_anchor_descriptor::dump() const anchor_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_anchor_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "anchor_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("main_vds:\n")); PRINT(("main_vds:\n"));
@@ -326,13 +326,13 @@ udf_anchor_descriptor::dump() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_implementation_use_descriptor // implementation_use_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_implementation_use_descriptor::dump() const implementation_use_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_implementation_use_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "implementation_use_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("vds_number: %ld\n", vds_number())); PRINT(("vds_number: %ld\n", vds_number()));
@@ -343,15 +343,15 @@ udf_implementation_use_descriptor::dump() const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_partition_descriptor // partition_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const uint8 Udf::kMaxPartitionDescriptors = 2; const uint8 Udf::kMaxPartitionDescriptors = 2;
void void
udf_partition_descriptor::dump() const partition_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_partition_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "partition_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("vds_number: %ld\n", vds_number())); PRINT(("vds_number: %ld\n", vds_number()));
@@ -372,13 +372,13 @@ udf_partition_descriptor::dump() const
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_logical_descriptor // logical_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_logical_descriptor::dump() const logical_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_logical_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "logical_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("vds_number: %ld\n", vds_number())); PRINT(("vds_number: %ld\n", vds_number()));
@@ -418,7 +418,7 @@ udf_logical_descriptor::dump() const
case 2: { case 2: {
PRINT((" partition_number: %d\n", *reinterpret_cast<const uint16*>(&(maps[offset+38])))); PRINT((" partition_number: %d\n", *reinterpret_cast<const uint16*>(&(maps[offset+38]))));
PRINT((" entity_id:\n")); PRINT((" entity_id:\n"));
const udf_entity_id *id = reinterpret_cast<const udf_entity_id*>(&(maps[offset+4])); const entity_id *id = reinterpret_cast<const entity_id*>(&(maps[offset+4]));
if (id) // To kill warning when DEBUG==0 if (id) // To kill warning when DEBUG==0
PDUMP(id); PDUMP(id);
break; break;
@@ -430,8 +430,8 @@ udf_logical_descriptor::dump() const
} }
udf_logical_descriptor& logical_descriptor&
udf_logical_descriptor::operator=(const udf_logical_descriptor &rhs) logical_descriptor::operator=(const logical_descriptor &rhs)
{ {
_tag = rhs._tag; _tag = rhs._tag;
_vds_number = rhs._vds_number; _vds_number = rhs._vds_number;
@@ -459,13 +459,13 @@ udf_logical_descriptor::operator=(const udf_logical_descriptor &rhs)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_physical_partition_map // physical_partition_map
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_physical_partition_map::dump() physical_partition_map::dump()
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_physical_partition_map"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "physical_partition_map");
PRINT(("type: %d\n", type())); PRINT(("type: %d\n", type()));
PRINT(("length: %d\n", length())); PRINT(("length: %d\n", length()));
PRINT(("volume_sequence_number: %d\n", volume_sequence_number())); PRINT(("volume_sequence_number: %d\n", volume_sequence_number()));
@@ -473,13 +473,13 @@ udf_physical_partition_map::dump()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_sparable_partition_map // sparable_partition_map
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_sparable_partition_map::dump() sparable_partition_map::dump()
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_sparable_partition_map"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "sparable_partition_map");
PRINT(("type: %d\n", type())); PRINT(("type: %d\n", type()));
PRINT(("length: %d\n", length())); PRINT(("length: %d\n", length()));
PRINT(("partition_type_id:")); PRINT(("partition_type_id:"));
@@ -494,13 +494,13 @@ udf_sparable_partition_map::dump()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_unallocated_space_descriptor // unallocated_space_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_unallocated_space_descriptor::dump() const unallocated_space_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_unallocated_space_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "unallocated_space_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("vds_number: %ld\n", vds_number())); PRINT(("vds_number: %ld\n", vds_number()));
@@ -510,25 +510,25 @@ udf_unallocated_space_descriptor::dump() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_terminating_descriptor // terminating_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_terminating_descriptor::dump() const terminating_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_terminating_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "terminating_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// udf_file_set_descriptor // file_set_descriptor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void void
udf_file_set_descriptor::dump() const file_set_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "udf_file_set_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS | CF_DUMP, "file_set_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("recording_date_and_time:\n")); PRINT(("recording_date_and_time:\n"));
@@ -562,9 +562,9 @@ udf_file_set_descriptor::dump() const
} }
void void
udf_file_id_descriptor::dump() const file_id_descriptor::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS, "udf_file_id_descriptor"); DUMP_INIT(CF_PUBLIC | CF_VOLUME_OPS, "file_id_descriptor");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
PRINT(("version_number: %d\n", version_number())); PRINT(("version_number: %d\n", version_number()));
@@ -584,9 +584,9 @@ udf_file_id_descriptor::dump() const
} }
void void
udf_icb_entry_tag::dump() const icb_entry_tag::dump() const
{ {
DUMP_INIT(CF_PUBLIC, "udf_icb_entry_tag"); DUMP_INIT(CF_PUBLIC, "icb_entry_tag");
PRINT(("prior_entries: %ld\n", prior_recorded_number_of_direct_entries())); PRINT(("prior_entries: %ld\n", prior_recorded_number_of_direct_entries()));
PRINT(("strategy_type: %d\n", strategy_type())); PRINT(("strategy_type: %d\n", strategy_type()));
PRINT(("strategy_parameters:\n")); PRINT(("strategy_parameters:\n"));
@@ -604,7 +604,7 @@ udf_icb_entry_tag::dump() const
uint16 entry_count; uint16 entry_count;
uint8 reserved; uint8 reserved;
uint8 file_type; uint8 file_type;
udf_logical_block_address parent_icb_location; logical_block_address parent_icb_location;
union { union {
uint16 all_flags; uint16 all_flags;
struct { struct {
@@ -629,9 +629,9 @@ udf_icb_entry_tag::dump() const
} }
void void
udf_icb_header::dump() const icb_header::dump() const
{ {
DUMP_INIT(CF_PUBLIC | CF_DUMP, "udf_icb_header"); DUMP_INIT(CF_PUBLIC | CF_DUMP, "icb_header");
PRINT(("tag:\n")); PRINT(("tag:\n"));
DUMP(tag()); DUMP(tag());
src/add-ons/kernel/file_systems/udf/DiskStructures.h
+246 -246
View File
File diff suppressed because it is too large Load Diff
src/add-ons/kernel/file_systems/udf/Icb.cpp
+8 -2
View File
@@ -1,3 +1,9 @@
//----------------------------------------------------------------------
// This software is part of the OpenBeOS distribution and is covered
// by the OpenBeOS license.
//
// Copyright (c) 2003 Tyler Dauwalder, [email protected]
//---------------------------------------------------------------------
#include "Icb.h" #include "Icb.h"
#include "time.h" #include "time.h"
@@ -9,7 +15,7 @@
using namespace Udf; using namespace Udf;
Icb::Icb(Volume *volume, udf_long_address address) Icb::Icb(Volume *volume, long_address address)
: fVolume(volume) : fVolume(volume)
, fData(volume) , fData(volume)
, fInitStatus(B_NO_INIT) , fInitStatus(B_NO_INIT)
@@ -25,7 +31,7 @@ Icb::Icb(Volume *volume, udf_long_address address)
off_t block; off_t block;
error = fVolume->MapBlock(address, &block); error = fVolume->MapBlock(address, &block);
if (!error) { if (!error) {
udf_icb_header *header = reinterpret_cast<udf_icb_header*>(fData.SetTo(block)); icb_header *header = reinterpret_cast<icb_header*>(fData.SetTo(block));
PDUMP(header); PDUMP(header);
error = header->tag().init_check(address.block()); error = header->tag().init_check(address.block());
} }
src/add-ons/kernel/file_systems/udf/Icb.h
+11 -11
View File
@@ -31,7 +31,7 @@ class DirectoryIterator;
class Volume; class Volume;
/*! \brief Abstract interface to file entry structure members /*! \brief Abstract interface to file entry structure members
that are not commonly accessible through udf_file_icb_entry(). that are not commonly accessible through file_icb_entry().
This is necessary, since we can't use virtual functions in This is necessary, since we can't use virtual functions in
the disk structure structs themselves, since we generally the disk structure structs themselves, since we generally
@@ -62,7 +62,7 @@ private:
class Icb { class Icb {
public: public:
Icb(Volume *volume, udf_long_address address); Icb(Volume *volume, long_address address);
status_t InitCheck(); status_t InitCheck();
vnode_id Id() { return fId; } vnode_id Id() { return fId; }
@@ -94,18 +94,18 @@ public:
private: private:
Icb(); // unimplemented Icb(); // unimplemented
udf_tag& Tag() { return (reinterpret_cast<udf_icb_header*>(fData.Block()))->tag(); } descriptor_tag & Tag() { return (reinterpret_cast<icb_header*>(fData.Block()))->tag(); }
udf_icb_entry_tag& IcbTag() { return (reinterpret_cast<udf_icb_header*>(fData.Block()))->icb_tag(); } icb_entry_tag& IcbTag() { return (reinterpret_cast<icb_header*>(fData.Block()))->icb_tag(); }
AbstractFileEntry* AbstractEntry() { AbstractFileEntry* AbstractEntry() {
DEBUG_INIT(CF_PRIVATE | CF_HIGH_VOLUME, "Icb"); DEBUG_INIT(CF_PRIVATE | CF_HIGH_VOLUME, "Icb");
return (Tag().id() == TAGID_EXTENDED_FILE_ENTRY) return (Tag().id() == TAGID_EXTENDED_FILE_ENTRY)
// ? reinterpret_cast<udf_extended_file_icb_entry*>(fData.Block()) // ? reinterpret_cast<extended_file_icb_entry*>(fData.Block())
// : reinterpret_cast<udf_file_icb_entry*>(fData.Block())); // : reinterpret_cast<file_icb_entry*>(fData.Block()));
? &fExtendedEntry ? &fExtendedEntry
: &fFileEntry; : &fFileEntry;
} }
udf_file_icb_entry* FileEntry() { return (reinterpret_cast<udf_file_icb_entry*>(fData.Block())); } file_icb_entry* FileEntry() { return (reinterpret_cast<file_icb_entry*>(fData.Block())); }
udf_extended_file_icb_entry& ExtendedEntry() { return *(reinterpret_cast<udf_extended_file_icb_entry*>(fData.Block())); } extended_file_icb_entry& ExtendedEntry() { return *(reinterpret_cast<extended_file_icb_entry*>(fData.Block())); }
template <class DescriptorList> template <class DescriptorList>
status_t _Read(DescriptorList &list, off_t pos, void *buffer, size_t *length, uint32 *block); status_t _Read(DescriptorList &list, off_t pos, void *buffer, size_t *length, uint32 *block);
@@ -117,8 +117,8 @@ private:
status_t fInitStatus; status_t fInitStatus;
vnode_id fId; vnode_id fId;
SinglyLinkedList<DirectoryIterator*> fIteratorList; SinglyLinkedList<DirectoryIterator*> fIteratorList;
FileEntry<udf_file_icb_entry> fFileEntry; FileEntry<file_icb_entry> fFileEntry;
FileEntry<udf_extended_file_icb_entry> fExtendedEntry; FileEntry<extended_file_icb_entry> fExtendedEntry;
}; };
/*! \brief Does the dirty work of reading using the given DescriptorList object /*! \brief Does the dirty work of reading using the given DescriptorList object
@@ -147,7 +147,7 @@ Icb::_Read(DescriptorList &list, off_t pos, void *_buffer, size_t *length, uint3
PRINT(("pos: %Ld\n", pos)); PRINT(("pos: %Ld\n", pos));
PRINT(("bytesLeft: %ld\n", bytesLeft)); PRINT(("bytesLeft: %ld\n", bytesLeft));
udf_long_address extent; long_address extent;
bool isEmpty = false; bool isEmpty = false;
error = list.FindExtent(pos, &extent, &isEmpty); error = list.FindExtent(pos, &extent, &isEmpty);
if (!error) { if (!error) {
src/add-ons/kernel/file_systems/udf/Recognition.cpp
+26 -26
View File
@@ -16,14 +16,14 @@ walk_volume_recognition_sequence(int device, off_t offset,
static status_t static status_t
walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length, walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
uint32 blockSize, uint32 blockShift, uint32 blockSize, uint32 blockShift,
udf_logical_descriptor &logicalVolumeDescriptor, logical_descriptor &logicalVolumeDescriptor,
udf_partition_descriptor partitionDescriptors[], partition_descriptor partitionDescriptors[],
uint8 &partitionDescriptorCount); uint8 &partitionDescriptorCount);
static status_t static status_t
walk_volume_descriptor_sequence(udf_extent_address descriptorSequence, walk_volume_descriptor_sequence(extent_address descriptorSequence,
int device, uint32 blockSize, uint32 blockShift, int device, uint32 blockSize, uint32 blockShift,
udf_logical_descriptor &logicalVolumeDescriptor, logical_descriptor &logicalVolumeDescriptor,
udf_partition_descriptor partitionDescriptors[], partition_descriptor partitionDescriptors[],
uint8 &partitionDescriptorCount); uint8 &partitionDescriptorCount);
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@@ -32,8 +32,8 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
status_t status_t
Udf::udf_recognize(int device, off_t offset, off_t length, uint32 blockSize, Udf::udf_recognize(int device, off_t offset, off_t length, uint32 blockSize,
uint32 &blockShift, udf_logical_descriptor &logicalVolumeDescriptor, uint32 &blockShift, logical_descriptor &logicalVolumeDescriptor,
udf_partition_descriptor partitionDescriptors[], partition_descriptor partitionDescriptors[],
uint8 &partitionDescriptorCount) uint8 &partitionDescriptorCount)
{ {
DEBUG_INIT_ETC(CF_PRIVATE, NULL, ("device: %d, offset: %Ld, length: %Ld, " DEBUG_INIT_ETC(CF_PRIVATE, NULL, ("device: %d, offset: %Ld, length: %Ld, "
@@ -78,8 +78,8 @@ Udf::udf_recognize(int device, off_t offset, off_t length, uint32 blockSize,
DEBUG_INIT_ETC(CF_PRIVATE, NULL, ("device: %d, offset: %Ld, length: %Ld, " DEBUG_INIT_ETC(CF_PRIVATE, NULL, ("device: %d, offset: %Ld, length: %Ld, "
"blockSize: %ld, volumeName: %p", device, offset, length, "blockSize: %ld, volumeName: %p", device, offset, length,
blockSize, volumeName)); blockSize, volumeName));
udf_logical_descriptor logicalVolumeDescriptor; logical_descriptor logicalVolumeDescriptor;
udf_partition_descriptor partitionDescriptors[Udf::kMaxPartitionDescriptors]; partition_descriptor partitionDescriptors[Udf::kMaxPartitionDescriptors];
uint8 partitionDescriptorCount; uint8 partitionDescriptorCount;
uint32 blockShift; uint32 blockShift;
status_t error = udf_recognize(device, offset, length, blockSize, blockShift, status_t error = udf_recognize(device, offset, length, blockSize, blockShift,
@@ -118,8 +118,8 @@ walk_volume_recognition_sequence(int device, off_t offset, uint32 blockSize, uin
ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize); ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);
if (bytesRead == (ssize_t)blockSize) if (bytesRead == (ssize_t)blockSize)
{ {
udf_volume_structure_descriptor_header* descriptor = volume_structure_descriptor_header* descriptor =
reinterpret_cast<udf_volume_structure_descriptor_header*>(chunk.Data()); reinterpret_cast<volume_structure_descriptor_header*>(chunk.Data());
if (descriptor->id_matches(kVSDID_ISO)) { if (descriptor->id_matches(kVSDID_ISO)) {
SIMPLE_PRINT(("found ISO9660 descriptor\n")); SIMPLE_PRINT(("found ISO9660 descriptor\n"));
foundISO = true; foundISO = true;
@@ -166,8 +166,8 @@ static
status_t status_t
walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length, walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
uint32 blockSize, uint32 blockShift, uint32 blockSize, uint32 blockShift,
udf_logical_descriptor &logicalVolumeDescriptor, logical_descriptor &logicalVolumeDescriptor,
udf_partition_descriptor partitionDescriptors[], partition_descriptor partitionDescriptors[],
uint8 &partitionDescriptorCount) uint8 &partitionDescriptorCount)
{ {
DEBUG_INIT(CF_PRIVATE, NULL); DEBUG_INIT(CF_PRIVATE, NULL);
@@ -183,7 +183,7 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
off_t block = avds_locations[i]; off_t block = avds_locations[i];
off_t address = (offset + block) << blockShift; off_t address = (offset + block) << blockShift;
MemoryChunk chunk(blockSize); MemoryChunk chunk(blockSize);
udf_anchor_descriptor *anchor = NULL; anchor_descriptor *anchor = NULL;
status_t anchorErr = chunk.InitCheck(); status_t anchorErr = chunk.InitCheck();
if (!anchorErr) { if (!anchorErr) {
@@ -195,7 +195,7 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
} }
} }
if (!anchorErr) { if (!anchorErr) {
anchor = reinterpret_cast<udf_anchor_descriptor*>(chunk.Data()); anchor = reinterpret_cast<anchor_descriptor*>(chunk.Data());
anchorErr = anchor->tag().init_check(block+offset); anchorErr = anchor->tag().init_check(block+offset);
if (anchorErr) { if (anchorErr) {
PRINT(("block %Ld: invalid anchor\n", block)); PRINT(("block %Ld: invalid anchor\n", block));
@@ -235,10 +235,10 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
static static
status_t status_t
walk_volume_descriptor_sequence(udf_extent_address descriptorSequence, walk_volume_descriptor_sequence(extent_address descriptorSequence,
int device, uint32 blockSize, uint32 blockShift, int device, uint32 blockSize, uint32 blockShift,
udf_logical_descriptor &logicalVolumeDescriptor, logical_descriptor &logicalVolumeDescriptor,
udf_partition_descriptor partitionDescriptors[], partition_descriptor partitionDescriptors[],
uint8 &partitionDescriptorCount) uint8 &partitionDescriptorCount)
{ {
DEBUG_INIT_ETC(CF_PRIVATE, NULL, ("descriptorSequence.loc:%ld, descriptorSequence.len:%ld", DEBUG_INIT_ETC(CF_PRIVATE, NULL, ("descriptorSequence.loc:%ld, descriptorSequence.len:%ld",
@@ -254,7 +254,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
off_t block = descriptorSequence.location()+i; off_t block = descriptorSequence.location()+i;
off_t address = block << blockShift; off_t address = block << blockShift;
MemoryChunk chunk(blockSize); MemoryChunk chunk(blockSize);
udf_tag *tag = NULL; descriptor_tag *tag = NULL;
PRINT(("descriptor #%ld (block %Ld):\n", i, block)); PRINT(("descriptor #%ld (block %Ld):\n", i, block));
@@ -268,7 +268,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
} }
} }
if (!loopErr) { if (!loopErr) {
tag = reinterpret_cast<udf_tag*>(chunk.Data()); tag = reinterpret_cast<descriptor_tag *>(chunk.Data());
loopErr = tag->init_check(block); loopErr = tag->init_check(block);
} }
if (!loopErr) { if (!loopErr) {
@@ -279,7 +279,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
case TAGID_PRIMARY_VOLUME_DESCRIPTOR: case TAGID_PRIMARY_VOLUME_DESCRIPTOR:
{ {
udf_primary_descriptor *primary = reinterpret_cast<udf_primary_descriptor*>(tag); primary_descriptor *primary = reinterpret_cast<primary_descriptor*>(tag);
PDUMP(primary); PDUMP(primary);
(void)primary; // kill the warning (void)primary; // kill the warning
break; break;
@@ -293,7 +293,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
case TAGID_IMPLEMENTATION_USE_VOLUME_DESCRIPTOR: case TAGID_IMPLEMENTATION_USE_VOLUME_DESCRIPTOR:
{ {
udf_implementation_use_descriptor *imp_use = reinterpret_cast<udf_implementation_use_descriptor*>(tag); implementation_use_descriptor *imp_use = reinterpret_cast<implementation_use_descriptor*>(tag);
PDUMP(imp_use); PDUMP(imp_use);
(void)imp_use; // kill the warning (void)imp_use; // kill the warning
break; break;
@@ -301,7 +301,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
case TAGID_PARTITION_DESCRIPTOR: case TAGID_PARTITION_DESCRIPTOR:
{ {
udf_partition_descriptor *partition = reinterpret_cast<udf_partition_descriptor*>(tag); partition_descriptor *partition = reinterpret_cast<partition_descriptor*>(tag);
PDUMP(partition); PDUMP(partition);
if (partition->tag().init_check(block) == B_OK) { if (partition->tag().init_check(block) == B_OK) {
// Check for a previously discovered partition descriptor with // Check for a previously discovered partition descriptor with
@@ -376,7 +376,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
case TAGID_LOGICAL_VOLUME_DESCRIPTOR: case TAGID_LOGICAL_VOLUME_DESCRIPTOR:
{ {
udf_logical_descriptor *logical = reinterpret_cast<udf_logical_descriptor*>(tag); logical_descriptor *logical = reinterpret_cast<logical_descriptor*>(tag);
PDUMP(logical); PDUMP(logical);
if (foundLogicalVolumeDescriptor) { if (foundLogicalVolumeDescriptor) {
// Keep the vd with the highest vds_number // Keep the vd with the highest vds_number
@@ -392,7 +392,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
case TAGID_UNALLOCATED_SPACE_DESCRIPTOR: case TAGID_UNALLOCATED_SPACE_DESCRIPTOR:
{ {
udf_unallocated_space_descriptor *unallocated = reinterpret_cast<udf_unallocated_space_descriptor*>(tag); unallocated_space_descriptor *unallocated = reinterpret_cast<unallocated_space_descriptor*>(tag);
PDUMP(unallocated); PDUMP(unallocated);
(void)unallocated; // kill the warning (void)unallocated; // kill the warning
break; break;
@@ -400,7 +400,7 @@ walk_volume_descriptor_sequence(udf_extent_address descriptorSequence,
case TAGID_TERMINATING_DESCRIPTOR: case TAGID_TERMINATING_DESCRIPTOR:
{ {
udf_terminating_descriptor *terminating = reinterpret_cast<udf_terminating_descriptor*>(tag); terminating_descriptor *terminating = reinterpret_cast<terminating_descriptor*>(tag);
PDUMP(terminating); PDUMP(terminating);
(void)terminating; // kill the warning (void)terminating; // kill the warning
break; break;
src/add-ons/kernel/file_systems/udf/Recognition.h
+2 -2
View File
@@ -17,8 +17,8 @@ namespace Udf {
status_t udf_recognize(int device, off_t offset, off_t length, status_t udf_recognize(int device, off_t offset, off_t length,
uint32 blockSize, uint32 &blockShift, uint32 blockSize, uint32 &blockShift,
udf_logical_descriptor &logicalVolumeDescriptor, logical_descriptor &logicalVolumeDescriptor,
udf_partition_descriptor partitionDescriptors[], partition_descriptor partitionDescriptors[],
uint8 &partitionDescriptorCount); uint8 &partitionDescriptorCount);
status_t udf_recognize(int device, off_t offset, off_t length, status_t udf_recognize(int device, off_t offset, off_t length,
uint32 blockSize, char *volumeName); uint32 blockSize, char *volumeName);
src/add-ons/kernel/file_systems/udf/Utils.cpp
+4 -4
View File
@@ -23,11 +23,11 @@ extern "C" {
namespace Udf { namespace Udf {
udf_long_address long_address
to_long_address(vnode_id id, uint32 length) to_long_address(vnode_id id, uint32 length)
{ {
DEBUG_INIT_ETC(CF_PUBLIC | CF_HELPER, NULL, ("vnode_id: %Ld (0x%Lx), length: %ld", id, id, length)); DEBUG_INIT_ETC(CF_PUBLIC | CF_HELPER, NULL, ("vnode_id: %Ld (0x%Lx), length: %ld", id, id, length));
udf_long_address result; long_address result;
result.set_block((id >> 16) & 0xffffffff); result.set_block((id >> 16) & 0xffffffff);
result.set_partition(id & 0xffff); result.set_partition(id & 0xffff);
result.set_length(length); result.set_length(length);
@@ -36,7 +36,7 @@ to_long_address(vnode_id id, uint32 length)
} }
vnode_id vnode_id
to_vnode_id(udf_long_address address) to_vnode_id(long_address address)
{ {
DEBUG_INIT(CF_PUBLIC | CF_HELPER, NULL); DEBUG_INIT(CF_PUBLIC | CF_HELPER, NULL);
vnode_id result = address.block(); vnode_id result = address.block();
@@ -50,7 +50,7 @@ to_vnode_id(udf_long_address address)
} }
time_t time_t
make_time(udf_timestamp &timestamp) make_time(timestamp &timestamp)
{ {
DEBUG_INIT_ETC(CF_HELPER | CF_HIGH_VOLUME, NULL, ("timestamp: (tnt: 0x%x, type: %d, timezone: %d = 0x%x, year: %d, " DEBUG_INIT_ETC(CF_HELPER | CF_HIGH_VOLUME, NULL, ("timestamp: (tnt: 0x%x, type: %d, timezone: %d = 0x%x, year: %d, "
"month: %d, day: %d, hour: %d, minute: %d, second: %d)", timestamp.type_and_timezone(), "month: %d, day: %d, hour: %d, minute: %d, second: %d)", timestamp.type_and_timezone(),
src/add-ons/kernel/file_systems/udf/Utils.h
+3 -3
View File
@@ -24,11 +24,11 @@ extern "C" {
namespace Udf { namespace Udf {
udf_long_address to_long_address(vnode_id id, uint32 length = 0); long_address to_long_address(vnode_id id, uint32 length = 0);
vnode_id to_vnode_id(udf_long_address address); vnode_id to_vnode_id(long_address address);
time_t make_time(udf_timestamp &timestamp); time_t make_time(timestamp &timestamp);
} // namespace Udf } // namespace Udf
src/add-ons/kernel/file_systems/udf/Volume.cpp
+23 -20
View File
@@ -72,11 +72,13 @@ Volume::Mount(const char *deviceName, off_t offset, off_t length,
} }
} }
udf_logical_descriptor logicalVolumeDescriptor; logical_descriptor logicalVolumeDescriptor;
udf_partition_descriptor partitionDescriptors[Udf::kMaxPartitionDescriptors]; partition_descriptor partitionDescriptors[Udf::kMaxPartitionDescriptors];
uint8 partitionDescriptorCount; uint8 partitionDescriptorCount;
uint32 blockShift; uint32 blockShift;
// Run through the volume recognition and descriptor sequences to
// see if we have a potentially valid UDF volume on our hands
error = udf_recognize(device, offset, length, blockSize, blockShift, error = udf_recognize(device, offset, length, blockSize, blockShift,
logicalVolumeDescriptor, partitionDescriptors, logicalVolumeDescriptor, partitionDescriptors,
partitionDescriptorCount); partitionDescriptorCount);
@@ -98,15 +100,15 @@ Volume::Mount(const char *deviceName, off_t offset, off_t length,
&& !error; i++) && !error; i++)
{ {
uint8 *maps = logicalVolumeDescriptor.partition_maps(); uint8 *maps = logicalVolumeDescriptor.partition_maps();
udf_partition_map_header *header = partition_map_header *header =
reinterpret_cast<udf_partition_map_header*>(maps+offset); reinterpret_cast<partition_map_header*>(maps+offset);
PRINT(("partition map %d (type %d):\n", i, header->type())); PRINT(("partition map %d (type %d):\n", i, header->type()));
if (header->type() == 1) { if (header->type() == 1) {
PRINT(("map type: physical\n")); PRINT(("map type: physical\n"));
udf_physical_partition_map* map = physical_partition_map* map =
reinterpret_cast<udf_physical_partition_map*>(header); reinterpret_cast<physical_partition_map*>(header);
// Find the corresponding partition descriptor // Find the corresponding partition descriptor
udf_partition_descriptor *descriptor = NULL; partition_descriptor *descriptor = NULL;
for (uint8 j = 0; j < partitionDescriptorCount; j++) { for (uint8 j = 0; j < partitionDescriptorCount; j++) {
if (map->partition_number() == if (map->partition_number() ==
partitionDescriptors[j].partition_number()) partitionDescriptors[j].partition_number())
@@ -135,27 +137,27 @@ Volume::Mount(const char *deviceName, off_t offset, off_t length,
error = B_ERROR; error = B_ERROR;
} }
} else if (header->type() == 2) { } else if (header->type() == 2) {
// Figure out what kind of partition map we have based // Figure out what kind of type 2 partition map we have based
// on the type identifier // on the type identifier
const udf_entity_id &typeId = header->partition_type_id(); const entity_id &typeId = header->partition_type_id();
DUMP(typeId); DUMP(typeId);
DUMP(kSparablePartitionMapId); DUMP(kSparablePartitionMapId);
if (typeId.matches(kVirtualPartitionMapId)) { if (typeId.matches(kVirtualPartitionMapId)) {
PRINT(("map type: virtual\n")); PRINT(("map type: virtual\n"));
udf_virtual_partition_map* map = virtual_partition_map* map =
reinterpret_cast<udf_virtual_partition_map*>(header); reinterpret_cast<virtual_partition_map*>(header);
virtualCount++; virtualCount++;
(void)map; // kill the warning for now (void)map; // kill the warning for now
} else if (typeId.matches(kSparablePartitionMapId)) { } else if (typeId.matches(kSparablePartitionMapId)) {
PRINT(("map type: sparable\n")); PRINT(("map type: sparable\n"));
udf_sparable_partition_map* map = sparable_partition_map* map =
reinterpret_cast<udf_sparable_partition_map*>(header); reinterpret_cast<sparable_partition_map*>(header);
sparableCount++; sparableCount++;
(void)map; // kill the warning for now (void)map; // kill the warning for now
} else if (typeId.matches(kMetadataPartitionMapId)) { } else if (typeId.matches(kMetadataPartitionMapId)) {
PRINT(("map type: metadata\n")); PRINT(("map type: metadata\n"));
udf_metadata_partition_map* map = metadata_partition_map* map =
reinterpret_cast<udf_metadata_partition_map*>(header); reinterpret_cast<metadata_partition_map*>(header);
metadataCount++; metadataCount++;
(void)map; // kill the warning for now (void)map; // kill the warning for now
} else { } else {
@@ -224,8 +226,8 @@ Volume::Mount(const char *deviceName, off_t offset, off_t length,
} }
// See if it's valid, and if so, create the root icb // See if it's valid, and if so, create the root icb
if (!error) { if (!error) {
udf_file_set_descriptor *fileSet = file_set_descriptor *fileSet =
reinterpret_cast<udf_file_set_descriptor*>(chunk.Data()); reinterpret_cast<file_set_descriptor*>(chunk.Data());
fileSet->tag().init_check(0); fileSet->tag().init_check(0);
PDUMP(fileSet); PDUMP(fileSet);
fRootIcb = new Icb(this, fileSet->root_directory_icb()); fRootIcb = new Icb(this, fileSet->root_directory_icb());
@@ -267,10 +269,11 @@ Volume::Name() const {
/*! \brief Maps the given logical block to a physical block. /*! \brief Maps the given logical block to a physical block.
*/ */
status_t status_t
Volume::MapBlock(udf_long_address address, off_t *mappedBlock) Volume::MapBlock(long_address address, off_t *mappedBlock)
{ {
DEBUG_INIT_ETC(CF_PRIVATE | CF_HIGH_VOLUME, "Volume", ("long_address(block: %ld, partition: %d), %p", DEBUG_INIT_ETC(CF_PRIVATE | CF_HIGH_VOLUME, "Volume",
address.block(), address.partition(), mappedBlock)); ("partition: %d, block: %ld, mappedBlock: %p",
address.partition(), address.block(), mappedBlock));
status_t error = mappedBlock ? B_OK : B_BAD_VALUE; status_t error = mappedBlock ? B_OK : B_BAD_VALUE;
if (!error) { if (!error) {
Partition *partition = _GetPartition(address.partition()); Partition *partition = _GetPartition(address.partition());
src/add-ons/kernel/file_systems/udf/Volume.h
+3 -3
View File
@@ -44,8 +44,8 @@ public:
status_t Unmount(); status_t Unmount();
// Address mapping // Address mapping
status_t MapBlock(udf_long_address address, off_t *mappedBlock); status_t MapBlock(long_address address, off_t *mappedBlock);
status_t MapExtent(udf_long_address logicalExtent, udf_extent_address &physicalExtent); status_t MapExtent(long_address logicalExtent, extent_address &physicalExtent);
// Miscellaneous info // Miscellaneous info
const char *Name() const; const char *Name() const;
@@ -77,7 +77,7 @@ private:
uint32 fBlockSize; uint32 fBlockSize;
uint32 fBlockShift; uint32 fBlockShift;
Partition *fPartitions[UDF_MAX_PARTITION_MAPS]; Partition *fPartitions[UDF_MAX_PARTITION_MAPS];
Icb *fRootIcb; // Destroyed by vfs via callback to udf_release_node() Icb *fRootIcb; // Destroyed by vfs via callback to release_node()
CS0String fName; CS0String fName;
}; };
src/add-ons/kernel/file_systems/udf/udf.cpp
+2 -1
View File
@@ -487,7 +487,8 @@ udf_walk(void *ns, void *_dir, const char *filename, char **resolvedPath, vnode_
int int
udf_ioctl(void *ns, void *node, void *cookie, int cmd, void *buffer, size_t bufferLength) udf_ioctl(void *ns, void *node, void *cookie, int cmd, void *buffer, size_t bufferLength)
{ {
DEBUG_INIT(CF_ENTRY | CF_VOLUME_OPS, NULL); DEBUG_INIT_ETC(CF_ENTRY | CF_VOLUME_OPS, NULL, ("node: %p, cmd: 0x%x, "
"buf: %p, len: %ld\n", node, cmd, buffer, bufferLength));
// FUNCTION_START(("node: %p, cmd: %d, buf: %p, len: %ld\n", node, cmd, buffer, bufferLength)); // FUNCTION_START(("node: %p, cmd: %d, buf: %p, len: %ld\n", node, cmd, buffer, bufferLength));
RETURN(B_ERROR); RETURN(B_ERROR);
} }