phys_lib.cpp File Reference

#include "phys_lib.h"

Include dependency graph for phys_lib.cpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	Vcb   ((PVCB)_Vcb)
#define	fms   FALSE
#define	TempMSF   toc->SessionData[index].Params.StartPositionOfLeadOut.MSF
#define	TempMSF   toc->SessionData[index].Params.StartPositionOfTrack.MSF
#define	TempMSF   toc->SessionData[index].Params.StartPositionOfTrack.MSF
#define	TempMSF   toc->SessionData[index].Params.StartPositionOfNextProgramArea.MaxLeadOut_MSF
#define	fms   FALSE
#define	TempMSF   toc->TrackData[TocEntry].LBA
#define	fms   FALSE
#define	fms   FALSE
#define	cap   ((PGET_CAPABILITIES_3_USER_OUT)ioBuf)

Functions
OSSTATUS	UDFSetSpeeds (IN PVCB Vcb)
NTSTATUS	UDFSetCaching (IN PVCB Vcb)
OSSTATUS	UDFRecoverFromError (IN PVCB Vcb, IN BOOLEAN WriteOp, IN OSSTATUS status, IN uint32 Lba, IN uint32 BCount, IN OUT uint32 *retry)
NTSTATUS	UDFSyncCache (IN PVCB Vcb)
OSSTATUS	UDFReallocTrackMap (IN PVCB Vcb, IN uint32 TrackNum)
OSSTATUS	UDFTWrite (IN void *_Vcb, IN void *Buffer, IN SIZE_T Length, IN uint32 LBA, OUT PSIZE_T WrittenBytes, IN uint32 Flags)
OSSTATUS	UDFTRead (IN void *_Vcb, IN void *Buffer, IN SIZE_T Length, IN uint32 LBA, OUT PSIZE_T ReadBytes, IN uint32 Flags)
NTSTATUS	UDFSetMRWMode (IN PVCB Vcb)
OSSTATUS	UDFDoOPC (IN PVCB Vcb)
OSSTATUS	UDFPrepareForWriteOperation (IN PVCB Vcb, IN uint32 Lba, IN uint32 BCount)
OSSTATUS	UDFReadDiscTrackInfo (PDEVICE_OBJECT DeviceObject, PVCB Vcb)
OSSTATUS	UDFReadAndProcessFullToc (PDEVICE_OBJECT DeviceObject, PVCB Vcb)
OSSTATUS	UDFUseStandard (PDEVICE_OBJECT DeviceObject, PVCB Vcb)
OSSTATUS	UDFGetBlockSize (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb)
OSSTATUS	UDFGetDiskInfo (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb)
OSSTATUS	UDFPrepareForReadOperation (IN PVCB Vcb, IN uint32 Lba, IN uint32 BCount)
void	UDFUpdateNWA (PVCB Vcb, uint32 LBA, uint32 BCount, OSSTATUS RC)
OSSTATUS	UDFWriteSectors (IN PVCB Vcb, IN BOOLEAN Translate, IN uint32 Lba, IN uint32 BCount, IN BOOLEAN Direct, IN int8 *Buffer, OUT PSIZE_T WrittenBytes)
OSSTATUS	UDFWriteInSector (IN PVCB Vcb, IN BOOLEAN Translate, IN uint32 Lba, IN uint32 i, IN uint32 l, IN BOOLEAN Direct, OUT int8 *Buffer, OUT PSIZE_T WrittenBytes)
OSSTATUS	UDFWriteData (IN PVCB Vcb, IN BOOLEAN Translate, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, IN int8 *Buffer, OUT PSIZE_T WrittenBytes)
OSSTATUS	UDFResetDeviceDriver (IN PVCB Vcb, IN PDEVICE_OBJECT TargetDeviceObject, IN BOOLEAN Unlock)

Variables
static const char	Signature [16] = {CDRW_SIGNATURE_v1}

Macro Definition Documentation

cap

GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum cap   ((PGET_CAPABILITIES_3_USER_OUT)ioBuf)

Definition at line 226 of file glfuncs.h.

Referenced by _mesa_IsEnabled(), ExecuteREBytecode(), GdipSetPenCustomEndCap(), GdipSetPenCustomStartCap(), GdipSetPenEndCap(), GdipSetPenStartCap(), gl_save_Disable(), gl_save_Enable(), mci_get_devcaps(), CustomLineCap::SetNativeCap(), test_create_adjustable_cap(), test_onevalue_cap(), test_physical(), test_resolution(), test_single_source(), and test_supported_sizes().

fms [1/4]

#define fms   FALSE

fms [2/4]

#define fms   FALSE

fms [3/4]

#define fms   FALSE

fms [4/4]

#define fms   FALSE

TempMSF [1/5]

#define TempMSF   toc->SessionData[index].Params.StartPositionOfLeadOut.MSF

TempMSF [2/5]

#define TempMSF   toc->SessionData[index].Params.StartPositionOfTrack.MSF

TempMSF [3/5]

#define TempMSF   toc->SessionData[index].Params.StartPositionOfTrack.MSF

TempMSF [4/5]

#define TempMSF   toc->SessionData[index].Params.StartPositionOfNextProgramArea.MaxLeadOut_MSF

TempMSF [5/5]

#define TempMSF   toc->TrackData[TocEntry].LBA

Vcb

IN PVCB Vcb   ((PVCB)_Vcb)

Definition at line 1415 of file cdprocs.h.

