/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
udfs_rec.c
Abstract:
This module contains the mini-file system recognizer for UDFS.
Author:
Dan Lovinger (danlo) 13-Feb-1997
Environment:
Kernel mode, local to I/O system
Revision History:
--*/
#include "fs_rec.h"
#include "udfs_rec.h"
//
// The local debug trace level
//
#define Dbg (FSREC_DEBUG_LEVEL_UDFS)
//
// Tables of tokens we have to parse up from mount-time on-disk structures
//
PARSE_KEYVALUE VsdIdentParseTable[] = {
{ VSD_IDENT_BEA01, VsdIdentBEA01 },
{ VSD_IDENT_TEA01, VsdIdentTEA01 },
{ VSD_IDENT_CDROM, VsdIdentCDROM },
{ VSD_IDENT_CD001, VsdIdentCD001 },
{ VSD_IDENT_CDW01, VsdIdentCDW01 },
{ VSD_IDENT_CDW02, VsdIdentCDW02 },
{ VSD_IDENT_NSR01, VsdIdentNSR01 },
{ VSD_IDENT_NSR02, VsdIdentNSR02 },
{ VSD_IDENT_BOOT2, VsdIdentBOOT2 },
{ VSD_IDENT_NSR03, VsdIdentNSR03 },
{ NULL, VsdIdentBad }
};
NTSTATUS
UdfsRecGetLastSessionStart(
IN PDEVICE_OBJECT DeviceObject,
OUT PULONG Psn
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE,IsUdfsVolume)
#pragma alloc_text(PAGE,UdfsFindInParseTable)
#pragma alloc_text(PAGE,UdfsRecFsControl)
#pragma alloc_text(PAGE,UdfsRecGetLastSessionStart)
#endif // ALLOC_PRAGMA
//
// This macro copies an unaligned src longword to a dst longword,
// performing an little/big endian swap.
//
#define SwapCopyUchar4(Dst,Src) { \
*((UNALIGNED UCHAR *)(Dst)) = *((UNALIGNED UCHAR *)(Src) + 3); \
*((UNALIGNED UCHAR *)(Dst) + 1) = *((UNALIGNED UCHAR *)(Src) + 2); \
*((UNALIGNED UCHAR *)(Dst) + 2) = *((UNALIGNED UCHAR *)(Src) + 1); \
*((UNALIGNED UCHAR *)(Dst) + 3) = *((UNALIGNED UCHAR *)(Src)); \
}
NTSTATUS
UdfsRecGetLastSessionStart(
IN PDEVICE_OBJECT DeviceObject,
OUT PULONG Psn
)
/*++
Routine Description:
This function queries the underlying device for the address of the
first track in the last session. Does nothing for DISK devices.
Arguments:
DeviceObject - Pointer to this driver's device object.
Psn - receives physical sector number of first block in last session,
0 for disk devices
Return Value:
The function value is the final status of the operation.
-*/
{
KEVENT Event;
NTSTATUS Status;
IO_STATUS_BLOCK ioStatus;
CDROM_TOC_SESSION_DATA SessionData;
PIRP Irp;
*Psn = 0;
if (DeviceObject->DeviceType != FILE_DEVICE_CD_ROM) {
return STATUS_SUCCESS;
}
KeInitializeEvent( &Event, SynchronizationEvent, FALSE );
Irp = IoBuildDeviceIoControlRequest( IOCTL_CDROM_GET_LAST_SESSION,
DeviceObject,
(PVOID) NULL,
0,
&SessionData,
sizeof( SessionData ),
FALSE,
&Event,
&ioStatus );
if (!Irp) {
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Override verify logic - we don't care. The fact we're in the picture means
// someone is trying to mount new/changed media in the first place.
//
SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
Status = IoCallDriver( DeviceObject, Irp );
if (Status == STATUS_PENDING) {
(VOID) KeWaitForSingleObject( &Event,
Executive,
KernelMode,
FALSE,
(PLARGE_INTEGER) NULL );
Status = ioStatus.Status;
}
if (!NT_SUCCESS( Status )) {
return Status;
}
if (SessionData.FirstCompleteSession != SessionData.LastCompleteSession) {
SwapCopyUchar4( Psn, &SessionData.TrackData[0].Address );
}
return STATUS_SUCCESS;
}
NTSTATUS
UdfsRecFsControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This function performs the mount and driver reload functions for this mini-
file system recognizer driver.
Arguments:
DeviceObject - Pointer to this driver's device object.
Irp - Pointer to the I/O Request Packet (IRP) representing the function to
be performed.
Return Value:
The function value is the final status of the operation.
-*/
{
NTSTATUS status;
PIO_STACK_LOCATION irpSp;
PDEVICE_EXTENSION deviceExtension;
UNICODE_STRING driverName;
ULONG bytesPerSector;
PDEVICE_OBJECT targetDevice;
PAGED_CODE();
//
// Begin by determining what function that is to be performed.
//
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
irpSp = IoGetCurrentIrpStackLocation( Irp );
switch ( irpSp->MinorFunction ) {
case IRP_MN_MOUNT_VOLUME:
//
// Attempt to mount a volume: There are two different cases here:
//
// 1) The device is being opened for DASD access, that is, no
// file system is required, thus it is OK to allow RAW to
// to open it.
//
// 2) We need to rummage the media to see if this is a UDF volume.
//
status = STATUS_UNRECOGNIZED_VOLUME;
targetDevice = irpSp->Parameters.MountVolume.DeviceObject;
if (FsRecGetDeviceSectorSize( targetDevice,
&bytesPerSector )) {
if (IsUdfsVolume( targetDevice,
bytesPerSector )) {
status = STATUS_FS_DRIVER_REQUIRED;
}
}
break;
case IRP_MN_LOAD_FILE_SYSTEM:
status = FsRecLoadFileSystem( DeviceObject,
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Udfs" );
break;
default:
status = STATUS_INVALID_DEVICE_REQUEST;
}
//
// Finally, complete the request and return the same status code to the
// caller.
//
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status;
}
BOOLEAN
IsUdfsVolume (
IN PDEVICE_OBJECT DeviceObject,
IN ULONG SectorSize
)
/*++
Routine Description:
This routine walks the Volume Recognition Sequence to determine
whether this volume contains an NSR02 (ISO 13346 Section 4) image.
Note: this routine is pretty much diked out of UdfsRecognizeVolume
in the real filesystem, modulo fitting it into the fs recognizer.
Arguments:
DeviceObject - device we are checking
SectorSize - size of a physical sector on this device
Return Value:
Boolean TRUE if we found NSR02, FALSE otherwise.
--*/
{
BOOLEAN FoundNSR;
BOOLEAN FoundBEA;
BOOLEAN Resolved;
ULONG LastSessionStartPsn;
PVSD_GENERIC VolumeStructureDescriptor = NULL;
PVOID Buffer = NULL;
ULONGLONG Offset;
PAGED_CODE();
DebugTrace(( +1, Dbg,
"IsUdfsVolume, DevObj %08x SectorSize %08x\n",
DeviceObject,
SectorSize ));
//
// Find the start of the last session
//
if (!NT_SUCCESS( UdfsRecGetLastSessionStart( DeviceObject,
&LastSessionStartPsn))) {
return FALSE;
}
Retry:
DebugTrace(( 0, Dbg, "IsUdfsVolume, Looking at session starting Psn == 0x%x\n", LastSessionStartPsn));
Offset = (SectorSize * LastSessionStartPsn) + SectorAlignN( SectorSize, VRA_BOUNDARY_LOCATION );
FoundNSR =
FoundBEA =
Resolved = FALSE;
while (!Resolved) {
//
// The VRS descriptors are specified at 2kb regardless of sector size. So
// we only want to read if we've processed all 2kb blocks in the last read
// sector (latest gen MO media has 4kb sectors) i.e. if we have landed
// on a sector aligned offset after processing the last descriptor.
//
if (0 == (Offset & (SectorSize - 1))) {
if (!FsRecReadBlock( DeviceObject,
(PLARGE_INTEGER)&Offset,
sizeof(VSD_GENERIC),
SectorSize,
&Buffer,
NULL )) {
break;
}
VolumeStructureDescriptor = Buffer;
}
//
// Now check the type of the descriptor. All ISO 13346 VSDs are
// of Type 0, 9660 PVDs are Type 1, 9660 SVDs are Type 2, and 9660
// terminating descriptors are Type 255.
//
if (VolumeStructureDescriptor->Type == 0) {
//
// In order to properly recognize the volume, we must know all of the
// Structure identifiers in ISO 13346 so that we can terminate if a
// badly formatted (or, shockingly, non 13346) volume is presented to us.
//
switch (UdfsFindInParseTable( VsdIdentParseTable,
VolumeStructureDescriptor->Ident,
VSD_LENGTH_IDENT )) {
case VsdIdentBEA01:
//
// Only one BEA may exist and its version must be 1 (2/9.2.3)
//
DebugTrace(( 0, Dbg, "IsUdfsVolume, got a BEA01\n" ));
if ((FoundBEA &&
DebugTrace(( 0, Dbg,
"IsUdfsVolume, ... but it is a duplicate!\n" ))) ||
(VolumeStructureDescriptor->Version != 1 &&
DebugTrace(( 0, Dbg,
"IsUdfsVolume, ... but it has a wacky version number %02x != 1!\n",
VolumeStructureDescriptor->Version )))) {
Resolved = TRUE;
break;
}
FoundBEA = TRUE;
break;
case VsdIdentTEA01:
//
// If we reach the TEA it must be the case that we don't recognize
//
DebugTrace(( 0, Dbg, "IsUdfsVolume, got a TEA01\n" ));
Resolved = TRUE;
break;
case VsdIdentNSR02:
case VsdIdentNSR03:
//
// We recognize NSR02 version 1 embedded after a BEA (3/9.1.3). For
// simplicity we will not bother being a complete nitpick and check
// for a bounding TEA, although we will be optimistic in the case where
// we fail to match the version.
//
DebugTrace(( 0, Dbg, "IsUdfsVolume, got an NSR02/3\n" ));
if ((FoundBEA ||
!DebugTrace(( 0, Dbg, "IsUdfsVolume, ... but we haven't seen a BEA01 yet!\n" ))) &&
(VolumeStructureDescriptor->Version == 1 ||
!DebugTrace(( 0, Dbg, "IsUdfsVolume, ... but it has a wacky version number %02x != 1\n",
VolumeStructureDescriptor->Version )))) {
FoundNSR = Resolved = TRUE;
break;
}
break;
case VsdIdentCD001:
case VsdIdentCDW01:
case VsdIdentNSR01:
case VsdIdentCDW02:
case VsdIdentBOOT2:
DebugTrace(( 0, Dbg, "IsUdfsVolume, got a valid but uninteresting 13346 descriptor\n" ));
//
// Valid but uninteresting (to us) descriptors
//
break;
default:
DebugTrace(( 0, Dbg, "IsUdfsVolume, got an invalid 13346 descriptor\n" ));
//
// Stumbling across something we don't know, it must be that this
// is not a valid 13346 image
//
Resolved = TRUE;
break;
}
} else if (!FoundBEA && (VolumeStructureDescriptor->Type < 3 ||
VolumeStructureDescriptor->Type == 255)) {
DebugTrace(( 0, Dbg, "IsUdfsVolume, got a 9660 descriptor\n" ));
//
// Only HSG (CDROM) and 9660 (CD001) are possible, and they are only legal
// before the ISO 13346 BEA/TEA extent. By design, an ISO 13346 VSD precisely
// overlaps a 9660 PVD/SVD in the appropriate fields.
//
// Note that we aren't being strict about the structure of the 9660 descriptors
// since that really isn't very interesting. We care more about the 13346.
//
//
switch (UdfsFindInParseTable( VsdIdentParseTable,
VolumeStructureDescriptor->Ident,
VSD_LENGTH_IDENT )) {
case VsdIdentCDROM:
case VsdIdentCD001:
DebugTrace(( 0, Dbg, "IsUdfsVolume, ... seems we have 9660 here\n" ));
//
// Note to our caller that we seem to have ISO 9660 here
//
break;
default:
DebugTrace(( 0, Dbg, "IsUdfsVolume, ... but it looks wacky\n" ));
//
// This probably was a false alert, but in any case there is nothing
// on this volume for us.
//
Resolved = TRUE;
break;
}
} else {
//
// Something else must be recorded on this volume.
//
DebugTrace(( 0, Dbg, "IsUdfsVolume, got an unrecognizeable descriptor, probably not 13346/9660\n" ));
break;
}
//
// Descriptor size is 2kb. Sector size is always a power of 2. So just
// increase offset by desc. size. This may fall on another 2k block within
// the current sector.
//
Offset += sizeof(VSD_GENERIC);
VolumeStructureDescriptor = (PVSD_GENERIC)(((PUCHAR)VolumeStructureDescriptor) + sizeof( VSD_GENERIC));
}
//
// If we were looking in the last session, and failed to find anything, then
// go back and try the first.
//
if (!FoundNSR && (0 != LastSessionStartPsn)) {
LastSessionStartPsn = 0;
goto Retry;
}
DebugTrace(( -1, Dbg, "IsUdfsVolume -> %c\n", ( FoundNSR ? 'T' : 'F' )));
//
// Free up our temporary buffer
//
if (Buffer) {
ExFreePool( Buffer );
}
return FoundNSR;
}
ULONG
UdfsFindInParseTable (
IN PPARSE_KEYVALUE ParseTable,
IN PCHAR Id,
IN ULONG MaxIdLen
)
/*++
Routine Description:
This routine walks a table of string key/value information for a match of the
input Id. MaxIdLen can be set to get a prefix match.
Arguments:
Table - This is the table being searched.
Id - Key value.
MaxIdLen - Maximum possible length of Id.
Return Value:
Value of matching entry, or the terminating (NULL) entry's value.
--*/
{
PAGED_CODE();
while (ParseTable->Key != NULL) {
if (RtlEqualMemory(ParseTable->Key, Id, MaxIdLen)) {
break;
}
ParseTable++;
}
return ParseTable->Value;
}