ReactOS 0.4.15-dev-7934-g1dc8d80
fsctl.c File Reference
#include "ext2fs.h"
Include dependency graph for fsctl.c:

Go to the source code of this file.

Functions

VOID Ext2SetVpbFlag (IN PVPB Vpb, IN USHORT Flag)
 
VOID Ext2ClearVpbFlag (IN PVPB Vpb, IN USHORT Flag)
 
BOOLEAN Ext2IsHandleCountZero (IN PEXT2_VCB Vcb)
 
NTSTATUS Ext2LockVcb (IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject)
 
NTSTATUS Ext2LockVolume (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2UnlockVcb (IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject)
 
NTSTATUS Ext2UnlockVolume (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2InvalidateVolumes (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2AllowExtendedDasdIo (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2OplockRequest (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2IsVolumeDirty (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2QueryExtentMappings (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Fcb, IN PLARGE_INTEGER RequestVbn, OUT PLARGE_INTEGER *pMappedRuns)
 
NTSTATUS Ext2QueryRetrievalPointers (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2GetRetrievalPointers (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2GetRetrievalPointerBase (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2InspectReparseData (IN PREPARSE_DATA_BUFFER RDB, IN ULONG InputBufferLength)
 
VOID Ext2InitializeReparseData (IN PREPARSE_DATA_BUFFER RDB, USHORT PathBufferLength)
 
NTSTATUS Ext2ReadSymlink (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN PVOID Buffer, IN ULONG Size, OUT PULONG BytesRead)
 
NTSTATUS Ext2GetReparsePoint (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2WriteSymlink (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN PVOID Buffer, IN ULONG Size, OUT PULONG BytesWritten)
 
NTSTATUS Ext2SetReparsePoint (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2TruncateSymlink (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, ULONG Size)
 
NTSTATUS Ext2DeleteReparsePoint (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2UserFsRequest (IN PEXT2_IRP_CONTEXT IrpContext)
 
BOOLEAN Ext2IsMediaWriteProtected (IN PEXT2_IRP_CONTEXT IrpContext, IN PDEVICE_OBJECT TargetDevice)
 
NTSTATUS Ext2MountVolume (IN PEXT2_IRP_CONTEXT IrpContext)
 
VOID Ext2VerifyVcb (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)
 
NTSTATUS Ext2VerifyVolume (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2IsVolumeMounted (IN PEXT2_IRP_CONTEXT IrpContext)
 
NTSTATUS Ext2DismountVolume (IN PEXT2_IRP_CONTEXT IrpContext)
 
BOOLEAN Ext2CheckDismount (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bForce)
 
NTSTATUS Ext2PurgeVolume (IN PEXT2_VCB Vcb, IN BOOLEAN FlushBeforePurge)
 
NTSTATUS Ext2PurgeFile (IN PEXT2_FCB Fcb, IN BOOLEAN FlushBeforePurge)
 
NTSTATUS Ext2FileSystemControl (IN PEXT2_IRP_CONTEXT IrpContext)
 

Variables

PEXT2_GLOBAL Ext2Global
 

Function Documentation

◆ Ext2AllowExtendedDasdIo()

NTSTATUS Ext2AllowExtendedDasdIo ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 407 of file fsctl.c.

408{
413
414 IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
415
416 Vcb = (PEXT2_VCB) IrpSp->FileObject->FsContext;
417 Ccb = (PEXT2_CCB) IrpSp->FileObject->FsContext2;
418
419 ASSERT(Vcb != NULL);
420
421 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
422 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
423
425
426 if (Ccb) {
429 } else {
431 }
432
433 Ext2CompleteIrpContext(IrpContext, status);
434 return status;
435}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
LONG NTSTATUS
Definition: precomp.h:26
_Inout_ PFILE_OBJECT _In_ TYPE_OF_OPEN PFCB _In_opt_ PCCB Ccb
Definition: cdprocs.h:592
#define NULL
Definition: types.h:112
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
@ EXT2VCB
Definition: ext2fs.h:462
#define IsMounted(Vcb)
Definition: ext2fs.h:812
#define SetLongFlag(_F, _SF)
Definition: ext2fs.h:258
struct _EXT2_VCB * PEXT2_VCB
NTSTATUS Ext2CompleteIrpContext(IN PEXT2_IRP_CONTEXT IrpContext, IN NTSTATUS Status)
Definition: read.c:32
#define CCB_ALLOW_EXTENDED_DASD_IO
Definition: ext2fs.h:1037
#define ASSERT(a)
Definition: mode.c:44
#define Vcb
Definition: cdprocs.h:1415
#define STATUS_SUCCESS
Definition: shellext.h:65
ULONG Flags
Definition: ntfs.h:536
PFILE_OBJECT FileObject
Definition: iotypes.h:3169
Definition: ps.c:97
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

Referenced by Ext2UserFsRequest().

◆ Ext2CheckDismount()

BOOLEAN Ext2CheckDismount ( IN PEXT2_IRP_CONTEXT  IrpContext,
IN PEXT2_VCB  Vcb,
IN BOOLEAN  bForce 
)

Definition at line 2592 of file fsctl.c.

2596{
2597 KIRQL Irql;
2598 PVPB Vpb = Vcb->Vpb, NewVpb = NULL;
2599 BOOLEAN bDeleted = FALSE, bTearDown = FALSE;
2600 ULONG UnCleanCount = 0;
2601
2603 if (NewVpb == NULL) {
2604 DEBUG(DL_ERR, ( "Ex2CheckDismount: failed to allocate NewVpb.\n"));
2605 return FALSE;
2606 }
2607 DEBUG(DL_DBG, ("Ext2CheckDismount: NewVpb allocated: %p\n", NewVpb));
2608 INC_MEM_COUNT(PS_VPB, NewVpb, sizeof(VPB));
2609 memset(NewVpb, '_', VPB_SIZE);
2610 RtlZeroMemory(NewVpb, sizeof(VPB));
2611
2614
2616 &Vcb->MainResource, TRUE );
2617
2618 if (IrpContext &&
2619 IrpContext->MajorFunction == IRP_MJ_CREATE &&
2620 IrpContext->RealDevice == Vcb->RealDevice) {
2621 UnCleanCount = 2;
2622 } else {
2623 UnCleanCount = 1;
2624 }
2625
2627
2628 DEBUG(DL_DBG, ("Ext2CheckDismount: Vpb %p ioctl=%d Device %p\n",
2629 Vpb, Vpb->ReferenceCount, Vpb->RealDevice));
2630
2631 if (Vpb->ReferenceCount <= UnCleanCount) {
2632
2633 if (!IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
2634
2635 ClearFlag(Vpb->Flags, VPB_MOUNTED);
2636 ClearFlag(Vpb->Flags, VPB_LOCKED);
2637
2638 if ((Vcb->RealDevice != Vpb->RealDevice) &&
2639 (Vcb->RealDevice->Vpb == Vpb)) {
2640 SetFlag(Vcb->RealDevice->Flags, DO_DEVICE_INITIALIZING);
2641 SetFlag(Vpb->Flags, VPB_PERSISTENT );
2642 }
2643
2646 }
2647
2648 if (Vpb->ReferenceCount) {
2649 bTearDown = TRUE;
2650 } else {
2651 bDeleted = TRUE;
2652 Vpb->DeviceObject = NULL;
2653 }
2654
2655 DEBUG(DL_DBG, ("Ext2CheckDismount: Vpb: %p bDeleted=%d bTearDown=%d\n",
2656 Vpb, bDeleted, bTearDown));
2657
2658
2659 } else if (bForce) {
2660
2661 DEBUG(DL_DBG, ( "Ext2CheckDismount: New/Old Vpb %p/%p Realdevice = %p\n",
2662 NewVpb, Vcb->Vpb, Vpb->RealDevice));
2663
2664 /* keep vpb president and later we'll free it */
2665 SetFlag(Vpb->Flags, VPB_PERSISTENT);
2666
2667 Vcb->Vpb2 = Vcb->Vpb;
2668 NewVpb->Type = IO_TYPE_VPB;
2669 NewVpb->Size = sizeof(VPB);
2670 NewVpb->Flags = Vpb->Flags & VPB_REMOVE_PENDING;
2671 NewVpb->RealDevice = Vpb->RealDevice;
2672 NewVpb->RealDevice->Vpb = NewVpb;
2673 NewVpb = NULL;
2674 ClearFlag(Vpb->Flags, VPB_MOUNTED);
2675 SetLongFlag(Vcb->Flags, VCB_NEW_VPB);
2676 ClearLongFlag(Vcb->Flags, VCB_MOUNTED);
2677 }
2678
2680
2681 ExReleaseResourceLite(&Vcb->MainResource);
2683
2684 if (bTearDown) {
2685 DEBUG(DL_DBG, ( "Ext2CheckDismount: Tearing vcb %p ...\n", Vcb));
2687 }
2688
2689 if (bDeleted) {
2690 DEBUG(DL_DBG, ( "Ext2CheckDismount: Deleting vcb %p ...\n", Vcb));
2692 }
2693
2694 if (NewVpb != NULL) {
2695 DEBUG(DL_DBG, ( "Ext2CheckDismount: freeing new Vpb %p\n", NewVpb));
2696 ExFreePoolWithTag(NewVpb, TAG_VPB);
2697 DEC_MEM_COUNT(PS_VPB, NewVpb, sizeof(VPB));
2698 }
2699
2700 return bDeleted;
2701}
unsigned char BOOLEAN
#define DEBUG(args)
Definition: rdesktop.h:129
#define TAG_VPB
Definition: cdprocs.h:106
_Out_ PKIRQL Irql
Definition: csq.h:179
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define PS_VPB
Definition: common.h:23
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define ExAcquireResourceExclusiveLite(res, wait)
Definition: env_spec_w32.h:615
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define NonPagedPool
Definition: env_spec_w32.h:307
PEXT2_GLOBAL Ext2Global
Definition: init.c:16
#define ClearFlag(_F, _SF)
Definition: ext2fs.h:191
#define SetFlag(_F, _SF)
Definition: ext2fs.h:187
VOID Ext2RemoveVcb(PEXT2_VCB Vcb)
Definition: memory.c:1943
#define VPB_SIZE
Definition: ext2fs.h:294
VOID Ext2TearDownStream(IN PEXT2_VCB Vcb)
Definition: memory.c:2798
#define DEC_MEM_COUNT(_i, _p, _s)
Definition: ext2fs.h:608
#define VCB_DISMOUNT_PENDING
Definition: ext2fs.h:791
#define VCB_NEW_VPB
Definition: ext2fs.h:792
#define ClearLongFlag(_F, _SF)
Definition: ext2fs.h:259
VOID Ext2DestroyVcb(IN PEXT2_VCB Vcb)
Definition: memory.c:2825
#define VCB_MOUNTED
Definition: ext2fs.h:790
#define DL_ERR
Definition: ext2fs.h:1434
#define INC_MEM_COUNT(_i, _p, _s)
Definition: ext2fs.h:607
#define DL_DBG
Definition: ext2fs.h:1435
#define IsFlagOn(a, b)
Definition: ext2fs.h:177
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB Vpb
Definition: fatprocs.h:1675
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define VPB_REMOVE_PENDING
Definition: ntifs_ex.h:428
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1822
VOID NTAPI IoReleaseVpbSpinLock(IN KIRQL Irql)
Definition: volume.c:1215
VOID NTAPI IoAcquireVpbSpinLock(OUT PKIRQL Irql)
Definition: volume.c:1204
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define memset(x, y, z)
Definition: compat.h:39
ERESOURCE Resource
Definition: ext2fs.h:519
PVPB Vpb
Definition: cdstruc.h:511
Definition: iotypes.h:189
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG
Definition: typedefs.h:59
#define VPB_MOUNTED
Definition: iotypes.h:1807
#define IO_TYPE_VPB
#define VPB_PERSISTENT
Definition: iotypes.h:1809
struct _VPB VPB
#define VPB_LOCKED
Definition: iotypes.h:1808

Referenced by Ext2DismountVolume(), Ext2ExceptionHandler(), Ext2FreeFcb(), and Ext2InvalidateVolumes().

◆ Ext2ClearVpbFlag()

VOID Ext2ClearVpbFlag ( IN PVPB  Vpb,
IN USHORT  Flag 
)

Definition at line 56 of file fsctl.c.

59{
61
63 Vpb->Flags &= ~Flag;
65}
Definition: xml2sdb.h:80
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by Ext2Cleanup(), and Ext2UnlockVcb().

◆ Ext2DeleteReparsePoint()

NTSTATUS Ext2DeleteReparsePoint ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 1784 of file fsctl.c.

1785{
1786 PIRP Irp = NULL;
1787
1789
1790 PEXT2_VCB Vcb = NULL;
1791 PEXT2_FCB Fcb = NULL;
1792 PEXT2_CCB Ccb = NULL;
1793 PEXT2_MCB Mcb = NULL;
1794
1795 PEXT2_FCB ParentDcb = NULL; /* Dcb of it's current parent */
1796 PEXT2_MCB ParentMcb = NULL;
1797
1799
1800 BOOLEAN FcbLockAcquired = FALSE;
1801 BOOLEAN MainResourceAcquired = FALSE;
1802
1803
1804 _SEH2_TRY {
1805
1806 Ccb = IrpContext->Ccb;
1807 ASSERT(Ccb != NULL);
1809 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
1810 DeviceObject = IrpContext->DeviceObject;
1811 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
1812 Mcb = IrpContext->Fcb->Mcb;
1813 Irp = IrpContext->Irp;
1814
1816 FcbLockAcquired = TRUE;
1817
1818 ParentMcb = Mcb->Parent;
1819 ParentDcb = ParentMcb->Fcb;
1820 if (ParentDcb == NULL) {
1821 ParentDcb = Ext2AllocateFcb(Vcb, ParentMcb);
1822 }
1823 if (ParentDcb) {
1824 Ext2ReferXcb(&ParentDcb->ReferenceCount);
1825 }
1826
1827 if (!Mcb || !IsInodeSymLink(&Mcb->Inode) ||
1831 }
1832
1834 if (Fcb) {
1835 Ext2ReferXcb(&Fcb->ReferenceCount);
1836 } else {
1839 }
1840
1841 if (FcbLockAcquired) {
1842 ExReleaseResourceLite(&Vcb->FcbLock);
1843 FcbLockAcquired = FALSE;
1844 }
1845
1847 &Fcb->MainResource,
1848 IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {
1851 }
1852 MainResourceAcquired = TRUE;
1853
1854 Status = Ext2TruncateSymlink(IrpContext, Vcb, Mcb, 0);
1855 if (!NT_SUCCESS(Status)) {
1857 }
1858
1859 /* inode is to be removed */
1861
1862 } _SEH2_FINALLY {
1863
1864 if (FcbLockAcquired) {
1865 ExReleaseResourceLite(&Vcb->FcbLock);
1866 }
1867
1868 if (MainResourceAcquired) {
1870 }
1871
1872 if (NT_SUCCESS(Status)) {
1874 IrpContext,
1875 Vcb,
1876 Mcb,
1879
1880 }
1881
1884 Status = Ext2QueueRequest(IrpContext);
1885 } else {
1886 Ext2CompleteIrpContext(IrpContext, Status);
1887 }
1888 }
1889
1890 if (ParentDcb) {
1892 }
1893
1894 if (Fcb) {
1896 }
1897 } _SEH2_END;
1898
1899 return Status;
1900}
_In_ PFCB Fcb
Definition: cdprocs.h:159
#define IRP_CONTEXT_FLAG_WAIT
Definition: cdstruc.h:1215
_In_ PIRP Irp
Definition: csq.h:116
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ PIO_STACK_LOCATION _Inout_ PFILE_OBJECT _Inout_ PVCB _Outptr_result_maybenull_ PDCB _In_ PDCB ParentDcb
Definition: create.c:4141
#define ExAcquireResourceSharedLite(res, wait)
Definition: env_spec_w32.h:621
NTSTATUS Ext2TruncateSymlink(PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, ULONG Size)
Definition: fsctl.c:1751
VOID Ext2ReleaseFcb(IN PEXT2_FCB Fcb)
Definition: memory.c:276
@ EXT2CCB
Definition: ext2fs.h:464
NTSTATUS Ext2QueueRequest(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: dispatch.c:158
#define Ext2ReferXcb(_C)
Definition: ext2fs.h:976
#define CCB_OPEN_REPARSE_POINT
Definition: ext2fs.h:1034
VOID Ext2NotifyReportChange(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Filter, IN ULONG Action)
Definition: dirctl.c:1209
#define IsInodeSymLink(I)
Definition: ext2fs.h:286
#define CCB_DELETE_ON_CLOSE
Definition: ext2fs.h:1035
PEXT2_FCB Ext2AllocateFcb(IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb)
Definition: memory.c:131
IN PVCB IN ULONG IN OUT PULONG IN BOOLEAN OUT PLARGE_MCB Mcb
Definition: fatprocs.h:348
#define _SEH2_FINALLY
Definition: filesup.c:21
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define _SEH2_LEAVE
Definition: filesup.c:20
Status
Definition: gdiplustypes.h:25
#define STATUS_CANT_WAIT
Definition: ntstatus.h:452
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_NOT_A_REPARSE_POINT
Definition: ntstatus.h:753
#define _SEH2_AbnormalTermination()
Definition: pseh2_64.h:160
ULONG Type
Definition: ntfs.h:95
ULONG Size
Definition: ntfs.h:96
PEXT2_FCB Fcb
Definition: ext2fs.h:914
NTFSIDENTIFIER Identifier
Definition: ntfs.h:515
ERESOURCE MainResource
Definition: ntfs.h:528
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
#define FILE_ACTION_MODIFIED
#define FILE_NOTIFY_CHANGE_ATTRIBUTES

Referenced by Ext2UserFsRequest().

◆ Ext2DismountVolume()

NTSTATUS Ext2DismountVolume ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 2521 of file fsctl.c.

2522{
2525 PEXT2_VCB Vcb = NULL;
2526 BOOLEAN VcbResourceAcquired = FALSE;
2527
2528 _SEH2_TRY {
2529
2530 ASSERT(IrpContext != NULL);
2531
2532 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
2533 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
2534
2535 DeviceObject = IrpContext->DeviceObject;
2536
2537 //
2538 // This request is not allowed on the main device object
2539 //
2543 }
2544
2545 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
2546
2547 ASSERT(Vcb != NULL);
2548
2549 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
2550 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
2551
2553
2555 &Vcb->MainResource,
2556 TRUE );
2557
2558 VcbResourceAcquired = TRUE;
2559
2560 if ( IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
2563 }
2564
2565 Ext2FlushFiles(IrpContext, Vcb, FALSE);
2566 Ext2FlushVolume(IrpContext, Vcb, FALSE);
2567
2568 ExReleaseResourceLite(&Vcb->MainResource);
2569 VcbResourceAcquired = FALSE;
2570
2572 Ext2CheckDismount(IrpContext, Vcb, TRUE);
2573
2574 DEBUG(DL_INF, ( "Ext2Dismount: Volume dismount pending.\n"));
2576
2577 } _SEH2_FINALLY {
2578
2579 if (VcbResourceAcquired) {
2580 ExReleaseResourceLite(&Vcb->MainResource);
2581 }
2582
2583 if (!IrpContext->ExceptionInProgress) {
2584 Ext2CompleteIrpContext(IrpContext, Status);
2585 }
2586 } _SEH2_END;
2587
2588 return Status;
2589}
NTSTATUS Ext2PurgeVolume(IN PEXT2_VCB Vcb, IN BOOLEAN FlushBeforePurge)
Definition: fsctl.c:2704
BOOLEAN Ext2CheckDismount(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bForce)
Definition: fsctl.c:2592
@ EXT2ICX
Definition: ext2fs.h:465
#define IsExt2FsDevice(DO)
Definition: ext2fs.h:616
#define DL_INF
Definition: ext2fs.h:1436
NTSTATUS Ext2FlushFiles(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bShutDown)
Definition: flush.c:112
NTSTATUS Ext2FlushVolume(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bShutDown)
Definition: flush.c:43
#define STATUS_VOLUME_DISMOUNTED
Definition: ntstatus.h:747
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138

Referenced by Ext2UserFsRequest().

◆ Ext2FileSystemControl()

NTSTATUS Ext2FileSystemControl ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 2848 of file fsctl.c.

2849{
2851
2852 ASSERT(IrpContext);
2853
2854 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
2855 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
2856
2857 switch (IrpContext->MinorFunction) {
2858
2860 Status = Ext2UserFsRequest(IrpContext);
2861 break;
2862
2864 Status = Ext2MountVolume(IrpContext);
2865 break;
2866
2868 Status = Ext2VerifyVolume(IrpContext);
2869 break;
2870
2871 default:
2872
2873 DEBUG(DL_ERR, ( "Ext2FilsSystemControl: Invalid Device Request.\n"));
2875 Ext2CompleteIrpContext(IrpContext, Status);
2876 }
2877
2878 return Status;
2879}
NTSTATUS Ext2VerifyVolume(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:2378
NTSTATUS Ext2UserFsRequest(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:1903
NTSTATUS Ext2MountVolume(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:2050
#define IRP_MN_VERIFY_VOLUME
Definition: iotypes.h:4405
#define IRP_MN_USER_FS_REQUEST
Definition: iotypes.h:4403
#define IRP_MN_MOUNT_VOLUME
Definition: iotypes.h:4404

Referenced by Ext2DispatchRequest().

◆ Ext2GetReparsePoint()

NTSTATUS Ext2GetReparsePoint ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 1386 of file fsctl.c.

1387{
1388 PIRP Irp = NULL;
1391
1393
1394 PEXT2_VCB Vcb = NULL;
1395 PEXT2_CCB Ccb = NULL;
1396 PEXT2_MCB Mcb = NULL;
1397
1399 BOOLEAN MainResourceAcquired = FALSE;
1400
1403 ULONG BytesRead = 0;
1404
1406
1407 UNICODE_STRING UniName;
1409
1410 PCHAR OemNameBuffer = NULL;
1411 int OemNameLength = 0, i;
1412
1413 Ccb = IrpContext->Ccb;
1414 ASSERT(Ccb != NULL);
1416 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
1417 DeviceObject = IrpContext->DeviceObject;
1418 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
1419 Mcb = IrpContext->Fcb->Mcb;
1420 Irp = IrpContext->Irp;
1422
1423 _SEH2_TRY {
1424
1425 if (!Mcb || !IsInodeSymLink(&Mcb->Inode) ||
1429 }
1430
1431 OutputBuffer = (PVOID)Irp->AssociatedIrp.SystemBuffer;
1433
1435 if (!RDB) {
1438 }
1442 }
1443
1444 OemNameLength = (ULONG)Mcb->Inode.i_size;
1445 if (OemNameLength > USHRT_MAX) {
1448 }
1449 OemName.Length = (USHORT)OemNameLength;
1450 OemName.MaximumLength = OemNameLength + 1;
1451 OemNameBuffer = OemName.Buffer = Ext2AllocatePool(NonPagedPool,
1452 OemName.MaximumLength,
1453 'NL2E');
1454 if (!OemNameBuffer) {
1457 }
1458
1459 Status = Ext2ReadSymlink(IrpContext,
1460 Vcb,
1461 Mcb,
1462 OemNameBuffer,
1463 OemNameLength,
1464 &BytesRead
1465 );
1466 OemName.Buffer[OemName.Length] = '\0';
1467 for (i = 0;i < OemName.Length;i++) {
1468 if (OemName.Buffer[i] == '/') {
1469 OemName.Buffer[i] = '\\';
1470 }
1471 }
1472
1473 if (OutputBufferLength - FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) > USHRT_MAX) {
1474 UniName.Length = USHRT_MAX;
1475 } else {
1476 UniName.Length = (USHORT)OutputBufferLength - FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer);
1477 }
1478 UniName.MaximumLength = UniName.Length;
1480 Irp->IoStatus.Information = FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + 2 * UniName.Length;
1481 if (UniName.MaximumLength < 2*UniName.Length) {
1484 }
1485
1486 Ext2InitializeReparseData(RDB, UniName.Length);
1487 UniName.Buffer = RDB->SymbolicLinkReparseBuffer.PathBuffer;
1488 /*
1489 (PWCHAR)((PUCHAR)&
1490 + RDB->SymbolicLinkReparseBuffer.SubstituteNameOffset);
1491 */
1492 Ext2OEMToUnicode(Vcb, &UniName, &OemName);
1494 RDB->SymbolicLinkReparseBuffer.SubstituteNameOffset,
1495 UniName.Buffer, UniName.Length);
1496
1498
1499 } _SEH2_FINALLY {
1500
1501 if (OemNameBuffer) {
1502 Ext2FreePool(OemNameBuffer, 'NL2E');
1503 }
1504
1507 Status = Ext2QueueRequest(IrpContext);
1508 } else {
1509 Ext2CompleteIrpContext(IrpContext, Status);
1510 }
1511 }
1512 } _SEH2_END;
1513
1514 return Status;
1515}
NTSTATUS Ext2ReadSymlink(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN PVOID Buffer, IN ULONG Size, OUT PULONG BytesRead)
Definition: fsctl.c:1364
VOID Ext2InitializeReparseData(IN PREPARSE_DATA_BUFFER RDB, USHORT PathBufferLength)
Definition: fsctl.c:1346
VOID Ext2FreePool(IN PVOID P, IN ULONG Tag)
Definition: debug.c:2697
PVOID Ext2AllocatePool(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)
Definition: debug.c:2684
NTSTATUS Ext2OEMToUnicode(IN PEXT2_VCB Vcb, IN OUT PUNICODE_STRING Oem, IN POEM_STRING Unicode)
Definition: misc.c:206
ULONG Ext2OEMToUnicodeSize(IN PEXT2_VCB Vcb, IN PANSI_STRING Oem)
Definition: misc.c:183
IN PDCB IN POEM_STRING OemName
Definition: fatprocs.h:1304
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
#define USHRT_MAX
Definition: limits.h:38
if(dx< 0)
Definition: linetemp.h:194
unsigned short USHORT
Definition: pedump.c:61
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
union _IO_STACK_LOCATION::@1564 Parameters
struct _IO_STACK_LOCATION::@3978::@3993 FileSystemControl
WCHAR PathBuffer[1]
Definition: shellext.h:176
struct _REPARSE_DATA_BUFFER::@318::@320 SymbolicLinkReparseBuffer
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
void * PVOID
Definition: typedefs.h:50
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
unsigned char * PUCHAR
Definition: typedefs.h:53
char * PCHAR
Definition: typedefs.h:51
STRING OEM_STRING
Definition: umtypes.h:203
_In_ WDFREQUEST _In_ size_t OutputBufferLength
Definition: wdfio.h:320
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:863
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesRead
Definition: wdfiotarget.h:870

Referenced by Ext2UserFsRequest().

◆ Ext2GetRetrievalPointerBase()

NTSTATUS Ext2GetRetrievalPointerBase ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 1160 of file fsctl.c.

1163{
1164 PIRP Irp = NULL;
1167
1170
1171 PEXT2_VCB Vcb = NULL;
1172 PEXT2_FCB Fcb = NULL;
1173 PEXT2_CCB Ccb = NULL;
1174
1175 PLARGE_INTEGER FileAreaOffset;
1176
1177 ULONG OutputSize;
1178
1180
1181 BOOLEAN FcbResourceAcquired = FALSE;
1182
1183 _SEH2_TRY {
1184
1185 ASSERT(IrpContext);
1186 Irp = IrpContext->Irp;
1187 ASSERT(Irp);
1188
1191 ASSERT(IrpSp);
1192
1193 OutputSize = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
1194
1195 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
1196 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
1197
1198 DeviceObject = IrpContext->DeviceObject;
1199
1200 /* This request is not allowed on the main device object */
1204 }
1205
1206 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
1207 ASSERT(Vcb != NULL);
1208 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
1209 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
1211
1212 FileObject = IrpContext->FileObject;
1213 Fcb = (PEXT2_FCB) FileObject->FsContext;
1214
1215 /* check Fcb is valid or not */
1216 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
1219 }
1220
1222 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
1223
1224 if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
1227 }
1228
1229 Ccb = (PEXT2_CCB) FileObject->FsContext2;
1230 if (Ccb == NULL) {
1233 }
1234
1236 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
1237
1238 if (OutputSize < sizeof(LARGE_INTEGER)) {
1241 }
1242
1247 }
1248 FcbResourceAcquired = TRUE;
1249
1250 FileAreaOffset = (PLARGE_INTEGER) Ext2GetUserBuffer(Irp);
1251
1252 /* probe user buffer */
1253
1254 _SEH2_TRY {
1255 if (Irp->RequestorMode != KernelMode) {
1256 ProbeForWrite(FileAreaOffset, OutputSize, sizeof(UCHAR));
1257 }
1258
1260
1262 } _SEH2_END;
1263
1264 if (!NT_SUCCESS(Status)) {
1266 }
1267
1268 DEBUG(DL_DBG, ("Ext2GetRetrievalPointerBase: FileAreaOffset is 0.\n"));
1269
1270 FileAreaOffset->QuadPart = 0; // sector offset to the first allocatable unit on the filesystem
1271
1272 Irp->IoStatus.Information = sizeof(LARGE_INTEGER);
1273
1274 } _SEH2_FINALLY {
1275
1276 if (FcbResourceAcquired) {
1278 }
1279
1282 Status = Ext2QueueRequest(IrpContext);
1283 } else {
1284 Ext2CompleteIrpContext(IrpContext, Status);
1285 }
1286 }
1287 } _SEH2_END;
1288
1289 return Status;
1290}
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
@ EXT2FCB
Definition: ext2fs.h:463
PVOID Ext2GetUserBuffer(IN PIRP Irp)
Definition: block.c:146
#define Ext2CanIWait()
Definition: ext2fs.h:1100
struct _EXT2_CCB * PEXT2_CCB
struct _EXT2_FCB * PEXT2_FCB
#define MCB_FILE_DELETED
Definition: ext2fs.h:955
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define KernelMode
Definition: asm.h:34
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
CD_MCB Mcb
Definition: cdstruc.h:1016
union _LARGE_INTEGER LARGE_INTEGER
union _LARGE_INTEGER * PLARGE_INTEGER
Definition: file.c:85
#define STATUS_FILE_DELETED
Definition: udferr_usr.h:172
#define STATUS_INVALID_USER_BUFFER
Definition: udferr_usr.h:166
#define PEXTENDED_IO_STACK_LOCATION
Definition: udffs.h:119
LONGLONG QuadPart
Definition: typedefs.h:114
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
* PFILE_OBJECT
Definition: iotypes.h:1998
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by Ext2UserFsRequest().