Referenced by __attribute__(), __brelse(), _Dispatch_type_(), _Function_class_(), _Requires_lock_held_(), _Requires_lock_not_held_(), _Success_(), add_balance_item(), add_calc_job_comp(), add_calc_job_decomp(), add_checksum_entry(), add_children_to_move_list(), add_csum_sparse_extents(), add_data_reloc(), add_data_reloc_extent_item(), add_device(), add_ext_holes(), add_metadata_reloc(), add_metadata_reloc_extent_item(), add_metadata_reloc_parent(), add_parents(), add_root_item_to_cache(), add_root_ref(), add_thread_job(), add_to_bootstrap(), add_trim_entry_avoid_sb(), add_volume_device(), AddBitmap(), AddFixupArray(), AddIndexAllocation(), AddIndexRoot(), AddRun(), allocate_cache(), allocate_cache_chunk(), allocate_tree_extents(), allow_extended_dasd_io(), balance_data_chunk(), balance_metadata_chunk(), bmap(), BrowseIndexEntries(), BrowseSubNodeIndexEntries(), calc_thread_main(), calc_tree_checksum(), CdCreateInternalStream(), CdDeleteFcb(), CdDeleteVcb(), CdFindActiveVolDescriptor(), CdFinishBuffers(), CdGetNextFcb(), CdInitializeVcb(), CdLookupFcbTable(), CdMarkDevForVerifyIfVcbMounted(), CdQueryFsAttributeInfo(), CdQueryFsDeviceInfo(), CdQueryFsSectorSizeInfo(), CdQueryFsSizeInfo(), CdRemoveClose(), CdUnlockVolumeInternal(), CdUpdateVcbFromVolDescriptor(), CdVerifyFcbOperation(), CdVerifyVcb(), check_csum(), check_for_orphans(), check_for_orphans_root(), check_inode_used(), check_sector_csum(), check_tree_checksum(), clean_space_cache(), clean_space_cache_chunk(), clear_free_space_cache(), construct_extent_item(), convert_old_extent(), create_chunk(), create_directory_fcb(), create_fcb(), create_fileref(), create_snapshot(), create_stream(), create_subvol(), CreateBTreeFromIndex(), CreateBTreeNodeFromIndexNode(), data_reloc_add_tree_edr(), decrease_extent_refcount(), decrease_extent_refcount_data(), decrease_extent_refcount_tree(), delete_root_ref(), delete_xattr(), dismount_volume(), do_calc_job(), do_create_snapshot(), do_flush(), do_splits(), do_tree_writes(), do_unlock_volume(), do_write(), do_write2(), do_write_job(), drop_chunk(), drop_root(), drop_roots(), duplicate_extents(), duplicate_fcb(), Ex2ProcessUserPerfStat(), Ext2AddBlockExtent(), Ext2AddEntry(), Ext2AddVcbExtent(), Ext2AllocateFcb(), Ext2AllocateInode(), Ext2AllocateMcb(), Ext2AllowExtendedDasdIo(), Ext2bhReaperThread(), Ext2BlockMap(), Ext2BuildEntry(), Ext2BuildExtents(), Ext2CheckBitmapConsistency(), Ext2CheckDismount(), Ext2CheckFileAccess(), Ext2CheckInodeAccess(), Ext2CheckJournal(), Ext2CheckSetBlock(), Ext2Cleanup(), Ext2CleanupAllMcbs(), Ext2ClearInode(), Ext2Close(), Ext2Create(), Ext2CreateFile(), Ext2CreateInode(), Ext2CreateVolume(), Ext2DeleteFile(), Ext2DeleteReparsePoint(), Ext2DestroyInode(), Ext2DestroyVcb(), Ext2DeviceControlNormal(), Ext2DiskShutDown(), Ext2DismountVolume(), Ext2DoExtentExpand(), Ext2DropBH(), Ext2DropGroupBH(), Ext2ExceptionFilter(), Ext2ExceptionHandler(), Ext2ExpandBlock(), Ext2ExpandExtent(), Ext2ExpandFile(), Ext2ExpandIndirect(), Ext2ExpandLast(), Ext2FastIoQueryStandardInfo(), Ext2FcbReaperThread(), Ext2FillEntry(), Ext2FirstUnusedMcb(), Ext2FloppyFlush(), Ext2Flush(), Ext2FlushFiles(), Ext2FlushRange(), Ext2FlushVcb(), Ext2FlushVolume(), Ext2FollowLink(), Ext2FreeBlock(), Ext2FreeCcb(), Ext2FreeFcb(), Ext2FreeInode(), Ext2GetBlock(), Ext2GetInodeLba(), Ext2GetReparsePoint(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2InitializeLabel(), Ext2InitializeVcb(), Ext2InitializeZone(), Ext2InsertFcb(), Ext2InsertMcb(), Ext2InsertVcb(), Ext2InvalidateVolumes(), Ext2IsFileRemovable(), Ext2IsHandleCountZero(), Ext2IsVolumeMounted(), Ext2IsWearingCloak(), Ext2LinkHeadMcb(), Ext2LinkTailMcb(), Ext2LoadBlock(), Ext2LoadBuffer(), Ext2LoadGroup(), Ext2LoadGroupBH(), Ext2LoadInode(), Ext2LoadInodeXattr(), Ext2LoadInternalJournal(), Ext2LoadSuper(), Ext2LockVcb(), Ext2LockVolume(), Ext2LookupBlockExtent(), Ext2LookupFile(), Ext2LookupVcbExtent(), Ext2MapExtent(), Ext2MapIndirect(), Ext2McbReaperThread(), Ext2MediaEjectControl(), Ext2MountVolume(), Ext2NewBlock(), Ext2NewInode(), Ext2NotifyChangeDirectory(), Ext2NotifyReportChange(), Ext2OEMToUnicode(), Ext2OEMToUnicodeSize(), Ext2OplockRequest(), Ext2OverwriteEa(), Ext2PerformRegistryVolumeParams(), Ext2ProcessEntry(), Ext2ProcessUserProperty(), Ext2ProcessVolumeProperty(), Ext2PurgeVolume(), Ext2PutGroup(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryExtentMappings(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2QueryUnusedBH(), Ext2QueryUnusedFcb(), Ext2QueryVolumeInformation(), Ext2QueryVolumeParams(), Ext2Read(), Ext2ReadDisk(), Ext2ReadFile(), Ext2ReadInode(), Ext2ReadSymlink(), Ext2ReadSync(), Ext2ReadVolume(), Ext2ReadWriteBlocks(), Ext2RecoverJournal(), Ext2RefreshSuper(), Ext2ReleaseFcb(), Ext2RemoveBlockExtent(), Ext2RemoveMcb(), Ext2RemoveVcb(), Ext2RemoveVcbExtent(), Ext2SaveBlock(), Ext2SaveBuffer(), Ext2SaveGroup(), Ext2SaveInode(), Ext2SaveInodeXattr(), Ext2SaveSuper(), Ext2ScanDir(), Ext2SearchMcb(), Ext2SetDispositionInfo(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetLinkInfo(), Ext2SetParentEntry(), Ext2SetRenameInfo(), Ext2SetReparsePoint(), Ext2SetVolumeInformation(), Ext2ShutDown(), Ext2StartFloppyFlushDpc(), Ext2SupersedeOrOverWriteFile(), Ext2TearDownStream(), Ext2TotalBlocks(), Ext2TruncateBlock(), Ext2TruncateExtent(), Ext2TruncateFile(), Ext2TruncateIndirect(), Ext2TruncateIndirectFast(), Ext2TruncateSymlink(), Ext2UnicodeToOEM(), Ext2UnicodeToOEMSize(), Ext2UnlinkFcb(), Ext2UnlinkMcb(), Ext2UnlockVcb(), Ext2UnlockVolume(), Ext2UpdateGroupDirStat(), Ext2UpdateVcbStat(), Ext2VerifyVcb(), Ext2VerifyVolume(), Ext2Write(), Ext2WriteFile(), Ext2WriteInode(), Ext2WriteSymlink(), Ext2WriteVolume(), Ext2ZeroBuffer(), ext3_inode_blocks(), ext3_inode_blocks_set(), ext4_check_descriptors(), ext4_inode_to_goal_block(), FatAddMcbEntry(), FatAllocateCloseContext(), FatAllowExtendedDasdIo(), FatAutoUnlock(), FatCheckDirtyBit(), FatCleanVolumeDpc(), FatCloseEaFile(), FatCommonQueryEa(), FatCommonSetEa(), FatComputeMoveFileSplicePoints(), FatCreateDcb(), FatCreateFcb(), FatCreateIrpContext(), FatDecodeFileObject(), FatDeferredCleanVolume(), FatDeferredFlush(), FatDeleteVcb(), FatExamineFatEntries(), FatFlushFat(), FatFlushFatEntries(), FatFspDispatch(), FatFspMarkVolumeDirtyWithRecover(), FatGetStatistics(), FatInterpretClusterType(), FatIsHandleCountZero(), FatIsVolumeDirty(), FatIsVolumeMounted(), FatLookupFatEntry(), FatMarkDevForVerifyIfVcbMounted(), FatMultipleAsync(), FatPagingFileErrorHandler(), FatPerformVerifyDiskRead(), FatPnpAdjustVpbRefCount(), FatPreallocateCloseContext(), FatQueryBpb(), FatQueryFsAttributeInfo(), FatQueryFsDeviceInfo(), FatQueryFsFullSizeInfo(), FatQueryFsSectorSizeInfo(), FatQueryFsSizeInfo(), FatQueryFsVolumeInfo(), FatQuickVerifyVcb(), FatReadEaSet(), FatReadVolumeFile(), FatSelectBestWindow(), FatSetFatRun(), FatSetFsLabelInfo(), FatSetRenameInfo(), FatSetupAllocationSupport(), FatSetZeroOnDeallocate(), FatSingleAsync(), FatSingleNonAlignedSync(), FatSwapVpb(), FatTearDownAllocationSupport(), FatTearDownVcb(), FatToggleMediaEjectDisable(), FatUnlockVolume(), FatUnlockVolumeInternal(), FatVerifyLookupFatEntry(), FatVerifyVcb(), FatZeroData(), fcb_load_csums(), file_create(), file_create2(), find_extent_data_refcount(), find_extent_shared_data_refcount(), find_extent_shared_tree_refcount(), find_metadata_address_in_chunk(), find_subvol(), FindAttribute(), FindFirstAttribute(), finish_removing_device(), FixupUpdateSequenceArray(), flush_changed_dev_stats(), flush_changed_extent(), flush_disk_caches(), flush_fcb_caches(), flush_partial_stripe(), flush_subvol(), free_vol(), FreeClusters(), fsctl_get_xattrs(), fsctl_oplock(), fsctl_request(), fsctl_set_xattr(), get_block_bh_mdl(), get_block_bh_pin(), get_csum_info(), get_devices(), get_ea_len(), get_extent_flags(), get_extent_refcount(), get_integrity_information(), get_reparse_tag(), get_retrieval_pointers(), get_sector_csum(), get_subvol_path(), get_tree_checksum(), get_tree_new_address(), get_usage(), GetBestFileNameFromRecord(), GetFileNameFromRecord(), GetStandardInformationFromRecord(), if(), increase_extent_refcount(), increase_extent_refcount_data(), IncreaseMftSize(), insert_extent_chunk(), insert_tree_extent(), insert_tree_extent_skinny(), insert_tree_item_batch(), invalidate_volumes(), is_device_part_of_mounted_btrfs_raid(), is_extent_unique(), is_tree_unique(), is_volume_dirty(), is_volume_mounted(), is_writable(), load_cache_chunk(), load_csum(), load_dir_children(), load_free_space_bitmap(), load_free_space_cache(), load_stored_free_space_cache(), load_stored_free_space_tree(), lock_volume(), log_error(), log_file_checksum_error(), log_file_checksum_error_shared(), log_tree_checksum_error(), log_tree_checksum_error_shared(), log_unrecoverable_error(), look_for_balance_item(), main(), mark_subvol_dirty(), mknod(), mountdev_query_stable_guid(), MupCleanupVcb(), MupCloseVcb(), MupDereferenceVcb(), MupInitializeVcb(), my_open(), my_retrieve_vol_type(), notify_change_directory(), NtfsAddFCBToTable(), NtfsAttachFCBToFileObject(), NtfsCreateFCB(), NtfsDirFindFile(), NtfsDumpFileAttributes(), NtfsDumpFileRecord(), NtfsFCBInitializeCache(), NtfsFindFileAt(), NtfsFindMftRecord(), NtfsGetFCBForFile(), NtfsGrabFCB(), NtfsGrabFCBFromTable(), NtfsLookupFile(), NtfsLookupFileAt(), NtfsMakeFCBFromDirEntry(), NtfsMakeRootFCB(), NtfsMountVolume(), NtfsOpenRootFCB(), NtfsReadFCBAttribute(), NtfsReleaseFCB(), open_fcb(), open_fcb_stream(), open_file(), open_file2(), open_file3(), open_fileref(), open_fileref_by_inode(), open_fileref_child(), OpenMupFileSystem(), oplock_complete(), partial_stripe_read(), pause_balance(), pause_scrub(), pnp_device_usage_notification(), pnp_query_remove_device(), pnp_remove_device(), pnp_surprise_removal(), print_open_trees(), PrintAllVCNs(), query_balance(), query_directory(), query_filesystems(), query_info(), query_scrub(), query_uuid(), RawCheckForDismount(), RawCleanup(), RawClose(), RawCreate(), RawDispatch(), RawFileSystemControl(), RawInitializeVcb(), RawQueryFsAttributeInfo(), RawQueryFsDeviceInfo(), RawQueryFsSizeInfo(), RawQueryFsVolumeInfo(), RawQueryInformation(), RawQueryVolumeInformation(), RawReadWriteDeviceControl(), RawSetInformation(), RawUserFsCtrl(), read_data(), read_data_dup(), read_data_raid0(), read_data_raid10(), read_data_raid5(), read_data_raid6(), read_send_buffer(), ReadAttribute(), ReadFileRecord(), ReadLCN(), recvd_subvol(), reduce_tree_extent(), regen_bootstrap(), regenerate_space_list(), registry_load_volume_options(), remove_balance_item(), remove_device(), remove_free_space_inode(), remove_from_bootstrap(), remove_root_extents(), remove_volume_child(), rename_file_to_stream(), rename_stream(), rename_stream_to_file(), reserve_subvol(), reset_stats(), resize_device(), resume_balance(), resume_scrub(), scrub_chunk(), scrub_chunk_raid56(), scrub_chunk_raid56_stripe_run(), scrub_data_extent(), scrub_extent(), scrub_extent_dup(), scrub_extent_raid0(), scrub_extent_raid10(), scrub_raid5_stripe(), scrub_raid6_stripe(), send_subvol(), set_basic_information(), set_disposition_information(), set_end_of_file_information(), set_file_security(), set_link_information(), set_rename_information(), set_sparse(), set_valid_data_length_information(), set_xattr(), set_zero_data(), SetNonResidentAttributeDataLength(), SetResidentAttributeDataLength(), shared_tree_is_unique(), should_balance_chunk(), snapshot_tree_copy(), split_path(), split_tree(), split_tree_at(), start_balance(), start_scrub(), stop_balance(), stop_scrub(), stream_set_end_of_file_information(), submit_bh_mdl(), submit_bh_pin(), sync_blockdev(), test_not_full(), trees_consistent(), trim_unalloc_space(), try_consolidation(), try_tree_amalgamate(), UDFAcquireDloc(), UDFAddXSpaceBitmap(), UDFAllocateFESpace(), UDFAllocFreeExtent_(), UDFAreSectorsRelocated(), UDFAssignAcl(), UDFAssingNewFUID(), UDFBlankMount(), UDFBuildAllocDescs(), UDFBuildFileEntry(), UDFBuildFreeSpaceBitmap(), UDFBuildHashEntry(), UDFBuildLongAllocDescs(), UDFBuildShortAllocDescs(), UDFBuildTreeItemsList(), UDFChangeFileCounter(), UDFCheckArea(), UDFCheckForDismount(), UDFCleanUpFcbChain(), UDFCleanUpFile__(), UDFCleanupVCB(), UDFCloseAllDelayed(), UDFCloseAllXXXDelayedInDir(), UDFCloseFile__(), UDFCloseFileInfoChain(), UDFCloseResidual(), UDFClrModified(), UDFCommonCleanup(), UDFCommonClose(), UDFCommonCreate(), UDFCommonDeviceControl(), UDFCommonDirControl(), UDFCommonDispatch(), UDFCommonFileInfo(), UDFCommonFlush(), UDFCommonPnp(), UDFCommonQueryVolInfo(), UDFCommonRead(), UDFCommonSetVolInfo(), UDFCommonShutdown(), UDFCommonWrite(), UDFCompleteMount(), UDFConvertFEToExtended(), UDFConvertFEToNonInICB(), UDFCreateFile__(), UDFCreateRootFile__(), UDFCreateStreamDir__(), UDFDiscardFESpace(), UDFDismountVcb(), UDFDismountVolume(), UDFDoDismountSequence(), UDFDoOPC(), UDFDOSName(), UDFEjectReqWaiter(), UDFExtAllocDescToMapping(), UDFExtentOffsetToLba(), UDFFileDirInfoToNT(), UDFFindAnchor(), UDFFindDloc(), UDFFindDlocInMem(), UDFFindFile(), UDFFindFile__(), UDFFindFileId(), UDFFindFreeDloc(), UDFFindFreeFileId(), UDFFindLastFileSet(), UDFFindMinSuitableExtent(), UDFFindNextMatch(), UDFFindVRS(), UDFFirstOpenFile(), UDFFlushADirectory(), UDFFlushAllCachedAllocations(), UDFFlushFE(), UDFFlushFESpace(), UDFFlushFI(), UDFFlushFile__(), UDFFlushIsBreaking(), UDFFlushLogicalVolume(), UDFFlushTryBreak(), UDFFreeDloc(), UDFFreeFESpace(), UDFFreeFileAllocation(), UDFGetBlockSize(), UDFGetCachedAllocation(), UDFGetCfgParameter(), UDFGetDiskInfo(), UDFGetDiskInfoAndVerify(), UDFGetFileStreamInformation(), UDFGetFreeSpace(), UDFGetInternalInformation(), UDFGetMediaClass(), UDFGetOpenParamsByFileId(), UDFGetPartFreeSpace(), UDFGetPartNumByPhysLba(), UDFGetRegParameter(), UDFGetRetrievalPointers(), UDFGetStatistics(), UDFGetTotalSpace(), UDFGetVolumeBitmap(), UDFHardLink(), UDFHardLinkFile__(), UDFIndexDirectory(), UDFInitAllocationCache(), UDFInitializeFCB(), UDFInitializeVCB(), UDFInvalidateVolumes(), UDFIsCachedBadSequence(), UDFIsExtentCached(), UDFIsNameInExpression(), UDFIsVolumeDirty(), UDFLoadBogusLogicalVol(), UDFLoadExtInfo(), UDFLoadFileset(), UDFLoadLogicalVol(), UDFLoadLogicalVolInt(), UDFLoadPartDesc(), UDFLoadPartition(), UDFLoadPVolDesc(), UDFLoadSparingTable(), UDFLoadVAT(), UDFLocateLbaInExtent(), UDFLockVolume(), UDFLongAllocDescToMapping(), UDFLookUpAcl(), UDFMarkAllocatedAsNotXXX(), UDFMarkAllocatedAsRecorded(), UDFMarkBadSpaceAsUsed(), UDFMarkNotAllocatedAsAllocated(), UDFMarkSpaceAsXXX_(), UDFMarkSpaceAsXXXNoProtect_(), UDFMarkStreamsForDeletion(), UDFMountVolume(), UDFNotifyChangeDirectory(), UDFOpenFile(), UDFOpenFile__(), UDFOpenRootFile__(), UDFOpenStreamDir__(), UDFPackDirectory__(), UDFPackMapping(), UDFPadLastSector(), UDFPartEnd(), UDFPartLbaToPhys(), UDFPartLen(), UDFPartStart(), UDFPerformVerify(), UDFPhReadSynchronous(), UDFPhWriteSynchronous(), UDFPhysLbaToPart(), UDFPnpQueryRemove(), UDFPnpRemove(), UDFPnpSurpriseRemove(), UDFPostRequest(), UDFPreClrModified(), UDFPrepareForReadOperation(), UDFPrepareForRenameMoveLink(), UDFPrepareForWriteOperation(), UDFPrepareXSpaceBitmap(), UDFProcessSequence(), UDFPurgeCacheEx_(), UDFQueryDirectory(), UDFQueryFsAttributeInfo(), UDFQueryFsDeviceInfo(), UDFQueryFsFullSizeInfo(), UDFQueryFsSizeInfo(), UDFQueryFsVolumeInfo(), UDFReadAndProcessFullToc(), UDFReadDiscTrackInfo(), UDFReadEntityID_Domain(), UDFReadExtent(), UDFReadExtentLocation(), UDFReadFile__(), UDFReadFileEntry(), UDFReadFileLocation__(), UDFReadMappingFromXEntry(), UDFReadRegKeys(), UDFReadSecurity(), UDFReadTagged(), UDFReadVDS(), UDFReallocTrackMap(), UDFRecordDirectory__(), UDFRecordVAT(), UDFRecoverFromError(), UDFReleaseDloc(), UDFReleaseDlocList(), UDFReleaseFileIdCache(), UDFReleaseVCB(), UDFRelocateDloc(), UDFRelocateSector(), UDFRelocateSectors(), UDFRemapPacket(), UDFRememberBadSequence(), UDFRemoveDloc(), UDFRemoveFileId(), UDFRename(), UDFRenameMoveFile__(), UDFResetDeviceDriver(), UDFResizeExtent(), UDFResizeFile__(), UDFReTagDirectory(), UDFScanForDismountedVcb(), UDFSetAllocationInformation(), UDFSetAllocDescLen(), UDFSetCaching(), UDFSetDispositionInformation(), UDFSetEOF(), UDFSetFileAllocModeFromICB(), UDFSetFileUID(), UDFSetLabelInfo(), UDFSetModified(), UDFSetMRWMode(), UDFSetSpeeds(), UDFSetUpTag(), UDFShortAllocDescToMapping(), UDFSparseFile__(), UDFStartEjectWaiter(), UDFStopEjectWaiter(), UDFStoreCachedAllocation(), UDFStoreDloc(), UDFStoreFileId(), UDFSyncCache(), UDFTRead(), UDFTSendIOCTL(), UDFTWrite(), UDFUmount__(), UDFUnlinkAllFilesInDir(), UDFUnlinkDloc(), UDFUnlinkFile__(), UDFUnlockVolume(), UDFUnmapRange(), UDFUnPackMapping(), UDFUpdateCompatOption(), UDFUpdateLogicalVol(), UDFUpdateLogicalVolInt(), UDFUpdateNonAllocated(), UDFUpdateNWA(), UDFUpdatePartDesc(), UDFUpdateSparingTable(), UDFUpdateVAT(), UDFUpdateVDS(), UDFUpdateVolIdent(), UDFUpdateXSpaceBitmaps(), UDFUseStandard(), UDFVerifyFreeSpaceBitmap(), UDFVerifyPartDesc(), UDFVerifySequence(), UDFVerifyVcb(), UDFVerifyVolume(), UDFVerifyXSpaceBitmap(), UDFVFlush(), UDFVForget(), UDFVInit(), UDFVIsStored(), UDFVRead(), UDFVRelease(), UDFVStoreBlock(), UDFVUpdateBlock(), UDFVVerify(), UDFVWorkItem(), UDFVWrite(), UDFWriteData(), UDFWriteExtent(), UDFWriteFile__(), UDFWriteInSector(), UDFWriteSectors(), UDFWriteSecurity(), UDFZeroExtent(), UDFZeroFile__(), unlock_volume(), update_backup_superblock(), update_changed_extent_ref(), update_chunk_cache(), update_chunk_cache_tree(), update_chunk_caches(), update_chunk_caches_tree(), update_chunk_usage(), update_chunks(), update_dev_item(), update_extent_flags(), update_extent_level(), update_root_backref(), update_root_root(), update_tree_extents(), update_tree_extents_recursive(), update_volumes(), UpdateFileNameRecord(), UpdateFileRecord(), UpdateIndexEntryFileNameSize(), UpdateMftMirror(), verify_vcb(), VfatCloseWorker(), VfatDiskShutDown(), vfatInitFCBFromDirEntry(), VfatPnp(), write(), write_metadata_items(), write_superblock(), write_superblocks(), write_trees(), WriteAttribute(), and zero_data().

Function Documentation

UDFDoOPC()

OSSTATUS UDFDoOPC

(

IN PVCB

Vcb

)

Definition at line 850 of file phys_lib.cpp.

{
    OSSTATUS RC;
    if(Vcb->OPCNum && !Vcb->OPCDone) {
        UDFPrint(("UDFDoOPC\n"));
        if(!Vcb->OPCh) {
            Vcb->OPCh =
                (PSEND_OPC_INFO_HEADER_USER_IN)MyAllocatePool__(NonPagedPool,
                    sizeof(SEND_OPC_INFO_HEADER_USER_IN) );
        }
        if(!Vcb->OPCh)
            return STATUS_INSUFFICIENT_RESOURCES;
        Vcb->OPCh->DoOpc = TRUE;
        Vcb->OPCh->OpcBlocksNumber = 0;
        RC = UDFPhSendIOCTL(IOCTL_CDRW_SEND_OPC_INFO, Vcb->TargetDeviceObject,
                        (void*)(Vcb->OPCh),sizeof(SEND_OPC_INFO_HEADER_USER_IN),
                        NULL,0,
                        FALSE, NULL);
        if(!OS_SUCCESS(RC)) {
            UDFPrint(("UDFDoOPC failed\n"));
            Vcb->OPCNum = 0;
//            Vcb->VCBFlags |= UDF_VCB_FLAGS_OPC_FAILED;
        }
        Vcb->OPCDone = TRUE;
    }
    return RC;
} // end UDFDoOPC()

Referenced by UDFPrepareForWriteOperation().

UDFGetBlockSize()

OSSTATUS UDFGetBlockSize	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVCB	Vcb
	)

Definition at line 2687 of file phys_lib.cpp.

{
    OSSTATUS        RC = STATUS_SUCCESS;
    PDISK_GEOMETRY  DiskGeometry = (PDISK_GEOMETRY)MyAllocatePool__(NonPagedPool,sizeof(DISK_GEOMETRY));
    PPARTITION_INFORMATION  PartitionInfo = (PPARTITION_INFORMATION)MyAllocatePool__(NonPagedPool,sizeof(PARTITION_INFORMATION)*2);
#ifdef UDF_FORMAT_MEDIA
    PUDFFmtState            fms = Vcb->fms;
#else
  #define fms FALSE
#endif //UDF_FORMAT_MEDIA
 
    if(!DiskGeometry || !PartitionInfo)
        try_return (RC = STATUS_INSUFFICIENT_RESOURCES);
 
#ifdef _BROWSE_UDF_
 
#ifdef UDF_HDD_SUPPORT
    if(!fms) {
        if(UDFGetDevType(DeviceObject) == FILE_DEVICE_DISK) {
            UDFPrint(("UDFGetBlockSize: HDD\n"));
            RC = UDFPhSendIOCTL(IOCTL_DISK_GET_DRIVE_GEOMETRY,DeviceObject,
                0,NULL,
                DiskGeometry,sizeof(DISK_GEOMETRY),
                TRUE,NULL );
            Vcb->BlockSize = (OS_SUCCESS(RC)) ? DiskGeometry->BytesPerSector : 512;
            if(!NT_SUCCESS(RC))
                try_return(RC);
            RC = UDFPhSendIOCTL(IOCTL_DISK_GET_PARTITION_INFO,DeviceObject,
                0,NULL,
                PartitionInfo,sizeof(PARTITION_INFORMATION),
                TRUE,NULL );
            if(!NT_SUCCESS(RC)) {
                UDFPrint(("UDFGetBlockSize: IOCTL_DISK_GET_PARTITION_INFO failed\n"));
                if(RC == STATUS_INVALID_DEVICE_REQUEST) /* ReactOS Code Change (was =) */
                    RC = STATUS_UNRECOGNIZED_VOLUME;
                try_return(RC);
            }
            if(PartitionInfo->PartitionType != PARTITION_IFS) {
                UDFPrint(("UDFGetBlockSize: PartitionInfo->PartitionType != PARTITION_IFS\n"));
                try_return(RC = STATUS_UNRECOGNIZED_VOLUME);
            }
        } else {
#endif //UDF_HDD_SUPPORT
            RC = UDFPhSendIOCTL(IOCTL_CDROM_GET_DRIVE_GEOMETRY,DeviceObject,
                DiskGeometry,sizeof(DISK_GEOMETRY),
                DiskGeometry,sizeof(DISK_GEOMETRY),
                TRUE,NULL );
 
            if(RC == STATUS_DEVICE_NOT_READY) {
                // probably, the device is really busy, may be by CD/DVD recording
                UserPrint(("  busy (0)\n"));
                try_return(RC);
            }
 
            Vcb->BlockSize = (OS_SUCCESS(RC)) ? DiskGeometry->BytesPerSector : 2048;
#ifdef UDF_HDD_SUPPORT
        }
    }
#endif //UDF_HDD_SUPPORT
 
#endif //_BROWSE_UDF_
 
#ifdef UDF_FORMAT_MEDIA
    if(fms) {
        RC = UDFPhSendIOCTL(IOCTL_CDROM_GET_DRIVE_GEOMETRY,DeviceObject,
            DiskGeometry,sizeof(DISK_GEOMETRY),
            DiskGeometry,sizeof(DISK_GEOMETRY),
            FALSE, NULL );
 
        if(!NT_SUCCESS(RC)) {
            RC = UDFPhSendIOCTL(IOCTL_DISK_GET_DRIVE_GEOMETRY,DeviceObject,
                DiskGeometry,sizeof(DISK_GEOMETRY),
                DiskGeometry,sizeof(DISK_GEOMETRY),
                FALSE, NULL );
            if(NT_SUCCESS(RC)) {
                fms->opt_media = MT_HD;
                RC = UDFPhSendIOCTL(IOCTL_DISK_GET_PARTITION_INFO,DeviceObject,
                    NULL,0,
                    PartitionInfo,sizeof(PARTITION_INFORMATION)*2,
                    FALSE, NULL );
                if(!NT_SUCCESS(RC)) {
                    LONG HiOffs=0;
                    RC = SetFilePointer(DeviceObject->h,0,&HiOffs,FILE_END);
                }
            }
        }
 
        if(RC == STATUS_DEVICE_NOT_READY) {
            // probably, the device is really busy, may be by CD/DVD recording
            UserPrint(("  busy\n"));
            try_return(RC );
        }
 
        Vcb->BlockSize = (NT_SUCCESS(RC)) ? DiskGeometry->BytesPerSector : 2048;
    }
#endif //UDF_FORMAT_MEDIA
 
    // Block size must be an even multiple of 512
    switch (Vcb->BlockSize) {
        case 2048: Vcb->BlockSizeBits = 11; break;
#ifdef UDF_HDD_SUPPORT
        case 512:  Vcb->BlockSizeBits = 9; break;
        case 1024: Vcb->BlockSizeBits = 10; break;
        case 4096: Vcb->BlockSizeBits = 12; break;
        case 8192: Vcb->BlockSizeBits = 13; break;
#endif //UDF_HDD_SUPPORT
        default:
        {
            UserPrint(("UDF: Bad block size (%ld)\n", Vcb->BlockSize));
            try_return(RC = STATUS_UNSUCCESSFUL);
        }
    }
 
#ifdef UDF_HDD_SUPPORT
    if(
#ifdef _BROWSE_UDF_
        (!fms && (UDFGetDevType(DeviceObject) == FILE_DEVICE_DISK))
                         ||
#endif //_BROWSE_UDF_
#ifdef UDF_FORMAT_MEDIA
        (fms && fms->opt_media == MT_HD)
                         ||
#endif //UDF_FORMAT_MEDIA
         FALSE ) {
 
#ifdef UDF_FORMAT_MEDIA
        if(fms && !NT_SUCCESS(RC))
            try_return(STATUS_UNSUCCESSFUL);
#endif //UDF_FORMAT_MEDIA
 
        Vcb->FirstLBA=0;//(ULONG)(PartitionInfo->StartingOffset.QuadPart >> Vcb->BlockSizeBits);
        Vcb->LastPossibleLBA =
        Vcb->LastLBA = (uint32)(PartitionInfo->PartitionLength.QuadPart >> Vcb->BlockSizeBits)/* + Vcb->FirstLBA*/ - 1;
    } else {
#endif //UDF_HDD_SUPPORT
        Vcb->FirstLBA=0;
        if(OS_SUCCESS(RC)) {
            Vcb->LastLBA = (uint32)(DiskGeometry->Cylinders.QuadPart *
                                    DiskGeometry->TracksPerCylinder *
                                    DiskGeometry->SectorsPerTrack - 1);
            if(Vcb->LastLBA == 0x7fffffff) {
                Vcb->LastLBA = UDFIsDvdMedia(Vcb) ? DEFAULT_LAST_LBA_DVD : DEFAULT_LAST_LBA_FP_CD;
            }
        } else {
            Vcb->LastLBA = UDFIsDvdMedia(Vcb) ? DEFAULT_LAST_LBA_DVD : DEFAULT_LAST_LBA_FP_CD;
        }
        Vcb->LastPossibleLBA = Vcb->LastLBA;
#ifdef UDF_HDD_SUPPORT
    }
#endif //UDF_HDD_SUPPORT
 
#ifdef _BROWSE_UDF_
//    if(UDFGetDevType(DeviceObject) == FILE_DEVICE_DISK) {
        Vcb->WriteBlockSize = PACKETSIZE_UDF*Vcb->BlockSize;
//    } else {
//        Vcb->WriteBlockSize = PACKETSIZE_UDF*Vcb->BlockSize;
//    }
#else //_BROWSE_UDF_
    if(fms->opt_media == MT_HD) {
        Vcb->WriteBlockSize = Vcb->BlockSize;
    } else {
        Vcb->WriteBlockSize = PACKETSIZE_UDF*Vcb->BlockSize;
    }
#endif //_BROWSE_UDF_
 
    RC = STATUS_SUCCESS;
 
try_exit:   NOTHING;
 
    UDFPrint(("UDFGetBlockSize:\nBlock size is %x, Block size bits %x, Last LBA is %x\n",
              Vcb->BlockSize, Vcb->BlockSizeBits, Vcb->LastLBA));
 
    MyFreePool__(PartitionInfo);
    MyFreePool__(DiskGeometry);
    return RC;
 
} // end UDFGetBlockSize()

Referenced by UDFGetDiskInfo().

UDFGetDiskInfo()

OSSTATUS UDFGetDiskInfo	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVCB	Vcb
	)

Definition at line 3050 of file phys_lib.cpp.

{
    OSSTATUS        RC = STATUS_UNRECOGNIZED_VOLUME;
    int8*           ioBuf = (int8*)MyAllocatePool__(NonPagedPool,4096);
    uint8 MediaType;
    PLUN_WRITE_PERF_DESC_USER WPerfDesc;
    uint32 i;
//    BOOLEAN MRW_problem = FALSE;
    uint32 SavedFeatures = 0;
#ifdef UDF_FORMAT_MEDIA
    PUDFFmtState            fms = Vcb->fms;
#else
  #define fms FALSE
#endif //UDF_FORMAT_MEDIA
 
    UDFPrint(("UDFGetDiskInfo\n"));
 
    if(!ioBuf) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    _SEH2_TRY {
        RC = UDFGetBlockSize(DeviceObject, Vcb);
        if(!OS_SUCCESS(RC)) try_return(RC);
 
 
        // Get lower driver signature
        RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_SIGNATURE,DeviceObject,
            ioBuf,sizeof(GET_SIGNATURE_USER_OUT),
            ioBuf,sizeof(GET_SIGNATURE_USER_OUT),
            TRUE,NULL);
 
        if(!OS_SUCCESS(RC)) {
 
            RC = UDFUseStandard(DeviceObject, Vcb);
#ifdef _BROWSE_UDF_
            if(!NT_SUCCESS(RC) || fms)
                try_return(RC);
 
            // assume Device Recordable for now
            goto GetSignatureFailed;
#endif //_BROWSE_UDF_
        }
 
        UDFPrint(("UDF: Signature of low driver is : %s \n",
            ((PGET_SIGNATURE_USER_OUT)(ioBuf))->VendorId));
 
        if(!strncmp( (const char *)(&( ((PGET_SIGNATURE_USER_OUT)(ioBuf))->VendorId[0]) ),
            Signature,strlen(Signature) )) {
            UDFPrint(("UDF: *****************************************\n"));
            UDFPrint(("UDF: ********* Our Device Driver Found ******\n"));
            UDFPrint(("UDF: *****************************************\n"));
 
            (Vcb->VCBFlags) |= UDF_VCB_FLAGS_OUR_DEVICE_DRIVER;
#ifndef _BROWSE_UDF_
            // reset driver
#ifdef UDF_FORMAT_MEDIA
            if(!fms->opt_probe) {
#endif //UDF_FORMAT_MEDIA
                UDFResetDeviceDriver(Vcb, Vcb->TargetDeviceObject, FALSE);
                // lock it
                ((PPREVENT_MEDIA_REMOVAL_USER_IN)(ioBuf))->PreventMediaRemoval = TRUE;
                UDFPhSendIOCTL( IOCTL_STORAGE_MEDIA_REMOVAL,
                                     DeviceObject,
                                     ioBuf,sizeof(PREVENT_MEDIA_REMOVAL_USER_IN),
                                     NULL,0,
                                     FALSE, NULL);
#ifdef UDF_FORMAT_MEDIA
            }
#endif //UDF_FORMAT_MEDIA
#endif //_BROWSE_UDF_
//#else //_BROWSE_UDF_
            // get device features
            UDFPhSendIOCTL( IOCTL_CDRW_GET_DEVICE_INFO,
                                 DeviceObject,
                                 NULL,0,
                                 ioBuf,sizeof(GET_DEVICE_INFO_USER_OUT),
                                 FALSE,NULL);
 
            Vcb->SavedFeatures =
                SavedFeatures = ((PGET_DEVICE_INFO_USER_OUT)ioBuf)->Features;
            if(!(SavedFeatures & CDRW_FEATURE_SYNC_ON_WRITE)) {
                UDFPrint(("UDFGetDiskInfo: UDF_VCB_IC_NO_SYNCCACHE_AFTER_WRITE\n"));
                Vcb->CompatFlags |= UDF_VCB_IC_NO_SYNCCACHE_AFTER_WRITE;
            }
            if(!(SavedFeatures & CDRW_FEATURE_FORCE_SYNC_BEFORE_READ)) {
                UDFPrint(("UDFGetDiskInfo: UDF_VCB_IC_SYNCCACHE_BEFORE_READ\n"));
                Vcb->CompatFlags |= UDF_VCB_IC_SYNCCACHE_BEFORE_READ;
            }
            if(SavedFeatures & CDRW_FEATURE_BAD_RW_SEEK) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_BAD_RW_SEEK\n"));
                Vcb->CompatFlags |= UDF_VCB_IC_BAD_RW_SEEK;
            }
            // we must check if this is FP-formatted disk in old devices
            // independently of MediaType they report
            if(SavedFeatures & CDRW_FEATURE_FP_ADDRESSING_PROBLEM) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_FP_ADDRESSING_PROBLEM ?\n"));
                Vcb->CompatFlags |= UDF_VCB_IC_FP_ADDR_PROBLEM;
            }
            if(SavedFeatures & CDRW_FEATURE_MRW_ADDRESSING_PROBLEM) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_MRW_ADDRESSING_PROBLEM ?\n"));
            }
            if(SavedFeatures & CDRW_FEATURE_FORCE_SYNC_ON_WRITE) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_FORCE_SYNC_ON_WRITE\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_FORCE_SYNC_CACHE;
            }
            if(SavedFeatures & CDRW_FEATURE_BAD_DVD_LAST_LBA) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_BAD_DVD_LAST_LBA\n"));
                Vcb->CompatFlags |= UDF_VCB_IC_BAD_DVD_LAST_LBA;
            }
            if(SavedFeatures & CDRW_FEATURE_STREAMING) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_STREAMING\n"));
            }
            if(SavedFeatures & CDRW_FEATURE_OPC) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_OPC -> assume OPCNum=1\n"));
                Vcb->OPCNum = 1;
            }
#ifdef UDF_FORMAT_MEDIA
            if(SavedFeatures & CDRW_FEATURE_FULL_BLANK_ON_FORMAT) {
                UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_FULL_BLANK_ON_FORMAT\n"));
                if((fms->opt_probe || fms->opt_smart_f)/* &&
                   (fms->format_media && fms->blank_media*/) {
                    UDFPrint(("UDFGetDiskInfo: force Full Erase\n"));
                    fms->opt_qblank = FALSE;
                }
            }
