allocsup.c File Reference

#include "UdfProcs.h"

Go to the source code of this file.

Defines
#define	BugCheckFileId   (UDFS_BUG_CHECK_ALLOCSUP)
#define	Dbg   (UDFS_DEBUG_LEVEL_ALLOCSUP)
Functions
PPCB	UdfCreatePcb (IN ULONG NumberOfPartitions)
NTSTATUS	UdfLoadSparingTables (PIRP_CONTEXT IrpContext, PVCB Vcb, PPCB Pcb, ULONG Reference)
BOOLEAN	UdfLookupAllocation (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN LONGLONG FileOffset, OUT PLONGLONG DiskOffset, OUT PULONG ByteCount)
VOID	UdfDeletePcb (IN PPCB Pcb)
NTSTATUS	UdfInitializePcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN OUT PPCB *Pcb, IN PNSR_LVOL LVD)
VOID	UdfAddToPcb (IN PPCB Pcb, IN PNSR_PART PartitionDescriptor)
NTSTATUS	UdfCompletePcb (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PPCB Pcb)
BOOLEAN	UdfEquivalentPcb (IN PIRP_CONTEXT IrpContext, IN PPCB Pcb1, IN PPCB Pcb2)
ULONG	UdfLookupPsnOfExtent (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN USHORT Reference, IN ULONG Lbn, IN ULONG Len)
ULONG	UdfLookupMetaVsnOfExtent (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN USHORT Reference, IN ULONG Lbn, IN ULONG Len, IN BOOLEAN ExactEnd)

---

Define Documentation

#define BugCheckFileId   (UDFS_BUG_CHECK_ALLOCSUP)

Definition at line 29 of file allocsup.c.

#define Dbg   (UDFS_DEBUG_LEVEL_ALLOCSUP)

Definition at line 35 of file allocsup.c.

---

Function Documentation

VOID UdfAddToPcb (  IN PPCB  Pcb, IN PNSR_PART  PartitionDescriptor )

