#include "ecma_167.h"
#include "osta_misc.h"
#include "udf_rel.h"
#include "wcache.h"

Include dependency graph for udf_info.h:

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

Macros
#define	HASH_POSIX 0x01

#define	HASH_ULFN 0x02

#define	HASH_DOS 0x04

#define	HASH_ALL 0x07

#define	HASH_KEEP_NAME 0x08

#define	UDFExtentToMapping(e) UDFExtentToMapping_(e)

#define	UDFDOSName__(Vcb, DosName, UdfName, FileInfo) UDFDOSName(Vcb, DosName, UdfName, (FileInfo) && ((FileInfo)->Index < 2));

#define	UDFCheckSpaceAllocation(Vcb, FileInfo, Map, asXXX) {;}

#define	UDFMarkSpaceAsXXXNoProtect(Vcb, FileInfo, Map, asXXX) UDFMarkSpaceAsXXXNoProtect_(Vcb, Map, asXXX);

#define	UDFMarkSpaceAsXXX(Vcb, FileInfo, Map, asXXX) UDFMarkSpaceAsXXX_(Vcb, Map, asXXX);

#define	AS_FREE 0x00

#define	AS_USED 0x01

#define	AS_DISCARDED 0x02

#define	AS_BAD 0x04

#define	UDFAllocFreeExtent(v, l, ss, sl, e, af) UDFAllocFreeExtent_(v, l, ss, sl, e, af)

#define	UDF_PREALLOC_CLASS_FE 0x00

#define	UDF_PREALLOC_CLASS_DIR 0x01

#define	FLUSH_FE_KEEP FALSE

#define	FLUSH_FE_FOR_DEL TRUE

#define	UDF_FSPACE_BM 0x00

#define	UDF_ZSPACE_BM 0x01

#define	UDFMarkAllocatedAsNotAllocated(Vcb, Off, Len, Ext) UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, TRUE)

#define	UDFMarkRecordedAsAllocated(Vcb, Off, Len, Ext) UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, FALSE)

#define	UDFZeroExtent__(Vcb, Ext, Off, Len, Dir, WB) UDFZeroExtent(Vcb, Ext, Off, Len, FALSE, Dir, WB)

#define	UDFSparseExtent__(Vcb, Ext, Off, Len, Dir, WB) UDFZeroExtent(Vcb, Ext, Off, Len, TRUE, Dir, WB)

#define	UDFIncFileLinkCount(fi) UDFChangeFileLinkCount(fi, TRUE)

#define	UDFDecFileLinkCount(fi) UDFChangeFileLinkCount(fi, FALSE)

#define	UDFSetEntityID_imp(eID, Str) UDFSetEntityID_imp_(eID, (uint8*)(Str), sizeof(Str));

#define	UDFIncFileCounter(Vcb) UDFChangeFileCounter(Vcb, TRUE, TRUE);

#define	UDFDecFileCounter(Vcb) UDFChangeFileCounter(Vcb, TRUE, FALSE);

#define	UDFIncDirCounter(Vcb) UDFChangeFileCounter(Vcb, FALSE, TRUE);

#define	UDFDecDirCounter(Vcb) UDFChangeFileCounter(Vcb, FALSE, FALSE);

#define	UDF_FREE_NOTHING 0x00

#define	UDF_FREE_FILEINFO 0x01

#define	UDF_FREE_DLOC 0x02

#define	UDFIsDeleted(DirNdx) (((DirNdx)->FileCharacteristics & FILE_DELETED) ? TRUE : FALSE)

#define	UDFIsADirectory(FileInfo) (((FileInfo) && ((FileInfo)->Dloc) && ((FileInfo)->Dloc->DirIndex \|\| ((FileInfo)->FileIdent && ((FileInfo)->FileIdent->fileCharacteristics & FILE_DIRECTORY)))) ? TRUE : FALSE)

#define	UDFGetFileAllocationSize(Vcb, FileInfo) (((FileInfo)->Dloc->DataLoc.Mapping) ? UDFGetExtentLength((FileInfo)->Dloc->DataLoc.Mapping) : Vcb->LBlockSize)

#define	UDFIsFlushed(FI)

#define	UDFIsFileCached__(Vcb, FileInfo, Offset, Length, ForWrite) (UDFIsExtentCached(Vcb, &((FileInfo)->Dloc->DataLoc), Offset, Length, ForWrite))

#define	UDFGetLVIDiUse(Vcb)

#define	UDFIsAStreamDir(FI) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR))

#define	UDFHasAStreamDir(FI) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_HAS_SDIR))

#define	UDFIsAStream(FI) ((FI) && UDFIsAStreamDir((FI)->ParentFile))

#define	UDFIsSDirDeleted(FI) ((FI) && (FI)->Dloc && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_DEL_SDIR))

#define	UDFGetPartNumByPartNdx(Vcb, pi) (Vcb->Partitions[pi].PartitionNum)

#define	UDFStreamsSupported(Vcb) (Vcb->maxUDFWriteRev >= 0x0200)

#define	UDFNtAclSupported(Vcb) (Vcb->maxUDFWriteRev >= 0x0200)

#define	UDFReferenceFile__(fi)

#define	UDFReferenceFileEx__(fi, i)

#define	UDFDereferenceFile__(fi)

#define	UDFIsDirEmpty__(fi) UDFIsDirEmpty((fi)->Dloc->DirIndex)

#define	UDFIsDirOpened__(fi) (fi->OpenCount)

#define	UDFSetFileAllocMode__(fi, mode)

#define	UDFGetFileAllocMode__(fi) ((fi)->Dloc->DataLoc.Flags & EXTENT_FLAG_ALLOC_MASK)

#define	UDFGetFileICBAllocMode__(fi) (((PFILE_ENTRY)((fi)->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK)

#define	UDF_DIR_INDEX_FRAME_SH 9

#define	UDF_DIR_INDEX_FRAME ((uint_di)(1 << UDF_DIR_INDEX_FRAME_SH))

#define	UDF_DIR_INDEX_FRAME_GRAN (32)

#define	UDF_DIR_INDEX_FRAME_GRAN_MASK (UDF_DIR_INDEX_FRAME_GRAN-1)

#define	AlignDirIndex(n) ((n+UDF_DIR_INDEX_FRAME_GRAN_MASK) & ~(UDF_DIR_INDEX_FRAME_GRAN_MASK))

#define	UDFDirIndexGetLastIndex(di) ((((di)->FrameCount - 1) << UDF_DIR_INDEX_FRAME_SH) + (di)->LastFrameCount)

#define	UDFGetBit(arr, bit) ( (BOOLEAN) ( ((((uint32*)(arr))[(bit)>>5]) >> ((bit)&31)) &1 ) )

#define	UDFSetBit(arr, bit) ( (((uint32*)(arr))[(bit)>>5]) \|= (((uint32)1) << ((bit)&31)) )

#define	UDFClrBit(arr, bit) ( (((uint32*)(arr))[(bit)>>5]) &= (~(((uint32)1) << ((bit)&31))) )

#define	UDFSetBits(arr, bit, bc)

#define	UDFClrBits(arr, bit, bc)

#define	UDFGetUsedBit(arr, bit) (!UDFGetBit(arr,bit))

#define	UDFGetFreeBit(arr, bit) UDFGetBit(arr,bit)

#define	UDFSetUsedBit(arr, bit) UDFClrBit(arr,bit)

#define	UDFSetFreeBit(arr, bit) UDFSetBit(arr,bit)

#define	UDFSetUsedBits(arr, bit, bc) UDFClrBits(arr,bit,bc)

#define	UDFSetFreeBits(arr, bit, bc) UDFSetBits(arr,bit,bc)

#define	UDFGetBadBit(arr, bit) UDFGetBit(arr,bit)

#define	UDFGetZeroBit(arr, bit) UDFGetBit(arr,bit)

#define	UDFSetZeroBit(arr, bit) UDFSetBit(arr,bit)

#define	UDFClrZeroBit(arr, bit) UDFClrBit(arr,bit)

#define	UDFSetZeroBits(arr, bit, bc) UDFSetBits(arr,bit,bc)

#define	UDFClrZeroBits(arr, bit, bc) UDFClrBits(arr,bit,bc)

#define	UDFSetFreeBitOwner(Vcb, i)

#define	UDFSetUsedBitOwner(Vcb, i, o)

#define	UDFCheckUsedBitOwner(Vcb, i, o)

#define	UDFCheckFreeBitOwner(Vcb, i)

#define	UDFRegisterFsStructure(Vcb, Lba, Length) {NOTHING;}

#define	UDF_MAX_VERIFY_CACHE (810241024/2048)

#define	UDF_VERIFY_CACHE_LOW (410241024/2048)

#define	UDF_VERIFY_CACHE_GRAN (512*1024/2048)

#define	UDF_SYS_CACHE_STOP_THR (1010241024/2048)

#define	PH_FORGET_VERIFIED 0x00800000

#define	PH_READ_VERIFY_CACHE 0x00400000

#define	PH_KEEP_VERIFY_CACHE 0x00200000

#define	UFD_VERIFY_FLAG_FORCE 0x01

#define	UFD_VERIFY_FLAG_WAIT 0x02

#define	UFD_VERIFY_FLAG_BG 0x04

#define	UFD_VERIFY_FLAG_LOCKED 0x10

Functions
uint32	UDFMemRealloc (IN int8 OldBuff, IN uint32 OldLength, OUT int8 *NewBuff, IN uint32 NewLength)

uint32	UDFExtentOffsetToLba (IN PVCB Vcb, IN PEXTENT_AD Extent, IN int64 Offset, OUT uint32 SectorOffset, OUT PSIZE_T AvailLength, OUT uint32 Flags, OUT uint32 *Index)

ULONG	UDFLocateLbaInExtent (IN PVCB Vcb, IN PEXTENT_MAP Extent, IN lba_t lba)

OSSTATUS	UDFReadExtent (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, OUT int8 *Buffer, OUT PSIZE_T ReadBytes)

OSSTATUS	UDFReadExtentLocation (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, OUT PEXTENT_MAP _SubExtInfo, IN OUT uint32 _SubExtInfoSz, OUT int64 *_NextOffset)

int64	UDFGetExtentLength (IN PEXTENT_MAP Extent)

void __fastcall	UDFDecompressUnicode (IN OUT PUNICODE_STRING UName, IN uint8 CS0, IN SIZE_T Length, OUT uint16 valueCRC)

uint8	UDFBuildHashEntry (IN PVCB Vcb, IN PUNICODE_STRING Name, OUT PHASH_ENTRY hashes, IN uint8 Mask)

PDIR_INDEX_ITEM	UDFDirIndexGetFrame (IN PDIR_INDEX_HDR hDirNdx, IN uint32 Frame, OUT uint32 FrameLen, OUT uint_di Index, IN uint_di Rel)

void	UDFDirIndexFree (PDIR_INDEX_HDR hDirNdx)

OSSTATUS	UDFDirIndexGrow (IN PDIR_INDEX_HDR *_hDirNdx, IN uint_di d)

OSSTATUS	UDFDirIndexTrunc (IN PDIR_INDEX_HDR *_hDirNdx, IN uint_di d)

BOOLEAN	UDFDirIndexInitScan (IN PUDF_FILE_INFO DirInfo, OUT PUDF_DIR_SCAN_CONTEXT Context, IN uint_di Index)

PDIR_INDEX_ITEM	UDFDirIndexScan (PUDF_DIR_SCAN_CONTEXT Context, PUDF_FILE_INFO *_FileInfo)

OSSTATUS	UDFIndexDirectory (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFFindFile (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN BOOLEAN NotDeleted, IN PUNICODE_STRING Name, IN PUDF_FILE_INFO DirInfo, IN OUT uint_di *Index)

__inline OSSTATUS	UDFFindFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN PUNICODE_STRING Name, IN PUDF_FILE_INFO DirInfo)

uint32	UDFGetMappingLength (IN PEXTENT_MAP Extent)

PEXTENT_MAP __fastcall	UDFMergeMappings (IN PEXTENT_MAP Extent, IN PEXTENT_MAP Extent2)

PEXTENT_MAP	UDFShortAllocDescToMapping (IN PVCB Vcb, IN uint32 PartNum, IN PLONG_AD AllocDesc, IN uint32 AllocDescLength, IN uint32 SubCallCount, OUT PEXTENT_INFO AllocLoc)

PEXTENT_MAP	UDFLongAllocDescToMapping (IN PVCB Vcb, IN PLONG_AD AllocDesc, IN uint32 AllocDescLength, IN uint32 SubCallCount, OUT PEXTENT_INFO AllocLoc)

PEXTENT_MAP	UDFExtAllocDescToMapping (IN PVCB Vcb, IN PLONG_AD AllocDesc, IN uint32 AllocDescLength, IN uint32 SubCallCount, OUT PEXTENT_INFO AllocLoc)

PEXTENT_MAP	UDFReadMappingFromXEntry (IN PVCB Vcb, IN uint32 PartNum, IN tag XEntry, IN OUT uint32 Offset, OUT PEXTENT_INFO AllocLoc)

OSSTATUS	UDFReadFileEntry (IN PVCB Vcb, IN long_ad Icb, IN OUT PFILE_ENTRY FileEntry, IN OUT uint16 Ident)

OSSTATUS	UDFFindLastFileSet (IN PVCB Vcb, IN lb_addr *Addr, IN OUT PFILE_SET_DESC FileSetDesc)

OSSTATUS	UDFLoadSparingTable (IN PVCB Vcb, IN PSPARABLE_PARTITION_MAP PartMap)

PEXTENT_MAP __fastcall	UDFExtentToMapping_ (IN PEXTENT_AD Extent)

OSSTATUS __fastcall	UDFRemapPacket (IN PVCB Vcb, IN uint32 Lba, IN BOOLEAN RemapSpared)

OSSTATUS __fastcall	UDFUnmapRange (IN PVCB Vcb, IN uint32 Lba, IN uint32 BCount)

uint32 __fastcall	UDFRelocateSector (IN PVCB Vcb, IN uint32 Lba)

BOOLEAN __fastcall	UDFAreSectorsRelocated (IN PVCB Vcb, IN uint32 Lba, IN uint32 BlockCount)

PEXTENT_MAP __fastcall	UDFRelocateSectors (IN PVCB Vcb, IN uint32 Lba, IN uint32 BlockCount)

BOOLEAN	UDFUnicodeInString (IN uint8 *string, IN WCHAR ch)

BOOLEAN __fastcall	UDFIsIllegalChar (IN WCHAR ch)

void __fastcall	UDFDOSName (IN PVCB Vcb, IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)

void __fastcall	UDFDOSName201 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)

void __fastcall	UDFDOSName200 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact, IN BOOLEAN Mode150)

void __fastcall	UDFDOSName100 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)

SIZE_T	UDFGetBitmapLen (uint32 *Bitmap, SIZE_T Offs, SIZE_T Lim)

SIZE_T	UDFFindMinSuitableExtent (IN PVCB Vcb, IN uint32 Length, IN uint32 SearchStart, IN uint32 SearchLim, OUT uint32 *MaxExtLen, IN uint8 AllocFlags)

void	UDFMarkSpaceAsXXXNoProtect_ (IN PVCB Vcb, IN PEXTENT_MAP Map, IN uint32 asXXX)

void	UDFMarkSpaceAsXXX_ (IN PVCB Vcb, IN PEXTENT_MAP Map, IN uint32 asXXX)

OSSTATUS	UDFAllocFreeExtent_ (IN PVCB Vcb, IN int64 Length, IN uint32 SearchStart, IN uint32 SearchLim, OUT PEXTENT_INFO Extent, IN uint8 AllocFlags)

uint32 __fastcall	UDFGetPartFreeSpace (IN PVCB Vcb, IN uint32 partNum)

OSSTATUS	UDFGetCachedAllocation (IN PVCB Vcb, IN uint32 ParentLocation, OUT PEXTENT_INFO Ext, OUT uint32 *Items, IN uint32 AllocClass)

OSSTATUS	UDFStoreCachedAllocation (IN PVCB Vcb, IN uint32 ParentLocation, IN PEXTENT_INFO Ext, IN uint32 Items, IN uint32 AllocClass)

OSSTATUS	UDFFlushAllCachedAllocations (IN PVCB Vcb, IN uint32 AllocClass)

OSSTATUS	UDFAllocateFESpace (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN uint32 PartNum, IN PEXTENT_INFO FEExtInfo, IN uint32 Len)

void	UDFFreeFESpace (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN PEXTENT_INFO FEExtInfo)

void	UDFFlushFESpace (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc, IN BOOLEAN Discard=FLUSH_FE_KEEP)

void	UDFFreeFileAllocation (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN PUDF_FILE_INFO FileInfo)

uint32	UDFPhysLbaToPart (IN PVCB Vcb, IN uint32 PartNum, IN uint32 Addr)

void	UDFSetUpTag (IN PVCB Vcb, IN tag *Tag, IN uint16 DataLen, IN uint32 TagLoc)