#endif //UDF_FORMAT_MEDIA
#ifdef _BROWSE_UDF_
            // get device buffer size
            RC = UDFPhSendIOCTL( IOCTL_CDRW_BUFFER_CAPACITY,
                                 DeviceObject,
                                 NULL,0,
                                 ioBuf,sizeof(BUFFER_CAPACITY_BLOCK_USER_OUT),
                                 FALSE,NULL);
            if(NT_SUCCESS(RC)) {
                Vcb->CdrwBufferSize = ((PBUFFER_CAPACITY_BLOCK_USER_OUT)ioBuf)->BufferLength;
            } else {
                Vcb->CdrwBufferSize = 0;
            }
            UDFPrint(("UDFGetDiskInfo: CdrwBufferSize = %dKb\n", Vcb->CdrwBufferSize / 1024));
            Vcb->CdrwBufferSizeCounter = 0;
#endif //_BROWSE_UDF_
            // get media type
            RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_MEDIA_TYPE,DeviceObject,
                    NULL,0,ioBuf,sizeof(GET_MEDIA_TYPE_USER_OUT),
                    FALSE, NULL);
            if(!OS_SUCCESS(RC)) goto Try_FullToc;
            Vcb->MediaType =
            MediaType = ((PGET_MEDIA_TYPE_USER_OUT)ioBuf)->MediaType;
            UDFPrint(("UDFGetDiskInfo: MediaType %x\n", MediaType));
 
#ifndef UDF_FORMAT_MEDIA
            // we shall ignore audio-disks
            switch(MediaType) {
            case MediaType_120mm_CDROM_AudioOnly:
            case MediaType_80mm_CDROM_AudioOnly:
            case MediaType_120mm_CDR_AudioOnly:
            case MediaType_80mm_CDR_AudioOnly:
            case MediaType_120mm_CDRW_AudioOnly:
            case MediaType_80mm_CDRW_AudioOnly:
//            case :
                UDFPrint(("UDFGetDiskInfo: we shall ignore audio-disks...\n"));
                try_return(RC = STATUS_UNRECOGNIZED_VOLUME);
            }
#endif //UDF_FORMAT_MEDIA
 
            UDFPrint(("UDFGetDiskInfo: Check DVD-disks...\n"));
            RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_MEDIA_TYPE_EX,DeviceObject,
                    NULL,0,ioBuf,sizeof(GET_MEDIA_TYPE_EX_USER_OUT),
                    FALSE, NULL);
            if(!OS_SUCCESS(RC)) goto Try_FullToc;
            Vcb->MediaClassEx =
            MediaType = (((PGET_MEDIA_TYPE_EX_USER_OUT)ioBuf)->MediaClass);
            UDFPrint(("UDFGetDiskInfo: MediaClassEx %x\n", MediaType));
 
#ifdef _BROWSE_UDF_
            if(!fms) {
 
                switch(MediaType) {
 
                case CdMediaClass_CDR:
                case CdMediaClass_DVDR:
                case CdMediaClass_DVDpR:
                case CdMediaClass_HD_DVDR:
                case CdMediaClass_BDR:
                    UDFPrint(("UDFGetDiskInfo: MediaClass R\n"));
                    Vcb->MediaType = MediaType_UnknownSize_CDR;
                    break;
                case CdMediaClass_CDRW:
 
                    if(SavedFeatures & CDRW_FEATURE_MRW_ADDRESSING_PROBLEM) {
                        UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_MRW_ADDRESSING_PROBLEM on CD-RW\n"));
                        Vcb->CompatFlags |= UDF_VCB_IC_MRW_ADDR_PROBLEM;
                    }
 
                case CdMediaClass_DVDRW:
                case CdMediaClass_DVDpRW:
                case CdMediaClass_DVDRAM:
                case CdMediaClass_HD_DVDRW:
                case CdMediaClass_HD_DVDRAM:
                case CdMediaClass_BDRE:
                    UDFPrint(("UDFGetDiskInfo: MediaClass RW\n"));
                    Vcb->MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_CDROM:
                case CdMediaClass_DVDROM:
                case CdMediaClass_HD_DVDROM:
                case CdMediaClass_BDROM:
                    UDFPrint(("UDFGetDiskInfo: MediaClass ROM\n"));
                    Vcb->MediaType = MediaType_Unknown;
    //                    Vcb->MediaType = MediaType_UnknownSize_CDROM;
                    break;
                default:
                    UDFPrint(("UDFGetDiskInfo: MediaClass Unknown\n"));
                    Vcb->MediaType = MediaType_Unknown;
                    break;
                }
                MediaType = Vcb->MediaType;
 
            }
#endif //_BROWSE_UDF_
 
#ifdef UDF_FORMAT_MEDIA
 
            if(fms) {
 
                switch(MediaType) {
                case CdMediaClass_CDR:
                    UDFPrint(("CdMediaClass_CDR\n"));
                    MediaType = MediaType_UnknownSize_CDR;
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_CDR;
                    break;
                case CdMediaClass_DVDR:
                    UDFPrint(("CdMediaClass_DVDR -> MediaType_UnknownSize_CDR\n"));
                    MediaType = MediaType_UnknownSize_CDR;
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDR;
                    break;
                case CdMediaClass_DVDpR:
                    UDFPrint(("CdMediaClass_DVDpR -> MediaType_UnknownSize_CDR\n"));
                    MediaType = MediaType_UnknownSize_CDR;
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDpR;
                    break;
                case CdMediaClass_HD_DVDR:
                    UDFPrint(("CdMediaClass_HD_DVDR -> MediaType_UnknownSize_CDR\n"));
                    MediaType = MediaType_UnknownSize_CDR;
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDR;
                    break;
                case CdMediaClass_BDR:
                    UDFPrint(("CdMediaClass_BDR -> MediaType_UnknownSize_CDR\n"));
                    MediaType = MediaType_UnknownSize_CDR;
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDR;
                    break;
                case CdMediaClass_CDRW:
                    UDFPrint(("CdMediaClass_CDRW\n"));
                    MediaType = MediaType_UnknownSize_CDRW;
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_CDRW;
                    if(SavedFeatures & CDRW_FEATURE_MRW_ADDRESSING_PROBLEM) {
                        UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_MRW_ADDRESSING_PROBLEM on CD-RW\n"));
                        Vcb->CompatFlags |= UDF_VCB_IC_MRW_ADDR_PROBLEM;
                    }
                    break;
                case CdMediaClass_DVDRW:
                    UDFPrint(("  CdMediaClass_DVDRW -> MediaType_UnknownSize_CDRW\n"));
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDRW;
                    MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_DVDpRW:
                    UDFPrint(("  CdMediaClass_DVDpRW -> MediaType_UnknownSize_CDRW\n"));
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDpRW;
                    MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_DVDRAM:
                    UDFPrint(("  CdMediaClass_DVDRAM -> MediaType_UnknownSize_CDRW\n"));
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDRAM;
                    MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_HD_DVDRW:
                    UDFPrint(("  CdMediaClass_HD_DVDRW -> MediaType_UnknownSize_CDRW\n"));
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDRW;
                    MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_HD_DVDRAM:
                    UDFPrint(("  CdMediaClass_HD_DVDRAM -> MediaType_UnknownSize_CDRW\n"));
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDRAM;
                    MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_BDRE:
                    UDFPrint(("  CdMediaClass_BDRE -> MediaType_UnknownSize_CDRW\n"));
                    if(fms->opt_media == MT_AUTO)
                        fms->opt_media = MT_DVDRW;
                    MediaType = MediaType_UnknownSize_CDRW;
                    break;
                case CdMediaClass_NoDiscPresent:
                    UDFPrint(("  CdMediaClass_NoDiscPresent -> MediaType_NoDiscPresent\n"));
                    MediaType = MediaType_NoDiscPresent;
                    fms->opt_media = MT_none;
                    break;
                case CdMediaClass_DoorOpen:
                    UDFPrint(("  CdMediaClass_DoorOpen -> MediaType_DoorOpen\n"));
                    MediaType = MediaType_DoorOpen;
                    fms->opt_media = MT_none;
                    break;
                default:
                    UDFPrint(("  MediaType_Unknown\n"));
                    MediaType = MediaType_Unknown;
                    break;
                }
                if(!apply_force_r(fms)) {
                    my_exit(fms, MKUDF_CANT_APPLY_R);
                }
            }
 
#endif //UDF_FORMAT_MEDIA
 
            Vcb->DVD_Mode = (((PGET_MEDIA_TYPE_EX_USER_OUT)ioBuf)->MediaClassEx == CdMediaClassEx_DVD);
            Vcb->PhMediaCapFlags = ((PGET_MEDIA_TYPE_EX_USER_OUT)ioBuf)->CapFlags;
            Vcb->WriteParamsReq = (Vcb->PhMediaCapFlags & CdCapFlags_WriteParamsReq) ? TRUE : FALSE;
            if(Vcb->DVD_Mode &&
                !(Vcb->PhMediaCapFlags & CdCapFlags_RandomWritable)) {
                UDFPrint(("UDFGetDiskInfo: DVD && !CdCapFlags_RandomWritable\n"));
                UDFPrint(("  Read-only volume\n"));
//                BrutePoint();
#ifndef UDF_CDRW_EMULATION_ON_ROM
                Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
#endif
            }
#ifdef UDF_FORMAT_MEDIA
            if(fms) {
                if((MediaType == MediaType_NoDiscPresent) ||
                   (MediaType == MediaType_DoorOpen)) {
                    UserPrint(("No media in device\n"));
                    my_exit(fms, MKUDF_NO_MEDIA_IN_DEVICE);
                }
            }
#endif //UDF_FORMAT_MEDIA
            if(!Vcb->WriteParamsReq) {
                UDFPrint(("UDFGetDiskInfo: do not use WriteParams\n"));
            }
            if(Vcb->PhMediaCapFlags & CdCapFlags_Cav) {
                UDFPrint(("UDFGetDiskInfo: Use CAV (1)\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_USE_CAV;
            }
 
#ifdef _BROWSE_UDF_
            if(!fms) {
                // check if this device is capable to write on such media
                if(UDFIsDvdMedia(Vcb)) {
                    //RC =
                    UDFPrint(("UDFGetDiskInfo: update defaulted LastLBA\n"));
                    UDFGetBlockSize(DeviceObject,Vcb);
                    //if(!OS_SUCCESS(RC)) goto Try_FullToc;
                } else {
                    if((SavedFeatures & CDRW_FEATURE_MRW_ADDRESSING_PROBLEM) &&
                       (SavedFeatures & UDF_VCB_IC_FP_ADDR_PROBLEM)) {
                        UDFPrint(("UDFGetDiskInfo: CDRW_FEATURE_MRW_ADDRESSING_PROBLEM on old CD-ROM\n"));
                        Vcb->CompatFlags |= UDF_VCB_IC_MRW_ADDR_PROBLEM;
                    }
                }
            }
#endif //_BROWSE_UDF_
 
/*#ifdef UDF_FORMAT_MEDIA
            if(fms) {
                if(MediaType == CdMediaClass_DVDRW) {
                    UserPrint(("Not empty media. Erase required.\n"));
                    my_exit(fms, MKUDF_BLANK_FORMAT_REQUIRED);
                }
            }
#endif //UDF_FORMAT_MEDIA*/
 
#define cap ((PGET_CAPABILITIES_3_USER_OUT)ioBuf)
            // get device capabilities
            RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_CAPABILITIES,DeviceObject,
                    NULL,0,ioBuf,sizeof(GET_CAPABILITIES_3_USER_OUT),
                    FALSE, NULL);
            if(!OS_SUCCESS(RC)) goto Try_FullToc;
 
            // check if this device is capable to write on such media
            RC = UDFPhSendIOCTL(IOCTL_DISK_IS_WRITABLE,DeviceObject,
                    NULL,0,NULL,0,FALSE, NULL);
            if(RC != STATUS_SUCCESS) {
                UDFPrint(("IS_WRITABLE - false, doing additional check...\n"));
                if( ((MediaType >= MediaType_UnknownSize_CDRW) && !(cap->WriteCap & DevCap_write_cd_rw)) ||
                    ((MediaType >= MediaType_UnknownSize_CDR) && !(cap->WriteCap & DevCap_write_cd_r)) ||
                     (MediaType < MediaType_UnknownSize_CDR) ) {
                    UserPrint(("Hardware Read-only volume\n"));
#ifndef UDF_CDRW_EMULATION_ON_ROM
                    Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
#endif  //UDF_CDRW_EMULATION_ON_ROM
#ifdef UDF_FORMAT_MEDIA
                    if(fms && !fms->opt_read_iso)
                        my_exit(fms, MKUDF_HW_READ_ONLY);
#endif //UDF_FORMAT_MEDIA
                }
            } else {
                UDFPrint(("Writable disk\n"));
            }
            Vcb->MaxWriteSpeed = cap->MaximumWriteSpeedSupported;
            Vcb->MaxReadSpeed  = cap->MaximumSpeedSupported;
            if(cap->PageLength >= (sizeof(GET_CAPABILITIES_3_USER_OUT)-2)) {
                Vcb->CurSpeed = max(cap->CurrentSpeed, cap->CurrentWriteSpeed3);
                if(cap->LunWPerfDescriptorCount && cap->LunWPerfDescriptorCount != 0xffff) {
                    ULONG n;
                    UDFPrint(("Write performance descriptor(s) found: %x\n", cap->LunWPerfDescriptorCount));
                    n = (4096 - sizeof(GET_CAPABILITIES_3_USER_OUT)) / sizeof(LUN_WRITE_PERF_DESC_USER);
                    n = min(n, cap->LunWPerfDescriptorCount);
                    // get device capabilities
                    RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_CAPABILITIES,DeviceObject,
                            ioBuf,sizeof(GET_CAPABILITIES_3_USER_OUT)+n*sizeof(LUN_WRITE_PERF_DESC_USER),
                            ioBuf,sizeof(GET_CAPABILITIES_3_USER_OUT)+n*sizeof(LUN_WRITE_PERF_DESC_USER),
                            TRUE,NULL);
                    if(OS_SUCCESS(RC)) {
                        WPerfDesc = (PLUN_WRITE_PERF_DESC_USER)(ioBuf + sizeof(GET_CAPABILITIES_3_USER_OUT));
                        n = FALSE;
                        for(i = 0; i<n; i++) {
                            if((WPerfDesc[i].RotationControl & LunWPerf_RotCtrl_Mask) == LunWPerf_RotCtrl_CAV) {
                                Vcb->VCBFlags |= UDF_VCB_FLAGS_USE_CAV;
                                if(!n) {
                                    Vcb->CurSpeed = WPerfDesc[i].WriteSpeedSupported;
                                    n = TRUE;
                                    UDFPrint(("Use CAV\n"));
                                } else {
                                    Vcb->CurSpeed = max(WPerfDesc[i].WriteSpeedSupported, Vcb->CurSpeed);
                                }
                                UDFPrint(("supports speed %dX\n", Vcb->CurSpeed/176));
                                //break;
                            }
                        }
                        if(n) {
                            UDFPrint(("Set r/w speeds to %dX\n", Vcb->CurSpeed/176));
                            Vcb->MaxWriteSpeed =
                            Vcb->MaxReadSpeed  = Vcb->CurSpeed;
                        }
                    }
                }
            } else {
                Vcb->CurSpeed = max(cap->CurrentSpeed, cap->CurrentWriteSpeed);
            }
            UDFPrint((" Speeds r/w %dX/%dX\n", Vcb->CurSpeed/176, cap->CurrentWriteSpeed/176));
 
            if(Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) {
                // limit both read & write speed to last write speed for CAV mode
                // some drives damage data when speed is adjusted during recording process
                // even in packet mode
                UDFSetSpeeds(Vcb);
            }
            UDFSetCaching(Vcb);
 
#undef cap
#ifdef UDF_FORMAT_MEDIA
            if(fms) {
                if( (fms->auto_media || (fms->opt_media == MT_AUTO)) &&
                       (fms->opt_media < MT_DVDR) ) {
                    if(MediaType < MediaType_UnknownSize_CDRW) {
                        fms->opt_media = MT_CDR;
                    } else {
                        fms->opt_media = MT_CDRW;
                    }
                }
                if(!apply_force_r(fms)) {
                    my_exit(fms, MKUDF_CANT_APPLY_R);
                }
            }
#endif //UDF_FORMAT_MEDIA
            RC = UDFReadDiscTrackInfo(DeviceObject, Vcb);
 
            if(!OS_SUCCESS(RC)) {
                // may be we have a CD-ROM device
Try_FullToc:
                UDFPrint(("Hardware Read-only volume (2)\n"));
//                BrutePoint();
#ifndef UDF_CDRW_EMULATION_ON_ROM
                Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
#endif
 
                RC = UDFReadAndProcessFullToc(DeviceObject, Vcb);
 
                if(!OS_SUCCESS(RC)) {
                    RC = UDFUseStandard(DeviceObject,Vcb);
                    if(!OS_SUCCESS(RC)) try_return(RC);
                }
 
            }
        } else {
#ifdef _BROWSE_UDF_
GetSignatureFailed:
#endif
            RC = UDFUseStandard(DeviceObject, Vcb);
            if(!OS_SUCCESS(RC)) try_return(RC);
        }
 
try_exit:   NOTHING;
 
    } _SEH2_FINALLY {
 
        if(ioBuf) MyFreePool__(ioBuf);
 
        if(UDFIsDvdMedia(Vcb) &&
           (Vcb->CompatFlags & UDF_VCB_IC_BAD_DVD_LAST_LBA) &&
           (Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY) &&
            Vcb->LastLBA &&
           (Vcb->LastLBA < DEFAULT_LAST_LBA_DVD)) {
            UDFPrint(("UDF: Bad DVD last LBA %x, fixup!\n", Vcb->LastLBA));
            Vcb->LastLBA = DEFAULT_LAST_LBA_DVD;
            Vcb->NWA = 0;
        }
 
 
        if(UDFIsDvdMedia(Vcb) && !Vcb->FirstLBA && !Vcb->LastPossibleLBA) {
            UDFPrint(("UDF: Empty DVD. Use bogus values for now\n"));
            Vcb->LastPossibleLBA = DEFAULT_LAST_LBA_DVD;
            Vcb->LastLBA = 0;
        }
 
        if((Vcb->LastPossibleLBA & 0x80000000) || (Vcb->LastPossibleLBA < Vcb->LastLBA)) {
            UDFPrint(("UDF: bad LastPossibleLBA %x -> %x\n", Vcb->LastPossibleLBA, Vcb->LastLBA));
            Vcb->LastPossibleLBA = Vcb->LastLBA;
        }
        if(!Vcb->WriteBlockSize)
            Vcb->WriteBlockSize = PACKETSIZE_UDF*Vcb->BlockSize;
 
#ifdef _BROWSE_UDF_
        if(Vcb->TrackMap) {
            if(Vcb->TrackMap[Vcb->LastTrackNum].LastLba > Vcb->NWA) {
                if(Vcb->NWA) {
                    if(Vcb->TrackMap[Vcb->LastTrackNum].DataParam & TrkInfo_FP) {
                        Vcb->LastLBA = Vcb->NWA-1;
                    } else {
                        Vcb->LastLBA = Vcb->NWA-7-1;
                    }
                }
            } else {
                if((Vcb->LastTrackNum > 1) &&
                   (Vcb->TrackMap[Vcb->LastTrackNum-1].FirstLba >= Vcb->TrackMap[Vcb->LastTrackNum-1].LastLba)) {
                    Vcb->LastLBA = Vcb->TrackMap[Vcb->LastTrackNum-1].LastLba;
                }
            }
        }
 
        for(i=0; i<32; i++) {
            if(!(Vcb->LastPossibleLBA >> i))
                break;
        }
        if(i > 20) {
            Vcb->WCacheBlocksPerFrameSh = max(Vcb->WCacheBlocksPerFrameSh, (2*i)/5+2);
            Vcb->WCacheBlocksPerFrameSh = min(Vcb->WCacheBlocksPerFrameSh, 16);
        }
 
        if(Vcb->CompatFlags & UDF_VCB_IC_FP_ADDR_PROBLEM) {
            // Check first 0x200 blocks
            UDFCheckTrackFPAddressing(Vcb, Vcb->FirstTrackNum);
            // if we really have such a problem, fix LastLBA
            if(Vcb->CompatFlags & UDF_VCB_IC_FP_ADDR_PROBLEM) {
                UDFPrint(("UDF: Fix LastLBA: %x -> %x\n", Vcb->LastLBA, (Vcb->LastLBA*32) / 39));
                Vcb->LastLBA = (Vcb->LastLBA*32) / 39;
            }
        }
#endif //_BROWSE_UDF_
 
        if(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY) {
            if(!Vcb->BlankCD && Vcb->MediaType != MediaType_UnknownSize_CDRW) {
                UDFPrint(("UDFGetDiskInfo: R/O+!Blank+!RW -> !RAW\n"));
                Vcb->VCBFlags &= ~UDF_VCB_FLAGS_RAW_DISK;
            } else {
                UDFPrint(("UDFGetDiskInfo: Blank or RW\n"));
            }
        }
 
        UDFPrint(("UDF: ------------------------------------------\n"));
        UDFPrint(("UDF: Media characteristics\n"));
        UDFPrint(("UDF: Last session: %d\n",Vcb->LastSession));
        UDFPrint(("UDF: First track in first session: %d\n",Vcb->FirstTrackNum));
        UDFPrint(("UDF: First track in last session: %d\n",Vcb->FirstTrackNumLastSes));
        UDFPrint(("UDF: Last track in last session: %d\n",Vcb->LastTrackNum));
        UDFPrint(("UDF: First LBA in first session: %x\n",Vcb->FirstLBA));
        UDFPrint(("UDF: First LBA in last session: %x\n",Vcb->FirstLBALastSes));
        UDFPrint(("UDF: Last LBA in last session: %x\n",Vcb->LastLBA));
        UDFPrint(("UDF: First writable LBA (NWA) in last session: %x\n",Vcb->NWA));
        UDFPrint(("UDF: Last available LBA beyond end of last session: %x\n",Vcb->LastPossibleLBA));
        UDFPrint(("UDF: blocks per frame: %x\n",1 << Vcb->WCacheBlocksPerFrameSh));
        UDFPrint(("UDF: Flags: %s%s\n",
                 Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK ? "RAW " : "",
                 Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY ? "R/O " : "WR "
                 ));
        UDFPrint(("UDF: ------------------------------------------\n"));
 
#ifdef UDF_FORMAT_MEDIA
        if(fms && fms->opt_disk_info) {
            UserPrint(("------------------------------------------\n"));
            UserPrint(("Media characteristics:\n"));
            UserPrint(("  First writable LBA (NWA) in last session: %x\n",Vcb->NWA));
            UserPrint(("  Last available LBA beyond end of last session: %x\n",Vcb->LastPossibleLBA));
            UserPrint(("------------------------------------------\n"));
        }
#endif //UDF_FORMAT_MEDIA
 
    } _SEH2_END;
 
    UDFPrint(("UDFGetDiskInfo: %x\n", RC));
    return(RC);
 
} // end UDFGetDiskInfo()

Referenced by UDFMountVolume(), and UDFVerifyVolume().

UDFPrepareForReadOperation()

OSSTATUS UDFPrepareForReadOperation	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	BCount
	)

Definition at line 3670 of file phys_lib.cpp.