◆ Ext2GetRetrievalPointers()

NTSTATUS Ext2GetRetrievalPointers ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 911 of file fsctl.c.

914{
915 PIRP Irp = NULL;
918
921
925
928
929 PEXT2_EXTENT Chain = NULL;
931
932 LONGLONG Vbn = 0;
933 ULONG Length = 0;
934 ULONG i = 0;
935
936 ULONG UsedSize = 0;
937 ULONG InputSize;
938 ULONG OutputSize;
939
941
942 BOOLEAN FcbResourceAcquired = FALSE;
943
944 _SEH2_TRY {
945
946 ASSERT(IrpContext);
947 Irp = IrpContext->Irp;
948 ASSERT(Irp);
949
952 ASSERT(IrpSp);
953
954 InputSize = EIrpSp->Parameters.FileSystemControl.InputBufferLength;
955 OutputSize = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
956
957 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
958 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
959
960 DeviceObject = IrpContext->DeviceObject;
961
962 /* This request is not allowed on the main device object */
966 }
967
968 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
969 ASSERT(Vcb != NULL);
970 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
971 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
973
974 FileObject = IrpContext->FileObject;
975 Fcb = (PEXT2_FCB) FileObject->FsContext;
976
977 /* check Fcb is valid or not */
978 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
981 }
982
984 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
985
986 if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
989 }
990
991 Ccb = (PEXT2_CCB) FileObject->FsContext2;
992 if (Ccb == NULL) {
995 }
996
998 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
999
1000 if (InputSize < sizeof(STARTING_VCN_INPUT_BUFFER) ||
1001 OutputSize < sizeof(RETRIEVAL_POINTERS_BUFFER) ) {
1004 }
1005
1010 }
1011 FcbResourceAcquired = TRUE;
1012
1014 EIrpSp->Parameters.FileSystemControl.Type3InputBuffer;
1016
1017 /* probe user buffer */
1018
1019 _SEH2_TRY {
1020 if (Irp->RequestorMode != KernelMode) {
1021 ProbeForRead (SVIB, InputSize, sizeof(UCHAR));
1022 ProbeForWrite(RPSB, OutputSize, sizeof(UCHAR));
1023 }
1026 } _SEH2_END;
1027
1028 if (!NT_SUCCESS(Status)) {
1030 }
1031
1032 UsedSize = FIELD_OFFSET(RETRIEVAL_POINTERS_BUFFER, Extents[0]);
1033
1034 /* request size beyonds whole file size ? */
1035 DEBUG(DL_DBG, ("Ext2GetRetrievalPointers: Startin from Vbn: %I64xh\n",
1036 SVIB->StartingVcn.QuadPart));
1037 Vbn = (SVIB->StartingVcn.QuadPart << BLOCK_BITS);
1038 if (Vbn >= Fcb->Header.AllocationSize.QuadPart ) {
1041 }
1042
1043 /* now building all the request extents */
1044 while (Vbn < Fcb->Header.AllocationSize.QuadPart) {
1045
1046 ASSERT(Chain == NULL);
1047 Length = 0x80000000; /* 2g bytes */
1048 if (Fcb->Header.AllocationSize.QuadPart < Vbn + Length) {
1049 Length = (ULONG)(Fcb->Header.AllocationSize.QuadPart - Vbn);
1050 }
1051
1052 /* build extents for sub-range */
1054 IrpContext,
1055 Vcb,
1056 Fcb->Mcb,
1057 Vbn,
1058 Length,
1059 FALSE,
1060 &Chain);
1061
1062 if (!NT_SUCCESS(Status)) {
1063 DbgBreak();
1065 }
1066
1067 /* fill user buffer of RETRIEVAL_POINTERS_BUFFER */
1068 Extent = Chain;
1069 while (Extent) {
1070
1071 DEBUG(DL_MAP, ("Ext2GetRetrievalPointers: %wZ %d Vbn = %I64xh Lbn = %I64xh\n",
1072 &Fcb->Mcb->FullName, i,
1073 ((Vbn + Extent->Offset) >> BLOCK_BITS),
1074 Extent->Lba));
1075
1076 RPSB->Extents[i].Lcn.QuadPart = (Extent->Lba >> BLOCK_BITS);
1077 RPSB->Extents[i].NextVcn.QuadPart = ((Vbn + Extent->Offset + Extent->Length) >> BLOCK_BITS);
1078 if (i == 0) {
1079 RPSB->StartingVcn.QuadPart = ((Vbn + Extent->Offset) >> BLOCK_BITS);
1080 } else {
1081 ASSERT(RPSB->Extents[i-1].NextVcn.QuadPart == ((Vbn + Extent->Offset) >> BLOCK_BITS));
1082 }
1083 if (UsedSize + sizeof(RETRIEVAL_POINTERS_BUFFER) > OutputSize) {
1086 }
1087 UsedSize += sizeof(LARGE_INTEGER) * 2;
1088 Irp->IoStatus.Information = (ULONG_PTR)UsedSize;
1089 RPSB->ExtentCount = ++i;
1090 Extent = Extent->Next;
1091 }
1092
1093 if (Chain) {
1095 Chain = NULL;
1096 }
1097
1098 Vbn = Vbn + Length;
1099 }
1100
1101#if 0
1102 {
1103 NTSTATUS _s;
1104 ULONG _i = 0;
1105 LARGE_INTEGER RequestVbn = Fcb->Header.AllocationSize;
1106 PLARGE_INTEGER MappedRuns = NULL;
1107
1109 IrpContext,
1110 Vcb,
1111 Fcb,
1112 &RequestVbn,
1113 &MappedRuns
1114 );
1115 if (!NT_SUCCESS(_s) || NULL == MappedRuns) {
1116 DbgBreak();
1117 goto exit_to_get_rps;
1118 }
1119
1120 while (MappedRuns[_i*2 + 0].QuadPart != 0 ||
1121 MappedRuns[_i*2 + 1].QuadPart != 0 ) {
1122 DEBUG(DL_MAP, ("Ext2QueryExtentMappings: %wZ %d Vbn = %I64xh Lbn = %I64xh\n",
1123 &Fcb->Mcb->FullName, _i,
1124 MappedRuns[_i*2 + 0].QuadPart,
1125 MappedRuns[_i*2 + 1].QuadPart));
1126 _i++;
1127 }
1128
1129exit_to_get_rps:
1130
1131 if (MappedRuns) {
1132 Ext2FreePool(MappedRuns, 'RE2E');
1133 }
1134 }
1135#endif
1136
1137 } _SEH2_FINALLY {
1138
1139 if (FcbResourceAcquired) {
1141 }
1142
1143 if (Chain) {
1145 }
1146
1149 Status = Ext2QueueRequest(IrpContext);
1150 } else {
1151 Ext2CompleteIrpContext(IrpContext, Status);
1152 }
1153 }
1154 } _SEH2_END;
1155
1156 return Status;
1157}
Definition: Header.h:9
#define BLOCK_BITS
Definition: stream.h:22
#define ULONG_PTR
Definition: config.h:101
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
NTSTATUS Ext2QueryExtentMappings(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Fcb, IN PLARGE_INTEGER RequestVbn, OUT PLARGE_INTEGER *pMappedRuns)
Definition: fsctl.c:670
VOID Ext2DestroyExtentChain(IN PEXT2_EXTENT Chain)
Definition: memory.c:546
NTSTATUS Ext2BuildExtents(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONGLONG Offset, IN ULONG Size, IN BOOLEAN bAlloc, OUT PEXT2_EXTENT *Chain)
Definition: memory.c:1207
#define DL_MAP
Definition: ext2fs.h:1444
#define DbgBreak()
Definition: ext2fs.h:46
_In_ LONGLONG Vbn
Definition: fsrtlfuncs.h:470
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
struct STARTING_VCN_INPUT_BUFFER * PSTARTING_VCN_INPUT_BUFFER
#define STATUS_END_OF_FILE
Definition: shellext.h:67
uint64 Length
Definition: DriveVolume.h:48
LARGE_INTEGER StartingVcn
Definition: winioctl.h:608
struct RETRIEVAL_POINTERS_BUFFER::@3333 Extents[1]
LARGE_INTEGER StartingVcn
Definition: winioctl.h:623
FSRTL_ADVANCED_FCB_HEADER Header
Definition: cdstruc.h:925
int64_t LONGLONG
Definition: typedefs.h:68
ret QuadPart
Definition: rtlfuncs.h:3089

