Ros-diffs November 2017

ros-diffs@reactos.org

22 participants
186 discussions

[reactos] 01/02: [CMD] Code formatting only.
by Hermès Bélusca-Maïto 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=24ed5344745899cf26494… commit 24ed5344745899cf26494ce1cb8b5b226ce84147 Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sat Nov 18 21:32:10 2017 +0100 [CMD] Code formatting only. --- base/shell/cmd/call.c | 6 +++--- base/shell/cmd/internal.c | 14 +++++++------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/base/shell/cmd/call.c b/base/shell/cmd/call.c index 56b61dbe2e..2cf2772c3c 100644 --- a/base/shell/cmd/call.c +++ b/base/shell/cmd/call.c @@ -34,7 +34,7 @@ * Perform CALL command. */ -INT cmd_call (LPTSTR param) +INT cmd_call(LPTSTR param) { TCHAR line[CMDLINE_LENGTH + 1]; TCHAR *first; @@ -49,7 +49,7 @@ INT cmd_call (LPTSTR param) /* Do a second round of %-variable substitutions */ if (!SubstituteVars(param, line, _T('%'))) - return nErrorLevel = 1; + return (nErrorLevel = 1); /* Find start and end of first word */ first = line; @@ -67,7 +67,7 @@ INT cmd_call (LPTSTR param) memmove(param + 1, param, (_tcslen(param) + 1) * sizeof(TCHAR)); *param++ = _T('\0'); - if (*first == _T(':') && (bc)) + if (*first == _T(':') && bc) { /* CALL :label - call a subroutine of the current batch file */ while (*param == _T(' ')) diff --git a/base/shell/cmd/internal.c b/base/shell/cmd/internal.c index 4e14daf527..4830660bbc 100644 --- a/base/shell/cmd/internal.c +++ b/base/shell/cmd/internal.c @@ -282,7 +282,7 @@ INT cmd_chdir (LPTSTR param) #ifdef INCLUDE_CMD_MKDIR /* Helper function for mkdir to make directories in a path. -Dont use the api to decrease depence on libs */ +Don't use the api to decrease dependence on libs */ BOOL MakeFullPath(TCHAR * DirPath) { @@ -509,21 +509,21 @@ INT cmd_rmdir (LPTSTR param) /* * set the exitflag to true */ -INT CommandExit (LPTSTR param) +INT CommandExit(LPTSTR param) { - if (!_tcsncmp (param, _T("/?"), 2)) + if (!_tcsncmp(param, _T("/?"), 2)) { - ConOutResPaging(TRUE,STRING_EXIT_HELP); + ConOutResPaging(TRUE, STRING_EXIT_HELP); /* Just make sure */ bExit = FALSE; - /* Dont exit */ + /* Don't exit */ return 0; } - if (bc != NULL && _tcsnicmp(param,_T("/b"),2) == 0) + if (bc != NULL && _tcsnicmp(param, _T("/b"), 2) == 0) { param += 2; - while (_istspace (*param)) + while (_istspace(*param)) param++; if (_istdigit(*param)) nErrorLevel = _ttoi(param);

1 0

[reactos] 01/01: [FREELDR] PcMemGetBiosMemoryMap(): Add checks for entry sizes and bare handling of error case. CORE-13332
by Serge Gautherie 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=14563105034fc009bb764… commit 14563105034fc009bb764e65e40a8158644028a7 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Mon Oct 9 01:40:22 2017 +0200 [FREELDR] PcMemGetBiosMemoryMap(): Add checks for entry sizes and bare handling of error case. CORE-13332 --- boot/freeldr/freeldr/arch/i386/pcmem.c | 23 +++++++++++++++++++++++ boot/freeldr/freeldr/include/arch/pc/pcbios.h | 5 +++++ 2 files changed, 28 insertions(+) diff --git a/boot/freeldr/freeldr/arch/i386/pcmem.c b/boot/freeldr/freeldr/arch/i386/pcmem.c index aa5b18d226..9b0997ebf5 100644 --- a/boot/freeldr/freeldr/arch/i386/pcmem.c +++ b/boot/freeldr/freeldr/arch/i386/pcmem.c @@ -293,6 +293,29 @@ PcMemGetBiosMemoryMap(PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG MaxMemoryMapSi goto nextRange; } + /* Extra safety: unexpected entry length. + * All in-between values are valid too, as x86 is little-indian + * and only lower byte is used per ACPI 6.2-A. + */ + if (Regs.x.ecx < RTL_SIZEOF_THROUGH_FIELD(BIOS_MEMORY_MAP, Type) || + Regs.x.ecx > sizeof(BIOS_MEMORY_MAP)) + { + ERR("Int 15h AX=E820h returned an invalid entry length! (would-be-PcBiosMapCount = %lu, Entry length = (%Iu <=) %lu (<= %Iu))\n\n", + PcBiosMapCount, RTL_SIZEOF_THROUGH_FIELD(BIOS_MEMORY_MAP, Type), Regs.x.ecx, sizeof(BIOS_MEMORY_MAP)); + /* Warn user, unless wrong case is "first and not too big entry", which is otherwise harmless. */ + if (PcBiosMapCount > 0 || Regs.x.ecx > sizeof(BIOS_MEMORY_MAP)) + { + ASSERTMSG("Int 15h AX=E820h returned an invalid entry length!", FALSE); + } + /* We keep previous entries (if any), but do not dare trying next entries. + * We assume these entries are good to use as is. If they are not, we are in trouble... + * (And don't ask what happens if BIOS actually overflowed our entry buffer...) + * + * FIXME: Safer = revert previous entries, Safest = blacklist this BIOS. + */ + break; + } + /* Copy data to global buffer */ RtlCopyMemory(&PcBiosMemoryMap[PcBiosMapCount], (PVOID)BIOSCALLBUFFER, Regs.x.ecx); diff --git a/boot/freeldr/freeldr/include/arch/pc/pcbios.h b/boot/freeldr/freeldr/include/arch/pc/pcbios.h index ecfaf90b2a..b60df0b122 100644 --- a/boot/freeldr/freeldr/include/arch/pc/pcbios.h +++ b/boot/freeldr/freeldr/include/arch/pc/pcbios.h @@ -19,6 +19,11 @@ typedef struct ULONG Reserved; } BIOS_MEMORY_MAP, *PBIOS_MEMORY_MAP; +/* Int 15h AX=E820h Entry minimal size. */ +C_ASSERT(FIELD_OFFSET(BIOS_MEMORY_MAP, Reserved) == 20); +/* Int 15h AX=E820h Entry maximal size. */ +C_ASSERT(sizeof(BIOS_MEMORY_MAP) == 24); + /* FIXME: Should be moved to NDK, and respective ACPI header files */ typedef struct _ACPI_BIOS_DATA {

1 0

[reactos] 01/01: [NFS41_NP] Attempt to fix MSVC build
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2ddebe3291568bb18d032… commit 2ddebe3291568bb18d03207337315d4f38d4d630 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 21:36:57 2017 +0100 [NFS41_NP] Attempt to fix MSVC build --- dll/np/nfs/nfs41_np.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dll/np/nfs/nfs41_np.c b/dll/np/nfs/nfs41_np.c index 42aa46730d..ce03c41999 100644 --- a/dll/np/nfs/nfs41_np.c +++ b/dll/np/nfs/nfs41_np.c @@ -649,10 +649,11 @@ NPCancelConnection( DbgP((TEXT("NPCancelConnection: Name %S EntryName %S\n"), lpName,pNetResource->LocalName)); - DbgP((TEXT("NPCancelConnection: Name Length %d Entry Name Length %d\n"), #ifndef __REACTOS__ + DbgP((TEXT("NPCancelConnection: Name Length %d Entry Name Length %d\n"), pNetResource->LocalNameLength,pNetResource->LocalName)); #else + DbgP((TEXT("NPCancelConnection: Name Length %d Entry Name Length %d\n"), (wcslen(lpName) + 1) * sizeof(WCHAR), pNetResource->LocalNameLength)); #endif

1 0

[reactos] 02/02: [SHELL32] Drop slash when dismounting a remote drive. MPR and NP are expecting a drive letter. This fixes dismounting a network drive using explorer.
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=45b543202d7e1927833d8… commit 45b543202d7e1927833d84faebdb39924d2b4e09 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 21:26:18 2017 +0100 [SHELL32] Drop slash when dismounting a remote drive. MPR and NP are expecting a drive letter. This fixes dismounting a network drive using explorer. --- dll/win32/shell32/folders/CDrivesFolder.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/dll/win32/shell32/folders/CDrivesFolder.cpp b/dll/win32/shell32/folders/CDrivesFolder.cpp index a708dc4d49..701a10643f 100644 --- a/dll/win32/shell32/folders/CDrivesFolder.cpp +++ b/dll/win32/shell32/folders/CDrivesFolder.cpp @@ -253,6 +253,7 @@ HRESULT CALLBACK DrivesContextMenuCallback(IShellFolder *psf, else if (wParam == CMDID_DISCONNECT) { /* do disconnect */ + wszBuf[2] = UNICODE_NULL; dwError = WNetCancelConnection2W(wszBuf, 0, FALSE); if (dwError == NO_ERROR) {

1 0

[reactos] 01/02: [NFS41_NP] Fix debug print in case of connection cancel failure
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=764b2b6ef72cff6072918… commit 764b2b6ef72cff60729184284d654c6a47699539 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 21:25:00 2017 +0100 [NFS41_NP] Fix debug print in case of connection cancel failure --- dll/np/nfs/nfs41_np.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/dll/np/nfs/nfs41_np.c b/dll/np/nfs/nfs41_np.c index 7dea7f3548..42aa46730d 100644 --- a/dll/np/nfs/nfs41_np.c +++ b/dll/np/nfs/nfs41_np.c @@ -650,7 +650,11 @@ NPCancelConnection( DbgP((TEXT("NPCancelConnection: Name %S EntryName %S\n"), lpName,pNetResource->LocalName)); DbgP((TEXT("NPCancelConnection: Name Length %d Entry Name Length %d\n"), +#ifndef __REACTOS__ pNetResource->LocalNameLength,pNetResource->LocalName)); +#else + (wcslen(lpName) + 1) * sizeof(WCHAR), pNetResource->LocalNameLength)); +#endif } }

1 0

[reactos] 01/01: [CMD] ExecutePipeline() returns the last error level (set to process exit code). CORE-13974
by Hermès Bélusca-Maïto 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=56a19b1439effc8a3990f… commit 56a19b1439effc8a3990f97ff9241379d55a07cb Author: Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org> AuthorDate: Sat Nov 18 20:50:50 2017 +0100 [CMD] ExecutePipeline() returns the last error level (set to process exit code). CORE-13974 This should fix situations where (for example): command_1 | command_2 && echo Succeeded should *NOT* run "echo Succeeded" if any of the command_1 or command_2 has failed. This also makes the ExecutePipeline() function on par with the other "ExecuteXXX()" helpers. Problem diagnosed by Doug Lyons; patch inspired by contributor 'cagey45'. --- base/shell/cmd/cmd.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/base/shell/cmd/cmd.c b/base/shell/cmd/cmd.c index e6c9bec785..549f10d59e 100644 --- a/base/shell/cmd/cmd.c +++ b/base/shell/cmd/cmd.c @@ -636,7 +636,7 @@ ExecuteAsync(PARSED_COMMAND *Cmd) return prci.hProcess; } -static VOID +static INT ExecutePipeline(PARSED_COMMAND *Cmd) { #ifdef FEATURE_REDIRECTION @@ -708,7 +708,7 @@ ExecutePipeline(PARSED_COMMAND *Cmd) while (--nProcesses >= 0) CloseHandle(hProcess[nProcesses]); - return; + return nErrorLevel; failed: if (hInput) @@ -721,6 +721,8 @@ failed: SetStdHandle(STD_INPUT_HANDLE, hOldConIn); SetStdHandle(STD_OUTPUT_HANDLE, hOldConOut); #endif + + return nErrorLevel; } INT @@ -771,7 +773,7 @@ ExecuteCommand(PARSED_COMMAND *Cmd) Ret = ExecuteCommand(Sub->Next); break; case C_PIPE: - ExecutePipeline(Cmd); + Ret = ExecutePipeline(Cmd); break; case C_IF: Ret = ExecuteIf(Cmd);

1 0

[reactos] 01/01: [SHELL32] Update French translation, following 6465705
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0701527f200a37e29f94f… commit 0701527f200a37e29f94fb7f4d350274f0b344bb Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 18:56:59 2017 +0100 [SHELL32] Update French translation, following 6465705 --- dll/win32/shell32/lang/fr-FR.rc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/dll/win32/shell32/lang/fr-FR.rc b/dll/win32/shell32/lang/fr-FR.rc index 16aaf76420..325487e4fe 100644 --- a/dll/win32/shell32/lang/fr-FR.rc +++ b/dll/win32/shell32/lang/fr-FR.rc @@ -683,8 +683,8 @@ BEGIN IDS_FORMATDRIVE "Formater..." IDS_RENAME "Renommer" IDS_PASTE "Insérer" - IDS_EJECT "Eject" - IDS_DISCONNECT "Disconnect" + IDS_EJECT "Éjecter" + IDS_DISCONNECT "Déconnecter" IDS_CREATEFOLDER_DENIED "Impossible de créer le dossier '%1'" IDS_CREATEFOLDER_CAPTION "Impossible de créer un dossier" @@ -753,7 +753,7 @@ BEGIN IDS_NEWFOLDER "Nouveau dossier" IDS_DRIVE_FIXED "Disque local" - IDS_DRIVE_CDROM "CD Drive" + IDS_DRIVE_CDROM "Lecteur CD" IDS_DRIVE_NETWORK "Disque réseau" IDS_DRIVE_FLOPPY "Disquette 3.5" IDS_DRIVE_REMOVABLE "Disque amovible" @@ -778,11 +778,11 @@ BEGIN IDS_PICK_ICON_FILTER "Fichiers d'icônes (*.ico, *.icl, *.exe, *.dll)\0*.ico;*.icl;*.exe;*.dll\0All Files (*.*)\0*.*\0" IDS_OPEN_WITH_FILTER "Fichiers exécutables (*.exe)\0*.exe\0All Files (*.*)\0*.*\0" - IDS_CANTLOCKVOLUME "Unable to lock volume (Error Code: %lu)." - IDS_CANTDISMOUNTVOLUME "Unable to dismount volume (Error Code: %lu)." - IDS_CANTEJECTMEDIA "Unable to eject media (Error Code: %lu)." - IDS_CANTSHOWPROPERTIES "Unable to show properties (Error Code: %lu)." - IDS_CANTDISCONNECT "Unable to disconnect (Error Code: %lu)." + IDS_CANTLOCKVOLUME "Impossible de verrouiller le volume (code d'erreur : %lu)." + IDS_CANTDISMOUNTVOLUME "Impossible de démonter le volume (code d'erreur : %lu)." + IDS_CANTEJECTMEDIA "Impossible d'éjecter le média (code d'erreur : %lu)." + IDS_CANTSHOWPROPERTIES "Impossible de montrer les propriétés (code d'erreur : %lu)." + IDS_CANTDISCONNECT "Impossible de déconnecter (code d'erreur : %lu)." IDS_DIRECTORY "Dossier" IDS_BAT_FILE "Fichier Batch ReactOS"

1 0

[reactos] 01/01: [NTOSKRNL] Fix MSVC build: don't attempt to return in a void function
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2284a457a36a9ce7e2b28… commit 2284a457a36a9ce7e2b28bf38b6456ff0a6de471 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 18:38:36 2017 +0100 [NTOSKRNL] Fix MSVC build: don't attempt to return in a void function --- ntoskrnl/fsrtl/oplock.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ntoskrnl/fsrtl/oplock.c b/ntoskrnl/fsrtl/oplock.c index 250f0fce3f..7ab457d399 100644 --- a/ntoskrnl/fsrtl/oplock.c +++ b/ntoskrnl/fsrtl/oplock.c @@ -63,7 +63,7 @@ FsRtlNotifyCompletion(IN PVOID Context, DPRINT("FsRtlNotifyCompletion(%p, %p)\n", Context, Irp); /* Just complete the IRP */ - return IoCompleteRequest(Irp, IO_DISK_INCREMENT); + IoCompleteRequest(Irp, IO_DISK_INCREMENT); } VOID

1 0

[reactos] 01/01: [CDFS] Attempt to a switch to the MS CDFS driver. To be reverted if it brings in too many regressions, even though I tried to do my best to address them.
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ec6b3ecbe48ad51c36656… commit ec6b3ecbe48ad51c366563196cc93a6ae74e8b69 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 18:32:36 2017 +0100 [CDFS] Attempt to a switch to the MS CDFS driver. To be reverted if it brings in too many regressions, even though I tried to do my best to address them. Leaving the old driver in place, for now; if no regressions are reported regarding CDFS in 0.4.8, then old driver could be dropped for 0.4.9. --- drivers/filesystems/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/filesystems/CMakeLists.txt b/drivers/filesystems/CMakeLists.txt index 7485d433b5..24937d7f13 100644 --- a/drivers/filesystems/CMakeLists.txt +++ b/drivers/filesystems/CMakeLists.txt @@ -1,6 +1,6 @@ add_subdirectory(btrfs) -add_subdirectory(cdfs) +add_subdirectory(cdfs_new) add_subdirectory(ext2) add_subdirectory(fastfat) add_subdirectory(ffs)

1 0

[reactos] 01/01: [NTOSKRNL] Implement FsRtlCheckOplock(), FsRtlCurrentBatchOplock(), FsRtlInitializeOplock(), FsRtlOplockFsctrl(), FsRtlOplockIsFastIoPossible(), FsRtlUninitializeOplock(). But also, implement FsRtlNotifyCompletion(), FsRtlCompletionRoutinePriv(), FsRtlRemoveAndCompleteWaitIrp(), FsRtlCancelWaitIrp(), FsRtlWaitOnIrp(), FsRtlOplockBreakNotify(), FsRtlRemoveAndCompleteIrp(), FsRtlCancelOplockIIIrp(), FsRtlAcknowledgeOplockBreak(), FsRtlOpBatchBreakClosePending(), FsRtlAllocateOploc
by Pierre Schweitzer 18 Nov '17

18 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d3d585395684b96df9782… commit d3d585395684b96df9782fe0af253f2c3e9cffc4 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Sat Nov 18 18:23:57 2017 +0100 [NTOSKRNL] Implement FsRtlCheckOplock(), FsRtlCurrentBatchOplock(), FsRtlInitializeOplock(), FsRtlOplockFsctrl(), FsRtlOplockIsFastIoPossible(), FsRtlUninitializeOplock(). But also, implement FsRtlNotifyCompletion(), FsRtlCompletionRoutinePriv(), FsRtlRemoveAndCompleteWaitIrp(), FsRtlCancelWaitIrp(), FsRtlWaitOnIrp(), FsRtlOplockBreakNotify(), FsRtlRemoveAndCompleteIrp(), FsRtlCancelOplockIIIrp(), FsRtlAcknowledgeOplockBreak(), FsRtlOpBatchBreakClosePending(), FsRtlAllocateOplock(), FsRtlCancelExclusiveIrp(), FsRtlRequestExclusiveOplock(), FsRtlRequestOplockII(), FsRtlOplockCleanup(), FsRtlOplockBreakToNone(), FsRtlOplockBreakToII(). In short... Implement oplocks support in ReactOS. --- ntoskrnl/fsrtl/oplock.c | 1556 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1543 insertions(+), 13 deletions(-) diff --git a/ntoskrnl/fsrtl/oplock.c b/ntoskrnl/fsrtl/oplock.c index ce31dfbab7..250f0fce3f 100644 --- a/ntoskrnl/fsrtl/oplock.c +++ b/ntoskrnl/fsrtl/oplock.c @@ -3,7 +3,7 @@ * LICENSE: GPL - See COPYING in the top level directory * FILE: ntoskrnl/fsrtl/oplock.c * PURPOSE: Provides an Opportunistic Lock for file system drivers. - * PROGRAMMERS: None. + * PROGRAMMERS: Pierre Schweitzer (pierre(a)reactos.org) */ /* INCLUDES ******************************************************************/ @@ -12,6 +12,1133 @@ #define NDEBUG #include <debug.h> +#define NO_OPLOCK 0x1 +#define LEVEL_1_OPLOCK 0x2 +#define BATCH_OPLOCK 0x4 +#define FILTER_OPLOCK 0x8 +#define LEVEL_2_OPLOCK 0x10 + +#define EXCLUSIVE_LOCK 0x40 +#define PENDING_LOCK 0x80 + +#define BROKEN_TO_LEVEL_2 0x100 +#define BROKEN_TO_NONE 0x200 +#define BROKEN_TO_NONE_FROM_LEVEL_2 0x400 +#define BROKEN_TO_CLOSE_PENDING 0x800 +#define BROKEN_ANY (BROKEN_TO_LEVEL_2 | BROKEN_TO_NONE | BROKEN_TO_NONE_FROM_LEVEL_2 | BROKEN_TO_CLOSE_PENDING) + +#define TAG_OPLOCK 'orSF' + +typedef struct _INTERNAL_OPLOCK +{ + /* Level I IRP */ + PIRP ExclusiveIrp; + /* Level I FILE_OBJECT */ + PFILE_OBJECT FileObject; + /* Level II IRPs */ + LIST_ENTRY SharedListHead; + /* IRPs waiting on level I */ + LIST_ENTRY WaitListHead; + ULONG Flags; + PFAST_MUTEX IntLock; +} INTERNAL_OPLOCK, *PINTERNAL_OPLOCK; + +typedef struct _WAIT_CONTEXT +{ + LIST_ENTRY WaitListEntry; + PIRP Irp; + POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine; + PVOID CompletionContext; + ULONG Reserved; + ULONG_PTR SavedInformation; +} WAIT_CONTEXT, *PWAIT_CONTEXT; + +VOID +NTAPI +FsRtlNotifyCompletion(IN PVOID Context, + IN PIRP Irp) +{ + PAGED_CODE(); + + DPRINT("FsRtlNotifyCompletion(%p, %p)\n", Context, Irp); + + /* Just complete the IRP */ + return IoCompleteRequest(Irp, IO_DISK_INCREMENT); +} + +VOID +NTAPI +FsRtlCompletionRoutinePriv(IN PVOID Context, + IN PIRP Irp) +{ + PKEVENT WaitEvent; + + PAGED_CODE(); + + DPRINT("FsRtlCompletionRoutinePriv(%p, %p)\n", Context, Irp); + + /* Set the event */ + WaitEvent = (PKEVENT)Context; + KeSetEvent(WaitEvent, IO_NO_INCREMENT, FALSE); +} + +VOID +FsRtlRemoveAndCompleteWaitIrp(IN PWAIT_CONTEXT WaitCtx) +{ + PIRP Irp; + + PAGED_CODE(); + + DPRINT("FsRtlRemoveAndCompleteWaitIrp(%p)\n", WaitCtx); + + RemoveEntryList(&WaitCtx->WaitListEntry); + Irp = WaitCtx->Irp; + + /* No cancel routine anymore */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* Set the information */ + Irp->IoStatus.Information = WaitCtx->SavedInformation; + /* Set the status according to the fact it got cancel or not */ + Irp->IoStatus.Status = (Irp->Cancel ? STATUS_CANCELLED : STATUS_SUCCESS); + + /* Call the completion routine */ + WaitCtx->CompletionRoutine(WaitCtx->CompletionContext, Irp); + + /* And get rid of the now useless wait context */ + ExFreePoolWithTag(WaitCtx, TAG_OPLOCK); +} + +VOID +NTAPI +FsRtlCancelWaitIrp(IN PDEVICE_OBJECT DeviceObject, + IN PIRP Irp) +{ + PINTERNAL_OPLOCK Oplock; + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + + DPRINT("FsRtlCancelWaitIrp(%p, %p)\n", DeviceObject, Irp); + + /* Get the associated oplock */ + Oplock = (PINTERNAL_OPLOCK)Irp->IoStatus.Information; + + /* Remove the cancel routine (we're being called!) */ + IoSetCancelRoutine(Irp, NULL); + /* And release the cancel spin lock (always locked when cancel routine is called) */ + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* Now, remove and complete any associated waiter */ + ExAcquireFastMutex(Oplock->IntLock); + for (NextEntry = Oplock->WaitListHead.Flink; + NextEntry != &Oplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + + if (WaitCtx->Irp->Cancel) + { + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + } + ExReleaseFastMutex(Oplock->IntLock); +} + +VOID +FsRtlWaitOnIrp(IN PINTERNAL_OPLOCK Oplock, + IN PIRP Irp, + IN PVOID CompletionContext, + IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, + IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine, + IN PKEVENT WaitEvent) +{ + BOOLEAN Locked; + PWAIT_CONTEXT WaitCtx; + + DPRINT("FsRtlWaitOnIrp(%p, %p, %p, %p, %p, %p)\n", Oplock, Irp, CompletionContext, CompletionRoutine, PostIrpRoutine, WaitEvent); + + /* We must always be called with IntLock locked! */ + Locked = TRUE; + /* Dirty check for above statement */ + ASSERT(Oplock->IntLock->Owner == KeGetCurrentThread()); + + /* Allocate a wait context for the IRP */ + WaitCtx = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE, sizeof(WAIT_CONTEXT), TAG_OPLOCK); + WaitCtx->Irp = Irp; + WaitCtx->SavedInformation = Irp->IoStatus.Information; + /* If caller provided everything required, us it */ + if (CompletionRoutine != NULL) + { + WaitCtx->CompletionRoutine = CompletionRoutine; + WaitCtx->CompletionContext = CompletionContext; + } + /* Otherwise, put ourselves */ + else + { + WaitCtx->CompletionRoutine = FsRtlCompletionRoutinePriv; + WaitCtx->CompletionContext = WaitEvent; + KeInitializeEvent(WaitEvent, NotificationEvent, FALSE); + } + + /* If we got a prepost routine, call it now! */ + if (PostIrpRoutine != NULL) + { + PostIrpRoutine(CompletionContext, Irp); + } + + Irp->IoStatus.Status = STATUS_SUCCESS; + + /* Queue the IRP - it's OK, we're locked */ + InsertHeadList(&Oplock->WaitListHead, &WaitCtx->WaitListEntry); + + /* Set the oplock as information of the IRP (for the cancel routine) + * And lock the cancel routine lock for setting it + */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + Irp->IoStatus.Information = (ULONG_PTR)Oplock; + + /* If there's already a cancel routine + * Cancel the IRP + */ + if (Irp->Cancel) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + Locked = FALSE; + + if (CompletionRoutine != NULL) + { + IoMarkIrpPending(Irp); + } + FsRtlCancelWaitIrp(NULL, Irp); + } + /* Otherwise, put ourselves as the cancel routine and start waiting */ + else + { + IoSetCancelRoutine(Irp, FsRtlCancelWaitIrp); + IoReleaseCancelSpinLock(Irp->CancelIrql); + if (CompletionRoutine != NULL) + { + IoMarkIrpPending(Irp); + } + else + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + Locked = FALSE; + KeWaitForSingleObject(WaitEvent, Executive, KernelMode, FALSE, NULL); + } + } + + /* If we didn't unlock yet, do it now */ + if (Locked) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + } +} + +NTSTATUS +FsRtlOplockBreakNotify(IN PINTERNAL_OPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp) +{ + PAGED_CODE(); + + DPRINT("FsRtlOplockBreakNotify(%p, %p, %p)\n", Oplock, Stack, Irp); + + /* No oplock, no break to notify */ + if (Oplock == NULL) + { + Irp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_SUCCESS; + } + + /* Notify by completing the IRP, unless we have broken to shared */ + ExAcquireFastMutexUnsafe(Oplock->IntLock); + if (!BooleanFlagOn(Oplock->Flags, BROKEN_TO_LEVEL_2)) + { + Irp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + /* If it's pending, just complete the IRP and get rid of the oplock */ + if (BooleanFlagOn(Oplock->Flags, PENDING_LOCK)) + { + Oplock->FileObject = NULL; + Oplock->Flags = NO_OPLOCK; + Irp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + /* Otherwise, wait on the IRP */ + Irp->IoStatus.Status = STATUS_SUCCESS; + FsRtlWaitOnIrp(Oplock, Irp, NULL, FsRtlNotifyCompletion, NULL, NULL); + return STATUS_SUCCESS; +} + +VOID +FsRtlRemoveAndCompleteIrp(IN PIRP Irp) +{ + PIO_STACK_LOCATION Stack; + + DPRINT("FsRtlRemoveAndCompleteIrp(%p)\n", Irp); + + Stack = IoGetCurrentIrpStackLocation(Irp); + + /* Remove our extra ref */ + ObDereferenceObject(Stack->FileObject); + + /* Remove our cancel routine */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* Remove the IRP from the list it may be in (wait or shared) */ + RemoveEntryList(&Irp->Tail.Overlay.ListEntry); + + /* And complete! */ + Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Irp->IoStatus.Status = (Irp->Cancel ? STATUS_CANCELLED : STATUS_SUCCESS); + + IoCompleteRequest(Irp, IO_DISK_INCREMENT); +} + +VOID +NTAPI +FsRtlCancelOplockIIIrp(IN PDEVICE_OBJECT DeviceObject, + IN PIRP Irp) +{ + PINTERNAL_OPLOCK Oplock; + PLIST_ENTRY NextEntry; + PIRP ListIrp; + BOOLEAN Removed; + + DPRINT("FsRtlCancelOplockIIIrp(%p, %p)\n", DeviceObject, Irp); + + /* Get the associated oplock */ + Oplock = (PINTERNAL_OPLOCK)Irp->IoStatus.Information; + + /* Remove the cancel routine (it's OK, we're the cancel routine! )*/ + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* Nothing removed yet */ + Removed = FALSE; + ExAcquireFastMutex(Oplock->IntLock); + /* Browse all the IRPs associated to the shared lock */ + for (NextEntry = Oplock->SharedListHead.Flink; + NextEntry != &Oplock->SharedListHead; + NextEntry = NextEntry->Flink) + { + ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry); + + /* If canceled, remove it */ + if (ListIrp->Cancel) + { + FsRtlRemoveAndCompleteIrp(ListIrp); + Removed = TRUE; + } + } + + /* If no IRP left, the oplock is gone */ + if (Removed && IsListEmpty(&Oplock->SharedListHead)) + { + Oplock->Flags = NO_OPLOCK; + } + /* Don't forget to release the mutex */ + ExReleaseFastMutex(Oplock->IntLock); +} + +NTSTATUS +FsRtlAcknowledgeOplockBreak(IN PINTERNAL_OPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp, + IN BOOLEAN SwitchToLevel2) +{ + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + BOOLEAN Deref; + BOOLEAN Locked; + + DPRINT("FsRtlAcknowledgeOplockBreak(%p, %p, %p, %u)\n", Oplock, Stack, Irp, Unknown); + + /* No oplock, nothing to acknowledge */ + if (Oplock == NULL) + { + Irp->IoStatus.Status = STATUS_INVALID_OPLOCK_PROTOCOL; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_INVALID_OPLOCK_PROTOCOL; + } + + /* Acquire oplock internal lock */ + ExAcquireFastMutexUnsafe(Oplock->IntLock); + Locked = TRUE; + /* Does it match the file? */ + if (Oplock->FileObject != Stack->FileObject) + { + Irp->IoStatus.Status = STATUS_INVALID_OPLOCK_PROTOCOL; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_INVALID_OPLOCK_PROTOCOL; + } + + /* Assume we'll have to deref our extra ref (level I) */ + Deref = TRUE; + + /* If we got broken to level 2 and asked for a shared lock + * switch the oplock to shared + */ + if (SwitchToLevel2 && BooleanFlagOn(Oplock->Flags, BROKEN_TO_LEVEL_2)) + { + /* The IRP cannot be synchronous, we'll move it to the LEVEL_2 IRPs */ + ASSERT(!IoIsOperationSynchronous(Irp)); + + /* Mark the IRP pending, and queue it for the shared IRPs */ + IoMarkIrpPending(Irp); + Irp->IoStatus.Status = STATUS_SUCCESS; + InsertTailList(&Oplock->SharedListHead, &Irp->Tail.Overlay.ListEntry); + + /* Don't deref, we're not done yet */ + Deref = FALSE; + /* And mark we've got a shared lock */ + Oplock->Flags = LEVEL_2_OPLOCK; + /* To find the lock back on cancel */ + Irp->IoStatus.Information = (ULONG_PTR)Oplock; + + /* Acquire the spinlock to set the cancel routine */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + /* If IRP got canceled, call it immediately */ + if (Irp->Cancel) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + Locked = FALSE; + FsRtlCancelOplockIIIrp(NULL, Irp); + } + /* Otherwise, just set our cancel routine */ + else + { + IoSetCancelRoutine(Irp, FsRtlCancelOplockIIIrp); + IoReleaseCancelSpinLock(Irp->CancelIrql); + } + } + /* If oplock got broken, remove it */ + else if (BooleanFlagOn(Oplock->Flags, (BROKEN_TO_NONE | BROKEN_TO_LEVEL_2))) + { + Irp->IoStatus.Status = STATUS_SUCCESS; + IofCompleteRequest(Irp, IO_DISK_INCREMENT); + Oplock->Flags = NO_OPLOCK; + } + /* Same, but precise we got broken from none to shared */ + else if (BooleanFlagOn(Oplock->Flags, BROKEN_TO_NONE_FROM_LEVEL_2)) + { + Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Irp->IoStatus.Status = STATUS_SUCCESS; + IofCompleteRequest(Irp, IO_DISK_INCREMENT); + Oplock->Flags = NO_OPLOCK; + } + + /* Now, complete any IRP waiting */ + for (NextEntry = Oplock->WaitListHead.Flink; + NextEntry != &Oplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + + /* If we dropped oplock, remove our extra ref */ + if (Deref) + { + ObfDereferenceObject(Oplock->FileObject); + } + /* And unset FO: no oplock left or shared */ + Oplock->FileObject = NULL; + + /* Don't leak the mutex! */ + if (Locked) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + } + + return STATUS_SUCCESS; +} + +NTSTATUS +FsRtlOpBatchBreakClosePending(IN PINTERNAL_OPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp) +{ + NTSTATUS Status; + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + + PAGED_CODE(); + + DPRINT("FsRtlOpBatchBreakClosePending(%p, %p, %p)\n", Oplock, Stack, Irp); + + /* No oplock, that's not legit! */ + if (Oplock == NULL) + { + Irp->IoStatus.Status = STATUS_INVALID_OPLOCK_PROTOCOL; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_INVALID_OPLOCK_PROTOCOL; + } + + Status = STATUS_SUCCESS; + ExAcquireFastMutexUnsafe(Oplock->IntLock); + + /* First of all, check if all conditions are met: + * Correct FO + broken oplock + */ + if (Oplock->FileObject == Stack->FileObject && (BooleanFlagOn(Oplock->Flags, (BROKEN_TO_LEVEL_2 | BROKEN_TO_NONE | BROKEN_TO_NONE_FROM_LEVEL_2)))) + { + /* If we have a pending or level 1 oplock... */ + if (BooleanFlagOn(Oplock->Flags, (PENDING_LOCK | LEVEL_1_OPLOCK))) + { + /* Remove our extra ref from the FO */ + if (Oplock->Flags & LEVEL_1_OPLOCK) + { + ObDereferenceObject(Oplock->FileObject); + } + + /* And remove the oplock */ + Oplock->Flags = NO_OPLOCK; + Oplock->FileObject = NULL; + + /* Complete any waiting IRP */ + for (NextEntry = Oplock->WaitListHead.Flink; + NextEntry != &Oplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + } + /* Otherwise, mark the oplock as close pending */ + else + { + ClearFlag(Oplock->Flags, BROKEN_ANY); + SetFlag(Oplock->Flags, BROKEN_TO_CLOSE_PENDING); + } + } + /* Oplock is in invalid state */ + else + { + Status = STATUS_INVALID_OPLOCK_PROTOCOL; + } + + /* And complete */ + Irp->IoStatus.Status = Status; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + ExReleaseFastMutexUnsafe(Oplock->IntLock); + + return Status; +} + +PINTERNAL_OPLOCK +FsRtlAllocateOplock(VOID) +{ + PINTERNAL_OPLOCK Oplock = NULL; + + PAGED_CODE(); + + DPRINT("FsRtlAllocateOplock()\n"); + + _SEH2_TRY + { + /* Allocate and initialize the oplock */ + Oplock = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE | POOL_COLD_ALLOCATION, sizeof(INTERNAL_OPLOCK), TAG_OPLOCK); + RtlZeroMemory(Oplock, sizeof(INTERNAL_OPLOCK)); + /* We allocate the fast mutex separately to have it non paged (while the rest of the oplock can be paged) */ + Oplock->IntLock = ExAllocatePoolWithTag(NonPagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE, sizeof(FAST_MUTEX), TAG_OPLOCK); + ExInitializeFastMutex(Oplock->IntLock); + /* Initialize the IRP list for level 2 oplock */ + InitializeListHead(&Oplock->SharedListHead); + /* And for the wait IRPs */ + InitializeListHead(&Oplock->WaitListHead); + Oplock->Flags = NO_OPLOCK; + } + _SEH2_FINALLY + { + /* In case of abnormal termination, it means either OPLOCK or FAST_MUTEX allocation failed */ + if (_abnormal_termination()) + { + /* That FAST_MUTEX, free OPLOCK */ + if (Oplock != NULL) + { + ExFreePoolWithTag(Oplock, TAG_OPLOCK); + Oplock = NULL; + } + } + } + _SEH2_END; + + return Oplock; +} + +VOID +NTAPI +FsRtlCancelExclusiveIrp(IN PDEVICE_OBJECT DeviceObject, + IN PIRP Irp) +{ + PINTERNAL_OPLOCK IntOplock; + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + + DPRINT("FsRtlCancelExclusiveIrp(%p, %p)\n", DeviceObject, Irp); + + /* Get the associated oplock */ + IntOplock = (PINTERNAL_OPLOCK)Irp->IoStatus.Information; + + /* Remove the cancel routine (us!) and release the cancel spinlock */ + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* Acquire our internal FAST_MUTEX */ + ExAcquireFastMutex(IntOplock->IntLock); + /* If we had an exclusive IRP */ + if (IntOplock->ExclusiveIrp != NULL && IntOplock->ExclusiveIrp->Cancel) + { + /* Cancel it, and remove it from the oplock */ + IntOplock->ExclusiveIrp->IoStatus.Status = STATUS_CANCELLED; + IoCompleteRequest(IntOplock->ExclusiveIrp, IO_DISK_INCREMENT); + IntOplock->ExclusiveIrp = NULL; + + /* Dereference the fileobject and remove the oplock */ + ObDereferenceObject(IntOplock->FileObject); + IntOplock->FileObject = NULL; + IntOplock->Flags = NO_OPLOCK; + + /* And complete any waiting IRP */ + for (NextEntry = IntOplock->WaitListHead.Flink; + NextEntry != &IntOplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + } + + /* Done! */ + ExReleaseFastMutexUnsafe(IntOplock->IntLock); +} + +NTSTATUS +FsRtlRequestExclusiveOplock(IN POPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp, + IN ULONG Flags) +{ + PINTERNAL_OPLOCK IntOplock; + PIRP ListIrp; + BOOLEAN Locked; + NTSTATUS Status; + + DPRINT("FsRtlRequestExclusiveOplock(%p, %p, %p, %lu)\n", Oplock, Stack, Irp, Flags); + + IntOplock = *Oplock; + Locked = FALSE; + Status = STATUS_SUCCESS; + + /* Time to work! */ + _SEH2_TRY + { + /* Was the oplock already allocated? If not, do it now! */ + if (IntOplock == NULL) + { + *Oplock = FsRtlAllocateOplock(); + IntOplock = *Oplock; + } + + /* Acquire our internal lock */ + ExAcquireFastMutexUnsafe(IntOplock->IntLock); + Locked = TRUE; + + /* If we request exclusiveness, a filter or a pending oplock, grant it */ + if (Flags == (EXCLUSIVE_LOCK | PENDING_LOCK | FILTER_OPLOCK)) + { + /* Either no oplock, or pending */ + ASSERT(BooleanFlagOn(IntOplock->Flags, (NO_OPLOCK | PENDING_LOCK))); + IntOplock->ExclusiveIrp = Irp; + IntOplock->FileObject = Stack->FileObject; + IntOplock->Flags = (EXCLUSIVE_LOCK | PENDING_LOCK | FILTER_OPLOCK); + } + else + { + /* Otherwise, shared or no effective oplock */ + if (BooleanFlagOn(IntOplock->Flags, (LEVEL_2_OPLOCK | PENDING_LOCK | NO_OPLOCK))) + { + /* The shared IRPs list should contain a single entry! */ + if (IntOplock->Flags == LEVEL_2_OPLOCK) + { + ListIrp = CONTAINING_RECORD(IntOplock->SharedListHead.Flink, IRP, Tail.Overlay.ListEntry); + ASSERT(IntOplock->SharedListHead.Flink == IntOplock->SharedListHead.Blink); + FsRtlRemoveAndCompleteIrp(ListIrp); + } + + /* Set the exclusiveness */ + IntOplock->ExclusiveIrp = Irp; + IntOplock->FileObject = Stack->FileObject; + IntOplock->Flags = Flags; + + /* Mark the IRP pending and reference our file object */ + IoMarkIrpPending(Irp); + ObReferenceObject(Stack->FileObject); + Irp->IoStatus.Information = (ULONG_PTR)IntOplock; + + /* Now, set ourselves as cancel routine */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + /* Unless IRP got canceled, then, just give up */ + if (Irp->Cancel) + { + ExReleaseFastMutexUnsafe(IntOplock->IntLock); + Locked = FALSE; + FsRtlCancelExclusiveIrp(NULL, Irp); + Status = STATUS_CANCELLED; + } + else + { + IoSetCancelRoutine(Irp, FsRtlCancelExclusiveIrp); + IoReleaseCancelSpinLock(Irp->CancelIrql); + } + } + /* Cannot set exclusiveness, fail */ + else + { + if (Irp != NULL) + { + Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + Status = STATUS_OPLOCK_NOT_GRANTED; + } + } + } + } + /* If locked, release */ + _SEH2_FINALLY + { + if (Locked) + { + ExReleaseFastMutexUnsafe(IntOplock->IntLock); + } + } + _SEH2_END; + + return Status; +} + +NTSTATUS +FsRtlRequestOplockII(IN POPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp) +{ + BOOLEAN Locked; + NTSTATUS Status; + PINTERNAL_OPLOCK IntOplock; + + DPRINT("FsRtlRequestOplockII(%p, %p, %p)\n", Oplock, Stack, Irp); + + IntOplock = *Oplock; + Locked = FALSE; + Status = STATUS_SUCCESS; + + _SEH2_TRY + { + /* No oplock yet? Allocate it */ + if (IntOplock == NULL) + { + *Oplock = FsRtlAllocateOplock(); + IntOplock = *Oplock; + } + + /* Acquire the oplock */ + ExAcquireFastMutexUnsafe(IntOplock->IntLock); + Locked = TRUE; + + /* If already shared, or no oplock that's fine! */ + if (BooleanFlagOn(IntOplock->Flags, (LEVEL_2_OPLOCK | NO_OPLOCK))) + { + IoMarkIrpPending(Irp); + /* Granted! */ + Irp->IoStatus.Status = STATUS_SUCCESS; + + /* Insert in the shared list */ + InsertTailList(&IntOplock->SharedListHead, &Irp->Tail.Overlay.ListEntry); + + /* Save the associated oplock */ + Irp->IoStatus.Information = (ULONG_PTR)IntOplock; + + /* The oplock is shared */ + IntOplock->Flags = LEVEL_2_OPLOCK; + + /* Reference the fileobject */ + ObReferenceObject(Stack->FileObject); + + /* Set our cancel routine, unless the IRP got canceled in-between */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + if (Irp->Cancel) + { + ExReleaseFastMutexUnsafe(IntOplock->IntLock); + Locked = FALSE; + FsRtlCancelOplockIIIrp(NULL, Irp); + Status = STATUS_CANCELLED; + } + else + { + IoSetCancelRoutine(Irp, FsRtlCancelOplockIIIrp); + IoReleaseCancelSpinLock(Irp->CancelIrql); + } + } + /* Otherwise, just fail */ + else + { + Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + Status = STATUS_OPLOCK_NOT_GRANTED; + } + } + _SEH2_FINALLY + { + if (Locked) + { + ExReleaseFastMutexUnsafe(IntOplock->IntLock); + } + } + _SEH2_END; + + return Status; +} + +VOID +FsRtlOplockCleanup(IN PINTERNAL_OPLOCK Oplock, + IN PIO_STACK_LOCATION Stack) +{ + PIO_STACK_LOCATION ListStack; + PLIST_ENTRY NextEntry; + PIRP ListIrp; + PWAIT_CONTEXT WaitCtx; + + DPRINT("FsRtlOplockCleanup(%p, %p)\n", Oplock, Stack); + + ExAcquireFastMutexUnsafe(Oplock->IntLock); + /* oplock cleaning only makes sense if there's an oplock */ + if (Oplock->Flags != NO_OPLOCK) + { + /* Shared lock */ + if (Oplock->Flags == LEVEL_2_OPLOCK) + { + /* Complete any associated IRP */ + for (NextEntry = Oplock->SharedListHead.Flink; + NextEntry != &Oplock->SharedListHead; + NextEntry = NextEntry->Flink) + { + ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry); + ListStack = IoGetCurrentIrpStackLocation(ListIrp); + + if (Stack->FileObject == ListStack->FileObject) + { + FsRtlRemoveAndCompleteIrp(ListIrp); + } + } + + /* If, in the end, no IRP is left, then the lock is gone */ + if (IsListEmpty(&Oplock->SharedListHead)) + { + Oplock->Flags = NO_OPLOCK; + } + } + else + { + /* If we have matching file */ + if (Oplock->FileObject == Stack->FileObject) + { + /* Oplock wasn't broken (still exclusive), easy case */ + if (!BooleanFlagOn(Oplock->Flags, (BROKEN_ANY | PENDING_LOCK))) + { + /* Remove the cancel routine we set previously */ + IoAcquireCancelSpinLock(&Oplock->ExclusiveIrp->CancelIrql); + IoSetCancelRoutine(Oplock->ExclusiveIrp, NULL); + IoReleaseCancelSpinLock(Oplock->ExclusiveIrp->CancelIrql); + + /* And return the fact we broke the oplock to no oplock */ + Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Oplock->ExclusiveIrp->IoStatus.Status = STATUS_SUCCESS; + + /* And complete! */ + IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT); + Oplock->ExclusiveIrp = NULL; + } + + /* If no pending, we can safely dereference the file object */ + if (!BooleanFlagOn(Oplock->Flags, PENDING_LOCK)) + { + ObDereferenceObject(Oplock->FileObject); + } + + /* Now, remove the oplock */ + Oplock->FileObject = NULL; + Oplock->Flags = NO_OPLOCK; + + /* And complete any waiting IRP */ + for (NextEntry = Oplock->WaitListHead.Flink; + NextEntry != &Oplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + } + } + } + ExReleaseFastMutexUnsafe(Oplock->IntLock); +} + +NTSTATUS +NTAPI +FsRtlOplockBreakToNone(IN PINTERNAL_OPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp, + IN PVOID Context, + IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, + IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL) +{ + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + PIRP ListIrp; + KEVENT WaitEvent; + + DPRINT("FsRtlOplockBreakToNone(%p, %p, %p, %p, %p, %p)\n", Oplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine); + + ExAcquireFastMutexUnsafe(Oplock->IntLock); + + /* No oplock to break! */ + if (Oplock->Flags == NO_OPLOCK) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + /* Not broken yet, but set... Let's do it! + * Also, we won't break a shared oplock + */ + if (!BooleanFlagOn(Oplock->Flags, (BROKEN_ANY | PENDING_LOCK | LEVEL_2_OPLOCK))) + { + /* Remove our cancel routine, no longer needed */ + IoAcquireCancelSpinLock(&Oplock->ExclusiveIrp->CancelIrql); + IoSetCancelRoutine(Oplock->ExclusiveIrp, NULL); + IoReleaseCancelSpinLock(Oplock->ExclusiveIrp->CancelIrql); + + /* If the IRP got canceled, we need to cleanup a bit */ + if (Oplock->ExclusiveIrp->Cancel) + { + /* Return cancelation */ + Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Oplock->ExclusiveIrp->IoStatus.Status = STATUS_CANCELLED; + IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT); + + /* No oplock left */ + Oplock->Flags = NO_OPLOCK; + Oplock->ExclusiveIrp = NULL; + + /* No need for the FO anymore */ + ObDereferenceObject(Oplock->FileObject); + Oplock->FileObject = NULL; + + /* And complete any waiting IRP */ + for (NextEntry = Oplock->WaitListHead.Flink; + NextEntry != &Oplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + + /* Done! */ + ExReleaseFastMutexUnsafe(Oplock->IntLock); + + return STATUS_SUCCESS; + } + + /* Easier break, just complete :-) */ + Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Oplock->ExclusiveIrp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT); + + /* And remove our exclusive IRP */ + Oplock->ExclusiveIrp = NULL; + SetFlag(Oplock->Flags, BROKEN_TO_NONE); + } + /* Shared lock */ + else if (Oplock->Flags == LEVEL_2_OPLOCK) + { + /* Complete any IRP in the shared lock */ + for (NextEntry = Oplock->SharedListHead.Flink; + NextEntry != &Oplock->SharedListHead; + NextEntry = NextEntry->Flink) + { + ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry); + FsRtlRemoveAndCompleteIrp(ListIrp); + } + + /* No lock left */ + Oplock->Flags = NO_OPLOCK; + + /* Done */ + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + /* If it was broken to level 2, break it to none from level 2 */ + else if (Oplock->Flags & BROKEN_TO_LEVEL_2) + { + ClearFlag(Oplock->Flags, BROKEN_TO_LEVEL_2); + SetFlag(Oplock->Flags, BROKEN_TO_NONE_FROM_LEVEL_2); + } + /* If it was pending, just drop the lock */ + else if (BooleanFlagOn(Oplock->Flags, PENDING_LOCK)) + { + Oplock->Flags = NO_OPLOCK; + Oplock->FileObject = NULL; + + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + /* If that's ours, job done */ + if (Oplock->FileObject == Stack->FileObject) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + /* Otherwise, wait on the IRP */ + if (Stack->MajorFunction != IRP_MJ_CREATE || !BooleanFlagOn(Stack->Parameters.Create.Options, FILE_COMPLETE_IF_OPLOCKED)) + { + FsRtlWaitOnIrp(Oplock, Irp, Context, CompletionRoutine, PostIrpRoutine, &WaitEvent); + + ExReleaseFastMutexUnsafe(Oplock->IntLock); + + return STATUS_SUCCESS; + } + /* Done */ + else + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_OPLOCK_BREAK_IN_PROGRESS; + } +} + +NTSTATUS +NTAPI +FsRtlOplockBreakToII(IN PINTERNAL_OPLOCK Oplock, + IN PIO_STACK_LOCATION Stack, + IN PIRP Irp, + IN PVOID Context, + IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, + IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL) +{ + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + KEVENT WaitEvent; + + DPRINT("FsRtlOplockBreakToII(%p, %p, %p, %p, %p, %p)\n", Oplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine); + + ExAcquireFastMutexUnsafe(Oplock->IntLock); + + /* If our lock, or if not exclusively locked, nothing to break! */ + if (!BooleanFlagOn(Oplock->Flags, EXCLUSIVE_LOCK) || Oplock->FileObject == Stack->FileObject) + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + /* If already broken or not set yet */ + if (BooleanFlagOn(Oplock->Flags, (BROKEN_ANY | PENDING_LOCK))) + { + /* Drop oplock if pending */ + if (BooleanFlagOn(Oplock->Flags, PENDING_LOCK)) + { + Oplock->Flags = NO_OPLOCK; + Oplock->FileObject = NULL; + + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_SUCCESS; + } + + } + /* To break! */ + else + { + /* Drop the cancel routine of the exclusive IRP */ + IoAcquireCancelSpinLock(&Oplock->ExclusiveIrp->CancelIrql); + IoSetCancelRoutine(Oplock->ExclusiveIrp, NULL); + IoReleaseCancelSpinLock(Oplock->ExclusiveIrp->CancelIrql); + + /* If it was canceled in between, break to no oplock */ + if (Oplock->ExclusiveIrp->Cancel) + { + /* Complete the IRP with cancellation */ + Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Oplock->ExclusiveIrp->IoStatus.Status = STATUS_CANCELLED; + IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT); + + /* And mark we have no longer lock */ + Oplock->Flags = NO_OPLOCK; + Oplock->ExclusiveIrp = NULL; + ObDereferenceObject(Oplock->FileObject); + Oplock->FileObject = NULL; + + /* Finally, complete any waiter */ + for (NextEntry = Oplock->WaitListHead.Flink; + NextEntry != &Oplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + FsRtlRemoveAndCompleteWaitIrp(WaitCtx); + } + + ExReleaseFastMutexUnsafe(Oplock->IntLock); + + return STATUS_SUCCESS; + } + + /* It wasn't canceled, so break to shared unless we were alone, in that case we break to no lock! */ + Oplock->ExclusiveIrp->IoStatus.Status = STATUS_SUCCESS; + if (BooleanFlagOn(Oplock->Flags, (BATCH_OPLOCK | LEVEL_1_OPLOCK))) + { + SetFlag(Oplock->Flags, BROKEN_TO_LEVEL_2); + Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_LEVEL_2; + } + else + { + SetFlag(Oplock->Flags, BROKEN_TO_NONE); + Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + } + /* And complete */ + IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT); + Oplock->ExclusiveIrp = NULL; + } + + /* Wait if required */ + if (Stack->MajorFunction != IRP_MJ_CREATE || !BooleanFlagOn(Stack->Parameters.Create.Options, FILE_COMPLETE_IF_OPLOCKED)) + { + FsRtlWaitOnIrp(Oplock, Irp, Context, CompletionRoutine, PostIrpRoutine, &WaitEvent); + + ExReleaseFastMutexUnsafe(Oplock->IntLock); + + return STATUS_SUCCESS; + } + else + { + ExReleaseFastMutexUnsafe(Oplock->IntLock); + return STATUS_OPLOCK_BREAK_IN_PROGRESS; + } +} + /* PUBLIC FUNCTIONS **********************************************************/ /*++ @@ -48,14 +1175,181 @@ FsRtlCheckOplock(IN POPLOCK Oplock, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL) { - /* Unimplemented */ - UNIMPLEMENTED; + PINTERNAL_OPLOCK IntOplock; + PIO_STACK_LOCATION Stack; + ACCESS_MASK DesiredAccess; + FILE_INFORMATION_CLASS FileInfo; + ULONG CreateDisposition; + +#define BreakToIIIfRequired \ + if (IntOplock->Flags != LEVEL_2_OPLOCK || IntOplock->FileObject != Stack->FileObject) \ + return FsRtlOplockBreakToII(IntOplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine) + +#define BreakToNoneIfRequired \ + if (IntOplock->Flags == LEVEL_2_OPLOCK || IntOplock->FileObject != Stack->FileObject) \ + return FsRtlOplockBreakToNone(IntOplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine) + + DPRINT("FsRtlCheckOplock(%p, %p, %p, %p, %p)\n", Oplock, Irp, Context, CompletionRoutine, PostIrpRoutine); + + IntOplock = *Oplock; + + /* No oplock, easy! */ + if (IntOplock == NULL) + { + return STATUS_SUCCESS; + } + + /* No sense on paging */ + if (Irp->Flags & IRP_PAGING_IO) + { + return STATUS_SUCCESS; + } + + /* No oplock, easy (bis!) */ + if (IntOplock->Flags == NO_OPLOCK) + { + return STATUS_SUCCESS; + } + + Stack = IoGetCurrentIrpStackLocation(Irp); + + /* If cleanup, cleanup the associated oplock & return */ + if (Stack->MajorFunction == IRP_MJ_CLEANUP) + { + FsRtlOplockCleanup(IntOplock, Stack); + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_LOCK_CONTROL) + { + /* OK for filter */ + if (BooleanFlagOn(IntOplock->Flags, FILTER_OPLOCK)) + { + return STATUS_SUCCESS; + } + + /* Lock operation, we will have to break to no lock if shared or not us */ + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) + { + /* FSCTL should be safe, unless user wants a write FSCTL */ + if (Stack->Parameters.FileSystemControl.FsControlCode != FSCTL_SET_ZERO_DATA) + { + return STATUS_SUCCESS; + } + + /* We will have to break for write if shared or not us! */ + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_WRITE) + { + /* Write operation, we will have to break if shared or not us */ + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_READ) + { + /* If that's filter oplock, it's alright */ + if (BooleanFlagOn(IntOplock->Flags, FILTER_OPLOCK)) + { + return STATUS_SUCCESS; + } + + /* Otherwise, we need to break to shared oplock */ + BreakToIIIfRequired; + + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_CREATE) + { + DesiredAccess = Stack->Parameters.Create.SecurityContext->DesiredAccess; + + /* If that's just for reading, the oplock is fine */ + if ((!(DesiredAccess & ~(SYNCHRONIZE | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_READ_DATA)) && !(Stack->Parameters.Create.Options & FILE_RESERVE_OPFILTER)) + || (BooleanFlagOn(IntOplock->Flags, FILTER_OPLOCK) && !(DesiredAccess & ~(SYNCHRONIZE | READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_EXECUTE | FILE_READ_EA | FILE_WRITE_DATA)) && BooleanFlagOn(Stack->Parameters.Create.ShareAccess, FILE_SHARE_READ))) + { + return STATUS_SUCCESS; + } + + /* Otherwise, check the disposition */ + CreateDisposition = (Stack->Parameters.Create.Options >> 24) & 0x000000FF; + if (!CreateDisposition || CreateDisposition == FILE_OVERWRITE || + CreateDisposition == FILE_OVERWRITE_IF || + BooleanFlagOn(Stack->Parameters.Create.Options, FILE_RESERVE_OPFILTER)) + { + /* Not us, we have to break the oplock! */ + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + + /* It's fine, we can have the oplock shared */ + BreakToIIIfRequired; + + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_FLUSH_BUFFERS) + { + /* We need to share the lock, if not done yet! */ + BreakToIIIfRequired; + + return STATUS_SUCCESS; + } + else if (Stack->MajorFunction == IRP_MJ_SET_INFORMATION) + { + /* Only deal with really specific classes */ + FileInfo = Stack->Parameters.SetFile.FileInformationClass; + if (FileInfo == FileRenameInformation || FileInfo == FileLinkInformation || + FileInfo == FileShortNameInformation) + { + /* No need to break */ + if (!BooleanFlagOn(IntOplock->Flags, (FILTER_OPLOCK | BATCH_OPLOCK))) + { + return STATUS_SUCCESS; + } + /* Otherwise break to none */ + else + { + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + } + else if (FileInfo == FileAllocationInformation) + { + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + else if (FileInfo == FileEndOfFileInformation) + { + /* Advance only, nothing to do */ + if (Stack->Parameters.SetFile.AdvanceOnly) + { + return STATUS_SUCCESS; + } + + /* Otherwise, attempt to break to none */ + BreakToNoneIfRequired; + + return STATUS_SUCCESS; + } + } + +#undef BreakToIIIfRequired +#undef BreakToNoneIfRequired + return STATUS_SUCCESS; } /*++ * @name FsRtlCurrentBatchOplock - * @unimplemented + * @implemented * * FILLME * @@ -71,8 +1365,21 @@ BOOLEAN NTAPI FsRtlCurrentBatchOplock(IN POPLOCK Oplock) { - /* Unimplemented */ - UNIMPLEMENTED; + PINTERNAL_OPLOCK IntOplock; + + PAGED_CODE(); + + DPRINT("FsRtlCurrentBatchOplock(%p)\n", Oplock); + + IntOplock = *Oplock; + + /* Only return true if batch or filter oplock */ + if (IntOplock != NULL && + BooleanFlagOn(IntOplock->Flags, (FILTER_OPLOCK | BATCH_OPLOCK))) + { + return TRUE; + } + return FALSE; } @@ -95,6 +1402,9 @@ NTAPI FsRtlInitializeOplock(IN OUT POPLOCK Oplock) { PAGED_CODE(); + + /* Nothing to do */ + DPRINT("FsRtlInitializeOplock(%p)\n", Oplock); } /*++ @@ -123,14 +1433,123 @@ FsRtlOplockFsctrl(IN POPLOCK Oplock, IN PIRP Irp, IN ULONG OpenCount) { - /* Unimplemented */ - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PIO_STACK_LOCATION Stack; + PINTERNAL_OPLOCK IntOplock; + + PAGED_CODE(); + + DPRINT("FsRtlOplockFsctrl(%p, %p, %lu)\n", Oplock, Irp, OpenCount); + + IntOplock = *Oplock; + Stack = IoGetCurrentIrpStackLocation(Irp); + /* Make sure it's not called on create */ + if (Stack->MajorFunction != IRP_MJ_CREATE) + { + switch (Stack->Parameters.FileSystemControl.FsControlCode) + { + case FSCTL_OPLOCK_BREAK_NOTIFY: + return FsRtlOplockBreakNotify(IntOplock, Stack, Irp); + + case FSCTL_OPLOCK_BREAK_ACK_NO_2: + return FsRtlAcknowledgeOplockBreak(IntOplock, Stack, Irp, FALSE); + + case FSCTL_OPBATCH_ACK_CLOSE_PENDING: + return FsRtlOpBatchBreakClosePending(IntOplock, Stack, Irp); + + case FSCTL_REQUEST_OPLOCK_LEVEL_1: + /* We can only grant level 1 if synchronous, and only a single handle to it + * (plus, not a paging IO - obvious, and not cleanup done...) + */ + if (OpenCount == 1 && !IoIsOperationSynchronous(Irp) && + !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE)) + { + return FsRtlRequestExclusiveOplock(Oplock, Stack, Irp, EXCLUSIVE_LOCK | LEVEL_1_OPLOCK); + } + /* Not matching, fail */ + else + { + Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_OPLOCK_NOT_GRANTED; + } + + case FSCTL_REQUEST_OPLOCK_LEVEL_2: + /* Shared can only be granted if no byte-range lock, and async operation + * (plus, not a paging IO - obvious, and not cleanup done...) + */ + if (OpenCount == 0 && !IoIsOperationSynchronous(Irp) && + !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE)) + { + return FsRtlRequestOplockII(Oplock, Stack, Irp); + } + /* Not matching, fail */ + else + { + Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_OPLOCK_NOT_GRANTED; + } + + case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE: + return FsRtlAcknowledgeOplockBreak(IntOplock, Stack, Irp, TRUE); + + case FSCTL_REQUEST_BATCH_OPLOCK: + /* Batch oplock can only be granted if there's a byte-range lock and async operation + * (plus, not a paging IO - obvious, and not cleanup done...) + */ + if (OpenCount == 1 && !IoIsOperationSynchronous(Irp) && + !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE)) + { + return FsRtlRequestExclusiveOplock(Oplock, Stack, Irp, EXCLUSIVE_LOCK | BATCH_OPLOCK); + } + /* Not matching, fail */ + else + { + Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_OPLOCK_NOT_GRANTED; + } + + case FSCTL_REQUEST_FILTER_OPLOCK: + /* Filter oplock can only be granted if there's a byte-range lock and async operation + * (plus, not a paging IO - obvious, and not cleanup done...) + */ + if (OpenCount == 1 && !IoIsOperationSynchronous(Irp) && + !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE)) + { + return FsRtlRequestExclusiveOplock(Oplock, Stack, Irp, EXCLUSIVE_LOCK | FILTER_OPLOCK); + } + /* Not matching, fail */ + else + { + Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_OPLOCK_NOT_GRANTED; + } + + default: + Irp->IoStatus.Status = STATUS_INVALID_PARAMETER; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + return STATUS_INVALID_PARAMETER; + } + } + + /* That's a create operation! Only grant exclusive if there's a single user handle opened + * and we're only performing reading operations. + */ + if (OpenCount == 1 && + !(Stack->Parameters.Create.SecurityContext->DesiredAccess & ~(FILE_READ_ATTRIBUTES | FILE_READ_DATA)) && + (Stack->Parameters.Create.ShareAccess & FILE_SHARE_VALID_FLAGS) == FILE_SHARE_VALID_FLAGS) + { + return FsRtlRequestExclusiveOplock(Oplock, Stack, NULL, EXCLUSIVE_LOCK | PENDING_LOCK | FILTER_OPLOCK); + } + + return STATUS_OPLOCK_NOT_GRANTED; } /*++ * @name FsRtlOplockIsFastIoPossible - * @unimplemented + * @implemented * * FILLME * @@ -146,13 +1565,27 @@ BOOLEAN NTAPI FsRtlOplockIsFastIoPossible(IN POPLOCK Oplock) { - UNIMPLEMENTED; + PINTERNAL_OPLOCK IntOplock; + + PAGED_CODE(); + + DPRINT("FsRtlOplockIsFastIoPossible(%p)\n", Oplock); + + IntOplock = *Oplock; + + /* If there's a shared oplock or if it was used for write operation, deny FastIO */ + if (IntOplock != NULL && + BooleanFlagOn(IntOplock->Flags, (BROKEN_ANY | LEVEL_2_OPLOCK))) + { + return FALSE; + } + return TRUE; } /*++ * @name FsRtlUninitializeOplock - * @unimplemented + * @implemented * * FILLME * @@ -168,6 +1601,103 @@ VOID NTAPI FsRtlUninitializeOplock(IN POPLOCK Oplock) { - UNIMPLEMENTED; + PINTERNAL_OPLOCK IntOplock; + PLIST_ENTRY NextEntry; + PWAIT_CONTEXT WaitCtx; + PIRP Irp; + PIO_STACK_LOCATION Stack; + + DPRINT("FsRtlUninitializeOplock(%p)\n", Oplock); + + IntOplock = *Oplock; + + /* No oplock, nothing to do */ + if (IntOplock == NULL) + { + return; + } + + /* Caller won't have the oplock anymore */ + *Oplock = NULL; + + _SEH2_TRY + { + ExAcquireFastMutexUnsafe(IntOplock->IntLock); + + /* If we had IRPs waiting for the lock, complete them */ + for (NextEntry = IntOplock->WaitListHead.Flink; + NextEntry != &IntOplock->WaitListHead; + NextEntry = NextEntry->Flink) + { + WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry); + Irp = WaitCtx->Irp; + + RemoveEntryList(&WaitCtx->WaitListEntry); + /* Remove the cancel routine */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* And complete */ + Irp->IoStatus.Information = 0; + WaitCtx->CompletionRoutine(WaitCtx->CompletionContext, WaitCtx->Irp); + + ExFreePoolWithTag(WaitCtx, TAG_OPLOCK); + } + + /* If we had shared IRPs (LEVEL_2), complete them */ + for (NextEntry = IntOplock->SharedListHead.Flink; + NextEntry != &IntOplock->SharedListHead; + NextEntry = NextEntry->Flink) + { + Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry); + + RemoveEntryList(&Irp->Tail.Overlay.ListEntry); + + /* Remvoe the cancel routine */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* Dereference the file object */ + Stack = IoGetCurrentIrpStackLocation(Irp); + ObDereferenceObject(Stack->FileObject); + + /* And complete */ + Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Irp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + } + + /* If we have an exclusive IRP, complete it */ + Irp = IntOplock->ExclusiveIrp; + if (Irp != NULL) + { + /* Remvoe the cancel routine */ + IoAcquireCancelSpinLock(&Irp->CancelIrql); + IoSetCancelRoutine(Irp, NULL); + IoReleaseCancelSpinLock(Irp->CancelIrql); + + /* And complete */ + Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE; + Irp->IoStatus.Status = STATUS_SUCCESS; + IoCompleteRequest(Irp, IO_DISK_INCREMENT); + IntOplock->ExclusiveIrp = NULL; + + /* If still referenced, dereference */ + if (IntOplock->FileObject != NULL) + { + ObDereferenceObject(IntOplock->FileObject); + } + } + } + _SEH2_FINALLY + { + ExReleaseFastMutexUnsafe(IntOplock->IntLock); + } + _SEH2_END; + + ExFreePoolWithTag(IntOplock->IntLock, TAG_OPLOCK); + ExFreePoolWithTag(IntOplock, TAG_OPLOCK); }

1 0

← Newer
1
...
4
5
6
7
8
9
10
...
19
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs November 2017