#include <ntifs.h>#include <ntddcdrm.h>#include <ntdddisk.h>#include <ntddscsi.h>#include "nodetype.h"#include "cd.h"#include "cdstruc.h"#include "cddata.h"
Include dependency graph for cdprocs.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| union | _UCHAR1 |
| union | _UCHAR2 |
| union | _UCHAR4 |
| union | _USHORT2 |
Typedefs | |
| typedef enum _TYPE_OF_OPEN | TYPE_OF_OPEN |
| typedef TYPE_OF_OPEN * | PTYPE_OF_OPEN |
| typedef enum _TYPE_OF_ACQUIRE | TYPE_OF_ACQUIRE |
| typedef enum _TYPE_OF_ACQUIRE * | PTYPE_OF_ACQUIRE |
| typedef union _UCHAR1 | UCHAR1 |
| typedef union _UCHAR1 * | PUCHAR1 |
| typedef union _UCHAR2 | UCHAR2 |
| typedef union _UCHAR2 * | PUCHAR2 |
| typedef union _UCHAR4 | UCHAR4 |
| typedef union _UCHAR4 * | PUCHAR4 |
| typedef union _USHORT2 | USHORT2 |
| typedef union _USHORT2 * | PUSHORT2 |
Enumerations | |
| enum | _TYPE_OF_OPEN { UnopenedFileObject = 0 , StreamFileOpen , UserVolumeOpen , UserDirectoryOpen , UserFileOpen , BeyondValidType , UnopenedFileObject = 1 , UserFileOpen , UserDirectoryOpen , UserVolumeOpen , VirtualVolumeFile , DirectoryFile , EaFile } |
| enum | _TYPE_OF_ACQUIRE { AcquireExclusive , AcquireShared , AcquireSharedStarveExclusive } |
Macro Definition Documentation
◆ Add2Ptr
◆ AssertVerifyDevice
◆ AssertVerifyDeviceIrp
◆ BlockAlign
Value:
( \
)
◆ BlockOffset
◆ BytesFromBlocks
◆ BytesFromSectors
Value:
◆ CanFsdWait
◆ CdAcquireAllFiles
| #define CdAcquireAllFiles | ( | IC, | |
| V | |||
| ) | CdAcquireResource( (IC), &(V)->FileResource, FALSE, AcquireExclusive ) |
◆ CdAcquireCacheForRead
| #define CdAcquireCacheForRead | ( | IC | ) | ExAcquireResourceSharedLite( &(IC)->Vcb->SectorCacheResource, TRUE) |
◆ CdAcquireCacheForUpdate
| #define CdAcquireCacheForUpdate | ( | IC | ) | ExAcquireResourceExclusiveLite( &(IC)->Vcb->SectorCacheResource, TRUE) |
◆ CdAcquireCdData
| #define CdAcquireCdData | ( | IC | ) | ExAcquireResourceExclusiveLite( &CdData.DataResource, TRUE ) |
◆ CdAcquireFcbExclusive
◆ CdAcquireFcbShared
◆ CdAcquireFileExclusive
◆ CdAcquireFileShared
◆ CdAcquireFileSharedStarveExclusive
◆ CdAcquireVcbExclusive
◆ CdAcquireVcbShared
◆ CdAllocateIoContext
| #define CdAllocateIoContext | ( | ) |
Value:
sizeof( CD_IO_CONTEXT ), \
PVOID NTAPI FsRtlAllocatePoolWithTag(IN POOL_TYPE PoolType, IN ULONG NumberOfBytes, IN ULONG Tag)
Definition: filter.c:229
Definition: cdstruc.h:1319
◆ CdCleanupCompoundPathEntry
◆ CdCleanupDirContext
| #define CdCleanupDirContext | ( | IC, | |
| DC | |||
| ) | CdUnpinData( (IC), &(DC)->Bcb ) |
◆ CdCleanupDirent
Value:
◆ CdConvertCacheToShared
| #define CdConvertCacheToShared | ( | IC | ) | ExConvertExclusiveToSharedLite( &(IC)->Vcb->SectorCacheResource); |
◆ CdCreateIrpContextLite
| #define CdCreateIrpContextLite | ( | IC | ) | ExAllocatePoolWithTag( CdNonPagedPool, sizeof( IRP_CONTEXT_LITE ), TAG_IRP_CONTEXT_LITE ) |
◆ CdDecrementCleanupCounts
Value:
◆ CdDecrementReferenceCounts
Value:
◆ CdFreeIoContext
◆ CdFreeIrpContextLite
| #define CdFreeIrpContextLite | ( | ICL | ) | CdFreePool( &(ICL) ) |
◆ CdFreePool
◆ CdGetFcbOplock
◆ CdIllegalFcbAccess
Value:
( \
BooleanFlagOn( (DA), \
((T) != UserVolumeOpen ? \
FILE_WRITE_DATA | \
FILE_WRITE_EA | \
FILE_ADD_FILE | \
FILE_APPEND_DATA) : 0) | \
DELETE | \
WRITE_DAC ))
◆ CdIncrementCleanupCounts
◆ CdIncrementReferenceCounts
◆ CdInitializeCompoundPathEntry
| #define CdInitializeCompoundPathEntry | ( | IC, | |
| CP | |||
| ) | RtlZeroMemory( CP, sizeof( COMPOUND_PATH_ENTRY )) |
◆ CdInitializeDirContext
| #define CdInitializeDirContext | ( | IC, | |
| DC | |||
| ) | RtlZeroMemory( DC, sizeof( DIRENT_ENUM_CONTEXT )) |
◆ CdInitializeDirent
◆ CdInitializeFileContext
| #define CdInitializeFileContext | ( | IC, | |
| FC | |||
| ) |
Value:
{ \
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; \
}
IN PDCB IN POEM_STRING IN PUNICODE_STRING IN OUT POEM_STRING ShortName
Definition: fatprocs.h:1307
Definition: cdstruc.h:1696
◆ CdIsFastIoPossible
Value:
((BOOLEAN) \
\
\
\
\
FastIoIsPossible)) \
)
BOOLEAN NTAPI FsRtlOplockIsFastIoPossible(IN POPLOCK Oplock)
Definition: oplock.c:1564
◆ CdIsRawDevice
Value:
◆ CdLockCdData
| #define CdLockCdData | ( | ) |
Value:
◆ CdLockFcb
Value:
{ \
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 ); \
} \
(F)->FcbLockCount += 1; \
}
Definition: nsiface.idl:2307
◆ CdLockUserBuffer
Value:
{ \
} \
}
NTSTATUS CdCreateUserMdl(_In_ PIRP_CONTEXT IrpContext, _In_ ULONG BufferLength, _In_ BOOLEAN RaiseOnError, _In_ LOCK_OPERATION Operation)
Definition: deviosup.c:1221
◆ CdLockVcb
Value:
ExAcquireFastMutex( &(V)->VcbMutex ); \
(V)->VcbLockThread = PsGetCurrentThread()
◆ CdLookupInitialFileDirent
Value:
CdLookupDirent( IC, \
F, \
DO, \
&(FC)->InitialDirent->DirContext ); \
CdUpdateDirentFromRawDirent( IC, \
F, \
&(FC)->InitialDirent->DirContext, \
&(FC)->InitialDirent->Dirent )
VOID CdLookupDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _In_ ULONG DirentOffset, _Out_ PDIRENT_ENUM_CONTEXT DirContext)
Definition: dirsup.c:125
◆ CdMapUserBuffer
| #define CdMapUserBuffer | ( | IC, | |
| UB | |||
| ) |
Value:
{ \
(IC)->Irp->UserBuffer : \
(MmGetSystemAddressForMdlSafe( (IC)->Irp->MdlAddress, NormalPagePriority | MdlMappingNoExecute))); \
if (NULL == *(UB)) { \
CdRaiseStatus( (IC), STATUS_INSUFFICIENT_RESOURCES); \
} \
}
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
◆ CdMarkRealDevForVerify
◆ CdMarkRealDevVerifyOk
◆ CdNonPagedPool
◆ CdNonPagedPoolCacheAligned
| #define CdNonPagedPoolCacheAligned NonPagedPoolNxCacheAligned |
◆ CdNormalizeAndRaiseStatus
| #define CdNormalizeAndRaiseStatus | ( | IC, | |
| S | |||
| ) | CdRaiseStatusEx( (IC), (S), TRUE, BugCheckFileId, __LINE__); |
◆ CdPagedPool
◆ CdRaiseStatus
| #define CdRaiseStatus | ( | IC, | |
| S | |||
| ) | CdRaiseStatusEx( (IC), (S), FALSE, BugCheckFileId, __LINE__); |
◆ CdRealDevNeedsVerify
| #define CdRealDevNeedsVerify | ( | DO | ) | BooleanFlagOn( (DO)->Flags, DO_VERIFY_VOLUME) |
◆ CdReleaseAllFiles
| #define CdReleaseAllFiles | ( | IC, | |
| V | |||
| ) | ExReleaseResourceLite( &(V)->FileResource ) |
◆ CdReleaseCache
| #define CdReleaseCache | ( | IC | ) | ExReleaseResourceLite( &(IC)->Vcb->SectorCacheResource); |
◆ CdReleaseCdData
| #define CdReleaseCdData | ( | IC | ) | ExReleaseResourceLite( &CdData.DataResource ) |
◆ CdReleaseFcb
| #define CdReleaseFcb | ( | IC, | |
| F | |||
| ) | ExReleaseResourceLite( &(F)->FcbNonpaged->FcbResource ) |
◆ CdReleaseFile
| #define CdReleaseFile | ( | IC, | |
| F | |||
| ) | ExReleaseResourceLite( (F)->Resource ) |
◆ CdReleaseVcb
| #define CdReleaseVcb | ( | IC, | |
| V | |||
| ) | ExReleaseResourceLite( &(V)->VcbResource ) |
◆ CdRestoreThreadContext
| #define CdRestoreThreadContext | ( | IC | ) |
Value:
(IC)->ThreadContext->Cdfs = 0; \
IoSetTopLevelIrp( (IC)->ThreadContext->SavedTopLevelIrp ); \
(IC)->ThreadContext = NULL
◆ CdTelemetryMountSafe
◆ CdUnlockCdData
| #define CdUnlockCdData | ( | ) |
Value:
ExReleaseFastMutex( &CdData.CdDataMutex )
◆ CdUnlockFcb
◆ CdUnlockVcb
◆ CdUnpinData
◆ CdUpdateMediaChangeCount
◆ CdUpdateVcbCondition
◆ CopyUchar1
Value:
◆ CopyUchar2
◆ CopyUchar4
◆ CopyUshort2
◆ INLINE
◆ LlBlockAlign
◆ LlBytesFromBlocks
◆ LlBytesFromSectors
Value:
◆ LlSectorAlign
Value:
( \
)
◆ LlSectorsFromBytes
Value:
◆ LlSectorTruncate
Value:
◆ LongAlign
◆ Max
◆ Min
◆ PtrOffset
◆ QuadAlign
◆ RawSectorAlign
| #define RawSectorAlign | ( | B | ) | ((((B)+(RAW_SECTOR_SIZE - 1)) / RAW_SECTOR_SIZE) * RAW_SECTOR_SIZE) |
◆ SectorAlign
Value:
◆ SectorBlockOffset
◆ SectorOffset
Value:
( \
)
◆ SectorsFromBytes
Value:
◆ SectorTruncate
Value:
◆ SwapCopyUchar4
Value:
{ \
}
◆ TAG_CCB
◆ TAG_CDROM_TOC
◆ TAG_DIRENT_NAME
◆ TAG_ENUM_EXPRESSION
◆ TAG_FCB_DATA
◆ TAG_FCB_INDEX
◆ TAG_FCB_NONPAGED
◆ TAG_FCB_TABLE
◆ TAG_FILE_NAME
◆ TAG_GEN_SHORT_NAME
◆ TAG_IO_BUFFER
◆ TAG_IO_CONTEXT
◆ TAG_IRP_CONTEXT
◆ TAG_IRP_CONTEXT_LITE
◆ TAG_MCB_ARRAY
◆ TAG_PATH_ENTRY_NAME
◆ TAG_PREFIX_ENTRY
◆ TAG_PREFIX_NAME
◆ TAG_SPANNING_PATH_TABLE
◆ TAG_UPCASE_NAME
◆ TAG_VOL_DESC
◆ TAG_VPB
◆ try_leave
◆ try_return
◆ WordAlign
Typedef Documentation
◆ PTYPE_OF_ACQUIRE
| typedef enum _TYPE_OF_ACQUIRE * PTYPE_OF_ACQUIRE |
◆ PTYPE_OF_OPEN
| typedef TYPE_OF_OPEN* PTYPE_OF_OPEN |
◆ PUCHAR1
◆ PUCHAR2
◆ PUCHAR4
◆ PUSHORT2
◆ TYPE_OF_ACQUIRE
| typedef enum _TYPE_OF_ACQUIRE TYPE_OF_ACQUIRE |
◆ TYPE_OF_OPEN
| typedef enum _TYPE_OF_OPEN TYPE_OF_OPEN |
◆ UCHAR1
◆ UCHAR2
◆ UCHAR4
◆ USHORT2
Enumeration Type Documentation
◆ _TYPE_OF_ACQUIRE
| Enumerator | |
|---|---|
| AcquireExclusive | |
| AcquireShared | |
| AcquireSharedStarveExclusive | |
Definition at line 827 of file cdprocs.h.
827 {
828
829 AcquireExclusive,
830 AcquireShared,
832
enum _TYPE_OF_ACQUIRE * PTYPE_OF_ACQUIRE
enum _TYPE_OF_ACQUIRE TYPE_OF_ACQUIRE
◆ _TYPE_OF_OPEN
Definition at line 571 of file cdprocs.h.
571 {
572
573 UnopenedFileObject = 0,
574 StreamFileOpen,
575 UserVolumeOpen,
576 UserDirectoryOpen,
577 UserFileOpen,
578 BeyondValidType
579
580} TYPE_OF_OPEN;
enum _TYPE_OF_OPEN TYPE_OF_OPEN
Function Documentation
◆ _At_() [1/6]
| _At_ | ( | Dirent-> | CdTime, |
| _Post_notnull_ | |||
| ) |
◆ _At_() [2/6]
◆ _At_() [3/6]
◆ _At_() [4/6]
| _At_ | ( | Fcb-> | NodeByteSize, |
| _In_range_(>=, FIELD_OFFSET(FCB, FcbType)) | |||
| ) |
◆ _At_() [5/6]
| _At_ | ( | FileContext->ShortName.FileName. | MaximumLength, |
| _In_range_(>=, BYTE_COUNT_8_DOT_3) | |||
| ) |
◆ _At_() [6/6]
| _At_ | ( | IrpContext | , |
| _Pre_notnull_ | |||
| ) |
◆ _CdFreePool()
◆ _Function_class_()
| _Function_class_ | ( | FAST_IO_RELEASE_FILE | ) |
Definition at line 366 of file resrcsup.c.
391{
392 PAGED_CODE();
393
394 //
395 // Release the resources.
396 //
397
400}
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
Definition: cdstruc.h:902
◆ _Inout_updates_bytes_()
| _Inout_updates_bytes_ | ( | Fcb-> | NodeByteSize | ) |
Definition at line 631 of file allocsup.c.
654{
655 PAGED_CODE();
656
657 UNREFERENCED_PARAMETER( IrpContext );
658
659 ASSERT_IRP_CONTEXT( IrpContext );
661
662 //
663 // Set the entry counts to show there is one entry in the array and
664 // it is unused.
665 //
666
669
671
672 return;
673}
◆ _IRQL_requires_max_()
| _IRQL_requires_max_ | ( | APC_LEVEL | ) |
Definition at line 37 of file cddata.c.
254{
255 THREAD_CONTEXT ThreadContext = {0};
258
259#ifdef CD_SANITY
260 PVOID PreviousTopLevel;
261#endif
262
264
265#if DBG
266
268
269#endif
270
272
274
275 FsRtlEnterFileSystem();
276
277#ifdef CD_SANITY
278 PreviousTopLevel = IoGetTopLevelIrp();
279#endif
280
281 //
282 // Loop until this request has been completed or posted.
283 //
284
285 do {
286
287 //
288 // Use a try-except to handle the exception cases.
289 //
290
291 _SEH2_TRY {
292
293 //
294 // If the IrpContext is NULL then this is the first pass through
295 // this loop.
296 //
297
299
300 //
301 // Decide if this request is waitable an allocate the IrpContext.
302 // If the file object in the stack location is NULL then this
303 // is a mount which is always waitable. Otherwise we look at
304 // the file object flags.
305 //
306
308
310
311 } else {
312
314 }
315
317
318 //
319 // Update the thread context information.
320 //
321
322 CdSetThreadContext( IrpContext, &ThreadContext );
323
324#ifdef CD_SANITY
325 NT_ASSERT( !CdTestTopLevel ||
327#endif
328
329 //
330 // Otherwise cleanup the IrpContext for the retry.
331 //
332
333 } else {
334
335 //
336 // Set the MORE_PROCESSING flag to make sure the IrpContext
337 // isn't inadvertently deleted here. Then cleanup the
338 // IrpContext to perform the retry.
339 //
340
343 }
344
345 //
346 // Case on the major irp code.
347 //
348
349 switch (IrpContext->MajorFunction) {
350
352
354 break;
355
357
359 break;
360
362
363 //
364 // If this is an Mdl complete request, don't go through
365 // common read.
366 //
367
369
371
372 } else {
373
375 }
376
377 break;
378
380
382 break;
383
385
387 break;
388
390
392 break;
393
395
397 break;
398
400
402 break;
403
405
407 break;
408
410
412 break;
413
415
417 break;
418
420
422 break;
423
425
427 break;
428
430
432 break;
433
434 default :
435
438 }
439
441
443 } _SEH2_END;
444
446
447#ifdef CD_SANITY
448 NT_ASSERT( !CdTestTopLevel ||
449 (PreviousTopLevel == IoGetTopLevelIrp()) );
450#endif
451
452 FsRtlExitFileSystem();
453
455
457}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:150
VOID CdCompleteRequest(_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
Definition: cddata.c:914
LONG CdExceptionFilter(_Inout_ PIRP_CONTEXT IrpContext, _In_ PEXCEPTION_POINTERS ExceptionPointer)
Definition: cddata.c:525
VOID CdSetThreadContext(_Inout_ PIRP_CONTEXT IrpContext, _In_ PTHREAD_CONTEXT ThreadContext)
Definition: cddata.c:981
NTSTATUS CdCompleteMdl(_In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
Definition: cachesup.c:411
VOID CdCleanupIrpContext(_In_ PIRP_CONTEXT IrpContext, _In_ BOOLEAN Post)
Definition: strucsup.c:1733
NTSTATUS CdCommonLockControl(_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
Definition: lockctrl.c:35
NTSTATUS CdCommonDevControl(_Inout_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp)
Definition: devctrl.c:46
_Ret_valid_ PIRP_CONTEXT CdCreateIrpContext(_In_ PIRP Irp, _In_ BOOLEAN Wait)
Definition: strucsup.c:1573
#define FsRtlEnterFileSystem
#define FsRtlExitFileSystem
Definition: usbstor.h:98
Definition: cdstruc.h:1363
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_MJ_SHUTDOWN
#define IRP_MJ_CLEANUP
◆ _Post_satisfies_()
| _Post_satisfies_ | ( | _Old_(CdName->FileName.Length) >=CdName->FileName.Length+CdName->VersionString. | Length | ) |
◆ _Requires_lock_held_()
| _Requires_lock_held_ | ( | _Global_critical_region_ | ) |
◆ _Success_()
Initial value:
BOOL WINAPI SetupDiGetDeviceRegistryPropertyA(HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, DWORD Property, PDWORD PropertyRegDataType, PBYTE PropertyBuffer, DWORD PropertyBufferSize, PDWORD RequiredSize)
Definition: devinst.c:3139
_In_ DWORD _Out_opt_ PDWORD _In_ DWORD PropertyBufferSize
Definition: setupapi.h:1553
Definition: setupapi_private.h:191
Definition: reader.h:120
Definition: setupapi.h:834
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID PropertyBuffer
Definition: wdfdevice.h:4437
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4439
Definition at line 3139 of file fsctrl.c.
3189{
3191
3193 PVPB OldVpb;
3194
3196
3197 PAGED_CODE();
3198
3199 UNREFERENCED_PARAMETER( IrpContext );
3200
3201 //
3202 // Check whether we are looking for a device only Mvcb.
3203 //
3204
3208
3210
3211 //
3212 // Skip ourselves.
3213 //
3214
3216
3217 //
3218 // Look at the Vpb and state of the previous Vcb.
3219 //
3220
3221 OldVpb = (*OldVcb)->Vpb;
3222
3225 ((*OldVcb)->VcbCondition == VcbNotMounted)) {
3226
3227 //
3228 // If the current disk is a raw disk then it can match a previous music or
3229 // raw disk.
3230 //
3231
3233
3235
3236 //
3237 // If we have both TOC then fail the remount if the lengths
3238 // are different or they don't match.
3239 //
3240
3242 ((Vcb->TocLength != 0) &&
3244 (*OldVcb)->CdromToc,
3245 Vcb->TocLength ))) {
3246
3247 continue;
3248 }
3249
3250 Remount = TRUE;
3251 break;
3252 }
3253
3254 //
3255 // The current disk is not a raw disk. Go ahead and compare
3256 // serial numbers, volume label and TOC.
3257 //
3258
3259 }
3261 (Vcb->TocLength == (*OldVcb)->TocLength) &&
3263 (*OldVcb)->CdromToc,
3264 Vcb->TocLength )) &&
3267 Vpb->VolumeLabel,
3268 Vpb->VolumeLabelLength ))) {
3269 //
3270 // Remember the old Vcb. Then set the return value to
3271 // TRUE and break.
3272 //
3273
3274 Remount = TRUE;
3275 break;
3276 }
3277 }
3278 }
3279
3280 return Remount;
3281}
Definition: typedefs.h:120
Definition: cdstruc.h:498
Definition: iotypes.h:189
WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH/sizeof(WCHAR)]
Definition: iotypes.h:198
◆ _When_() [1/6]
| _Acquires_exclusive_lock_ Resource _Acquires_shared_lock_ Resource _When_ | ( | IgnoreWait | = = FALSE, |
| _Post_satisfies_(return==TRUE) | |||
| ) |
◆ _When_() [2/6]
| _When_ | ( | RaiseOnError|| | return, |
| _At_(Fcb->FileLock, _Post_notnull_) | |||
| ) |
◆ _When_() [3/6]
◆ _When_() [4/6]
| _When_ | ( | return | = = UnopenedFileObject, |
| _At_ *, | _Post_null_ | ||
| ) |
◆ _When_() [5/6]
| _Acquires_exclusive_lock_ Resource _When_ | ( | Type | = = AcquireShared && return != FALSE, |
| _Acquires_shared_lock_ * | Resource | ||
| ) |
◆ _When_() [6/6]
| _When_ | ( | TypeOfOpen | = = UnopenedFileObject, |
| _At_(Fcb, _In_opt_) | |||
| ) |
◆ CdAcquireForCache()
Referenced by CdInitializeGlobalData().
◆ CdAddAllocationFromDirent()
| VOID CdAddAllocationFromDirent | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PFCB | Fcb, | ||
| _In_ ULONG | McbEntryOffset, | ||
| _In_ LONGLONG | StartingFileOffset, | ||
| _In_ PDIRENT | Dirent | ||
| ) |
Definition at line 335 of file allocsup.c.
368{
369 ULONG NewArraySize;
370 PVOID NewMcbArray;
371 PCD_MCB_ENTRY McbEntry;
372
373 PAGED_CODE();
374
375 UNREFERENCED_PARAMETER( IrpContext );
376
377 ASSERT_IRP_CONTEXT( IrpContext );
380
381 //
382 // If we need to grow the Mcb then do it now.
383 //
384
386
387 //
388 // Allocate a new buffer and copy the old data over.
389 //
390
392
394 NewArraySize,
395 TAG_MCB_ARRAY );
396
397 RtlZeroMemory( NewMcbArray, NewArraySize );
398 RtlCopyMemory( NewMcbArray,
401
402 //
403 // Deallocate the current array unless it is embedded in the Fcb.
404 //
405
407
409 }
410
411 //
412 // Now update the Mcb with the new array.
413 //
414
417 }
418
419 //
420 // Update the new entry with the input data.
421 //
422
424
425 //
426 // Start with the location and length on disk.
427 //
428
431
432 //
433 // Round the byte count up to a logical block boundary if this is
434 // the last extent.
435 //
436
438
440 }
441
442 //
443 // The file offset is the logical position within this file.
444 // We know this is correct regardless of whether we bias the
445 // file size or disk offset.
446 //
447
448 McbEntry->FileOffset = StartingFileOffset;
449
450 //
451 // Convert the interleave information from logical blocks to
452 // bytes.
453 //
454
456
460
461 //
462 // If the file is not interleaved then the size of the data block
463 // and total block are the same as the byte count.
464 //
465
466 } else {
467
468 McbEntry->DataBlockByteCount =
470 }
471
472 //
473 // Update the number of entries in the Mcb. The Mcb is never sparse
474 // so whenever we add an entry it becomes the last entry in the Mcb.
475 //
476
478
479 return;
480}
struct _CD_MCB_ENTRY CD_MCB_ENTRY
Definition: cdstruc.h:200
Referenced by _Requires_lock_held_(), and CdInitializeFcbFromFileContext().
◆ CdAddInitialAllocation()
| VOID CdAddInitialAllocation | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PFCB | Fcb, | ||
| _In_ ULONG | StartingBlock, | ||
| _In_ LONGLONG | DataLength | ||
| ) |
Definition at line 484 of file allocsup.c.
519{
520 PCD_MCB_ENTRY McbEntry;
521
522 PAGED_CODE();
523
524 UNREFERENCED_PARAMETER( IrpContext );
525
526 ASSERT_IRP_CONTEXT( IrpContext );
531
532 //
533 // Update the new entry with the input data.
534 //
535
537
538 //
539 // Start with the location and length on disk.
540 //
541
544
546
547 //
548 // The file offset is the logical position within this file.
549 // We know this is correct regardless of whether we bias the
550 // file size or disk offset.
551 //
552
553 McbEntry->FileOffset = 0;
554
555 //
556 // If the file is not interleaved then the size of the data block
557 // and total block are the same as the byte count.
558 //
559
560 McbEntry->DataBlockByteCount =
562
563 //
564 // Update the number of entries in the Mcb. The Mcb is never sparse
565 // so whenever we add an entry it becomes the last entry in the Mcb.
566 //
567
569
570 return;
571}
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID _In_ size_t _In_ PVOID _In_ size_t _Out_ size_t * DataLength
Definition: cdrom.h:1444
Referenced by CdCreateInternalStream(), CdInitializeFcbFromPathEntry(), and CdUpdateVcbFromVolDescriptor().
◆ CdCleanupFileContext()
| VOID CdCleanupFileContext | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ PFILE_ENUM_CONTEXT | FileContext | ||
| ) |
Definition at line 1636 of file dirsup.c.
1659{
1660 PCOMPOUND_DIRENT CurrentCompoundDirent;
1662
1663 PAGED_CODE();
1664
1665 UNREFERENCED_PARAMETER( IrpContext );
1666
1667 //
1668 // Cleanup the individual compound dirents.
1669 //
1670
1671 do {
1672
1676
1678
1679 return;
1680}
PAGED_CODE()
_In_ PFCB _In_ PCD_NAME _In_ BOOLEAN _In_ ULONG _Inout_ PFILE_ENUM_CONTEXT FileContext
Definition: dirsup.c:1148
Definition: cdstruc.h:1681
Referenced by _Requires_lock_held_(), and CdInitializeEnumeration().
◆ CdCleanupIrpContext()
| VOID CdCleanupIrpContext | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ BOOLEAN | Post | ||
| ) |
Definition at line 1733 of file strucsup.c.
1757{
1758 PAGED_CODE();
1759
1760 //
1761 // If we aren't doing more processing then deallocate this as appropriate.
1762 //
1763
1765
1766 //
1767 // If this context is the top level CDFS context then we need to
1768 // restore the top level thread context.
1769 //
1770
1772
1773 CdRestoreThreadContext( IrpContext );
1774 }
1775
1776 //
1777 // Deallocate the Io context if allocated.
1778 //
1779
1781
1782 CdFreeIoContext( IrpContext->IoContext );
1783 }
1784
1785 //
1786 // Deallocate the IrpContext if not from the stack.
1787 //
1788
1790
1792
1793 CdLockCdData();
1794
1797
1798 CdUnlockCdData();
1799
1800 } else {
1801
1802 //
1803 // We couldn't add this to our lookaside list so free it to
1804 // pool.
1805 //
1806
1807 CdFreePool( &IrpContext );
1808 }
1809 }
1810
1811 //
1812 // Clear the appropriate flags.
1813 //
1814
1815 } else if (Post) {
1816
1817 //
1818 // If this context is the top level CDFS context then we need to
1819 // restore the top level thread context.
1820 //
1821
1823
1824 CdRestoreThreadContext( IrpContext );
1825 }
1826
1828
1829 } else {
1830
1832 }
1833
1834 return;
1835}
Definition: ntbasedef.h:628
FORCEINLINE VOID PushEntryList(_Inout_ PSINGLE_LIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)
Definition: rtlfuncs.h:253
Referenced by _IRQL_requires_max_(), CdCompleteRequest(), CdFspDispatch(), and CdQueueClose().
◆ CdCommonDevControl()
| NTSTATUS CdCommonDevControl | ( | _Inout_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PIRP | Irp | ||
| ) |
Definition at line 46 of file devctrl.c.
61{
63
67
69 PIO_STACK_LOCATION NextIrpSp;
70
71 PAGED_CODE();
72
73 //
74 // Extract and decode the file object.
75 //
76
78
79 TypeOfOpen = CdDecodeFileObject( IrpContext,
81 &Fcb,
82 &Ccb );
83
84 //
85 // The only type of opens we accept are user volume opens.
86 //
87
89
92 }
93
95
96 //
97 // Verify the Vcb in this case to detect if the volume has changed.
98 //
99
101
102 //
103 // Handle the case of the disk type ourselves.
104 //
105
107
108 //
109 // Verify the Vcb in this case to detect if the volume has changed.
110 //
111
113
114 //
115 // Check the size of the output buffer.
116 //
117
119
122 }
123
124 //
125 // Copy the data from the Vcb.
126 //
127
129
133 }
134
135 //
136 // Get the next stack location, and copy over the stack parameter
137 // information.
138 //
139
141
142 *NextIrpSp = *IrpSp;
143
144 //
145 // Set up the completion routine
146 //
147
150 NULL,
151 TRUE,
152 TRUE,
153 TRUE );
154
155 //
156 // Send the request.
157 //
158
160
161 //
162 // Cleanup our Irp Context. The driver has completed the Irp.
163 //
164
166
168}
VOID CdVerifyVcb(_In_ PIRP_CONTEXT IrpContext, _Inout_ PVCB Vcb)
Definition: verfysup.c:411
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
struct _CDROM_DISK_DATA * PCDROM_DISK_DATA
struct _CDROM_DISK_DATA CDROM_DISK_DATA
Definition: cdstruc.h:1067
Definition: ntddcdrm.h:148
Definition: Bus_PDO_EvalMethod.c:93
struct _IO_STACK_LOCATION::@1575::@1576 DeviceIoControl
union _IO_STACK_LOCATION::@1575 Parameters
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
Referenced by _IRQL_requires_max_(), and CdFspDispatch().
◆ CdCommonLockControl()
| NTSTATUS CdCommonLockControl | ( | _Inout_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PIRP | Irp | ||
| ) |
Definition at line 35 of file lockctrl.c.
57{
60
64
65 PAGED_CODE();
66
67 //
68 // Extract and decode the type of file object we're being asked to process
69 //
70
72
73 //
74 // If the file is not a user file open then we reject the request
75 // as an invalid parameter
76 //
77
79
82 }
83
84 //
85 // We check whether we can proceed based on the state of the file oplocks.
86 // This call might post the irp for us.
87 //
88
90 Irp,
91 IrpContext,
93 NULL );
94
95 //
96 // If we don't get success then the oplock package completed the request.
97 //
98
100
102 }
103
104 //
105 // Verify the Fcb.
106 //
107
109
110 //
111 // If we don't have a file lock, then get one now.
112 //
113
115
116 //
117 // Now call the FsRtl routine to do the actual processing of the
118 // Lock request
119 //
120
122
123 //
124 // Set the flag indicating if Fast I/O is possible
125 //
126
130
131 //
132 // Complete the request.
133 //
134
137}
BOOLEAN CdVerifyFcbOperation(_In_opt_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb)
Definition: verfysup.c:615
NTSTATUS NTAPI FsRtlProcessFileLock(IN PFILE_LOCK FileLock, IN PIRP Irp, IN PVOID Context OPTIONAL)
Definition: filelock.c:1152
NTSTATUS NTAPI FsRtlCheckOplock(IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
Definition: oplock.c:1170
Referenced by _IRQL_requires_max_(), and CdFspDispatch().
◆ CdCompleteMdl()
| NTSTATUS CdCompleteMdl | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PIRP | Irp | ||
| ) |
Definition at line 411 of file cachesup.c.
433{
435
436 PAGED_CODE();
437
438 //
439 // Do completion processing.
440 //
441
443
445
446 //
447 // Mdl is now deallocated.
448 //
449
451
452 //
453 // Complete the request and exit right away.
454 //
455
457
459}
VOID NTAPI CcMdlReadComplete(IN PFILE_OBJECT FileObject, IN PMDL MdlChain)
Definition: mdlsup.c:75
Referenced by _IRQL_requires_max_().
◆ CdCompleteRequest()
| VOID CdCompleteRequest | ( | _Inout_opt_ PIRP_CONTEXT | IrpContext, |
| _Inout_opt_ PIRP | Irp, | ||
| _In_ NTSTATUS | Status | ||
| ) |
Definition at line 914 of file cddata.c.
939{
940 ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
942
943 //
944 // Cleanup the IrpContext if passed in here.
945 //
946
948
950 }
951
952 //
953 // If we have an Irp then complete the irp.
954 //
955
957
958 //
959 // Clear the information field in case we have used this Irp
960 // internally.
961 //
962
965
966 Irp->IoStatus.Information = 0;
967 }
968
970
972
974 }
975
976 return;
977}
#define ARGUMENT_PRESENT(ArgumentPointer)
#define IRP_INPUT_OPERATION
Referenced by _IRQL_requires_max_(), _Requires_lock_held_(), _Success_(), CdAllowExtendedDasdIo(), CdCommonDevControl(), CdCommonLockControl(), CdCompleteMdl(), CdFspDispatch(), CdIsPathnameValid(), CdIsVolumeDirty(), CdIsVolumeMounted(), and CdQueueClose().
◆ CdConvertBigToLittleEndian()
| VOID CdConvertBigToLittleEndian | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_reads_bytes_(ByteCount) PCHAR | BigEndian, | ||
| _In_ ULONG | ByteCount, | ||
| _Out_writes_bytes_(ByteCount) PCHAR | LittleEndian | ||
| ) |
Definition at line 110 of file namesup.c.
140{
142
145
146 PAGED_CODE();
147
148 //
149 // If the byte count isn't an even number then the disk is corrupt.
150 //
151
153
155 }
156
157 //
158 // Start by copy the low-order bytes into the correct position. Do
159 // this by skipping the first byte in the BigEndian string.
160 //
161
163 Source + 1,
164 RemainingByteCount - 1 );
165
166 //
167 // Now move the high-order bytes into position.
168 //
169
170 Destination += 1;
171
172 while (RemainingByteCount != 0) {
173
174#ifdef _MSC_VER
175#pragma prefast(push)
176#pragma prefast(suppress:26014, "RemainingByteCount is even")
177#endif
179#ifdef _MSC_VER
180#pragma prefast(pop)
181#endif
182
183 Source += 2;
184 Destination += 2;
185
186 RemainingByteCount -= 2;
187 }
188
189 return;
190}
PAGED_CODE()
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _In_ LARGE_INTEGER ByteCount
Definition: iotypes.h:1099
Referenced by CdFindActiveVolDescriptor(), CdUpdateDirentName(), and CdUpdatePathEntryName().
◆ CdCreateCcb()
Definition at line 1405 of file strucsup.c.
1429{
1430 PCCB NewCcb;
1431 PAGED_CODE();
1432
1433 UNREFERENCED_PARAMETER( IrpContext );
1434
1435 //
1436 // Allocate and initialize the structure.
1437 //
1438
1439 NewCcb = CdAllocateCcb( IrpContext );
1440
1442
1443 //
1444 // Set the proper node type code and node byte size
1445 //
1446
1449
1450 //
1451 // Set the initial value for the flags and Fcb
1452 //
1453
1456
1457 return NewCcb;
1458}
struct _CCB CCB
◆ CdCreateFcb()
| PFCB CdCreateFcb | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ FILE_ID | FileId, | ||
| _In_ NODE_TYPE_CODE | NodeTypeCode, | ||
| _Out_opt_ PBOOLEAN | FcbExisted | ||
| ) |
Definition at line 986 of file strucsup.c.
1018{
1019 PFCB NewFcb;
1020 BOOLEAN LocalFcbExisted;
1021
1022 PAGED_CODE();
1023
1024 //
1025 // Use the local boolean if one was not passed in.
1026 //
1027
1029
1030 FcbExisted = &LocalFcbExisted;
1031 }
1032
1033 //
1034 // Maybe this is already in the table.
1035 //
1036
1037 NewFcb = CdLookupFcbTable( IrpContext, IrpContext->Vcb, FileId );
1038
1039 //
1040 // If not then create the Fcb is requested by our caller.
1041 //
1042
1044
1045 //
1046 // Allocate and initialize the structure depending on the
1047 // type code.
1048 //
1049
1050 switch (NodeTypeCode) {
1051
1054
1055 NewFcb = CdAllocateFcbIndex( IrpContext );
1056
1058
1059 NewFcb->NodeByteSize = SIZEOF_FCB_INDEX;
1060
1061 InitializeListHead( &NewFcb->FcbQueue );
1062
1063 break;
1064
1066
1067 NewFcb = CdAllocateFcbData( IrpContext );
1068
1070
1071 NewFcb->NodeByteSize = SIZEOF_FCB_DATA;
1072
1073 break;
1074
1075 default:
1076
1077#ifdef _MSC_VER
1078#pragma prefast( suppress: __WARNING_USE_OTHER_FUNCTION, "This is a bug." )
1079#endif
1080 CdBugCheck( 0, 0, 0 );
1081 }
1082
1083 //
1084 // Now do the common initialization.
1085 //
1086
1087 NewFcb->NodeTypeCode = NodeTypeCode;
1088
1089 NewFcb->Vcb = IrpContext->Vcb;
1090 NewFcb->FileId = FileId;
1091
1092 CdInitializeMcb( IrpContext, NewFcb );
1093
1094 //
1095 // Now create the non-paged section object.
1096 //
1097
1099
1100 //
1101 // Deallocate the Fcb and raise if the allocation failed.
1102 //
1103
1105
1106 CdFreePool( &NewFcb );
1107
1109 }
1110
1111 *FcbExisted = FALSE;
1112
1113 //
1114 // Initialize Advanced FCB Header fields
1115 //
1116
1118 FsRtlSetupAdvancedHeader( &NewFcb->Header,
1120
1122
1124 }
1125
1126 } else {
1127
1128 *FcbExisted = TRUE;
1129 }
1130
1131 return NewFcb;
1132}
PFCB_NONPAGED CdCreateFcbNonpaged(_In_ PIRP_CONTEXT IrpContext)
Definition: strucsup.c:2555
PFCB CdLookupFcbTable(_In_ PIRP_CONTEXT IrpContext, _In_ PVCB Vcb, _In_ FILE_ID FileId)
Definition: strucsup.c:2107
VOID NTAPI FsRtlInitializeOplock(IN OUT POPLOCK Oplock)
Definition: oplock.c:1400
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
Referenced by _Requires_lock_held_(), and CdUpdateVcbFromVolDescriptor().
◆ CdCreateInternalStream()
| VOID CdCreateInternalStream | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ PVCB | Vcb, | ||
| _Inout_ PFCB | Fcb, | ||
| _In_ PUNICODE_STRING | Name | ||
| ) |
Definition at line 38 of file cachesup.c.
66{
69
72
75
76 PAGED_CODE();
77
78 ASSERT_IRP_CONTEXT( IrpContext );
80
81 //
82 // We may only have the Fcb shared. Lock the Fcb and do a
83 // safe test to see if we need to really create the file object.
84 //
85
87
89
91 return;
92 }
93
94 //
95 // Use a try-finally to facilitate cleanup.
96 //
97
98 _SEH2_TRY {
99
100 //
101 // Create the internal stream. The Vpb should be pointing at our volume
102 // device object at this point.
103 //
104
106
108
110 }
111
112 //
113 // Initialize the fields of the file object.
114 //
115
116 StreamFile->ReadAccess = TRUE;
117 StreamFile->WriteAccess = FALSE;
118 StreamFile->DeleteAccess = FALSE;
119
121
122 //
123 // Set the file object type and increment the Vcb counts.
124 //
125
126 CdSetFileObject( IrpContext,
127 StreamFile,
128 StreamFileOpen,
129 Fcb,
130 NULL );
131
132 //
133 // We'll give stream file objects a name to aid IO profiling etc. We
134 // NULL this in CdDeleteInternalStream before OB deletes the file object,
135 // and before CdRemovePrefix is called (which frees Fcb names).
136 //
137
138 StreamFile->FileName = *Name;
139
140 //
141 // We will reference the current Fcb twice to keep it from going
142 // away in the error path. Otherwise if we dereference it
143 // below in the finally clause a close could cause the Fcb to
144 // be deallocated.
145 //
146
150 DecrementReference = TRUE;
151
152 //
153 // Initialize the cache map for the file.
154 //
155
156 CcInitializeCacheMap( StreamFile,
158 TRUE,
160 Fcb );
161
162 //
163 // Go ahead and store the stream file into the Fcb.
164 //
165
167 StreamFile = NULL;
168
169 //
170 // If this is the first file object for a directory then we need to
171 // read the self entry for this directory and update the sizes
172 // in the Fcb. We know that the Fcb has been initialized so
173 // that we have a least one sector available to read.
174 //
175
177
178 ULONG NewDataLength;
179
180 //
181 // Initialize the search structures.
182 //
183
186 CleanupDirContext = TRUE;
187
188 //
189 // Read the dirent from disk and transfer the data to the
190 // in-memory dirent.
191 //
192
193 CdLookupDirent( IrpContext,
194 Fcb,
195 Fcb->StreamOffset,
196 &DirContext );
197
199
200 //
201 // Verify that this really for the self entry. We do this by
202 // updating the name in the dirent and then checking that it matches
203 // one of the hard coded names.
204 //
205
207
209
211 }
212
213 //
214 // If the data sizes are different then update the header
215 // and Mcb for this Fcb.
216 //
217
219
220 if (NewDataLength == 0) {
221
223 }
224
226
227 Fcb->AllocationSize.QuadPart =
228 Fcb->FileSize.QuadPart =
229 Fcb->ValidDataLength.QuadPart = NewDataLength;
230
232
234 CdAddInitialAllocation( IrpContext,
235 Fcb,
236 Dirent.StartingOffset,
237 NewDataLength );
238
239 UpdateFcbSizes = TRUE;
240 }
241
242 //
243 // Check for the existence flag and transform to hidden.
244 //
245
247
249 }
250
251 //
252 // Convert the time to NT time.
253 //
254
255 CdConvertCdTimeToNtTime( IrpContext,
256 Dirent.CdTime,
258
259 //
260 // Update the Fcb flags to indicate we have read the
261 // self entry.
262 //
263
265
266 //
267 // If we updated the sizes then we want to purge the file. Go
268 // ahead and unpin and then purge the first page.
269 //
270
273 CleanupDirContext = FALSE;
274
275 if (UpdateFcbSizes) {
276
278 NULL,
279 0,
280 FALSE );
281 }
282 }
283
284 } _SEH2_FINALLY {
285
286 //
287 // Cleanup any dirent structures we may have used.
288 //
289
290 if (CleanupDirContext) {
291
294 }
295
296 //
297 // If we raised then we need to dereference the file object.
298 //
299
301
302 //
303 // Null the name pointer, since the stream file object never actually
304 // 'owns' the names, we just point it to existing ones.
305 //
306
307 StreamFile->FileName.Buffer = NULL;
308 StreamFile->FileName.MaximumLength = StreamFile->FileName.Length = 0;
309
310 ObDereferenceObject( StreamFile );
312 }
313
314 //
315 // Dereference and unlock the Fcb.
316 //
317
318 if (DecrementReference) {
319
323 }
324
326 } _SEH2_END;
327
328 return;
329}
VOID CdTruncateAllocation(_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ LONGLONG StartingFileOffset)
Definition: allocsup.c:575
VOID CdAddInitialAllocation(_In_ PIRP_CONTEXT IrpContext, _Inout_ PFCB Fcb, _In_ ULONG StartingBlock, _In_ LONGLONG DataLength)
Definition: allocsup.c:484
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
#define CdDecrementReferenceCounts(IC, F, C, UC)
Definition: cdprocs.h:1325
#define CdIncrementReferenceCounts(IC, F, C, UC)
Definition: cdprocs.h:1317
VOID NTAPI CcSetFileSizes(IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes)
Definition: fssup.c:356
VOID NTAPI CcInitializeCacheMap(IN PFILE_OBJECT FileObject, IN PCC_FILE_SIZES FileSizes, IN BOOLEAN PinAccess, IN PCACHE_MANAGER_CALLBACKS Callbacks, IN PVOID LazyWriteContext)
Definition: fssup.c:195
BOOLEAN NTAPI CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
Definition: fssup.c:386
PFILE_OBJECT NTAPI IoCreateStreamFileObjectLite(IN PFILE_OBJECT FileObject OPTIONAL, IN PDEVICE_OBJECT DeviceObject OPTIONAL)
Definition: file.c:3199
Definition: cctypes.h:14
CACHE_MANAGER_CALLBACKS CacheManagerCallbacks
Definition: cdstruc.h:409
Definition: cdstruc.h:1539
Definition: cdstruc.h:1577
Definition: typedefs.h:103
Referenced by CdUpdateVcbFromVolDescriptor(), and CdVerifyOrCreateDirStreamFile().
◆ CdCreateIrpContext()
| _Ret_valid_ PIRP_CONTEXT CdCreateIrpContext | ( | _In_ PIRP | Irp, |
| _In_ BOOLEAN | Wait | ||
| ) |
Definition at line 1573 of file strucsup.c.
1598{
1601
1602 PAGED_CODE();
1603
1604 //
1605 // The only operations a filesystem device object should ever receive
1606 // are create/teardown of fsdo handles and operations which do not
1607 // occur in the context of fileobjects (i.e., mount).
1608 //
1609
1610#ifndef __REACTOS__
1612#else
1615#endif
1616
1621
1623 }
1624
1626
1630
1633
1635 }
1636
1637 //
1638 // Look in our lookaside list for an IrpContext.
1639 //
1640
1642
1643 CdLockCdData();
1646
1648 }
1649
1650 CdUnlockCdData();
1651 }
1652
1654
1655 //
1656 // We didn't get it from our private list so allocate it from pool.
1657 //
1658
1659 NewIrpContext = FsRtlAllocatePoolWithTag( CdNonPagedPool, sizeof( IRP_CONTEXT ), TAG_IRP_CONTEXT );
1660 }
1661
1663
1664 //
1665 // Set the proper node type code and node byte size
1666 //
1667
1668 NewIrpContext->NodeTypeCode = CDFS_NTC_IRP_CONTEXT;
1670
1671 //
1672 // Set the originating Irp field
1673 //
1674
1676
1677 //
1678 // Copy RealDevice for workque algorithms. We will update this in the Mount or
1679 // Verify since they have no file objects to use here.
1680 //
1681
1683
1685 }
1686
1687 //
1688 // Locate the volume device object and Vcb that we are trying to access.
1689 // This may be our filesystem device object. In that case don't initialize
1690 // the Vcb field.
1691 //
1692
1693#ifndef __REACTOS__
1695#else
1698#endif
1699
1701
1702 }
1703
1704 //
1705 // Major/Minor Function codes
1706 //
1707
1710
1711 //
1712 // Set the wait parameter
1713 //
1714
1716
1718
1719 } else {
1720
1722 }
1723
1724 //
1725 // return and tell the caller
1726 //
1727
1728 return NewIrpContext;
1729}
struct _IO_STACK_LOCATION::@3974::@3989 FileSystemControl
FORCEINLINE PSINGLE_LIST_ENTRY PopEntryList(_Inout_ PSINGLE_LIST_ENTRY ListHead)
Definition: rtlfuncs.h:240
Referenced by _IRQL_requires_max_().
◆ CdCreateUserMdl()
| NTSTATUS CdCreateUserMdl | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ ULONG | BufferLength, | ||
| _In_ BOOLEAN | RaiseOnError, | ||
| _In_ LOCK_OPERATION | Operation | ||
| ) |
Definition at line 1221 of file deviosup.c.
1255{
1258
1259 PAGED_CODE();
1260
1262 UNREFERENCED_PARAMETER( IrpContext );
1263
1264 ASSERT_IRP_CONTEXT( IrpContext );
1265 ASSERT_IRP( IrpContext->Irp );
1267
1268 //
1269 // Allocate the Mdl, and Raise if we fail.
1270 //
1271
1273 BufferLength,
1274 FALSE,
1275 FALSE,
1276 IrpContext->Irp );
1277
1279
1280 //
1281 // Now probe the buffer described by the Irp. If we get an exception,
1282 // deallocate the Mdl and return the appropriate "expected" status.
1283 //
1284
1285 _SEH2_TRY {
1286
1288
1290
1291#ifdef _MSC_VER
1292#pragma warning(suppress: 6320)
1293#endif
1295
1297
1299 IrpContext->Irp->MdlAddress = NULL;
1300
1302
1304 }
1305 } _SEH2_END;
1306 }
1307
1308 //
1309 // Check if we are to raise or return
1310 //
1311
1313
1315
1317 }
1318 }
1319
1320 //
1321 // Return the status code.
1322 //
1323
1325}
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:931
BOOLEAN NTAPI FsRtlIsNtstatusExpected(IN NTSTATUS NtStatus)
Definition: filter.c:61
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
◆ CdDeleteCcb()
| VOID CdDeleteCcb | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ __drv_freesMem(Pool) PCCB | Ccb | ||
| ) |
Definition at line 1462 of file strucsup.c.
1482{
1483 PAGED_CODE();
1484
1485 UNREFERENCED_PARAMETER( IrpContext );
1486
1488
1490 }
1491
1493 return;
1494}
◆ CdDeleteFileLock()
| VOID CdDeleteFileLock | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PFILE_LOCK | FileLock | ||
| ) |
◆ CdDeleteInternalStream()
| VOID CdDeleteInternalStream | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PFCB | Fcb | ||
| ) |
Definition at line 333 of file cachesup.c.
357{
359
360 PAGED_CODE();
361
362 UNREFERENCED_PARAMETER( IrpContext );
363
364 ASSERT_IRP_CONTEXT( IrpContext );
366
367 //
368 // Lock the Fcb.
369 //
370
372
373 //
374 // Capture the file object.
375 //
376
379
380 //
381 // It is now safe to unlock the Fcb.
382 //
383
385
386 //
387 // Dereference the file object if present.
388 //
389
391
393
395 }
396
397 //
398 // Null the name pointer, since the stream file object never actually
399 // 'owns' the names, we just point it to existing ones.
400 //
401
404
406 }
407}
BOOLEAN NTAPI CcUninitializeCacheMap(IN PFILE_OBJECT FileObject, IN OPTIONAL PLARGE_INTEGER TruncateSize, IN OPTIONAL PCACHE_UNINITIALIZE_EVENT UninitializeEvent)
Definition: fssup.c:286
Referenced by _Requires_lock_held_().
◆ CdDeleteVcb()
| VOID CdDeleteVcb | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PVCB | Vcb | ||
| ) |
Definition at line 876 of file strucsup.c.
899{
900 PAGED_CODE();
901
904
905 UNREFERENCED_PARAMETER( IrpContext );
906
907 //
908 // Chuck the backpocket Vpb we kept just in case.
909 //
910
912
913 //
914 // If there is a Vpb then we must delete it ourselves.
915 //
916
918
919 //
920 // Dereference our target if we haven't already done so.
921 //
922
924
926 }
927
928 //
929 // Delete the XA Sector and sector cache buffer if allocated.
930 //
931
934
936
939
941 }
942
943 //
944 // Remove this entry from the global queue.
945 //
946
948
949 //
950 // Delete the Vcb and File resources.
951 //
952
955
956 //
957 // Delete the TOC if present.
958 //
959
961
962 //
963 // Uninitialize the notify structures.
964 //
965
967
969 }
970
971 //
972 // Now delete the volume device object.
973 //
974#ifdef _MSC_VER
975#pragma prefast( suppress: __WARNING_BUFFER_UNDERFLOW, "This is ok, the Vcb is embedded in our volume device object, and that is what we are really deleting." )
976#endif
978 VOLUME_DEVICE_OBJECT,
979 Vcb ));
980
981 return;
982}
VOID NTAPI FsRtlNotifyUninitializeSync(IN PNOTIFY_SYNC *NotifySync)
Definition: notify.c:1668
Definition: env_spec_w32.h:413
Definition: cdstruc.h:727
◆ CdDissectName()
| VOID CdDissectName | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PUNICODE_STRING | RemainingName, | ||
| _Out_ PUNICODE_STRING | FinalName | ||
| ) |
Definition at line 301 of file namesup.c.
327{
328 ULONG NameLength;
329 PWCHAR NextWchar;
330
331 PAGED_CODE();
332
333 UNREFERENCED_PARAMETER( IrpContext );
334
335 //
336 // Find the offset of the next component separators.
337 //
338
342
343 //
344 // Adjust all the strings by this amount.
345 //
346
347 FinalName->Buffer = RemainingName->Buffer;
348
349 FinalName->MaximumLength = FinalName->Length = (USHORT) NameLength;
350
351 //
352 // If this is the last component then set the RemainingName lengths to zero.
353 //
354
356
357 RemainingName->Length = 0;
358
359 //
360 // Otherwise we adjust the string by this amount plus the separating character.
361 //
362
363 } else {
364
369 PWCHAR );
370 }
371
372 return;
373}
Referenced by _Requires_lock_held_().
◆ CdExceptionFilter()
| LONG CdExceptionFilter | ( | _Inout_ PIRP_CONTEXT | IrpContext, |
| _In_ PEXCEPTION_POINTERS | ExceptionPointer | ||
| ) |
Definition at line 525 of file cddata.c.
549{
552
553 ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
554
555 ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
556
557 //
558 // If the exception is STATUS_IN_PAGE_ERROR, get the I/O error code
559 // from the exception record.
560 //
561
563 (ExceptionPointer->ExceptionRecord->NumberParameters >= 3)) {
564
565 ExceptionCode =
566 (NTSTATUS)ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
567 }
568
569 //
570 // If there is an Irp context then check which status code to use.
571 //
572
574
576
577 //
578 // Store the real status into the IrpContext.
579 //
580
581 IrpContext->ExceptionStatus = ExceptionCode;
582
583 } else {
584
585 //
586 // No need to test the status code if we raised it ourselves.
587 //
588
590 }
591 }
592
593 AssertVerifyDevice( IrpContext, IrpContext->ExceptionStatus );
594
595 //
596 // Bug check if this status is not supported.
597 //
598
600
601#ifdef _MSC_VER
602#pragma prefast( suppress: __WARNING_USE_OTHER_FUNCTION, "We're corrupted." )
603#endif
605 (ULONG_PTR) ExceptionPointer->ContextRecord,
606 (ULONG_PTR) ExceptionPointer->ExceptionRecord->ExceptionAddress );
607
608 }
609
611}
Referenced by _IRQL_requires_max_(), _Requires_lock_held_(), and CdFspDispatch().
◆ CdFastDecodeFileObject()
| TYPE_OF_OPEN CdFastDecodeFileObject | ( | _In_ PFILE_OBJECT | FileObject, |
| _Out_ PFCB * | Fcb | ||
| ) |
Definition at line 206 of file filobsup.c.
232{
233 PAGED_CODE();
234
236
237 //
238 // The Fcb is in the FsContext field. The type of open is in the low
239 // bits of the Ccb.
240 //
241
243
246}
Referenced by _Function_class_(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), and CdFastUnlockSingle().
◆ CdFindDirectory()
| BOOLEAN CdFindDirectory | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ PFCB | Fcb, | ||
| _In_ PCD_NAME | Name, | ||
| _In_ BOOLEAN | IgnoreCase, | ||
| _Inout_ PFILE_ENUM_CONTEXT | FileContext | ||
| ) |
Definition at line 997 of file dirsup.c.
1031{
1033
1035
1036 PAGED_CODE();
1037
1038 //
1039 // Make sure there is a stream file for this Fcb.
1040 //
1041
1043
1044 //
1045 // Position ourselves at the first entry.
1046 //
1047
1049
1050 //
1051 // Loop while there are more entries in this directory.
1052 //
1053
1054 do {
1055
1057
1058 //
1059 // We only look for directories. Directories cannot have the
1060 // associated bit set.
1061 //
1062
1064
1065 //
1066 // Update the name in the current dirent.
1067 //
1068
1070
1071 //
1072 // Don't bother with constant entries.
1073 //
1074
1076
1077 continue;
1078 }
1079
1080 //
1081 // Now check whether we have a name match.
1082 // We exit the loop if we have a match.
1083 //
1084
1086 &Dirent->CdCaseFileName,
1087 Name,
1088 0,
1089 TRUE )) {
1090
1092 break;
1093 }
1094 }
1095
1096 //
1097 // Go to the next initial dirent.
1098 //
1099
1101
1103}
VOID CdUpdateDirentName(_In_ PIRP_CONTEXT IrpContext, _Inout_ PDIRENT Dirent, _In_ ULONG IgnoreCase)
Definition: dirsup.c:534
CdVerifyOrCreateDirStreamFile(IrpContext, Fcb)
BOOLEAN CdLookupNextInitialFileDirent(_In_ PIRP_CONTEXT IrpContext, _In_ PFCB Fcb, _Inout_ PFILE_ENUM_CONTEXT FileContext)
Definition: dirsup.c:1275
BOOLEAN CdIsNameInExpression(_In_ PIRP_CONTEXT IrpContext, _In_ PCD_NAME CurrentName, _In_ PCD_NAME SearchExpression, _In_ ULONG WildcardFlags, _In_ BOOLEAN CheckVersion)
Definition: namesup.c:844
Definition: apinames.c:49
◆ CdFspClose()
Referenced by _Requires_lock_held_(), and CdCloseWorker().
◆ CdFullCompareNames()
| FSRTL_COMPARISON_RESULT CdFullCompareNames | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _In_ PUNICODE_STRING | NameA, | ||
| _In_ PUNICODE_STRING | NameB | ||
| ) |
Definition at line 1064 of file namesup.c.
1091{
1093 ULONG MinLength = NameA->Length;
1095
1096 PAGED_CODE();
1097
1098 UNREFERENCED_PARAMETER( IrpContext );
1099
1100 //
1101 // Figure out the minimum of the two lengths
1102 //
1103
1104 if (NameA->Length > NameB->Length) {
1105
1106 MinLength = NameB->Length;
1108
1109 } else if (NameA->Length == NameB->Length) {
1110
1112 }
1113
1114 //
1115 // Loop through looking at all of the characters in both strings
1116 // testing for equalilty, less than, and greater than
1117 //
1118
1120
1122
1123 //
1124 // We know the offset of the first character which is different.
1125 //
1126
1128 LessThan :
1129 GreaterThan);
1130 }
1131
1132 //
1133 // The names match up to the length of the shorter string.
1134 // The shorter string lexically appears first.
1135 //
1136
1138}
enum _FSRTL_COMPARISON_RESULT FSRTL_COMPARISON_RESULT
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
Referenced by CdFindNameLink(), and CdInsertNameLink().
◆ CdGenerate8dot3Name()
| VOID CdGenerate8dot3Name | ( | _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 | ||
| ) |
Definition at line 550 of file namesup.c.
594{
596
598 UNICODE_STRING BiasedShortName;
601
602 GENERATE_NAME_CONTEXT NameContext;
603
604 ULONG BiasedDirentOffset;
605
606 ULONG MaximumBaseBytes;
607 ULONG BaseNameOffset;
608
609 PWCHAR NextWchar;
610 WCHAR ThisWchar;
612
614
616 USHORT OemNameOffset = 0;
618
619 PAGED_CODE();
620
621 //
622 // Initialize the short string to use the input buffer.
623 //
624
625 ShortName.Buffer = ShortNameBuffer;
627
628 //
629 // Initialize the name context.
630 //
631
633
634 //
635 // We now have the unicode name for the input string. Go ahead and generate
636 // the short name.
637 //
638
640
641 //
642 // We now have the generic short name. We want incorporate the dirent offset
643 // into the name in order to reduce the chance of name conflicts. We will use
644 // a tilde character followed by a character representation of the dirent offset.
645 // This will be the hexadecimal representation of the dirent offset in the directory.
646 // It is actuall this offset divided by 32 since we don't need the full
647 // granularity.
648 //
649
651
652 //
653 // Point to a local buffer to store the offset string. We start
654 // at the end of the buffer and work backwards.
655 //
656
657 NextWchar = Add2Ptr( BiasedShortNameBuffer,
658 BYTE_COUNT_8_DOT_3,
659 PWCHAR );
660
662
663 //
664 // Generate an OEM version of the string so that we can check for double
665 // byte characters.
666 //
667
669
670 //
671 // If this failed, bail out. Don't expect any problems other than no mem.
672 //
673
675
678 }
679
680 Length = 0;
681
682 //
683 // Now add the characters for the dirent offset. We need to start
684 // from the least significant digit and work backwards.
685 //
686
687 do {
688
689 NextWchar -= 1;
690
691 ThisWchar = (WCHAR) (BiasedDirentOffset & 0x0000000f);
692
693 //
694 // Store in the next character. Bias against either '0' or 'A'
695 //
696
697 if (ThisWchar <= 9) {
698
700
701 } else {
702
704 }
705
707
708 //
709 // Shift out the low 4 bits of the offset.
710 //
711
712 BiasedDirentOffset >>= 4;
713
714 } while (BiasedDirentOffset != 0);
715
716 //
717 // Now store in the tilde character.
718 //
719
720 NextWchar -= 1;
723
724 //
725 // Set the length of this string.
726 //
727
729 BiasedShortName.Buffer = NextWchar;
730
731 //
732 // Figure out the maximum number of characters we can copy of the base
733 // name. We subract the number of characters in the dirent string from 8.
734 // We will copy this many characters or stop when we reach a '.' character
735 // or a '~' character in the name.
736 //
737
738 MaximumBaseBytes = 16 - Length;
739
740 BaseNameOffset = 0;
741
742 //
743 // Keep copying from the base name until we hit a '.', '~' or the end of
744 // the short name.
745 //
746
747 NextWchar = ShortFileName;
748 Length = 0;
749
752
753 //
754 // Remember if we found a tilde character in the short name,
755 // so we don't copy it or anything following it.
756 //
757
759
760 FoundTilde = TRUE;
761 }
762
763 //
764 // We need to consider the DBCS code page, because Unicode characters
765 // may use 2 bytes as DBCS characters.
766 //
767
768#ifdef _MSC_VER
769#pragma prefast(push)
770#pragma prefast(suppress:26014, "OemNameOffset <= BaseNameOffset throughout this loop; OemName buffer previously allocated based on ShortName's length.")
771#endif
773#ifdef _MSC_VER
774#pragma prefast(pop)
775#endif
776
777 OemNameOffset += 2;
778
780
781 OverflowBuffer = TRUE;
782 }
783 }
784 else {
785
786 OemNameOffset++;
787 }
788
789 //
790 // Only copy the bytes if we still have space for the dirent string.
791 //
792
793 if (!FoundTilde && !OverflowBuffer && (BaseNameOffset < MaximumBaseBytes)) {
794
795 *NextWchar = ShortName.Buffer[BaseNameOffset / 2];
797 NextWchar += 1;
798 }
799
800 BaseNameOffset += 2;
801 }
802
804
805 //
806 // Now copy the dirent string into the biased name buffer.
807 //
808
809#ifdef _MSC_VER
810#pragma prefast(push)
811#endif
812 RtlCopyMemory( NextWchar,
813 BiasedShortName.Buffer,
814 BiasedShortName.Length );
815#ifdef _MSC_VER
816#pragma prefast(pop)
817#endif
818
821
822 //
823 // Now copy any remaining bytes over to the biased short name.
824 //
825
827
828 RtlCopyMemory( NextWchar,
829 &ShortName.Buffer[BaseNameOffset / 2],
830 ShortName.Length - BaseNameOffset );
831
833 }
834
835 //
836 // The final short name is stored in the user's buffer.
837 //
838
839 *ShortByteCount = Length;
840}
NTSYSAPI VOID NTAPI RtlGenerate8dot3Name(_In_ PCUNICODE_STRING Name, _In_ BOOLEAN AllowExtendedCharacters, _Inout_ PGENERATE_NAME_CONTEXT Context, _Inout_ PUNICODE_STRING Name8dot3)
VOID NTAPI RtlFreeOemString(POEM_STRING OemString)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToOemString(POEM_STRING DestinationString, PCUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
Definition: filecomp.c:348
Definition: rtltypes.h:616
Definition: env_spec_w32.h:368
Referenced by _Success_(), CdEnumerateIndex(), and if().
◆ CdGetNextFcb()
Definition at line 2155 of file strucsup.c.
2182{
2184
2185 PAGED_CODE();
2186
2187 UNREFERENCED_PARAMETER( IrpContext );
2188
2190
2192
2194 }
2195
2197}
struct _FCB_TABLE_ELEMENT * PFCB_TABLE_ELEMENT
_Must_inspect_result_ NTSYSAPI PVOID NTAPI RtlEnumerateGenericTableWithoutSplaying(_In_ PRTL_GENERIC_TABLE Table, _Inout_ PVOID *RestartKey)
Referenced by _Requires_lock_held_().
◆ CdHijackIrpAndFlushDevice()
| NTSTATUS CdHijackIrpAndFlushDevice | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PIRP | Irp, | ||
| _In_ PDEVICE_OBJECT | TargetDeviceObject | ||
| ) |
Definition at line 4105 of file deviosup.c.
4134{
4137 PIO_STACK_LOCATION NextIrpSp;
4138
4139 PAGED_CODE();
4140
4141 UNREFERENCED_PARAMETER( IrpContext );
4142
4143 //
4144 // Get the next stack location, and copy over the stack location
4145 //
4146
4148
4150
4152 NextIrpSp->MinorFunction = 0;
4153
4154 //
4155 // Set up the completion routine
4156 //
4157
4159
4161 CdSyncCompletionRoutine,
4162 &Event,
4163 TRUE,
4164 TRUE,
4165 TRUE );
4166
4167 //
4168 // Send the request.
4169 //
4170
4172
4174
4176
4178 }
4179
4180 //
4181 // If the driver doesn't support flushes, return SUCCESS.
4182 //
4183
4185
4187 }
4188
4189 Irp->IoStatus.Status = 0;
4190 Irp->IoStatus.Information = 0;
4191
4193}
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
Definition: filtergraph.c:51
Definition: ketypes.h:811
#define IRP_MJ_FLUSH_BUFFERS
Referenced by _Requires_lock_held_().
◆ CdInitializeFcbFromFileContext()
| VOID CdInitializeFcbFromFileContext | ( | _In_ PIRP_CONTEXT | IrpContext, |
| _Inout_ PFCB | Fcb, | ||
| _In_ PFCB | ParentFcb, | ||
| _In_ PFILE_ENUM_CONTEXT | FileContext | ||
| ) |
Definition at line 1225 of file strucsup.c.
1257{
1259 PCOMPOUND_DIRENT CurrentCompoundDirent;
1260
1261 LONGLONG CurrentFileOffset;
1262 ULONG CurrentMcbEntryOffset;
1263
1264 PAGED_CODE();
1265
1266 //
1267 // Use a try-finally to facilitate cleanup.
1268 //
1269
1271
1272 _SEH2_TRY {
1273
1274 //
1275 // Initialize the common header in the Fcb. The node type is already
1276 // present.
1277 //
1278
1280
1281 //
1282 // Allocation occurs in block-sized units.
1283 //
1284
1285 Fcb->FileSize.QuadPart =
1287
1289
1290 //
1291 // Set the flags from the dirent. We always start with the read-only bit.
1292 //
1293
1296
1298 }
1299
1300 //
1301 // Convert the time to NT time.
1302 //
1303
1304 CdConvertCdTimeToNtTime( IrpContext,
1305 ThisDirent->CdTime,
1307
1308 //
1309 // Set the flag indicating the type of extent.
1310 //
1311
1313
1315
1317
1318 } else {
1319
1321 }
1322
1325 }
1326
1327 //
1328 // Read through all of the dirents for the file until we find the last
1329 // and add the allocation into the Mcb.
1330 //
1331
1332 CurrentCompoundDirent = FileContext->InitialDirent;
1333 CurrentFileOffse