Referenced by Ext2UserFsRequest().

◆ Ext2InitializeReparseData()

VOID Ext2InitializeReparseData ( IN PREPARSE_DATA_BUFFER  RDB,
USHORT  PathBufferLength 
)

Definition at line 1346 of file fsctl.c.

1347{
1348 ASSERT(FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.SubstituteNameOffset) ==
1350 RDB->ReparseTag = IO_REPARSE_TAG_SYMLINK;
1351 RDB->ReparseDataLength = FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) -
1352 FIELD_OFFSET(REPARSE_DATA_BUFFER, GenericReparseBuffer.DataBuffer) +
1353 PathBufferLength * sizeof(WCHAR);
1354 RDB->Reserved = 0;
1355 RDB->SymbolicLinkReparseBuffer.SubstituteNameOffset = PathBufferLength;
1356 RDB->SymbolicLinkReparseBuffer.SubstituteNameLength = PathBufferLength;
1357 RDB->SymbolicLinkReparseBuffer.PrintNameOffset = 0;
1358 RDB->SymbolicLinkReparseBuffer.PrintNameLength = PathBufferLength;
1359 RDB->SymbolicLinkReparseBuffer.Flags = SYMLINK_FLAG_RELATIVE;
1360 RtlZeroMemory(&RDB->SymbolicLinkReparseBuffer.PathBuffer, PathBufferLength * 2);
1361}
#define REPARSE_DATA_BUFFER_HEADER_SIZE
Definition: vista.c:17
#define SYMLINK_FLAG_RELATIVE
Definition: shellext.h:193
USHORT SubstituteNameOffset
Definition: shellext.h:171
UCHAR DataBuffer[1]
Definition: shellext.h:188
#define IO_REPARSE_TAG_SYMLINK
Definition: iotypes.h:7240
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by Ext2GetReparsePoint().