{
    if( (Vcb->FsDeviceType != FILE_DEVICE_CD_ROM_FILE_SYSTEM) ) {
        Vcb->VCBFlags &= ~UDF_VCB_LAST_WRITE;
        return STATUS_SUCCESS;
    }
    uint32 i = Vcb->LastReadTrack;
    BOOLEAN speed_changed = FALSE;
#ifdef _BROWSE_UDF_
    PUCHAR tmp;
    OSSTATUS RC;
    SIZE_T ReadBytes;
#endif //_BROWSE_UDF_
 
#ifdef _UDF_STRUCTURES_H_
    if(Vcb->BSBM_Bitmap) {
        ULONG i;
        for(i=0; i<BCount; i++) {
            if(UDFGetBit((uint32*)(Vcb->BSBM_Bitmap), Lba+i)) {
                UDFPrint(("R: Known BB @ %#x\n", Lba));
                //return STATUS_FT_WRITE_RECOVERY; // this shall not be treated as error and
                                                   // we shall get IO request to BAD block
                return STATUS_DEVICE_DATA_ERROR;
            }
        }
    }
#endif //_UDF_STRUCTURES_H_
 
    if(!UDFIsDvdMedia(Vcb) &&
        (Vcb->VCBFlags & UDF_VCB_LAST_WRITE) &&
       !(Vcb->VCBFlags & UDF_VCB_FLAGS_NO_SYNC_CACHE) &&
       !(Vcb->CompatFlags & UDF_VCB_IC_NO_SYNCCACHE_AFTER_WRITE)){
 
//        OSSTATUS RC;
 
        RC = UDFSyncCache(Vcb);
    }
    if( (Vcb->VCBFlags & UDF_VCB_LAST_WRITE) &&
       !(Vcb->VCBFlags & UDF_VCB_FLAGS_NO_SYNC_CACHE) &&
#ifndef UDF_FORMAT_MEDIA
        (Vcb->CompatFlags & UDF_VCB_IC_SYNCCACHE_BEFORE_READ) &&
#endif //UDF_FORMAT_MEDIA
        TRUE)
    {
//        OSSTATUS RC;
        UDFSyncCache(Vcb);
    }
 
#ifdef _BROWSE_UDF_
    if(!UDFIsDvdMedia(Vcb)) {
        // limit read speed after write operation
        // to avoid performance degrade durring speed-up/down
        // on read/write mode switching
        if(Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) {
            // limit both read & write speed to last write speed for CAV mode
            // some drives damage data when speed is adjusted during recording process
            // even in packet mode
            if(Vcb->CurSpeed != Vcb->MaxWriteSpeed ||
               Vcb->CurSpeed != Vcb->MaxReadSpeed) {
                Vcb->CurSpeed = Vcb->MaxWriteSpeed;
                speed_changed = TRUE;
            }
        } else
        if(Vcb->VCBFlags & UDF_VCB_LAST_WRITE) {
            // limit read speed to last write speed
            if(Vcb->CurSpeed > Vcb->MaxWriteSpeed) {
                Vcb->CurSpeed = Vcb->MaxWriteSpeed;
                speed_changed = TRUE;
            }
        } else
        if(Vcb->CurSpeed < Vcb->MaxReadSpeed ) {
            // increment read speed (+1X)
            Vcb->CurSpeed += 176/1;
            speed_changed = TRUE;
        }
 
        if(Vcb->CurSpeed > Vcb->MaxReadSpeed) {
            Vcb->CurSpeed = Vcb->MaxReadSpeed;
        }
        // send speed limits to drive
        if(speed_changed) {
            RtlZeroMemory(&(Vcb->SpeedBuf), sizeof(SET_CD_SPEED_EX_USER_IN));
            Vcb->SpeedBuf.ReadSpeed  = Vcb->CurSpeed;
            Vcb->SpeedBuf.WriteSpeed = Vcb->MaxWriteSpeed;
            if(Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) {
                Vcb->SpeedBuf.RotCtrl = CdSpeed_RotCtrl_CAV;
            }
            UDFPrint(("    UDFPrepareForReadOperation: set speed to %s %dX/%dX\n",
                (Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) ? "CAV" : "CLV",
                Vcb->SpeedBuf.ReadSpeed,
                Vcb->SpeedBuf.WriteSpeed));
            UDFPhSendIOCTL(IOCTL_CDRW_SET_SPEED,
                                Vcb->TargetDeviceObject,
                                &(Vcb->SpeedBuf),sizeof(SET_CD_SPEED_EX_USER_IN),
                                NULL,0,TRUE,NULL);
        }
    }
 
    if(UDFIsDvdMedia(Vcb))
        return STATUS_SUCCESS;
 
    if(Vcb->LastReadTrack &&
       ((Vcb->TrackMap[i].FirstLba <= Lba) || (Vcb->TrackMap[i].FirstLba & 0x80000000)) &&
       (Vcb->TrackMap[i].LastLba >= Lba)) {
check_for_data_track:
        // check track mode (Mode1/XA)
        switch((Vcb->TrackMap[i].DataParam & TrkInfo_Dat_Mask)) {
        case TrkInfo_Dat_Mode1: // Mode1
        case TrkInfo_Dat_XA:    // XA Mode2
        case TrkInfo_Dat_Unknown: // for some stupid irons
            UDFSetMRWMode(Vcb);
            break;
        default:
            Vcb->IncrementalSeekState = INCREMENTAL_SEEK_NONE;
            return STATUS_INVALID_PARAMETER;
        }
    } else {
        for(i=Vcb->FirstTrackNum; i<=Vcb->LastTrackNum; i++) {
            if(((Vcb->TrackMap[i].FirstLba > Lba) && !(Vcb->TrackMap[i].FirstLba & 0x80000000)) ||
               (Vcb->TrackMap[i].LastLba < Lba))
                continue;
            Vcb->LastReadTrack = i;
            goto check_for_data_track;
        }
        Vcb->LastReadTrack = 0;
    }
    if(Vcb->IncrementalSeekState != INCREMENTAL_SEEK_WORKAROUND) {
        Vcb->IncrementalSeekState = INCREMENTAL_SEEK_NONE;
        return STATUS_SUCCESS;
    }
    UDFPrint(("    UDFPrepareForReadOperation: seek workaround...\n"));
    Vcb->IncrementalSeekState = INCREMENTAL_SEEK_DONE;
 
    tmp = (PUCHAR)DbgAllocatePoolWithTag(NonPagedPool, Vcb->BlockSize, 'bNWD');
    if(!tmp) {
        Vcb->IncrementalSeekState = INCREMENTAL_SEEK_NONE;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    for(i=0x1000; i<=Lba; i+=0x1000) {
        RC = UDFPhReadSynchronous(Vcb->TargetDeviceObject, tmp, Vcb->BlockSize,
                   ((uint64)UDFFixFPAddress(Vcb,i)) << Vcb->BlockSizeBits, &ReadBytes, 0);
        UDFPrint(("    seek workaround, LBA %x, status %x\n", i, RC));
    }
    DbgFreePool(tmp);
#endif //_BROWSE_UDF_
 
    return STATUS_SUCCESS;
} // end UDFPrepareForReadOperation()

Referenced by UDFTRead().

UDFPrepareForWriteOperation()

OSSTATUS UDFPrepareForWriteOperation	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	BCount
	)

Definition at line 893 of file phys_lib.cpp.