Definition at line 724 of file allocsup.c. References ASSERT, ASSERT_PCB, Dbg, DebugTrace, FALSE, PAGED_CODE, Physical, PNSR_PART, PNSR_VD_GENERIC, UdfStoreVolumeDescriptorIfPrevailing(), USHORT, and Virtual. Referenced by UdfFindVolumeDescriptors(). : This routine possibly adds a partition descriptor into a Pcb if it turns out to be of higher precendence than a descriptor already present. Used in building a Pcb already initialized in preperation for UdfCompletePcb. Arguments: Vcb - Vcb of the volume the Pcb describes Pcb - Pcb being filled in Return Value: None. An old partition descriptor may be returned in the input field. --*/ { USHORT Reference; PAGED_CODE(); // // Check inputs // ASSERT_PCB( Pcb ); ASSERT( PartitionDescriptor ); for (Reference = 0; Reference < Pcb->Partitions; Reference++) { DebugTrace(( 0, Dbg, "UdfAddToPcb, considering partition reference %d (type %d)\n", (ULONG)Reference, Pcb->Partition[Reference].Type)); switch (Pcb->Partition[Reference].Type) { case Physical: // // Now possibly store this descriptor in the Pcb if it is // the partition number for this partition reference. // if (Pcb->Partition[Reference].Physical.PartitionNumber == PartitionDescriptor->Number) { // // It seems to be legal (if questionable) for multiple partition maps to reference // the same partition descriptor. So we make a copy of the descriptor for each // referencing partitionmap to make life easier when it comes to freeing it. // UdfStoreVolumeDescriptorIfPrevailing( (PNSR_VD_GENERIC *) &Pcb->Partition[Reference].Physical.PartitionDescriptor, (PNSR_VD_GENERIC) PartitionDescriptor ); } break; case Virtual: break; default: ASSERT(FALSE); break; } } }

NTSTATUS UdfCompletePcb (  IN PIRP_CONTEXT  IrpContext, IN PVCB  Vcb, IN PPCB  Pcb )

Definition at line 804 of file allocsup.c. References ASSERT, ASSERT_IRP_CONTEXT, ASSERT_PCB, ASSERT_VCB, Dbg, DebugTrace, FALSE, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, Physical, Status, UdfFreePool(), UdfLoadSparingTables(), and Virtual. Referenced by UdfMountVolume(), and UdfVerifyVolume(). : This routine completes initialization of a Pcb which has been filled in with partition descriptors. Initialization-time data such as the physical partition descriptors will be returned to the system. Arguments: Vcb - Vcb of the volume the Pcb describes Pcb - Pcb being completed Return Value: NTSTATUS according to whether intialization completion was succesful --*/ { ULONG Reference; NTSTATUS Status; PAGED_CODE(); // // Check inputs // ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_VCB( Vcb ); ASSERT_PCB( Pcb ); DebugTrace(( +1, Dbg, "UdfCompletePcb, Vcb %08x Pcb %08x\n", Vcb, Pcb )); // // Complete intialization all physical partitions // for (Reference = 0; Reference < Pcb->Partitions; Reference++) { DebugTrace(( 0, Dbg, "UdfCompletePcb, Examining Ref %u (type %u)!\n", Reference, Pcb->Partition[Reference].Type)); switch (Pcb->Partition[Reference].Type) { case Physical: if (Pcb->Partition[Reference].Physical.PartitionDescriptor == NULL) { DebugTrace(( 0, Dbg, "UdfCompletePcb, ... but didn't find Partition# %u!\n", Pcb->Partition[Reference].Physical.PartitionNumber )); DebugTrace(( -1, Dbg, "UdfCompletePcb -> STATUS_DISK_CORRUPT_ERROR\n" )); return STATUS_DISK_CORRUPT_ERROR; } Pcb->Partition[Reference].Physical.Start = Pcb->Partition[Reference].Physical.PartitionDescriptor->Start; Pcb->Partition[Reference].Physical.Length = Pcb->Partition[Reference].Physical.PartitionDescriptor->Length; // // Retrieve the sparing information at this point if appropriate. // We have to do this when we can map logical -> physical blocks. // if (Pcb->Partition[Reference].Physical.SparingMap) { Status = UdfLoadSparingTables( IrpContext, Vcb, Pcb, Reference ); if (!NT_SUCCESS( Status )) { DebugTrace(( -1, Dbg, "UdfCompletePcb -> %08x\n", Status )); return Status; } } // // We will not need the descriptor or sparing map anymore, so drop them. // UdfFreePool( &Pcb->Partition[Reference].Physical.PartitionDescriptor ); UdfFreePool( &Pcb->Partition[Reference].Physical.SparingMap ); break; case Virtual: break; default: ASSERT(FALSE); break; } } DebugTrace(( -1, Dbg, "UdfCompletePcb -> STATUS_SUCCESS\n" )); return STATUS_SUCCESS; }

PPCB UdfCreatePcb (  IN ULONG  NumberOfPartitions  )

Definition at line 1357 of file allocsup.c. References ASSERT, FsRtlAllocatePoolWithTag, _PCB::NodeByteSize, _PCB::NodeTypeCode, PAGED_CODE, _PCB::Partitions, PCB, Size, TAG_PCB, UdfPagedPool, UDFS_NTC_PCB, and USHORT. Referenced by UdfInitializePcb(). : This routine creates a new Pcb of the indicated size. Arguments: NumberOfPartitions - Number of partitions this Pcb will describe Return Value: PPCB - the Pcb created --*/ { PPCB Pcb; ULONG Size = sizeof(PCB) + sizeof(PARTITION)*NumberOfPartitions; PAGED_CODE(); ASSERT( NumberOfPartitions ); ASSERT( NumberOfPartitions < MAXUSHORT ); Pcb = (PPCB) FsRtlAllocatePoolWithTag( UdfPagedPool, Size, TAG_PCB ); RtlZeroMemory( Pcb, Size ); Pcb->NodeTypeCode = UDFS_NTC_PCB; Pcb->NodeByteSize = (USHORT) Size; Pcb->Partitions = (USHORT)NumberOfPartitions; return Pcb; }

VOID UdfDeletePcb (  IN PPCB  Pcb  )

Definition at line 309 of file allocsup.c. References ASSERT, ExFreePool(), FALSE, FsRtlUninitializeLargeMcb(), Physical, PPARTITION, UdfFreePool(), Uninitialized, and Virtual. Referenced by UdfDeleteVcb(), UdfInitializePcb(), UdfMountVolume(), and UdfVerifyVolume(). : This routine deallocates a Pcb and all ancilliary structures. Arguments: Pcb - Pcb being deleted Return Value: None --*/ { PPARTITION Partition; if (Pcb->SparingMcb) { FsRtlUninitializeLargeMcb( Pcb->SparingMcb ); UdfFreePool( &Pcb->SparingMcb ); } for (Partition = Pcb->Partition; Partition < &Pcb->Partition[Pcb->Partitions]; Partition++) { switch (Partition->Type) { case Physical: UdfFreePool( &Partition->Physical.PartitionDescriptor ); UdfFreePool( &Partition->Physical.SparingMap ); break; case Virtual: case Uninitialized: break; default: ASSERT( FALSE ); break; } } ExFreePool( Pcb ); }

BOOLEAN UdfEquivalentPcb (  IN PIRP_CONTEXT  IrpContext, IN PPCB  Pcb1, IN PPCB  Pcb2 )

Definition at line 923 of file allocsup.c. References ASSERT, ASSERT_IRP_CONTEXT, FALSE, Index, PAGED_CODE, Physical, TRUE, and Virtual. Referenced by UdfVerifyVolume(). : This routine compares two completed Pcbs to see if they appear equivalent. Arguments: Pcb1 - Pcb being compared Pcb2 - Pcb being compared Return Value: BOOLEAN according to whether they are equivalent (TRUE, else FALSE) --*/ { ULONG Index; PAGED_CODE(); // // Check input. // ASSERT_IRP_CONTEXT( IrpContext ); if (Pcb1->Partitions != Pcb2->Partitions) { return FALSE; } for (Index = 0; Index < Pcb1->Partitions; Index++) { // // First check that the partitions are of the same type. // if (Pcb1->Partition[Index].Type != Pcb2->Partition[Index].Type) { return FALSE; } // // Now the map content must be the same ... // switch (Pcb1->Partition[Index].Type) { case Physical: if (Pcb1->Partition[Index].Physical.PartitionNumber != Pcb2->Partition[Index].Physical.PartitionNumber || Pcb1->Partition[Index].Physical.Length != Pcb2->Partition[Index].Physical.Length || Pcb1->Partition[Index].Physical.Start != Pcb2->Partition[Index].Physical.Start) { return FALSE; } break; case Virtual: if (Pcb1->Partition[Index].Virtual.RelatedReference != Pcb2->Partition[Index].Virtual.RelatedReference) { return FALSE; } break; default: ASSERT( FALSE); return FALSE; break; } } // // All map elements were equivalent. // return TRUE; }

NTSTATUS UdfInitializePcb (  IN PIRP_CONTEXT  IrpContext, IN PVCB  Vcb, IN OUT PPCB *  Pcb, IN PNSR_LVOL  LVD )

Definition at line 367 of file allocsup.c. References Add2Ptr, ASSERT_OPTIONAL_PCB, Dbg, DebugTrace, FALSE, FlagOn, FsRtlAllocatePoolWithTag, ISONsrLvolSize, _PARTMAP_UDF_GENERIC::Length, NTSTATUS(), NULL, PAGED_CODE, PagedPool, _PARTMAP_UDF_GENERIC::PartID, PARTITION, PARTMAP_PHYSICAL::Partition, _PARTMAP_VIRTUAL::Partition, _PARTMAP_SPARABLE::Partition, _tagPARTITION::PartitionNumber, PARTMAP_SPARABLE, PARTMAP_TYPE_PHYSICAL, PARTMAP_TYPE_PROXY, PCB_FLAG_PHYSICAL_PARTITION, PCB_FLAG_SPARABLE_PARTITION, PCB_FLAG_VIRTUAL_PARTITION, Physical, PNSR_LVOL, PPARTMAP_PHYSICAL, PPARTMAP_SPARABLE, PPARTMAP_UDF_GENERIC, PPARTMAP_VIRTUAL, SetFlag, Status, TAG_NSR_FSD, TRUE, _PARTMAP_UDF_GENERIC::Type, UDF_VERSION_150, UDF_VERSION_RECOGNIZED, UdfCreatePcb(), UdfDeletePcb(), UdfDomainIdentifierContained(), UdfSparablePartitionDomainIdentifier, UdfVirtualPartitionDomainIdentifier, USHORT, Virtual, PARTMAP_PHYSICAL::VolSetSeq, and _PARTMAP_SPARABLE::VolSetSeq. Referenced by UdfFindVolumeDescriptors(). : This routine walks through the partition map of a Logical Volume Descriptor and builds an intializing Pcb from it. The Pcb will be ready to be used in searching for the partition descriptors of a volume. Arguments: Vcb - The volume this Pcb will pertain to Pcb - Caller's pointer to the Pcb LVD - The Logical Volume Descriptor being used Return Value: STATUS_SUCCESS if the partition map is good and the Pcb is built STATUS_DISK_CORRUPT_ERROR if corrupt maps are found STATUS_UNRECOGNIZED_VOLUME if noncompliant maps are found --*/ { PPARTMAP_UDF_GENERIC Map; PPARTITION Partition; BOOLEAN Found; PAGED_CODE(); // // Check the input parameters // ASSERT_OPTIONAL_PCB( *Pcb ); DebugTrace(( +1, Dbg, "UdfInitializePcb, Lvd %08x\n", LVD )); // // Delete a pre-existing (partially initialized from a failed // crawl of a VDS) Pcb. // if (*Pcb != NULL) { UdfDeletePcb( *Pcb ); *Pcb = NULL; } *Pcb = UdfCreatePcb( LVD->MapTableCount ); // // Walk the table of partition maps intializing the Pcb for the descriptor // initialization pass. // for (Map = (PPARTMAP_UDF_GENERIC) LVD->MapTable, Partition = (*Pcb)->Partition; Partition < &(*Pcb)->Partition[(*Pcb)->Partitions]; Map = Add2Ptr( Map, Map->Length, PPARTMAP_UDF_GENERIC ), Partition++) { // // Now check that this LVD can actually contain this map entry. First check that // the descriptor can contain the first few fields, then check that it can hold // all of the bytes claimed by the descriptor. // if (Add2Ptr( Map, sizeof( PARTMAP_GENERIC ), PCHAR ) > Add2Ptr( LVD, ISONsrLvolSize( LVD ), PCHAR ) || Add2Ptr( Map, Map->Length, PCHAR ) > Add2Ptr( LVD, ISONsrLvolSize( LVD ), PCHAR )) { DebugTrace(( 0, Dbg, "UdfInitializePcb, map at +%04x beyond Lvd size %04x\n", (PCHAR) Map - (PCHAR) LVD, ISONsrLvolSize( LVD ))); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_DISK_CORRUPT_ERROR\n" )); return STATUS_DISK_CORRUPT_ERROR; } // // Now load up this map entry. // switch (Map->Type) { case PARTMAP_TYPE_PHYSICAL: { PPARTMAP_PHYSICAL MapPhysical = (PPARTMAP_PHYSICAL) Map; // // Type 1 - Physical Partition // DebugTrace(( 0, Dbg, "UdfInitializePcb, map reference %02x is Physical (Partition # %08x)\n", (Partition - (*Pcb)->Partition)/sizeof(PARTITION), MapPhysical->Partition )); // // It must be the case that the volume the partition is on is the first // one since we only do single disc UDF. This will have already been // checked by the caller. // if (MapPhysical->VolSetSeq > 1) { DebugTrace(( 0, Dbg, "UdfInitializePcb, ... but physical partition resides on volume set volume # %08x (> 1)!\n", MapPhysical->VolSetSeq )); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_DISK_CORRUPT_ERROR\n" )); return STATUS_DISK_CORRUPT_ERROR; } SetFlag( (*Pcb)->Flags, PCB_FLAG_PHYSICAL_PARTITION ); Partition->Type = Physical; Partition->Physical.PartitionNumber = MapPhysical->Partition; } break; case PARTMAP_TYPE_PROXY: // // Type 2 - a Proxy Partition, something not explicitly physical. // DebugTrace(( 0, Dbg, "UdfInitializePcb, map reference %02x is a proxy\n", (Partition - (*Pcb)->Partition)/sizeof(PARTITION))); // // Handle the various types of proxy partitions we recognize // if (UdfDomainIdentifierContained( &Map->PartID, &UdfVirtualPartitionDomainIdentifier, UDF_VERSION_150, UDF_VERSION_RECOGNIZED )) { { PPARTMAP_VIRTUAL MapVirtual = (PPARTMAP_VIRTUAL) Map; // // Only one of these guys can exist, since there can be only one VAT per media surface. // if (FlagOn( (*Pcb)->Flags, PCB_FLAG_VIRTUAL_PARTITION )) { DebugTrace(( 0, Dbg, "UdfInitializePcb, ... but this is a second virtual partition!?!!\n" )); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_UNCRECOGNIZED_VOLUME\n" )); return STATUS_UNRECOGNIZED_VOLUME; } DebugTrace(( 0, Dbg, "UdfInitializePcb, ... Virtual (Partition # %08x)\n", MapVirtual->Partition )); SetFlag( (*Pcb)->Flags, PCB_FLAG_VIRTUAL_PARTITION ); Partition->Type = Virtual; // // We will convert the partition number to a partition reference // before returning. // Partition->Virtual.RelatedReference = MapVirtual->Partition; } } else if (UdfDomainIdentifierContained( &Map->PartID, &UdfSparablePartitionDomainIdentifier, UDF_VERSION_150, UDF_VERSION_RECOGNIZED )) { { NTSTATUS Status; PPARTMAP_SPARABLE MapSparable = (PPARTMAP_SPARABLE) Map; // // It must be the case that the volume the partition is on is the first // one since we only do single disc UDF. This will have already been // checked by the caller. // if (MapSparable->VolSetSeq > 1) { DebugTrace(( 0, Dbg, "UdfInitializePcb, ... but sparable partition resides on volume set volume # %08x (> 1)!\n", MapSparable->VolSetSeq )); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_DISK_CORRUPT_ERROR\n" )); return STATUS_DISK_CORRUPT_ERROR; } DebugTrace(( 0, Dbg, "UdfInitializePcb, ... Sparable (Partition # %08x)\n", MapSparable->Partition )); // // We pretend that sparable partitions are basically the same as // physical partitions. Since we are not r/w (and will never be // on media that requires host-based sparing in any case), this // is a good simplification. // SetFlag( (*Pcb)->Flags, PCB_FLAG_SPARABLE_PARTITION ); Partition->Type = Physical; Partition->Physical.PartitionNumber = MapSparable->Partition; // // Save this map for use when the partition descriptor is found. // We can't load the sparing table at this time because we have // to turn the Lbn->Psn mapping into a Psn->Psn mapping. UDF // believes that the way sparing will be used in concert with // the Lbn->Psn mapping engine (like UdfLookupPsnOfExtent). // // Unfortunately, this would be a bit painful at this time. // The users of UdfLookupPsnOfExtent would need to iterate // over a new interface (not so bad) but the Vmcb package // would need to be turned inside out so that it didn't do // the page-filling alignment of blocks in the metadata // stream - instead, UdfLookupMetaVsnOfExtent would need to // do this itself. I choose to lay the sparing engine into // the read path and raw sector read engine instead. // Partition->Physical.SparingMap = FsRtlAllocatePoolWithTag( PagedPool, sizeof(PARTMAP_SPARABLE), TAG_NSR_FSD); RtlCopyMemory( Partition->Physical.SparingMap, MapSparable, sizeof(PARTMAP_SPARABLE)); } } else { DebugTrace(( 0, Dbg, "UdfInitializePcb, ... but we don't recognize this proxy!\n" )); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_UNRECOGNIZED_VOLUME\n" )); return STATUS_UNRECOGNIZED_VOLUME; } break; default: DebugTrace(( 0, Dbg, "UdfInitializePcb, map reference %02x is of unknown type %02x\n", Map->Type )); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_UNRECOGNIZED_VOLUME\n" )); return STATUS_UNRECOGNIZED_VOLUME; break; } } if (!FlagOn( (*Pcb)->Flags, PCB_FLAG_PHYSICAL_PARTITION | PCB_FLAG_SPARABLE_PARTITION )) { DebugTrace(( 0, Dbg, "UdfInitializePcb, no physical partition seen on this logical volume!\n" )); DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_UNRECOGNIZED_VOLUME\n" )); return STATUS_UNRECOGNIZED_VOLUME; } if (FlagOn( (*Pcb)->Flags, PCB_FLAG_VIRTUAL_PARTITION )) { PPARTITION Host; // // Confirm the validity of any type 2 virtual maps on this volume // and convert partition numbers to partition references that will // immediately index an element of the Pcb. // for (Partition = (*Pcb)->Partition; Partition < &(*Pcb)->Partition[(*Pcb)->Partitions]; Partition++) { if (Partition->Type == Virtual) { // // Go find the partition this thing is talking about // Found = FALSE; for (Host = (*Pcb)->Partition; Host < &(*Pcb)->Partition[(*Pcb)->Partitions]; Host++) { if (Host->Type == Physical && Host->Physical.PartitionNumber == Partition->Virtual.RelatedReference) { Partition->Virtual.RelatedReference = (USHORT)(Host - (*Pcb)->Partition)/sizeof(PARTITION); Found = TRUE; break; } } // // Failure to find a physical partition for this virtual guy // is not a good sign. // if (!Found) { return STATUS_DISK_CORRUPT_ERROR; } } } } DebugTrace(( -1, Dbg, "UdfInitializePcb -> STATUS_SUCCESS\n" )); return STATUS_SUCCESS; }

NTSTATUS UdfLoadSparingTables (  PIRP_CONTEXT  IrpContext, PVCB  Vcb, PPCB  Pcb, ULONG  Reference )

Definition at line 1406 of file allocsup.c. References Add2Ptr, ASSERT, ASSERT_IRP_CONTEXT, ASSERT_VCB, BytesFromSectors, Dbg, DebugTrace, DebugUnwind, FALSE, FsRtlAddLargeMcbEntry(), FsRtlAllocatePoolWithTag, FsRtlInitializeLargeMcb(), Header, _SPARING_TABLE_ENTRY::Mapped, Min, NTSTATUS(), NULL, _PARTMAP_SPARABLE::NumSparingTables, _SPARING_TABLE_ENTRY::Original, OSCLASS_INVALID, OSIDENTIFIER_INVALID, _PARTMAP_SPARABLE::PacketLength, PAGE_SIZE, PagedPool, _PCB::Partition, PSPARING_TABLE_ENTRY, PSPARING_TABLE_HEADER, SectorsFromBlocks, SectorSize, SPARING_TABLE_ENTRY, SPARING_TABLE_HEADER, _PCB::SparingMcb, Status, _PARTMAP_SPARABLE::TableLocation, _PARTMAP_SPARABLE::TableSize, TAG_NSR_FSD, TAG_SPARING_MCB, _VCB::TargetDeviceObject, TRUE, UDF_SPARING_AVALIABLE, UDF_SPARING_DEFECTIVE, UDF_SPARING_PACKET_LENGTH, UDF_VERSION_150, UDF_VERSION_RECOGNIZED, UdfFreePool(), UdfLoadSparingTables(), UdfReadSectors(), UdfSparingTableIdentifier, UdfUdfIdentifierContained(), UdfVerifyDescriptor(), and VOID(). Referenced by UdfCompletePcb(), and UdfLoadSparingTables(). 01415 : 01416 01417 This routine reads the sparing tables for a partition and fills 01418 in the sparing Mcb. 01419 01420 Arguments: 01421 01422 Vcb - the volume hosting the spared partition 01423 01424 Pcb - the partion block corresponding to the volume 01425 01426 Reference - the partition reference being pulled in 01427 01428 Return Value: 01429 01430 NTSTATUS according to whether the sparing tables were loaded 01431 01432 --*/ 01433 01434 { 01435 NTSTATUS Status; 01436 01437 ULONG SparingTable; 01438 PULONG SectorBuffer; 01439 ULONG Psn; 01440 01441 ULONG RemainingBytes; 01442 ULONG ByteOffset; 01443 ULONG TotalBytes; 01444 01445 BOOLEAN Complete; 01446 01447 PSPARING_TABLE_HEADER Header; 01448 PSPARING_TABLE_ENTRY Entry; 01449 01450 PPARTITION Partition = &Pcb->Partition[Reference]; 01451 PPARTMAP_SPARABLE Map = Partition->Physical.SparingMap; 01452 01453 ASSERT_IRP_CONTEXT( IrpContext ); 01454 ASSERT_VCB( Vcb ); 01455 01456 ASSERT( Map != NULL ); 01457 01458 DebugTrace(( +1, Dbg, "UdfLoadSparingTables, Vcb %08x, PcbPartition %08x, Map @ %08x\n", Vcb, Partition, Map )); 01459 01460 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, Map sez: PacketLen %u, NTables %u, TableSize %u\n", 01461 Map->PacketLength, 01462 Map->NumSparingTables, 01463 Map->TableSize)); 01464 01465 01466 // 01467 // Check that the sparale map appears sane. If there are no sparing tables that 01468 // is pretty OK, and it'll wind up looking like a regular physical partition. 01469 // 01470 01471 if (Map->NumSparingTables == 0) { 01472 01473 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, no sparing tables claimed!\n" )); 01474 DebugTrace(( -1, Dbg, "UdfLoadSparingTables -> STATUS_SUCCESS\n" )); 01475 return STATUS_SUCCESS; 01476 } 01477 01478 if (Map->NumSparingTables > sizeof(Map->TableLocation)/sizeof(ULONG)) { 01479 01480 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, too many claimed tables to fit! (max %u)\n", 01481 sizeof(Map->TableLocation)/sizeof(ULONG))); 01482 DebugTrace(( -1, Dbg, "UdfLoadSparingTables -> STATUS_DISK_CORRUPT_ERROR\n" )); 01483 return STATUS_DISK_CORRUPT_ERROR; 01484 } 01485 01486 if (Map->PacketLength != UDF_SPARING_PACKET_LENGTH) { 01487 01488 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, packet size is %u (not %u!\n", 01489 Map->PacketLength, 01490 UDF_SPARING_PACKET_LENGTH )); 01491 DebugTrace(( -1, Dbg, "UdfLoadSparingTables -> STATUS_DISK_CORRUPT_ERROR\n" )); 01492 return STATUS_DISK_CORRUPT_ERROR; 01493 } 01494 01495 if (Map->TableSize < sizeof(SPARING_TABLE_HEADER) || 01496 (Map->TableSize - sizeof(SPARING_TABLE_HEADER)) % sizeof(SPARING_TABLE_ENTRY) != 0) { 01497 01498 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, sparing table size is too small or unaligned!\n" )); 01499 DebugTrace(( -1, Dbg, "UdfLoadSparingTables -> STATUS_DISK_CORRUPT_ERROR\n" )); 01500 return STATUS_DISK_CORRUPT_ERROR; 01501 } 01502 01503 #ifdef UDF_SANITY 01504 DebugTrace(( 0, Dbg, "UdfLoadSparingTables" )); 01505 for (SparingTable = 0; SparingTable < Map->NumSparingTables; SparingTable++) { 01506 01507 DebugTrace(( 0, Dbg, ", Table %u @ %x", SparingTable, Map->TableLocation[SparingTable] )); 01508 } 01509 DebugTrace(( 0, Dbg, "\n" )); 01510 #endif 01511 01512 // 01513 // If a sparing mcb doesn't exist, manufacture one. 01514 // 01515 01516 if (Pcb->SparingMcb == NULL) { 01517 01518 Pcb->SparingMcb = FsRtlAllocatePoolWithTag( PagedPool, sizeof(LARGE_MCB), TAG_SPARING_MCB ); 01519 FsRtlInitializeLargeMcb( Pcb->SparingMcb, PagedPool ); 01520 } 01521 01522 SectorBuffer = FsRtlAllocatePoolWithTag( PagedPool, PAGE_SIZE, TAG_NSR_FSD ); 01523 01524 // 01525 // Now loop across the sparing tables and pull the data in. 01526 // 01527 01528 try { 01529 01530 for (Complete = FALSE, SparingTable = 0; 01531 01532 SparingTable < Map->NumSparingTables; 01533 01534 SparingTable++) { 01535 01536 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, loading sparing table %u!\n", 01537 SparingTable )); 01538 01539 ByteOffset = 0; 01540 TotalBytes = 0; 01541 RemainingBytes = 0; 01542 01543 do { 01544 01545 if (RemainingBytes == 0) { 01546 01547 (VOID) UdfReadSectors( IrpContext, 01548 BytesFromSectors( Vcb, Map->TableLocation[SparingTable] ) + ByteOffset, 01549 SectorSize( Vcb ), 01550 FALSE, 01551 SectorBuffer, 01552 Vcb->TargetDeviceObject ); 01553 01554 // 01555 // Verify the descriptor at the head of the sparing table. If it is not 01556 // valid, we just break out for a chance at the next table, if any. 01557 // 01558 01559 if (ByteOffset == 0) { 01560 01561 Header = (PSPARING_TABLE_HEADER) SectorBuffer; 01562 01563 if (!UdfVerifyDescriptor( IrpContext, 01564 &Header->Destag, 01565 0, 01566 SectorSize( Vcb ), 01567 Header->Destag.Lbn, 01568 TRUE )) { 01569 01570 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, sparing table %u didn't verify destag!\n", 01571 SparingTable )); 01572 break; 01573 } 01574 01575 if (!UdfUdfIdentifierContained( &Header->RegID, 01576 &UdfSparingTableIdentifier, 01577 UDF_VERSION_150, 01578 UDF_VERSION_RECOGNIZED, 01579 OSCLASS_INVALID, 01580 OSIDENTIFIER_INVALID)) { 01581 01582 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, sparing table %u didn't verify regid!\n", 01583 SparingTable )); 01584 break; 01585 } 01586 01587 // 01588 // Calculate the total number bytes this map spans and check it against what 01589 // we were told the sparing table sizes are. 01590 // 01591 01592 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, Sparing table %u has %u entries\n", 01593 SparingTable, 01594 Header->TableEntries )); 01595 01596 TotalBytes = sizeof(SPARING_TABLE_HEADER) + Header->TableEntries * sizeof(SPARING_TABLE_ENTRY); 01597 01598 if (Map->TableSize < TotalBytes) { 01599 01600 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, sparing table #ents %u overflows allocation!\n", 01601 Header->TableEntries )); 01602 break; 01603 } 01604 01605 // 01606 // So far so good, advance past the header. 01607 // 01608 01609 ByteOffset = sizeof(SPARING_TABLE_HEADER); 01610 Entry = Add2Ptr( SectorBuffer, sizeof(SPARING_TABLE_HEADER), PSPARING_TABLE_ENTRY ); 01611 01612 } else { 01613 01614 // 01615 // Pick up in the new sector. 01616 // 01617 01618 Entry = (PSPARING_TABLE_ENTRY) SectorBuffer; 01619 } 01620 01621 RemainingBytes = Min( SectorSize( Vcb ), TotalBytes - ByteOffset ); 01622 } 01623 01624 // 01625 // Add the mapping. Since sparing tables are an Lbn->Psn mapping, 01626 // very odd, and I want to simplify things by putting the sparing 01627 // in right at IO dispatch, translate this to a Psn->Psn mapping. 01628 // 01629 01630 if (Entry->Original != UDF_SPARING_AVALIABLE && 01631 Entry->Original != UDF_SPARING_DEFECTIVE) { 01632 01633 Psn = Partition->Physical.Start + SectorsFromBlocks( Vcb, Entry->Original ); 01634 01635 DebugTrace(( 0, Dbg, "UdfLoadSparingTables, mapping from Psn %x (Lbn %x) -> Psn %x\n", 01636 Psn, 01637 Entry->Original, 01638 Entry->Mapped )); 01639 01640 FsRtlAddLargeMcbEntry( Pcb->SparingMcb, 01641 Psn, 01642 Entry->Mapped, 01643 UDF_SPARING_PACKET_LENGTH ); 01644 } 01645 01646 // 01647 // Advance to the next, and drop out if we've hit the end. 01648 // 01649 01650 ByteOffset += sizeof(SPARING_TABLE_ENTRY); 01651 RemainingBytes -= sizeof(SPARING_TABLE_ENTRY); 01652 Entry++; 01653 01654 } while ( ByteOffset < TotalBytes ); 01655 } 01656 01657 } finally { 01658 01659 DebugUnwind( UdfLoadSparingTables ); 01660 01661 UdfFreePool( &SectorBuffer ); 01662 } 01663 01664 DebugTrace(( -1, Dbg, "UdfLoadSparingTables -> STATUS_SUCCESS\n" )); 01665 01666 return STATUS_SUCCESS; 01667 } }

BOOLEAN UdfLookupAllocation (  IN PIRP_CONTEXT  IrpContext, IN PFCB  Fcb, IN LONGLONG  FileOffset, OUT PLONGLONG  DiskOffset, OUT PULONG  ByteCount )

Definition at line 69 of file allocsup.c. References ASSERT, ASSERT_FCB, ASSERT_IRP_CONTEXT, BytesFromSectors, Dbg, DebugTrace, FALSE, FCB_STATE_EMBEDDED_DATA, FCB_STATE_MCB_INITIALIZED, FCB_STATE_VMCB_MAPPING, FlagOn, FsRtlLookupLargeMcbEntry(), LlBytesFromSectors, LlSectorsFromBytes, NULL, PAGED_CODE, _VCB::Pcb, PFCB, SectorOffset, SectorsFromBytes, _PCB::SparingMcb, TRUE, UdfMethod2NextRunoutInSectors, UdfMethod2TransformByteOffset, UdfVmcbVbnToLbn(), VCB_STATE_METHOD_2_FIXUP, _VCB::VcbState, and _VCB::Vmcb. Referenced by UdfPrepareBuffers(). : This routine looks through the mapping information for the file to find the logical diskoffset and number of bytes at that offset. This routine assumes we are looking up a valid range in the file. If a mapping does not exist, Arguments: Fcb - Fcb representing this stream. FileOffset - Lookup the allocation beginning at this point. DiskOffset - Address to store the logical disk offset. ByteCount - Address to store the number of contiguous bytes beginning at DiskOffset above. Return Value: BOOLEAN - whether the extent is unrecorded data --*/ { PVCB Vcb; BOOLEAN Recorded = TRUE; BOOLEAN Result; LARGE_INTEGER LocalPsn; LARGE_INTEGER LocalSectorCount; PAGED_CODE(); // // Check inputs // ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); // // We will never be looking up the allocations of embedded objects. // ASSERT( !FlagOn( Fcb->FcbState, FCB_STATE_EMBEDDED_DATA )); Vcb = Fcb->Vcb; LocalPsn.QuadPart = LocalSectorCount.QuadPart = 0; // // Lookup the entry containing this file offset. // if (FlagOn( Fcb->FcbState, FCB_STATE_VMCB_MAPPING )) { // // Map this offset into the metadata stream. // ASSERT( SectorOffset( Vcb, FileOffset ) == 0 ); Result = UdfVmcbVbnToLbn( &Vcb->Vmcb, SectorsFromBytes( Vcb, FileOffset ), &LocalPsn.LowPart, &LocalSectorCount.LowPart ); ASSERT( Result ); } else { // // Map this offset in a regular stream. // ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_MCB_INITIALIZED )); Result = FsRtlLookupLargeMcbEntry( &Fcb->Mcb, LlSectorsFromBytes( Vcb, FileOffset ), &LocalPsn.QuadPart, &LocalSectorCount.QuadPart, NULL, NULL, NULL ); } // // If within the Mcb then we use the data out of this entry and are nearly done. // if (Result) { if ( LocalPsn.QuadPart == -1 ) { // // Regular files can have holey allocations which represent unrecorded extents. For // such extents which are sandwiched in between recorded extents of the file, the Mcb // package tells us that it found a valid mapping but that it doesn't correspond to // any extents on the media yet. In this case, simply fake the disk offset. The // returned sector count is accurate. // *DiskOffset = 0; Recorded = FALSE; } else { // // Now mimic the effects of physical sector sparing. This may shrink the size of the // returned run if sparing interrupted the extent on disc. // ASSERT( LocalPsn.HighPart == 0 ); if (Vcb->Pcb->SparingMcb) { LONGLONG SparingPsn; LONGLONG SparingSectorCount; if (FsRtlLookupLargeMcbEntry( Vcb->Pcb->SparingMcb, LocalPsn.LowPart, &SparingPsn, &SparingSectorCount, NULL, NULL, NULL )) { // // Only emit noise if we will really change anything as a result // of the sparing table. // if (SparingPsn != -1 || SparingSectorCount < LocalSectorCount.QuadPart) { DebugTrace(( 0, Dbg, "UdfLookupAllocation, spared [%x, +%x) onto [%x, +%x)\n", LocalPsn.LowPart, LocalSectorCount.LowPart, (ULONG) SparingPsn, (ULONG) SparingSectorCount )); } // // If we did not land in a hole, map the sector. // if (SparingPsn != -1) { LocalPsn.QuadPart = SparingPsn; } // // The returned sector count now reduces the previous sector count. // If we landed in a hole, this indicates that the trailing edge of // the extent is spared, if not this indicates that the leading // edge is spared. // if (SparingSectorCount < LocalSectorCount.QuadPart) { LocalSectorCount.QuadPart = SparingSectorCount; } } } *DiskOffset = LlBytesFromSectors( Vcb, LocalPsn.QuadPart ) + SectorOffset( Vcb, FileOffset ); // // Now we can apply method 2 fixups, which will again interrupt the size of the extent. // if (FlagOn( Vcb->VcbState, VCB_STATE_METHOD_2_FIXUP )) { LARGE_INTEGER SectorsToRunout; SectorsToRunout.QuadPart= UdfMethod2NextRunoutInSectors( Vcb, *DiskOffset ); if (SectorsToRunout.QuadPart < LocalSectorCount.QuadPart) { LocalSectorCount.QuadPart = SectorsToRunout.QuadPart; } *DiskOffset = UdfMethod2TransformByteOffset( Vcb, *DiskOffset ); } } } else { // // We know that prior to this call the system has restricted IO to points within the // the file data. Since we failed to find a mapping this is an unrecorded extent at // the end of the file, so just conjure up a proper representation. // ASSERT( FileOffset < Fcb->FileSize.QuadPart ); *DiskOffset = 0; LocalSectorCount.QuadPart = LlSectorsFromBytes( Vcb, Fcb->FileSize.QuadPart ) - LlSectorsFromBytes( Vcb, FileOffset ) + 1; Recorded = FALSE; } // // Restrict to MAXULONG bytes of allocation // if (LocalSectorCount.QuadPart > SectorsFromBytes( Vcb, MAXULONG )) { *ByteCount = MAXULONG; } else { *ByteCount = BytesFromSectors( Vcb, LocalSectorCount.LowPart ); } *ByteCount -= SectorOffset( Vcb, FileOffset ); return Recorded; }

ULONG UdfLookupMetaVsnOfExtent (  IN PIRP_CONTEXT  IrpContext, IN PVCB  Vcb, IN USHORT  Reference, IN ULONG  Lbn, IN ULONG  Len, IN BOOLEAN  ExactEnd )

Definition at line 1177 of file allocsup.c. References ASSERT_IRP_CONTEXT, ASSERT_VCB, BlockOffset, BlocksFromBytes, BlocksFromSectors, CcSetFileSizes(), FALSE, LlBytesFromSectors, NULL, PCC_FILE_SIZES, SectorsFromBytes, TRUE, try_leave, UdfAddVmcbMapping(), UdfLockFcb, UdfLookupPsnOfExtent(), UdfRaiseStatus(), UdfRemoveVmcbMapping(), UdfUnlockFcb, and UdfVmcbLbnToVbn(). Referenced by UdfInitializeAllocations(), UdfMapMetadataView(), and UdfUpdateVcbPhase0(). : This routine maps the input logical block extent on a given partition to a starting virtual block in the metadata stream. If a mapping does not exist, one will be created and the metadata stream extended. Arguments: Vcb - Vcb of logical volume Reference - Partition reference to use in the mapping Lbn - Logical block number Len - Length of extent in bytes ExactEnd - Indicates the extension policy if these blocks are not mapped. Return Value: ULONG virtual sector number Raised status if the Lbn extent is split across multiple Vbn extents. --*/ { ULONG Vsn; ULONG Psn; ULONG SectorCount; BOOLEAN Result; BOOLEAN UnwindExtension = FALSE; LONGLONG UnwindAllocationSize; PFCB Fcb = NULL; // // Check inputs // ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_VCB( Vcb ); // // The extent must be an integral number of logical blocks in length. // if (Len == 0 || BlockOffset( Vcb, Len )) { UdfRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); } // // Get the physical mapping of the extent. The Mcb package operates on ULONG/ULONG // keys and values so we must render our 48bit address into 32. We can do this since // this is a single surface implementation, and it is guaranteed that a surface cannot // contain more than MAXULONG physical sectors. // Psn = UdfLookupPsnOfExtent( IrpContext, Vcb, Reference, Lbn, Len ); // // Use try-finally for cleanup // try { // // We must safely establish a mapping and extend the metadata stream so that cached // reads can occur on this new extent. // Fcb = Vcb->MetadataFcb; UdfLockFcb( IrpContext, Fcb ); Result = UdfVmcbLbnToVbn( &Vcb->Vmcb, Psn, &Vsn, &SectorCount ); if (Result) { // // If the mapping covers the extent, we can give this back. // if (BlocksFromSectors( Vcb, SectorCount ) >= BlocksFromBytes( Vcb, Len )) { try_leave( NOTHING ); } // // It is a fatal error if the extent we are mapping is not wholly contained // by an extent of Vsns in the Vmcb. This will indicate that some structure // is trying to overlap another. // UdfRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); } // // Add the new mapping. We know that it is being added to the end of the stream. // UdfAddVmcbMapping( &Vcb->Vmcb, Psn, SectorsFromBytes( Vcb, Len ), ExactEnd, &Vsn, &SectorCount ); UnwindAllocationSize = Fcb->AllocationSize.QuadPart; UnwindExtension = TRUE; Fcb->AllocationSize.QuadPart = Fcb->FileSize.QuadPart = Fcb->ValidDataLength.QuadPart = LlBytesFromSectors( Vcb, Vsn + SectorCount); CcSetFileSizes( Fcb->FileObject, (PCC_FILE_SIZES) &Fcb->AllocationSize ); UnwindExtension = FALSE; // // We do not need to purge the cache maps since the Vmcb will always be // page aligned, and thus any reads will have filled it with valid data. // } finally { if (UnwindExtension) { ULONG FirstZappedVsn; // // Strip off the additional mappings we made. // Fcb->AllocationSize.QuadPart = Fcb->FileSize.QuadPart = Fcb->ValidDataLength.QuadPart = UnwindAllocationSize; FirstZappedVsn = SectorsFromBytes( Vcb, UnwindAllocationSize ); UdfRemoveVmcbMapping( &Vcb->Vmcb, FirstZappedVsn, Vsn + SectorCount - FirstZappedVsn ); CcSetFileSizes( Fcb->FileObject, (PCC_FILE_SIZES) &Fcb->AllocationSize ); } if (Fcb) { UdfUnlockFcb( IrpContext, Fcb ); } } return Vsn; }

ULONG UdfLookupPsnOfExtent (  IN PIRP_CONTEXT  IrpContext, IN PVCB  Vcb, IN USHORT  Reference, IN ULONG  Lbn, IN ULONG  Len )

Definition at line 1017 of file allocsup.c. References ASSERT, ASSERT_IRP_CONTEXT, ASSERT_PCB, ASSERT_VCB, BlocksFromBytes, BlockSize, CcMapData(), Dbg, DebugTrace, DebugUnwind, FALSE, _tagPARTITION::Length, Offset, PAGED_CODE, _PCB::Partition, _PCB::Partitions, PBCB, Physical, SectorsFromBlocks, SectorsFromBytes, TRUE, UdfLookupPsnOfExtent(), UdfRaiseStatus(), UdfUnpinData, and Virtual. Referenced by UdfFindFileSetDescriptor(), UdfInitializeAllocations(), UdfLookupMetaVsnOfExtent(), and UdfLookupPsnOfExtent(). : This routine maps the input logical block extent on a given partition to a starting physical sector. It doubles as a bounds checker - if the routine does not raise, the caller is guaranteed that the extent lies within the partition. Arguments: Vcb - Vcb of logical volume Reference - Partition reference to use in the mapping Lbn - Logical block number Len - Length of extent in bytes Return Value: ULONG physical sector number --*/ { PPCB Pcb = Vcb->Pcb; ULONG Psn; PBCB Bcb; LARGE_INTEGER Offset; PULONG MappedLbn; PAGED_CODE(); // // Check inputs // ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_VCB( Vcb ); ASSERT_PCB( Pcb ); DebugTrace(( +1, Dbg, "UdfLookupPsnOfExtent, [%04x/%08x, +%08x)\n", Reference, Lbn, Len )); if (Reference < Pcb->Partitions) { while (TRUE) { switch (Pcb->Partition[Reference].Type) { case Physical: // // Check that the input extent lies inside the partition. Calculate the // Lbn of the last block and see that it is interior. // if (SectorsFromBlocks( Vcb, Lbn ) + SectorsFromBytes( Vcb, Len ) > Pcb->Partition[Reference].Physical.Length) { goto NoGood; } Psn = Pcb->Partition[Reference].Physical.Start + SectorsFromBlocks( Vcb, Lbn ); DebugTrace(( -1, Dbg, "UdfLookupPsnOfExtent -> %08x\n", Psn )); return Psn; case Virtual: // // Bounds check. Per UDF 2.00 2.3.10 and implied in UDF 1.50, virtual // extent lengths cannot be greater than one block in size. // if (Lbn + BlocksFromBytes( Vcb, Len ) > Pcb->Partition[Reference].Virtual.Length || Len > BlockSize( Vcb )) { goto NoGood; } try { // // Calculate the location of the mapping element in the VAT // and retrieve. // Offset.QuadPart = Lbn * sizeof(ULONG); CcMapData( Vcb->VatFcb->FileObject, &Offset, sizeof(ULONG), TRUE, &Bcb, &MappedLbn ); // // Now rewrite the inputs in terms of the virtual mapping. We // will reloop to perform the logical -> physical mapping. // DebugTrace(( 0, Dbg, "UdfLookupPsnOfExtent, Mapping V %04x/%08x -> L %04x/%08x\n", Reference, Lbn, Pcb->Partition[Reference].Virtual.RelatedReference, *MappedLbn )); Lbn = *MappedLbn; Reference = Pcb->Partition[Reference].Virtual.RelatedReference; } finally { DebugUnwind( UdfLookupPsnOfExtent ); UdfUnpinData( IrpContext, &Bcb ); } // // An Lbn of ~0 in the VAT is defined to indicate that the sector is unused, // so we should never see such a thing. // if (Lbn == ~0) { goto NoGood; } break; default: ASSERT(FALSE); break; } } } NoGood: // // Some people have misinterpreted a partition number to equal a // partition reference, or perhaps this is just corrupt media. // UdfRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); }

---