◆ Ext2InspectReparseData()

NTSTATUS Ext2InspectReparseData ( IN PREPARSE_DATA_BUFFER  RDB,
IN ULONG  InputBufferLength 
)

Definition at line 1293 of file fsctl.c.

1297{
1299
1300 if (!RDB) {
1302 goto out;
1303 }
1304
1305 if (InputBufferLength < sizeof(REPARSE_DATA_BUFFER)) {
1307 goto out;
1308 }
1309
1310 if (InputBufferLength < RDB->ReparseDataLength) {
1312 goto out;
1313 }
1314
1315 if (RDB->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
1317 goto out;
1318 }
1319
1320 if ((PUCHAR)RDB->SymbolicLinkReparseBuffer.PathBuffer
1321 + RDB->SymbolicLinkReparseBuffer.SubstituteNameOffset
1322 + RDB->SymbolicLinkReparseBuffer.SubstituteNameLength
1323 > (PUCHAR)RDB + InputBufferLength ) {
1325 goto out;
1326 }
1327
1328 if ((PUCHAR)RDB->SymbolicLinkReparseBuffer.PathBuffer
1329 + RDB->SymbolicLinkReparseBuffer.PrintNameOffset
1330 + RDB->SymbolicLinkReparseBuffer.PrintNameLength
1331 > (PUCHAR)RDB + InputBufferLength) {
1333 goto out;
1334 }
1335
1336 if (RDB->SymbolicLinkReparseBuffer.Flags != SYMLINK_FLAG_RELATIVE) {
1338 goto out;
1339 }
1340
1341out:
1342 return Status;
1343}
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
static FILE * out
Definition: regtests2xml.c:44
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:322

Referenced by Ext2SetReparsePoint().

◆ Ext2InvalidateVolumes()

NTSTATUS Ext2InvalidateVolumes ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 296 of file fsctl.c.

297{
299 PIRP Irp;
301
302#ifndef __REACTOS__
303 PVPB NewVpb = NULL;
304#endif
306 PLIST_ENTRY ListEntry;
307
308 ULONG InputLength = 0;
311 BOOLEAN GlobalResourceAcquired = FALSE;
312
314
315 _SEH2_TRY {
316
317 Irp = IrpContext->Irp;
319
323 }
324
325 if (!SeSinglePrivilegeCheck(Privilege, Irp->RequestorMode)) {
328 }
329
330
331#ifndef _GNU_NTIFS_
332 InputLength = IrpSp->Parameters.FileSystemControl.InputBufferLength;
333#else
334 InputLength = ((PEXTENDED_IO_STACK_LOCATION)(IrpSp))->
335 Parameters.FileSystemControl.InputBufferLength;
336#endif
337
338#if defined(_WIN64)
339 if (IoIs32bitProcess(Irp)) {
340 if (InputLength != sizeof(UINT32)) {
343 }
344 Handle = (HANDLE) LongToHandle( (*(PUINT32)Irp->AssociatedIrp.SystemBuffer) );
345 } else
346#endif
347 {
348 if (InputLength != sizeof(HANDLE)) {
351 }
352 Handle = *(PHANDLE)Irp->AssociatedIrp.SystemBuffer;
353 }
354
356 0,
359 (void **)&FileObject,
360 NULL );
361
362 if (!NT_SUCCESS(Status)) {
364 } else {
365 DeviceObject = FileObject->DeviceObject;
367 }
368
370 GlobalResourceAcquired = TRUE;
371
372 ListEntry = Ext2Global->VcbList.Flink;
373 while (ListEntry != &Ext2Global->VcbList) {
374
375 PEXT2_VCB Vcb = CONTAINING_RECORD(ListEntry, EXT2_VCB, Next);
376 ListEntry = ListEntry->Flink;
377
378 DEBUG(DL_DBG, ( "Ext2InvalidateVolumes: Vcb=%xh Vcb->Vpb=%xh "
379 "Blink = %p &Vcb->Next = %p\n",
380 Vcb, Vcb->Vpb, ListEntry->Blink, &Vcb->Next));
381
382 if (Vcb->Vpb && (Vcb->Vpb->RealDevice == DeviceObject)) {
383
384 DEBUG(DL_DBG, ( "Ext2InvalidateVolumes: Got Vcb=%xh Vcb->Vpb=%xh "
385 "Blink = %p &Vcb->Next = %p\n",
386 Vcb, Vcb->Vpb, ListEntry->Blink, &Vcb->Next));
387 /* dismount the volume */
388 Ext2CheckDismount(IrpContext, Vcb, FALSE);
389 }
390 }
391
392 } _SEH2_FINALLY {
393
394 if (GlobalResourceAcquired) {
396 }
397
398 if (!IrpContext->ExceptionInProgress) {
399 Ext2CompleteIrpContext(IrpContext, Status);
400 }
401 } _SEH2_END;
402
403 return Status;
404}
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
unsigned int UINT32
#define LongToHandle(h)
Definition: basetsd.h:82
unsigned int * PUINT32
Definition: basetsd.h:125
ULONG Handle
Definition: gdb_input.c:15
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
#define SE_TCB_PRIVILEGE
Definition: security.c:661
BOOLEAN NTAPI SeSinglePrivilegeCheck(_In_ LUID PrivilegeValue, _In_ KPROCESSOR_MODE PreviousMode)
Checks if a single privilege is present in the context of the calling thread.
Definition: priv.c:744
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
LIST_ENTRY VcbList
Definition: ext2fs.h:545
PDEVICE_OBJECT DeviceObject
Definition: iotypes.h:3223
Definition: typedefs.h:120
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
PVOID HANDLE
Definition: typedefs.h:73
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
BOOL Privilege(LPTSTR pszPrivilege, BOOL bEnable)
Definition: user_lib.cpp:531
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
#define ObDereferenceObject
Definition: obfuncs.h:203

Referenced by Ext2UserFsRequest().

◆ Ext2IsHandleCountZero()

BOOLEAN Ext2IsHandleCountZero ( IN PEXT2_VCB  Vcb)

Definition at line 68 of file fsctl.c.

69{
72
73 for ( List = Vcb->FcbList.Flink;
74 List != &Vcb->FcbList;
75 List = List->Flink ) {
76
78
80 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
81
82 DEBUG(DL_INF, ( "Ext2IsHandleCountZero: Inode:%xh File:%S OpenHandleCount=%xh\n",
83 Fcb->Inode->i_ino, Fcb->Mcb->ShortName.Buffer, Fcb->OpenHandleCount));
84
85 if (Fcb->OpenHandleCount) {
86 return FALSE;
87 }
88 }
89
90 return TRUE;
91}
ULONG OpenHandleCount
Definition: ntfs.h:537
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550

Referenced by Ext2LockVcb().

◆ Ext2IsMediaWriteProtected()

BOOLEAN Ext2IsMediaWriteProtected ( IN PEXT2_IRP_CONTEXT  IrpContext,
IN PDEVICE_OBJECT  TargetDevice 
)

Definition at line 2005 of file fsctl.c.

2009{
2010 PIRP Irp;
2011 KEVENT Event;
2014
2016
2019 NULL,
2020 0,
2021 NULL,
2022 0,
2023 FALSE,
2024 &Event,
2025 &IoStatus );
2026
2027 if (Irp == NULL) {
2028 return FALSE;
2029 }
2030
2032
2034
2035 if (Status == STATUS_PENDING) {
2036
2038 Executive,
2039 KernelMode,
2040 FALSE,
2042
2043 Status = IoStatus.Status;
2044 }
2045
2047}
#define VOID
Definition: acefi.h:82
#define IOCTL_DISK_IS_WRITABLE
Definition: cdrw_usr.h:172
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
__in UCHAR __in POWER_STATE __in_opt PVOID __in PIO_STATUS_BLOCK IoStatus
Definition: mxum.h:159
@ NotificationEvent
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
#define IoCallDriver
Definition: irp.c:1225
#define STATUS_MEDIA_WRITE_PROTECTED
Definition: udferr_usr.h:161
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
_Must_inspect_result_ __drv_aliasesMem PDEVICE_OBJECT _In_ PDEVICE_OBJECT TargetDevice
Definition: iofuncs.h:691
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823
@ Executive
Definition: ketypes.h:415

Referenced by Ext2InitializeVcb(), and Ext2VerifyVolume().

◆ Ext2IsVolumeDirty()

NTSTATUS Ext2IsVolumeDirty ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 618 of file fsctl.c.

621{
623 PIRP Irp;
626
627 _SEH2_TRY {
628
629 Irp = IrpContext->Irp;
631
632 //
633 // Get a pointer to the output buffer. Look at the system buffer field in th
634 // irp first. Then the Irp Mdl.
635 //
636
637 if (Irp->AssociatedIrp.SystemBuffer != NULL) {
638
639 VolumeState = Irp->AssociatedIrp.SystemBuffer;
640
641 } else if (Irp->MdlAddress != NULL) {
642
644
645 } else {
646
649 }
650
651 if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(ULONG)) {
654 }
655
656 *VolumeState = 0;
657
658 } _SEH2_FINALLY {
659
660 if (!IrpContext->ExceptionInProgress) {
661 Ext2CompleteIrpContext(IrpContext, status);
662 }
663 } _SEH2_END;
664
665 return status;
666}
IN PVCB IN FAT_VOLUME_STATE VolumeState
Definition: fatprocs.h:1998
uint32_t * PULONG
Definition: typedefs.h:59
#define MmGetSystemAddressForMdl(Mdl)

Referenced by Ext2UserFsRequest().

◆ Ext2IsVolumeMounted()

NTSTATUS Ext2IsVolumeMounted ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 2494 of file fsctl.c.

2495{
2497 PEXT2_VCB Vcb = 0;
2499
2500 ASSERT(IrpContext);
2501
2502 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
2503 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
2504
2505
2506 DeviceObject = IrpContext->DeviceObject;
2507
2508 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
2509
2511
2512 Ext2VerifyVcb (IrpContext, Vcb);
2513
2514 Ext2CompleteIrpContext(IrpContext, Status);
2515
2516 return Status;
2517}
VOID Ext2VerifyVcb(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)
Definition: fsctl.c:2277

Referenced by Ext2UserFsRequest().

◆ Ext2LockVcb()

NTSTATUS Ext2LockVcb ( IN PEXT2_VCB  Vcb,
IN PFILE_OBJECT  FileObject 
)

Definition at line 94 of file fsctl.c.

96{
98
99 _SEH2_TRY {
100
101 if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
102 DEBUG(DL_INF, ( "Ext2LockVolume: Volume is already locked.\n"));
105 }
106
107 if (Vcb->OpenHandleCount > (ULONG)(FileObject ? 1 : 0)) {
108 DEBUG(DL_INF, ( "Ext2LockVcb: There are still opened files.\n"));
109
112 }
113
115 DEBUG(DL_INF, ( "Ext2LockVcb: Thare are still opened files.\n"));
116
119 }
120
123 Vcb->LockFile = FileObject;
124
125 DEBUG(DL_INF, ( "Ext2LockVcb: Volume locked.\n"));
126
127 } _SEH2_FINALLY {
128 // Nothing
129 } _SEH2_END;
130
131 return Status;
132}
BOOLEAN Ext2IsHandleCountZero(IN PEXT2_VCB Vcb)
Definition: fsctl.c:68
VOID Ext2SetVpbFlag(IN PVPB Vpb, IN USHORT Flag)
Definition: fsctl.c:44
#define VCB_VOLUME_LOCKED
Definition: ext2fs.h:789
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145

Referenced by Ext2LockVolume().

◆ Ext2LockVolume()

NTSTATUS Ext2LockVolume ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 136 of file fsctl.c.

137{
142 BOOLEAN VcbResourceAcquired = FALSE;
143
144 _SEH2_TRY {
145
146 ASSERT(IrpContext != NULL);
147
148 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
149 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
150
151 DeviceObject = IrpContext->DeviceObject;
152
154
155 //
156 // This request is not allowed on the main device object
157 //
161 }
162
163 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
164
165 ASSERT(Vcb != NULL);
166
167 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
168 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
169
171
172 IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
173
174#if (_WIN32_WINNT >= 0x0500)
176#endif
178 &Vcb->MainResource,
179 TRUE );
180
181 VcbResourceAcquired = TRUE;
182
183 /* flush dirty data before locking the volume */
184 if (!IsVcbReadOnly(Vcb)) {
185 Ext2FlushFiles(IrpContext, Vcb, FALSE);
186 Ext2FlushVolume(IrpContext, Vcb, FALSE);
187 }
188
190
191 } _SEH2_FINALLY {
192
193 if (VcbResourceAcquired) {
194 ExReleaseResourceLite(&Vcb->MainResource);
195 }
196
197 if (!IrpContext->ExceptionInProgress) {
198 Ext2CompleteIrpContext(IrpContext, Status);
199 }
200 } _SEH2_END;
201
202 return Status;
203}
NTSTATUS Ext2LockVcb(IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject)
Definition: fsctl.c:94
#define IsVcbReadOnly(Vcb)
Definition: ext2fs.h:814
NTSTATUS NTAPI CcWaitForCurrentLazyWriterActivity(VOID)
Definition: lazyrite.c:30