OSSTATUS	UDFBuildShortAllocDescs (IN PVCB Vcb, IN uint32 PartNum, OUT int8 **Buff, IN uint32 InitSz, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFBuildLongAllocDescs (IN PVCB Vcb, IN uint32 PartNum, OUT int8 **Buff, IN uint32 InitSz, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFBuildFileEntry (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN PUDF_FILE_INFO FileInfo, IN uint32 PartNum, IN uint16 AllocMode, IN uint32 ExtAttrSz, IN BOOLEAN Extended)

uint32 __fastcall	UDFGetPartNumByPhysLba (IN PVCB Vcb, IN uint32 Lba)

OSSTATUS	UDFAddXSpaceBitmap (IN PVCB Vcb, IN uint32 PartNum, IN PSHORT_AD bm, IN ULONG bm_type)

OSSTATUS	UDFDelXSpaceBitmap (IN PVCB Vcb, IN uint32 PartNum, IN PSHORT_AD bm)

OSSTATUS	UDFBuildFreeSpaceBitmap (IN PVCB Vcb, IN uint32 PartNdx, IN PPARTITION_HEADER_DESC phd, IN uint32 Lba)

OSSTATUS	UDFLoadExtInfo (IN PVCB Vcb, IN PFILE_ENTRY fe, IN PLONG_AD fe_loc, IN OUT PEXTENT_INFO FExtInfo, IN OUT PEXTENT_INFO AExtInfo)

void __fastcall	UDFCompressUnicode (IN PUNICODE_STRING UName, IN OUT uint8 **_CS0, IN OUT PSIZE_T Length)

OSSTATUS	UDFBuildFileIdent (IN PVCB Vcb, IN PUNICODE_STRING fn, IN PLONG_AD FileEntryIcb, IN uint32 ImpUseLen, OUT PFILE_IDENT_DESC _FileId, OUT uint32 FileIdLen)

OSSTATUS	UDFMarkAllocatedAsRecorded (IN PVCB Vcb, IN int64 Offset, IN uint32 Length, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFMarkNotAllocatedAsAllocated (IN PVCB Vcb, IN int64 Offset, IN uint32 Length, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFMarkAllocatedAsNotXXX (IN PVCB Vcb, IN int64 Offset, IN uint32 Length, IN PEXTENT_INFO ExtInfo, IN BOOLEAN Deallocate)

OSSTATUS	UDFWriteExtent (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, IN int8 *Buffer, OUT PSIZE_T WrittenBytes)

OSSTATUS	UDFZeroExtent (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Deallocate, IN BOOLEAN Direct, OUT PSIZE_T WrittenBytes)

uint32 __fastcall	UDFPartStart (PVCB Vcb, uint32 PartNum)

uint32 __fastcall	UDFPartEnd (PVCB Vcb, uint32 PartNum)

OSSTATUS	UDFResizeExtent (IN PVCB Vcb, IN uint32 PartNum, IN int64 Length, IN BOOLEAN AlwaysInIcb, OUT PEXTENT_INFO ExtInfo)

OSSTATUS	UDFBuildAllocDescs (IN PVCB Vcb, IN uint32 PartNum, IN OUT PUDF_FILE_INFO FileInfo, OUT int8 **AllocData)

void	UDFSetFileSize (IN PUDF_FILE_INFO FileInfo, IN int64 Size)

void	UDFSetFileSizeInDirNdx (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 *ASize)

int64	UDFGetFileSize (IN PUDF_FILE_INFO FileInfo)

int64	UDFGetFileSizeFromDirNdx (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

void	UDFSetAllocDescLen (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

void	UDFChangeFileLinkCount (IN PUDF_FILE_INFO FileInfo, IN BOOLEAN Increase)

void	UDFSetEntityID_imp_ (IN EntityID eID, IN uint8 Str, IN uint32 Len)

uint16	UDFGetFileLinkCount (IN PUDF_FILE_INFO FileInfo)

void	UDFReadEntityID_Domain (PVCB Vcb, EntityID *eID)

uint32	UDFGetFileEALength (IN PUDF_FILE_INFO FileInfo)

void	UDFSetFileUID (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

int64	UDFGetFileUID (IN PUDF_FILE_INFO FileInfo)

void	UDFChangeFileCounter (IN PVCB Vcb, IN BOOLEAN FileCounter, IN BOOLEAN Increase)

OSSTATUS	UDFWriteFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, IN int8 *Buffer, OUT PSIZE_T WrittenBytes)

OSSTATUS	UDFUnlinkFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN BOOLEAN FreeSpace)

OSSTATUS	UDFUnlinkAllFilesInDir (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo)

OSSTATUS	UDFOpenFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN BOOLEAN NotDeleted, IN PUNICODE_STRING fn, IN PUDF_FILE_INFO DirInfo, OUT PUDF_FILE_INFO _FileInfo, IN uint_di IndexToOpen)

OSSTATUS	UDFOpenRootFile__ (IN PVCB Vcb, IN lb_addr *RootLoc, OUT PUDF_FILE_INFO FileInfo)

uint32	UDFCleanUpFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFCreateFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN PUNICODE_STRING fn, IN uint32 ExtAttrSz, IN uint32 ImpUseLen, IN BOOLEAN Extended, IN BOOLEAN CreateNew, IN OUT PUDF_FILE_INFO DirInfo, OUT PUDF_FILE_INFO *_FileInfo)

__inline OSSTATUS	UDFReadFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, OUT int8 *Buffer, OUT PSIZE_T ReadBytes)

__inline OSSTATUS	UDFReadFileLocation__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, OUT PEXTENT_MAP SubExtInfo, IN OUT uint32 SubExtInfoSz, OUT int64 *NextOffset)

__inline OSSTATUS	UDFZeroFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN uint32 Length, IN BOOLEAN Direct, OUT uint32 *ReadBytes)

__inline OSSTATUS	UDFSparseFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN uint32 Length, IN BOOLEAN Direct, OUT uint32 *ReadBytes)

OSSTATUS	UDFPadLastSector (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFCloseFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFPrepareXSpaceBitmap (IN PVCB Vcb, IN OUT PSHORT_AD XSpaceBitmap, IN OUT PEXTENT_INFO XSBMExtInfo, IN OUT int8 *XSBM, IN OUT uint32 XSl)

OSSTATUS	UDFUpdateXSpaceBitmaps (IN PVCB Vcb, IN uint32 PartNum, IN PPARTITION_HEADER_DESC phd)

OSSTATUS	UDFUpdatePartDesc (PVCB Vcb, int8 *Buf)

OSSTATUS	UDFUpdateLogicalVolInt (PVCB Vcb, BOOLEAN Close)

OSSTATUS	UDFUpdateUSpaceDesc (IN PVCB Vcb, int8 *Buf)

OSSTATUS	UDFUpdateVDS (IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, IN uint32 flags)

OSSTATUS	UDFUmount__ (IN PVCB Vcb)

OSSTATUS	UDFRenameMoveFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN OUT BOOLEAN *Replace, IN PUNICODE_STRING fn, IN OUT PUDF_FILE_INFO DirInfo1, IN OUT PUDF_FILE_INFO DirInfo2, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFResizeFile__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo, IN int64 NewLength)

OSSTATUS	UDFRecordDirectory__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO DirInfo)

OSSTATUS	UDFPackDirectory__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFReTagDirectory (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFLoadVAT (IN PVCB Vcb, IN uint32 PartNdx)

int64 __fastcall	UDFGetFreeSpace (IN PVCB Vcb)

int64 __fastcall	UDFGetTotalSpace (IN PVCB Vcb)

PDIR_INDEX_HDR	UDFGetDirIndexByFileInfo (IN PUDF_FILE_INFO FileInfo)

BOOLEAN	UDFIsDirEmpty (IN PDIR_INDEX_HDR hCurDirNdx)

OSSTATUS	UDFFlushFE (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint32 PartNum)

OSSTATUS	UDFFlushFI (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint32 PartNum)

OSSTATUS	UDFFlushFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN ULONG FlushFlags=0)

BOOLEAN	UDFCompareFileInfo (IN PUDF_FILE_INFO f1, IN PUDF_FILE_INFO f2)

void __fastcall	UDFPackMapping (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)

BOOLEAN	UDFIsExtentCached (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN uint32 Length, IN BOOLEAN ForWrite)

ULONG	UDFIsBlockAllocated (IN void *_Vcb, IN uint32 Lba)

OSSTATUS	UDFUpdateVolIdent (IN PVCB Vcb, IN UDF_VDS_RECORD Lba, IN PUNICODE_STRING VolIdent)

uint16 __fastcall	UDFUnicodeCksum (PWCHAR s, uint32 n)

uint16 __fastcall	UDFUnicodeCksum150 (PWCHAR s, uint32 n)

uint32 __fastcall	crc32 (IN uint8 *s, IN uint32 len)

uint16 __fastcall	UDFCrc (IN uint8 *Data, IN SIZE_T Size)

OSSTATUS	UDFReadTagged (IN PVCB Vcb, IN int8 Buf, IN uint32 Block, IN uint32 Location, OUT uint16 Ident)

uint32 __fastcall	UDFPartLbaToPhys (IN PVCB Vcb, IN lb_addr *Addr)

lba_t	UDFFindAnchor (PVCB Vcb)

uint32	UDFFindVRS (PVCB Vcb)

void	UDFLoadPVolDesc (PVCB Vcb, int8 *Buf)

OSSTATUS	UDFLoadLogicalVolInt (PDEVICE_OBJECT DeviceObject, PVCB Vcb, extent_ad loc)

OSSTATUS	UDFLoadLogicalVol (PDEVICE_OBJECT DeviceObject, PVCB Vcb, int8 Buf, lb_addr fileset)

OSSTATUS	UDFLoadPartDesc (PVCB Vcb, int8 *Buf)

OSSTATUS	UDFReadVDS (IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, IN PUDF_VDS_RECORD vds, IN int8 *Buf)

OSSTATUS	UDFProcessSequence (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, OUT lb_addr *fileset)

OSSTATUS	UDFVerifySequence (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, OUT lb_addr *fileset)

void	UDFLoadFileset (IN PVCB Vcb, IN PFILE_SET_DESC fset, OUT lb_addr root, OUT lb_addr sysstream)

OSSTATUS	UDFLoadPartition (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb, OUT lb_addr *fileset)

OSSTATUS	UDFGetDiskInfoAndVerify (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb)

OSSTATUS	UDFHardLinkFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN OUT BOOLEAN *Replace, IN PUNICODE_STRING fn, IN OUT PUDF_FILE_INFO DirInfo1, IN OUT PUDF_FILE_INFO DirInfo2, IN OUT PUDF_FILE_INFO FileInfo)

LONG	UDFFindDloc (IN PVCB Vcb, IN uint32 Lba)

LONG	UDFFindFreeDloc (IN PVCB Vcb, IN uint32 Lba)

OSSTATUS	UDFAcquireDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

OSSTATUS	UDFReleaseDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

OSSTATUS	UDFStoreDloc (IN PVCB Vcb, IN PUDF_FILE_INFO fi, IN uint32 Lba)

OSSTATUS	UDFRemoveDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

OSSTATUS	UDFUnlinkDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

void	UDFFreeDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

void	UDFRelocateDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc, IN uint32 NewLba)

void	UDFReleaseDlocList (IN PVCB Vcb)

PUDF_FILE_INFO	UDFLocateParallelFI (PUDF_FILE_INFO di, uint_di i, PUDF_FILE_INFO fi)

PUDF_FILE_INFO	UDFLocateAnyParallelFI (PUDF_FILE_INFO fi)

void	UDFInsertLinkedFile (PUDF_FILE_INFO fi, PUDF_FILE_INFO fi2)

OSSTATUS	UDFCreateRootFile__ (IN PVCB Vcb, IN uint32 PartNum, IN uint32 ExtAttrSz, IN uint32 ImpUseLen, IN BOOLEAN Extended, OUT PUDF_FILE_INFO *_FileInfo)

OSSTATUS	UDFCreateStreamDir__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, OUT PUDF_FILE_INFO *_SDirInfo)

OSSTATUS	UDFOpenStreamDir__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, OUT PUDF_FILE_INFO *_SDirInfo)

OSSTATUS	UDFRecordVAT (IN PVCB Vcb)

OSSTATUS	UDFModifyVAT (IN PVCB Vcb, IN uint32 Lba, IN uint32 Length)

OSSTATUS	UDFUpdateVAT (IN void _Vcb, IN uint32 Lba, IN uint32 RelocTab, IN uint32 BCount)

OSSTATUS __fastcall	UDFUnPackMapping (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFConvertFEToNonInICB (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint8 NewAllocMode)

OSSTATUS	UDFConvertFEToExtended (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

uint32 __fastcall	UDFPartLen (PVCB Vcb, uint32 PartNum)

OSSTATUS	UDFPretendFileDeleted__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

__inline PDIR_INDEX_ITEM	UDFDirIndex (IN PDIR_INDEX_HDR hDirNdx, IN uint_di i)

OSSTATUS	UDFVInit (IN PVCB Vcb)

VOID	UDFVRelease (IN PVCB Vcb)

OSSTATUS	UDFVWrite (IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)

OSSTATUS	UDFVRead (IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)

OSSTATUS	UDFVForget (IN PVCB Vcb, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)

VOID	UDFVVerify (IN PVCB Vcb, IN ULONG Flags)

VOID	UDFVFlush (IN PVCB Vcb)

__inline BOOLEAN __fastcall	UDFVIsStored (IN PVCB Vcb, IN lba_t lba)

BOOLEAN __fastcall	UDFCheckArea (IN PVCB Vcb, IN lba_t LBA, IN uint32 BCount)

Variables
const char	hexChar []

Macro Definition Documentation

◆ AlignDirIndex

#define AlignDirIndex ( n ) ((n+UDF_DIR_INDEX_FRAME_GRAN_MASK) & ~(UDF_DIR_INDEX_FRAME_GRAN_MASK))

Definition at line 1093 of file udf_info.h.

◆ AS_BAD

#define AS_BAD 0x04

Definition at line 329 of file udf_info.h.

◆ AS_DISCARDED

#define AS_DISCARDED 0x02

Definition at line 328 of file udf_info.h.

◆ AS_FREE

#define AS_FREE 0x00

Definition at line 326 of file udf_info.h.

◆ AS_USED

#define AS_USED 0x01

Definition at line 327 of file udf_info.h.

◆ FLUSH_FE_FOR_DEL

#define FLUSH_FE_FOR_DEL TRUE

Definition at line 396 of file udf_info.h.

◆ FLUSH_FE_KEEP

#define FLUSH_FE_KEEP FALSE

Definition at line 395 of file udf_info.h.

◆ HASH_ALL

#define HASH_ALL 0x07

Definition at line 78 of file udf_info.h.

◆ HASH_DOS

#define HASH_DOS 0x04

Definition at line 77 of file udf_info.h.

◆ HASH_KEEP_NAME

#define HASH_KEEP_NAME 0x08

Definition at line 79 of file udf_info.h.

◆ HASH_POSIX

#define HASH_POSIX 0x01

Definition at line 75 of file udf_info.h.

◆ HASH_ULFN

#define HASH_ULFN 0x02

Definition at line 76 of file udf_info.h.

◆ PH_FORGET_VERIFIED

#define PH_FORGET_VERIFIED 0x00800000

Definition at line 1270 of file udf_info.h.

◆ PH_KEEP_VERIFY_CACHE

#define PH_KEEP_VERIFY_CACHE 0x00200000

Definition at line 1272 of file udf_info.h.

◆ PH_READ_VERIFY_CACHE

#define PH_READ_VERIFY_CACHE 0x00400000

Definition at line 1271 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME

#define UDF_DIR_INDEX_FRAME ((uint_di)(1 << UDF_DIR_INDEX_FRAME_SH))

Definition at line 1089 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME_GRAN

#define UDF_DIR_INDEX_FRAME_GRAN (32)

Definition at line 1091 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME_GRAN_MASK

#define UDF_DIR_INDEX_FRAME_GRAN_MASK (UDF_DIR_INDEX_FRAME_GRAN-1)

Definition at line 1092 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME_SH

#define UDF_DIR_INDEX_FRAME_SH 9

Definition at line 1084 of file udf_info.h.

◆ UDF_FREE_DLOC

#define UDF_FREE_DLOC 0x02

Definition at line 650 of file udf_info.h.

◆ UDF_FREE_FILEINFO

#define UDF_FREE_FILEINFO 0x01

Definition at line 649 of file udf_info.h.

◆ UDF_FREE_NOTHING

#define UDF_FREE_NOTHING 0x00

Definition at line 648 of file udf_info.h.

◆ UDF_FSPACE_BM

#define UDF_FSPACE_BM 0x00

Definition at line 445 of file udf_info.h.

◆ UDF_MAX_VERIFY_CACHE

#define UDF_MAX_VERIFY_CACHE (8*1024*1024/2048)

Definition at line 1255 of file udf_info.h.

◆ UDF_PREALLOC_CLASS_DIR

#define UDF_PREALLOC_CLASS_DIR 0x01

Definition at line 356 of file udf_info.h.

◆ UDF_PREALLOC_CLASS_FE

#define UDF_PREALLOC_CLASS_FE 0x00

Definition at line 355 of file udf_info.h.

◆ UDF_SYS_CACHE_STOP_THR

#define UDF_SYS_CACHE_STOP_THR (10*1024*1024/2048)

Definition at line 1258 of file udf_info.h.

◆ UDF_VERIFY_CACHE_GRAN

#define UDF_VERIFY_CACHE_GRAN (512*1024/2048)

Definition at line 1257 of file udf_info.h.

◆ UDF_VERIFY_CACHE_LOW

#define UDF_VERIFY_CACHE_LOW (4*1024*1024/2048)

Definition at line 1256 of file udf_info.h.

◆ UDF_ZSPACE_BM

#define UDF_ZSPACE_BM 0x01

Definition at line 446 of file udf_info.h.

◆ UDFAllocFreeExtent

#define UDFAllocFreeExtent	(	v,
		l,
		ss,
		sl,
		e,
		af
	)	UDFAllocFreeExtent_(v, l, ss, sl, e, af)

Definition at line 347 of file udf_info.h.

◆ UDFCheckFreeBitOwner

#define UDFCheckFreeBitOwner	(	Vcb,
		i
	)

Definition at line 1238 of file udf_info.h.

◆ UDFCheckSpaceAllocation

#define UDFCheckSpaceAllocation	(	Vcb,
		FileInfo,
		Map,
		asXXX
	)	{;}

Definition at line 281 of file udf_info.h.

◆ UDFCheckUsedBitOwner

#define UDFCheckUsedBitOwner	(	Vcb,
		i,
		o
	)

