Something went wrong. Try again.
Reactos
Something went wrong. Try again.
63 kB · 2318 lines
C
at master
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319/*++
Copyright (c) 1989-2000 Microsoft Corporation
Module Name:
CdProcs.h
Abstract:
This module defines all of the globally used procedures in the Cdfs file system.
--*/
#ifndef _CDPROCS_#define _CDPROCS_
#ifdef _MSC_VER#pragma warning( disable: 4127 ) // conditional expression is constant
#pragma warning( push )#pragma warning( disable: 4201 ) // nonstandard extension used : nameless struct/union#pragma warning( disable: 4214 ) // nonstandard extension used : bit field types#endif
#include <ntifs.h>
#include <ntddcdrm.h>#include <ntdddisk.h>#include <ntddscsi.h>#ifdef __REACTOS__#include <pseh/pseh2.h>#endif
#ifndef INLINE#define INLINE __inline#endif
#include "nodetype.h"#include "cd.h"#include "cdstruc.h"#include "cddata.h"
#ifdef CDFS_TELEMETRY_DATA
#include <winmeta.h>#include <TraceLoggingProvider.h>#include <telemetry\MicrosoftTelemetry.h>
#endif // CDFS_TELEMETRY_DATA
#ifdef _MSC_VER#pragma warning( pop )#endif
#ifdef __REACTOS__// Downgrade unsupported NT6.2+ features.#undef MdlMappingNoExecute#define MdlMappingNoExecute 0#define NonPagedPoolNx NonPagedPool#define NonPagedPoolNxCacheAligned NonPagedPoolCacheAligned#endif
//**** x86 compiler bug ****
#if defined(_M_IX86)#undef Int64ShraMod32#define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))#endif
#ifndef Min#define Min(a, b) ((a) < (b) ? (a) : (b))#endif
#ifndef Max#define Max(a, b) ((a) > (b) ? (a) : (b))#endif
//// Here are the different pool tags.//
#define TAG_CCB 'ccdC' // Ccb#define TAG_CDROM_TOC 'ctdC' // TOC#define TAG_DIRENT_NAME 'nddC' // CdName in dirent#define TAG_ENUM_EXPRESSION 'eedC' // Search expression for enumeration#define TAG_FCB_DATA 'dfdC' // Data Fcb#define TAG_FCB_INDEX 'ifdC' // Index Fcb#define TAG_FCB_NONPAGED 'nfdC' // Nonpaged Fcb#define TAG_FCB_TABLE 'tfdC' // Fcb Table entry#define TAG_FILE_NAME 'nFdC' // Filename buffer#define TAG_GEN_SHORT_NAME 'sgdC' // Generated short name#define TAG_IO_BUFFER 'fbdC' // Temporary IO buffer#define TAG_IO_CONTEXT 'oidC' // Io context for async reads#define TAG_IRP_CONTEXT 'cidC' // Irp Context#define TAG_IRP_CONTEXT_LITE 'lidC' // Irp Context lite#define TAG_MCB_ARRAY 'amdC' // Mcb array#define TAG_PATH_ENTRY_NAME 'nPdC' // CdName in path entry#define TAG_PREFIX_ENTRY 'epdC' // Prefix Entry#define TAG_PREFIX_NAME 'npdC' // Prefix Entry name#define TAG_SPANNING_PATH_TABLE 'psdC' // Buffer for spanning path table#define TAG_UPCASE_NAME 'nudC' // Buffer for upcased name#define TAG_VOL_DESC 'dvdC' // Buffer for volume descriptor#define TAG_VPB 'pvdC' // Vpb allocated in filesystem
//// Tag all of our allocations if tagging is turned on//
#ifdef POOL_TAGGING
#undef FsRtlAllocatePool#undef FsRtlAllocatePoolWithQuota#define FsRtlAllocatePool(a,b) FsRtlAllocatePoolWithTag(a,b,'sfdC')#define FsRtlAllocatePoolWithQuota(a,b) FsRtlAllocatePoolWithQuotaTag(a,b,'sfdC')
#endif // POOL_TAGGING
//// File access check routine, implemented in AcChkSup.c//
//// BOOLEAN// CdIllegalFcbAccess (// _In_ PIRP_CONTEXT IrpContext,// _In_ TYPE_OF_OPEN TypeOfOpen,// _In_ ACCESS_MASK DesiredAccess// );//
#define CdIllegalFcbAccess(IC,T,DA) ( \ BooleanFlagOn( (DA), \ ((T) != UserVolumeOpen ? \ (FILE_WRITE_ATTRIBUTES | \ FILE_WRITE_DATA | \ FILE_WRITE_EA | \ FILE_ADD_FILE | \ FILE_ADD_SUBDIRECTORY | \ FILE_APPEND_DATA) : 0) | \ FILE_DELETE_CHILD | \ DELETE | \ WRITE_DAC ))
//// Allocation support routines, implemented in AllocSup.c//// These routines are for querying allocation on individual streams.//
_Requires_lock_held_(_Global_critical_region_)VOIDCdLookupAllocation ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ LONGLONG FileOffset, _Out_ PLONGLONG DiskOffset, _Out_ PULONG ByteCount );
VOIDCdAddAllocationFromDirent ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ ULONG McbEntryOffset, _In_ LONGLONG StartingFileOffset, _In_ PDIRENT Dirent );
VOIDCdAddInitialAllocation ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ ULONG StartingBlock, _In_ LONGLONG DataLength );
VOIDCdTruncateAllocation ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ LONGLONG StartingFileOffset );
_At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType )))VOIDCdInitializeMcb ( _In_ PIRP_CONTEXT IrpContext, _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb );
_At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType )))_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_PATH_TABLE, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX)))_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_INDEX, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX)))_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_DATA, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_DATA)))VOIDCdUninitializeMcb ( _In_ PIRP_CONTEXT IrpContext, _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb );
//// Buffer control routines for data caching, implemented in CacheSup.c//
VOIDCdCreateInternalStream ( _In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _Inout_ PFCB Fcb, _In_ PUNICODE_STRING Name );
VOIDCdDeleteInternalStream ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb );
NTSTATUSCdCompleteMdl ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdPurgeVolume ( _In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _In_ BOOLEAN DismountUnderway );
static /* ReactOS Change: GCC "multiple definition" */INLINE /* GCC only accepts __inline as the first modifier */VOIDCdVerifyOrCreateDirStreamFile ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb ){ // // Unsafe test to see if call / lock neccessary. //
if (NULL == Fcb->FileObject) {
CdCreateInternalStream( IrpContext, Fcb->Vcb, Fcb, &Fcb->FileNamePrefix.ExactCaseName.FileName); }}
//// VOID// CdUnpinData (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PBCB *Bcb// );//
#define CdUnpinData(IC,B) \ if (*(B) != NULL) { CcUnpinData( *(B) ); *(B) = NULL; }
//// Device I/O routines, implemented in DevIoSup.c//// These routines perform the actual device read and writes. They only affect// the on disk structure and do not alter any other data structures.//
_Requires_lock_held_(_Global_critical_region_)VOIDCdFreeDirCache ( _In_ PIRP_CONTEXT IrpContext );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdNonCachedRead ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ LONGLONG StartingOffset, _In_ ULONG ByteCount );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdNonCachedXARead ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ LONGLONG StartingOffset, _In_ ULONG ByteCount );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdVolumeDasdWrite ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ LONGLONG StartingOffset, _In_ ULONG ByteCount );
BOOLEANCdReadSectors ( _In_ PIRP_CONTEXT IrpContext, _In_ LONGLONG StartingOffset, _In_ ULONG ByteCount, _In_ BOOLEAN ReturnError, _Out_writes_bytes_(ByteCount) PVOID Buffer, _In_ PDEVICE_OBJECT TargetDeviceObject );
NTSTATUSCdCreateUserMdl ( _In_ PIRP_CONTEXT IrpContext, _In_ ULONG BufferLength, _In_ BOOLEAN RaiseOnError, _In_ LOCK_OPERATION Operation );
NTSTATUSFASTCALLCdPerformDevIoCtrl ( _In_ PIRP_CONTEXT IrpContext, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT Device, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _In_ BOOLEAN OverrideVerify, _Out_opt_ PIO_STATUS_BLOCK Iosb );
NTSTATUSCdPerformDevIoCtrlEx ( _In_ PIRP_CONTEXT IrpContext, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT Device, _In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _In_ BOOLEAN OverrideVerify, _Out_opt_ PIO_STATUS_BLOCK Iosb );
NTSTATUSCdHijackIrpAndFlushDevice ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp, _In_ PDEVICE_OBJECT TargetDeviceObject );
//// VOID// CdMapUserBuffer (// _In_ PIRP_CONTEXT IrpContext// _Out_ PVOID UserBuffer// );//// Returns pointer to sys address. Will raise on failure.////// VOID// CdLockUserBuffer (// _Inout_ PIRP_CONTEXT IrpContext,// _In_ ULONG BufferLength// );//
#define CdMapUserBuffer(IC, UB) { \ *(UB) = (PVOID) ( ((IC)->Irp->MdlAddress == NULL) ? \ (IC)->Irp->UserBuffer : \ (MmGetSystemAddressForMdlSafe( (IC)->Irp->MdlAddress, NormalPagePriority | MdlMappingNoExecute))); \ if (NULL == *(UB)) { \ CdRaiseStatus( (IC), STATUS_INSUFFICIENT_RESOURCES); \ } \ }
#define CdLockUserBuffer(IC,BL,OP) { \ if ((IC)->Irp->MdlAddress == NULL) { \ (VOID) CdCreateUserMdl( (IC), (BL), TRUE, (OP) ); \ } \}
//// Dirent support routines, implemented in DirSup.c//
VOIDCdLookupDirent ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG DirentOffset, _Out_ PDIRENT_ENUM_CONTEXT DirContext );
BOOLEANCdLookupNextDirent ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext, _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext );
_At_(Dirent->CdTime, _Post_notnull_)VOIDCdUpdateDirentFromRawDirent ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PDIRENT_ENUM_CONTEXT DirContext, _Inout_ PDIRENT Dirent );
VOIDCdUpdateDirentName ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase );
_Success_(return != FALSE) BOOLEANCdFindFile ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _Inout_ PFILE_ENUM_CONTEXT FileContext, _Out_ PCD_NAME *MatchingName );
BOOLEANCdFindDirectory ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _Inout_ PFILE_ENUM_CONTEXT FileContext );
_At_(FileContext->ShortName.FileName.MaximumLength, _In_range_(>=, BYTE_COUNT_8_DOT_3))BOOLEANCdFindFileByShortName ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _In_ ULONG ShortNameDirentOffset, _Inout_ PFILE_ENUM_CONTEXT FileContext );
BOOLEANCdLookupNextInitialFileDirent ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext );
VOIDCdLookupLastFileDirent ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ PFILE_ENUM_CONTEXT FileContext );
VOIDCdCleanupFileContext ( _In_ PIRP_CONTEXT IrpContext, _In_ PFILE_ENUM_CONTEXT FileContext );
//// VOID// CdInitializeFileContext (// _In_ PIRP_CONTEXT IrpContext,// _Out_ PFILE_ENUM_CONTEXT FileContext// );////// VOID// CdInitializeDirent (// _In_ PIRP_CONTEXT IrpContext,// _Out_ PDIRENT Dirent// );//// VOID// CdInitializeDirContext (// _In_ PIRP_CONTEXT IrpContext,// _Out_ PDIRENT_ENUM_CONTEXT DirContext// );//// VOID// CdCleanupDirent (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PDIRENT Dirent// );//// VOID// CdCleanupDirContext (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PDIRENT_ENUM_CONTEXT DirContext// );//// VOID// CdLookupInitialFileDirent (// _In_ PIRP_CONTEXT IrpContext,// _In_ PFCB Fcb,// _Out_ PFILE_ENUM_CONTEXT FileContext,// _In_ ULONG DirentOffset// );//
#define CdInitializeFileContext(IC,FC) { \ RtlZeroMemory( FC, sizeof( FILE_ENUM_CONTEXT )); \ (FC)->PriorDirent = &(FC)->Dirents[0]; \ (FC)->InitialDirent = &(FC)->Dirents[1]; \ (FC)->CurrentDirent = &(FC)->Dirents[2]; \ (FC)->ShortName.FileName.MaximumLength = BYTE_COUNT_8_DOT_3; \ (FC)->ShortName.FileName.Buffer = (FC)->ShortNameBuffer; \}
#define CdInitializeDirent(IC,D) \ RtlZeroMemory( D, sizeof( DIRENT ))
#define CdInitializeDirContext(IC,DC) \ RtlZeroMemory( DC, sizeof( DIRENT_ENUM_CONTEXT ))
#define CdCleanupDirent(IC,D) { \ if (FlagOn( (D)->Flags, DIRENT_FLAG_ALLOC_BUFFER )) { \ CdFreePool( &(D)->CdFileName.FileName.Buffer ); \ } \}
#define CdCleanupDirContext(IC,DC) \ CdUnpinData( (IC), &(DC)->Bcb )
#define CdLookupInitialFileDirent(IC,F,FC,DO) \ CdLookupDirent( IC, \ F, \ DO, \ &(FC)->InitialDirent->DirContext ); \ CdUpdateDirentFromRawDirent( IC, \ F, \ &(FC)->InitialDirent->DirContext, \ &(FC)->InitialDirent->Dirent )
//// The following routines are used to manipulate the fscontext fields// of the file object, implemented in FilObSup.c//
//// Type of opens. FilObSup.c depends on this order.//
typedef enum _TYPE_OF_OPEN {
UnopenedFileObject = 0, StreamFileOpen, UserVolumeOpen, UserDirectoryOpen, UserFileOpen, BeyondValidType
} TYPE_OF_OPEN;typedef TYPE_OF_OPEN *PTYPE_OF_OPEN;
_When_(TypeOfOpen == UnopenedFileObject, _At_(Fcb, _In_opt_))_When_(TypeOfOpen != UnopenedFileObject, _At_(Fcb, _In_))VOIDCdSetFileObject ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFILE_OBJECT FileObject, _In_ TYPE_OF_OPEN TypeOfOpen, PFCB Fcb, _In_opt_ PCCB Ccb );
_When_(return == UnopenedFileObject, _At_(*Fcb, _Post_null_))_When_(return != UnopenedFileObject, _At_(Fcb, _Outptr_))_When_(return == UnopenedFileObject, _At_(*Ccb, _Post_null_))_When_(return != UnopenedFileObject, _At_(Ccb, _Outptr_))TYPE_OF_OPENCdDecodeFileObject ( _In_ PIRP_CONTEXT IrpContext, _In_ PFILE_OBJECT FileObject, PFCB *Fcb, PCCB *Ccb );
TYPE_OF_OPENCdFastDecodeFileObject ( _In_ PFILE_OBJECT FileObject, _Out_ PFCB *Fcb );
//// Name support routines, implemented in NameSup.c//
_Post_satisfies_(_Old_(CdName->FileName.Length) >= CdName->FileName.Length + CdName->VersionString.Length)VOIDCdConvertNameToCdName ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PCD_NAME CdName );
VOIDCdConvertBigToLittleEndian ( _In_ PIRP_CONTEXT IrpContext, _In_reads_bytes_(ByteCount) PCHAR BigEndian, _In_ ULONG ByteCount, _Out_writes_bytes_(ByteCount) PCHAR LittleEndian );
VOIDCdUpcaseName ( _In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME Name, _Inout_ PCD_NAME UpcaseName );
VOIDCdDissectName ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PUNICODE_STRING RemainingName, _Out_ PUNICODE_STRING FinalName );
BOOLEANCdIsLegalName ( _In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName );
BOOLEANCdIs8dot3Name ( _In_ PIRP_CONTEXT IrpContext, _In_ UNICODE_STRING FileName );
VOIDCdGenerate8dot3Name ( _In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING FileName, _In_ ULONG DirentOffset, _Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR ShortFileName, _Out_ PUSHORT ShortByteCount );
BOOLEANCdIsNameInExpression ( _In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion );
ULONGCdShortNameDirentOffset ( _In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING Name );
FSRTL_COMPARISON_RESULTCdFullCompareNames ( _In_ PIRP_CONTEXT IrpContext, _In_ PUNICODE_STRING NameA, _In_ PUNICODE_STRING NameB );
//// Filesystem control operations. Implemented in Fsctrl.c//
_Requires_lock_held_(_Global_critical_region_)_Requires_lock_held_(Vcb->VcbResource)NTSTATUSCdLockVolumeInternal ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_opt_ PFILE_OBJECT FileObject );
NTSTATUSCdUnlockVolumeInternal ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_opt_ PFILE_OBJECT FileObject );
//// Path table enumeration routines. Implemented in PathSup.c//
VOIDCdLookupPathEntry ( _In_ PIRP_CONTEXT IrpContext, _In_ ULONG PathEntryOffset, _In_ ULONG Ordinal, _In_ BOOLEAN VerifyBounds, _Inout_ PCOMPOUND_PATH_ENTRY CompoundPathEntry );
BOOLEANCdLookupNextPathEntry ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PPATH_ENUM_CONTEXT PathContext, _Inout_ PPATH_ENTRY PathEntry );
_Success_(return != FALSE)BOOLEANCdFindPathEntry ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB ParentFcb, _In_ PCD_NAME DirName, _In_ BOOLEAN IgnoreCase, _Inout_ PCOMPOUND_PATH_ENTRY CompoundPathEntry );
VOIDCdUpdatePathEntryName ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PPATH_ENTRY PathEntry, _In_ BOOLEAN IgnoreCase );
//// VOID// CdInitializeCompoundPathEntry (// _In_ PIRP_CONTEXT IrpContext,// _Out_ PCOMPOUND_PATH_ENTRY CompoundPathEntry// );//// VOID// CdCleanupCompoundPathEntry (// _In_ PIRP_CONTEXT IrpContext,// _Out_ PCOMPOUND_PATH_ENTRY CompoundPathEntry// );//
#define CdInitializeCompoundPathEntry(IC,CP) \ RtlZeroMemory( CP, sizeof( COMPOUND_PATH_ENTRY ))
#define CdCleanupCompoundPathEntry(IC,CP) { \ CdUnpinData( (IC), &(CP)->PathContext.Bcb ); \ if ((CP)->PathContext.AllocatedData) { \ CdFreePool( &(CP)->PathContext.Data ); \ } \ if (FlagOn( (CP)->PathEntry.Flags, PATH_ENTRY_FLAG_ALLOC_BUFFER )) { \ CdFreePool( &(CP)->PathEntry.CdDirName.FileName.Buffer ); \ } \}
//// Largest matching prefix searching routines, implemented in PrefxSup.c//
VOIDCdInsertPrefix ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ PCD_NAME Name, _In_ BOOLEAN IgnoreCase, _In_ BOOLEAN ShortNameMatch, _Inout_ PFCB ParentFcb );
VOIDCdRemovePrefix ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb );
_Requires_lock_held_(_Global_critical_region_)VOIDCdFindPrefix ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB *CurrentFcb, _Inout_ PUNICODE_STRING RemainingName, _In_ BOOLEAN IgnoreCase );
//// Synchronization routines. Implemented in Resrcsup.c//// The following routines/macros are used to synchronize the in-memory structures.//// Routine/Macro Synchronizes Subsequent//// CdAcquireCdData Volume Mounts/Dismounts,Vcb Queue CdReleaseCdData// CdAcquireVcbExclusive Vcb for open/close CdReleaseVcb// CdAcquireVcbShared Vcb for open/close CdReleaseVcb// CdAcquireAllFiles Locks out operations to all files CdReleaseAllFiles// CdAcquireFileExclusive Locks out file operations CdReleaseFile// CdAcquireFileShared Files for file operations CdReleaseFile// CdAcquireFcbExclusive Fcb for open/close CdReleaseFcb// CdAcquireFcbShared Fcb for open/close CdReleaseFcb// CdLockCdData Fields in CdData CdUnlockCdData// CdLockVcb Vcb fields, FcbReference, FcbTable CdUnlockVcb// CdLockFcb Fcb fields, prefix table, Mcb CdUnlockFcb//
typedef enum _TYPE_OF_ACQUIRE {
AcquireExclusive, AcquireShared, AcquireSharedStarveExclusive
} TYPE_OF_ACQUIRE, *PTYPE_OF_ACQUIRE;
_Requires_lock_held_(_Global_critical_region_)_When_(Type == AcquireExclusive && return != FALSE, _Acquires_exclusive_lock_(*Resource))_When_(Type == AcquireShared && return != FALSE, _Acquires_shared_lock_(*Resource))_When_(Type == AcquireSharedStarveExclusive && return != FALSE, _Acquires_shared_lock_(*Resource))_When_(IgnoreWait == FALSE, _Post_satisfies_(return == TRUE))BOOLEANCdAcquireResource ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PERESOURCE Resource, _In_ BOOLEAN IgnoreWait, _In_ TYPE_OF_ACQUIRE Type );
//// BOOLEAN// CdAcquireCdData (// _In_ PIRP_CONTEXT IrpContext// );//// VOID// CdReleaseCdData (// _In_ PIRP_CONTEXT IrpContext// );//// BOOLEAN// CdAcquireVcbExclusive (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PVCB Vcb,// _In_ BOOLEAN IgnoreWait// );//// BOOLEAN// CdAcquireVcbShared (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PVCB Vcb,// _In_ BOOLEAN IgnoreWait// );//// VOID// CdReleaseVcb (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PVCB Vcb// );//// VOID// CdAcquireAllFiles (// _In_ PIRP_CONTEXT,// _In_ PVCB Vcb// );//// VOID// CdReleaseAllFiles (// _In_ PIRP_CONTEXT,// _In_ PVCB Vcb// );//// VOID// CdAcquireFileExclusive (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb,// );//// VOID// CdAcquireFileShared (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// VOID// CdReleaseFile (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// BOOLEAN// CdAcquireFcbExclusive (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb,// _In_ BOOLEAN IgnoreWait// );//// BOOLEAN// CdAcquireFcbShared (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb,// _In_ BOOLEAN IgnoreWait// );//// BOOLEAN// CdReleaseFcb (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// VOID// CdLockCdData (// );//// VOID// CdUnlockCdData (// );//// VOID// CdLockVcb (// _In_ PIRP_CONTEXT IrpContext// );//// VOID// CdUnlockVcb (// _In_ PIRP_CONTEXT IrpContext// );//// VOID// CdLockFcb (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// VOID// CdUnlockFcb (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//
#define CdAcquireCacheForRead( IC) \ ExAcquireResourceSharedLite( &(IC)->Vcb->SectorCacheResource, TRUE)
#define CdAcquireCacheForUpdate( IC) \ ExAcquireResourceExclusiveLite( &(IC)->Vcb->SectorCacheResource, TRUE)
#define CdReleaseCache( IC) \ ExReleaseResourceLite( &(IC)->Vcb->SectorCacheResource);
#define CdConvertCacheToShared( IC) \ ExConvertExclusiveToSharedLite( &(IC)->Vcb->SectorCacheResource);
#define CdAcquireCdData(IC) \ ExAcquireResourceExclusiveLite( &CdData.DataResource, TRUE )
#define CdReleaseCdData(IC) \ ExReleaseResourceLite( &CdData.DataResource )
#define CdAcquireVcbExclusive(IC,V,I) \ CdAcquireResource( (IC), &(V)->VcbResource, (I), AcquireExclusive )
#define CdAcquireVcbShared(IC,V,I) \ CdAcquireResource( (IC), &(V)->VcbResource, (I), AcquireShared )
#define CdReleaseVcb(IC,V) \ ExReleaseResourceLite( &(V)->VcbResource )
#define CdAcquireAllFiles(IC,V) \ CdAcquireResource( (IC), &(V)->FileResource, FALSE, AcquireExclusive )
#define CdReleaseAllFiles(IC,V) \ ExReleaseResourceLite( &(V)->FileResource )
#define CdAcquireFileExclusive(IC,F) \ CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireExclusive )
#define CdAcquireFileShared(IC,F) \ CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireShared )
#define CdAcquireFileSharedStarveExclusive(IC,F) \ CdAcquireResource( (IC), (F)->Resource, FALSE, AcquireSharedStarveExclusive )
#define CdReleaseFile(IC,F) \ ExReleaseResourceLite( (F)->Resource )
#define CdAcquireFcbExclusive(IC,F,I) \ CdAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireExclusive )
#define CdAcquireFcbShared(IC,F,I) \ CdAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireShared )
#define CdReleaseFcb(IC,F) \ ExReleaseResourceLite( &(F)->FcbNonpaged->FcbResource )
#define CdLockCdData() \ ExAcquireFastMutex( &CdData.CdDataMutex ); \ CdData.CdDataLockThread = PsGetCurrentThread()
#define CdUnlockCdData() \ CdData.CdDataLockThread = NULL; \ ExReleaseFastMutex( &CdData.CdDataMutex )
#define CdLockVcb(IC,V) \ ExAcquireFastMutex( &(V)->VcbMutex ); \ NT_ASSERT( NULL == (V)->VcbLockThread); \ (V)->VcbLockThread = PsGetCurrentThread()
#define CdUnlockVcb(IC,V) \ NT_ASSERT( NULL != (V)->VcbLockThread); \ (V)->VcbLockThread = NULL; \ ExReleaseFastMutex( &(V)->VcbMutex )
#if defined(_PREFAST_)
_Success_(return)_IRQL_saves_global_(OldIrql, FastMutex)BOOLEAN DummySaveIrql(_Inout_ PFAST_MUTEX FastMutex);
_Success_(return)_IRQL_restores_global_(OldIrql, FastMutex)BOOLEAN DummyRestoreIrql(_Inout_ PFAST_MUTEX FastMutex);#endif // _PREFAST_
#define CdLockFcb(IC,F) { \ PVOID _CurrentThread = PsGetCurrentThread(); \ if (_CurrentThread != (F)->FcbLockThread) { \ ExAcquireFastMutex( &(F)->FcbNonpaged->FcbMutex ); \ NT_ASSERT( (F)->FcbLockCount == 0 ); \ _Analysis_assume_( (F)->FcbLockCount == 0 ); \ (F)->FcbLockThread = _CurrentThread; \ } \ else \ { \ _Analysis_assume_lock_held_( (F)->FcbNonpaged->FcbMutex ); \ _Analysis_assume_(FALSE != DummySaveIrql(&(F)->FcbNonpaged->FcbMutex)); \ } \ (F)->FcbLockCount += 1; \}
#define CdUnlockFcb(IC,F) { \ (F)->FcbLockCount -= 1; \ if ((F)->FcbLockCount == 0) { \ (F)->FcbLockThread = NULL; \ ExReleaseFastMutex( &(F)->FcbNonpaged->FcbMutex ); \ } \ else \ { \ _Analysis_assume_lock_not_held_( (F)->FcbNonpaged->FcbMutex ); \ _Analysis_assume_(FALSE != DummyRestoreIrql(&(F)->FcbNonpaged->FcbMutex)); \ } \}
//// The following macro is used to retrieve the oplock structure within// the Fcb. This structure was moved to the advanced Fcb header// in Win8.//
#if (NTDDI_VERSION >= NTDDI_WIN8)
#define CdGetFcbOplock(F) &(F)->Header.Oplock
#else
#define CdGetFcbOplock(F) &(F)->Oplock
#endif
BOOLEANNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdNoopAcquire ( _In_ PVOID Fcb, _In_ BOOLEAN Wait );
VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdNoopRelease ( _In_ PVOID Fcb );
_Requires_lock_held_(_Global_critical_region_)_When_(return!=0, _Acquires_shared_lock_(*Fcb->Resource))BOOLEANNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdAcquireForCache ( _Inout_ PFCB Fcb, _In_ BOOLEAN Wait );
_Requires_lock_held_(_Global_critical_region_)_Releases_lock_(*Fcb->Resource)VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdReleaseFromCache ( _Inout_ PFCB Fcb );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdFilterCallbackAcquireForCreateSection ( _In_ PFS_FILTER_CALLBACK_DATA CallbackData, _Unreferenced_parameter_ PVOID *CompletionContext );
_Function_class_(FAST_IO_RELEASE_FILE)_Requires_lock_held_(_Global_critical_region_)VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdReleaseForCreateSection ( _In_ PFILE_OBJECT FileObject );
//// In-memory structure support routines. Implemented in StrucSup.c//
VOIDCdInitializeVcb ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_ __drv_aliasesMem PDEVICE_OBJECT TargetDeviceObject, _In_ __drv_aliasesMem PVPB Vpb, _In_ __drv_aliasesMem PCDROM_TOC_LARGE CdromToc, _In_ ULONG TocLength, _In_ ULONG TocTrackCount, _In_ ULONG TocDiskFlags, _In_ ULONG BlockFactor, _In_ ULONG MediaChangeCount );
VOIDCdUpdateVcbFromVolDescriptor ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_reads_bytes_opt_(SECTOR_SIZE) PCHAR RawIsoVd );
VOIDCdDeleteVcb ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb );
PFCBCdCreateFcb ( _In_ PIRP_CONTEXT IrpContext, _In_ FILE_ID FileId, _In_ NODE_TYPE_CODE NodeTypeCode, _Out_opt_ PBOOLEAN FcbExisted );
VOIDCdInitializeFcbFromPathEntry ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_opt_ PFCB ParentFcb, _In_ PPATH_ENTRY PathEntry );
VOIDCdInitializeFcbFromFileContext ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ PFCB ParentFcb, _In_ PFILE_ENUM_CONTEXT FileContext );
PCCBCdCreateCcb ( _In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG Flags );
VOIDCdDeleteCcb ( _In_ PIRP_CONTEXT IrpContext, _In_ __drv_freesMem( Pool ) PCCB Ccb );
_When_(RaiseOnError || return, _At_(Fcb->FileLock, _Post_notnull_))_When_(RaiseOnError, _At_(IrpContext, _Pre_notnull_))BOOLEANCdCreateFileLock ( _In_opt_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ BOOLEAN RaiseOnError );
VOIDCdDeleteFileLock ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFILE_LOCK FileLock );
_Ret_valid_ PIRP_CONTEXTCdCreateIrpContext ( _In_ PIRP Irp, _In_ BOOLEAN Wait );
VOIDCdCleanupIrpContext ( _In_ PIRP_CONTEXT IrpContext, _In_ BOOLEAN Post );
VOIDCdInitializeStackIrpContext ( _Out_ PIRP_CONTEXT IrpContext, _In_ PIRP_CONTEXT_LITE IrpContextLite );
//// PIRP_CONTEXT_LITE// CdCreateIrpContextLite (// _In_ PIRP_CONTEXT IrpContext// );//// VOID// CdFreeIrpContextLite (// _Inout_ PIRP_CONTEXT_LITE IrpContextLite// );//
#define CdCreateIrpContextLite(IC) \ ExAllocatePoolWithTag( CdNonPagedPool, sizeof( IRP_CONTEXT_LITE ), TAG_IRP_CONTEXT_LITE )
#define CdFreeIrpContextLite(ICL) \ CdFreePool( &(ICL) )
_Requires_lock_held_(_Global_critical_region_)VOIDCdTeardownStructures ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB StartingFcb, _Out_ PBOOLEAN RemovedStartingFcb );
//// VOID// CdIncrementCleanupCounts (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// VOID// CdDecrementCleanupCounts (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// VOID// CdIncrementReferenceCounts (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb,// _In_ ULONG ReferenceCount// _In_ ULONG UserReferenceCount// );//// VOID// CdDecrementReferenceCounts (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb,// _In_ ULONG ReferenceCount// _In_ ULONG UserReferenceCount// );//// VOID// CdIncrementFcbReference (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//// VOID// CdDecrementFcbReference (// _In_ PIRP_CONTEXT IrpContext,// _Inout_ PFCB Fcb// );//
#define CdIncrementCleanupCounts(IC,F) { \ ASSERT_LOCKED_VCB( (F)->Vcb ); \ (F)->FcbCleanup += 1; \ (F)->Vcb->VcbCleanup += 1; \}
#define CdDecrementCleanupCounts(IC,F) { \ ASSERT_LOCKED_VCB( (F)->Vcb ); \ (F)->FcbCleanup -= 1; \ (F)->Vcb->VcbCleanup -= 1; \}
#define CdIncrementReferenceCounts(IC,F,C,UC) { \ ASSERT_LOCKED_VCB( (F)->Vcb ); \ (F)->FcbReference += (C); \ (F)->FcbUserReference += (UC); \ (F)->Vcb->VcbReference += (C); \ (F)->Vcb->VcbUserReference += (UC); \}
#define CdDecrementReferenceCounts(IC,F,C,UC) { \ ASSERT_LOCKED_VCB( (F)->Vcb ); \ (F)->FcbReference -= (C); \ (F)->FcbUserReference -= (UC); \ (F)->Vcb->VcbReference -= (C); \ (F)->Vcb->VcbUserReference -= (UC); \}
//// PCD_IO_CONTEXT// CdAllocateIoContext (// );//// VOID// CdFreeIoContext (// PCD_IO_CONTEXT IoContext// );//
#define CdAllocateIoContext() \ FsRtlAllocatePoolWithTag( CdNonPagedPool, \ sizeof( CD_IO_CONTEXT ), \ TAG_IO_CONTEXT )
#define CdFreeIoContext(IO) CdFreePool( (PVOID) &(IO) ) /* ReactOS Change: GCC "passing argument 1 from incompatible pointer type" */
PFCBCdLookupFcbTable ( _In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _In_ FILE_ID FileId );
PFCBCdGetNextFcb ( _In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _In_ PVOID *RestartKey );
NTSTATUSCdProcessToc ( _In_ PIRP_CONTEXT IrpContext, _In_ PDEVICE_OBJECT TargetDeviceObject, _In_ PCDROM_TOC_LARGE CdromToc, _Inout_ PULONG Length, _Out_ PULONG TrackCount, _Inout_ PULONG DiskFlags );
//// For debugging purposes we sometimes want to allocate our structures from nonpaged// pool so that in the kernel debugger we can walk all the structures.//
#define CdPagedPool PagedPool#define CdNonPagedPool NonPagedPoolNx#define CdNonPagedPoolCacheAligned NonPagedPoolNxCacheAligned
//// Verification support routines. Contained in verfysup.c//
static /* ReactOS Change: GCC "multiple definition" */INLINEBOOLEANCdOperationIsDasdOpen ( _In_ PIRP_CONTEXT IrpContext ){ PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->Irp);
return ((IrpContext->MajorFunction == IRP_MJ_CREATE) && (IrpSp->FileObject->FileName.Length == 0) && (IrpSp->FileObject->RelatedFileObject == NULL));}
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdPerformVerify ( _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp, _In_ PDEVICE_OBJECT DeviceToVerify );
_Requires_lock_held_(_Global_critical_region_)BOOLEANCdCheckForDismount ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb, _In_ BOOLEAN Force );
BOOLEANCdMarkDevForVerifyIfVcbMounted ( _Inout_ PVCB Vcb );
VOIDCdVerifyVcb ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb );
BOOLEANCdVerifyFcbOperation ( _In_opt_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb );
_Requires_lock_held_(_Global_critical_region_)BOOLEANCdDismountVcb ( _In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb );
//// Macros to abstract device verify flag changes.//
#define CdUpdateMediaChangeCount( V, C) (V)->MediaChangeCount = (C)#define CdUpdateVcbCondition( V, C) (V)->VcbCondition = (C)
#define CdMarkRealDevForVerify( DO) SetFlag( (DO)->Flags, DO_VERIFY_VOLUME)
#define CdMarkRealDevVerifyOk( DO) ClearFlag( (DO)->Flags, DO_VERIFY_VOLUME)
#define CdRealDevNeedsVerify( DO) BooleanFlagOn( (DO)->Flags, DO_VERIFY_VOLUME)
//// BOOLEAN// CdIsRawDevice (// _In_ PIRP_CONTEXT IrpContext,// _In_ NTSTATUS Status// );//
#define CdIsRawDevice(IC,S) ( \ ((S) == STATUS_DEVICE_NOT_READY) || \ ((S) == STATUS_NO_MEDIA_IN_DEVICE) \)
//// Work queue routines for posting and retrieving an Irp, implemented in// workque.c//
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdFsdPostRequest ( _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdPrePostIrp ( _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)VOIDNTAPI /* ReactOS Change: GCC Does not support STDCALL by default */CdOplockComplete ( _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
//// Miscellaneous support routines//
//// This macro returns TRUE if a flag in a set of flags is on and FALSE// otherwise//
/* GCC complains about multi-line comments.//#ifndef BooleanFlagOn//#define BooleanFlagOn(F,SF) ( \// (BOOLEAN)(((F) & (SF)) != 0) \//)//#endif
//#ifndef SetFlag//#define SetFlag(Flags,SingleFlag) { \// (Flags) |= (SingleFlag); \//}//#endif
//#ifndef ClearFlag//#define ClearFlag(Flags,SingleFlag) { \// (Flags) &= ~(SingleFlag); \//}//#endif*/
//// CAST// Add2Ptr (// _In_ PVOID Pointer,// _In_ ULONG Increment// _In_ (CAST)// );//// ULONG// PtrOffset (// _In_ PVOID BasePtr,// _In_ PVOID OffsetPtr// );//
#define Add2Ptr(PTR,INC,CAST) ((CAST)((PUCHAR)(PTR) + (INC)))
#define PtrOffset(BASE,OFFSET) ((ULONG)((ULONG_PTR)(OFFSET) - (ULONG_PTR)(BASE)))
//// This macro takes a pointer (or ulong) and returns its rounded up word// value//
#define WordAlign(Ptr) ( \ ((((ULONG)(Ptr)) + 1) & 0xfffffffe) \ )
//// This macro takes a pointer (or ulong) and returns its rounded up longword// value//
#define LongAlign(Ptr) ( \ ((((ULONG)(Ptr)) + 3) & 0xfffffffc) \ )
//// This macro takes a pointer (or ulong) and returns its rounded up quadword// value//
#define QuadAlign(Ptr) ( \ ((((ULONG)(Ptr)) + 7) & 0xfffffff8) \ )
//// The following macros round up and down to sector boundaries.//
#define SectorAlign(L) ( \ ((((ULONG)(L)) + (SECTOR_SIZE - 1)) & ~(SECTOR_SIZE - 1)) \)
#define LlSectorAlign(L) ( \ ((((LONGLONG)(L)) + (SECTOR_SIZE - 1)) & ~(SECTOR_SIZE - 1)) \)
#define SectorTruncate(L) ( \ ((ULONG)(L)) & ~(SECTOR_SIZE - 1) \)
#define LlSectorTruncate(L) ( \ ((LONGLONG)(L)) & ~(SECTOR_SIZE - 1) \)
#define BytesFromSectors(L) ( \ ((ULONG) (L)) << SECTOR_SHIFT \)
#define SectorsFromBytes(L) ( \ ((ULONG) (L)) >> SECTOR_SHIFT \)
static /* ReactOS Change: GCC "multiple definition" */INLINEULONGSectorsFromLlBytes( ULONGLONG Bytes) {
return (ULONG)(Bytes >> SECTOR_SHIFT);}
#define LlBytesFromSectors(L) ( \ Int64ShllMod32( (LONGLONG)(L), SECTOR_SHIFT ) \)
#define LlSectorsFromBytes(L) ( \ Int64ShraMod32( (LONGLONG)(L), SECTOR_SHIFT ) \)
#define SectorOffset(L) ( \ ((ULONG)(ULONG_PTR) (L)) & SECTOR_MASK \)
#define SectorBlockOffset(V,LB) ( \ ((ULONG) (LB)) & ((V)->BlocksPerSector - 1) \)
#define BytesFromBlocks(V,B) ( \ (ULONG) (B) << (V)->BlockToByteShift \)
#define LlBytesFromBlocks(V,B) ( \ Int64ShllMod32( (LONGLONG) (B), (V)->BlockToByteShift ) \)
#define BlockAlign(V,L) ( \ ((ULONG)(L) + (V)->BlockMask) & (V)->BlockInverseMask \)
//// Carefully make sure the mask is sign extended to 64bits//
#define LlBlockAlign(V,L) ( \ ((LONGLONG)(L) + (V)->BlockMask) & (LONGLONG)((LONG)(V)->BlockInverseMask) \)
#define BlockOffset(V,L) ( \ ((ULONG) (L)) & (V)->BlockMask \)
#define RawSectorAlign( B) ((((B)+(RAW_SECTOR_SIZE - 1)) / RAW_SECTOR_SIZE) * RAW_SECTOR_SIZE)
//// The following types and macros are used to help unpack the packed and// misaligned fields found in the Bios parameter block//
typedef union _UCHAR1 { UCHAR Uchar[1]; UCHAR ForceAlignment;} UCHAR1, *PUCHAR1;
typedef union _UCHAR2 { UCHAR Uchar[2]; USHORT ForceAlignment;} UCHAR2, *PUCHAR2;
typedef union _UCHAR4 { UCHAR Uchar[4]; ULONG ForceAlignment;} UCHAR4, *PUCHAR4;
typedef union _USHORT2 { USHORT Ushort[2]; ULONG ForceAlignment;} USHORT2, *PUSHORT2;
//// This macro copies an unaligned src byte to an aligned dst byte//
#define CopyUchar1(Dst,Src) { \ *((UCHAR1 *)(Dst)) = *((UNALIGNED UCHAR1 *)(Src)); \ }
//// This macro copies an unaligned src word to an aligned dst word//
#define CopyUchar2(Dst,Src) { \ *((UCHAR2 *)(Dst)) = *((UNALIGNED UCHAR2 *)(Src)); \ }
//// This macro copies an unaligned src longword to an aligned dsr longword//
#define CopyUchar4(Dst,Src) { \ *((UCHAR4 *)(Dst)) = *((UNALIGNED UCHAR4 *)(Src)); \ }
//// This macro copies an unaligned src longword to an aligned dsr longword// accessing the source on a word boundary.//
#define CopyUshort2(Dst,Src) { \ *((USHORT2 *)(Dst)) = *((UNALIGNED USHORT2 *)(Src));\ }
//// This macro copies an unaligned src longword to a dst longword,// performing an little/big endian swap.//
#define SwapCopyUchar4(Dst,Src) { \ *((UNALIGNED UCHAR1 *)(Dst)) = *((UNALIGNED UCHAR1 *)(Src) + 3); \ *((UNALIGNED UCHAR1 *)(Dst) + 1) = *((UNALIGNED UCHAR1 *)(Src) + 2); \ *((UNALIGNED UCHAR1 *)(Dst) + 2) = *((UNALIGNED UCHAR1 *)(Src) + 1); \ *((UNALIGNED UCHAR1 *)(Dst) + 3) = *((UNALIGNED UCHAR1 *)(Src)); \}
VOIDCdLbnToMmSsFf ( _In_ ULONG Blocks, _Out_writes_(3) PUCHAR Msf );
//// Following routines handle entry in and out of the filesystem. They are// contained in CdData.c//
_IRQL_requires_max_(APC_LEVEL)__drv_dispatchType(DRIVER_DISPATCH)__drv_dispatchType(IRP_MJ_CREATE)__drv_dispatchType(IRP_MJ_CLOSE)__drv_dispatchType(IRP_MJ_READ)__drv_dispatchType(IRP_MJ_WRITE)__drv_dispatchType(IRP_MJ_QUERY_INFORMATION)__drv_dispatchType(IRP_MJ_SET_INFORMATION)__drv_dispatchType(IRP_MJ_QUERY_VOLUME_INFORMATION)__drv_dispatchType(IRP_MJ_DIRECTORY_CONTROL)__drv_dispatchType(IRP_MJ_FILE_SYSTEM_CONTROL)__drv_dispatchType(IRP_MJ_DEVICE_CONTROL)__drv_dispatchType(IRP_MJ_LOCK_CONTROL)__drv_dispatchType(IRP_MJ_CLEANUP)__drv_dispatchType(IRP_MJ_PNP)__drv_dispatchType(IRP_MJ_SHUTDOWN)NTSTATUSNTAPICdFsdDispatch ( _In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp );
// DRIVER_DISPATCH CdFsdDispatch;
LONGCdExceptionFilter ( _Inout_ PIRP_CONTEXT IrpContext, _In_ PEXCEPTION_POINTERS ExceptionPointer );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdProcessException ( _In_opt_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp, _In_ NTSTATUS ExceptionCode );
VOIDCdCompleteRequest ( _Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status );
//// VOID// CdRaiseStatus (// _In_ PRIP_CONTEXT IrpContext,// _In_ NT_STATUS Status// );//// VOID// CdNormalizeAndRaiseStatus (// _In_ PRIP_CONTEXT IrpContext,// _In_ NT_STATUS Status// );//
#if 0#define AssertVerifyDevice(C, S) \ NT_ASSERT( (C) == NULL || \ FlagOn( (C)->Flags, IRP_CONTEXT_FLAG_IN_FSP ) || \ !((S) == STATUS_VERIFY_REQUIRED && \ IoGetDeviceToVerify( PsGetCurrentThread() ) == NULL ));
#define AssertVerifyDeviceIrp(I) \ NT_ASSERT( (I) == NULL || \ !(((I)->IoStatus.Status) == STATUS_VERIFY_REQUIRED && \ ((I)->Tail.Overlay.Thread == NULL || \ IoGetDeviceToVerify( (I)->Tail.Overlay.Thread ) == NULL )));#else#define AssertVerifyDevice(C, S)#define AssertVerifyDeviceIrp(I)#endif
#ifdef CD_SANITY
DECLSPEC_NORETURNVOIDCdRaiseStatusEx ( _In_ PIRP_CONTEXT IrpContext, _In_ NTSTATUS Status, _In_ BOOLEAN NormalizeStatus, _In_opt_ ULONG FileId, _In_opt_ ULONG Line );
#else
#ifdef __REACTOS__static // make windows gcc release build compile#endifINLINEDECLSPEC_NORETURNVOIDCdRaiseStatusEx( _In_ PIRP_CONTEXT IrpContext, _In_ NTSTATUS Status, _In_ BOOLEAN NormalizeStatus, _In_ ULONG Fileid, _In_ ULONG Line ){ if (NormalizeStatus) {
IrpContext->ExceptionStatus = FsRtlNormalizeNtstatus( Status, STATUS_UNEXPECTED_IO_ERROR); } else {
IrpContext->ExceptionStatus = Status; }
IrpContext->RaisedAtLineFile = (Fileid << 16) | Line;
ExRaiseStatus( IrpContext->ExceptionStatus );}
#endif
#define CdRaiseStatus( IC, S) CdRaiseStatusEx( (IC), (S), FALSE, BugCheckFileId, __LINE__);#define CdNormalizeAndRaiseStatus( IC, S) CdRaiseStatusEx( (IC), (S), TRUE, BugCheckFileId, __LINE__);
//// Following are the fast entry points.//
// _Success_(return != FALSE)// BOOLEAN// CdFastQueryBasicInfo (// _In_ PFILE_OBJECT FileObject,// _In_ BOOLEAN Wait,// _Out_ PFILE_BASIC_INFORMATION Buffer,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_QUERY_BASIC_INFO CdFastQueryBasicInfo;
// _Success_(return != FALSE)// BOOLEAN// CdFastQueryStdInfo (// _In_ PFILE_OBJECT FileObject,// _In_ BOOLEAN Wait,// _Out_ PFILE_STANDARD_INFORMATION Buffer,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_QUERY_STANDARD_INFO CdFastQueryStdInfo;
// BOOLEAN// CdFastLock (// _In_ PFILE_OBJECT FileObject,// _In_ PLARGE_INTEGER FileOffset,// _In_ PLARGE_INTEGER Length,// _In_ PEPROCESS ProcessId,// _In_ ULONG Key,// _In_ BOOLEAN FailImmediately,// _In_ BOOLEAN ExclusiveLock,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_LOCK CdFastLock;
// BOOLEAN// CdFastUnlockSingle (// _In_ PFILE_OBJECT FileObject,// _In_ PLARGE_INTEGER FileOffset,// _In_ PLARGE_INTEGER Length,// _In_ PEPROCESS ProcessId,// _In_ ULONG Key,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_UNLOCK_SINGLE CdFastUnlockSingle;
// BOOLEAN// CdFastUnlockAll (// _In_ PFILE_OBJECT FileObject,// _In_ PEPROCESS ProcessId,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_UNLOCK_ALL CdFastUnlockAll;
// BOOLEAN// CdFastUnlockAllByKey (// _In_ PFILE_OBJECT FileObject,// _In_ PVOID ProcessId,// _In_ ULONG Key,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_UNLOCK_ALL_BY_KEY CdFastUnlockAllByKey;
// BOOLEAN// CdFastIoCheckIfPossible (// _In_ PFILE_OBJECT FileObject,// _In_ PLARGE_INTEGER FileOffset,// _In_ ULONG Length,// _In_ BOOLEAN Wait,// _In_ ULONG LockKey,// _In_ BOOLEAN CheckForReadOperation,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_CHECK_IF_POSSIBLE CdFastIoCheckIfPossible;
// _Success_(return != FALSE)// BOOLEAN// CdFastQueryNetworkInfo (// _In_ PFILE_OBJECT FileObject,// _In_ BOOLEAN Wait,// _Out_ PFILE_NETWORK_OPEN_INFORMATION Buffer,// _Out_ PIO_STATUS_BLOCK IoStatus,// _In_ PDEVICE_OBJECT DeviceObject// );
FAST_IO_QUERY_NETWORK_OPEN_INFO CdFastQueryNetworkInfo;
//// Following are the routines to handle the top level thread logic.//
VOIDCdSetThreadContext ( _Inout_ PIRP_CONTEXT IrpContext, _In_ PTHREAD_CONTEXT ThreadContext );
//// VOID// CdRestoreThreadContext (// _Inout_ PIRP_CONTEXT IrpContext// );//
#define CdRestoreThreadContext(IC) \ (IC)->ThreadContext->Cdfs = 0; \ IoSetTopLevelIrp( (IC)->ThreadContext->SavedTopLevelIrp ); \ (IC)->ThreadContext = NULL
ULONGCdSerial32 ( _In_reads_bytes_(ByteCount) PCHAR Buffer, _In_ ULONG ByteCount );
//// The following macro is used to determine if an FSD thread can block// for I/O or wait for a resource. It returns TRUE if the thread can// block and FALSE otherwise. This attribute can then be used to call// the FSD & FSP common work routine with the proper wait value.//
#define CanFsdWait(I) IoIsOperationSynchronous(I)
//// The following macro is used to set the fast i/o possible bits in the// FsRtl header.//// FastIoIsNotPossible - If the Fcb is bad or there are oplocks on the file.//// FastIoIsQuestionable - If there are file locks.//// FastIoIsPossible - In all other cases.////
#define CdIsFastIoPossible(F) ((BOOLEAN) \ ((((F)->Vcb->VcbCondition != VcbMounted ) || \ !FsRtlOplockIsFastIoPossible( CdGetFcbOplock(F) )) ? \ \ FastIoIsNotPossible : \ \ ((((F)->FileLock != NULL) && FsRtlAreThereCurrentFileLocks( (F)->FileLock )) ? \ \ FastIoIsQuestionable : \ \ FastIoIsPossible)) \)
//// The FSP level dispatch/main routine. This is the routine that takes// IRP's off of the work queue and calls the appropriate FSP level// work routine.//
// VOID// CdFspDispatch ( // implemented in FspDisp.c// _Inout_ PIRP_CONTEXT IrpContext// );
WORKER_THREAD_ROUTINE CdFspDispatch;
VOIDCdFspClose ( // implemented in Close.c _In_opt_ PVCB Vcb );
//// The following routines are the entry points for the different operations// based on the IrpSp major functions.//
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonCreate ( // Implemented in Create.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonClose ( // Implemented in Close.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonRead ( // Implemented in Read.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonWrite ( // Implemented in Write.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonQueryInfo ( // Implemented in FileInfo.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonSetInfo ( // Implemented in FileInfo.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonQueryVolInfo ( // Implemented in VolInfo.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonDirControl ( // Implemented in DirCtrl.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonFsControl ( // Implemented in FsCtrl.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
NTSTATUSCdCommonDevControl ( // Implemented in DevCtrl.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
NTSTATUSCdCommonLockControl ( // Implemented in LockCtrl.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonCleanup ( // Implemented in Cleanup.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonPnp ( // Implemented in Pnp.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
_Requires_lock_held_(_Global_critical_region_)NTSTATUSCdCommonShutdown ( // Implemented in Shutdown.c _Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp );
//// The following macros are used to establish the semantics needed// to do a return from within a try-finally clause. As a rule every// try clause must end with a label call try_exit. For example,//// try {// :// ://// try_exit: NOTHING;// } finally {//// :// :// }//// Every return statement executed inside of a try clause should use the// try_return macro. If the compiler fully supports the try-finally construct// then the macro should be//// #define try_return(S) { return(S); }//// If the compiler does not support the try-finally construct then the macro// should be//// #define try_return(S) { S; goto try_exit; }//
#ifndef __REACTOS__#define try_return(S) { S; goto try_exit; }#define try_leave(S) { S; leave; }#else#define try_return(S) { S; goto try_exit; }#define try_leave(S) { S; _SEH2_LEAVE; }#endif
//// Encapsulate safe pool freeing///* ReactOS Change: GCC "passing argument 1 of CdFreePool from incompatible pointer type" */#define CdFreePool(x) _CdFreePool((PVOID*)(x))
static /* ReactOS Change: GCC "multiple definition" */INLINEVOID_CdFreePool( _Inout_ _At_(*Pool, __drv_freesMem(Mem) _Post_null_) PVOID *Pool ){ if (*Pool != NULL) {
ExFreePool(*Pool); *Pool = NULL; }}
#ifdef CDFS_TELEMETRY_DATA
//// CDFS Telemetry. Current implementation uses the Telemetry TraceLogging APIs.//// The Telemetry TraceLoggingWrite() routines use a lot of stack space. We must// therefor wrap all our telemetry points with our own routines, and add a guard to// make sure there's enough stack space to call these routines.//// These telemetry routines should not be called on high-performance code paths.//
TRACELOGGING_DECLARE_PROVIDER( CdTelemetryProvider );
VOIDCdInitializeTelemetry ( VOID );
DECLSPEC_NOINLINEVOIDCdTelemetryMount ( __in PGUID VolumeGuid, __in NTSTATUS Status, __in PVCB Vcb );
//// Every additional argument passed to TraceLoggingWrite() consumes an additional// 16 to 32 bytes extra stack space. Having 512 bytes reserved space should be// sufficient for up to 20 arguments or so. This will be less of course if our// wrapper routines also declare their own local variables.//
#define CDFS_TELEMETRY_STACK_THRESHOLD_DEFAULT 512 // for "small" telemetry points#define CDFS_TELEMETRY_STACK_THRESHOLD_LARGE 2048 // for "large" telemetry points
INLINEBOOLEANCdTelemetryGuard ( __in ULONG StackSpaceNeeded )/*++
Routine Description:
This routine returns TRUE only when:
1) There is an ETW listener, AND 2) There is enough free stack space to safely call the Telemetry TraceLogging APIs
We'll also count how many times there wasn't enough stack space, and include this value as part of the periodic cdfs Telemetry.
Arguments:
StackSpaceNeeded - Stack space needed in bytes
--*/{ ASSERT( IoGetRemainingStackSize() >= StackSpaceNeeded );
if (CdTelemetryProvider->LevelPlus1 <= 5) {
// // Bail out early if there are no ETW listeners //
return FALSE; }
if (IoGetRemainingStackSize() < StackSpaceNeeded) {
// // Count how many times it was unsafe to generate telemetry because of // not enough stack space. //
InterlockedIncrement( &CdTelemetryData.MissedTelemetryPoints );
return FALSE; }
return TRUE;}
#define CdTelemetryMountSafe( VolumeGuid, Status, Vcb ) \ if (CdTelemetryGuard( CDFS_TELEMETRY_STACK_THRESHOLD_LARGE )) { \ CdTelemetryMount( VolumeGuid, Status, Vcb ); \ }
#if DBG#define CDFS_TELEMETRY_PERIODIC_INTERVAL CdTelemetryData.PeriodicInterval#else#define CDFS_TELEMETRY_PERIODIC_INTERVAL INTERVAL_ONE_DAY#endif
#else // CDFS_TELEMETRY_DATA
//// When CDFS_TELEMETRY_DATA is not defined then the CdTelemetry___Safe() routines// expand to nothing. This minimizes the cdfs.sys binary footprint. This also// means that the places where these Safe() routines are called do not// have to have to be surrounded by #ifdef CDFS_TELEMETRY_DATA .. #endif//
#define CdTelemetryMountSafe( ... ) NOTHING
#endif // CDFS_TELEMETRY_DATA
#endif // _CDPROCS_