Referenced by Ext2Format(), and Ext2UserFsRequest().

◆ Ext2MountVolume()

NTSTATUS Ext2MountVolume ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 2050 of file fsctl.c.

2051{
2053 BOOLEAN GlobalDataResourceAcquired = FALSE;
2054 PIRP Irp;
2055 PIO_STACK_LOCATION IoStackLocation;
2058 PDEVICE_OBJECT VolumeDeviceObject = NULL;
2059 PEXT2_VCB Vcb = NULL, OldVcb = NULL;
2060 PVPB OldVpb = NULL, Vpb = NULL;
2061 PEXT2_SUPER_BLOCK Ext2Sb = NULL;
2062 ULONG dwBytes;
2063 DISK_GEOMETRY DiskGeometry;
2064
2065 _SEH2_TRY {
2066
2067 ASSERT(IrpContext != NULL);
2068 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
2069 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
2070
2071 MainDeviceObject = IrpContext->DeviceObject;
2072
2073 //
2074 // Make sure we can wait.
2075 //
2076
2077 SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
2078
2079 //
2080 // This request is only allowed on the main device object
2081 //
2085 }
2086
2090 }
2091
2092#if 0
2093 if (IrpContext->RealDevice->Size >= sizeof(ULONG) + sizeof(DEVICE_OBJECT) &&
2094 *((PULONG)IrpContext->RealDevice->DeviceExtension) == 'DSSA') {
2095 } else {
2098 }
2099#endif
2100
2101 Irp = IrpContext->Irp;
2102 IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
2104 IoStackLocation->Parameters.MountVolume.DeviceObject;
2105
2106 dwBytes = sizeof(DISK_GEOMETRY);
2110 NULL,
2111 0,
2112 &DiskGeometry,
2113 &dwBytes );
2114
2115 if (!NT_SUCCESS(Status)) {
2117 }
2118
2120 MainDeviceObject->DriverObject,
2121 sizeof(EXT2_VCB),
2122 NULL,
2124 0,
2125 FALSE,
2126 &VolumeDeviceObject );
2127
2128 if (!NT_SUCCESS(Status)) {
2130 }
2131 INC_MEM_COUNT(PS_VCB, VolumeDeviceObject, sizeof(EXT2_VCB));
2132
2133#ifdef _PNP_POWER_
2134 /* don't care about power management requests */
2135 VolumeDeviceObject->DeviceObjectExtension->PowerControlNeeded = FALSE;
2136#endif
2137
2138 VolumeDeviceObject->StackSize = (CCHAR)(TargetDeviceObject->StackSize + 1);
2139 ClearFlag(VolumeDeviceObject->Flags, DO_DEVICE_INITIALIZING);
2140
2141/*
2142 These are for buffer-address alignment requirements.
2143 Never do this check, unless you want fail user requests :)
2144
2145 if (TargetDeviceObject->AlignmentRequirement >
2146 VolumeDeviceObject->AlignmentRequirement) {
2147
2148 VolumeDeviceObject->AlignmentRequirement =
2149 TargetDeviceObject->AlignmentRequirement;
2150 }
2151
2152 if (DiskGeometry.BytesPerSector - 1 >
2153 VolumeDeviceObject->AlignmentRequirement) {
2154 VolumeDeviceObject->AlignmentRequirement =
2155 DiskGeometry.BytesPerSector - 1;
2156 TargetDeviceObject->AlignmentRequirement =
2157 DiskGeometry.BytesPerSector - 1;
2158 }
2159*/
2160 (IoStackLocation->Parameters.MountVolume.Vpb)->DeviceObject =
2161 VolumeDeviceObject;
2162 Vpb = IoStackLocation->Parameters.MountVolume.Vpb;
2163
2164 Vcb = (PEXT2_VCB) VolumeDeviceObject->DeviceExtension;
2165
2166 RtlZeroMemory(Vcb, sizeof(EXT2_VCB));
2167 Vcb->Identifier.Type = EXT2VCB;
2168 Vcb->Identifier.Size = sizeof(EXT2_VCB);
2169 Vcb->TargetDeviceObject = TargetDeviceObject;
2170 Vcb->DiskGeometry = DiskGeometry;
2171 InitializeListHead(&Vcb->Next);
2172
2173 Status = Ext2LoadSuper(Vcb, FALSE, &Ext2Sb);
2174 if (!NT_SUCCESS(Status)) {
2175 Vcb = NULL;
2178 }
2179 ASSERT (NULL != Ext2Sb);
2180
2181 /* check Linux Ext2/Ext3 volume magic */
2182 if (Ext2Sb->s_magic == EXT2_SUPER_MAGIC) {
2183 DEBUG(DL_INF, ( "Volume of ext2 file system is found.\n"));
2184 } else {
2186 Vcb = NULL;
2188 }
2189
2190 DEBUG(DL_DBG, ("Ext2MountVolume: DevObject=%p Vcb=%p\n", VolumeDeviceObject, Vcb));
2191
2192 /* initialize Vcb structure */
2193 Status = Ext2InitializeVcb( IrpContext, Vcb, Ext2Sb,
2195 VolumeDeviceObject, Vpb);
2196
2197 if (NT_SUCCESS(Status)) {
2198
2200
2202 GlobalDataResourceAcquired = TRUE;
2203
2204 for (List = Ext2Global->VcbList.Flink;
2205 List != &Ext2Global->VcbList;
2206 List = List->Flink) {
2207
2208 OldVcb = CONTAINING_RECORD(List, EXT2_VCB, Next);
2209 OldVpb = OldVcb->Vpb;
2210
2211 /* in case we are already in the queue, should not happen */
2212 if (OldVpb == Vpb) {
2213 continue;
2214 }
2215
2216 if ( (OldVpb->SerialNumber == Vpb->SerialNumber) &&
2217 (!IsMounted(OldVcb)) && (IsFlagOn(OldVcb->Flags, VCB_NEW_VPB)) &&
2218 (OldVpb->RealDevice == TargetDeviceObject) &&
2219 (OldVpb->VolumeLabelLength == Vpb->VolumeLabelLength) &&
2220 (RtlEqualMemory(&OldVpb->VolumeLabel[0],
2221 &Vpb->VolumeLabel[0],
2222 Vpb->VolumeLabelLength)) &&
2223 (RtlEqualMemory(&OldVcb->SuperBlock->s_uuid[0],
2224 &Vcb->SuperBlock->s_uuid[0], 16)) ) {
2225 ClearFlag(OldVcb->Flags, VCB_MOUNTED);
2226 }
2227 }
2228
2229 SetLongFlag(Vcb->Flags, VCB_MOUNTED);
2230 SetFlag(Vcb->Vpb->Flags, VPB_MOUNTED);
2232 Vcb = NULL;
2233 Vpb = NULL;
2235
2236 } else {
2237
2238 Vcb = NULL;
2239 }
2240
2241 } _SEH2_FINALLY {
2242
2243 if (GlobalDataResourceAcquired) {
2245 }
2246
2247 if (!NT_SUCCESS(Status)) {
2248
2249 if (!NT_SUCCESS(Status)) {
2250 if ( Vpb != NULL ) {
2251 Vpb->DeviceObject = NULL;
2252 }
2253 }
2254
2255 if (Vcb) {
2257 } else {
2258 if (Ext2Sb) {
2259 Ext2FreePool(Ext2Sb, EXT2_SB_MAGIC);
2260 }
2261 if (VolumeDeviceObject) {
2262 IoDeleteDevice(VolumeDeviceObject);
2263 DEC_MEM_COUNT(PS_VCB, VolumeDeviceObject, sizeof(EXT2_VCB));
2264 }
2265 }
2266 }
2267
2268 if (!IrpContext->ExceptionInProgress) {
2269 Ext2CompleteIrpContext(IrpContext, Status);
2270 }
2271 } _SEH2_END;
2272
2273 return Status;
2274}
static PDEVICE_OBJECT MainDeviceObject
#define IOCTL_DISK_GET_DRIVE_GEOMETRY
Definition: cdrw_usr.h:169
#define PS_VCB
Definition: common.h:17
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
struct _EXT2_VCB EXT2_VCB
#define EXT2_SUPER_MAGIC
Definition: ext2fs.h:349
#define EXT2_SB_MAGIC
Definition: ext2fs.h:302
NTSTATUS Ext2InitializeVcb(PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_SUPER_BLOCK Ext2Sb, PDEVICE_OBJECT TargetDevice, PDEVICE_OBJECT VolumeDevice, PVPB Vpb)
#define EXT2_UNLOAD_PENDING
Definition: ext2fs.h:590
NTSTATUS Ext2LoadSuper(IN PEXT2_VCB Vcb, IN BOOLEAN bVerify, OUT PEXT2_SUPER_BLOCK *Sb)
Definition: generic.c:29
VOID Ext2InsertVcb(PEXT2_VCB Vcb)
Definition: memory.c:1935
NTSTATUS Ext2DiskIoControl(IN PDEVICE_OBJECT DeviceOjbect, IN ULONG IoctlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, IN OUT PVOID OutputBuffer, IN OUT PULONG OutputBufferSize)
Definition: block.c:609
IN OUT PVCB IN PDEVICE_OBJECT TargetDeviceObject
Definition: fatprocs.h:1674
#define RtlEqualMemory(a, b, c)
Definition: kdvm.h:18
struct _DISK_GEOMETRY DISK_GEOMETRY
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
#define FILE_DEVICE_DISK_FILE_SYSTEM
Definition: winioctl.h:114
PVOID DeviceExtension
Definition: env_spec_w32.h:418
ULONG Flags
Definition: ext2fs.h:523
struct _IO_STACK_LOCATION::@3978::@3998 MountVolume
WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH/sizeof(WCHAR)]
Definition: iotypes.h:198
USHORT VolumeLabelLength
Definition: iotypes.h:193
ULONG SerialNumber
Definition: iotypes.h:196
struct _DEVICE_OBJECT * RealDevice
Definition: iotypes.h:195
char CCHAR
Definition: typedefs.h:51
#define STATUS_UNRECOGNIZED_VOLUME
Definition: udferr_usr.h:173

Referenced by Ext2FileSystemControl().

◆ Ext2OplockRequest()

NTSTATUS Ext2OplockRequest ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 451 of file fsctl.c.

454{
456
457 ULONG FsCtrlCode;
460
461 PIRP Irp = NULL;
464
468
469 ULONG OplockCount = 0;
470
471 BOOLEAN VcbResourceAcquired = FALSE;
472 BOOLEAN FcbResourceAcquired = FALSE;
473
474 ASSERT(IrpContext);
475
476 _SEH2_TRY {
477
478 Irp = IrpContext->Irp;
479 ASSERT(Irp);
480
482 ASSERT(IrpSp);
484
485 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
486 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
487
488 DeviceObject = IrpContext->DeviceObject;
489
490 //
491 // This request is not allowed on the main device object
492 //
496 }
497
498 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
499
500 ASSERT(Vcb != NULL);
501
502 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
503 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
504
506
507 FileObject = IrpContext->FileObject;
508
509 Fcb = (PEXT2_FCB) FileObject->FsContext;
510
511 //
512 // This request is not allowed on volumes
513 //
514
515 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
518 }
519
521 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
522
523 if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
526 }
527
528 Ccb = (PEXT2_CCB) FileObject->FsContext2;
529 if (Ccb == NULL) {
532 }
533
534
536 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
537
538 FsCtrlCode = EIrpSp->Parameters.FileSystemControl.FsControlCode;
539
540 switch (FsCtrlCode) {
541
545
546 VcbResourceAcquired =
548 &Vcb->MainResource,
549 IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
550
551 ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
552
553 FcbResourceAcquired =
556 IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
557
558 if (FsCtrlCode == FSCTL_REQUEST_OPLOCK_LEVEL_2) {
559 OplockCount = (ULONG) FsRtlAreThereCurrentFileLocks(&Fcb->FileLockAnchor);
560 } else {
561 OplockCount = Fcb->OpenHandleCount;
562 }
563
564 break;
565
570
571 FcbResourceAcquired =
574 IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
575
576 break;
577
578 default:
579
580 Ext2BugCheck(EXT2_BUGCHK_FSCTL, FsCtrlCode, 0, 0);
581 }
582
583
584 //
585 // Call the FsRtl routine to grant/acknowledge oplock.
586 //
587
588 Status = FsRtlOplockFsctrl( &Fcb->Oplock,
589 Irp,
590 OplockCount );
591
592 //
593 // Set the flag indicating if Fast I/O is possible
594 //
595
596 Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
597 IrpContext->Irp = NULL;
598
599 } _SEH2_FINALLY {
600
601 if (FcbResourceAcquired) {
603 }
604
605 if (VcbResourceAcquired) {
606 ExReleaseResourceLite(&Vcb->MainResource);
607 }
608
610 Ext2CompleteIrpContext(IrpContext, Status);
611 }
612 } _SEH2_END;
613
614 return Status;
615}
#define Ext2BugCheck(A, B, C, D)
Definition: ext2fs.h:340
#define EXT2_BUGCHK_FSCTL
Definition: ext2fs.h:328
FAST_IO_POSSIBLE Ext2IsFastIoPossible(IN PEXT2_FCB Fcb)
Definition: fastio.c:38
#define FsRtlAreThereCurrentFileLocks(FL)
Definition: fsrtlfuncs.h:1584
#define FSCTL_OPLOCK_BREAK_NOTIFY
Definition: nt_native.h:831
#define FSCTL_OPLOCK_BREAK_ACKNOWLEDGE
Definition: nt_native.h:829
#define FSCTL_REQUEST_OPLOCK_LEVEL_1
Definition: nt_native.h:826
#define FSCTL_REQUEST_BATCH_OPLOCK
Definition: nt_native.h:828
#define FSCTL_OPBATCH_ACK_CLOSE_PENDING
Definition: nt_native.h:830
#define FSCTL_OPLOCK_BREAK_ACK_NO_2
Definition: nt_native.h:846
#define FSCTL_REQUEST_OPLOCK_LEVEL_2
Definition: nt_native.h:827
NTSTATUS NTAPI FsRtlOplockFsctrl(IN POPLOCK Oplock, IN PIRP Irp, IN ULONG OpenCount)
Definition: oplock.c:1430