Definition at line 1237 of file udf_info.h.

◆ UDFClrBit

#define UDFClrBit	(	arr,
		bit
	)	( (((uint32*)(arr))[(bit)>>5]) &= (~(((uint32)1) << ((bit)&31))) )

Definition at line 1182 of file udf_info.h.

◆ UDFClrBits

#define UDFClrBits	(	arr,
		bit,
		bc
	)

Value:

{uint32 j;                       \
    for(j=0;j<bc;j++) {          \
        UDFClrBit(arr, (bit)+j); \
}}

Definition at line 1190 of file udf_info.h.

◆ UDFClrZeroBit

#define UDFClrZeroBit	(	arr,
		bit
	)	UDFClrBit(arr,bit)

Definition at line 1209 of file udf_info.h.

◆ UDFClrZeroBits

#define UDFClrZeroBits	(	arr,
		bit,
		bc
	)	UDFClrBits(arr,bit,bc)

Definition at line 1211 of file udf_info.h.

◆ UDFDecDirCounter

#define UDFDecDirCounter ( Vcb ) UDFChangeFileCounter(Vcb, FALSE, FALSE);

Definition at line 617 of file udf_info.h.

◆ UDFDecFileCounter

#define UDFDecFileCounter ( Vcb ) UDFChangeFileCounter(Vcb, TRUE, FALSE);

Definition at line 615 of file udf_info.h.

◆ UDFDecFileLinkCount

#define UDFDecFileLinkCount ( fi ) UDFChangeFileLinkCount(fi, FALSE)

Definition at line 581 of file udf_info.h.

◆ UDFDereferenceFile__

#define UDFDereferenceFile__ ( fi )

Value:

{                                                    \
    UDFInterlockedDecrement((PLONG)&((fi)->RefCount));  \
    UDFInterlockedDecrement((PLONG)&((fi)->Dloc->LinkRefCount));  \
    if((fi)->ParentFile) {                           \
        UDFInterlockedDecrement((PLONG)&((fi)->ParentFile->OpenCount));  \
    }                                                \
}

Definition at line 1061 of file udf_info.h.

◆ UDFDirIndexGetLastIndex

#define UDFDirIndexGetLastIndex ( di ) ((((di)->FrameCount - 1) << UDF_DIR_INDEX_FRAME_SH) + (di)->LastFrameCount)

Definition at line 1122 of file udf_info.h.

◆ UDFDOSName__

#define UDFDOSName__	(	Vcb,
		DosName,
		UdfName,
		FileInfo
	)	UDFDOSName(Vcb, DosName, UdfName, (FileInfo) && ((FileInfo)->Index < 2));

Definition at line 217 of file udf_info.h.

◆ UDFExtentToMapping

#define UDFExtentToMapping ( e ) UDFExtentToMapping_(e)

Definition at line 181 of file udf_info.h.

◆ UDFGetBadBit

#define UDFGetBadBit	(	arr,
		bit
	)	UDFGetBit(arr,bit)

Definition at line 1205 of file udf_info.h.

◆ UDFGetBit

#define UDFGetBit	(	arr,
		bit
	)	( (BOOLEAN) ( ((((uint32*)(arr))[(bit)>>5]) >> ((bit)&31)) &1 ) )

Definition at line 1180 of file udf_info.h.

◆ UDFGetFileAllocationSize

#define UDFGetFileAllocationSize	(	Vcb,
		FileInfo
	)	(((FileInfo)->Dloc->DataLoc.Mapping) ? UDFGetExtentLength((FileInfo)->Dloc->DataLoc.Mapping) : Vcb->LBlockSize)

Definition at line 797 of file udf_info.h.

◆ UDFGetFileAllocMode__

#define UDFGetFileAllocMode__ ( fi ) ((fi)->Dloc->DataLoc.Flags & EXTENT_FLAG_ALLOC_MASK)

Definition at line 1079 of file udf_info.h.

◆ UDFGetFileICBAllocMode__

#define UDFGetFileICBAllocMode__ ( fi ) (((PFILE_ENTRY)((fi)->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK)

Definition at line 1081 of file udf_info.h.

◆ UDFGetFreeBit

#define UDFGetFreeBit	(	arr,
		bit
	)	UDFGetBit(arr,bit)

Definition at line 1199 of file udf_info.h.

◆ UDFGetLVIDiUse

#define UDFGetLVIDiUse ( Vcb )

Value:

    ( ((Vcb) && (Vcb)->LVid) ? \
        ( (LogicalVolIntegrityDescImpUse*) \
                     ( ((int8*)(Vcb->LVid+1)) + \
                       Vcb->LVid->numOfPartitions*2*sizeof(uint32))) \
       : NULL)

Definition at line 884 of file udf_info.h.

◆ UDFGetPartNumByPartNdx

#define UDFGetPartNumByPartNdx	(	Vcb,
		pi
	)	(Vcb->Partitions[pi].PartitionNum)

Definition at line 1028 of file udf_info.h.

◆ UDFGetUsedBit

#define UDFGetUsedBit	(	arr,
		bit
	)	(!UDFGetBit(arr,bit))

Definition at line 1198 of file udf_info.h.

◆ UDFGetZeroBit

#define UDFGetZeroBit	(	arr,
		bit
	)	UDFGetBit(arr,bit)

Definition at line 1207 of file udf_info.h.

◆ UDFHasAStreamDir

#define UDFHasAStreamDir ( FI ) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_HAS_SDIR))

Definition at line 1000 of file udf_info.h.

◆ UDFIncDirCounter

#define UDFIncDirCounter ( Vcb ) UDFChangeFileCounter(Vcb, FALSE, TRUE);

Definition at line 616 of file udf_info.h.

◆ UDFIncFileCounter

#define UDFIncFileCounter ( Vcb ) UDFChangeFileCounter(Vcb, TRUE, TRUE);

Definition at line 614 of file udf_info.h.

◆ UDFIncFileLinkCount

#define UDFIncFileLinkCount ( fi ) UDFChangeFileLinkCount(fi, TRUE)

Definition at line 580 of file udf_info.h.

◆ UDFIsADirectory

#define UDFIsADirectory ( FileInfo ) (((FileInfo) && ((FileInfo)->Dloc) && ((FileInfo)->Dloc->DirIndex || ((FileInfo)->FileIdent && ((FileInfo)->FileIdent->fileCharacteristics & FILE_DIRECTORY)))) ? TRUE : FALSE)

Definition at line 792 of file udf_info.h.

◆ UDFIsAStream

#define UDFIsAStream ( FI ) ((FI) && UDFIsAStreamDir((FI)->ParentFile))

Definition at line 1002 of file udf_info.h.

◆ UDFIsAStreamDir

#define UDFIsAStreamDir ( FI ) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR))

Definition at line 998 of file udf_info.h.

◆ UDFIsDeleted

#define UDFIsDeleted ( DirNdx ) (((DirNdx)->FileCharacteristics & FILE_DELETED) ? TRUE : FALSE)

Definition at line 788 of file udf_info.h.

◆ UDFIsDirEmpty__

#define UDFIsDirEmpty__ ( fi ) UDFIsDirEmpty((fi)->Dloc->DirIndex)

Definition at line 1070 of file udf_info.h.

◆ UDFIsDirOpened__

#define UDFIsDirOpened__ ( fi ) (fi->OpenCount)

Definition at line 1071 of file udf_info.h.

◆ UDFIsFileCached__

#define UDFIsFileCached__	(	Vcb,
		FileInfo,
		Offset,
		Length,
		ForWrite
	)	(UDFIsExtentCached(Vcb, &((FileInfo)->Dloc->DataLoc), Offset, Length, ForWrite))

Definition at line 839 of file udf_info.h.

◆ UDFIsFlushed

#define UDFIsFlushed ( FI )

Value:

    (   FI &&                    \
      !(FI->Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) &&      \
      !(FI->Dloc->DataLoc.Modified) && \
      !(FI->Dloc->AllocLoc.Modified) &&\
      !(FI->Dloc->FELoc.Modified) &&   \
      !(UDFGetDirIndexByFileInfo(FI)[FI->Index].FI_Flags & UDF_FI_FLAG_FI_MODIFIED) )

Definition at line 814 of file udf_info.h.

◆ UDFIsSDirDeleted

#define UDFIsSDirDeleted ( FI ) ((FI) && (FI)->Dloc && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_DEL_SDIR))

Definition at line 1004 of file udf_info.h.

◆ UDFMarkAllocatedAsNotAllocated

#define UDFMarkAllocatedAsNotAllocated	(	Vcb,
		Off,
		Len,
		Ext
	)	UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, TRUE)

Definition at line 503 of file udf_info.h.

◆ UDFMarkRecordedAsAllocated

#define UDFMarkRecordedAsAllocated	(	Vcb,
		Off,
		Len,
		Ext
	)	UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, FALSE)

Definition at line 516 of file udf_info.h.

◆ UDFMarkSpaceAsXXX

#define UDFMarkSpaceAsXXX	(	Vcb,
		FileInfo,
		Map,
		asXXX
	)	UDFMarkSpaceAsXXX_(Vcb, Map, asXXX);

Definition at line 322 of file udf_info.h.

◆ UDFMarkSpaceAsXXXNoProtect

#define UDFMarkSpaceAsXXXNoProtect	(	Vcb,
		FileInfo,
		Map,
		asXXX
	)	UDFMarkSpaceAsXXXNoProtect_(Vcb, Map, asXXX);

Definition at line 302 of file udf_info.h.

◆ UDFNtAclSupported

#define UDFNtAclSupported ( Vcb ) (Vcb->maxUDFWriteRev >= 0x0200)

Definition at line 1040 of file udf_info.h.

◆ UDFReferenceFile__

#define UDFReferenceFile__ ( fi )

Value:

{                                                    \
    UDFInterlockedIncrement((PLONG)&((fi)->RefCount));  \
    UDFInterlockedIncrement((PLONG)&((fi)->Dloc->LinkRefCount));  \
    if((fi)->ParentFile) {                           \
        UDFInterlockedIncrement((PLONG)&((fi)->ParentFile->OpenCount));  \
    }                                                \
}

Definition at line 1043 of file udf_info.h.

◆ UDFReferenceFileEx__

#define UDFReferenceFileEx__	(	fi,
		i
	)

Value:

{                                                    \
    UDFInterlockedExchangeAdd((PLONG)&((fi)->RefCount),i);  \
    UDFInterlockedExchangeAdd((PLONG)&((fi)->Dloc->LinkRefCount),i);  \
    if((fi)->ParentFile) {                           \
        UDFInterlockedExchangeAdd((PLONG)&((fi)->ParentFile->OpenCount),i);  \
    }                                                \
}

Definition at line 1052 of file udf_info.h.

◆ UDFRegisterFsStructure

#define UDFRegisterFsStructure	(	Vcb,
		Lba,
		Length
	)	{NOTHING;}

Definition at line 1250 of file udf_info.h.

◆ UDFSetBit

#define UDFSetBit	(	arr,
		bit
	)	( (((uint32*)(arr))[(bit)>>5]) \|= (((uint32)1) << ((bit)&31)) )

Definition at line 1181 of file udf_info.h.

◆ UDFSetBits

#define UDFSetBits	(	arr,
		bit,
		bc
	)

Value:

{uint32 j;                       \
    for(j=0;j<bc;j++) {          \
        UDFSetBit(arr, (bit)+j); \
}}

Definition at line 1184 of file udf_info.h.

◆ UDFSetEntityID_imp

#define UDFSetEntityID_imp	(	eID,
		Str
	)	UDFSetEntityID_imp_(eID, (uint8*)(Str), sizeof(Str));

Definition at line 598 of file udf_info.h.

◆ UDFSetFileAllocMode__

#define UDFSetFileAllocMode__	(	fi,
		mode
	)

Value:

{                                       \
    (fi)->Dloc->DataLoc.Flags = \
        ((fi)->Dloc->DataLoc.Flags & ~EXTENT_FLAG_ALLOC_MASK) | (mode & EXTENT_FLAG_ALLOC_MASK);     \
}

Definition at line 1073 of file udf_info.h.

◆ UDFSetFreeBit

#define UDFSetFreeBit	(	arr,
		bit
	)	UDFSetBit(arr,bit)

Definition at line 1201 of file udf_info.h.

◆ UDFSetFreeBitOwner

#define UDFSetFreeBitOwner	(	Vcb,
		i
	)

Definition at line 1235 of file udf_info.h.

◆ UDFSetFreeBits

#define UDFSetFreeBits	(	arr,
		bit,
		bc
	)	UDFSetBits(arr,bit,bc)

Definition at line 1203 of file udf_info.h.

◆ UDFSetUsedBit

#define UDFSetUsedBit	(	arr,
		bit
	)	UDFClrBit(arr,bit)

Definition at line 1200 of file udf_info.h.

◆ UDFSetUsedBitOwner

#define UDFSetUsedBitOwner	(	Vcb,
		i,
		o
	)

Definition at line 1236 of file udf_info.h.

◆ UDFSetUsedBits

#define UDFSetUsedBits	(	arr,
		bit,
		bc
	)	UDFClrBits(arr,bit,bc)

Definition at line 1202 of file udf_info.h.

◆ UDFSetZeroBit

#define UDFSetZeroBit	(	arr,
		bit
	)	UDFSetBit(arr,bit)

Definition at line 1208 of file udf_info.h.

◆ UDFSetZeroBits

#define UDFSetZeroBits	(	arr,
		bit,
		bc
	)	UDFSetBits(arr,bit,bc)

Definition at line 1210 of file udf_info.h.

◆ UDFSparseExtent__

#define UDFSparseExtent__	(	Vcb,
		Ext,
		Off,
		Len,
		Dir,
		WB
	)	UDFZeroExtent(Vcb, Ext, Off, Len, TRUE, Dir, WB)

Definition at line 542 of file udf_info.h.

◆ UDFStreamsSupported

#define UDFStreamsSupported ( Vcb ) (Vcb->maxUDFWriteRev >= 0x0200)

Definition at line 1037 of file udf_info.h.

◆ UDFZeroExtent__

#define UDFZeroExtent__	(	Vcb,
		Ext,
		Off,
		Len,
		Dir,
		WB
	)	UDFZeroExtent(Vcb, Ext, Off, Len, FALSE, Dir, WB)

Definition at line 539 of file udf_info.h.

◆ UFD_VERIFY_FLAG_BG

#define UFD_VERIFY_FLAG_BG 0x04

Definition at line 1304 of file udf_info.h.

◆ UFD_VERIFY_FLAG_FORCE

#define UFD_VERIFY_FLAG_FORCE 0x01

Definition at line 1302 of file udf_info.h.

◆ UFD_VERIFY_FLAG_LOCKED

#define UFD_VERIFY_FLAG_LOCKED 0x10

Definition at line 1305 of file udf_info.h.

◆ UFD_VERIFY_FLAG_WAIT

#define UFD_VERIFY_FLAG_WAIT 0x02

Definition at line 1303 of file udf_info.h.

Function Documentation

◆ crc32()

uint32 __fastcall crc32	(	IN uint8 *	s,
		IN uint32	len
	)

Definition at line 4290 of file udf_info.cpp.

{
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
//    uint32 _Size = len;
 
    __asm {
        push  ebx
        push  ecx
        push  edx
        push  esi
 
        xor   eax,eax
        mov   esi,ecx  // ESI <- s
        mov   ecx,edx  // ECX <- len
 
        jecxz EO_CRC
 
        lea   ebx,[crc32_tab]
        xor   edx,edx
 
CRC_loop:
 
        mov   dl,al
        xor   dl,[esi]
        shr   eax,8
        xor   eax,[dword ptr ebx+edx*4]
        inc   esi
        loop  CRC_loop
 
EO_CRC:
 
        pop   esi
        pop   edx
        pop   ecx
        pop   ebx
 
        ret
    }
#else  // NO X86 optimization , use generic C/C++
    uint32 i;
    uint32 crc32val = 0;
 
    for(i=0; i<len; i++, s++) {
        crc32val =
            crc32_tab[(crc32val ^ (*s)) & 0xff] ^ (crc32val >> 8);
    }
    return crc32val;
#endif // _X86_
} // end crc32()

◆ UDFAcquireDloc()

OSSTATUS UDFAcquireDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc
	)

Definition at line 1206 of file dirtree.cpp.

{
    UDFAcquireResourceExclusive(&(Vcb->DlocResource2),TRUE);
    if(Dloc->FE_Flags & UDF_FE_FLAG_UNDER_INIT) {
        UDFReleaseResource(&(Vcb->DlocResource2));
        return STATUS_SHARING_PAUSED;
    }
    Dloc->FE_Flags |= UDF_FE_FLAG_UNDER_INIT;
    UDFReleaseResource(&(Vcb->DlocResource2));
    return STATUS_SUCCESS;
} // end UDFAcquireDloc()

Referenced by UDFStoreDloc().

◆ UDFAddXSpaceBitmap()

OSSTATUS UDFAddXSpaceBitmap	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN PSHORT_AD	bm,
		IN ULONG	bm_type
	)

Definition at line 1569 of file mount.cpp.