{
#ifndef UDF_READ_ONLY_BUILD
#ifdef UDF_FORMAT_MEDIA
    PUDFFmtState            fms = Vcb->fms;
#else
  #define fms FALSE
#endif //UDF_FORMAT_MEDIA
 
#ifdef _UDF_STRUCTURES_H_
    if(Vcb->BSBM_Bitmap) {
        ULONG i;
        for(i=0; i<BCount; i++) {
            if(UDFGetBit((uint32*)(Vcb->BSBM_Bitmap), Lba+i)) {
                UDFPrint(("W: Known BB @ %#x\n", Lba));
                //return STATUS_FT_WRITE_RECOVERY; // this shall not be treated as error and
                                                   // we shall get IO request to BAD block
                return STATUS_DEVICE_DATA_ERROR;
            }
        }
    }
#endif //_UDF_STRUCTURES_H_
 
    Vcb->VCBFlags |= UDF_VCB_LAST_WRITE;
 
    if(
#ifdef _BROWSE_UDF_
       (((Vcb->FsDeviceType != FILE_DEVICE_CD_ROM_FILE_SYSTEM) ||
       !(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_MOUNTED) ||
        (Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK))
        && !fms
        ) ||
#endif //_BROWSE_UDF_
#ifdef UDF_FORMAT_MEDIA
        (fms && fms->SkipPrepareW) ||
#endif //UDF_FORMAT_MEDIA
       !(Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER)
       ) {
        UDFPrint(("Skip prepare for Write @%x\n", Lba));
        return STATUS_SUCCESS;
    }
 
    // check if the device requires OPC before each write operation
    UDFDoOPC(Vcb);
 
    if(Vcb->SyncCacheState == SYNC_CACHE_RECOVERY_ATTEMPT) {
        Vcb->SyncCacheState = SYNC_CACHE_RECOVERY_RETRY;
    } else {
        Vcb->SyncCacheState = SYNC_CACHE_RECOVERY_NONE;
    }
    if(Vcb->LastModifiedTrack &&
       (Vcb->TrackMap[Vcb->LastModifiedTrack].FirstLba <= Lba) &&
       (Vcb->TrackMap[Vcb->LastModifiedTrack].LastLba >= Lba) &&
       !( (Vcb->MediaClassEx == CdMediaClass_DVDRW ||
           Vcb->MediaClassEx == CdMediaClass_DVDpRW ||
           Vcb->MediaClassEx == CdMediaClass_DVDRAM ||
           Vcb->MRWStatus == DiscInfo_BGF_Interrupted ||
           Vcb->MRWStatus == DiscInfo_BGF_InProgress) && (Lba > Vcb->LastLBA))
      ) {
        // Ok, we needn't change Write Parameters
//        if(Vcb->TrackMap[Vcb->LastModifiedTrack].Flags & TrackMap_Try_variation)
//            Vcb->TrackMap[Vcb->LastModifiedTrack].Flags |= TrackMap_Use_variation;
        UDFPrint(("Skip prepare for Write (2) @%x\n", Lba));
        return STATUS_SUCCESS;
    }
 
    UDFSetMRWMode(Vcb);
 
    if(!UDFIsWriteParamsReq(Vcb)) {
#ifdef UDF_FORMAT_MEDIA
        if(fms) {
            return STATUS_SUCCESS;
        }
#endif //UDF_FORMAT_MEDIA
    }
 
    for(uint32 i=Vcb->FirstTrackNum; i<=Vcb->LastTrackNum; i++) {
        if((Vcb->TrackMap[i].FirstLba > Lba) ||
           (Vcb->TrackMap[i].LastLba < Lba)) {
            //UDFPrint(("not in track %d\n"));
            continue;
        }
        OSSTATUS RC;
        PGET_WRITE_MODE_USER_OUT WParams;
 
        if(!UDFIsWriteParamsReq(Vcb)) {
            RC = STATUS_SUCCESS;
            goto check_dvd_bg_format;
        }
 
        if(!Vcb->WParams) {
            Vcb->WParams =
                (PGET_WRITE_MODE_USER_OUT)MyAllocatePool__(NonPagedPool, 512);
        }
        if(!(WParams = Vcb->WParams)) {
            UDFPrint(("!WParams\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_WRITE_MODE, Vcb->TargetDeviceObject,
                        NULL,0,
                        (void*)(Vcb->WParams),sizeof(GET_WRITE_MODE_USER_OUT),
                        FALSE, NULL);
        if(!OS_SUCCESS(RC)) {
#ifdef UDF_FORMAT_MEDIA
            if(fms) {
                fms->SkipPrepareW = 1;
                MyFreePool__(WParams);
                return STATUS_SUCCESS;
            }
#endif //UDF_FORMAT_MEDIA
            UDFPrint(("!get WParams\n"));
            return RC;
        }
        // clear unnecassary flags
        WParams->Byte2.Flags &= ~WParam_TestWrite;
        WParams->Byte2.Flags &= ~WParam_WType_Mask;
        // select packet writing
        WParams->Byte2.Flags |= WParam_WType_Packet;
 
        WParams->Byte3.Flags &= ~(WParam_TrkMode_Mask |
                                  WParam_TrkMode_AllowCpy |
                                  WParam_Copy);
        WParams->Byte3.Flags |= Vcb->TrackMap[i].TrackParam &
                                 (WParam_TrkMode_Mask |
                                  WParam_TrkMode_AllowCpy |
                                  WParam_Copy);
 
        // set packet type (VP/FP)
//        if(opt_partition == PT_VAT15 ||
//           opt_blank_vat15)
        if(WParams->Byte2.Flags & WParam_LS_V) {
            WParams->LinkSize = 7;
        }
 
        if(Vcb->TrackMap[i].DataParam & TrkInfo_Packet) {
            if((Vcb->TrackMap[i].DataParam & TrkInfo_FP) &&
                !Vcb->CDR_Mode) {
                WParams->Byte3.Flags |= WParam_FP;
            } else {
                WParams->Byte3.Flags &= ~WParam_FP;
            }
        } else {
            if(!Vcb->CDR_Mode) {
                WParams->Byte3.Flags |= WParam_FP;
            } else {
                WParams->Byte3.Flags &= ~WParam_FP;
            }
        }
 
        // select multisession mode
        WParams->Byte3.Flags &= ~WParam_MultiSes_Mask;
        if((Vcb->DiscStat & DiscInfo_Disk_Mask) == DiscInfo_Disk_Appendable) {
            WParams->Byte3.Flags |= WParam_Multises_Multi;
        } else
        if(Vcb->LastSession > 1) {
            WParams->Byte3.Flags |= WParam_Multises_Final;
        } else {
            WParams->Byte3.Flags |= WParam_Multises_None;
        }
        // set sector mode (Mode1/XA)
        WParams->Byte4.Flags &= ~WParam_BlkType_Mask;
        if((Vcb->TrackMap[i].DataParam & TrkInfo_Dat_Mask) == TrkInfo_Dat_XA) {
            // XA Mode2
            WParams->Byte4.Flags |= WParam_BlkType_M2XAF1_2048;
            WParams->SesFmt = WParam_SesFmt_CdRomXa;
        } else if((Vcb->TrackMap[i].DataParam & TrkInfo_Dat_Mask) == TrkInfo_Dat_Mode1) {
            // Mode1
            WParams->Byte4.Flags |= WParam_BlkType_M1_2048;
            WParams->SesFmt = WParam_SesFmt_CdRom;
        } else {
#ifdef UDF_FORMAT_MEDIA
            if(fms) {
                fms->SkipPrepareW = 1;
                MyFreePool__(WParams);
                return STATUS_SUCCESS;
            }
#endif //UDF_FORMAT_MEDIA
            UDFPrint(("  inv sector mode\n"));
            return STATUS_INVALID_PARAMETER;
        }
        // set packet size
        *((uint32*)&(WParams->PacketSize)) = BCount;
        *((uint32*)&(WParams->SubHeader)) = 0;
        // set additional flags for VP
 
        if(Vcb->CDR_Mode) {
//        if(opt_partition == PT_VAT15)
            WParams->SubHeader.Params.Params1.SubMode = WParam_SubHdr_SubMode1;
        }
        WParams->PageLength = sizeof(GET_WRITE_MODE_USER_OUT)-2;
        WParams->PageCode = MODE_PAGE_WRITE_PARAMS;
        // apply write parameters
        RC = UDFPhSendIOCTL(IOCTL_CDRW_SET_WRITE_MODE, Vcb->TargetDeviceObject,
                        (void*)WParams,sizeof(SET_WRITE_MODE_USER_IN),
                        NULL,0,FALSE,NULL);
 
#ifdef UDF_FORMAT_MEDIA
        if(fms) {
            if(!NT_SUCCESS(RC)) {
                fms->SkipPrepareW = 1;
                MyFreePool__(WParams);
                return STATUS_SUCCESS;
            }
 
            RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_WRITE_MODE, Vcb->TargetDeviceObject,
                            NULL,0,
                            (PVOID)WParams,sizeof(GET_WRITE_MODE_USER_OUT),
                            FALSE, NULL);
            if(!NT_SUCCESS(RC)) {
                MyFreePool__(WParams);
                return RC;
            }
 
            if(fms->opt_partition == PT_VAT15 ||
               fms->opt_blank_vat15) {
                if(WParams->Byte3.Flags & WParam_FP) {
                    MyFreePool__(WParams);
                    return STATUS_INVALID_DEVICE_STATE;
                }
            } else {
                if(!(WParams->Byte3.Flags & WParam_FP)) {
                    MyFreePool__(WParams);
                    return STATUS_INVALID_DEVICE_STATE;
                }
            }
        }
#endif //UDF_FORMAT_MEDIA
 
        // switch to random access mode
        ((PSET_RANDOM_ACCESS_USER_IN)WParams)->RandomAccessMode = Vcb->CDR_Mode ? FALSE : TRUE;
//        ((PSET_RANDOM_ACCESS_USER_IN)WParams)->RandomAccessMode = (opt_partition != PT_VAT15) ? TRUE : FALSE;
        RC = UDFPhSendIOCTL(IOCTL_CDRW_SET_RANDOM_ACCESS, Vcb->TargetDeviceObject,
                        (void*)WParams,sizeof(SET_RANDOM_ACCESS_USER_IN),
                        NULL,0,FALSE, NULL);
 
check_dvd_bg_format:
 
        UDFPrint(("  check BGF\n"));
        if(!Vcb->CDR_Mode) {
            if(OS_SUCCESS(RC)) {
                Vcb->LastModifiedTrack = i;
                if(!(Vcb->TrackMap[i].Flags & TrackMap_Use_variation)) {
                    if(Vcb->TrackMap[i].Flags & TrackMap_Try_variation) {
                        Vcb->TrackMap[i].Flags |= TrackMap_Use_variation;
                    } else {
                        Vcb->TrackMap[i].Flags |= TrackMap_Try_variation;
                    }
                }
            }
        } else {
            Vcb->LastModifiedTrack = 0;
        }
//        fms->SkipPrepareW = 1;
 
 
        if((Vcb->MediaClassEx == CdMediaClass_DVDRW ||
            Vcb->MediaClassEx == CdMediaClass_DVDpRW ||
            Vcb->MediaClassEx == CdMediaClass_DVDRAM ||
            Vcb->MRWStatus == DiscInfo_BGF_Interrupted )
                 && (Lba > Vcb->LastLBA)) {
 
            ULONG fLba;
            SIZE_T WrittenBytes;
            ULONG PSz = BCount << Vcb->BlockSizeBits;
#ifdef _BROWSE_UDF_
            ULONG retry;
#endif //_BROWSE_UDF_
            PFORMAT_CDRW_PARAMETERS_USER_IN ForBuf;
 
            ASSERT((Vcb->LastLBA+1) == Vcb->NWA);
 
            if(Lba+BCount <= (Vcb->LastLBA+1) ) {
                UDFPrint(("DVD cont. fmt, LBA+BCount<=NWA, exiting\n"));
                return STATUS_SUCCESS;
            }
            if((Vcb->MRWStatus != DiscInfo_BGF_Interrupted) &&
               (Lba <= (Vcb->LastLBA+1)) ) {
                UDFPrint(("!PausedBGF + DVD cont. fmt, LBA<=NWA, exiting\n"));
                return STATUS_SUCCESS;
            }
 
            if(Vcb->MRWStatus == DiscInfo_BGF_Interrupted) {
                // This code also can restart background MRW formatting
                UDFPrint(("DVD cont. fmt, LastLBA %x, Lba %x\n", Vcb->LastLBA, Lba));
 
                ForBuf = (PFORMAT_CDRW_PARAMETERS_USER_IN)DbgAllocatePoolWithTag(NonPagedPool, sizeof(FORMAT_CDRW_PARAMETERS_USER_IN), 'zNWD');
                if(ForBuf) {
                    RtlZeroMemory(ForBuf, sizeof(FORMAT_CDRW_PARAMETERS_USER_IN));
                    ForBuf->Flags.FlagsEx = FORMAT_UNIT_RESTART_MRW;
                    ForBuf->BlockCount = 0xffffffff;
 
                    RC = UDFPhSendIOCTL(IOCTL_CDRW_FORMAT_UNIT, Vcb->TargetDeviceObject,
                            ForBuf,sizeof(FORMAT_CDRW_PARAMETERS_USER_IN),
                            NULL,0,FALSE, NULL);
                    DbgFreePool(ForBuf);
                    if(OS_SUCCESS(RC)) {
                        UDFPrint(("BGFormat restarted Interrupted->InProgress\n"));
                        Vcb->MRWStatus = DiscInfo_BGF_InProgress;
                    } else {
                        PGET_LAST_ERROR_USER_OUT Error = NULL;
                        if(!Vcb->Error) {
                            Vcb->Error = (PGET_LAST_ERROR_USER_OUT)
                                            MyAllocatePool__(NonPagedPool, sizeof(GET_LAST_ERROR_USER_OUT));
                        }
                        Error = Vcb->Error;
                        if(Error) {
                            UDFPhSendIOCTL( IOCTL_CDRW_GET_LAST_ERROR, Vcb->TargetDeviceObject,
                                            NULL,0,
                                            Error,sizeof(GET_LAST_ERROR_USER_OUT),
                                            TRUE,NULL);
                            UDFPrint(("SK=%x ASC=%x, ASCQ=%x, IE=%x\n",
                                     Error->SenseKey, Error->AdditionalSenseCode, Error->AdditionalSenseCodeQualifier, Error->LastError));
                            // check for Long Write In Progress
                            if( (Error->SenseKey == SCSI_SENSE_NOT_READY) &&
                                (Error->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY) &&
                                 ((Error->AdditionalSenseCodeQualifier == SCSI_SENSEQ_LONG_WRITE_IN_PROGRESS) ||
                                  (Error->AdditionalSenseCodeQualifier == SCSI_SENSEQ_FORMAT_IN_PROGRESS)) ) {
                                RC = STATUS_SUCCESS;
                                UDFPrint(("Seems, BGFormat already restarted\n"));
                                Vcb->MRWStatus = DiscInfo_BGF_InProgress;
                            }
                        }
                    }
                }
            } else {
                RC = STATUS_SUCCESS;
            }
 
            UDFPrint(("DVD cont. write, LastLBA %x, Lba %x\n", Vcb->LastLBA, Lba));
 
            ASSERT(Vcb->MediaClassEx == CdMediaClass_DVDRW);
            if(!Vcb->fZBuffer) {
                Vcb->fZBuffer = (PCHAR)DbgAllocatePoolWithTag(NonPagedPool, PSz, 'zNWD');
                RtlZeroMemory(Vcb->fZBuffer, PSz);
                Vcb->fZBufferSize = PSz;
            } else
            if(Vcb->fZBufferSize < PSz) {
                PSz = Vcb->fZBufferSize;
            }
            if(!Vcb->fZBuffer) {
                BrutePoint();
                RC = STATUS_INSUFFICIENT_RESOURCES;
            } else {
                for(fLba = Vcb->NWA; fLba < Lba; fLba+=BCount) {
#ifdef _BROWSE_UDF_
                    retry = UDF_WRITE_MAX_RETRY;
retry_1:
#endif //_BROWSE_UDF_
                    RC = UDFPhWriteVerifySynchronous(Vcb->TargetDeviceObject, Vcb->fZBuffer, PSz,
                           ((uint64)fLba) << Vcb->BlockSizeBits, &WrittenBytes, PH_TMP_BUFFER);
                    Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
                    UDFPrint(("Fmt status: %x\n", RC));
#ifdef _BROWSE_UDF_
                    if(!OS_SUCCESS(RC) &&
                        OS_SUCCESS(RC = UDFRecoverFromError(Vcb, TRUE, RC, fLba, BCount, &retry)) ) {
                        goto retry_1;
                        UDFPrint(("Fmt retry\n"));
                    }
#endif //_BROWSE_UDF_
                    if(!OS_SUCCESS(RC)) {
                        BrutePoint();
                        UDFPrint(("Fmt break on ERROR\n"));
                        break;
                    }
                    UDFUpdateNWA(Vcb, fLba, BCount, RC);
                }
            }
        } else {
            UDFPrint(("  no special processing\n"));
        }
 
        return RC;
    }
#endif //UDF_READ_ONLY_BUILD
    UDFPrint(("  no suitable track!\n"));
    return STATUS_INVALID_PARAMETER;
} // end UDFPrepareForWriteOperation()

Referenced by UDFRecoverFromError(), and UDFTWrite().

UDFReadAndProcessFullToc()

OSSTATUS UDFReadAndProcessFullToc	(	PDEVICE_OBJECT	DeviceObject,
		PVCB	Vcb
	)

Definition at line 2243 of file phys_lib.cpp.

{
    OSSTATUS                RC = STATUS_SUCCESS;
    PREAD_FULL_TOC_USER_OUT toc = (PREAD_FULL_TOC_USER_OUT)MyAllocatePool__(NonPagedPool,sizeof(READ_FULL_TOC_USER_OUT) );
    uint32 index;
    uint8 POINT;
    uint8 CurTrack = 0;
    uint32 LastLeadOut = 0;
//    BOOLEAN IsMRW = FALSE;
 
    UDFPrint(("UDFReadAndProcessFullToc\n"));
 
    if(!toc) return STATUS_INSUFFICIENT_RESOURCES;
    Vcb->FirstTrackNum = 0xFF;
 
    RtlZeroMemory(toc,sizeof(READ_FULL_TOC_USER_OUT));
 
    RC = UDFPhSendIOCTL(IOCTL_CDRW_READ_FULL_TOC,DeviceObject,
        NULL,0,
        toc,sizeof(READ_FULL_TOC_USER_OUT),
        TRUE,NULL);
 
    if(!OS_SUCCESS(RC)) {
 
        MyFreePool__(toc);
        return RC;
    }
 
#ifdef _CONSOLE
    Vcb->PhDeviceType = FILE_DEVICE_CD_ROM;
#endif //_CONSOLE
    Vcb->LastSession = toc->Sessions.Last_TrackSes;
 
    RC = UDFReallocTrackMap(Vcb, 0x100);
    if(!OS_SUCCESS(RC)) {
        MyFreePool__(toc);
        return RC;
    }
 
    // get LastPossibleLBA
 
    // Note: some drives return Full TOC items unordered.
    // So, LeadOut position may come before Track definition.
    // In order to handle such situation, we must initialize
    // CurTrack when First or Last Track descriptor comes
    for (index=0;(index<MAXIMUM_NUMBER_OF_SESSIONS);index++) {
/*        if((toc->SessionData[index].Adr == TOC_ADR_TrackInfo) &&
           ((toc->SessionData[index].Control == TOC_CTL_MRWTrackInfo) || (toc->SessionData[index].Control == TOC_CTL_MRWLastSes))) {
            IsMRW = TRUE;
        }*/
        if(toc->SessionData[index].Adr == 1) {
            switch (POINT = toc->SessionData[index].POINT) {
            case POINT_FirstTrackNum: {
                Vcb->FirstTrackNum = toc->SessionData[index].Params.FirstTrackNum.FirstTrackNum;
                if(!CurTrack)
                    CurTrack = (uint8)(Vcb->FirstTrackNum);
                break;
                }
            case POINT_LastTrackNum: {
                Vcb->LastTrackNum = toc->SessionData[index].Params.LastTrackNum.LastTrackNum;
                if(CurTrack < Vcb->LastTrackNum)
                    CurTrack = (uint8)(Vcb->FirstTrackNum);
                break;
                }
            case POINT_StartPositionOfLeadOut: {
#define TempMSF toc->SessionData[index].Params.StartPositionOfLeadOut.MSF
                Vcb->TrackMap[CurTrack].LastLba = MSF_TO_LBA(TempMSF[0],TempMSF[1],TempMSF[2]);
                LastLeadOut = max(LastLeadOut, Vcb->TrackMap[CurTrack].LastLba);
#undef TempMSF
                break;
                }
            default: {
                if( (Vcb->FirstTrackNum != 0x0FF) &&
                     (toc->SessionData[index].POINT == Vcb->FirstTrackNum) ) {
#define TempMSF toc->SessionData[index].Params.StartPositionOfTrack.MSF
                    Vcb->FirstLBA = MSF_TO_LBA(TempMSF[0],TempMSF[1],TempMSF[2]);
                    if(Vcb->FirstLBA & 0x80000000) {
                        Vcb->FirstLBA = 0;
                    }
#undef TempMSF
                }
                break;
                }
            }
            if((POINT >= POINT_StartPositionOfTrack_Min) &&
               (POINT <= POINT_StartPositionOfTrack_Max)) {
#define TempMSF toc->SessionData[index].Params.StartPositionOfTrack.MSF
                Vcb->TrackMap[POINT].FirstLba = MSF_TO_LBA(TempMSF[0],TempMSF[1],TempMSF[2])-1;
                if(Vcb->TrackMap[POINT].FirstLba & 0x80000000) {
                    if(POINT == 1) {
                        Vcb->TrackMap[POINT].FirstLba = 0;
                    } else {
                        if(Vcb->TrackMap[POINT-1].LastLba) {
                            Vcb->TrackMap[POINT].FirstLba = Vcb->TrackMap[POINT-1].LastLba+1;
                        }
                    }
                }
#undef TempMSF
                if(POINT > POINT_StartPositionOfTrack_Min) {
                    Vcb->TrackMap[POINT-1].LastLba = Vcb->TrackMap[POINT].FirstLba-1;
                }
                CurTrack = POINT;
            }
        } else
        if(toc->SessionData[index].Adr == 5) {
            switch (POINT = toc->SessionData[index].POINT) {
            case POINT_StartPositionOfNextProgramArea: {
#define TempMSF toc->SessionData[index].Params.StartPositionOfNextProgramArea.MaxLeadOut_MSF
                Vcb->LastPossibleLBA = MSF_TO_LBA(TempMSF[0],TempMSF[1],TempMSF[2]);
#undef TempMSF
                break;
                }
            default: {
                break;
                }
            }
        }
 
    }
 
/*    if(!IsMRW) {
        UDFPrint(("No MRW\n"));
        Vcb->CompatFlags &= ~UDF_VCB_IC_MRW_ADDR_PROBLEM;
    }*/
//        Vcb->CompatFlags &= ~UDF_VCB_IC_MRW_ADDR_PROBLEM;
    // some devices report LastTrackNum=0 for full disks
    Vcb->LastTrackNum = max(Vcb->LastTrackNum, Vcb->FirstTrackNum);
    Vcb->TrackMap[Vcb->LastTrackNum].LastLba = max(LastLeadOut, Vcb->TrackMap[Vcb->LastTrackNum].LastLba);
 
    Vcb->LastLBA = Vcb->TrackMap[Vcb->LastTrackNum].LastLba;
 
    MyFreePool__(toc);
//    Vcb->LastLBA=PacketVariable2Fixed(Vcb->LastLBA)-2;
    return STATUS_SUCCESS;
} // end UDFReadAndProcessFullToc()

Referenced by UDFGetDiskInfo().

UDFReadDiscTrackInfo()

OSSTATUS UDFReadDiscTrackInfo	(	PDEVICE_OBJECT	DeviceObject,
		PVCB	Vcb
	)

Definition at line 1635 of file phys_lib.cpp.

{
    OSSTATUS                    RC = STATUS_SUCCESS;
    PDISC_INFO_BLOCK_USER_OUT   DiscInfo = (PDISC_INFO_BLOCK_USER_OUT)MyAllocatePool__(NonPagedPool,sizeof(DISC_INFO_BLOCK_USER_OUT) );
    PTRACK_INFO_BLOCK_USER_OUT  TrackInfoOut = (PTRACK_INFO_BLOCK_USER_OUT)MyAllocatePool__(NonPagedPool,sizeof(TRACK_INFO_BLOCK_USER_OUT) );
    PTRACK_INFO_BLOCK_USER_IN   TrackInfoIn = (PTRACK_INFO_BLOCK_USER_IN)TrackInfoOut;
    READ_CAPACITY_USER_OUT      CapacityBuffer;
    LONG                        TrackNumber;
    BOOLEAN                     NotFP = FALSE;
    BOOLEAN                     ForceFP = FALSE;
    BOOLEAN                     PacketTrack = FALSE;
    BOOLEAN                     MRWRetry = FALSE;
//    BOOLEAN                     ReadCapacityOk = FALSE;
#ifdef UDF_FORMAT_MEDIA
    PUDFFmtState            fms = Vcb->fms;
#endif
 
    _SEH2_TRY {
        if(!DiscInfo || !TrackInfoOut)
            try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
 
MRWRetry_label:
 
        RC = UDFPhSendIOCTL(IOCTL_CDRW_READ_DISC_INFO, DeviceObject,
                NULL, 0,
                DiscInfo,sizeof(DISC_INFO_BLOCK_USER_OUT), TRUE, NULL);
        if(!OS_SUCCESS(RC)) {
            UDFPrint(("ReadDiskInfo failed. Use default.\n"));
            if(Vcb->MediaClassEx == CdMediaClass_DVDRW ||
                Vcb->MediaClassEx == CdMediaClass_DVDpRW ||
                Vcb->MediaClassEx == CdMediaClass_DVDRAM) {
                Vcb->LastPossibleLBA = DEFAULT_LAST_LBA_DVD;
            } else
            if(Vcb->MediaClassEx == CdMediaClass_BDRE) {
                Vcb->LastPossibleLBA = DEFAULT_LAST_LBA_BD;
            } else {
                Vcb->LastPossibleLBA = DEFAULT_LAST_LBA_FP_CD;
            }
            try_return(RC);
        }
#ifdef UDF_FORMAT_MEDIA
        if(fms && fms->opt_disk_info) {
            UserPrint(("ReadDiskInfo OK\n"));
        }
#endif //UDF_FORMAT_MEDIA
 
        RC = UDFPhSendIOCTL(IOCTL_CDRW_READ_CAPACITY, DeviceObject,
                NULL, 0,
                &CapacityBuffer,sizeof(READ_CAPACITY_USER_OUT), TRUE, NULL);
        if(!OS_SUCCESS(RC)) {
            UDFPrint(("ReadCapacity failed.\n"));
            if(Vcb->MediaClassEx == CdMediaClass_DVDpRW) {
                Vcb->LastPossibleLBA = DEFAULT_LAST_LBA_DVD;
            }
        } else {
            UDFPrint(("ReadCapacity ok.\n"));
            UDFPrint(("Last possible LBA %#x.\n", CapacityBuffer.LogicalBlockAddress));
            if(!(CapacityBuffer.LogicalBlockAddress  & 0xc0000000) &&
                (CapacityBuffer.LogicalBlockAddress != 0x7fffffff)) {
                // good value from ReadCapacity
                UDFPrint(("Update Last possible LBA %#x.\n", CapacityBuffer.LogicalBlockAddress));
                Vcb->LastPossibleLBA = CapacityBuffer.LogicalBlockAddress;
//                ReadCapacityOk = TRUE;
#ifdef UDF_FORMAT_MEDIA
                if(fms && fms->opt_disk_info) {
                    UserPrint(("ReadCapacity OK\n"));
                }
#endif //UDF_FORMAT_MEDIA
            }
        }
 
#ifdef _CONSOLE
        Vcb->PhDeviceType = FILE_DEVICE_CD_ROM;
#endif //_CONSOLE
        Vcb->PhSerialNumber = *((uint32*)&(DiscInfo->DiskId));
        Vcb->PhErasable = DiscInfo->DiscStat.Flags & DiscInfo_Disk_Erasable;
        Vcb->PhDiskType = DiscInfo->DiskType;
        // save OPC info
        if(DiscInfo->OPCNum)
            Vcb->OPCNum = DiscInfo->OPCNum;
        UDFPrint(("DiskInfo: SN %x, OPCn %x(%x), Stat %x, Flg: %x\n",
            Vcb->PhSerialNumber, Vcb->OPCNum, DiscInfo->OPCNum, DiscInfo->DiscStat.Flags, DiscInfo->Flags.Flags));
#ifdef UDF_FORMAT_MEDIA
        if(fms && fms->opt_disk_info) {
            UserPrint(("Media type: "));
            switch(Vcb->MediaClassEx) {
            case CdMediaClass_CDROM     : UserPrint(("CD-ROM     \n")); break;
            case CdMediaClass_CDR       : UserPrint(("CD-R       \n")); break;
            case CdMediaClass_CDRW      : UserPrint(("CD-RW      \n")); break;
            case CdMediaClass_DVDROM    : UserPrint(("DVD-ROM    \n")); break;
            case CdMediaClass_DVDRAM    : UserPrint(("DVD-RAM    \n")); break;
            case CdMediaClass_DVDR      : UserPrint(("DVD-R      \n")); break;
            case CdMediaClass_DVDRW     : UserPrint(("DVD-RW     \n")); break;
            case CdMediaClass_DVDpR     : UserPrint(("DVD+R      \n")); break;
            case CdMediaClass_DVDpRW    : UserPrint(("DVD+RW     \n")); break;
            case CdMediaClass_DDCDROM   : UserPrint(("DDCD-ROM   \n")); break;
            case CdMediaClass_DDCDR     : UserPrint(("DDCD-R     \n")); break;
            case CdMediaClass_DDCDRW    : UserPrint(("DDCD-RW    \n")); break;
            case CdMediaClass_BDROM     : UserPrint(("BD-ROM     \n")); break;
            case CdMediaClass_BDRE      : UserPrint(("BD-RE      \n")); break;
            case CdMediaClass_BDR       : UserPrint(("BD-R       \n")); break;
            case CdMediaClass_HD_DVDROM : UserPrint(("HD DVD-ROM \n")); break;
            case CdMediaClass_HD_DVDRAM : UserPrint(("HD DVD-RAM \n")); break;
            case CdMediaClass_HD_DVDR   : UserPrint(("HD DVD-R   \n")); break;
            case CdMediaClass_HD_DVDRW  : UserPrint(("HD DVD-RW  \n")); break;
            default: UserPrint(("Unknown\n")); break;
            }
            UserPrint(("SN %#x, OPCn %#x\n",
                Vcb->PhSerialNumber, Vcb->OPCNum, DiscInfo->OPCNum));
            UserPrint(("Disk State: "));
            switch(DiscInfo->DiscStat.Flags & DiscInfo_Disk_Mask) {
            case DiscInfo_Disk_Empty:
                UserPrint(("Empty\n"));
                break;
            case DiscInfo_Disk_Appendable:
                UserPrint(("Appendable\n"));
                break;
            case DiscInfo_Disk_Complete:
                UserPrint(("Complete\n"));
                break;
            case DiscInfo_Disk_OtherRW:
                UserPrint(("RW in unknown state\n"));
                break;
            }
            UserPrint(("Last Session State: "));
            switch(DiscInfo->DiscStat.Flags & DiscInfo_Ses_Mask) {
            case DiscInfo_Ses_Empty:
                UserPrint(("Empty\n"));
                break;
            case DiscInfo_Ses_Incomplete:
                UserPrint(("Incomplete\n"));
                break;
            case DiscInfo_Ses_Complete:
                UserPrint(("Complete\n"));
                break;
            default:
                UserPrint(("unknown state\n"));
                break;
            }
            UserPrint(("Erasable: %s\n",
                (DiscInfo->DiscStat.Flags & DiscInfo_Disk_Erasable) ? "yes" : "no"
                ));
        }
#endif //UDF_FORMAT_MEDIA
        // Save disk status
        Vcb->DiscStat = DiscInfo->DiscStat.Flags;
        if((DiscInfo->DiscStat.Flags & DiscInfo_Disk_Mask) == DiscInfo_Disk_Empty) {
            UDFPrint(("Blank\n"));
            Vcb->BlankCD = TRUE;
        }
        if( (DiscInfo->DiscStat.Flags & DiscInfo_Disk_Mask) == DiscInfo_Disk_Empty ||
            (DiscInfo->DiscStat.Flags & DiscInfo_Ses_Mask) == DiscInfo_Ses_Incomplete) {
            // we shall mount empty disk to make it possible for
            // external applications to perform format operation
            // or something like this
            UDFPrint(("Try RAW_MOUNT\n"));
            Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
            PacketTrack = TRUE;
        }
 
#ifndef _BROWSE_UDF_
        // If drive returned reasonable value from ReadCapacity, do not use
        // last LeadIn/LeadOut
        if(Vcb->MediaClassEx != CdMediaClass_DVDpRW &&
           !ReadCapacityOk) {
            // +RW returns bad value
            UDFPrint(("+RW returns bad value\n"));
            Vcb->LastPossibleLBA = (DiscInfo->LastSesLeadOutLBA & 0x80000000) ?
                0 : DiscInfo->LastSesLeadOutLBA;
            if(!(DiscInfo->LastSesLeadInLBA & 0x80000000)) {
                Vcb->LastPossibleLBA = max(DiscInfo->LastSesLeadInLBA, Vcb->LastPossibleLBA);
            }
        }
#endif // _BROWSE_UDF_
        if((DiscInfo->Flags.Flags & DiscInfo_BGF_Mask) != 0) {
            UDFPrint(("ForceFP + MRW\n"));
            ForceFP = TRUE;
            Vcb->MRWStatus = DiscInfo->Flags.Flags & DiscInfo_BGF_Mask;
            // update addressing mode
            if(!MRWRetry) {
                UDFSetMRWMode(Vcb);
                MRWRetry = TRUE;
                goto MRWRetry_label;
            }
        }
        UDFPrint(("MRW state %x\n", Vcb->MRWStatus));
        if(Vcb->MediaClassEx == CdMediaClass_DVDRW) {
            if(Vcb->PhMediaCapFlags & CdCapFlags_RandomWritable) {
                UDFPrint(("DVD-RW Rewritable\n"));
                ForceFP = TRUE;
            } else
            if((DiscInfo->DiscStat.Flags & DiscInfo_Disk_Mask) == DiscInfo_Disk_Empty) {
                UDFPrint(("Blank DVD-RW\n"));
                ForceFP = TRUE;
            } else {
                UDFPrint(("DVD-RW Sequential\n"));
                NotFP = TRUE;
            }
        } else
        if(CdrwIsDvdOverwritable(Vcb->MediaClassEx)) {
            UDFPrint(("force Rewritable (2)\n"));
            ForceFP = TRUE;
        }
        // We have incomplete last session, so process each track from last to first
//            Vcb->LastPossibleLBA = DiscInfo->LastSesLeadInLBA;
 
        Vcb->LastSession   = DiscInfo->Status.NumOfSes;
        Vcb->LastTrackNum  = DiscInfo->Status.LastTrackNumLastSes;
        Vcb->FirstTrackNum = DiscInfo->FirstTrackNum;
        // some devices report LastTrackNum=0 for full disks
        Vcb->LastTrackNum = max(Vcb->LastTrackNum, Vcb->FirstTrackNum);
        if(!Vcb->LastTrackNum) {
            UDFPrint(("Try read 1st track...\n"));
            Vcb->LastTrackNum = 1;
        }
        UDFPrint(("DiskInfo: 1st trk %x, last trk %x\n", Vcb->FirstTrackNum, Vcb->LastTrackNum));
#ifdef UDF_FORMAT_MEDIA
        if(fms && fms->opt_disk_info) {
            UserPrint(("First track: %d\n"
                       "Last track:  %d\n", Vcb->FirstTrackNum, Vcb->LastTrackNum));
            UserPrint(("------------------------------------------\n"));
        }
#endif //UDF_FORMAT_MEDIA
 
        RC = UDFReallocTrackMap(Vcb, Vcb->LastTrackNum+1);
        if(!OS_SUCCESS(RC))
            try_return(RC);
 
        // Get last LBA from invisible track (if any)
        RtlZeroMemory(TrackInfoOut,sizeof(TRACK_INFO_BLOCK_USER_OUT));
 
        TrackInfoIn->LBA_TrkNum = 0; // invisible track
        TrackInfoIn->Track = TRUE;
 
        RC = UDFPhSendIOCTL(IOCTL_CDRW_READ_TRACK_INFO, DeviceObject,
                TrackInfoIn, sizeof(TRACK_INFO_BLOCK_USER_IN),
                TrackInfoOut,sizeof(TRACK_INFO_BLOCK_USER_OUT), TRUE, NULL);
        if(OS_SUCCESS(RC)) {
            if((Vcb->LastTrackNum < TrackInfoOut->TrackNum) &&
                TrackInfoOut->TrackLength &&
               (TrackInfoOut->TrackStartLBA != TrackInfoOut->NextWriteLBA)) {
                Vcb->LastTrackNum = TrackInfoOut->TrackNum;
                if(!(TrackInfoOut->NextWriteLBA & 0x80000000))
                    Vcb->NWA = TrackInfoOut->NextWriteLBA;
                if(TrackInfoOut->TrackLength > 1) {
                    Vcb->LastPossibleLBA =
                        TrackInfoOut->TrackStartLBA + TrackInfoOut->TrackLength - (TrackInfoOut->TrackLength ? 1 : 0);
                    UDFPrint((" set LastPossibleLBA=%x\n", Vcb->LastPossibleLBA));
                }
            }
 
            UDFPrint(("Ses %d, Track %d (%x, len %x) PckSize %x: \n"
                     "  NWA: %x (%s)  DatType:%x, %s %s %s %s TrkType:%x %s %s\n"
                     "  LRA: %x (%s)  RC_LBA:%x\n",
                TrackInfoOut->SesNum,
                0,
                TrackInfoOut->TrackStartLBA,
                TrackInfoOut->TrackLength,
                TrackInfoOut->FixPacketSize,
 
                TrackInfoOut->NextWriteLBA,
                TrackInfoOut->NWA_V & TrkInfo_NWA_V ? "vld" : "inv",
                TrackInfoOut->DataParam.Flags & TrkInfo_Dat_Mask,
                (TrackInfoOut->DataParam.Flags & TrkInfo_Packet) ? "Pck" : "",
                (TrackInfoOut->DataParam.Flags & TrkInfo_FP) ? "FP" : "",
                (TrackInfoOut->DataParam.Flags & TrkInfo_Blank) ? "Blank" : "",
                (TrackInfoOut->DataParam.Flags & TrkInfo_RT) ? "RT" : "",
 
                TrackInfoOut->TrackParam.Flags & TrkInfo_Trk_Mask,
                (TrackInfoOut->TrackParam.Flags & TrkInfo_Copy) ? "Cpy" : "",
                (TrackInfoOut->TrackParam.Flags & TrkInfo_Damage) ? "Damage" : "",
 
                TrackInfoOut->LastRecordedAddr,
                (TrackInfoOut->NWA_V & TrkInfo_LRA_V) ? "vld" : "inv",
 
                TrackInfoOut->ReadCompatLBA
                ));
#ifdef UDF_FORMAT_MEDIA
            if(fms && fms->opt_disk_info) {
                UserPrint(("Invisible track: \n"));
                UserPrint(("  Ses %d, Track %d (%x, len %x) PckSize %x: \n"
                           "    NWA: %x (%s)  DatType:%x, %s %s %s %s TrkType:%x %s %s\n"
                           "    LRA: %x (%s)  RC_LBA:%x\n",
                    TrackInfoOut->SesNum,
                    0,
                    TrackInfoOut->TrackStartLBA,
                    TrackInfoOut->TrackLength,
                    TrackInfoOut->FixPacketSize,
 
                    TrackInfoOut->NextWriteLBA,
                    TrackInfoOut->NWA_V & TrkInfo_NWA_V ? "vld" : "inv",
                    TrackInfoOut->DataParam.Flags & TrkInfo_Dat_Mask,
                    (TrackInfoOut->DataParam.Flags & TrkInfo_Packet) ? "Pck" : "",
                    (TrackInfoOut->DataParam.Flags & TrkInfo_FP) ? "FP" : "",
                    (TrackInfoOut->DataParam.Flags & TrkInfo_Blank) ? "Blank" : "",
                    (TrackInfoOut->DataParam.Flags & TrkInfo_RT) ? "RT" : "",
 
                    TrackInfoOut->TrackParam.Flags & TrkInfo_Trk_Mask,
                    (TrackInfoOut->TrackParam.Flags & TrkInfo_Copy) ? "Cpy" : "",
                    (TrackInfoOut->TrackParam.Flags & TrkInfo_Damage) ? "Damage" : "",
 
                    TrackInfoOut->LastRecordedAddr,
                    (TrackInfoOut->NWA_V & TrkInfo_LRA_V) ? "vld" : "inv",
 
                    TrackInfoOut->ReadCompatLBA
                    ));
            }
#endif //UDF_FORMAT_MEDIA
 
        }
 
        for (TrackNumber=(LONG)DiscInfo->FirstTrackNum;TrackNumber <= (LONG)Vcb->LastTrackNum;TrackNumber++) {
 
            RtlZeroMemory(TrackInfoOut,sizeof(TRACK_INFO_BLOCK_USER_OUT));
            TrackInfoIn->LBA_TrkNum = TrackNumber;
            TrackInfoIn->Track = TRUE;
 
            RC = UDFPhSendIOCTL(IOCTL_CDRW_READ_TRACK_INFO, DeviceObject,
                    TrackInfoIn, sizeof(TRACK_INFO_BLOCK_USER_IN),
                    TrackInfoOut,sizeof(TRACK_INFO_BLOCK_USER_OUT), TRUE, NULL);
            // fill sector type map
            if(TrackInfoOut->TrackStartLBA & 0x80000000) {
                UDFPrint(("TrkInfo: Bad FirstLba (%x), change to %x\n", TrackInfoOut->TrackStartLBA, 0));
                Vcb->TrackMap[TrackNumber].FirstLba = 0;
            } else {
                Vcb->TrackMap[TrackNumber].FirstLba = TrackInfoOut->TrackStartLBA;
            }
            if(TrackInfoOut->TrackLength & 0x80000000) {
                UDFPrint(("TrkInfo: Bad TrackLength (%x), change to %x\n", TrackInfoOut->TrackLength,
                    Vcb->LastPossibleLBA - Vcb->TrackMap[TrackNumber].FirstLba + 1));
                TrackInfoOut->TrackLength = Vcb->LastPossibleLBA - Vcb->TrackMap[TrackNumber].FirstLba + 1;
            }
            Vcb->TrackMap[TrackNumber].LastLba = TrackInfoOut->TrackStartLBA +
                                                 TrackInfoOut->TrackLength -
                                            (TrackInfoOut->TrackLength ? 1 : 0);
 
            Vcb->TrackMap[TrackNumber].TrackParam = TrackInfoOut->TrackParam.Flags;
            Vcb->TrackMap[TrackNumber].DataParam = TrackInfoOut->DataParam.Flags;
            Vcb->TrackMap[TrackNumber].NWA_V = TrackInfoOut->NWA_V;
            if((TrackInfoOut->NextWriteLBA & 0x80000000) ||
               (TrackInfoOut->NextWriteLBA < TrackInfoOut->TrackStartLBA)) {
                if(!(Vcb->TrackMap[TrackNumber].LastLba & 0x8000000)) {
                    UDFPrint(("TrkInfo: set NWA to LastLba (%x)\n", Vcb->TrackMap[TrackNumber].LastLba));
                    Vcb->TrackMap[TrackNumber].NWA =
                        Vcb->TrackMap[TrackNumber].LastLba;
                } else {
                    UDFPrint(("TrkInfo: set NWA to INV (1)\n"));
                    Vcb->TrackMap[TrackNumber].NWA = 0;
                    Vcb->TrackMap[TrackNumber].NWA_V = 0;
                }
            } else {
                if(!(TrackInfoOut->NextWriteLBA & 0x80000000)) {
                    UDFPrint(("TrkInfo: Good NWA (%x)\n", TrackInfoOut->NextWriteLBA));
                    Vcb->TrackMap[TrackNumber].NWA =
                        TrackInfoOut->NextWriteLBA;
                } else {
                    UDFPrint(("TrkInfo: set NWA to INV (2)\n"));
                    Vcb->TrackMap[TrackNumber].NWA = 0;
                    Vcb->TrackMap[TrackNumber].NWA_V = 0;
                }
            }
            Vcb->TrackMap[TrackNumber].Session = TrackInfoOut->SesNum;
            // for FP tracks we shall get PacketSize from returned info
            // otherwise set to default UDF value (0x20)
            if(NotFP) {
                UDFPrint(("Apply NotFP\n"));
                Vcb->TrackMap[TrackNumber].DataParam &= ~TrkInfo_FP;
#ifdef DBG
                TrackInfoOut->DataParam.Flags &= ~TrkInfo_FP;
#endif //DBG
            } else
            if(ForceFP) {
                UDFPrint(("Apply ForceFP\n"));
                PacketTrack = TRUE;
                Vcb->TrackMap[TrackNumber].DataParam |= TrkInfo_FP;
#ifdef DBG
                TrackInfoOut->DataParam.Flags |= TrkInfo_FP;
#endif //DBG
            }
            if(Vcb->TrackMap[TrackNumber].DataParam & TrkInfo_FP) {
                Vcb->TrackMap[TrackNumber].PacketSize = TrackInfoOut->FixPacketSize;
                Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
                Vcb->FP_disc = TRUE;
            } else {
                Vcb->TrackMap[TrackNumber].PacketSize = PACKETSIZE_UDF;
            }
            // presence of Damaged track means, that we should mount this disk in RAW mode
            if(Vcb->TrackMap[TrackNumber].TrackParam & TrkInfo_Damage) {
                UDFPrint(("TrkInfo_Damage, Try RAW_MOUNT\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
            }
            // presence of track with Unknown data type means, that we should mount
            // this disk in RAW mode
            if((TrackInfoOut->DataParam.Flags & TrkInfo_Dat_Mask) == TrkInfo_Trk_unknown) {
                UDFPrint(("Unknown DatType, Try RAW_MOUNT\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
            }
 
            PacketTrack |= ((TrackInfoOut->DataParam.Flags & TrkInfo_Packet) != 0);
 
            UDFPrint(("Ses %d, Track %d (%x - %x) PckSize %x: \n"
                     "  NWA: %x (%s)  DatType:%x, %s %s %s %s TrkType:%x %s %s\n"
                     "  LRA: %x (%s)  RC_LBA:%x\n",
                TrackInfoOut->SesNum,
                TrackNumber,
                Vcb->TrackMap[TrackNumber].FirstLba,
                Vcb->TrackMap[TrackNumber].LastLba,
                TrackInfoOut->FixPacketSize,
 
                TrackInfoOut->NextWriteLBA,
                TrackInfoOut->NWA_V & TrkInfo_NWA_V ? "vld" : "inv",
                TrackInfoOut->DataParam.Flags & TrkInfo_Dat_Mask,
                (TrackInfoOut->DataParam.Flags & TrkInfo_Packet) ? "Pck" : "",
                (TrackInfoOut->DataParam.Flags & TrkInfo_FP) ? "FP" : "",
                (TrackInfoOut->DataParam.Flags & TrkInfo_Blank) ? "Blank" : "",
                (TrackInfoOut->DataParam.Flags & TrkInfo_RT) ? "RT" : "",
 
                TrackInfoOut->TrackParam.Flags & TrkInfo_Trk_Mask,
                (TrackInfoOut->TrackParam.Flags & TrkInfo_Copy) ? "Cpy" : "",
                (TrackInfoOut->TrackParam.Flags & TrkInfo_Damage) ? "Damage" : "",
 
                TrackInfoOut->LastRecordedAddr,
                (TrackInfoOut->NWA_V & TrkInfo_LRA_V) ? "vld" : "inv",
 
                TrackInfoOut->ReadCompatLBA
                ));
#ifdef UDF_FORMAT_MEDIA
            if(fms && fms->opt_disk_info) {
                UserPrint(("Track %d: \n", TrackNumber));
                UserPrint(("  Ses %d, Track %d (%x, len %x) PckSize %x: \n"
                           "    NWA: %x (%s)  DatType:%x, %s %s %s %s TrkType:%x %s %s\n"
                           "    LRA: %x (%s)  RC_LBA:%x\n",
                    TrackInfoOut->SesNum,
                    TrackNumber,
                    TrackInfoOut->TrackStartLBA,
                    TrackInfoOut->TrackLength,
                    TrackInfoOut->FixPacketSize,
 
                    TrackInfoOut->NextWriteLBA,
                    TrackInfoOut->NWA_V & TrkInfo_NWA_V ? "vld" : "inv",
                    TrackInfoOut->DataParam.Flags & TrkInfo_Dat_Mask,
                    (TrackInfoOut->DataParam.Flags & TrkInfo_Packet) ? "Pck" : "",
                    (TrackInfoOut->DataParam.Flags & TrkInfo_FP) ? "FP" : "",
                    (TrackInfoOut->DataParam.Flags & TrkInfo_Blank) ? "Blank" : "",
                    (TrackInfoOut->DataParam.Flags & TrkInfo_RT) ? "RT" : "",
 
                    TrackInfoOut->TrackParam.Flags & TrkInfo_Trk_Mask,
                    (TrackInfoOut->TrackParam.Flags & TrkInfo_Copy) ? "Cpy" : "",
                    (TrackInfoOut->TrackParam.Flags & TrkInfo_Damage) ? "Damage" : "",
 
                    TrackInfoOut->LastRecordedAddr,
                    (TrackInfoOut->NWA_V & TrkInfo_LRA_V) ? "vld" : "inv",
 
                    TrackInfoOut->ReadCompatLBA
                    ));
            }
#endif //UDF_FORMAT_MEDIA
 
            if(TrackNumber == DiscInfo->FirstTrackNum) {
                if(!(Vcb->TrackMap[TrackNumber].FirstLba & 0x80000000)) {
                    UDFPrint(("TrkInfo: Update FirstLBA (%x)\n", Vcb->TrackMap[TrackNumber].FirstLba));
                    Vcb->FirstLBA = Vcb->TrackMap[TrackNumber].FirstLba;
                }
            }
            if((TrackInfoOut->SesNum == Vcb->LastSession) && !Vcb->FirstTrackNumLastSes) {
                if(!(Vcb->TrackMap[TrackNumber].FirstLba & 0x80000000)) {
                    UDFPrint(("TrkInfo: Update FirstLBALastSes (%x)\n", Vcb->TrackMap[TrackNumber].FirstLba));
                    Vcb->FirstLBALastSes = Vcb->TrackMap[TrackNumber].FirstLba;
                }
                Vcb->FirstTrackNumLastSes = TrackNumber;
            }
        }
 
        if(!(TrackInfoOut->NextWriteLBA & 0x80000000) &&
           !(TrackInfoOut->TrackLength  & 0x80000000) &&
            (Vcb->NWA < TrackInfoOut->NextWriteLBA)
           ) {
            UDFPrint((" set NWA to %x\n", TrackInfoOut->NextWriteLBA));
            if(Vcb->MediaClassEx != CdMediaClass_DVDpRW) {
                Vcb->NWA = TrackInfoOut->NextWriteLBA;
            } else {
                Vcb->NWA =
                    TrackInfoOut->TrackStartLBA + TrackInfoOut->TrackLength - (TrackInfoOut->TrackLength ? 1 : 0);
            }
        }
        if(Vcb->MediaClassEx != CdMediaClass_DVDpRW &&
           !(TrackInfoOut->TrackLength & 0x80000000) &&
           TrackInfoOut->TrackLength > 1) {
            Vcb->LastPossibleLBA =
                TrackInfoOut->TrackStartLBA + TrackInfoOut->TrackLength - (TrackInfoOut->TrackLength ? 1 : 0);
            UDFPrint((" set LastPossibleLBA=%x\n", Vcb->LastPossibleLBA));
        }
        TrackNumber = Vcb->LastTrackNum;
        // quick formatted +RW returns bogus value
        if(Vcb->MediaClassEx == CdMediaClass_DVDpRW) {
            UDFPrint((" check quick formatted +RW\n"));
            if(Vcb->TrackMap[TrackNumber].LastLba &&
               !(Vcb->TrackMap[TrackNumber].LastLba & 0x80000000) &&
               Vcb->TrackMap[TrackNumber].LastLba < Vcb->LastPossibleLBA /*&&
               Vcb->TrackMap[TrackNumber].LastLba != Vcb->LastPossibleLBA*/
               ) {
                UDFPrint((" track LastLBA %x != LastPossibleLBA %x, verify\n",
                    Vcb->TrackMap[TrackNumber].LastLba, Vcb->LastPossibleLBA));
 
                if(Vcb->MRWStatus == DiscInfo_BGF_Complete) {
                    UDFPrint((" complete MRW state\n"));
#ifdef _BROWSE_UDF_
                    Vcb->LastPossibleLBA =
                    Vcb->NWA =
                    Vcb->LastLBA =
                    Vcb->TrackMap[TrackNumber].LastLba;
                    goto valid_track_length;
#endif // _BROWSE_UDF_
                } else
                if(Vcb->MRWStatus) {
                    uint8* buff;
                    SIZE_T ReadBytes;
 
                    UDFPrint((" MRW state %x\n", Vcb->MRWStatus));
 
                    buff = (uint8*)DbgAllocatePoolWithTag(NonPagedPool, Vcb->WriteBlockSize, 'bNWD' );
                    if(buff) {
                        RC = UDFTRead(Vcb,
                                       buff,
                                       Vcb->WriteBlockSize,
                                       Vcb->TrackMap[TrackNumber].LastLba+1,
                                       &ReadBytes,
                                       PH_TMP_BUFFER);
                        DbgFreePool(buff);
                        if(!OS_SUCCESS(RC)) {
                            UDFPrint((" Can't read beyond track LastLBA (%x)\n", Vcb->TrackMap[TrackNumber].LastLba+1));
                            Vcb->LastLBA = Vcb->TrackMap[TrackNumber].LastLba;
                            Vcb->NWA = Vcb->LastLBA+1;
                            Vcb->TrackMap[TrackNumber].NWA_V = 1;
                            Vcb->TrackMap[TrackNumber].NWA = Vcb->NWA;
                            Vcb->TrackMap[TrackNumber].LastLba = Vcb->LastPossibleLBA;
                            RC = STATUS_SUCCESS;
                            goto valid_track_length;
                        }
                    }
                }
            }
            UDFPrint((" set track LastLBA %x\n", Vcb->LastPossibleLBA));
            Vcb->NWA =
            Vcb->LastLBA =
            Vcb->TrackMap[TrackNumber].LastLba =
                Vcb->LastPossibleLBA;
        }
valid_track_length:
        // Test for last empty session
        if((Vcb->TrackMap[TrackNumber].Session !=
            Vcb->TrackMap[TrackNumber-1].Session) &&
           (Vcb->LastSession > 1)) {
            // Note: some devices return negative track length
            if((Vcb->TrackMap[TrackNumber].LastLba <=
                Vcb->TrackMap[TrackNumber].FirstLba) ||
               (Vcb->TrackMap[TrackNumber].FirstLba ==
                Vcb->TrackMap[TrackNumber].NWA)) {
                // empty last session...
                Vcb->LastTrackNum--;
//                TrackNumber--;
/*                for(SesNum = Vcb->TrackMap[TrackNumber].Session;
                    Vcb->TrackMap[TrackNumber].Session == SesNum;
                    TrackNumber--) {
                }*/
                if(TrackNumber>1)
                    Vcb->LastSession = Vcb->TrackMap[TrackNumber-1].Session;
            }
        }
 
        TrackNumber = Vcb->LastTrackNum;
#ifdef _BROWSE_UDF_
        Vcb->LastLBA = min(Vcb->TrackMap[TrackNumber].LastLba, Vcb->TrackMap[TrackNumber].NWA);
#endif //_BROWSE_UDF_
 
        if(Vcb->TrackMap[TrackNumber].NWA_V & TrkInfo_NWA_V) {
            UDFPrint((" NWA ok, set LastLBA to min(Last %x, NWA %x\n",
                Vcb->TrackMap[TrackNumber].LastLba,
                Vcb->TrackMap[TrackNumber].NWA));
            Vcb->LastLBA = min(Vcb->TrackMap[TrackNumber].LastLba, Vcb->TrackMap[TrackNumber].NWA);
        } else {
            UDFPrint((" no NWA, set LastLBA to Last %x\n", Vcb->TrackMap[TrackNumber].LastLba));
            Vcb->LastLBA = Vcb->TrackMap[TrackNumber].LastLba;
        }
 
        Vcb->VCBFlags |= UDF_VCB_FLAGS_TRACKMAP;
        if(!PacketTrack && Vcb->MediaClassEx != CdMediaClass_DVDRAM ) {
            UDFPrint((" disable Raw mount\n"));
            Vcb->VCBFlags &= ~UDF_VCB_FLAGS_RAW_DISK;
        }
 
try_exit:    NOTHING;
 
    } _SEH2_FINALLY {
        if(DiscInfo) MyFreePool__(DiscInfo);
        if(TrackInfoOut) MyFreePool__(TrackInfoOut);
    } _SEH2_END;
 
    return RC;
} // end UDFReadDiscTrackInfo()

Referenced by UDFGetDiskInfo().

UDFReallocTrackMap()

OSSTATUS UDFReallocTrackMap	(	IN PVCB	Vcb,
		IN uint32	TrackNum
	)

Definition at line 69 of file phys_lib.cpp.

{
#ifdef _BROWSE_UDF_
    if(Vcb->TrackMap) {
        MyFreePool__(Vcb->TrackMap);
        Vcb->TrackMap = NULL;
    }
    Vcb->TrackMap = (PUDFTrackMap)
        MyAllocatePool__(NonPagedPool, TrackNum*sizeof(UDFTrackMap));
    if(!Vcb->TrackMap) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
#endif //_BROWSE_UDF_
    RtlZeroMemory(Vcb->TrackMap,TrackNum*sizeof(UDFTrackMap));
    return STATUS_SUCCESS;
} // end UDFReallocTrackMap()

Referenced by UDFReadAndProcessFullToc(), UDFReadDiscTrackInfo(), and UDFUseStandard().

UDFRecoverFromError()

OSSTATUS UDFRecoverFromError	(	IN PVCB	Vcb,
		IN BOOLEAN	WriteOp,
		IN OSSTATUS	status,
		IN uint32	Lba,
		IN uint32	BCount,
		IN OUT uint32 *	retry
	)

Definition at line 1283 of file phys_lib.cpp.

{
    PGET_LAST_ERROR_USER_OUT Error = NULL;
    LARGE_INTEGER delay;
//    OSSTATUS RC;
    uint32 i;
    BOOLEAN UpdateBB = FALSE;
 
    if(!(*retry) ||
       !(Vcb->VCBFlags & UDF_VCB_FLAGS_OUR_DEVICE_DRIVER) ||
        (Vcb->FsDeviceType != FILE_DEVICE_CD_ROM_FILE_SYSTEM))
        return status;
    (*retry)--;
    // allocate tmp buffer
    _SEH2_TRY {
        if(!Vcb->Error) {
            if(!(Vcb->Error = (PGET_LAST_ERROR_USER_OUT)
                            MyAllocatePool__(NonPagedPool, sizeof(GET_LAST_ERROR_USER_OUT))))
                try_return(status);
        }
        if(status == STATUS_NO_SUCH_DEVICE) {
            UDFPrint(("Error recovery: STATUS_NO_SUCH_DEVICE, die.....\n"));
            Vcb->VCBFlags |= UDF_VCB_FLAGS_UNSAFE_IOCTL | UDF_VCB_FLAGS_DEAD;
            try_return(status);
        }
 
#ifdef _UDF_STRUCTURES_H_
        if(status == STATUS_NO_MEDIA_IN_DEVICE && !Vcb->EjectWaiter) {
            UDFPrint(("Error recovery: STATUS_NO_MEDIA_IN_DEVICE, prevent further remount.....\n"));
            // Make sure, that volume will never be quick-remounted
            // It is very important for ChkUdf utility and
            // some CD-recording libraries
            Vcb->SerialNumber--;
            try_return(status);
        }
#endif //_UDF_STRUCTURES_H_
 
        Error = Vcb->Error;
        UDFPhSendIOCTL( IOCTL_CDRW_GET_LAST_ERROR, Vcb->TargetDeviceObject,
                        NULL,0,
                        Error,sizeof(GET_LAST_ERROR_USER_OUT),
                        TRUE,NULL);
        UDFPrint(("SK=%x ASC=%x, ASCQ=%x, IE=%x\n",
                 Error->SenseKey, Error->AdditionalSenseCode, Error->AdditionalSenseCodeQualifier, Error->LastError));
        // check for Long Write In Progress
        if( ((Error->SenseKey == SCSI_SENSE_NOT_READY) &&
             (Error->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY) &&
             (Error->AdditionalSenseCodeQualifier == SCSI_SENSEQ_LONG_WRITE_IN_PROGRESS)) ) {
            // we should wait...
            if(WriteOp) {
                if((*retry) == UDF_WRITE_MAX_RETRY-1) {
                    UDFPrint(("Error recovery: reserve retry count for write retries\n"));
                    (*retry) = UDF_WRITE_MAX_RETRY*3;
                } else
                if((*retry) == UDF_WRITE_MAX_RETRY) {
                    UDFPrint(("Error recovery: jump over UDF_WRITE_MAX_RETRY\n"));
                    (*retry)--;
                }
                delay.QuadPart = -500000; // 0.05 sec
                KeDelayExecutionThread(KernelMode, FALSE, &delay);
                if(WriteOp && ((*retry) > UDF_WRITE_MAX_RETRY-1)) {
                    UDFPrint(("Error recovery: simple write retry with delay\n"));
                    try_return(status = STATUS_SUCCESS);
                }
            } else {
                delay.QuadPart = -500000; // 0.05 sec
                KeDelayExecutionThread(KernelMode, FALSE, &delay);
                if((*retry) == UDF_WRITE_MAX_RETRY-1) {
                    UDFPrint(("Error recovery: retry read after small delay\n"));
                    try_return(status = STATUS_SUCCESS);
                }
            }
            UDFPrint(("Error recovery: sync cache\n"));
            // ...flush device cache...
            UDFSyncCache(Vcb);
            // wait again & retry
            delay.QuadPart = -1000000; // 0.1 sec
            KeDelayExecutionThread(KernelMode, FALSE, &delay);
#ifdef _UDF_STRUCTURES_H_
            if(Vcb->BGWriters) (*retry)++;
#endif //_UDF_STRUCTURES_H_
            try_return(status = STATUS_SUCCESS);
        } else
        // check for Long Write In Progress
        if((Error->SenseKey == SCSI_SENSE_NOT_READY) &&
           (Error->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY) &&
          ((Error->AdditionalSenseCodeQualifier == SCSI_SENSEQ_FORMAT_IN_PROGRESS) ||
           (Error->AdditionalSenseCodeQualifier == SCSI_SENSEQ_BECOMING_READY) ||
           (Error->AdditionalSenseCodeQualifier == SCSI_SENSEQ_OPERATION_IN_PROGRESS) ) ) {
            // we should wait & retry
            UDFPrint(("Error recovery: op. in progress, waiting 0.3 sec\n"));
            delay.QuadPart = -3000000; // 0.3 sec
            KeDelayExecutionThread(KernelMode, FALSE, &delay);
#ifdef _UDF_STRUCTURES_H_
            if(Vcb->BGWriters) (*retry)++;
#endif //_UDF_STRUCTURES_H_
            Vcb->SyncCacheState = SYNC_CACHE_RECOVERY_ATTEMPT;
            try_return(status = STATUS_SUCCESS);
        } else
        // check for non empty cache special case
        if((Error->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
           (Error->AdditionalSenseCode == SCSI_ADSENSE_INVALID_CMD_SEQUENCE)) {
            // we should wait & retry
            if(!WriteOp) {
                UDFPrint(("Error recovery: invalid command sequence on read\n"));
                delay.QuadPart = -1000000; // 0.1 sec
                KeDelayExecutionThread(KernelMode, FALSE, &delay);
                UDFPrint(("Error recovery: sync cache\n"));
                // ...flush device cache...
                UDFSyncCache(Vcb);
                // wait again & retry
                delay.QuadPart = -1000000; // 0.1 sec
                KeDelayExecutionThread(KernelMode, FALSE, &delay);
#ifdef _UDF_STRUCTURES_H_
                if(Vcb->BGWriters) (*retry)++;
#endif //_UDF_STRUCTURES_H_
                try_return(status = STATUS_SUCCESS);
            }
            goto reinit_sector_mode;
        } else
        // check for Bus Reset (sometimes it happends...)
        if((Error->SenseKey == SCSI_SENSE_UNIT_ATTENTION) &&
           (Error->AdditionalSenseCode == SCSI_ADSENSE_BUS_RESET) ) {
            // we should wait
            UDFPrint(("Error recovery: bus reset...\n"));
            Vcb->MediaChangeCount = Error->MediaChangeCount;
            delay.QuadPart = -1000000; // 0.1 sec
            KeDelayExecutionThread(KernelMode, FALSE, &delay);
            // reset driver
            UDFResetDeviceDriver(Vcb, Vcb->TargetDeviceObject, FALSE);
            delay.QuadPart = -1000000; // 0.1 sec
            KeDelayExecutionThread(KernelMode, FALSE, &delay);
            // lock it
/*            ((PPREVENT_MEDIA_REMOVAL_USER_IN)(Error))->PreventMediaRemoval = TRUE;
            UDFPhSendIOCTL( IOCTL_STORAGE_MEDIA_REMOVAL,
                                 Vcb->TargetDeviceObject,
                                 Error,sizeof(PREVENT_MEDIA_REMOVAL_USER_IN),
                                 NULL,0,
                                 FALSE,NULL);
            delay.QuadPart = -1000000; // 0.1 sec
            KeDelayExecutionThread(KernelMode, FALSE, &delay);*/
 
            // reinit write mode the following is performed inside UDFResetDeviceDriver()
            //Vcb->LastModifiedTrack = 0;
            //Vcb->OPCDone = FALSE;
 
reinit_sector_mode:
            // reinit sector mode
            Vcb->LastModifiedTrack = 0;
            UDFPrepareForWriteOperation(Vcb, Lba, BCount);
            try_return(status = STATUS_SUCCESS);
        } else
        // check for Illegal Sector Mode.
        // We can get this error 'cause of 2 reasons:
        // a) Bus reset occured. We should reinit
        // b) CopyProtection settings missmatch
        // c) preblems with DNA of firmware developer, some TEACs fall into such state
        //    after failed streaming read
        if((Error->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
           (Error->AdditionalSenseCode == SCSI_ADSENSE_ILLEGAL_MODE_FOR_THIS_TRACK)) {
bad_rw_seek_recovery:
            if(WriteOp) {
 
                if((*retry) <= 1) {
                    // Variate CopyProtection...
                    for(i=Vcb->FirstTrackNum; i<=Vcb->LastTrackNum; i++) {
                        if((Vcb->TrackMap[i].FirstLba > Lba) ||
                           (Vcb->TrackMap[i].LastLba < Lba))
                            continue;
    /*                    if(Vcb->TrackMap[i].Flags & TrackMap_CopyBit_variated)
                            // Last chance....
                            goto reinit_sector_mode;*/
 
                        // check if we have successuflly completed WriteOp
                        // using Variation.
                        // We should not variate these bits again in this case.
                        if(Vcb->TrackMap[i].Flags & TrackMap_Use_variation)
                            break;
                        Vcb->TrackMap[i].Flags &= ~TrackMap_Try_variation;
    /*                    if((Vcb->TrackMap[i].Flags & TrackMap_Try_variation) &&
                           (Vcb->TrackMap[i].Flags & (TrackMap_AllowCopyBit_variated |
                                                      TrackMap_CopyBit_variated)))
                            break;*/
    /*                    if(Vcb->TrackMap[i].Flags & TrackMap_Use_variation)
                            break;*/
                        Vcb->TrackMap[i].Flags |= TrackMap_Try_variation;
                        // Try variation.
                        if(!(Vcb->TrackMap[i].Flags ^= TrackMap_AllowCopyBit_variated))
                            Vcb->TrackMap[i].Flags ^= TrackMap_CopyBit_variated;
                        if(Vcb->TrackMap[i].Flags & (TrackMap_AllowCopyBit_variated |
                                                     TrackMap_CopyBit_variated) ) {
                            (*retry) = 1;
                        } else {
                            Vcb->TrackMap[i].Flags &= ~TrackMap_Try_variation;
                        }
                        // reinit sector mode
                        Vcb->LastModifiedTrack = 0;
                        UDFPrepareForWriteOperation(Vcb, Lba, BCount);
                        break;
                    }
                } else {
                    // Reinit...
//reinit_sector_mode:
                    // we should wait
                    delay.QuadPart = -1000000; // 0.1 sec
                    KeDelayExecutionThread(KernelMode, FALSE, &delay);
                    // reinit sector mode
                    goto reinit_sector_mode;
/*
                    Vcb->LastModifiedTrack = 0;
                    UDFPrepareForWriteOperation(Vcb, Lba, BCount);
                    try_return(status = STATUS_SUCCESS);
*/
                }
            } else
            if((Vcb->CompatFlags & UDF_VCB_IC_BAD_RW_SEEK) &&
               (Vcb->IncrementalSeekState != INCREMENTAL_SEEK_DONE)) {
                UDFPrint(("Using incremental seek workaround...\n"));
                Vcb->IncrementalSeekState = INCREMENTAL_SEEK_WORKAROUND;
                try_return(status = STATUS_SUCCESS);
            } else {
                UDFPrint(("Seems to be BB @ %x\n", Lba));
                UpdateBB = TRUE;
            }
        } else
        if((Error->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
           (Error->AdditionalSenseCode == SCSI_ADSENSE_INVALID_SESSION_MODE)) {
            if(WriteOp &&
               (Vcb->SavedFeatures & CDRW_FEATURE_STREAMING) &&
               Lba+BCount <= Vcb->LastLBA+1) {
                UDFPrint(("bad Session in streaming mode. Lba %x, try fix-up\n", Lba));
                // ...flush device cache...
                UDFSyncCache(Vcb);
                // we should wait
                delay.QuadPart = -10000000; // 1 sec
                KeDelayExecutionThread(KernelMode, FALSE, &delay);
                try_return(status = STATUS_SUCCESS);
            }
        } else
        if((Error->LastError == CDRW_ERR_WRITE_IN_PROGRESS_BUSY) ||
           (status == STATUS_DEVICE_BUSY)) {
            delay.QuadPart = -5000000; // 0.5 sec
            UDFPrint(("CDRW_ERR_WRITE_IN_PROGRESS_BUSY || STATUS_DEVICE_BUSY\n"));
            KeDelayExecutionThread(KernelMode, FALSE, &delay);
#ifdef _UDF_STRUCTURES_H_
            if(Vcb->BGWriters) (*retry)++;
#endif //_UDF_STRUCTURES_H_
            try_return(status = STATUS_SUCCESS);
        } else
        // some devices (SONY) return such a strange sequence....
        if( ((Error->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
             (Error->AdditionalSenseCode == SCSI_ADSENSE_INVALID_CDB)) &&
              WriteOp) {
            // reinit write mode
            Vcb->LastModifiedTrack = 0;
            UDFPrepareForWriteOperation(Vcb, Lba, BCount);
            try_return(status = STATUS_SUCCESS);
        } else
        // No seek on Read... to morgue, I'm afraid
        if((Error->SenseKey == SCSI_SENSE_MEDIUM_ERROR) /*&&
           ((Error->AdditionalSenseCode == SCSI_ADSENSE_CD_READ_ERROR) ||
            (Error->AdditionalSenseCode == SCSI_ADSENSE_NO_SENSE) ||
            (Error->AdditionalSenseCode == SCSI_ADSENSE_FORMAT_CORRUPTED) ||
            (Error->AdditionalSenseCode == SCSI_ADSENSE_SEEK_ERROR))*/ &&
           !WriteOp) {
            if(Error->AdditionalSenseCode == SCSI_ADSENSE_SEEK_ERROR) {
                UDFPrint(("Seek error\n"));
                if(Vcb->CompatFlags & UDF_VCB_IC_BAD_RW_SEEK) {
                    UDFPrint(("try recovery\n"));
                    goto bad_rw_seek_recovery;
                }
                UDFPrint(("map error to STATUS_NONEXISTENT_SECTOR\n"));
                status = STATUS_NONEXISTENT_SECTOR;
            }
            UDFPrint(("Seems to be BB @ %x (read 2)\n", Lba));
            UpdateBB = TRUE;
        } else
        // handle invalid block address
        if( ((Error->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
             (Error->AdditionalSenseCode == SCSI_ADSENSE_ILLEGAL_BLOCK)) ) {
            if(!WriteOp &&
               (Vcb->SavedFeatures & CDRW_FEATURE_STREAMING) &&
               Lba+BCount <= Vcb->LastLBA+1) {
                UDFPrint(("bad LBA %x in streaming mode, try fix-up\n", Lba));
                // ...flush device cache...
                UDFSyncCache(Vcb);
                try_return(status = STATUS_SUCCESS);
            }
 
            if((Lba+BCount >= Vcb->LastLBA) &&
               (Vcb->MRWStatus == DiscInfo_BGF_Interrupted)) {
                UDFPrint(("stupid drive, cannot read beyond formatted area on DiscInfo_BGF_Interrupted\n"));
                UpdateBB = FALSE;
                try_return(status = STATUS_BUFFER_ALL_ZEROS);
            }
            // prevent Bad Block Bitmap modification
        }
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
#ifdef UDF_DBG
        if(OS_SUCCESS(status)) {
            UDFPrint(("Retry\n"));
        }
#endif //UDF_DBG
    } _SEH2_END;
    if(!OS_SUCCESS(status)) {
        if((Vcb->MountPhErrorCount != (ULONG)-1) &&
           (Vcb->MountPhErrorCount < 0x7fffffff)) {
            Vcb->MountPhErrorCount++;
        }
//#ifdef _UDF_STRUCTURES_H_
        if(UpdateBB && (BCount == 1)) {
            uint32* bm;
            if(!(bm = (uint32*)(Vcb->BSBM_Bitmap))) {
                bm = (uint32*)(Vcb->BSBM_Bitmap = (int8*)DbgAllocatePoolWithTag(NonPagedPool, (i = (Vcb->LastPossibleLBA+1+7)>>3), 'mNWD' ));
                if(bm) {
                    RtlZeroMemory(bm, i);
                } else {
                    UDFPrint(("Can't alloc BSBM for %x blocks\n", Vcb->LastPossibleLBA));
                }
            }
            if(bm) {
                UDFSetBit(bm, Lba);
                UDFPrint(("Set BB @ %#x\n", Lba));
            }
#ifdef _BROWSE_UDF_
            bm = (uint32*)(Vcb->FSBM_Bitmap);
            if(bm) {
                UDFSetUsedBit(bm, Lba);
                UDFPrint(("Set BB @ %#x as used\n", Lba));
            }
#endif //_BROWSE_UDF_
        }
//#endif //_UDF_STRUCTURES_H_
    }
    return status;
} // end UDFRecoverFromError()

Referenced by UDFPrepareForWriteOperation(), UDFTRead(), and UDFTWrite().

UDFResetDeviceDriver()

OSSTATUS UDFResetDeviceDriver	(	IN PVCB	Vcb,
		IN PDEVICE_OBJECT	TargetDeviceObject,
		IN BOOLEAN	Unlock
	)

Definition at line 4199 of file phys_lib.cpp.

{
    PCDRW_RESET_DRIVER_USER_IN tmp = (PCDRW_RESET_DRIVER_USER_IN)
        MyAllocatePool__(NonPagedPool, sizeof(CDRW_RESET_DRIVER_USER_IN));
    OSSTATUS RC;
    if(!tmp)
        return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(tmp, sizeof(CDRW_RESET_DRIVER_USER_IN));
    tmp->UnlockTray = (Unlock ? 1 : 0);
    tmp->MagicWord = 0x3a6 | (Unlock ? 1 : 0);
    RC = UDFPhSendIOCTL(IOCTL_CDRW_RESET_DRIVER_EX, TargetDeviceObject,
        tmp, sizeof(CDRW_RESET_DRIVER_USER_IN), NULL, 0, TRUE,NULL);
    if(Vcb) {
        Vcb->LastReadTrack = 0;
        Vcb->LastModifiedTrack = 0;
        Vcb->OPCDone = FALSE;
        if((Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) &&
           Vcb->TargetDeviceObject) {
            // limit both read & write speed to last write speed for CAV mode
            // some drives damage data when speed is adjusted during recording process
            // even in packet mode
            UDFSetSpeeds(Vcb);
        }
        UDFSetCaching(Vcb);
    }
 
    MyFreePool__(tmp);
    return RC;
} // end UDFResetDeviceDriver()

Referenced by UDFCommonCleanup(), UDFDoDismountSequence(), UDFGetDiskInfo(), UDFMountVolume(), and UDFRecoverFromError().

UDFSetCaching()

NTSTATUS UDFSetCaching

(

IN PVCB

Vcb

)

Definition at line 4263 of file phys_lib.cpp.

{
#pragma pack(push,1)
    struct {
        MODE_PARAMETER_HEADER    Header;
        MODE_CACHING_PAGE        Data;
        CHAR Padding [16];
    } CachingPage;
 
    struct {
        MODE_PARAMETER_HEADER         Header;
        MODE_READ_WRITE_RECOVERY_PAGE Data;
        CHAR Padding [16];
    } RecoveryPage;
#ifdef _MSC_VER
#pragma pack(pop,1)
#else
#pragma pack(pop)
#endif
 
    MODE_SENSE_USER_IN ModeSenseCtl;
    OSSTATUS RC;
 
    UDFPrint(("UDFSetCaching:\n"));
 
    ModeSenseCtl.PageCode.Byte = MODE_PAGE_ERROR_RECOVERY;
    RC = UDFPhSendIOCTL(IOCTL_CDRW_MODE_SENSE, Vcb->TargetDeviceObject,
                    &ModeSenseCtl,sizeof(ModeSenseCtl),
                    (PVOID)&RecoveryPage,sizeof(RecoveryPage),
                    FALSE, NULL);
    if(OS_SUCCESS(RC)) {
        UDFPrint(("  Error recovery page:\n"
            "PageCode         %d\n"
            "PageLength       %d\n"
 
            "DCRBit %d\n"
            "DTEBit %d\n"
            "PERBit %d\n"
            "EERBit %d\n"
            "RCBit  %d\n"
            "TBBit  %d\n"
            "ARRE   %d\n"
            "AWRE   %d\n"
 
            "ReadRetryCount %d\n"
            "CorrectionSpan %d\n"
            "HeadOffsetCount %d\n"
            "DataStrobOffsetCount %d\n"
 
            "ErrorRecoveryParam2.Fields.EMCDR %d\n"
 
            "WriteRetryCount %d\n",
 
            RecoveryPage.Data.PageCode,
            RecoveryPage.Data.PageLength,
 
            RecoveryPage.Data.ErrorRecoveryParam.Fields.DCRBit,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.DTEBit,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.PERBit,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.EERBit,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.RCBit,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.TBBit,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.ARRE,
            RecoveryPage.Data.ErrorRecoveryParam.Fields.AWRE,
 
            RecoveryPage.Data.ReadRetryCount,
            RecoveryPage.Data.CorrectionSpan,
            RecoveryPage.Data.HeadOffsetCount,
            RecoveryPage.Data.DataStrobOffsetCount,
 
            RecoveryPage.Data.ErrorRecoveryParam2.Fields.EMCDR,
 
            RecoveryPage.Data.WriteRetryCount
 
        ));
    }
 
    ModeSenseCtl.PageCode.Byte = MODE_PAGE_CACHING;
    RC = UDFPhSendIOCTL(IOCTL_CDRW_MODE_SENSE, Vcb->TargetDeviceObject,
                    &ModeSenseCtl,sizeof(ModeSenseCtl),
                    (PVOID)&CachingPage,sizeof(CachingPage),
                    FALSE, NULL);
    if(!OS_SUCCESS(RC)) {
        return RC;
    }
 
    UDFPrint(("  Caching page:\n"
        "PageCode         %d\n"
        "PageLength       %d\n"
        "ReadDisableCache %d\n"
        "MultiplicationFactor %d\n"
        "WriteCacheEnable %d\n"
        "WriteRetensionPriority %d\n"
        "ReadRetensionPriority  %d\n",
 
        CachingPage.Data.PageCode,
        CachingPage.Data.PageLength,
        CachingPage.Data.ReadDisableCache,
        CachingPage.Data.MultiplicationFactor,
        CachingPage.Data.WriteCacheEnable,
        CachingPage.Data.WriteRetensionPriority,
        CachingPage.Data.ReadRetensionPriority
    ));
 
    RtlZeroMemory(&CachingPage.Header, sizeof(CachingPage.Header));
    CachingPage.Data.PageCode = MODE_PAGE_CACHING;
    CachingPage.Data.PageSavable = 0;
    if( CachingPage.Data.ReadDisableCache ||
       !CachingPage.Data.WriteCacheEnable) {
        CachingPage.Data.ReadDisableCache = 0;
        CachingPage.Data.WriteCacheEnable = 1;
        RC = UDFPhSendIOCTL(IOCTL_CDRW_MODE_SELECT, Vcb->TargetDeviceObject,
                        (PVOID)&CachingPage,sizeof(CachingPage.Header) + 2 + CachingPage.Data.PageLength,
                        NULL,0,
                        FALSE, NULL);
    } else {
        RC = STATUS_SUCCESS;
    }
    UDFPrint(("UDFSetCaching: %x\n", RC));
    return RC;
} // end UDFSetCaching()

Referenced by UDFGetDiskInfo(), and UDFResetDeviceDriver().

UDFSetMRWMode()

NTSTATUS UDFSetMRWMode

(

IN PVCB

Vcb

)

Definition at line 811 of file phys_lib.cpp.

{
    GET_MRW_MODE_USER_OUT MRWPage;
    OSSTATUS RC;
 
    if(Vcb->MediaClassEx != CdMediaClass_CDRW)
        return STATUS_SUCCESS;
//#ifdef _BROWSE_UDF_
    if(Vcb->CompatFlags & UDF_VCB_IC_MRW_ADDR_PROBLEM)
        return STATUS_SUCCESS;
//#endif //_BROWSE_UDF_
 
    if(!Vcb->MRWStatus) {
        UDFPrint(("Non-MRW disk. Skip setting MRW_MODE\n"));
        return STATUS_SUCCESS;
    }
    UDFPrint(("try set MRW_MODE\n"));
    RC = UDFPhSendIOCTL(IOCTL_CDRW_GET_MRW_MODE, Vcb->TargetDeviceObject,
                    NULL,0,
                    (PVOID)&MRWPage,sizeof(MRWPage),
                    FALSE, NULL);
    if(!NT_SUCCESS(RC)) {
        return RC;
    }
    UDFPrint(("GET_MRW_MODE ok (current %x)\n", MRWPage.AddressMode));
    MRWPage.AddressMode = Vcb->MRWStatus ? 0 : MrwPage_use_GAA;
    UDFPrint(("SET_MRW_MODE %x\n", MRWPage.AddressMode));
    RC = UDFPhSendIOCTL(IOCTL_CDRW_SET_MRW_MODE, Vcb->TargetDeviceObject,
                    (PVOID)&MRWPage,sizeof(MRWPage),
                    NULL,0,
                    FALSE, NULL);
    UDFPrint(("SET_MRW_MODE status %x\n", RC));
 
    return STATUS_SUCCESS;
} // end UDFSetMRWMode()

Referenced by UDFPrepareForReadOperation(), UDFPrepareForWriteOperation(), and UDFReadDiscTrackInfo().

UDFSetSpeeds()

OSSTATUS UDFSetSpeeds

(

IN PVCB

Vcb

)

Definition at line 4234 of file phys_lib.cpp.

{
    OSSTATUS RC;
 
    RtlZeroMemory(&(Vcb->SpeedBuf), sizeof(SET_CD_SPEED_EX_USER_IN));
    if(Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) {
        Vcb->SpeedBuf.RotCtrl = CdSpeed_RotCtrl_CAV;
        Vcb->CurSpeed =
        Vcb->SpeedBuf.ReadSpeed =
        Vcb->SpeedBuf.WriteSpeed = Vcb->MaxWriteSpeed;
    } else {
        Vcb->SpeedBuf.ReadSpeed  = Vcb->CurSpeed;
        Vcb->SpeedBuf.WriteSpeed = Vcb->MaxWriteSpeed;
    }
    UDFPrint(("    UDFSetSpeeds: set speed to %s %dX/%dX\n",
        (Vcb->VCBFlags & UDF_VCB_FLAGS_USE_CAV) ? "CAV" : "CLV",
        Vcb->SpeedBuf.ReadSpeed / 176,
        Vcb->SpeedBuf.WriteSpeed / 176));
    RC = UDFPhSendIOCTL(IOCTL_CDRW_SET_SPEED,
                        Vcb->TargetDeviceObject,
                        &(Vcb->SpeedBuf),sizeof(SET_CD_SPEED_EX_USER_IN),
                        NULL,0,TRUE,NULL);
    UDFPrint(("UDFSetSpeeds: %x\n", RC));
    return RC;
} // end UDFSetSpeeds()

Referenced by UDFGetDiskInfo(), and UDFResetDeviceDriver().

UDFSyncCache()

NTSTATUS UDFSyncCache

(

IN PVCB

Vcb

)

Definition at line 52 of file phys_lib.cpp.

{
    UDFPrint(("UDFSyncCache:\n"));
    OSSTATUS RC;
    RC = UDFPhSendIOCTL( IOCTL_CDRW_SYNC_CACHE, Vcb->TargetDeviceObject,
                    NULL,0, NULL,0, FALSE, NULL);
    if(OS_SUCCESS(RC)) {
        // clear LAST_WRITE flag
        Vcb->VCBFlags &= ~UDF_VCB_LAST_WRITE;
    }
    return RC;
} // end UDFSyncCache()

Referenced by UDFPrepareForReadOperation(), UDFRecoverFromError(), and UDFUpdateNWA().

UDFTRead()

OSSTATUS UDFTRead	(	IN void *	_Vcb,
		IN void *	Buffer,
		IN SIZE_T	Length,
		IN uint32	LBA,
		OUT PSIZE_T	ReadBytes,
		IN uint32	Flags
	)

Definition at line 596 of file phys_lib.cpp.

{
    uint32 rLba;
    OSSTATUS RC = STATUS_SUCCESS;
    uint32 retry;
    PVCB Vcb = (PVCB)_Vcb;
    uint32 BCount = Length >> Vcb->BlockSizeBits;
    uint32 i;
#ifdef _BROWSE_UDF_
    PEXTENT_MAP RelocExtent;
    PEXTENT_MAP RelocExtent_saved = NULL;
    BOOLEAN res_acq = FALSE;
//    LARGE_INTEGER delay;
    Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
 
    ASSERT(Buffer);
 
    (*ReadBytes) = 0;
 
    if(Vcb->VCBFlags & UDF_VCB_FLAGS_DEAD)
        return STATUS_NO_SUCH_DEVICE;
 
    RelocExtent = UDFRelocateSectors(Vcb, LBA, BCount);
    if(!RelocExtent) return STATUS_INSUFFICIENT_RESOURCES;
 
    _SEH2_TRY {
 
        if(!(Flags & PH_IO_LOCKED)) {
            UDFAcquireResourceExclusive(&(Vcb->IoResource), TRUE);
            res_acq = TRUE;
        }
 
        if(RelocExtent == UDF_NO_EXTENT_MAP) {
            rLba = LBA;
            if(rLba >= (Vcb->CDR_Mode ? Vcb->NWA : Vcb->LastLBA + 1)) {
                RtlZeroMemory(Buffer, Length);
                try_return(RC = STATUS_SUCCESS);
            }
            retry = UDF_WRITE_MAX_RETRY;
retry_1:
            RC = UDFPrepareForReadOperation(Vcb, rLba, Length >> Vcb->BlockSizeBits);
            if(!OS_SUCCESS(RC)) try_return(RC);
            rLba = UDFFixFPAddress(Vcb, rLba);
#else
            rLba = LBA;
            retry = UDF_WRITE_MAX_RETRY;
retry_1:
            RC = UDFPrepareForReadOperation(Vcb, rLba, Length >> Vcb->BlockSizeBits);
            if(!OS_SUCCESS(RC)) return RC; // this is for !_BROWSE_UDF only
#endif //_BROWSE_UDF_
            if(Flags & PH_VCB_IN_RETLEN) {
                (*ReadBytes) = (SIZE_T)Vcb;
            }
            RC = UDFPhReadSynchronous(Vcb->TargetDeviceObject, Buffer, Length,
                       ((uint64)rLba) << Vcb->BlockSizeBits, ReadBytes, Flags);
            Vcb->VCBFlags &= ~UDF_VCB_LAST_WRITE;
#ifdef _BROWSE_UDF_
            Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
#endif //_BROWSE_UDF_
            if(!OS_SUCCESS(RC) &&
                OS_SUCCESS(RC = UDFRecoverFromError(Vcb, FALSE, RC, rLba, BCount, &retry)) ) {
                if(RC != STATUS_BUFFER_ALL_ZEROS) {
                    goto retry_1;
                }
                RtlZeroMemory(Buffer, Length);
                (*ReadBytes) = Length;
                RC = STATUS_SUCCESS;
            }
#ifdef _BROWSE_UDF_
            try_return(RC);
        }
        // read according to relocation table
        RelocExtent_saved = RelocExtent;
        for(i=0; RelocExtent->extLength; i++, RelocExtent++) {
            SIZE_T _ReadBytes;
            rLba = RelocExtent->extLocation;
            if(rLba >= (Vcb->CDR_Mode ? Vcb->NWA : Vcb->LastLBA + 1)) {
                RtlZeroMemory(Buffer, _ReadBytes = RelocExtent->extLength);
                RC = STATUS_SUCCESS;
                goto TR_continue;
            }
            BCount = RelocExtent->extLength>>Vcb->BlockSizeBits;
            retry = UDF_WRITE_MAX_RETRY;
retry_2:
            RC = UDFPrepareForReadOperation(Vcb, rLba, RelocExtent->extLength >> Vcb->BlockSizeBits);
            if(!OS_SUCCESS(RC)) break;
            rLba = UDFFixFPAddress(Vcb, rLba);
            if(Flags & PH_VCB_IN_RETLEN) {
                _ReadBytes = (SIZE_T)Vcb;
            }
            RC = UDFPhReadSynchronous(Vcb->TargetDeviceObject, Buffer, RelocExtent->extLength,
                       ((uint64)rLba) << Vcb->BlockSizeBits, &_ReadBytes, Flags);
            Vcb->VCBFlags &= ~UDF_VCB_LAST_WRITE;
            Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
            if(!OS_SUCCESS(RC) &&
                OS_SUCCESS(RC = UDFRecoverFromError(Vcb, FALSE, RC, rLba, BCount, &retry)) ) {
                if(RC != STATUS_BUFFER_ALL_ZEROS) {
                    goto retry_2;
                }
                RtlZeroMemory(Buffer, RelocExtent->extLength);
                _ReadBytes = RelocExtent->extLength;
                RC = STATUS_SUCCESS;
            }
TR_continue:
            (*ReadBytes) += _ReadBytes;
            if(!OS_SUCCESS(RC)) break;
            *((uint32*)&Buffer) += RelocExtent->extLength;
        }
try_exit: NOTHING;
    } _SEH2_FINALLY {
        if(res_acq) {
            UDFReleaseResource(&(Vcb->IoResource));
        }
        if(RelocExtent_saved) {
            MyFreePool__(RelocExtent_saved);
        }
    } _SEH2_END;
#endif //_BROWSE_UDF_
    return RC;
} // end UDFTRead()

Referenced by UDFCheckArea(), UDFCommonRead(), UDFReadDiscTrackInfo(), and UDFVerifyVolume().

UDFTWrite()

OSSTATUS UDFTWrite	(	IN void *	_Vcb,
		IN void *	Buffer,
		IN SIZE_T	Length,
		IN uint32	LBA,
		OUT PSIZE_T	WrittenBytes,
		IN uint32	Flags
	)

Definition at line 453 of file phys_lib.cpp.

{
#ifndef UDF_READ_ONLY_BUILD
#define Vcb ((PVCB)_Vcb)
 
#ifdef _BROWSE_UDF_
    PEXTENT_MAP RelocExtent;
    PEXTENT_MAP RelocExtent_saved = NULL;
#endif //_BROWSE_UDF_
    uint32 retry;
    BOOLEAN res_acq = FALSE;
 
    OSSTATUS RC = STATUS_SUCCESS;
    uint32 rLba;
    uint32 BCount;
    uint32 i;
 
#ifdef DBG
    //ASSERT(!(LBA & (32-1)));
#endif //DBG
 
    (*WrittenBytes) = 0;
    BCount = Length>>Vcb->BlockSizeBits;
 
    UDFPrint(("TWrite %x (%x)\n", LBA, BCount));
#ifdef _BROWSE_UDF_
    if(Vcb->VCBFlags & UDF_VCB_FLAGS_DEAD) {
        UDFPrint(("DEAD\n"));
        return STATUS_NO_SUCH_DEVICE;
    }
 
    Vcb->VCBFlags |= (UDF_VCB_SKIP_EJECT_CHECK | UDF_VCB_LAST_WRITE);
    if(!Vcb->CDR_Mode) {
        RelocExtent = UDFRelocateSectors(Vcb, LBA, BCount);
        if(!RelocExtent) {
            UDFPrint(("can't relocate\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        rLba = LBA;
    } else {
        RelocExtent = UDF_NO_EXTENT_MAP;
        rLba = Vcb->NWA;
    }
#else //_BROWSE_UDF_
    rLba = LBA;
#endif //_BROWSE_UDF_
 
#ifdef DBG
    //ASSERT(!(rLba & (32-1)));
#endif //DBG
 
    _SEH2_TRY {
#ifdef _BROWSE_UDF_
 
        if(!(Flags & PH_IO_LOCKED)) {
            UDFAcquireResourceExclusive(&(Vcb->IoResource), TRUE);
            res_acq = TRUE;
        }
 
        if(RelocExtent == UDF_NO_EXTENT_MAP) {
#endif //_BROWSE_UDF_
            retry = UDF_WRITE_MAX_RETRY;
retry_1:
            RC = UDFPrepareForWriteOperation(Vcb, rLba, BCount);
            if(!OS_SUCCESS(RC)) {
                UDFPrint(("prepare failed\n"));
                try_return(RC);
            }
            if(Flags & PH_VCB_IN_RETLEN) {
                (*WrittenBytes) = (ULONG_PTR)Vcb;
            }
            RC = UDFPhWriteVerifySynchronous(Vcb->TargetDeviceObject, Buffer, Length,
                       ((uint64)rLba) << Vcb->BlockSizeBits, WrittenBytes, Flags);
#ifdef _BROWSE_UDF_
            Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
#endif //_BROWSE_UDF_
            if(!OS_SUCCESS(RC) &&
                OS_SUCCESS(RC = UDFRecoverFromError(Vcb, TRUE, RC, rLba, BCount, &retry)) )
                goto retry_1;
            UDFUpdateNWA((PVCB)_Vcb, rLba, BCount, RC);
            try_return(RC);
#ifdef _BROWSE_UDF_
        }
        // write according to relocation table
        RelocExtent_saved = RelocExtent;
        for(i=0; RelocExtent->extLength; i++, RelocExtent++) {
            SIZE_T _WrittenBytes;
            rLba = RelocExtent->extLocation;
            BCount = RelocExtent->extLength>>Vcb->BlockSizeBits;
            retry = UDF_WRITE_MAX_RETRY;
retry_2:
            RC = UDFPrepareForWriteOperation(Vcb, rLba, BCount);
            if(!OS_SUCCESS(RC)) {
                UDFPrint(("prepare failed (2)\n"));
                break;
            }
            if(Flags & PH_VCB_IN_RETLEN) {
                _WrittenBytes = (ULONG_PTR)Vcb;
            }
            RC = UDFPhWriteVerifySynchronous(Vcb->TargetDeviceObject, Buffer, RelocExtent->extLength,
                       ((uint64)rLba) << Vcb->BlockSizeBits, &_WrittenBytes, Flags);
            Vcb->VCBFlags |= UDF_VCB_SKIP_EJECT_CHECK;
            if(!OS_SUCCESS(RC) &&
                OS_SUCCESS(RC = UDFRecoverFromError(Vcb, TRUE, RC, rLba, BCount, &retry)) )
                goto retry_2;
            UDFUpdateNWA((PVCB)_Vcb, rLba, BCount, RC);
            LBA += BCount;
            (*WrittenBytes) += _WrittenBytes;
            if(!OS_SUCCESS(RC)) break;
            *((uint32*)&Buffer) += RelocExtent->extLength;
        }
#endif //_BROWSE_UDF_
try_exit: NOTHING;
    } _SEH2_FINALLY {
        if(res_acq) {
            UDFReleaseResource(&(Vcb->IoResource));
        }
#ifdef _BROWSE_UDF_
        if(RelocExtent_saved) {
            MyFreePool__(RelocExtent_saved);
        }
#endif //_BROWSE_UDF_
    } _SEH2_END;
    UDFPrint(("TWrite: %x\n", RC));
    return RC;
 
#undef Vcb
#else //UDF_READ_ONLY_BUILD
    return STATUS_ACCESS_DENIED;
#endif //UDF_READ_ONLY_BUILD
} // end UDFTWrite()

Referenced by UDFCommonWrite(), UDFVerifyVolume(), and UDFWriteSectors().

UDFUpdateNWA()

void UDFUpdateNWA	(	PVCB	Vcb,
		uint32	LBA,
		uint32	BCount,
		OSSTATUS	RC
	)

Definition at line 3826 of file phys_lib.cpp.

{
#ifndef UDF_READ_ONLY_BUILD
#ifdef _BROWSE_UDF_
    if(!OS_SUCCESS(RC)) {
        return;
    }
    if(!Vcb->CDR_Mode) {
 
        if((Vcb->MediaClassEx == CdMediaClass_DVDRW ||
            Vcb->MediaClassEx == CdMediaClass_DVDpRW ||
            Vcb->MediaClassEx == CdMediaClass_DVDRAM ||
            Vcb->MRWStatus == DiscInfo_BGF_Interrupted ||
            Vcb->MRWStatus == DiscInfo_BGF_InProgress)
              && (LBA+BCount-1) > Vcb->LastLBA) {
            ASSERT(Vcb->NWA > Vcb->LastLBA);
            Vcb->NWA = LBA+BCount;
            Vcb->LastLBA = Vcb->NWA-1;
        }
        if(Vcb->VCBFlags & UDF_VCB_FLAGS_FORCE_SYNC_CACHE)
            goto sync_cache;
/*        if(Vcb->CdrwBufferSize) {
            Vcb->CdrwBufferSizeCounter += BCount * 2048;
            if(Vcb->CdrwBufferSizeCounter >= Vcb->CdrwBufferSize + 2*2048) {
                UDFPrint(("    UDFUpdateNWA: buffer is full, sync...\n"));
                Vcb->CdrwBufferSizeCounter = 0;
                goto sync_cache;
            }
        }*/
        if(Vcb->SyncCacheState == SYNC_CACHE_RECOVERY_RETRY) {
            Vcb->VCBFlags |= UDF_VCB_FLAGS_FORCE_SYNC_CACHE;
        }
        Vcb->SyncCacheState = SYNC_CACHE_RECOVERY_NONE;
        return;
    }
    if(Vcb->LastLBA < (LBA+BCount))
        Vcb->LastLBA = LBA+BCount;
    if(Vcb->NWA)
        Vcb->NWA+=BCount+7;
sync_cache:
    if(!(Vcb->CompatFlags & UDF_VCB_IC_NO_SYNCCACHE_AFTER_WRITE)) {
        UDFPrint(("    UDFUpdateNWA: syncing...\n"));
        RC = UDFSyncCache(Vcb);
    }
#endif //_BROWSE_UDF_
#endif //UDF_READ_ONLY_BUILD
} // end UDFUpdateNWA()

Referenced by UDFPrepareForWriteOperation(), and UDFTWrite().

UDFUseStandard()

OSSTATUS UDFUseStandard	(	PDEVICE_OBJECT	DeviceObject,
		PVCB	Vcb
	)

Definition at line 2386 of file phys_lib.cpp.

{
    OSSTATUS                RC = STATUS_SUCCESS;
    PREAD_TOC_USER_OUT      toc = (PREAD_TOC_USER_OUT)MyAllocatePool__(NonPagedPool,max(Vcb->BlockSize, sizeof(READ_TOC_USER_OUT)) );
    PGET_LAST_SESSION_USER_OUT LastSes = (PGET_LAST_SESSION_USER_OUT)MyAllocatePool__(NonPagedPool,sizeof(GET_LAST_SESSION_USER_OUT) );
    uint32                  LocalTrackCount;
//    uint32                  LocalTocLength;
    uint32                  TocEntry;
#ifdef _BROWSE_UDF_
    uint32                  OldTrkNum;
    uint32                  TrkNum;
    SIZE_T                  ReadBytes, i, len;
#endif //_BROWSE_UDF_
#ifdef UDF_FORMAT_MEDIA
    PUDFFmtState            fms = Vcb->fms;
#else
  #define fms FALSE
#endif //UDF_FORMAT_MEDIA
 
    UDFPrint(("UDFUseStandard\n"));
 
    _SEH2_TRY {
 
        if(!toc || !LastSes) {
            try_return (RC = STATUS_INSUFFICIENT_RESOURCES);
        }
        RtlZeroMemory(toc,sizeof(READ_TOC_TOC));
 
        Vcb->VCBFlags |= UDF_VCB_FLAGS_USE_STD;
 
        RC = UDFPhSendIOCTL(IOCTL_CDROM_READ_TOC,DeviceObject,
            toc,sizeof(READ_TOC_USER_OUT),
            toc,sizeof(READ_TOC_USER_OUT),
            TRUE,NULL );
 
        if((RC == STATUS_DEVICE_NOT_READY) || (RC == STATUS_NO_MEDIA_IN_DEVICE)) {
            try_return(RC);
        }
#ifdef UDF_FORMAT_MEDIA
        if(fms->opt_media == MT_none) {
            try_return(RC = STATUS_NO_MEDIA_IN_DEVICE);
        }
#endif //UDF_FORMAT_MEDIA
 
        // If even standard read toc does not work, then use default values
        if(!OS_SUCCESS(RC)) {
 
            RC = UDFReallocTrackMap(Vcb, 2);
            if(!OS_SUCCESS(RC)) {
                try_return(RC);
            }
 
            Vcb->LastSession=1;
            Vcb->FirstTrackNum=1;
//            Vcb->FirstLBA=0;
            Vcb->LastTrackNum=1;
            Vcb->TrackMap[1].FirstLba = Vcb->FirstLBA;
            Vcb->TrackMap[1].LastLba = Vcb->LastLBA;
            Vcb->TrackMap[1].PacketSize = PACKETSIZE_UDF;
#ifdef UDF_FORMAT_MEDIA
            if(!fms) {
#endif //UDF_FORMAT_MEDIA
 
#ifdef _BROWSE_UDF_
#ifdef UDF_HDD_SUPPORT
                if(UDFGetDevType(DeviceObject) == FILE_DEVICE_DISK) {
                    try_return(RC = STATUS_SUCCESS);
                }
#endif //UDF_HDD_SUPPORT
#endif //_BROWSE_UDF_
 
#ifdef UDF_FORMAT_MEDIA
            } else {
 
                if(fms->opt_media == MT_HD) {
                    Vcb->LastPossibleLBA = Vcb->LastLBA;
                    try_return(RC = STATUS_SUCCESS);
                }
            }
#endif //UDF_FORMAT_MEDIA
            Vcb->LastPossibleLBA = max(Vcb->LastLBA, DEFAULT_LAST_LBA_FP_CD);
            Vcb->TrackMap[1].DataParam = TrkInfo_Dat_XA | TrkInfo_FP | TrkInfo_Packet;
            Vcb->TrackMap[1].TrackParam = TrkInfo_Trk_XA;
            Vcb->TrackMap[1].NWA = 0xffffffff;
            Vcb->NWA = DEFAULT_LAST_LBA_FP_CD + 7 + 1;
            try_return(RC = STATUS_SUCCESS);
        }
 
#ifdef _CONSOLE
        Vcb->PhDeviceType = FILE_DEVICE_CD_ROM;
#endif //_CONSOLE
 
        LocalTrackCount = toc->Tracks.Last_TrackSes - toc->Tracks.First_TrackSes + 1;
//        LocalTocLength = PtrOffset( toc, &(toc->TrackData[LocalTrackCount + 1]) );  /* FIXME ReactOS Assume PtrOffset is not changing it's arguments? */
 
        // Get out if there is an immediate problem with the TOC.
        if(toc->Tracks.First_TrackSes > toc->Tracks.Last_TrackSes) {
            try_return(RC = STATUS_DISK_CORRUPT_ERROR);
        }
 
#ifdef _BROWSE_UDF_
        Vcb->LastTrackNum=toc->Tracks.Last_TrackSes;
        Vcb->FirstTrackNum=toc->Tracks.First_TrackSes;
        // some devices report LastTrackNum=0 for full disks
        Vcb->LastTrackNum = max(Vcb->LastTrackNum, Vcb->FirstTrackNum);
 
        RC = UDFReallocTrackMap(Vcb, MAXIMUM_NUMBER_OF_TRACKS+1);
/*        if(Vcb->TrackMap) {
            MyFreePool__(Vcb->TrackMap);
            Vcb->TrackMap = NULL;
        }
        Vcb->TrackMap = (PUDFTrackMap)
            MyAllocatePool__(NonPagedPool, (MAXIMUM_NUMBER_OF_TRACKS+1)*sizeof(UDFTrackMap));
        if(!Vcb->TrackMap) {
            MyFreePool__(toc);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlZeroMemory(Vcb->TrackMap,(MAXIMUM_NUMBER_OF_TRACKS+1)*sizeof(UDFTrackMap));
*/
        if(!OS_SUCCESS(RC)) {
            BrutePoint();
            try_return(RC);
        }
        // find 1st and last session
        RC = UDFPhSendIOCTL(IOCTL_CDROM_GET_LAST_SESSION,DeviceObject,
            LastSes,sizeof(GET_LAST_SESSION_USER_OUT),
            LastSes,sizeof(GET_LAST_SESSION_USER_OUT),
            TRUE,NULL );
 
        if(OS_SUCCESS(RC)) {
            TrkNum = LastSes->LastSes_1stTrack.TrackNum;
            Vcb->LastSession = LastSes->Sessions.First_TrackSes;
            for(TocEntry=0;TocEntry<LocalTrackCount + 1;TocEntry++) {
                if(toc->TrackData[TocEntry].TrackNum == TrkNum) {
                    Vcb->TrackMap[TrkNum].Session = Vcb->LastSession;
                }
            }
        }
 
        OldTrkNum = 0;
        // Scan toc for first & last LBA
        for(TocEntry=0;TocEntry<LocalTrackCount + 1;TocEntry++) {
#define TempMSF toc->TrackData[TocEntry].LBA
            TrkNum = toc->TrackData[TocEntry].TrackNum;
#ifdef UDF_DBG
            if (TrkNum >= MAXIMUM_NUMBER_OF_TRACKS &&
                TrkNum != TOC_LastTrack_ID) {
                UDFPrint(("UDFUseStandard: Array out of bounds\n"));
                BrutePoint();
                try_return(RC = STATUS_SUCCESS);
            }
            UDFPrint(("Track N %d (0x%x) first LBA %ld (%lx) \n",TrkNum,TrkNum,
                MSF_TO_LBA(TempMSF[1],TempMSF[2],TempMSF[3]),
                MSF_TO_LBA(TempMSF[1],TempMSF[2],TempMSF[3])));
#endif // UDF_DBG
            if(Vcb->FirstTrackNum == TrkNum) {
                Vcb->FirstLBA = MSF_TO_LBA(TempMSF[1],TempMSF[2],TempMSF[3]);
                if(Vcb->FirstLBA & 0x80000000) {
                    Vcb->FirstLBA = 0;
                }