Referenced by Ext2UserFsRequest().

◆ Ext2PurgeFile()

NTSTATUS Ext2PurgeFile ( IN PEXT2_FCB  Fcb,
IN BOOLEAN  FlushBeforePurge 
)

Definition at line 2811 of file fsctl.c.

2813{
2815
2816 ASSERT(Fcb != NULL);
2817
2819 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
2820
2821
2822 if (!IsVcbReadOnly(Fcb->Vcb) && FlushBeforePurge) {
2823 DEBUG(DL_INF, ( "Ext2PurgeFile: CcFlushCache on %wZ.\n",
2824 &Fcb->Mcb->FullName));
2827 CcFlushCache(&Fcb->SectionObject, NULL, 0, &IoStatus);
2829 }
2830
2831 if (Fcb->SectionObject.ImageSectionObject) {
2832 DEBUG(DL_INF, ( "Ext2PurgeFile: MmFlushImageSection on %wZ.\n",
2833 &Fcb->Mcb->FullName));
2834 MmFlushImageSection(&Fcb->SectionObject, MmFlushForWrite);
2835 }
2836
2837 if (Fcb->SectionObject.DataSectionObject) {
2838 DEBUG(DL_INF, ( "Ext2PurgeFile: CcPurgeCacheSection on %wZ.\n",
2839 &Fcb->Mcb->FullName));
2840 CcPurgeCacheSection(&Fcb->SectionObject, NULL, 0, FALSE);
2841 }
2842
2843 return STATUS_SUCCESS;
2844}
VOID NTAPI CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, OUT OPTIONAL PIO_STATUS_BLOCK IoStatus)
Definition: cachesub.c:222
#define FCB_FILE_MODIFIED
Definition: ext2fs.h:882
BOOLEAN NTAPI CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN OPTIONAL PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN UninitializeCacheMaps)
Definition: fssup.c:386
BOOLEAN NTAPI ExAcquireSharedStarveExclusive(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:1068
BOOLEAN NTAPI MmFlushImageSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer, IN MMFLUSH_TYPE FlushType)
Definition: section.c:4356
PVCB Vcb
Definition: cdstruc.h:933
ERESOURCE PagingIoResource
Definition: ntfs.h:527

Referenced by Ext2PurgeVolume().

◆ Ext2PurgeVolume()

NTSTATUS Ext2PurgeVolume ( IN PEXT2_VCB  Vcb,
IN BOOLEAN  FlushBeforePurge 
)

Definition at line 2704 of file fsctl.c.

2706{
2707 PEXT2_FCB Fcb;
2708 LIST_ENTRY List, *Next;
2709
2710 BOOLEAN VcbResourceAcquired = FALSE;
2711 BOOLEAN FcbResourceAcquired = FALSE;
2712 BOOLEAN gdResourceAcquired = FALSE;
2713
2714 _SEH2_TRY {
2715
2716 ASSERT(Vcb != NULL);
2717 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
2718 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
2719
2720 ExAcquireResourceExclusiveLite(&Vcb->MainResource, TRUE);
2721 VcbResourceAcquired = TRUE;
2722
2723 if (IsVcbReadOnly(Vcb)) {
2724 FlushBeforePurge = FALSE;
2725 }
2726
2728
2730 FcbResourceAcquired = TRUE;
2731
2732 while (!IsListEmpty(&Vcb->FcbList)) {
2733
2734 Next = RemoveHeadList(&Vcb->FcbList);
2735 Fcb = CONTAINING_RECORD(Next, EXT2_FCB, Next);
2736
2737 DEBUG(DL_INF, ( "Ext2PurgeVolume: %wZ refercount=%xh\n",
2738 &Fcb->Mcb->FullName, Fcb->ReferenceCount));
2739 InsertTailList(&List, &Fcb->Next);
2740 }
2741
2742 while (!IsListEmpty(&List)) {
2743
2744 Next = RemoveHeadList(&List);
2745 Fcb = CONTAINING_RECORD(Next, EXT2_FCB, Next);
2746
2748 &Fcb->MainResource,
2749 TRUE )) {
2750
2751 Ext2PurgeFile(Fcb, FlushBeforePurge);
2752
2753 if (Fcb->ReferenceCount <= 1) {
2754 Fcb->TsDrop.QuadPart = 0;
2755 InsertHeadList(&Vcb->FcbList, &Fcb->Next);
2756 } else {
2757 InsertTailList(&Vcb->FcbList, &Fcb->Next);
2758 }
2760 }
2761 }
2762
2763 if (FcbResourceAcquired) {
2764 ExReleaseResourceLite(&Vcb->FcbLock);
2765 FcbResourceAcquired = FALSE;
2766 }
2767
2768 /* acquire bd lock to avoid bh creation */
2769 ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE);
2770 gdResourceAcquired = TRUE;
2771
2772 /* discard buffer_headers for group_desc */
2773 Ext2DropBH(Vcb);
2774
2775 if (FlushBeforePurge) {
2776 ExAcquireSharedStarveExclusive(&Vcb->PagingIoResource, TRUE);
2777 ExReleaseResourceLite(&Vcb->PagingIoResource);
2778
2779 CcFlushCache(&Vcb->SectionObject, NULL, 0, NULL);
2780 }
2781
2782 if (Vcb->SectionObject.ImageSectionObject) {
2783 MmFlushImageSection(&Vcb->SectionObject, MmFlushForWrite);
2784 }
2785
2786 if (Vcb->SectionObject.DataSectionObject) {
2787 CcPurgeCacheSection(&Vcb->SectionObject, NULL, 0, FALSE);
2788 }
2789
2790 DEBUG(DL_INF, ( "Ext2PurgeVolume: Volume flushed and purged.\n"));
2791
2792 } _SEH2_FINALLY {
2793
2794 if (gdResourceAcquired) {
2795 ExReleaseResourceLite(&Vcb->sbi.s_gd_lock);
2796 }
2797
2798 if (FcbResourceAcquired) {
2799 ExReleaseResourceLite(&Vcb->FcbLock);
2800 }
2801
2802 if (VcbResourceAcquired) {
2803 ExReleaseResourceLite(&Vcb->MainResource);
2804 }
2805 } _SEH2_END;
2806
2807 return STATUS_SUCCESS;
2808}
#define InsertTailList(ListHead, Entry)
#define InsertHeadList(ListHead, Entry)
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
NTSTATUS Ext2PurgeFile(IN PEXT2_FCB Fcb, IN BOOLEAN FlushBeforePurge)
Definition: fsctl.c:2811
VOID Ext2DropBH(IN PEXT2_VCB Vcb)
Definition: generic.c:266

Referenced by Ext2DismountVolume(), Ext2VerifyVolume(), and Ext2WriteVolume().

◆ Ext2QueryExtentMappings()

NTSTATUS Ext2QueryExtentMappings ( IN PEXT2_IRP_CONTEXT  IrpContext,
IN PEXT2_VCB  Vcb,
IN PEXT2_FCB  Fcb,
IN PLARGE_INTEGER  RequestVbn,
OUT PLARGE_INTEGER pMappedRuns 
)

Definition at line 670 of file fsctl.c.

677{
678 PLARGE_INTEGER MappedRuns = NULL;
679 PLARGE_INTEGER PartialRuns = NULL;
680
681 PEXT2_EXTENT Chain = NULL;
683
684 LONGLONG Vbn = 0;
685 ULONG Length = 0;
686 ULONG i = 0;
687
689
690 _SEH2_TRY {
691
692 /* now building all the request extents */
693 while (Vbn < RequestVbn->QuadPart) {
694
695 Length = 0x80000000; /* 2g bytes */
696 if (RequestVbn->QuadPart < Vbn + Length) {
697 Length = (ULONG)(RequestVbn->QuadPart - Vbn);
698 }
699
700 /* build extents for sub-range */
701 Extent = NULL;
703 IrpContext,
704 Vcb,
705 Fcb->Mcb,
706 Vbn,
707 Length,
708 FALSE,
709 &Extent);
710
711 if (!NT_SUCCESS(Status)) {
713 }
714
715 if (Chain) {
716 Ext2JointExtents(Chain, Extent);
717 } else {
718 Chain = Extent;
719 }
720
721 /* allocate extent array */
722 PartialRuns = Ext2AllocatePool(
724 (Ext2CountExtents(Chain) + 2) *
725 (2 * sizeof(LARGE_INTEGER)),
726 'RE2E');
727
728 if (PartialRuns == NULL) {
731 }
732 RtlZeroMemory( PartialRuns,
733 (Ext2CountExtents(Chain) + 2) *
734 (2 * sizeof(LARGE_INTEGER)));
735
736 if (MappedRuns) {
737 RtlMoveMemory(PartialRuns,
738 MappedRuns,
739 i * 2 * sizeof(LARGE_INTEGER));
740 Ext2FreePool(MappedRuns, 'RE2E');
741 }
742 MappedRuns = PartialRuns;
743
744 /* walk all the Mcb runs in Extent */
745 for (; Extent != NULL; Extent = Extent->Next) {
746 MappedRuns[i*2 + 0].QuadPart = Vbn + Extent->Offset;
747 MappedRuns[i*2 + 1].QuadPart = Extent->Lba;
748 i = i+1;
749 }
750
751 Vbn = Vbn + Length;
752 }
753
754 *pMappedRuns = MappedRuns;
755
756 } _SEH2_FINALLY {
757
759 if (MappedRuns) {
760 Ext2FreePool(MappedRuns, 'RE2E');
761 }
762 *pMappedRuns = NULL;
763 }
764
765 if (Chain) {
767 }
768 } _SEH2_END;
769
770 return Status;
771}
VOID Ext2JointExtents(IN PEXT2_EXTENT Chain, IN PEXT2_EXTENT Extent)
Definition: memory.c:527
ULONG Ext2CountExtents(IN PEXT2_EXTENT Chain)
Definition: memory.c:513

Referenced by Ext2GetRetrievalPointers(), and Ext2QueryRetrievalPointers().

◆ Ext2QueryRetrievalPointers()

NTSTATUS Ext2QueryRetrievalPointers ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 774 of file fsctl.c.

777{
778 PIRP Irp = NULL;
781
784
788
789 PLARGE_INTEGER RequestVbn;
790 PLARGE_INTEGER * pMappedRuns;
791
792 ULONG InputSize;
793 ULONG OutputSize;
794
796
797 BOOLEAN FcbResourceAcquired = FALSE;
798
799 _SEH2_TRY {
800
801 ASSERT(IrpContext);
802 Irp = IrpContext->Irp;
803 ASSERT(Irp);
804
807 ASSERT(IrpSp);
808
809 InputSize = EIrpSp->Parameters.FileSystemControl.InputBufferLength;
810 OutputSize = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
811
812 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
813 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
814
815 DeviceObject = IrpContext->DeviceObject;
816
817 DbgBreak();
818
819 /* This request is not allowed on the main device object */
823 }
824
825 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
826 ASSERT(Vcb != NULL);
827 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
828 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
830
831 FileObject = IrpContext->FileObject;
832 Fcb = (PEXT2_FCB) FileObject->FsContext;
833
834 /* check Fcb is valid or not */
835 if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
838 }
839
841 (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
842 if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
845 }
846
847 Ccb = (PEXT2_CCB) FileObject->FsContext2;
848 if (Ccb == NULL) {
851 }
852
854 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
855
856 /* Is requstor in kernel and Fcb a paging file ? */
857 if (Irp->RequestorMode != KernelMode ||
859 InputSize != sizeof(LARGE_INTEGER) ||
860 OutputSize != sizeof(PVOID)) {
863 }
864
869 }
870 FcbResourceAcquired = TRUE;
871
872 RequestVbn = EIrpSp->Parameters.FileSystemControl.Type3InputBuffer;
873 pMappedRuns = Irp->UserBuffer;
874
875 DbgBreak();
876
877 /* request size beyonds whole file size */
878 if (RequestVbn->QuadPart >= Fcb->Header.AllocationSize.QuadPart) {
881 }
882
884 IrpContext,
885 Vcb,
886 Fcb,
887 RequestVbn,
888 pMappedRuns
889 );
890
891 } _SEH2_FINALLY {
892
893 if (FcbResourceAcquired) {
895 }
896
899 Status = Ext2QueueRequest(IrpContext);
900 } else {
901 Ext2CompleteIrpContext(IrpContext, Status);
902 }
903 }
904 } _SEH2_END;
905
906 return Status;
907}
#define FCB_PAGE_FILE
Definition: ext2fs.h:881

Referenced by Ext2UserFsRequest().

◆ Ext2ReadSymlink()