{
    int8* tmp;
    int8* tmp_bm;
    uint32 i, lim, j, lba, l, lim2, l2, k;
    lb_addr locAddr;
    OSSTATUS status;
    uint16 Ident;
    uint32 flags;
    SIZE_T Length;
    SIZE_T ReadBytes;
    BOOLEAN bit_set;
 
    UDF_CHECK_BITMAP_RESOURCE(Vcb);
    UDFPrint(("UDFAddXSpaceBitmap: at block=%x, partition=%d\n",
        bm->extPosition,
        PartNum));
 
    if(!(Length = (bm->extLength & UDF_EXTENT_LENGTH_MASK))) return STATUS_SUCCESS;
    i=UDFPartStart(Vcb, PartNum);
    flags = bm->extLength >> 30;
    if(!flags /*|| flags == EXTENT_NOT_RECORDED_ALLOCATED*/) {
        tmp = (int8*)DbgAllocatePool(NonPagedPool, max(Length, Vcb->BlockSize));
        if(!tmp) return STATUS_INSUFFICIENT_RESOURCES;
        locAddr.partitionReferenceNum = (uint16)PartNum;
        locAddr.logicalBlockNum = bm->extPosition;
        // read header of the Bitmap
        if(!OS_SUCCESS(status = UDFReadTagged(Vcb, tmp, lba = UDFPartLbaToPhys(Vcb, &(locAddr)),
                             locAddr.logicalBlockNum, &Ident)) ) {
err_addxsbm_1:
            DbgFreePool(tmp);
            return status;
        }
        if(Ident != TID_SPACE_BITMAP_DESC) {
            status = STATUS_DISK_CORRUPT_ERROR;
            goto err_addxsbm_1;
        }
        UDFRegisterFsStructure(Vcb, lba, Vcb->BlockSize);
        // read the whole Bitmap
        if(!OS_SUCCESS(status = UDFReadData(Vcb, FALSE, ((uint64)lba)<<Vcb->BlockSizeBits, Length, FALSE, tmp, &ReadBytes)))
            goto err_addxsbm_1;
        UDFRegisterFsStructure(Vcb, lba, Length);
        lim = min(i + ((lim2 = ((PSPACE_BITMAP_DESC)tmp)->numOfBits) << Vcb->LB2B_Bits), Vcb->FSBM_BitCount);
        tmp_bm = tmp + sizeof(SPACE_BITMAP_DESC);
        j = 0;
        for(;(l = UDFGetBitmapLen((uint32*)tmp_bm, j, lim2)) && (i<lim);) {
            // expand LBlocks to Sectors...
            l2 = l << Vcb->LB2B_Bits;
            // ...and mark them
            if(bm_type == UDF_FSPACE_BM) {
                bit_set = UDFGetFreeBit(tmp_bm, j);
                for(k=0;(k<l2) && (i<lim);k++) {
                    if(bit_set) {
                        // FREE block
                        UDFSetFreeBit(Vcb->FSBM_Bitmap, i);
                        UDFSetFreeBitOwner(Vcb, i);
                        UDFSetZeroBit(Vcb->ZSBM_Bitmap, i);
                    } else {
                        // USED block
                        UDFClrZeroBit(Vcb->ZSBM_Bitmap, i);
                    }
                    i++;
                }
            } else {
                bit_set = UDFGetZeroBit(tmp_bm, j);
                for(k=0;(k<l2) && (i<lim);k++) {
                    if(bit_set) {
                        // ZERO block
                        UDFSetZeroBit(Vcb->ZSBM_Bitmap, i);
                    } else {
                        // DATA block
                        UDFClrZeroBit(Vcb->ZSBM_Bitmap, i);
                    }
                    i++;
                }
            }
            j += l;
        }
        DbgFreePool(tmp);
/*    } else if((bm->extLength >> 30) == EXTENT_NOT_RECORDED_ALLOCATED) {
        i=Vcb->Partitions[PartNum].PartitionRoot;
        lim = i + Vcb->Partitions[PartNum].PartitionLen;
        for(;i<lim;i++) {
            UDFSetUsedBit(Vcb->FSBM_Bitmap, i);
        }*/
    }
    return STATUS_SUCCESS;
} // end UDFAddXSpaceBitmap()

Referenced by UDFBuildFreeSpaceBitmap().

◆ UDFAllocateFESpace()

OSSTATUS UDFAllocateFESpace	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo,
		IN uint32	PartNum,
		IN PEXTENT_INFO	FEExtInfo,
		IN uint32	Len
	)

Definition at line 1563 of file extent.cpp.

{
#ifdef UDF_FE_ALLOCATION_CHARGE // UDF_FE_ALLOCATION_CHARGE
    OSSTATUS status;
    PEXTENT_INFO Ext;
    EXTENT_AD Extent;
    BOOLEAN retry = FALSE;
    uint32 i, lim;
 
/*
    1. #Dir1#->*File*                ->  Dir1's FECharge
    2. #Dir1#->*Dir*                 ->  Dir1's FECharge
    3. #Dir1#->*SDir*                ->  Dir1's FECharge
    4. Dir1->#SDir#->*Stream*        ->  Dir1's FEChargeSDir
    5. Dir1->#File#->*SDir*          ->  Dir1's FEChargeSDir
    6. Dir1->#Dir#->*SDir*           ->  (see p.2)
    7. Dir1->File->#SDir#->*Stream*  ->  Dir1's FEChargeSDir
    8. Dir1->Dir->#SDir#->*Stream*   ->  (see p.4)
 
## ~ DirInfo
** ~ Object to be created
 
*/
 
//    ASSERT(!FEExtInfo->Mapping);
    // check if DirInfo we are called with is a Directory
    // (it can be a file with SDir)
    if(!DirInfo || !DirInfo->Dloc->DirIndex ||
       ((lim = ((DirInfo->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR) ? Vcb->FEChargeSDir : Vcb->FECharge)) <= 1))
#endif // UDF_FE_ALLOCATION_CHARGE
        return UDFAllocFreeExtent(Vcb, Len,
               UDFPartStart(Vcb, PartNum), UDFPartEnd(Vcb, PartNum), FEExtInfo, EXTENT_FLAG_VERIFY);
#ifdef UDF_FE_ALLOCATION_CHARGE // UDF_FE_ALLOCATION_CHARGE
 
    Ext = &(DirInfo->Dloc->DirIndex->FECharge);
 
    while(TRUE) {
 
        if(!Ext->Mapping) {
            ULONG p_start;
            ULONG p_end;
            ULONG fe_loc;
            ULONG l1, l2;
 
            p_start = UDFPartStart(Vcb, PartNum);
            p_end   = UDFPartEnd(Vcb, PartNum);
            fe_loc  = DirInfo->Dloc->FELoc.Mapping[0].extLocation;
 
            status = UDFGetCachedAllocation(Vcb, fe_loc, Ext, NULL, UDF_PREALLOC_CLASS_FE);
            if(OS_SUCCESS(status)) {
                // do nothing, even do not unpack
            } else
            if(Vcb->LowFreeSpace) {
                status = UDFAllocFreeExtent(Vcb, Len << Vcb->LBlockSizeBits,p_start, p_end, FEExtInfo, EXTENT_FLAG_VERIFY);
                if(OS_SUCCESS(status)) {
                    UDFPrint(("FE @ %x (1)\n", FEExtInfo->Mapping[0].extLocation ));
                }
                return status;
            } else {
                if(fe_loc > p_start + 512*16) {
                    l1 = fe_loc - 512*16;
                } else {
                    l1 = p_start;
                }
                if(fe_loc + 512*16 < p_end) {
                    l2 = fe_loc + 512*16;
                } else {
                    l2 = p_end;
                }
                status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, l1, l2, Ext, EXTENT_FLAG_VERIFY);
                if(!OS_SUCCESS(status)) {
                    status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, (p_start+fe_loc)/2, (fe_loc+p_end)/2, Ext, EXTENT_FLAG_VERIFY);
                }
                if(!OS_SUCCESS(status)) {
                    status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, p_start, p_end, Ext, EXTENT_FLAG_VERIFY);
                }
                if(!OS_SUCCESS(status)) {
                    status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, p_start+1024, p_end-1024, Ext, EXTENT_FLAG_VERIFY);
                }
                if(!OS_SUCCESS(status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, p_start, p_end, Ext, EXTENT_FLAG_VERIFY) )) {
                    // can't pre-allocate space for multiple FEs. Try single FE
                    UDFPrint(("allocate single FE entry\n"));
                    status = UDFAllocFreeExtent(Vcb, Len,
                           p_start, p_end, FEExtInfo, EXTENT_FLAG_VERIFY);
                    if(OS_SUCCESS(status)) {
                        UDFPrint(("FE @ %x (2)\n", FEExtInfo->Mapping[0].extLocation ));
                    }
                    return status;
                }
                status = UDFUnPackMapping(Vcb, Ext);
                if(!OS_SUCCESS(status)) {
                    MyFreePool__(Ext->Mapping);
                    Ext->Mapping = NULL;
                    return status;
                }
            }
        }
 
        for(i=0;i<lim;i++) {
            if( (Ext->Mapping[i].extLength >> 30) == EXTENT_NOT_RECORDED_ALLOCATED ) {
                Ext->Mapping[i].extLength &= UDF_EXTENT_LENGTH_MASK; // EXTENT_RECORDED_ALLOCATED
 
                Extent.extLength = Vcb->LBlockSize | (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                Extent.extLocation = Ext->Mapping[i].extLocation;
 
                if(Vcb->BSBM_Bitmap) {
                    uint32 lba = Ext->Mapping[i].extLocation;
                    if(UDFGetBadBit((uint32*)(Vcb->BSBM_Bitmap), lba)) {
                        UDFPrint(("Remove BB @ %x from FE charge\n", lba));
                        Ext->Mapping[i].extLength |= (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
                        Ext->Mapping[i].extLocation = 0;
                        continue;
                    }
                }
 
                FEExtInfo->Mapping = UDFExtentToMapping(&Extent);
                if(!FEExtInfo->Mapping) {
                    ASSERT(!(Ext->Mapping[i].extLength >> 30));
                    Ext->Mapping[i].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
                UDFPrint(("FE @ %x (3)\n", FEExtInfo->Mapping[0].extLocation ));
                FEExtInfo->Length = Len;
                FEExtInfo->Offset = 0;
                FEExtInfo->Modified = TRUE;
                return STATUS_SUCCESS;
            }
        }
 
        if(Vcb->LowFreeSpace) {
            status = UDFAllocFreeExtent(Vcb, Len,
                   UDFPartStart(Vcb, PartNum), UDFPartEnd(Vcb, PartNum), FEExtInfo, EXTENT_FLAG_VERIFY);
            if(OS_SUCCESS(status)) {
                UDFPrint(("FE @ %x (4)\n", FEExtInfo->Mapping[0].extLocation ));
            }
            return status;
        }
        if(retry)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        // we can get here if there are no free slots in
        // preallocated FE charge. So, we should release
        // memory and try to allocate space for new FE charge.
        MyFreePool__(Ext->Mapping);
        Ext->Mapping = NULL;
        retry = TRUE;
    }
    return STATUS_INSUFFICIENT_RESOURCES;
#endif // UDF_FE_ALLOCATION_CHARGE
 
} // end UDFAllocateFESpace()

Referenced by UDFBuildFileEntry(), and UDFFlushFE().

◆ UDFAllocFreeExtent_()

OSSTATUS UDFAllocFreeExtent_	(	IN PVCB	Vcb,
		IN int64	Length,
		IN uint32	SearchStart,
		IN uint32	SearchLim,
		OUT PEXTENT_INFO	Extent,
		IN uint8	AllocFlags
	)

Definition at line 963 of file alloc.cpp.

{
    EXTENT_AD Ext;
    PEXTENT_MAP Map = NULL;
    uint32 len, LBS, BSh, blen;
 
    LBS = Vcb->LBlockSize;
    BSh = Vcb->BlockSizeBits;
    blen = (uint32)(((Length+LBS-1) & ~((int64)LBS-1)) >> BSh);
    ExtInfo->Mapping = NULL;
    ExtInfo->Offset = 0;
 
    ASSERT(blen <= (uint32)(UDF_MAX_EXTENT_LENGTH >> BSh));
 
    UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE);
 
    if(blen > (SearchLim - SearchStart)) {
        goto no_free_space_err;
    }
    // walk through the free space bitmap & find a single extent or a set of
    // frags giving in sum the Length specified
    while(blen) {
        Ext.extLocation = UDFFindMinSuitableExtent(Vcb, blen, SearchStart,
                                                               SearchLim, &len, AllocFlags);
 
//        ASSERT(len <= (uint32)(UDF_MAX_EXTENT_LENGTH >> BSh));
        if(len >= blen) {
            // complete search
            Ext.extLength = blen<<BSh;
            blen = 0;
        } else if(len) {
            // we need still some frags to complete request &
            // probably we have the opportunity to do it
            Ext.extLength = len<<BSh;
            blen -= len;
        } else {
no_free_space_err:
            // no more free space. abort
            if(ExtInfo->Mapping) {
                UDFMarkSpaceAsXXXNoProtect(Vcb, 0, ExtInfo->Mapping, AS_DISCARDED); // free
                MyFreePool__(ExtInfo->Mapping);
                ExtInfo->Mapping = NULL;
            }
            UDFReleaseResource(&(Vcb->BitMapResource1));
            ExtInfo->Length = 0;//UDFGetExtentLength(ExtInfo->Mapping);
            AdPrint(("  DISK_FULL\n"));
            return STATUS_DISK_FULL;
        }
        // append the frag found to mapping
        ASSERT(!(Ext.extLength >> 30));
        ASSERT(Ext.extLocation);
 
        // mark newly allocated blocks as zero-filled
        UDFSetZeroBits(Vcb->ZSBM_Bitmap, Ext.extLocation, (Ext.extLength & UDF_EXTENT_LENGTH_MASK) >> BSh);
 
        if(AllocFlags & EXTENT_FLAG_VERIFY) {
            if(!UDFCheckArea(Vcb, Ext.extLocation, Ext.extLength >> BSh)) {
                AdPrint(("newly allocated extent contains BB\n"));
                UDFMarkSpaceAsXXXNoProtect(Vcb, 0, ExtInfo->Mapping, AS_DISCARDED); // free
                UDFMarkBadSpaceAsUsed(Vcb, Ext.extLocation, Ext.extLength >> BSh); // bad -> bad+used
                // roll back
                blen += Ext.extLength>>BSh;
                continue;
            }
        }
 
        Ext.extLength |= EXTENT_NOT_RECORDED_ALLOCATED << 30;
        if(!(ExtInfo->Mapping)) {
            // create new
#ifdef UDF_TRACK_ALLOC_FREE_EXTENT
            ExtInfo->Mapping = UDFExtentToMapping_(&Ext, src, line);
#else // UDF_TRACK_ALLOC_FREE_EXTENT
            ExtInfo->Mapping = UDFExtentToMapping(&Ext);
#endif // UDF_TRACK_ALLOC_FREE_EXTENT
            if(!ExtInfo->Mapping) {
                BrutePoint();
                UDFReleaseResource(&(Vcb->BitMapResource1));
                ExtInfo->Length = 0;
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, ExtInfo->Mapping, AS_USED); // used
        } else {
            // update existing
            Map = UDFExtentToMapping(&Ext);
            if(!Map) {
                BrutePoint();
                UDFReleaseResource(&(Vcb->BitMapResource1));
                ExtInfo->Length = UDFGetExtentLength(ExtInfo->Mapping);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, Map, AS_USED); // used
            ExtInfo->Mapping = UDFMergeMappings(ExtInfo->Mapping, Map);
            MyFreePool__(Map);
        }
        if(!ExtInfo->Mapping) {
            BrutePoint();
            UDFReleaseResource(&(Vcb->BitMapResource1));
            ExtInfo->Length = 0;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    UDFReleaseResource(&(Vcb->BitMapResource1));
    ExtInfo->Length = Length;
    return STATUS_SUCCESS;
} // end UDFAllocFreeExtent_()

◆ UDFAreSectorsRelocated()

BOOLEAN __fastcall UDFAreSectorsRelocated	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	BlockCount
	)

Definition at line 982 of file remap.cpp.

{
 
    if(Vcb->SparingTable) {
        // use sparing table for relocation
        uint32 i, BS, orig;
        BS = Vcb->SparingBlockSize;
        PSPARING_MAP Map;
 
        Map = Vcb->SparingTable;
        for(i=0;i<Vcb->SparingCount;i++,Map++) {
            if( ((Lba >= (orig = Map->origLocation)) && (Lba < orig + BS)) ||
                ((Lba+BlockCount-1 >= orig) && (Lba+BlockCount-1 < orig + BS)) ||
                ((orig >= Lba) && (orig < Lba+BlockCount)) ||
                ((orig+BS >= Lba) && (orig+BS < Lba+BlockCount)) ) {
                return TRUE;
            }
        }
    } else if(Vcb->Vat) {
        // use VAT for relocation
        uint32 i, root, j;
        uint32* Map;
        if(Lba < (root = Vcb->Partitions[Vcb->VatPartNdx].PartitionRoot))
            return FALSE;
        if(Lba+BlockCount >= Vcb->NWA)
            return TRUE;
        Map = &(Vcb->Vat[Lba-root/*+i*/]);
        for(i=0; i<BlockCount; i++, Map++) {
            if((j = (*Map)) &&
               (j != Lba-root+i) &&
               ((j != UDF_VAT_FREE_ENTRY) || ((Lba+i) < Vcb->LastLBA)))
                return TRUE;
        }
    }
    return FALSE;
} // end UDFAreSectorsRelocated()

Referenced by UDFRelocateSectors().

◆ UDFBuildAllocDescs()

OSSTATUS UDFBuildAllocDescs	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN OUT PUDF_FILE_INFO	FileInfo,
		OUT int8 **	AllocData
	)

Definition at line 2628 of file extent.cpp.

{
//    PEXTENT_MAP InMap;
//    uint32 i=0;
    int8* Allocs;
    uint16 AllocMode;
    uint32 InitSz;
    OSSTATUS status;
 
    ValidateFileInfo(FileInfo);
    AdPrint(("BuildAllocDesc\n"));
    // get space available in the 1st LBlock after FE
    InitSz = Vcb->LBlockSize - FileInfo->Dloc->FileEntryLen;
    Allocs = (int8*)MyAllocatePool__(NonPagedPool, InitSz);
    if(!Allocs) {
        *AllocData = NULL;
        AdPrint(("BuildAllocDesc: cant alloc %x bytes for Allocs\n", InitSz));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlZeroMemory(Allocs, InitSz);
//    InMap = FileInfo->Dloc->DataLoc.Mapping;
    UDFCheckSpaceAllocation(Vcb, 0, InMap, AS_USED); // check if used
 
    // TODO: move data from mapped locations here
 
    AllocMode = ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK;
    switch(AllocMode) {
    case ICB_FLAG_AD_IN_ICB: {
        MyFreePool__(Allocs);
        ASSERT(!FileInfo->Dloc->AllocLoc.Mapping);
        Allocs = NULL;
        status = STATUS_SUCCESS;
        break;
    }
    case ICB_FLAG_AD_SHORT: {
        status = UDFBuildShortAllocDescs(Vcb, PartNum, &Allocs, InitSz, FileInfo);
        break;
    }
    case ICB_FLAG_AD_LONG: {
        status = UDFBuildLongAllocDescs(Vcb, PartNum, &Allocs, InitSz, FileInfo);
        break;
    }
/*    case ICB_FLAG_AD_EXTENDED: {
        status = UDFBuildExtAllocDescs(Vcb, PartNum, &Allocs, InitSz, FileInfo);
        break;
    }*/
    default: {
        MyFreePool__(Allocs);
        Allocs = NULL;
        status = STATUS_INVALID_PARAMETER;
    }
    }
 
    *AllocData = Allocs;
    UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_USED); // check if used
 
    return status;
} // end UDFBuildAllocDescs()

Referenced by UDFFlushFE().

◆ UDFBuildFileEntry()

OSSTATUS UDFBuildFileEntry	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo,
		IN PUDF_FILE_INFO	FileInfo,
		IN uint32	PartNum,
		IN uint16	AllocMode,
		IN uint32	ExtAttrSz,
		IN BOOLEAN	Extended
	)

Definition at line 971 of file udf_info.cpp.