NTSTATUS Ext2ReadSymlink ( IN PEXT2_IRP_CONTEXT  IrpContext,
IN PEXT2_VCB  Vcb,
IN PEXT2_MCB  Mcb,
IN PVOID  Buffer,
IN ULONG  Size,
OUT PULONG  BytesRead 
)

Definition at line 1364 of file fsctl.c.

1372{
1373 return Ext2ReadInode ( IrpContext,
1374 Vcb,
1375 Mcb,
1376 0,
1377 Buffer,
1378 Size,
1379 FALSE,
1380 BytesRead);
1381}
BOOLEAN Ext2ReadInode(PEXT2_VOLUME_INFO Volume, ULONG Inode, PEXT2_INODE InodeBuffer)
Definition: ext2.c:907
Definition: bufpool.h:45
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533

Referenced by Ext2FollowLink(), and Ext2GetReparsePoint().

◆ Ext2SetReparsePoint()

NTSTATUS Ext2SetReparsePoint ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 1572 of file fsctl.c.

1573{
1574 PIRP Irp = NULL;
1576
1578
1579 PEXT2_VCB Vcb = NULL;
1580 PEXT2_FCB Fcb = NULL;
1581 PEXT2_CCB Ccb = NULL;
1582 PEXT2_MCB Mcb = NULL;
1583
1585
1588 ULONG BytesWritten = 0;
1589
1590 PEXT2_FCB ParentDcb = NULL; /* Dcb of it's current parent */
1591 PEXT2_MCB ParentMcb = NULL;
1592
1594
1595 UNICODE_STRING UniName;
1597
1598 PCHAR OemNameBuffer = NULL;
1599 int OemNameLength = 0, i;
1600
1601 BOOLEAN MainResourceAcquired = FALSE;
1602 BOOLEAN FcbLockAcquired = FALSE;
1603
1604 _SEH2_TRY {
1605
1606 Ccb = IrpContext->Ccb;
1607 ASSERT(Ccb != NULL);
1609 (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
1610 DeviceObject = IrpContext->DeviceObject;
1611 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
1612 Fcb = IrpContext->Fcb;
1613 Mcb = Fcb->Mcb;
1614 Irp = IrpContext->Irp;
1616
1618 FcbLockAcquired = TRUE;
1619
1620 ParentMcb = Mcb->Parent;
1621 ParentDcb = ParentMcb->Fcb;
1622 if (ParentDcb == NULL) {
1623 ParentDcb = Ext2AllocateFcb(Vcb, ParentMcb);
1624 }
1625 if (ParentDcb) {
1626 Ext2ReferXcb(&ParentDcb->ReferenceCount);
1627 }
1628
1629 if (!Mcb)
1631
1632 if (FcbLockAcquired) {
1633 ExReleaseResourceLite(&Vcb->FcbLock);
1634 FcbLockAcquired = FALSE;
1635 }
1636
1638 &Fcb->MainResource,
1639 IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {
1642 }
1643 MainResourceAcquired = TRUE;
1644
1645 InputBuffer = Irp->AssociatedIrp.SystemBuffer;
1647
1650 if (!NT_SUCCESS(Status)) {
1652 }
1653
1654 UniName.Length = RDB->SymbolicLinkReparseBuffer.SubstituteNameLength;
1655 UniName.MaximumLength = UniName.Length;
1656 UniName.Buffer =
1657 (PWCHAR)((PUCHAR)&RDB->SymbolicLinkReparseBuffer.PathBuffer
1658 + RDB->SymbolicLinkReparseBuffer.SubstituteNameOffset);
1659
1660 OemNameLength = Ext2UnicodeToOEMSize(Vcb, &UniName);
1661 if (OemNameLength > USHRT_MAX) {
1664 }
1665 OemName.Length = (USHORT)OemNameLength;
1666 OemName.MaximumLength = OemNameLength + 1;
1667 OemNameBuffer = OemName.Buffer = Ext2AllocatePool(PagedPool,
1668 OemName.MaximumLength,
1669 'NL2E');
1670 if (!OemNameBuffer) {
1673 }
1674
1675 Ext2UnicodeToOEM(Vcb, &OemName, &UniName);
1676 OemName.Buffer[OemName.Length] = '\0';
1677 for (i = 0;i < OemName.Length;i++) {
1678 if (OemName.Buffer[i] == '\\') {
1679 OemName.Buffer[i] = '/';
1680 }
1681 }
1682
1683 /* free all data blocks of the inode (to be set as symlink) */
1684 {
1685 LARGE_INTEGER zero = {0};
1686 Status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &zero);
1687 }
1688
1689 /* decrease dir count of group desc and vcb stat */
1690 if (S_ISDIR(Mcb->Inode.i_mode)) {
1691
1692 ULONG group = (Mcb->Inode.i_ino - 1) / INODES_PER_GROUP;
1693 Ext2UpdateGroupDirStat(IrpContext, Vcb, group);
1694
1695 /* drop extra reference for dir inode */
1696 ext3_dec_count(&Mcb->Inode);
1697 }
1698
1699 /* overwrite inode mode as type SYMLINK */
1700 Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
1702
1703 Status = Ext2WriteSymlink(IrpContext, Vcb, Mcb, OemNameBuffer,
1704 OemNameLength, &BytesWritten);
1705 if (NT_SUCCESS(Status)) {
1706 Ext2SetFileType(IrpContext, Vcb, ParentDcb, Mcb,
1707 S_IFLNK | S_IRWXUGO);
1708 }
1709
1710 } _SEH2_FINALLY {
1711
1712 if (FcbLockAcquired) {
1713 ExReleaseResourceLite(&Vcb->FcbLock);
1714 FcbLockAcquired = FALSE;
1715 }
1716
1717 if (MainResourceAcquired) {
1719 }
1720
1721 if (OemNameBuffer) {
1722 Ext2FreePool(OemNameBuffer, 'NL2E');
1723 }
1724
1725 if (NT_SUCCESS(Status)) {
1727 IrpContext,
1728 Vcb,
1729 Mcb,
1732 }
1733
1736 Status = Ext2QueueRequest(IrpContext);
1737 } else {
1738 Ext2CompleteIrpContext(IrpContext, Status);
1739 }
1740 }
1741
1742 if (ParentDcb) {
1744 }
1745 } _SEH2_END;
1746
1747 return Status;
1748}
#define S_ISDIR(mode)
Definition: various.h:18
#define PagedPool
Definition: env_spec_w32.h:308
NTSTATUS Ext2InspectReparseData(IN PREPARSE_DATA_BUFFER RDB, IN ULONG InputBufferLength)
Definition: fsctl.c:1293
NTSTATUS Ext2WriteSymlink(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN PVOID Buffer, IN ULONG Size, OUT PULONG BytesWritten)
Definition: fsctl.c:1519
#define S_IRWXUGO
Definition: ext2fs.h:400
NTSTATUS Ext2TruncateFile(PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, PLARGE_INTEGER AllocationSize)
Definition: fileinfo.c:1204
BOOLEAN Ext2SaveInode(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN struct inode *Inode)
Definition: generic.c:552
#define INODES_PER_GROUP
Definition: ext2fs.h:99
ULONG Ext2UnicodeToOEMSize(IN PEXT2_VCB Vcb, IN PUNICODE_STRING Unicode)
Definition: misc.c:239
void ext3_dec_count(struct inode *inode)
Definition: htree.c:312
NTSTATUS Ext2SetFileType(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, IN PEXT2_MCB Mcb, IN umode_t mode)
Definition: generic.c:1951
NTSTATUS Ext2UnicodeToOEM(IN PEXT2_VCB Vcb, IN OUT POEM_STRING Oem, IN PUNICODE_STRING Unicode)
Definition: misc.c:261
NTSTATUS Ext2UpdateGroupDirStat(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG Group)
Definition: generic.c:1728
#define S_IFLNK
Definition: ext2fs.h:360
GLboolean GLuint group
Definition: glext.h:11120
#define FILE_ATTRIBUTE_REPARSE_POINT
Definition: ntifs_ex.h:381
int zero
Definition: sehframes.cpp:29
struct _REPARSE_DATA_BUFFER * PREPARSE_DATA_BUFFER
struct _FCB::@720::@723 Fcb
uint16_t * PWCHAR
Definition: typedefs.h:56
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesWritten
Definition: wdfiotarget.h:960
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:953

Referenced by Ext2UserFsRequest().

◆ Ext2SetVpbFlag()

VOID Ext2SetVpbFlag ( IN PVPB  Vpb,
IN USHORT  Flag 
)

Definition at line 44 of file fsctl.c.

47{
49
51 Vpb->Flags |= Flag;
53}

Referenced by Ext2LockVcb().

◆ Ext2TruncateSymlink()

NTSTATUS Ext2TruncateSymlink ( PEXT2_IRP_CONTEXT  IrpContext,
PEXT2_VCB  Vcb,
PEXT2_MCB  Mcb,
ULONG  Size 
)

Definition at line 1751 of file fsctl.c.

1757{
1759 PUCHAR data = (PUCHAR)&Mcb->Inode.i_block;
1760 ULONG len = (ULONG)Mcb->Inode.i_size;
1762
1763 if (len < EXT2_LINKLEN_IN_INODE && !Mcb->Inode.i_blocks) {
1764
1766 Mcb->Inode.i_size = Size;
1767 Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
1768
1769 } else {
1770 NewSize.QuadPart = Size;
1771 status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &NewSize);
1772 if (!NT_SUCCESS(status)) {
1773 goto out;
1774 }
1775 }
1776
1777out:
1778 return status;
1779}
#define EXT2_LINKLEN_IN_INODE
Definition: ext2fs.h:76
_Must_inspect_result_ _In_ USHORT NewSize
Definition: fltkernel.h:975
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLenum GLsizei len
Definition: glext.h:6722

Referenced by Ext2DeleteReparsePoint().

◆ Ext2UnlockVcb()

NTSTATUS Ext2UnlockVcb ( IN PEXT2_VCB  Vcb,
IN PFILE_OBJECT  FileObject 
)

Definition at line 206 of file fsctl.c.

208{
210
211 _SEH2_TRY {
212
213 if (FileObject && FileObject->FsContext != Vcb) {
216 }
217
218 if (!FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
219 DEBUG(DL_ERR, ( ": Ext2UnlockVcb: Volume is not locked.\n"));
222 }
223
224 if (Vcb->LockFile == FileObject) {
227 DEBUG(DL_INF, ( "Ext2UnlockVcb: Volume unlocked.\n"));
229 } else {
231 }
232
233 } _SEH2_FINALLY {
234 // Nothing
235 } _SEH2_END;
236
237 return Status;
238}
VOID Ext2ClearVpbFlag(IN PVPB Vpb, IN USHORT Flag)
Definition: fsctl.c:56
#define STATUS_NOT_LOCKED
Definition: ntstatus.h:279

Referenced by Ext2UnlockVolume().

◆ Ext2UnlockVolume()

NTSTATUS Ext2UnlockVolume ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 241 of file fsctl.c.

244{
249 BOOLEAN VcbResourceAcquired = FALSE;
250
251 _SEH2_TRY {
252
253 ASSERT(IrpContext != NULL);
254 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
255 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
256
257 DeviceObject = IrpContext->DeviceObject;
258 IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
259
260 //
261 // This request is not allowed on the main device object
262 //
266 }
267
268 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
269 ASSERT(Vcb != NULL);
270 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
271 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
272
274 &Vcb->MainResource,
275 TRUE );
276 VcbResourceAcquired = TRUE;
277
279
280 } _SEH2_FINALLY {
281
282 if (VcbResourceAcquired) {
283 ExReleaseResourceLite(&Vcb->MainResource);
284 }
285
286 if (!IrpContext->ExceptionInProgress) {
287 Ext2CompleteIrpContext(IrpContext, Status);
288 }
289 } _SEH2_END;
290
291 return Status;
292}
NTSTATUS Ext2UnlockVcb(IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject)
Definition: fsctl.c:206

Referenced by Ext2UserFsRequest().

◆ Ext2UserFsRequest()

NTSTATUS Ext2UserFsRequest ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 1903 of file fsctl.c.