{
    PFILE_ENTRY FileEntry;
    OSSTATUS status;
//    EntityID* eID;
    uint32 l;
    EXTENT_INFO _FEExtInfo;
    uint16* lcp;
 
    ASSERT(!PartNum);
    ASSERT(!ExtAttrSz);
    // calculate the length required
    l = (Extended ? sizeof(EXTENDED_FILE_ENTRY) : sizeof(FILE_ENTRY)) + ExtAttrSz;
    if(l > Vcb->LBlockSize) return STATUS_INVALID_PARAMETER;
    // allocate block for FE
    if(!OS_SUCCESS(status = UDFAllocateFESpace(Vcb, DirInfo, PartNum, &_FEExtInfo, l) ))
        return status;
    // remember FE location for future hard link creation
    ASSERT(UDFFindDloc(Vcb, _FEExtInfo.Mapping[0].extLocation) == (-1));
    if(!OS_SUCCESS(status = UDFStoreDloc(Vcb, FileInfo, _FEExtInfo.Mapping[0].extLocation))) {
        ASSERT(status != STATUS_SHARING_PAUSED);
        UDFFreeFESpace(Vcb, DirInfo, &_FEExtInfo); // free
        MyFreePool__(_FEExtInfo.Mapping);
        return status;
    }
    FileEntry = (PFILE_ENTRY)MyAllocatePoolTag__(NonPagedPool, l, MEM_FE_TAG);
    if(!FileEntry) {
        UDFRemoveDloc(Vcb, FileInfo->Dloc);
        FileInfo->Dloc = NULL;
        UDFFreeFESpace(Vcb, DirInfo, &_FEExtInfo); // free
        MyFreePool__(_FEExtInfo.Mapping);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    FileInfo->Dloc->FELoc = _FEExtInfo;
 
    RtlZeroMemory((int8*)FileEntry, l);
    // set up in-memory FE structure
    FileEntry->icbTag.flags = AllocMode;
    FileEntry->icbTag.fileType = UDF_FILE_TYPE_REGULAR;
    FileEntry->icbTag.numEntries = 1;
//    if(DirInfo && DirInfo->Dloc && DirInfo->Dloc
    FileEntry->icbTag.strategyType = 4;
//    FileEntry->icbTag.strategyParameter = 0;
    FileEntry->descTag.tagIdent = Extended ? TID_EXTENDED_FILE_ENTRY : TID_FILE_ENTRY;
    FileEntry->descTag.tagLocation = UDFPhysLbaToPart(Vcb, PartNum, _FEExtInfo.Mapping[0].extLocation);
    FileEntry->uid = Vcb->DefaultUID;
    FileEntry->gid = Vcb->DefaultGID;
 
    if(Extended) {
//        eID = &(((PEXTENDED_FILE_ENTRY)FileEntry)->impIdent);
        lcp = &(((PEXTENDED_FILE_ENTRY)FileEntry)->fileLinkCount);
        ((PEXTENDED_FILE_ENTRY)FileEntry)->checkpoint = 1;
    } else {
//        eID = &(FileEntry->impIdent);
        lcp = &(FileEntry->fileLinkCount);
        ((PFILE_ENTRY)FileEntry)->checkpoint = 1;
    }
 
#if 0
    UDFSetEntityID_imp(eID, UDF_ID_DEVELOPER);
#endif
 
    /*RtlCopyMemory((int8*)&(eID->ident), UDF_ID_DEVELOPER, sizeof(UDF_ID_DEVELOPER) );
    iis = (impIdentSuffix*)&(eID->identSuffix);
    iis->OSClass = UDF_OS_CLASS_WINNT;
    iis->OSIdent = UDF_OS_ID_WINNT;*/
 
    *lcp = 0xffff;
 
    FileInfo->Dloc->FileEntry = (tag*)FileEntry;
    FileInfo->Dloc->FileEntryLen = l;
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
 
    return STATUS_SUCCESS;
} // end UDFBuildFileEntry()

Referenced by UDFCreateFile__(), and UDFCreateRootFile__().

◆ UDFBuildFileIdent()

OSSTATUS UDFBuildFileIdent	(	IN PVCB	Vcb,
		IN PUNICODE_STRING	fn,
		IN PLONG_AD	FileEntryIcb,
		IN uint32	ImpUseLen,
		OUT PFILE_IDENT_DESC *	_FileId,
		OUT uint32 *	FileIdLen
	)

Definition at line 1107 of file udf_info.cpp.

{
    PFILE_IDENT_DESC FileId;
    uint8* CS0;
    SIZE_T Nlen;
    uint32 l;
    // prepare filename
    UDFCompressUnicode(fn, &CS0, &Nlen);
    if(!CS0) return STATUS_INSUFFICIENT_RESOURCES;
    if(Nlen < 2) {
        Nlen = 0;
    } else
    if(Nlen > UDF_NAME_LEN) {
        if(CS0) MyFreePool__(CS0);
        return STATUS_OBJECT_NAME_INVALID;
    }
    // allocate memory for FI
    l = (sizeof(FILE_IDENT_DESC) + Nlen + ImpUseLen + 3) & ~((uint32)3);
    FileId = (PFILE_IDENT_DESC)MyAllocatePoolTag__(NonPagedPool, l, MEM_FID_TAG);
    if(!FileId) {
        if(CS0) MyFreePool__(CS0);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    // fill FI structure
    RtlZeroMemory( (int8*)FileId, l);
    RtlCopyMemory( ((int8*)(FileId+1))+ImpUseLen, CS0, Nlen);
    FileId->descTag.tagIdent = TID_FILE_IDENT_DESC;
    FileId->fileVersionNum = 1;
    FileId->lengthOfImpUse = (uint16)ImpUseLen;
    FileId->lengthFileIdent = (uint8)Nlen;
    FileId->icb = *FileEntryIcb;
    *_FileId = FileId;
    *FileIdLen = l;
 
    if(CS0) MyFreePool__(CS0);
    return STATUS_SUCCESS;
} // end UDFBuildFileIdent()

Referenced by UDFCreateFile__(), and UDFRecordDirectory__().

◆ UDFBuildFreeSpaceBitmap()

OSSTATUS UDFBuildFreeSpaceBitmap	(	IN PVCB	Vcb,
		IN uint32	PartNdx,
		IN PPARTITION_HEADER_DESC	phd,
		IN uint32	Lba
	)

Definition at line 1910 of file mount.cpp.

{
    OSSTATUS status;
    uint32 i, l;
    uint16 Ident;
    int8* AllocDesc;
    PEXTENT_MAP Extent;
    lb_addr locAddr;
    uint32 PartNum;
 
    PartNum = UDFGetPartNumByPartNdx(Vcb, PartNdx);
    if(!(Vcb->FSBM_Bitmap)) {
        // init Bitmap buffer if necessary
        Vcb->FSBM_Bitmap = (int8*)DbgAllocatePool(NonPagedPool, (i = (Vcb->LastPossibleLBA+1+7)>>3) );
        if(!(Vcb->FSBM_Bitmap)) return STATUS_INSUFFICIENT_RESOURCES;
 
        Vcb->ZSBM_Bitmap = (int8*)DbgAllocatePool(NonPagedPool, (i = (Vcb->LastPossibleLBA+1+7)>>3) );
        if(!(Vcb->ZSBM_Bitmap)) {
#ifdef UDF_TRACK_ONDISK_ALLOCATION_OWNERS
free_fsbm:
#endif //UDF_TRACK_ONDISK_ALLOCATION_OWNERS
            MyFreePool__(Vcb->FSBM_Bitmap);
            Vcb->FSBM_Bitmap = NULL;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlZeroMemory(Vcb->FSBM_Bitmap, i);
        RtlZeroMemory(Vcb->ZSBM_Bitmap, i);
#ifdef UDF_TRACK_ONDISK_ALLOCATION_OWNERS
        Vcb->FSBM_Bitmap_owners = (uint32*)DbgAllocatePool(NonPagedPool, (Vcb->LastPossibleLBA+1)*sizeof(uint32));
        if(!(Vcb->FSBM_Bitmap_owners)) {
            MyFreePool__(Vcb->ZSBM_Bitmap);
            Vcb->ZSBM_Bitmap = NULL;
            goto free_fsbm;
        }
        RtlFillMemory(Vcb->FSBM_Bitmap_owners, (Vcb->LastPossibleLBA+1)*sizeof(uint32), 0xff);
#endif //UDF_TRACK_ONDISK_ALLOCATION_OWNERS
        Vcb->FSBM_ByteCount = i;
        Vcb->FSBM_BitCount = Vcb->LastPossibleLBA+1;
    }
    // read info for partition header (if any)
    if(phd) {
        // read unallocated Bitmap
        if(!OS_SUCCESS(status = UDFAddXSpaceBitmap(Vcb, PartNum, &(phd->unallocatedSpaceBitmap), UDF_FSPACE_BM)))
            return status;
        // read freed Bitmap
        if(!OS_SUCCESS(status = UDFAddXSpaceBitmap(Vcb, PartNum, &(phd->freedSpaceBitmap), UDF_ZSPACE_BM)))
            return status;
    }
    // read UnallocatedSpaceDesc & convert to Bitmap
    if(Lba) {
        if(!(AllocDesc = (int8*)MyAllocatePool__(NonPagedPool, Vcb->LBlockSize + sizeof(EXTENT_AD) )))
            return STATUS_INSUFFICIENT_RESOURCES;
        RtlZeroMemory(((int8*)AllocDesc) + Vcb->LBlockSize, sizeof(EXTENT_AD));
        if(!OS_SUCCESS(status = UDFReadTagged(Vcb, AllocDesc, Lba, Lba, &Ident)) ||
           !(Extent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, l = (((PUNALLOC_SPACE_DESC)AllocDesc)->numAllocDescs+1) * sizeof(EXTENT_AD) ))) {
            MyFreePool__(AllocDesc);
            return status;
        }
        UDFRegisterFsStructure(Vcb, Lba, Vcb->BlockSize);
        RtlCopyMemory((int8*)Extent, AllocDesc+sizeof(UNALLOC_SPACE_DESC), (((PUNALLOC_SPACE_DESC)AllocDesc)->numAllocDescs+1) * sizeof(EXTENT_AD) );
        locAddr.partitionReferenceNum = (uint16)PartNum;
        // read extent is recorded with relative addresses
        // so, we should convert it to suitable form
        for(i=0; Extent[i].extLength; i++) {
            locAddr.logicalBlockNum = Extent[i].extLocation;
            Extent[i].extLocation = UDFPartLbaToPhys(Vcb, &locAddr);
            if(Extent[i].extLocation == LBA_OUT_OF_EXTENT) {
                BrutePoint();
                MyFreePool__(AllocDesc);
                return STATUS_DISK_CORRUPT_ERROR;
            }
            if((Extent[i].extLocation >> 30) == EXTENT_NEXT_EXTENT_ALLOCDESC) {
                // load continuation
                Lba = Extent[i].extLocation & UDF_EXTENT_LENGTH_MASK;
                if(!OS_SUCCESS(status = UDFReadTagged(Vcb, AllocDesc, Lba, Lba, &Ident)) ||
                   !(Extent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, (((PUNALLOC_SPACE_DESC)AllocDesc)->numAllocDescs+1) * sizeof(EXTENT_AD) ))) {
                    MyFreePool__(AllocDesc);
                    return status;
                }
                if(Ident == TID_UNALLOC_SPACE_DESC) {
                    UDFRegisterFsStructure(Vcb, Lba, Vcb->BlockSize);
                    if(!(l = MyReallocPool__((int8*)Extent, l, (int8**)&Extent, i*sizeof(EXTENT_MAP)))) {
                        MyFreePool__(Extent);
                        MyFreePool__(AllocDesc);
                        return STATUS_INSUFFICIENT_RESOURCES;
                    }
                    Extent[i].extLength =
                    Extent[i].extLocation = 0;
                    Extent = UDFMergeMappings(Extent, (PEXTENT_MAP)(AllocDesc+sizeof(UNALLOC_SPACE_DESC)) );
#ifdef UDF_DBG
                } else {
                    UDFPrint(("Broken unallocated space descriptor sequence\n"));
#endif // UDF_DBG
                }
            }
        }
        UDFMarkSpaceAsXXX(Vcb, (-1), Extent, AS_USED); // mark as used
        MyFreePool__(Extent);
        MyFreePool__(AllocDesc);
    }
    return status;
} // end UDFVerifyFreeSpaceBitmap()

Referenced by UDFLoadPartDesc(), and UDFProcessSequence().

◆ UDFBuildHashEntry()

uint8 UDFBuildHashEntry	(	IN PVCB	Vcb,
		IN PUNICODE_STRING	Name,
		OUT PHASH_ENTRY	hashes,
		IN uint8	Mask
	)

Definition at line 429 of file dirtree.cpp.

{
    UNICODE_STRING UName;
    WCHAR ShortNameBuffer[13];
    uint8 RetFlags = 0;
 
    if(!Name->Buffer) return 0;
 
    if(Mask & HASH_POSIX)
        hashes->hPosix = crc32((uint8*)(Name->Buffer), Name->Length);
 
    if(Mask & HASH_ULFN) {
/*        if(OS_SUCCESS(MyInitUnicodeString(&UName, L"")) &&
           OS_SUCCESS(MyAppendUnicodeStringToStringTag(&UName, Name, MEM_USDIRHASH_TAG))) {*/
        if(OS_SUCCESS(MyCloneUnicodeString(&UName, Name))) {
            RtlUpcaseUnicodeString(&UName, &UName, FALSE);
    /*        if(!RtlCompareUnicodeString(Name, &UName, FALSE)) {
                RetFlags |= UDF_FI_FLAG_LFN;
            }*/
            hashes->hLfn = crc32((uint8*)(UName.Buffer), UName.Length);
        } else {
            BrutePoint();
        }
        MyFreePool__(UName.Buffer);
    }
 
    if(Mask & HASH_DOS) {
        UName.Buffer = (PWCHAR)(&ShortNameBuffer);
        UName.MaximumLength = 13*sizeof(WCHAR);
        UDFDOSName(Vcb, &UName, Name, (Mask & HASH_KEEP_NAME) ? TRUE : FALSE);
        if(!RtlCompareUnicodeString(Name, &UName, TRUE)) {
            RetFlags |= UDF_FI_FLAG_DOS;
        }
        hashes->hDos = crc32((uint8*)(UName.Buffer), UName.Length);
    }
    return RetFlags;
} // UDFBuildHashEntry()

Referenced by UDFBlankMount(), UDFCreateFile__(), UDFFindFile(), UDFIndexDirectory(), UDFQueryDirectory(), and UDFRenameMoveFile__().

◆ UDFBuildLongAllocDescs()

OSSTATUS UDFBuildLongAllocDescs	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		OUT int8 **	Buff,
		IN uint32	InitSz,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 1012 of file extent.cpp.

{
    uint32 i, j;
    uint32 len=0;
    PEXTENT_MAP Extent = FileInfo->Dloc->DataLoc.Mapping;
    PEXTENT_INFO AllocExtent = &(FileInfo->Dloc->AllocLoc);
    PLONG_AD Alloc;
    uint32 NewLen;
    OSSTATUS status;
    uint32 ph_len=0; // in general, this should be uint64,
                     // but we need its lower part only
#ifdef UDF_ALLOW_FRAG_AD
    uint32 ac, len2, ts;
    uint32 TagLoc, prevTagLoc;
    uint32 LBS = Vcb->LBlockSize;
    uint32 LBSh = Vcb->BlockSizeBits;
    uint32 BufOffs;
    uint32 ExtOffs = AllocExtent->Offset;
    PLONG_AD saved_Alloc;
    uint32 TagLen = 0;
    tag* Tag = NULL;
#endif //UDF_ALLOW_FRAG_AD
 
    ValidateFileInfo(FileInfo);
    ExtPrint(("UDFBuildLongAllocDescs: FE %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    // calculate length
    //for(len=0; i=(Extent[len].extLength & UDF_EXTENT_LENGTH_MASK); len++, ph_len+=i);
    for(len=0; (i=(Extent[len].extLength & UDF_EXTENT_LENGTH_MASK)); len++, ph_len+=i) {
        ExtPrint(("bLnExt: type %x, loc %x, len %x\n",
            Extent[len].extLength >> 30, Extent[len].extLocation, Extent[len].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    Alloc = (PLONG_AD)MyAllocatePoolTag__(NonPagedPool, (len+1)*sizeof(LONG_AD), MEM_LNGAD_TAG);
    if(!Alloc) return STATUS_INSUFFICIENT_RESOURCES;
    // fill contiguous AllocDesc buffer (decribing UserData)
    for(i=0;i<len;i++) {
        Alloc[i].extLength = Extent[i].extLength;
        Alloc[i].extLocation.logicalBlockNum = UDFPhysLbaToPart(Vcb, PartNum, Extent[i].extLocation);
        Alloc[i].extLocation.partitionReferenceNum = (uint16)PartNum;
        RtlZeroMemory(&(Alloc[i].impUse), sizeof(Alloc[i].impUse));
    }
    if((Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) && i) {
        Alloc[i-1].extLength -= (ph_len - (ULONG)(FileInfo->Dloc->DataLoc.Length)) &
                                (Vcb->LBlockSize-1);
        ExtPrint(("bLnExt: cut tail -> %x\n",
            Alloc[i-1].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    RtlZeroMemory(&(Alloc[i]), sizeof(LONG_AD));
    j = len*sizeof(LONG_AD); // required space
    len = (InitSz & ~(sizeof(LONG_AD)-1)); // space available in 1st block
    ASSERT(len == InitSz);
 
    // Ok. Let's init AllocLoc
    if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
        FileInfo->Dloc->AllocLoc.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool, 2 * sizeof(EXTENT_MAP), MEM_EXTMAP_TAG);
        if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
            MyFreePool__(Alloc);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        // allocation descriptors are located in the same sector as FileEntry
        // (at least their 1st part), just after it
        FileInfo->Dloc->AllocLoc.Mapping[0] = FileInfo->Dloc->FELoc.Mapping[0];
        FileInfo->Dloc->AllocLoc.Offset = FileInfo->Dloc->FileEntryLen;
        FileInfo->Dloc->AllocLoc.Length = 0;
        // set terminator
        FileInfo->Dloc->AllocLoc.Mapping[1].extLength =
        FileInfo->Dloc->AllocLoc.Mapping[1].extLocation = 0;
    }
 
    if(j <= len) {
        // we needn't allocating additional blocks to store AllocDescs
        RtlCopyMemory(*Buff, (int8*)Alloc, j);
        NewLen = j;
        MyFreePool__(Alloc);
    } else {
#ifndef UDF_ALLOW_FRAG_AD
        AdPrint(("  DISK_FULL\n"));
        return STATUS_DISK_FULL;
#else //UDF_ALLOW_FRAG_AD
        BufOffs = 0;
        TagLoc = prevTagLoc = 0;
        // calculate the space available for LONG_ADs in each block
        ac = (LBS - (sizeof(ALLOC_EXT_DESC) + sizeof(LONG_AD))) & ~(sizeof(LONG_AD)-1);
        len2 = len;
        // tail size
        ts = InitSz - len2;
        len -= sizeof(LONG_AD);
        // calculate actual AllocSequence length (in LBlocks)
        NewLen = ( ((j - len + ac - 1) / ac) << LBSh) + InitSz + sizeof(LONG_AD);
        MyFreePool__(*Buff);
        (*Buff) = (int8*)MyAllocatePoolTag__(NonPagedPool, NewLen, MEM_LNGAD_TAG);
        if(!(*Buff)) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto lad_alloc_err;
        }
        if(UDFGetExtentLength(AllocExtent->Mapping) < NewLen) {
            status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
            if(!OS_SUCCESS(status)) {
lad_alloc_err:
                MyFreePool__(Alloc);
                return status;
            }
        }
        ExtOffs = AllocExtent->Offset;
        RtlZeroMemory(*Buff, NewLen);
        NewLen = 0; // recorded length
        saved_Alloc = Alloc;
        len2 = len+sizeof(LONG_AD);
        // fill buffer sector by sector (adding links at the end of each one)
        while(TRUE) {
 
            // j - remained AllocDescs length (in bytes)
            // len - bytes available for in AllocDescs each block
 
            // leave space for terminator or pointer to next part of sequence
            if(j == len2) {
                // if we have only 1 LONG_AD that we can fit in last sector
                // we shall do it instead of recording link & allocating new block
                len =
                TagLen = len2;
            }
            RtlCopyMemory( (*Buff)+BufOffs, (int8*)Alloc, len);
            Alloc = (PLONG_AD)((int8*)Alloc + len);
            j -= len;
            BufOffs += len;
            if(Tag) {
                // Set up Tag for AllocDesc
                Tag->tagIdent = TID_ALLOC_EXTENT_DESC;
                UDFSetUpTag(Vcb, Tag, (uint16)TagLen, TagLoc);
                prevTagLoc = TagLoc;
            }
            if(!j) {
                // terminate loop
                NewLen = BufOffs;
                break;
            }
            len = ac;
            if(j <= (len + sizeof(LONG_AD)))
                len = j - sizeof(LONG_AD);
            len2 = len+sizeof(LONG_AD);
            // we have more than 1 LONG_AD that we can't fit in current block
            // so we shall set up pointer to the next block
            ((PLONG_AD)((*Buff)+BufOffs))->extLength = /*LBS*/ len2 |
                (((uint32)EXTENT_NEXT_EXTENT_ALLOCDESC) << 30) ;
            ((PLONG_AD)((*Buff)+BufOffs))->extLocation.logicalBlockNum = TagLoc =
                UDFPhysLbaToPart(Vcb, PartNum,
                    UDFExtentOffsetToLba(Vcb, AllocExtent->Mapping,
                        ExtOffs+BufOffs+sizeof(LONG_AD)+ts,
                        NULL, NULL, NULL, NULL) );
            ((PLONG_AD)((*Buff)+BufOffs))->extLocation.partitionReferenceNum = (uint16)PartNum;
            // reflect additional (link) block & LBlock tail (if any)
            BufOffs += ts+sizeof(LONG_AD);
            // init AllocDesc
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->lengthAllocDescs = len2;
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->previousAllocExtLocation = prevTagLoc;
            Tag = (tag*)((*Buff)+BufOffs);
            TagLen = len2;
            ts = LBS-len2-sizeof(ALLOC_EXT_DESC);
            BufOffs += sizeof(ALLOC_EXT_DESC);
        }
        MyFreePool__(saved_Alloc);
#endif //UDF_ALLOW_FRAG_AD
    }
    status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
    return status;
} // end UDFBuildLongAllocDescs()

Referenced by UDFBuildAllocDescs().

◆ UDFBuildShortAllocDescs()

OSSTATUS UDFBuildShortAllocDescs	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		OUT int8 **	Buff,
		IN uint32	InitSz,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 825 of file extent.cpp.

{
    uint32 i, j;
    uint32 len=0;
    PEXTENT_MAP Extent = FileInfo->Dloc->DataLoc.Mapping;
    PEXTENT_INFO AllocExtent = &(FileInfo->Dloc->AllocLoc);
    PSHORT_AD Alloc;
    uint32 NewLen;
    OSSTATUS status;
    uint32 ph_len=0; // in general, this should be uint64,
                     // but we need its lower part only
#ifdef UDF_ALLOW_FRAG_AD
    uint32 ts, ac, len2;
    uint32 LBS = Vcb->LBlockSize;
    uint32 LBSh = Vcb->BlockSizeBits;
    uint32 TagLen = 0;
    tag* Tag = NULL;
    PSHORT_AD saved_Alloc;
    uint32 TagLoc, prevTagLoc;
    uint32 BufOffs;
    uint32 ExtOffs;
    uint32 saved_NewLen;
#endif //UDF_ALLOW_FRAG_AD
 
    ValidateFileInfo(FileInfo);
    ExtPrint(("UDFBuildShortAllocDescs: FE %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    // calculate length
    for(len=0; (i=(Extent[len].extLength & UDF_EXTENT_LENGTH_MASK)); len++, ph_len+=i) {
        ExtPrint(("bShExt: type %x, loc %x, len %x\n",
            Extent[len].extLength >> 30, Extent[len].extLocation, Extent[len].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    Alloc = (PSHORT_AD)MyAllocatePoolTag__(NonPagedPool, (len+1)*sizeof(SHORT_AD), MEM_SHAD_TAG);
    if(!Alloc) {
        BrutePoint();
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    // fill contiguous AllocDesc buffer (decribing UserData)
    for(i=0;i<len;i++) {
        Alloc[i].extLength = Extent[i].extLength;
        Alloc[i].extPosition = UDFPhysLbaToPart(Vcb, PartNum, Extent[i].extLocation);
    }
    if((Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) && i) {
        Alloc[i-1].extLength -= (ph_len - (ULONG)(FileInfo->Dloc->DataLoc.Length)) &
                                (Vcb->LBlockSize-1);
        ExtPrint(("bShExt: cut tail -> %x\n",
            Alloc[i-1].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    Alloc[i].extLength =
    Alloc[i].extPosition = 0;
    j = len*sizeof(SHORT_AD); // required space
    len = (InitSz & ~(sizeof(SHORT_AD)-1)); // space available in 1st block
    ASSERT(len == InitSz);
 
    // Ok. Let's init AllocLoc
    if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
        FileInfo->Dloc->AllocLoc.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool, 2 * sizeof(EXTENT_MAP), MEM_EXTMAP_TAG);
        if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
            BrutePoint();
            MyFreePool__(Alloc);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        // allocation descriptors are located in the same sector as FileEntry
        // (at least their 1st part), just after it
        FileInfo->Dloc->AllocLoc.Mapping[0] = FileInfo->Dloc->FELoc.Mapping[0];
        FileInfo->Dloc->AllocLoc.Offset = FileInfo->Dloc->FileEntryLen;
        FileInfo->Dloc->AllocLoc.Length = 0;
        // set terminator
        FileInfo->Dloc->AllocLoc.Mapping[1].extLength =
        FileInfo->Dloc->AllocLoc.Mapping[1].extLocation = 0;
    }
 
    if(j <= len) {
        // we needn't allocating additional blocks to store AllocDescs
        AdPrint(("in-ICB AllocDescs, j=%x\n",j));
        RtlCopyMemory(*Buff, (int8*)Alloc, j);
        NewLen = j;
        MyFreePool__(Alloc);
    } else {
#ifndef UDF_ALLOW_FRAG_AD
        AdPrint(("  DISK_FULL\n"));
        return STATUS_DISK_FULL;
#else //UDF_ALLOW_FRAG_AD
        AdPrint(("multi-block AllocDescs, j=%x\n",j));
        BufOffs = 0;
        TagLoc = prevTagLoc = 0;
        // calculate the space available for SHORT_ADs in each block
        ac = (LBS - (sizeof(ALLOC_EXT_DESC) + sizeof(SHORT_AD))) & ~(sizeof(SHORT_AD)-1);
        len2 = len;
        // tail size
        ts = InitSz - len2;
        len -= sizeof(SHORT_AD);
        // calculate actual AllocSequence length (in bytes)
        NewLen = ( ((j - len + ac - 1) / ac) << LBSh) + InitSz + sizeof(SHORT_AD);
        MyFreePool__(*Buff);
        (*Buff) = (int8*)MyAllocatePoolTag__(NonPagedPool, NewLen, MEM_SHAD_TAG);
        if(!(*Buff)) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            UDFPrint(("UDFResizeExtent() failed (%x)\n",status));
            BrutePoint();
            goto sh_alloc_err;
        }
        if(UDFGetExtentLength(AllocExtent->Mapping) < NewLen) {
            status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
            if(!OS_SUCCESS(status)) {
                UDFPrint(("UDFResizeExtent(2) failed (%x)\n",status));
                BrutePoint();
sh_alloc_err:
                MyFreePool__(Alloc);
                return status;
            }
        }
        ExtOffs = AllocExtent->Offset;
        RtlZeroMemory(*Buff, NewLen);
        saved_NewLen = NewLen;
        NewLen = 0; // recorded length
        saved_Alloc = Alloc;
        // fill buffer sector by sector (adding links at the end of each one)
        while(TRUE) {
 
            // j - remained AllocDescs length (in bytes)
            // len - bytes available for AllocDescs in current block
            // ac - bytes available for AllocDescs in each block
 
            // leave space for terminator or pointer to next part of sequence
            if(j == len2) {
                // if we have only 1 SHORT_AD that we can fit in last sector
                // we shall do it instead of recording link & allocating new block
                len =
                TagLen = len2;
            }
            ASSERT(saved_NewLen >= (BufOffs + len));
            RtlCopyMemory( (*Buff)+BufOffs, (int8*)Alloc, len);
            Alloc = (PSHORT_AD)((int8*)Alloc + len);
            j -= len;
            BufOffs += len;
            if(Tag) {
                // Set up Tag for AllocDesc
                Tag->tagIdent = TID_ALLOC_EXTENT_DESC;
                UDFSetUpTag(Vcb, Tag, (uint16)TagLen, TagLoc);
                prevTagLoc = TagLoc;
            }
            if(!j) {
                // terminate loop
                NewLen = BufOffs;
                break;
            }
            len = ac;
            if(j <= (len + sizeof(SHORT_AD)))
                len = j - sizeof(SHORT_AD);
            len2 = len + sizeof(SHORT_AD);
            // we have more than 1 SHORT_AD that we can't fit in current block
            // so we shall set up pointer to the next block
            ((PSHORT_AD)((*Buff)+BufOffs))->extLength = /*LBS*/ len2 |
                (((uint32)EXTENT_NEXT_EXTENT_ALLOCDESC) << 30) ;
            ((PSHORT_AD)((*Buff)+BufOffs))->extPosition = TagLoc =
                UDFPhysLbaToPart(Vcb, PartNum,
                    UDFExtentOffsetToLba(Vcb, AllocExtent->Mapping,
                        ExtOffs+BufOffs+sizeof(SHORT_AD)+ts,
                        NULL, NULL, NULL, NULL) );
            // reflect additional (link) block & LBlock tail (if any)
            BufOffs += ts+sizeof(SHORT_AD);
            // init AllocDesc
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->lengthAllocDescs = len2;
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->previousAllocExtLocation = prevTagLoc;
            Tag = (tag*)((*Buff)+BufOffs);
            TagLen = len2;
            ts = LBS-len2-sizeof(ALLOC_EXT_DESC);
            BufOffs += sizeof(ALLOC_EXT_DESC);
        }
        MyFreePool__(saved_Alloc);
#endif //UDF_ALLOW_FRAG_AD
    }
    status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
    return status;
} // end UDFBuildShortAllocDescs()

Referenced by UDFBuildAllocDescs().

◆ UDFChangeFileCounter()

void UDFChangeFileCounter	(	IN PVCB	Vcb,
		IN BOOLEAN	FileCounter,
		IN BOOLEAN	Increase
	)

Definition at line 1520 of file udf_info.cpp.

{
    uint32* counter;
 
    counter = FileCounter ?
        &(Vcb->numFiles) :
        &(Vcb->numDirs);
    if(*counter == (ULONG)-1)
        return;
    if(Increase) {
        UDFInterlockedIncrement((int32*)counter);
    } else {
        UDFInterlockedDecrement((int32*)counter);
    }
 
} // end UDFChangeFileCounter()

Referenced by UDFUnlinkFile__().

◆ UDFChangeFileLinkCount()

void UDFChangeFileLinkCount	(	IN PUDF_FILE_INFO	FileInfo,
		IN BOOLEAN	Increase
	)

Definition at line 1315 of file udf_info.cpp.

{
    uint16 Ident;
 
    ValidateFileInfo(FileInfo);
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        if(Increase) {
            fe->fileLinkCount++;
        } else {
            fe->fileLinkCount--;
        }
        if(fe->fileLinkCount & 0x8000)
            fe->fileLinkCount = 0xffff;
        return;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        if(Increase) {
            fe->fileLinkCount++;
        } else {
            fe->fileLinkCount--;
        }
        if(fe->fileLinkCount & 0x8000)
            fe->fileLinkCount = 0xffff;
        return;
    }
    return;
} // end UDFChangeFileLinkCount()

◆ UDFCheckArea()

BOOLEAN __fastcall UDFCheckArea	(	IN PVCB	Vcb,
		IN lba_t	LBA,
		IN uint32	BCount
	)

Definition at line 763 of file remap.cpp.

{
    uint8* buff;
    OSSTATUS RC;
    SIZE_T ReadBytes;
    uint32 i, d;
    BOOLEAN ext_ok = TRUE;
    EXTENT_MAP Map[2];
    uint32 PS = Vcb->WriteBlockSize >> Vcb->BlockSizeBits;
 
    buff = (uint8*)DbgAllocatePoolWithTag(NonPagedPool, Vcb->WriteBlockSize, 'bNWD' );
    if(buff) {
        for(i=0; i<BCount; i+=d) {
            if(!((LBA+i) & (PS-1)) &&
               (i+PS <= BCount)) {
                d = PS;
            } else {
                d = 1;
            }
            RC = UDFTRead(Vcb,
                           buff,
                           d << Vcb->BlockSizeBits,
                           LBA+i,
                           &ReadBytes,
                           PH_TMP_BUFFER);
 
            if(RC != STATUS_SUCCESS) {
                Map[0].extLocation = LBA+i;
                Map[0].extLength = d << Vcb->BlockSizeBits;
                UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &(Map[0]), AS_DISCARDED | AS_BAD); // free
                ext_ok = FALSE;
            }
        }
        DbgFreePool(buff);
    }
    return ext_ok;
} // end UDFCheckArea()

Referenced by UDFAllocFreeExtent_(), and UDFRemapPacket().

◆ UDFCleanUpFile__()

uint32 UDFCleanUpFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 2276 of file udf_info.cpp.

{
    PUDF_DATALOC_INFO Dloc;
    uint32 lc = 0;
    BOOLEAN IsASDir;
    BOOLEAN KeepDloc;
    PDIR_INDEX_ITEM DirNdx, DirNdx2;
    BOOLEAN Parallel = FALSE;
    BOOLEAN Linked = FALSE;
#ifdef UDF_DBG
    BOOLEAN Modified = FALSE;
    PDIR_INDEX_HDR hDirNdx;
    uint_di Index;
    PUDF_FILE_INFO DirInfo;
#endif // UDF_DBG
 
    if(!FileInfo) return UDF_FREE_FILEINFO;
 
    ValidateFileInfo(FileInfo);
 
    if(FileInfo->OpenCount || FileInfo->RefCount) {
        UDFPrint(("UDF: not all references are closed\n"));
        UDFPrint(("     Skipping cleanup\n"));
        UDFPrint(("UDF: OpenCount = %x, RefCount = %x, LinkRefCount = %x\n",
                              FileInfo->OpenCount,FileInfo->RefCount,FileInfo->Dloc->LinkRefCount));
        return UDF_FREE_NOTHING;
    }
    if(FileInfo->Fcb) {
        UDFPrint(("Operating System still has references to this file\n"));
        UDFPrint(("     Skipping cleanup\n"));
//        BrutePoint();
        return UDF_FREE_NOTHING;
    }
 
    IsASDir = UDFIsAStreamDir(FileInfo);
 
    if((Dloc = FileInfo->Dloc)) {
 
#ifdef UDF_DBG
        DirInfo = FileInfo->ParentFile;
        if(DirInfo) {
            hDirNdx = DirInfo->Dloc->DirIndex;
            Index = FileInfo->Index;
            // we can't delete modified file
            // it should be closed & reopened (or flushed) before deletion
            DirNdx = UDFDirIndex(hDirNdx,Index);
            UDFPrint(("Cleanup Mod: %s%s%s%s%s%s\n",
                                 (Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ? "FE "       : "",
                                 (Dloc->DataLoc.Modified)                   ? "DataLoc "  : "",
                                 (Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) ? "Data-PreAlloc " : "",
                                 (Dloc->AllocLoc.Modified)                  ? "AllocLoc " : "",
                                 (Dloc->FELoc.Modified)                     ? "FELoc "    : "",
                                 (DirNdx && (DirNdx->FI_Flags & UDF_FI_FLAG_FI_MODIFIED)) ? "FI " : ""
                                 ));
            Modified = ((Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ||
                         Dloc->DataLoc.Modified ||
                        (Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) ||
                         Dloc->AllocLoc.Modified ||
                         Dloc->FELoc.Modified ||
                        (DirNdx && (DirNdx->FI_Flags & UDF_FI_FLAG_FI_MODIFIED)) );
        }
#endif // UDF_DBG
 
        PUDF_FILE_INFO ParFileInfo = UDFLocateAnyParallelFI(FileInfo);
 
        Parallel = (ParFileInfo != NULL);
        Linked = (FileInfo->NextLinkedFile != FileInfo);
 
//        Parallel = (FileInfo->NextLinkedFile != FileInfo);
        ASSERT(FileInfo->NextLinkedFile);
//        ASSERT(!Parallel);
        KeepDloc = (Dloc->LinkRefCount ||
                    Dloc->CommonFcb ||
                    Linked ) ?
                    TRUE : FALSE;
 
        if(Dloc->DirIndex) {
            uint_di i;
            for(i=2; (DirNdx = UDFDirIndex(Dloc->DirIndex,i)); i++) {
                if(DirNdx->FileInfo) {
                    if(!KeepDloc) {
                        BrutePoint();
                        UDFPrint(("UDF: Found not cleaned up reference.\n"));
                        UDFPrint(("     Skipping cleanup (1)\n"));
//                        BrutePoint();
                        return UDF_FREE_NOTHING;
                    }
                    // The file being cleaned up may have not closed Dirs
                    // (linked Dir). In this case each of them may have
                    // reference to FileInfo in DirIndex[1]
                    // Here we'll check it and change for valid value if
                    // necessary (Update Child Objects - I)
                    if(DirNdx->FileInfo->Dloc) {
                        // we can get here only when (Parallel == TRUE)
                        DirNdx2 = UDFDirIndex(DirNdx->FileInfo->Dloc->DirIndex, 1);
                        // It is enough to check DirNdx2->FileInfo only.
                        // If one of Parallel FI's has reference (and equal)
                        // to the FI being removed, it'll be removed from
                        // the chain & nothing wrong will happen.
                        if(DirNdx2 && (DirNdx2->FileInfo == FileInfo)) {
                            if(FileInfo->PrevLinkedFile == FileInfo) {
                                BrutePoint();
                                DirNdx2->FileInfo = NULL;
                            } else {
                                DirNdx2->FileInfo = Parallel ?
                                    ParFileInfo : FileInfo->PrevLinkedFile;
                            }
                            ASSERT(!DirNdx2->FileInfo->RefCount);
                        }
                    }
                }
            }
        }
        if(Dloc->SDirInfo) {
            UDFPrint(("UDF: Found not cleaned up reference (SDir).\n"));
 
            // (Update Child Objects - II)
            if(Dloc->SDirInfo->ParentFile == FileInfo) {
                BrutePoint();
                ASSERT(ParFileInfo);
                Dloc->SDirInfo->ParentFile = ParFileInfo;
            }
            // We should break Cleanup process if alive reference detected
            // and there is no possibility to store pointer in some other
            // place (in parallel object)
            if(!KeepDloc) {
                BrutePoint();
                UDFPrint(("     Skipping cleanup\n"));
                return UDF_FREE_NOTHING;
            }
 
            if(!UDFIsSDirDeleted(Dloc->SDirInfo) &&
               Dloc->SDirInfo->Dloc) {
                DirNdx2 = UDFDirIndex(Dloc->SDirInfo->Dloc->DirIndex, 1);
                if(DirNdx2 && (DirNdx2->FileInfo == FileInfo)) {
                    DirNdx2->FileInfo =
                        Parallel ? ParFileInfo : NULL;
                    ASSERT(!DirNdx2->FileInfo->RefCount);
                }
            }
        }
 
        if(!KeepDloc) {
 
#ifdef UDF_DBG
            ASSERT(!Modified);
#endif
 
#ifndef UDF_TRACK_ONDISK_ALLOCATION
            if(Dloc->DataLoc.Mapping)  MyFreePool__(Dloc->DataLoc.Mapping);
            if(Dloc->AllocLoc.Mapping) MyFreePool__(Dloc->AllocLoc.Mapping);
            if(Dloc->FELoc.Mapping)    MyFreePool__(Dloc->FELoc.Mapping);
            if(Dloc->FileEntry) {
                // plain file
                lc = UDFGetFileLinkCount(FileInfo);
                MyFreePool__(Dloc->FileEntry);
                Dloc->FileEntry = NULL;
            } else if(FileInfo->Index >= 2) {
                // error durring open operation
                lc = UDF_INVALID_LINK_COUNT;
            }
#endif //UDF_TRACK_ONDISK_ALLOCATION
            if(FileInfo->Dloc->DirIndex) {
                uint_di i;
                for(i=2; (DirNdx = UDFDirIndex(Dloc->DirIndex,i)); i++) {
                    ASSERT(!DirNdx->FileInfo);
                    if(DirNdx->FName.Buffer)
                        MyFreePool__(DirNdx->FName.Buffer);
                }
                // The only place where we can free FE_Charge extent is here
                UDFFlushFESpace(Vcb, Dloc);
                UDFDirIndexFree(Dloc->DirIndex);
                Dloc->DirIndex = NULL;
#ifdef UDF_TRACK_ONDISK_ALLOCATION
                UDFIndexDirectory(Vcb, FileInfo);
                if(FileInfo->Dloc->DirIndex) {
                    for(i=2; DirNdx = UDFDirIndex(Dloc->DirIndex,i); i++) {
                        ASSERT(!DirNdx->FileInfo);
                        if(DirNdx->FName.Buffer)
                            MyFreePool__(DirNdx->FName.Buffer);
                    }
                    UDFDirIndexFree(Dloc->DirIndex);
                    Dloc->DirIndex = NULL;
                }
#endif //UDF_TRACK_ONDISK_ALLOCATION
            }
 
#ifdef UDF_TRACK_ONDISK_ALLOCATION
            if(Dloc->AllocLoc.Mapping) MyFreePool__(Dloc->AllocLoc.Mapping);
            if(Dloc->FELoc.Mapping)    MyFreePool__(Dloc->FELoc.Mapping);
            if(Dloc->FileEntry) {
                // plain file
                lc = UDFGetFileLinkCount(FileInfo);
                MyFreePool__(Dloc->FileEntry);
                Dloc->FileEntry = NULL;
            } else if(FileInfo->Index >= 2) {
                // error durring open operation
                lc = UDF_INVALID_LINK_COUNT;
            }
            if(Dloc->DataLoc.Mapping) {
                if(lc && (lc != UDF_INVALID_LINK_COUNT)) {
                    UDFCheckSpaceAllocation(Vcb, 0, Dloc->DataLoc.Mapping, AS_USED); // check if used
                } else {
                    UDFCheckSpaceAllocation(Vcb, 0, Dloc->DataLoc.Mapping, AS_FREE); // check if free
                }
                MyFreePool__(Dloc->DataLoc.Mapping);
            }
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
            if(lc && (lc != UDF_INVALID_LINK_COUNT)) {
                UDFRemoveDloc(Vcb, Dloc);
            } else {
                UDFFreeDloc(Vcb, Dloc);
            }
        } else // KeepDloc cannot be FALSE if (Linked == TRUE)
        if(Linked) {
//            BrutePoint();
            // Update pointers in ParentObject (if any)
            if(FileInfo->ParentFile->Dloc->SDirInfo == FileInfo)
                FileInfo->ParentFile->Dloc->SDirInfo = FileInfo->PrevLinkedFile;
            DirNdx = UDFDirIndex(FileInfo->Dloc->DirIndex, 0);
            if(DirNdx && (DirNdx->FileInfo == FileInfo))
                DirNdx->FileInfo = FileInfo->PrevLinkedFile;
            DirNdx = UDFDirIndex(FileInfo->ParentFile->Dloc->DirIndex, FileInfo->Index);
            if(DirNdx && (DirNdx->FileInfo == FileInfo))
                DirNdx->FileInfo = ParFileInfo;
            // remove from linked chain
            FileInfo->NextLinkedFile->PrevLinkedFile = FileInfo->PrevLinkedFile;
            FileInfo->PrevLinkedFile->NextLinkedFile = FileInfo->NextLinkedFile;
            // update pointer in Dloc
            if(FileInfo->Dloc->LinkedFileInfo == FileInfo)
                FileInfo->Dloc->LinkedFileInfo = FileInfo->PrevLinkedFile;
        }
        FileInfo->Dloc = NULL;
    } else {
        KeepDloc = FALSE;
    }
 
    // Cleanup pointers in ParentObject (if any)
    if(IsASDir) {
        if(FileInfo->ParentFile->Dloc->SDirInfo == FileInfo) {
            ASSERT(!Linked);
            FileInfo->ParentFile->Dloc->SDirInfo = NULL;
            FileInfo->ParentFile->Dloc->FE_Flags &= ~UDF_FE_FLAG_HAS_DEL_SDIR;
        }
    } else
    if(FileInfo->ParentFile) {
        ASSERT(FileInfo->ParentFile->Dloc);
        DirNdx = UDFDirIndex(FileInfo->ParentFile->Dloc->DirIndex, FileInfo->Index);
        ASSERT(DirNdx);
#ifdef UDF_DBG
        PUDF_FILE_INFO OldFI;
        if(Parallel) {
            ASSERT(!DirNdx || !(OldFI = DirNdx->FileInfo) ||
                    !(OldFI == FileInfo));
        } else {
            ASSERT(!DirNdx || !(OldFI = DirNdx->FileInfo) ||
                     (OldFI == FileInfo));
        }
#endif
        if( DirNdx && (DirNdx->FileInfo == FileInfo) ) {
            if(!Parallel)
                DirNdx->FileInfo = NULL;
#ifdef UDF_DBG
        } else {
            // We can get here after incomplete Open
            if(!Parallel && DirNdx->FileInfo)
                BrutePoint();
#endif
        }
#ifdef UDF_DBG
    } else {
//        BrutePoint();
#endif
    }
 
    if(!Parallel && FileInfo->FileIdent)
        MyFreePool__(FileInfo->FileIdent);
    FileInfo->FileIdent = NULL;
    // Kill reference to parent object
    FileInfo->ParentFile = NULL;
    // Kill references to parallel object(s) since it has no reference to
    // this one now
    FileInfo->NextLinkedFile =
    FileInfo->PrevLinkedFile = FileInfo;
    if(FileInfo->ListPtr)
        FileInfo->ListPtr->FileInfo = NULL;;
    return KeepDloc ? UDF_FREE_FILEINFO : (UDF_FREE_FILEINFO | UDF_FREE_DLOC);
} // end UDFCleanUpFile__()

Referenced by UDFBlankMount(), UDFCleanUpFcbChain(), UDFCloseResidual(), UDFCommonCreate(), UDFCompareVcb(), UDFCompleteMount(), UDFCreateFile__(), UDFCreateStreamDir__(), UDFHardLinkFile__(), UDFLoadVAT(), UDFMarkStreamsForDeletion(), UDFReadSecurity(), UDFRenameMoveFile__(), UDFUnlinkAllFilesInDir(), UDFUnlinkFile__(), and UDFWriteSecurity().

◆ UDFCloseFile__()

OSSTATUS UDFCloseFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 2994 of file udf_info.cpp.

{
    ValidateFileInfo(FileInfo);
 
    if(!FileInfo) return STATUS_SUCCESS;
    if(FileInfo->Index<2 && (FileInfo->ParentFile) && !UDFIsAStreamDir(FileInfo)) {
        UDFPrint(("Closing Current or Parent Directory... :-\\\n"));
        if(FileInfo->RefCount) {
            UDFInterlockedDecrement((PLONG)&(FileInfo->RefCount));
            ASSERT(FileInfo->Dloc);
            if(FileInfo->Dloc)
                UDFInterlockedDecrement((PLONG)&(FileInfo->Dloc->LinkRefCount));
#ifdef UDF_DBG
        } else {
            BrutePoint();
            UDFPrint(("ERROR: Closing unreferenced file!\n"));
#endif // UDF_DBG
        }
        if(FileInfo->ParentFile->OpenCount) {
            UDFInterlockedDecrement((PLONG)&(FileInfo->ParentFile->OpenCount));
#ifdef UDF_DBG
        } else {
            BrutePoint();
            UDFPrint(("ERROR: Closing unopened file!\n"));
#endif // UDF_DBG
        }
        return STATUS_SUCCESS;
    }
    PUDF_FILE_INFO DirInfo = FileInfo->ParentFile;
    OSSTATUS status;
    uint32 PartNum;
    if(FileInfo->RefCount) {
        UDFInterlockedDecrement((PLONG)&(FileInfo->RefCount));
        ASSERT(FileInfo->Dloc);
        if(FileInfo->Dloc)
            UDFInterlockedDecrement((PLONG)&(FileInfo->Dloc->LinkRefCount));
#ifdef UDF_DBG
    } else {
        BrutePoint();
        UDFPrint(("ERROR: Closing unreferenced file!\n"));
#endif // UDF_DBG
    }
    if(DirInfo) {
        // validate DirInfo
        ValidateFileInfo(DirInfo);
 
        if(DirInfo->OpenCount) {
            UDFInterlockedDecrement((PLONG)&(DirInfo->OpenCount));
#ifdef UDF_DBG
        } else {
            BrutePoint();
            UDFPrint(("ERROR: Closing unopened file!\n"));
#endif // UDF_DBG
        }
    }
    // If the file has gone (unlinked) we should return STATUS_SUCCESS here.
    if(!FileInfo->Dloc) return STATUS_SUCCESS;
 
    if(FileInfo->RefCount ||
       FileInfo->OpenCount ||
       !(FileInfo->Dloc->FELoc.Mapping)) return STATUS_SUCCESS;
//    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    PartNum = UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if(PartNum == (uint32)-1) {
        UDFPrint(("  Is DELETED ?\n"));
        if(DirInfo) {
            PartNum = UDFGetPartNumByPhysLba(Vcb, DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        } else {
            BrutePoint();
        }
    }
#ifdef UDF_CHECK_DISK_ALLOCATION
    if(  FileInfo->Fcb &&
         UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) {
 
        //ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
        if(UDFIsAStreamDir(FileInfo)) {
            if(!UDFIsSDirDeleted(FileInfo)) {
                UDFPrint(("  Not DELETED SDir\n"));
                BrutePoint();
            }
            ASSERT(!FileInfo->Dloc->FELoc.Modified);
        } else
        if(!FileInfo->FileIdent ||
           !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED)) {
            if(!FileInfo->FileIdent) {
                AdPrint(("  No FileIdent\n"));
            }
            if(FileInfo->FileIdent &&
               !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED))
                AdPrint(("  Not DELETED\n"));
            ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
            AdPrint(("Flushing to Discarded block %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
            BrutePoint();
        } else {
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_FREE); // check if free
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->FELoc.Mapping, AS_FREE); // check if free
        }
    } else {
        if(!FileInfo->Dloc->FELoc.Mapping[0].extLocation ||
            UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) {
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_FREE); // check if free
        } else {
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_USED); // check if used
        }
    }
#endif // UDF_CHECK_DISK_ALLOCATION
    // check if we should update parentICBLocation
    if( !((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.logicalBlockNum &&
        !((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.partitionReferenceNum &&
        DirInfo &&
        !Vcb->CDR_Mode &&
        Vcb->Modified &&
        UDFGetFileLinkCount(FileInfo) ) {
        ASSERT(DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.logicalBlockNum =
             UDFPhysLbaToPart(Vcb, PartNum, DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.partitionReferenceNum = (uint16)PartNum;
        FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    }
 
    // we needn't flushing FE & Allocs untill all links are closed...
    if(!FileInfo->Dloc->LinkRefCount) {
 
        // flush FE and pre-allocation charge for directories
        if(FileInfo->Dloc &&
           FileInfo->Dloc->DirIndex) {
 
            UDFFlushFESpace(Vcb, FileInfo->Dloc);
            if(FileInfo->Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) {
                FileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_CUT_PREALLOCATED;
                status = UDFResizeExtent(Vcb, PartNum, UDFGetFileSize(FileInfo), FALSE, &(FileInfo->Dloc->DataLoc));
                FileInfo->Dloc->DataLoc.Flags &= ~(EXTENT_FLAG_PREALLOCATED | EXTENT_FLAG_CUT_PREALLOCATED);
                if(OS_SUCCESS(status)) {
                    AdPrint(("Dir pre-alloc truncated (Close)\n"));
                    FileInfo->Dloc->DataLoc.Modified = TRUE;
                }
            }
        }
 
        if(!OS_SUCCESS(status = UDFFlushFE(Vcb, FileInfo, PartNum))) {
            UDFPrint(("Error flushing FE\n"));
//flush_recovery:
            BrutePoint();
            if(FileInfo->Index >= 2) {
                PDIR_INDEX_ITEM DirNdx;
                DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo), FileInfo->Index);
                if(DirNdx) {
                    UDFPrint(("Recovery: mark as deleted & flush FI\n"));
                    DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
                    DirNdx->FileCharacteristics |= FILE_DELETED;
                    FileInfo->FileIdent->fileCharacteristics |= FILE_DELETED;
                    UDFFlushFI(Vcb, FileInfo, PartNum);
                }
            }
            return status;
        }
    }
    // ... but FI must be updated (if any)
    if(!OS_SUCCESS(status = UDFFlushFI(Vcb, FileInfo, PartNum))) {
        UDFPrint(("Error flushing FI\n"));
        return status;
    }
#ifdef UDF_DBG
//    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if((FileInfo->Dloc->FileEntry->descVersion != 2) &&
       (FileInfo->Dloc->FileEntry->descVersion != 3)) {
        ASSERT(UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    }
#endif // UDF_DBG
    return STATUS_SUCCESS;
} // end UDFCloseFile__()

Referenced by UDFCleanUpFcbChain(), UDFCloseFileInfoChain(), UDFCloseResidual(), UDFCommonCreate(), UDFCompareVcb(), UDFCompleteMount(), UDFCreateFile__(), UDFCreateStreamDir__(), UDFHardLinkFile__(), UDFLoadVAT(), UDFMarkStreamsForDeletion(), UDFReadSecurity(), UDFRename(), UDFRenameMoveFile__(), UDFSetEOF(), UDFUnlinkAllFilesInDir(), UDFUnlinkFile__(), and UDFWriteSecurity().

◆ UDFCompareFileInfo()

BOOLEAN UDFCompareFileInfo	(	IN PUDF_FILE_INFO	f1,
		IN PUDF_FILE_INFO	f2
	)

Definition at line 4218 of file udf_info.cpp.

{
    uint_di i;
    PDIR_INDEX_HDR hDirIndex1;
    PDIR_INDEX_HDR hDirIndex2;
    PDIR_INDEX_ITEM DirIndex1;
    PDIR_INDEX_ITEM DirIndex2;
 
    if(!f1 || !f2) return FALSE;
    if(f1->Dloc->FileEntryLen != f2->Dloc->FileEntryLen) return FALSE;
//    if(f1->FileIdentLen != f2->FileIdentLen) return FALSE;
/*    if(f1->Dloc->DirIndex && !f2->Dloc->DirIndex) return FALSE;
    if(f2->Dloc->DirIndex && !f1->Dloc->DirIndex) return FALSE;
    if((f1->Dloc->DirIndex) &&
       (f1->Dloc->DirIndex->LastFrameCount != f2->Dloc->DirIndex->LastFrameCount)) return FALSE;*/
    if(f1->Index != f2->Index) return FALSE;
    if(!(f1->Dloc->DataLoc.Mapping)) return FALSE;
    if(!(f2->Dloc->DataLoc.Mapping)) return FALSE;
    if(f1->Dloc->DataLoc.Mapping[0].extLocation != f2->Dloc->DataLoc.Mapping[0].extLocation) return FALSE;
    if(f1->Dloc->DataLoc.Mapping[0].extLength != f2->Dloc->DataLoc.Mapping[0].extLength) return FALSE;
//    if(f1-> != f2->) return FALSE;
//    if(f1-> != f2->) return FALSE;
//    if(f1-> != f2->) return FALSE;
    if(!(f1->Dloc->FileEntry)) return FALSE;
    if(!(f2->Dloc->FileEntry)) return FALSE;
    if(RtlCompareMemory(f1->Dloc->FileEntry, f2->Dloc->FileEntry, f2->Dloc->FileEntryLen) != f2->Dloc->FileEntryLen)
        return FALSE;
    if(!(hDirIndex1 = f1->Dloc->DirIndex)) return FALSE;
    if(!(hDirIndex2 = f2->Dloc->DirIndex)) return FALSE;
 
    for(i=2; (DirIndex1 = UDFDirIndex(hDirIndex1,i)) &&
             (DirIndex2 = UDFDirIndex(hDirIndex2,i)); i++) {
        if( DirIndex1->FName.Buffer &&
           !DirIndex2->FName.Buffer)
            return FALSE;
        if( DirIndex2->FName.Buffer &&
           !DirIndex1->FName.Buffer)
            return FALSE;
        if(!DirIndex2->FName.Buffer &&
           !DirIndex1->FName.Buffer)
            continue;
        if(RtlCompareUnicodeString(&(DirIndex1->FName),
                                   &(DirIndex2->FName),FALSE)) {
            return FALSE;
        }
//        if(DirIndex1[i].FileEntry != DirIndex2[i].FileEntry)
//            return FALSE;
        if(RtlCompareMemory(&(DirIndex1->FileEntryLoc),
                            &(DirIndex2->FileEntryLoc), sizeof(lb_addr)) != sizeof(lb_addr))
            return FALSE;
    }
 
    return TRUE;
} // end UDFCompareFileInfo()

Referenced by UDFCompareVcb().

◆ UDFCompressUnicode()

void __fastcall UDFCompressUnicode	(	IN PUNICODE_STRING	UName,
		IN OUT uint8 **	_CS0,
		IN OUT PSIZE_T	Length
	)

Definition at line 240 of file udf_info.cpp.

{
    uint8* CS0;
    uint8 compID;
    uint16 unicodeIndex;
    uint32 i, len;
    PWCHAR Buff;
 
    len = (UName->Length) / sizeof(WCHAR);
    compID = (!len) ? 0 : UDF_COMP_ID_8;
    // check for uncompressable characters
    Buff = UName->Buffer;
    for(i=0; i<len; i++, Buff++) {
        if((*Buff) & 0xff00) {
            compID = UDF_COMP_ID_16;
            break;
        }
    }
 
    CS0 = (uint8*)MyAllocatePool__(NonPagedPool, *Length = (((compID==UDF_COMP_ID_8) ? 1 : 2)*len + 1) );
    if(!CS0) return;
 
    CS0[0] = compID;
    *_CS0 = CS0;
    // init loop
    CS0++;
    unicodeIndex = 0;
    Buff = UName->Buffer;
    if(compID == UDF_COMP_ID_16) {
        // Loop through all the bytes.
        while (unicodeIndex < len) {
            // Move the 2nd byte to the low bits of the compressed unicode char.
            *CS0 = (uint8)((*Buff) >> 8);
            CS0++;
            *CS0 = (uint8)(*Buff);
            CS0++;
            Buff++;
            unicodeIndex++;
        }
    } else {
        // Loop through all the bytes.
        while (unicodeIndex < len) {
            *CS0 = (uint8)(*Buff);
            CS0++;
            Buff++;
            unicodeIndex++;
        }
    }
} // end UDFCompressUnicode()

Referenced by UDFBuildFileIdent(), UDFRenameMoveFile__(), and UDFSetDstring().

◆ UDFConvertFEToExtended()

OSSTATUS UDFConvertFEToExtended	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 5458 of file udf_info.cpp.

{
    PEXTENDED_FILE_ENTRY ExFileEntry;
    PFILE_ENTRY FileEntry;
    uint32 Length, NewLength, l;
    OSSTATUS status;
    SIZE_T ReadBytes;
 
    if(!FileInfo) return STATUS_INVALID_PARAMETER;
    ValidateFileInfo(FileInfo);
    if(FileInfo->Dloc->FileEntry->tagIdent == TID_EXTENDED_FILE_ENTRY) return STATUS_SUCCESS;
    if(FileInfo->Dloc->FileEntry->tagIdent != TID_FILE_ENTRY) return STATUS_INVALID_PARAMETER;
 
/*    if(!OS_SUCCESS(status = UDFFlushFile__(Vcb, FileInfo)))
        return status;*/
 
    Length = FileInfo->Dloc->FileEntryLen;
    NewLength = Length - sizeof(FILE_ENTRY) + sizeof(EXTENDED_FILE_ENTRY);
    ExFileEntry = (PEXTENDED_FILE_ENTRY)MyAllocatePoolTag__(NonPagedPool, NewLength, MEM_XFE_TAG);
    if(!ExFileEntry) return STATUS_INSUFFICIENT_RESOURCES;
    FileEntry = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
    RtlZeroMemory(ExFileEntry, NewLength);
 
    ExFileEntry->descTag.tagIdent = TID_EXTENDED_FILE_ENTRY;
    ExFileEntry->icbTag = FileEntry->icbTag;
    ExFileEntry->uid = FileEntry->uid;
    ExFileEntry->gid = FileEntry->gid;
    ExFileEntry->permissions = FileEntry->permissions;
    ExFileEntry->fileLinkCount = FileEntry->fileLinkCount;
    ExFileEntry->recordFormat = FileEntry->recordFormat;
    ExFileEntry->recordDisplayAttr = FileEntry->recordDisplayAttr;
    ExFileEntry->recordLength = FileEntry->recordLength;
    ExFileEntry->informationLength = FileEntry->informationLength;
    ExFileEntry->logicalBlocksRecorded = FileEntry->logicalBlocksRecorded;
    ExFileEntry->accessTime = FileEntry->accessTime;
    ExFileEntry->modificationTime = FileEntry->modificationTime;
    ExFileEntry->attrTime = FileEntry->attrTime;
    ExFileEntry->checkpoint = FileEntry->checkpoint;
    ExFileEntry->extendedAttrICB = FileEntry->extendedAttrICB;
    ExFileEntry->impIdent = FileEntry->impIdent;
    ExFileEntry->uniqueID = FileEntry->uniqueID;
    ExFileEntry->lengthExtendedAttr = FileEntry->lengthExtendedAttr;
    ExFileEntry->lengthAllocDescs = FileEntry->lengthAllocDescs;
    RtlCopyMemory(ExFileEntry+1, FileEntry+1, FileEntry->lengthExtendedAttr);
    RtlCopyMemory((int8*)(ExFileEntry+1)+FileEntry->lengthExtendedAttr, (int8*)(ExFileEntry+1)+FileEntry->lengthExtendedAttr, FileEntry->lengthAllocDescs);
 
    if((((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) == ICB_FLAG_AD_IN_ICB) {
 
        if((l = (uint32)(FileInfo->Dloc->DataLoc.Length))) {
 
            int8* tmp_buff = (int8*)MyAllocatePool__(NonPagedPool, l);
            if(!tmp_buff) {
                MyFreePool__(ExFileEntry);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            if(!OS_SUCCESS(status = UDFReadFile__(Vcb, FileInfo, 0, l, FALSE, tmp_buff, &ReadBytes)) ||
               !OS_SUCCESS(status = UDFResizeFile__(Vcb, FileInfo, 0)) ) {
                MyFreePool__(ExFileEntry);
                MyFreePool__(tmp_buff);
                return status;
            }
            FileInfo->Dloc->FELoc.Length =
            FileInfo->Dloc->DataLoc.Offset = NewLength;
            FileInfo->Dloc->FELoc.Modified =
            FileInfo->Dloc->DataLoc.Modified = TRUE;
            MyFreePool__(FileInfo->Dloc->FileEntry);
            FileInfo->Dloc->FileEntry = (tag*)ExFileEntry;
            if(!OS_SUCCESS(status = UDFResizeFile__(Vcb, FileInfo, l)) ||
               !OS_SUCCESS(status = UDFWriteFile__(Vcb, FileInfo, 0, l, FALSE, tmp_buff, &ReadBytes)) ) {
                MyFreePool__(ExFileEntry);
                MyFreePool__(tmp_buff);
                return status;
            }
            MyFreePool__(tmp_buff);
        } else {
            FileInfo->Dloc->FELoc.Length =
            FileInfo->Dloc->DataLoc.Offset = NewLength;
            FileInfo->Dloc->FELoc.Modified =
            FileInfo->Dloc->DataLoc.Modified = TRUE;
            MyFreePool__(FileInfo->Dloc->FileEntry);
            FileInfo->Dloc->FileEntry = (tag*)ExFileEntry;
        }
    } else {
        FileInfo->Dloc->FELoc.Length =
        FileInfo->Dloc->AllocLoc.Offset = NewLength;
        FileInfo->Dloc->FELoc.Modified =
        FileInfo->Dloc->AllocLoc.Modified = TRUE;
        MyFreePool__(FileInfo->Dloc->FileEntry);
        FileInfo->Dloc->FileEntry = (tag*)ExFileEntry;
    }
    FileInfo->Dloc->FileEntryLen = NewLength;
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    if(Vcb->minUDFReadRev < 0x0200)
        Vcb->minUDFReadRev = 0x0200;
    return STATUS_SUCCESS;
} // end UDFConvertFEToExtended()

Referenced by UDFCreateStreamDir__().

◆ UDFConvertFEToNonInICB()

OSSTATUS UDFConvertFEToNonInICB	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN uint8	NewAllocMode
	)

Definition at line 5358 of file udf_info.cpp.

{
    OSSTATUS status;
    int8* OldInIcb = NULL;
    uint32 OldLen;
    ValidateFileInfo(FileInfo);
    SIZE_T ReadBytes;
    SIZE_T _WrittenBytes;
    PUDF_DATALOC_INFO Dloc;
 
//    ASSERT(FileInfo->RefCount >= 1);
 
    Dloc = FileInfo->Dloc;
    ASSERT(Dloc->FELoc.Mapping[0].extLocation);
    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, Dloc->FELoc.Mapping[0].

Macros

Functions

Variables

Macro Definition Documentation

◆ AlignDirIndex

◆ AS_BAD

◆ AS_DISCARDED

◆ AS_FREE

◆ AS_USED

◆ FLUSH_FE_FOR_DEL

◆ FLUSH_FE_KEEP

◆ HASH_ALL

◆ HASH_DOS

◆ HASH_KEEP_NAME

◆ HASH_POSIX

◆ HASH_ULFN

◆ PH_FORGET_VERIFIED

◆ PH_KEEP_VERIFY_CACHE

◆ PH_READ_VERIFY_CACHE

◆ UDF_DIR_INDEX_FRAME

◆ UDF_DIR_INDEX_FRAME_GRAN

◆ UDF_DIR_INDEX_FRAME_GRAN_MASK

◆ UDF_DIR_INDEX_FRAME_SH

◆ UDF_FREE_DLOC

◆ UDF_FREE_FILEINFO

◆ UDF_FREE_NOTHING

◆ UDF_FSPACE_BM

◆ UDF_MAX_VERIFY_CACHE

◆ UDF_PREALLOC_CLASS_DIR

◆ UDF_PREALLOC_CLASS_FE

◆ UDF_SYS_CACHE_STOP_THR

◆ UDF_VERIFY_CACHE_GRAN

◆ UDF_VERIFY_CACHE_LOW

◆ UDF_ZSPACE_BM

◆ UDFAllocFreeExtent

◆ UDFCheckFreeBitOwner

◆ UDFCheckSpaceAllocation

◆ UDFCheckUsedBitOwner

◆ UDFClrBit

◆ UDFClrBits

◆ UDFClrZeroBit

◆ UDFClrZeroBits

◆ UDFDecDirCounter

◆ UDFDecFileCounter

◆ UDFDecFileLinkCount

◆ UDFDereferenceFile__

◆ UDFDirIndexGetLastIndex

◆ UDFDOSName__

◆ UDFExtentToMapping

◆ UDFGetBadBit

◆ UDFGetBit

◆ UDFGetFileAllocationSize

◆ UDFGetFileAllocMode__

◆ UDFGetFileICBAllocMode__

◆ UDFGetFreeBit

◆ UDFGetLVIDiUse

◆ UDFGetPartNumByPartNdx

◆ UDFGetUsedBit

◆ UDFGetZeroBit

◆ UDFHasAStreamDir

◆ UDFIncDirCounter

◆ UDFIncFileCounter

◆ UDFIncFileLinkCount

◆ UDFIsADirectory

◆ UDFIsAStream

◆ UDFIsAStreamDir

◆ UDFIsDeleted

◆ UDFIsDirEmpty__

◆ UDFIsDirOpened__

◆ UDFIsFileCached__

◆ UDFIsFlushed

◆ UDFIsSDirDeleted

◆ UDFMarkAllocatedAsNotAllocated

◆ UDFMarkRecordedAsAllocated

◆ UDFMarkSpaceAsXXX

◆ UDFMarkSpaceAsXXXNoProtect

◆ UDFNtAclSupported

◆ UDFReferenceFile__

◆ UDFReferenceFileEx__

◆ UDFRegisterFsStructure