1904{
1905 PIRP Irp;
1906 PIO_STACK_LOCATION IoStackLocation;
1909
1910 ASSERT(IrpContext);
1911
1912 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
1913 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
1914
1915 Irp = IrpContext->Irp;
1916 IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
1917
1918#ifndef _GNU_NTIFS_
1920 IoStackLocation->Parameters.FileSystemControl.FsControlCode;
1921#else
1923 IoStackLocation)->Parameters.FileSystemControl.FsControlCode;
1924#endif
1925
1926 switch (FsControlCode) {
1927
1929 Status = Ext2GetReparsePoint(IrpContext);
1930 break;
1931
1933 Status = Ext2SetReparsePoint(IrpContext);
1934 break;
1935
1937 Status = Ext2DeleteReparsePoint(IrpContext);
1938 break;
1939
1940 case FSCTL_LOCK_VOLUME:
1941 Status = Ext2LockVolume(IrpContext);
1942 break;
1943
1945 Status = Ext2UnlockVolume(IrpContext);
1946 break;
1947
1949 Status = Ext2DismountVolume(IrpContext);
1950 break;
1951
1953 Status = Ext2IsVolumeMounted(IrpContext);
1954 break;
1955
1957 Status = Ext2InvalidateVolumes(IrpContext);
1958 break;
1959
1960#if (_WIN32_WINNT >= 0x0500)
1962 Status = Ext2AllowExtendedDasdIo(IrpContext);
1963 break;
1964#endif //(_WIN32_WINNT >= 0x0500)
1965
1973
1974 Status = Ext2OplockRequest(IrpContext);
1975 break;
1976
1978 Status = Ext2IsVolumeDirty(IrpContext);
1979 break;
1980
1982 Status = Ext2QueryRetrievalPointers(IrpContext);
1983 break;
1984
1986 Status = Ext2GetRetrievalPointers(IrpContext);
1987 break;
1988
1990 Status = Ext2GetRetrievalPointerBase(IrpContext);
1991 break;
1992
1993 default:
1994
1995 DEBUG(DL_INF, ( "Ext2UserFsRequest: Invalid User Request: %xh.\n", FsControlCode));
1997
1998 Ext2CompleteIrpContext(IrpContext, Status);
1999 }
2000
2001 return Status;
2002}
NTSTATUS Ext2UnlockVolume(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:241
NTSTATUS Ext2QueryRetrievalPointers(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:774
NTSTATUS Ext2OplockRequest(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:451
NTSTATUS Ext2DeleteReparsePoint(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:1784
NTSTATUS Ext2AllowExtendedDasdIo(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:407
NTSTATUS Ext2GetRetrievalPointers(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:911
NTSTATUS Ext2DismountVolume(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:2521
NTSTATUS Ext2GetRetrievalPointerBase(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:1160
NTSTATUS Ext2GetReparsePoint(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:1386
NTSTATUS Ext2InvalidateVolumes(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:296
NTSTATUS Ext2IsVolumeMounted(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:2494
NTSTATUS Ext2LockVolume(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:136
NTSTATUS Ext2IsVolumeDirty(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:618
NTSTATUS Ext2SetReparsePoint(IN PEXT2_IRP_CONTEXT IrpContext)
Definition: fsctl.c:1572
#define FSCTL_GET_RETRIEVAL_POINTER_BASE
Definition: ext2fs.h:1132
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG FsControlCode
Definition: fltkernel.h:1370
#define FSCTL_QUERY_RETRIEVAL_POINTERS
Definition: nt_native.h:840
#define FSCTL_LOCK_VOLUME
Definition: nt_native.h:832
#define FSCTL_INVALIDATE_VOLUMES
Definition: nt_native.h:847
#define FSCTL_UNLOCK_VOLUME
Definition: nt_native.h:833
#define FSCTL_IS_VOLUME_MOUNTED
Definition: nt_native.h:836
#define FSCTL_DISMOUNT_VOLUME
Definition: nt_native.h:834
#define FSCTL_GET_REPARSE_POINT
Definition: winioctl.h:97
#define FSCTL_SET_REPARSE_POINT
Definition: winioctl.h:98
#define FSCTL_IS_VOLUME_DIRTY
Definition: winioctl.h:714
#define FSCTL_GET_RETRIEVAL_POINTERS
Definition: winioctl.h:95
#define FSCTL_DELETE_REPARSE_POINT
Definition: winioctl.h:99
#define FSCTL_ALLOW_EXTENDED_DASD_IO
Definition: winioctl.h:124

Referenced by Ext2FileSystemControl().

◆ Ext2VerifyVcb()

VOID Ext2VerifyVcb ( IN PEXT2_IRP_CONTEXT  IrpContext,
IN PEXT2_VCB  Vcb 
)

Definition at line 2277 of file fsctl.c.

2279{
2281
2283 ULONG ChangeCount = 0;
2284 ULONG dwBytes;
2285
2286 PIRP Irp;
2288
2289 _SEH2_TRY {
2290
2291 ASSERT(IrpContext != NULL);
2292
2293 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
2294 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
2295
2296 Irp = IrpContext->Irp;
2298
2299 bVerify = IsFlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
2300
2301 if ( (IsFlagOn(Vcb->Flags, VCB_REMOVABLE_MEDIA) ||
2302 IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) && !bVerify ) {
2303
2304 dwBytes = sizeof(ULONG);
2306 Vcb->TargetDeviceObject,
2308 NULL,
2309 0,
2310 &ChangeCount,
2311 &dwBytes );
2312
2316 (NT_SUCCESS(Status) &&
2317 (ChangeCount != Vcb->ChangeCount))) {
2318
2319 KIRQL Irql;
2320
2322 if (Vcb->Vpb == Vcb->Vpb->RealDevice->Vpb) {
2323 SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
2324 }
2326
2327 } else {
2328
2329 if (!NT_SUCCESS(Status)) {
2331 }
2332 }
2333 }
2334
2335 if ( IsFlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME)) {
2336 IoSetHardErrorOrVerifyDevice( Irp, Vcb->Vpb->RealDevice );
2337 Ext2NormalizeAndRaiseStatus ( IrpContext,
2339 }
2340
2341 if (IsMounted(Vcb)) {
2342
2343 if ( (IrpContext->MajorFunction == IRP_MJ_WRITE) ||
2344 (IrpContext->MajorFunction == IRP_MJ_SET_INFORMATION) ||
2345 (IrpContext->MajorFunction == IRP_MJ_SET_EA) ||
2346 (IrpContext->MajorFunction == IRP_MJ_FLUSH_BUFFERS) ||
2347 (IrpContext->MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION) ||
2348 (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
2349 IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST &&
2350 IrpSp->Parameters.FileSystemControl.FsControlCode ==
2352
2353 if (IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {
2354
2355 KIRQL Irql;
2356
2358 if (Vcb->Vpb == Vcb->Vpb->RealDevice->Vpb) {
2359 SetFlag (Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
2360 }
2362
2363 IoSetHardErrorOrVerifyDevice( Irp, Vcb->Vpb->RealDevice );
2364
2366 }
2367 }
2368 }
2369
2370 } _SEH2_FINALLY {
2371
2372 } _SEH2_END;
2373
2374}
#define IOCTL_DISK_CHECK_VERIFY
Definition: cdrw_usr.h:175
#define DO_VERIFY_VOLUME
Definition: env_spec_w32.h:393
#define VCB_WRITE_PROTECTED
Definition: ext2fs.h:805
#define Ext2RaiseStatus(IRPCONTEXT, STATUS)
Definition: ext2fs.h:263
#define VCB_REMOVABLE_MEDIA
Definition: ext2fs.h:808
#define Ext2NormalizeAndRaiseStatus(IRPCONTEXT, STATUS)
Definition: ext2fs.h:268
#define VCB_FLOPPY_DISK
Definition: ext2fs.h:806
#define FSCTL_MARK_VOLUME_DIRTY
Definition: nt_native.h:838
VOID NTAPI IoSetHardErrorOrVerifyDevice(IN PIRP Irp, IN PDEVICE_OBJECT DeviceObject)
Definition: util.c:316
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
#define IRP_MJ_SET_INFORMATION
Definition: rdpdr.c:49
#define STATUS_DEVICE_NOT_READY
Definition: shellext.h:70
#define STATUS_NO_MEDIA_IN_DEVICE
Definition: udferr_usr.h:141
#define STATUS_VERIFY_REQUIRED
Definition: udferr_usr.h:130
static BOOL bVerify
Definition: verify.c:27
#define IRP_MJ_FILE_SYSTEM_CONTROL
#define IRP_MJ_SET_VOLUME_INFORMATION
#define IRP_MJ_SET_EA
#define IRP_MJ_FLUSH_BUFFERS

Referenced by Ext2Create(), Ext2Flush(), Ext2IsVolumeMounted(), and Ext2SetVolumeInformation().

◆ Ext2VerifyVolume()

NTSTATUS Ext2VerifyVolume ( IN PEXT2_IRP_CONTEXT  IrpContext)

Definition at line 2378 of file fsctl.c.

2379{
2382 PEXT2_SUPER_BLOCK ext2_sb = NULL;
2383 PEXT2_VCB Vcb = NULL;
2384 BOOLEAN VcbResourceAcquired = FALSE;
2385 PIRP Irp;
2386 ULONG ChangeCount = 0;
2387 ULONG dwBytes;
2388
2389 _SEH2_TRY {
2390
2391 ASSERT(IrpContext != NULL);
2392 ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
2393 (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
2394
2395 DeviceObject = IrpContext->DeviceObject;
2396 //
2397 // This request is not allowed on the main device object
2398 //
2402 }
2403
2404 Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
2405 ASSERT(Vcb != NULL);
2406 ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
2407 (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
2408
2409 VcbResourceAcquired =
2411 &Vcb->MainResource,
2412 TRUE );
2413
2414 if (!FlagOn(Vcb->TargetDeviceObject->Flags, DO_VERIFY_VOLUME)) {
2417 }
2418
2419 if (!IsMounted(Vcb)) {
2422 }
2423
2424 dwBytes = sizeof(ULONG);
2426 Vcb->TargetDeviceObject,
2428 NULL,
2429 0,
2430 &ChangeCount,
2431 &dwBytes );
2432
2433
2434 if (!NT_SUCCESS(Status)) {
2437 } else {
2438 Vcb->ChangeCount = ChangeCount;
2439 }
2440
2441 Irp = IrpContext->Irp;
2442
2443 Status = Ext2LoadSuper(Vcb, TRUE, &ext2_sb);
2444
2445 if (!NT_SUCCESS(Status)) {
2447 }
2448
2449 ASSERT(NULL != ext2_sb);
2450 if ((ext2_sb->s_magic == EXT2_SUPER_MAGIC) &&
2451 (memcmp(ext2_sb->s_uuid, SUPER_BLOCK->s_uuid, 16) == 0) &&
2452 (memcmp(ext2_sb->s_volume_name, SUPER_BLOCK->s_volume_name, 16) ==0)) {
2453
2454 ClearFlag(Vcb->TargetDeviceObject->Flags, DO_VERIFY_VOLUME);
2455
2456 if (Ext2IsMediaWriteProtected(IrpContext, Vcb->TargetDeviceObject)) {
2458 } else {
2460 }
2461
2462 DEBUG(DL_INF, ( "Ext2VerifyVolume: Volume verify succeeded.\n"));
2463
2464 } else {
2465
2468
2470 ClearFlag(Vcb->TargetDeviceObject->Flags, DO_VERIFY_VOLUME);
2471
2472 DEBUG(DL_INF, ( "Ext2VerifyVolume: Volume verify failed.\n"));
2473 }
2474
2475 } _SEH2_FINALLY {
2476
2477 if (ext2_sb)
2478 Ext2FreePool(ext2_sb, EXT2_SB_MAGIC);
2479
2480 if (VcbResourceAcquired) {
2481 ExReleaseResourceLite(&Vcb->MainResource);
2482 }
2483
2484 if (!IrpContext->ExceptionInProgress) {
2485 Ext2CompleteIrpContext(IrpContext, Status);
2486 }
2487 } _SEH2_END;
2488
2489 return Status;
2490}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
BOOLEAN Ext2IsMediaWriteProtected(IN PEXT2_IRP_CONTEXT IrpContext, IN PDEVICE_OBJECT TargetDevice)
Definition: fsctl.c:2005
#define SUPER_BLOCK
Definition: ext2fs.h:90
#define STATUS_WRONG_VOLUME
Definition: udferr_usr.h:140

Referenced by Ext2FileSystemControl().

◆ Ext2WriteSymlink()

NTSTATUS Ext2WriteSymlink ( IN PEXT2_IRP_CONTEXT  IrpContext,
IN PEXT2_VCB  Vcb,
IN PEXT2_MCB  Mcb,
IN PVOID  Buffer,
IN ULONG  Size,
OUT PULONG  BytesWritten 
)

Definition at line 1519 of file fsctl.c.

1527{
1529 PUCHAR Data = (PUCHAR)(&Mcb->Inode.i_block[0]);
1530
1531 if (Size >= EXT2_LINKLEN_IN_INODE) {
1532
1533 /* initialize inode i_block[] */
1534 if (0 == Mcb->Inode.i_blocks) {
1536 ClearFlag(Mcb->Inode.i_flags, EXT4_EXTENTS_FL);
1537 Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
1538 }
1539
1540 Status = Ext2WriteInode(IrpContext, Vcb, Mcb,
1541 0, Buffer, Size,
1543 if (!NT_SUCCESS(Status)) {
1544 goto out;
1545 }
1546
1547 } else {
1548
1549 /* free inode blocks before writing in line */
1550 if (Mcb->Inode.i_blocks) {
1551 LARGE_INTEGER Zero = {0, 0};
1552 Ext2TruncateFile(IrpContext, Vcb, Mcb, &Zero);
1553 }
1554
1555 ClearFlag(Mcb->Inode.i_flags, EXT4_EXTENTS_FL);
1558 }
1559
1560 Mcb->Inode.i_size = Size;
1561 Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
1562
1563 if (BytesWritten) {
1564 *BytesWritten = Size;
1565 }
1566
1567out:
1568 return Status;
1569}
NTSTATUS Ext2WriteInode(IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONGLONG Offset, IN PVOID Buffer, IN ULONG Size, IN BOOLEAN bDirectIo, OUT PULONG dwReturn)
Definition: write.c:668
#define EXT4_EXTENTS_FL
Definition: ext3_fs.h:263
IN PVCB IN VBO IN ULONG OUT PBCB OUT PVOID IN BOOLEAN IN BOOLEAN Zero
Definition: fatprocs.h:418
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263

Referenced by Ext2SetReparsePoint().

Variable Documentation

◆ Ext2Global

PEXT2_GLOBAL Ext2Global
extern

Definition at line 16 of file init.c.

Referenced by Ext2CheckDismount(), Ext2InvalidateVolumes(), and Ext2MountVolume().