[prev in list] [next in list] [prev in thread] [next in thread]
List: ros-diffs
Subject: [ros-diffs] [gdalsnes] 13782: init. work on a notify-directory impl.
From: <gdalsnes () svn ! reactos ! com>
Date: 2005-02-28 21:01:00
Message-ID: 000001c51dd8$9b41cf50$6601a8c0 () penelope
[Download RAW message or body]
init. work on a notify-directory impl.
Modified: trunk/reactos/ntoskrnl/fs/notify.c
_____
Modified: trunk/reactos/ntoskrnl/fs/notify.c
--- trunk/reactos/ntoskrnl/fs/notify.c 2005-02-28 20:43:23 UTC (rev
13781)
+++ trunk/reactos/ntoskrnl/fs/notify.c 2005-02-28 21:00:59 UTC (rev
13782)
@@ -5,14 +5,126 @@
* FILE: ntoskrnl/fs/notify.c
* PURPOSE: No purpose listed.
*
- * PROGRAMMERS: No programmer listed.
+ * PROGRAMMERS: Gunnar Dalsnes
*/
#include <ntoskrnl.h>
#define NDEBUG
#include <internal/debug.h>
+
+PAGED_LOOKASIDE_LIST NotifyEntryLookaside;
+
+typedef struct _NOTIFY_ENTRY
+{
+ LIST_ENTRY ListEntry;
+ PSTRING FullDirectoryName;
+ BOOLEAN WatchTree;
+ BOOLEAN IgnoreBuffer;
+ ULONG CompletionFilter;
+ LIST_ENTRY IrpQueue;
+ PVOID Fcb;
+ PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback;
+ PSECURITY_SUBJECT_CONTEXT SubjectContext;
+ PVOID FsContext;
+ LIST_ENTRY BufferedChangesList;
+} NOTIFY_ENTRY, *PNOTIFY_ENTRY;
+
+typedef struct _BUFFERED_CHANGE
+{
+ LIST_ENTRY ListEntry;
+ ULONG Action;
+ USHORT NameLen;
+ WCHAR RelativeName[1];
+
+} BUFFERED_CHANGE, *PBUFFERED_CHANGE;
+
+
/**********************************************************************
+ * NAME PRIVATE
+ * FsRtlpInitNotifyImplementation
+ *
+ */
+VOID
+STDCALL INIT_FUNCTION
+FsRtlpInitNotifyImplementation(VOID)
+{
+ ExInitializePagedLookasideList( &NotifyEntryLookaside,
+ NULL,
+ NULL,
+ 0,
+ sizeof(NOTIFY_ENTRY),
+ 0 /* FSRTL_NOTIFY_TAG*/,
+ 0
+ );
+
+
+}
+
+
+
+
+
+/**********************************************************************
+ * NAME PRIVATE
+ * FsRtlpNotifyCancelRoutine
+ *
+ */
+static
+VOID
+STDCALL
+FsRtlpNotifyCancelRoutine(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ )
+{
+ PFAST_MUTEX Lock;
+
+ //don't need this since we have our own sync. protecting irp
cancellation
+ IoReleaseCancelSpinLock(Irp->CancelIrql);
+
+ Lock = (PFAST_MUTEX)Irp->Tail.Overlay.DriverContext[3];
+
+ ExAcquireFastMutex(Lock );
+
+ RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
+
+ ExReleaseFastMutex(Lock);
+
+ Irp->IoStatus.Status = STATUS_CANCELLED;
+ Irp->IoStatus.Information = 0;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+}
+
+
+
+static
+PNOTIFY_ENTRY
+FASTCALL
+FsRtlpFindNotifyEntry(
+ PLIST_ENTRY NotifyList,
+ PVOID FsContext
+ )
+{
+ PLIST_ENTRY EnumEntry;
+ PNOTIFY_ENTRY NotifyEntry;
+
+ LIST_FOR_EACH(EnumEntry, NotifyList)
+ {
+ NotifyEntry = CONTAINING_RECORD(EnumEntry, NOTIFY_ENTRY,
ListEntry);
+
+ if (NotifyEntry->FsContext == FsContext)
+ {
+ return NotifyEntry;
+ }
+ }
+
+ return NULL;
+}
+
+/**********************************************************************
* NAME EXPORTED
* FsRtlNotifyChangeDirectory@28
*
@@ -57,7 +169,8 @@
* FsRtlNotifyCleanup@12
*
* DESCRIPTION
- *
+ * Called by FSD when all handles to FileObject (identified by
FsContext) are closed
+ *
* ARGUMENTS
*
* RETURN VALUE
@@ -72,6 +185,64 @@
IN PVOID FsContext
)
{
+ PNOTIFY_ENTRY NotifyEntry;
+ LIST_ENTRY CompletedListHead;
+ PLIST_ENTRY TmpEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PIRP Irp;
+
+ InitializeListHead(&CompletedListHead);
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyEntry = FsRtlpFindNotifyEntry(NotifyList, FsContext);
+
+ if (NotifyEntry)
+ {
+ /* free buffered changes */
+ while (!IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ TmpEntry = RemoveHeadList(&NotifyEntry->BufferedChangesList);
+ BufferedChange = CONTAINING_RECORD(TmpEntry , BUFFERED_CHANGE,
ListEntry);
+ ExFreePool(BufferedChange);
+ }
+
+ /* cancel(?) pending irps */
+ while (!IsListEmpty(&NotifyEntry->IrpQueue))
+ {
+ TmpEntry = RemoveHeadList(&NotifyEntry->IrpQueue);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP,
Tail.Overlay.ListEntry);
+
+ /* irp cancelation bolilerplate */
+ if (!IoSetCancelRoutine(Irp, NULL))
+ {
+ //The cancel routine will be called. When we release the
lock it will complete the irp.
+ InitializeListHead(&Irp->Tail.Overlay.ListEntry);
+ continue;
+ }
+
+ Irp->IoStatus.Status = STATUS_NOTIFY_CLEANUP; /* FIXME:
correct status? */
+ Irp->IoStatus.Information = 0;
+
+ /* avoid holding lock while completing irp */
+ InsertTailList(&CompletedListHead,
&Irp->Tail.Overlay.ListEntry);
+ }
+
+ /* Unlink and free the NotifyStruct */
+ RemoveEntryList(&NotifyEntry->ListEntry);
+ ExFreeToPagedLookasideList(&NotifyEntryLookaside, NotifyEntry);
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ /* complete defered irps */
+ while (!IsListEmpty(&CompletedListHead))
+ {
+ TmpEntry = RemoveHeadList(&CompletedListHead);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP, Tail.Overlay.ListEntry);
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
+
}
@@ -119,6 +290,75 @@
}
+
+static
+VOID
+FASTCALL
+FsRtlpWatchedDirectoryWasDeleted(
+ IN PNOTIFY_SYNC NotifySync,
+ IN PLIST_ENTRY NotifyList,
+ IN PVOID Fcb
+ )
+{
+ LIST_ENTRY CompletedListHead;
+ PLIST_ENTRY EnumEntry, TmpEntry;
+ PNOTIFY_ENTRY NotifyEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PIRP Irp;
+
+ InitializeListHead(&CompletedListHead);
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ LIST_FOR_EACH_SAFE(EnumEntry, NotifyList, NotifyEntry, NOTIFY_ENTRY,
ListEntry )
+ {
+ if (NotifyEntry->Fcb == Fcb)
+ {
+ RemoveEntryList(&NotifyEntry->ListEntry);
+
+ /* free buffered changes */
+ while (!IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ TmpEntry =
RemoveHeadList(&NotifyEntry->BufferedChangesList);
+ BufferedChange = CONTAINING_RECORD(TmpEntry ,
BUFFERED_CHANGE, ListEntry);
+ ExFreePool(BufferedChange);
+ }
+
+ /* cancel(?) pending irps */
+ while (!IsListEmpty(&NotifyEntry->IrpQueue))
+ {
+ TmpEntry = RemoveHeadList(&NotifyEntry->IrpQueue);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP,
Tail.Overlay.ListEntry);
+
+ /* irp cancelation bolilerplate */
+ if (!IoSetCancelRoutine(Irp, NULL))
+ {
+ //The cancel routine will be called. When we release the
lock it will complete the irp.
+ InitializeListHead(&Irp->Tail.Overlay.ListEntry);
+ continue;
+ }
+
+ Irp->IoStatus.Status = STATUS_NOTIFY_CLEANUP; /* FIXME:
correct status? */
+ Irp->IoStatus.Information = 0;
+
+ /* avoid holding lock while completing irp */
+ InsertTailList(&CompletedListHead,
&Irp->Tail.Overlay.ListEntry);
+ }
+ }
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ /* complete defered irps */
+ while (!IsListEmpty(&CompletedListHead))
+ {
+ TmpEntry = RemoveHeadList(&CompletedListHead);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP, Tail.Overlay.ListEntry);
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
+
+}
+
/**********************************************************************
* NAME EXPORTED
* FsRtlNotifyFullChangeDirectory@40
@@ -137,23 +377,185 @@
IN PNOTIFY_SYNC NotifySync,
IN PLIST_ENTRY NotifyList,
IN PVOID FsContext,
- IN PSTRING FullDirectoryName,
- IN BOOLEAN WatchTree,
- IN BOOLEAN IgnoreBuffer,
- IN ULONG CompletionFilter,
- IN PIRP NotifyIrp,
- IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback
OPTIONAL,
+ IN PSTRING FullDirectoryName,
+ IN BOOLEAN WatchTree,
+ IN BOOLEAN IgnoreBuffer,
+ IN ULONG CompletionFilter,
+ IN PIRP NotifyIrp,
+ IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL,
IN PSECURITY_SUBJECT_CONTEXT SubjectContext
OPTIONAL
)
{
-#if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1300)
- DbgPrint("%s()\n", __FUNCTION__);
-#else
- DbgPrint("FsRtlNotifyFullChangeDirectory()\n");
-#endif
+ PIO_STACK_LOCATION IrpStack;
+ PNOTIFY_ENTRY NotifyEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PLIST_ENTRY TmpEntry;
+
+ if (!NotifyIrp)
+ {
+ /* all other params are ignored if NotifyIrp == NULL */
+ FsRtlpWatchedDirectoryWasDeleted(NotifySync, NotifyList,
FsContext);
+ return;
+ }
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ IrpStack = IoGetCurrentIrpStackLocation(NotifyIrp);
+ if (IrpStack->FileObject->Flags & FO_CLEANUP_COMPLETE)
+ {
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyIrp->IoStatus.Information = 0;
+ NotifyIrp->IoStatus.Status = STATUS_NOTIFY_CLEANUP;
+ IoCompleteRequest(NotifyIrp, IO_NO_INCREMENT);
+ return;
+ }
+
+ NotifyEntry = FsRtlpFindNotifyEntry(NotifyList, FsContext);
+
+ if (!NotifyEntry)
+ {
+ /* No NotifyStruct for this FileObject existed */
+
+ NotifyEntry =
ExAllocateFromPagedLookasideList(&NotifyEntryLookaside);
+
+ NotifyEntry->FsContext = FsContext;
+ NotifyEntry->FullDirectoryName = FullDirectoryName;
+ NotifyEntry->WatchTree = WatchTree;
+ NotifyEntry->IgnoreBuffer = IgnoreBuffer;
+ NotifyEntry->CompletionFilter = CompletionFilter;
+ NotifyEntry->TraverseCallback = TraverseCallback;
+ NotifyEntry->SubjectContext = SubjectContext;
+ NotifyEntry->Fcb = IrpStack->FileObject->FsContext;
+ InitializeListHead(&NotifyEntry->IrpQueue);
+ InitializeListHead(&NotifyEntry->BufferedChangesList);
+
+ InsertTailList(NotifyList, &NotifyEntry->ListEntry);
+ }
+
+ /*
+ * FIXME: this NotifyStruct allready have values for WatchTree,
CompletionFilter etc.
+ * What if the WatchTree, CompletionFilter etc. params are different
from
+ * those in the NotifyStruct? Should the params be ignored or should
the params overwrite
+ * the "old" values in the NotifyStruct??
+ * STATUS: Currently we ignore these params for subsequesnt request.
+ *
+ * -Gunnar
+ */
+
+ if (IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ /* No changes are pending. Queue the irp */
+
+ /* Irp cancelation boilerplate */
+ IoSetCancelRoutine(NotifyIrp, FsRtlpNotifyCancelRoutine);
+ if (NotifyIrp->Cancel && IoSetCancelRoutine(NotifyIrp, NULL))
+ {
+ //irp was canceled
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyIrp->IoStatus.Status = STATUS_CANCELLED;
+ NotifyIrp->IoStatus.Information = 0;
+
+ IoCompleteRequest(NotifyIrp, IO_NO_INCREMENT);
+ return;
+ }
+
+ IoMarkIrpPending(NotifyIrp);
+
+ //FIXME: any point in setting irp status/information before
queueing?
+
+ /* save NotifySych for use in the cancel routine */
+ NotifyIrp->Tail.Overlay.DriverContext[3] = NotifySync;
+ InsertTailList(&NotifyEntry->IrpQueue,
&NotifyIrp->Tail.Overlay.ListEntry);
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+ return;
+ }
+
+
+
+
+ /*
+ typedef struct _FILE_NOTIFY_INFORMATION {
+ ULONG NextEntryOffset;
+ ULONG Action;
+ ULONG NameLength;
+ WCHAR Name[1];
+ } FILE_NOTIFY_INFORMATION, *PFILE_NOTIFY_INFORMATION;
+ */
+
+ /* Buffered changes exist */
+
+
+ /* Copy as much buffered data as available/the buffer can hold */
+ while (!IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ TmpEntry = RemoveHeadList(&NotifyEntry->BufferedChangesList);
+ BufferedChange = CONTAINING_RECORD(TmpEntry, BUFFERED_CHANGE,
ListEntry);
+
+ /* FIXME:
+ Fill user-buffer with recorded events until full. If user buffer
is too small to hold even
+ a single record or can only hold some of the events, what should
we do????????????
+ */
+
+ /* FIXME: implement this (copy data to user) */
+
+// BufferedChange->Action = Action;
+// RecordedChange->Name
+// RecordedChange->NameLength
+
+ ExFreePool(BufferedChange);
+
+
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyIrp->IoStatus.Information = 0; //<- FIXME
+ NotifyIrp->IoStatus.Status = STATUS_SUCCESS;
+ IoCompleteRequest(NotifyIrp, IO_NO_INCREMENT);
}
+
+static
+PIRP
+FASTCALL
+FsRtlpGetNextIrp(PNOTIFY_ENTRY NotifyEntry)
+{
+ PIRP Irp;
+ PLIST_ENTRY TmpEntry;
+
+ /* Loop to get a non-canceled irp */
+ while (!IsListEmpty(&NotifyEntry->IrpQueue))
+ {
+ /* If we have queued irp(s) we can't possibly have buffered
changes too */
+ ASSERT(IsListEmpty(&NotifyEntry->BufferedChangesList));
+
+ TmpEntry = RemoveHeadList(&NotifyEntry->IrpQueue);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP, Tail.Overlay.ListEntry);
+
+ /* irp cancelation bolilerplate */
+ if (!IoSetCancelRoutine(Irp, NULL))
+ {
+ //The cancel routine will be called. When we release the lock
it will complete the irp.
+ InitializeListHead(&Irp->Tail.Overlay.ListEntry);
+ continue;
+ }
+
+ /* Finally we got a non-canceled irp */
+ return Irp;
+ }
+
+ return NULL;
+}
+
+
+
+
+
+
/**********************************************************************
* NAME EXPORTED
* FsRtlNotifyFullReportChange@36
@@ -172,7 +574,7 @@
IN PNOTIFY_SYNC NotifySync,
IN PLIST_ENTRY NotifyList,
IN PSTRING FullTargetName,
- IN USHORT TargetNameOffset,
+ IN USHORT TargetNameOffset, /* in bytes */
IN PSTRING StreamName OPTIONAL,
IN PSTRING NormalizedParentName OPTIONAL,
IN ULONG FilterMatch,
@@ -180,6 +582,80 @@
IN PVOID TargetContext
)
{
+ UNICODE_STRING FullDirName;
+ UNICODE_STRING TargetName;
+ PLIST_ENTRY EnumEntry;
+ PNOTIFY_ENTRY NotifyEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PIRP Irp;
+ LIST_ENTRY CompletedListHead;
+
+ InitializeListHead(&CompletedListHead);
+
+ FullDirName.Buffer = (WCHAR*)FullTargetName->Buffer;
+ FullDirName.MaximumLength = FullDirName.Length = TargetNameOffset -
sizeof(WCHAR);
+
+ TargetName.Buffer = (WCHAR*)(FullTargetName->Buffer +
TargetNameOffset);
+ TargetName.MaximumLength = TargetName.Length =
FullTargetName->Length - TargetNameOffset;
+
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ LIST_FOR_EACH_SAFE(EnumEntry, NotifyList, NotifyEntry, NOTIFY_ENTRY,
ListEntry )
+ {
+ /* rule out some easy cases */
+ /* FIXME: short vs. long names??? */
+ if (FilterMatch != NotifyEntry->CompletionFilter) continue;
+
+ if (FullDirName.Length < NotifyEntry->FullDirectoryName->Length)
continue;
+
+ if (!NotifyEntry->WatchTree && FullDirName.Length !=
NotifyEntry->FullDirectoryName->Length) continue;
+
+ if (wcsncmp((WCHAR*)NotifyEntry->FullDirectoryName->Buffer,
+ FullDirName.Buffer,
+ NotifyEntry->FullDirectoryName->Length/sizeof(WCHAR)) != 0)
continue;
+
+ /* Found a valid change */
+
+ if ((Irp = FsRtlpGetNextIrp(NotifyEntry)))
+ {
+ //FIXME: copy data to user
+
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+
+ /* avoid holding lock while completing irp */
+ InsertTailList(&CompletedListHead,
&Irp->Tail.Overlay.ListEntry);
+ }
+ else
+ {
+ /* No irp in queue. Buffer changes */
+ /* FIXME: how much stuff should we buffer?
+ -Should we alloc with quotas?
+ -Should we use a hardcoded limit?
+ -Should we use a time-out? (drop changes if they are not
retrieved in x seconds?
+ */
+ BufferedChange = ExAllocatePool(PagedPool,
FIELD_OFFSET(BUFFERED_CHANGE, RelativeName) + TargetName.Length);
+
+ BufferedChange->Action = Action;
+ BufferedChange->NameLen = TargetName.Length;
+ memcpy(BufferedChange->RelativeName, TargetName.Buffer,
TargetName.Length);
+
+ InsertTailList(&NotifyEntry->BufferedChangesList,
&BufferedChange->ListEntry);
+ }
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ /* complete defered irps */
+ while (!IsListEmpty(&CompletedListHead))
+ {
+ EnumEntry = RemoveHeadList(&CompletedListHead);
+ Irp = CONTAINING_RECORD(EnumEntry, IRP, Tail.Overlay.ListEntry);
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
+
}
@@ -198,25 +674,11 @@
VOID
STDCALL
FsRtlNotifyInitializeSync (
- IN PNOTIFY_SYNC NotifySync
+ IN PNOTIFY_SYNC *NotifySync
)
{
-#if 0
- *NotifySync = NULL;
- *NotifySync = ExAllocatePoolWithTag (
- 0x10, // PoolType???
- sizeof (NOTIFY_SYNC), // NumberOfBytes = 0x28
- FSRTL_TAG
- );
-
- *NotifySync->Unknown0 = 1;
- *NotifySync->Unknown2 = 0;
- *NotifySync->Unknown3 = 1;
- *NotifySync->Unknown4 = 4;
- *NotifySync->Unknown5 = 0;
- *NotifySync->Unknown9 = 0;
- *NotifySync->Unknown10 = 0;
-#endif
+ *NotifySync = ExAllocatePoolWithTag(NonPagedPool,
sizeof(FAST_MUTEX), 0/*FSRTL_NOTIFY_TAG*/ );
+ ExInitializeFastMutex((PFAST_MUTEX)*NotifySync);
}
@@ -246,11 +708,11 @@
NotifySync,
NotifyList,
FullTargetName,
- (FullTargetName->Length - *FileNamePartLength), /*?*/
+ (FullTargetName->Length - *FileNamePartLength),
NULL,
NULL,
FilterMatch,
- 0, /* Action ? */
+ 0,
NULL
);
}
@@ -276,16 +738,10 @@
VOID
STDCALL
FsRtlNotifyUninitializeSync (
- IN OUT PNOTIFY_SYNC NotifySync
+ IN PNOTIFY_SYNC NotifySync
)
{
-#if 0
- if (NULL != *NotifySync)
- {
- ExFreePool (*NotifySync);
- *NotifySync = NULL;
- }
-#endif
+ ExFreePool (NotifySync);
}
/**********************************************************************
[Attachment #3 (text/html)]
<html>
<head>
<style>
<!--
body { background-color:#ffffff }
.file { border:1px solid #eeeeee; margin-top:1em; margin-bottom:1em }
.pathname { font-family:monospace; float:right }
.fileheader { margin-bottom:.5em }
.diff { margin:0 }
.tasklist { padding:4px; border:1px dashed #000000; margin-top:1em }
.tasklist ul { margin-top:0; margin-bottom:0 }
tr.alt { background-color:#eeeeee }
#added { background-color:#ddffdd }
#addedchars { background-color:#99ff99; font-weight:bolder }
tr.alt #added { background-color:#ccf7cc }
#removed { background-color:#ffdddd }
#removedchars { background-color:#ff9999; font-weight:bolder }
tr.alt #removed { background-color:#f7cccc }
#info { color:#888888 }
#context { background-color:#eeeeee }
td {padding-left:.3em; padding-right:.3em }
tr.head { border-bottom-width:1px; border-bottom-style:solid }
tr.head td { padding:0; padding-top:.2em }
.task { background-color:#ffff00 }
.comment { padding:4px; border:1px dashed #000000; background-color:#ffffdd }
.error { color:red }
hr { border-width:0px; height:2px; background:black }
-->
</style>
</head>
<body>
<pre class="comment">init. work on a notify-directory impl.</pre><pre class="diff" \
id="context">Modified: trunk/reactos/ntoskrnl/fs/notify.c </pre><hr /><div \
class="file"> <div class="fileheader"><big><b>Modified: \
trunk/reactos/ntoskrnl/fs/notify.c</b></big></div> <pre class="diff"><small \
id="info">--- trunk/reactos/ntoskrnl/fs/notify.c 2005-02-28 20:43:23 \
UTC (rev 13781)
+++ trunk/reactos/ntoskrnl/fs/notify.c 2005-02-28 21:00:59 UTC (rev 13782)
@@ -5,14 +5,126 @@
</small></pre><pre class="diff" id="context"> * FILE: \
ntoskrnl/fs/notify.c * PURPOSE: \
No purpose listed. *
</pre><pre class="diff" id="removed">- * PROGRAMMERS: <span \
id="removedchars">No programmer listed.</span> </pre><pre class="diff" id="added">+ * \
PROGRAMMERS: <span id="addedchars">Gunnar Dalsnes</span> </pre><pre \
class="diff" id="context"> */
#include <ntoskrnl.h>
#define NDEBUG
#include <internal/debug.h>
</pre><pre class="diff" id="added">+
+PAGED_LOOKASIDE_LIST NotifyEntryLookaside;
+
+typedef struct _NOTIFY_ENTRY
+{
+ LIST_ENTRY ListEntry;
+ PSTRING FullDirectoryName;
+ BOOLEAN WatchTree;
+ BOOLEAN IgnoreBuffer;
+ ULONG CompletionFilter;
+ LIST_ENTRY IrpQueue;
+ PVOID Fcb;
+ PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback;
+ PSECURITY_SUBJECT_CONTEXT SubjectContext;
+ PVOID FsContext;
+ LIST_ENTRY BufferedChangesList;
+} NOTIFY_ENTRY, *PNOTIFY_ENTRY;
+
+typedef struct _BUFFERED_CHANGE
+{
+ LIST_ENTRY ListEntry;
+ ULONG Action;
+ USHORT NameLen;
+ WCHAR RelativeName[1];
+
+} BUFFERED_CHANGE, *PBUFFERED_CHANGE;
+
+
</pre><pre class="diff" id="context"> \
/********************************************************************** </pre><pre \
class="diff" id="added">+ * NAME \
PRIVATE + * FsRtlpInitNotifyImplementation
+ *
+ */
+VOID
+STDCALL INIT_FUNCTION
+FsRtlpInitNotifyImplementation(VOID)
+{
+ ExInitializePagedLookasideList( &NotifyEntryLookaside,
+ \
NULL, + \
\
NULL, + \
0, + \
\
sizeof(NOTIFY_ENTRY), + \
0 \
/* FSRTL_NOTIFY_TAG*/, + \
0 + \
\
); +
+
+}
+
+
+
+
+
+/**********************************************************************
+ * NAME PRIVATE
+ * FsRtlpNotifyCancelRoutine
+ *
+ */
+static
+VOID
+STDCALL
+FsRtlpNotifyCancelRoutine(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ )
+{
+ PFAST_MUTEX Lock;
+
+ //don't need this since we have our own sync. protecting irp cancellation
+ IoReleaseCancelSpinLock(Irp->CancelIrql);
+
+ Lock = (PFAST_MUTEX)Irp->Tail.Overlay.DriverContext[3];
+
+ ExAcquireFastMutex(Lock );
+
+ RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
+
+ ExReleaseFastMutex(Lock);
+
+ Irp->IoStatus.Status = STATUS_CANCELLED;
+ Irp->IoStatus.Information = 0;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+}
+
+
+
+static
+PNOTIFY_ENTRY
+FASTCALL
+FsRtlpFindNotifyEntry(
+ PLIST_ENTRY NotifyList,
+ PVOID FsContext
+ )
+{
+ PLIST_ENTRY EnumEntry;
+ PNOTIFY_ENTRY NotifyEntry;
+
+ LIST_FOR_EACH(EnumEntry, NotifyList)
+ {
+ NotifyEntry = CONTAINING_RECORD(EnumEntry, NOTIFY_ENTRY, \
ListEntry); +
+ if (NotifyEntry->FsContext == FsContext)
+ {
+ return NotifyEntry;
+ }
+ }
+
+ return NULL;
+}
+
+/**********************************************************************
</pre><pre class="diff" id="context"> * NAME EXPORTED
* FsRtlNotifyChangeDirectory@28
*
@@ -57,7 +169,8 @@
</pre><pre class="diff" id="context"> * FsRtlNotifyCleanup@12
*
* DESCRIPTION
</pre><pre class="diff" id="removed">- *
</pre><pre class="diff" id="added">+ * <span id="addedchars"> Called by FSD when all \
handles to FileObject (identified by FsContext) are closed</span> + *
</pre><pre class="diff" id="context"> * ARGUMENTS
*
* RETURN VALUE
@@ -72,6 +185,64 @@
</pre><pre class="diff" id="context"> IN PVOID FsContext
)
{
</pre><pre class="diff" id="added">+ PNOTIFY_ENTRY NotifyEntry;
+ LIST_ENTRY CompletedListHead;
+ PLIST_ENTRY TmpEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PIRP Irp;
+
+ InitializeListHead(&CompletedListHead);
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyEntry = FsRtlpFindNotifyEntry(NotifyList, FsContext);
+
+ if (NotifyEntry)
+ {
+ /* free buffered changes */
+ while (!IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ TmpEntry = \
RemoveHeadList(&NotifyEntry->BufferedChangesList); + \
BufferedChange = CONTAINING_RECORD(TmpEntry , BUFFERED_CHANGE, ListEntry); + \
ExFreePool(BufferedChange); + }
+
+ /* cancel(?) pending irps */
+ while (!IsListEmpty(&NotifyEntry->IrpQueue))
+ {
+ TmpEntry = \
RemoveHeadList(&NotifyEntry->IrpQueue); + Irp = \
CONTAINING_RECORD(TmpEntry , IRP, Tail.Overlay.ListEntry); +
+ /* irp cancelation bolilerplate */
+ if (!IoSetCancelRoutine(Irp, NULL))
+ {
+ //The cancel routine will be called. When \
we release the lock it will complete the irp. + \
InitializeListHead(&Irp->Tail.Overlay.ListEntry); + \
continue; + }
+
+ Irp->IoStatus.Status = STATUS_NOTIFY_CLEANUP; /* \
FIXME: correct status? */ + Irp->IoStatus.Information \
= 0; +
+ /* avoid holding lock while completing irp */
+ InsertTailList(&CompletedListHead, \
&Irp->Tail.Overlay.ListEntry); + }
+
+ /* Unlink and free the NotifyStruct */
+ RemoveEntryList(&NotifyEntry->ListEntry);
+ ExFreeToPagedLookasideList(&NotifyEntryLookaside, \
NotifyEntry); + }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ /* complete defered irps */
+ while (!IsListEmpty(&CompletedListHead))
+ {
+ TmpEntry = RemoveHeadList(&CompletedListHead);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP, \
Tail.Overlay.ListEntry); + IoCompleteRequest(Irp, \
IO_NO_INCREMENT); + }
+
</pre><pre class="diff" id="context"> }
@@ -119,6 +290,75 @@
</pre><pre class="diff" id="context"> }
</pre><pre class="diff" id="added">+
+static
+VOID
+FASTCALL
+FsRtlpWatchedDirectoryWasDeleted(
+ IN PNOTIFY_SYNC NotifySync,
+ IN PLIST_ENTRY NotifyList,
+ IN PVOID Fcb
+ )
+{
+ LIST_ENTRY CompletedListHead;
+ PLIST_ENTRY EnumEntry, TmpEntry;
+ PNOTIFY_ENTRY NotifyEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PIRP Irp;
+
+ InitializeListHead(&CompletedListHead);
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ LIST_FOR_EACH_SAFE(EnumEntry, NotifyList, NotifyEntry, NOTIFY_ENTRY, \
ListEntry ) + {
+ if (NotifyEntry->Fcb == Fcb)
+ {
+ RemoveEntryList(&NotifyEntry->ListEntry); \
+
+ /* free buffered changes */
+ while \
(!IsListEmpty(&NotifyEntry->BufferedChangesList)) + \
{ + TmpEntry = \
RemoveHeadList(&NotifyEntry->BufferedChangesList); + \
BufferedChange = CONTAINING_RECORD(TmpEntry , BUFFERED_CHANGE, \
ListEntry); + ExFreePool(BufferedChange);
+ }
+
+ /* cancel(?) pending irps */
+ while (!IsListEmpty(&NotifyEntry->IrpQueue))
+ {
+ TmpEntry = \
RemoveHeadList(&NotifyEntry->IrpQueue); + \
Irp = CONTAINING_RECORD(TmpEntry , IRP, Tail.Overlay.ListEntry); +
+ /* irp cancelation bolilerplate */
+ if (!IoSetCancelRoutine(Irp, NULL))
+ {
+ //The cancel routine will be \
called. When we release the lock it will complete the irp. + \
InitializeListHead(&Irp->Tail.Overlay.ListEntry); \
+ continue; + \
} +
+ Irp->IoStatus.Status = \
STATUS_NOTIFY_CLEANUP; /* FIXME: correct status? */ + \
Irp->IoStatus.Information = 0; +
+ /* avoid holding lock while completing irp \
*/ + InsertTailList(&CompletedListHead, \
&Irp->Tail.Overlay.ListEntry); + }
+ }
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ /* complete defered irps */
+ while (!IsListEmpty(&CompletedListHead))
+ {
+ TmpEntry = RemoveHeadList(&CompletedListHead);
+ Irp = CONTAINING_RECORD(TmpEntry , IRP, \
Tail.Overlay.ListEntry); + IoCompleteRequest(Irp, \
IO_NO_INCREMENT); + }
+
+}
+
</pre><pre class="diff" id="context"> \
/********************************************************************** * \
NAME EXPORTED * FsRtlNotifyFullChangeDirectory@40
@@ -137,23 +377,185 @@
</pre><pre class="diff" id="context"> IN PNOTIFY_SYNC NotifySync,
IN PLIST_ENTRY NotifyList,
IN PVOID FsContext,
</pre><pre class="diff" id="removed">- IN PSTRING FullDirectoryName,
- IN BOOLEAN WatchTree,
- IN BOOLEAN IgnoreBuffer,
- IN ULONG CompletionFilter,
- IN PIRP NotifyIrp,
-<span id="removedchars"> IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL</span>,
</pre><pre class="diff" id="added">+<span id="addedchars"> IN PSTRING \
FullDirectoryName</span>, + IN BOOLEAN \
WatchTree, + IN BOOLEAN \
IgnoreBuffer, + IN ULONG \
CompletionFilter, + IN PIRP \
NotifyIrp, + IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL,
</pre><pre class="diff" id="context"> \
IN PSECURITY_SUBJECT_CONTEXT SubjectContext OPTIONAL )
{
</pre><pre class="diff" id="removed">-#if defined(__GNUC__) || (defined(_MSC_VER) \
&& _MSC_VER >= 1300)
- DbgPrint("%s()\n", __FUNCTION__);
-#else
- DbgPrint("FsRtlNotifyFullChangeDirectory()\n");
-#endif
</pre><pre class="diff" id="added">+ PIO_STACK_LOCATION IrpStack;
+ PNOTIFY_ENTRY NotifyEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PLIST_ENTRY TmpEntry;
+
+ if (!NotifyIrp)
+ {
+ /* all other params are ignored if NotifyIrp == NULL */
+ FsRtlpWatchedDirectoryWasDeleted(NotifySync, NotifyList, \
FsContext); + return;
+ }
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ IrpStack = IoGetCurrentIrpStackLocation(NotifyIrp);
+ if (IrpStack->FileObject->Flags & FO_CLEANUP_COMPLETE)
+ {
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyIrp->IoStatus.Information = 0;
+ NotifyIrp->IoStatus.Status = STATUS_NOTIFY_CLEANUP;
+ IoCompleteRequest(NotifyIrp, IO_NO_INCREMENT);
+ return;
+ }
+
+ NotifyEntry = FsRtlpFindNotifyEntry(NotifyList, FsContext);
+
+ if (!NotifyEntry)
+ {
+ /* No NotifyStruct for this FileObject existed */
+
+ NotifyEntry = \
ExAllocateFromPagedLookasideList(&NotifyEntryLookaside); +
+ NotifyEntry->FsContext = FsContext;
+ NotifyEntry->FullDirectoryName = FullDirectoryName;
+ NotifyEntry->WatchTree = WatchTree;
+ NotifyEntry->IgnoreBuffer = IgnoreBuffer;
+ NotifyEntry->CompletionFilter = CompletionFilter;
+ NotifyEntry->TraverseCallback = TraverseCallback;
+ NotifyEntry->SubjectContext = SubjectContext;
+ NotifyEntry->Fcb = IrpStack->FileObject->FsContext;
+ InitializeListHead(&NotifyEntry->IrpQueue);
+ InitializeListHead(&NotifyEntry->BufferedChangesList);
+
+ InsertTailList(NotifyList, &NotifyEntry->ListEntry);
+ }
+
+ /*
+ * FIXME: this NotifyStruct allready have values for WatchTree, \
CompletionFilter etc. + * What if the WatchTree, CompletionFilter etc. \
params are different from + * those in the NotifyStruct? Should the \
params be ignored or should the params overwrite + * the "old" \
values in the NotifyStruct?? + * STATUS: Currently we ignore these \
params for subsequesnt request. + *
+ * -Gunnar
+ */
+
+ if (IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ /* No changes are pending. Queue the irp */
+
+ /* Irp cancelation boilerplate */
+ IoSetCancelRoutine(NotifyIrp, FsRtlpNotifyCancelRoutine);
+ if (NotifyIrp->Cancel && \
IoSetCancelRoutine(NotifyIrp, NULL)) + { \
+ //irp was canceled
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyIrp->IoStatus.Status = STATUS_CANCELLED;
+ NotifyIrp->IoStatus.Information = 0;
+
+ IoCompleteRequest(NotifyIrp, IO_NO_INCREMENT);
+ return;
+ }
+
+ IoMarkIrpPending(NotifyIrp);
+
+ //FIXME: any point in setting irp status/information before \
queueing? +
+ /* save NotifySych for use in the cancel routine */
+ NotifyIrp->Tail.Overlay.DriverContext[3] = NotifySync;
+ InsertTailList(&NotifyEntry->IrpQueue, \
&NotifyIrp->Tail.Overlay.ListEntry); +
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+ return;
+ }
+
+
+
+
+ /*
+ typedef struct _FILE_NOTIFY_INFORMATION {
+ ULONG NextEntryOffset;
+ ULONG Action;
+ ULONG NameLength;
+ WCHAR Name[1];
+ } FILE_NOTIFY_INFORMATION, *PFILE_NOTIFY_INFORMATION;
+ */
+
+ /* Buffered changes exist */
+
+
+ /* Copy as much buffered data as available/the buffer can hold */
+ while (!IsListEmpty(&NotifyEntry->BufferedChangesList))
+ {
+ TmpEntry = \
RemoveHeadList(&NotifyEntry->BufferedChangesList); + \
BufferedChange = CONTAINING_RECORD(TmpEntry, BUFFERED_CHANGE, ListEntry); +
+ /* FIXME:
+ Fill user-buffer with recorded events until full. If user \
buffer is too small to hold even + a single record or can only \
hold some of the events, what should we do???????????? + */
+
+ /* FIXME: implement this (copy data to user) */
+
+// BufferedChange->Action = Action;
+// RecordedChange->Name
+// RecordedChange->NameLength
+
+ ExFreePool(BufferedChange);
+
+
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ NotifyIrp->IoStatus.Information = 0; //<- FIXME
+ NotifyIrp->IoStatus.Status = STATUS_SUCCESS;
+ IoCompleteRequest(NotifyIrp, IO_NO_INCREMENT);
</pre><pre class="diff" id="context"> }
</pre><pre class="diff" id="added">+
+static
+PIRP
+FASTCALL
+FsRtlpGetNextIrp(PNOTIFY_ENTRY NotifyEntry)
+{
+ PIRP Irp;
+ PLIST_ENTRY TmpEntry;
+
+ /* Loop to get a non-canceled irp */
+ while (!IsListEmpty(&NotifyEntry->IrpQueue))
+ {
+ /* If we have queued irp(s) we can't possibly have buffered \
changes too */ + \
ASSERT(IsListEmpty(&NotifyEntry->BufferedChangesList)); + \
+ TmpEntry = \
RemoveHeadList(&NotifyEntry->IrpQueue); + Irp = \
CONTAINING_RECORD(TmpEntry , IRP, Tail.Overlay.ListEntry); +
+ /* irp cancelation bolilerplate */
+ if (!IoSetCancelRoutine(Irp, NULL))
+ {
+ //The cancel routine will be called. When we release \
the lock it will complete the irp. + \
InitializeListHead(&Irp->Tail.Overlay.ListEntry); + \
continue; + }
+
+ /* Finally we got a non-canceled irp */
+ return Irp;
+ }
+
+ return NULL;
+}
+
+
+
+
+
+
</pre><pre class="diff" id="context"> \
/********************************************************************** * \
NAME EXPORTED * FsRtlNotifyFullReportChange@36
@@ -172,7 +574,7 @@
</pre><pre class="diff" id="context"> IN PNOTIFY_SYNC NotifySync,
IN PLIST_ENTRY NotifyList,
IN PSTRING FullTargetName,
</pre><pre class="diff" id="removed">- IN USHORT TargetNameOffset,
</pre><pre class="diff" id="added">+ IN USHORT TargetNameOffset,<span \
id="addedchars"> /* in bytes */</span> </pre><pre class="diff" id="context"> \
IN PSTRING StreamName OPTIONAL, IN PSTRING NormalizedParentName OPTIONAL,
IN ULONG FilterMatch,
@@ -180,6 +582,80 @@
</pre><pre class="diff" id="context"> IN PVOID TargetContext
)
{
</pre><pre class="diff" id="added">+ UNICODE_STRING FullDirName;
+ UNICODE_STRING TargetName;
+ PLIST_ENTRY EnumEntry;
+ PNOTIFY_ENTRY NotifyEntry;
+ PBUFFERED_CHANGE BufferedChange;
+ PIRP Irp;
+ LIST_ENTRY CompletedListHead;
+
+ InitializeListHead(&CompletedListHead);
+
+ FullDirName.Buffer = (WCHAR*)FullTargetName->Buffer;
+ FullDirName.MaximumLength = FullDirName.Length = TargetNameOffset - \
sizeof(WCHAR); +
+ TargetName.Buffer = (WCHAR*)(FullTargetName->Buffer + TargetNameOffset);
+ TargetName.MaximumLength = TargetName.Length = FullTargetName->Length - \
TargetNameOffset; +
+
+ ExAcquireFastMutex((PFAST_MUTEX)NotifySync);
+
+ LIST_FOR_EACH_SAFE(EnumEntry, NotifyList, NotifyEntry, NOTIFY_ENTRY, \
ListEntry ) + {
+ /* rule out some easy cases */
+ /* FIXME: short vs. long names??? */
+ if (FilterMatch != NotifyEntry->CompletionFilter) continue;
+
+ if (FullDirName.Length < \
NotifyEntry->FullDirectoryName->Length) continue; +
+ if (!NotifyEntry->WatchTree && FullDirName.Length != \
NotifyEntry->FullDirectoryName->Length) continue; +
+ if \
(wcsncmp((WCHAR*)NotifyEntry->FullDirectoryName->Buffer, + \
FullDirName.Buffer, + \
NotifyEntry->FullDirectoryName->Length/sizeof(WCHAR)) != 0) continue; + \
+ /* Found a valid change */
+
+ if ((Irp = FsRtlpGetNextIrp(NotifyEntry)))
+ {
+ //FIXME: copy data to user
+
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+
+ /* avoid holding lock while completing irp */
+ InsertTailList(&CompletedListHead, \
&Irp->Tail.Overlay.ListEntry); + }
+ else
+ {
+ /* No irp in queue. Buffer changes */
+ /* FIXME: how much stuff should we buffer?
+ -Should we alloc with quotas?
+ -Should we use a hardcoded limit?
+ -Should we use a time-out? (drop changes \
if they are not retrieved in x seconds? + */
+ BufferedChange = ExAllocatePool(PagedPool, \
FIELD_OFFSET(BUFFERED_CHANGE, RelativeName) + TargetName.Length); + \
+ BufferedChange->Action = Action;
+ BufferedChange->NameLen = TargetName.Length;
+ memcpy(BufferedChange->RelativeName, \
TargetName.Buffer, TargetName.Length); +
+ \
InsertTailList(&NotifyEntry->BufferedChangesList, \
&BufferedChange->ListEntry); + }
+ }
+
+ ExReleaseFastMutex((PFAST_MUTEX)NotifySync);
+
+ /* complete defered irps */
+ while (!IsListEmpty(&CompletedListHead))
+ {
+ EnumEntry = RemoveHeadList(&CompletedListHead);
+ Irp = CONTAINING_RECORD(EnumEntry, IRP, \
Tail.Overlay.ListEntry); +
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
+
</pre><pre class="diff" id="context"> }
@@ -198,25 +674,11 @@
</pre><pre class="diff" id="context"> VOID
STDCALL
FsRtlNotifyInitializeSync (
</pre><pre class="diff" id="removed">- IN PNOTIFY_SYNC NotifySync
</pre><pre class="diff" id="added">+ IN PNOTIFY_SYNC <span \
id="addedchars">*</span>NotifySync </pre><pre class="diff" id="context"> )
{
</pre><pre class="diff" id="removed">-#if 0
- *NotifySync = NULL;
- *NotifySync = ExAllocatePoolWithTag (
- 0x10, // PoolType???
- sizeof (NOTIFY_SYNC), // NumberOfBytes = 0x28
- FSRTL_TAG
- );
-
- *NotifySync->Unknown0 = 1;
- *NotifySync->Unknown2 = 0;
- *NotifySync->Unknown3 = 1;
- *NotifySync->Unknown4 = 4;
- *NotifySync->Unknown5 = 0;
- *NotifySync->Unknown9 = 0;
- *NotifySync->Unknown10 = 0;
-#endif
</pre><pre class="diff" id="added">+ *NotifySync = \
ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), 0/*FSRTL_NOTIFY_TAG*/ ); + \
ExInitializeFastMutex((PFAST_MUTEX)*NotifySync); </pre><pre class="diff" \
id="context"> }
@@ -246,11 +708,11 @@
</pre><pre class="diff" id="context"> NotifySync,
NotifyList,
FullTargetName,
</pre><pre class="diff" id="removed">- (FullTargetName->Length - \
*FileNamePartLength),<span id="removedchars"> /*?*/</span> </pre><pre class="diff" \
id="added">+ (FullTargetName->Length - *FileNamePartLength), </pre><pre \
class="diff" id="context"> NULL, NULL,
FilterMatch,
</pre><pre class="diff" id="removed">- 0,<span id="removedchars"> /* Action ? \
*/</span> </pre><pre class="diff" id="added">+ 0,
</pre><pre class="diff" id="context"> NULL
);
}
@@ -276,16 +738,10 @@
</pre><pre class="diff" id="context"> VOID
STDCALL
FsRtlNotifyUninitializeSync (
</pre><pre class="diff" id="removed">- IN <span id="removedchars">OUT \
</span>PNOTIFY_SYNC NotifySync </pre><pre class="diff" id="added">+ IN \
PNOTIFY_SYNC NotifySync </pre><pre class="diff" id="context"> )
{
</pre><pre class="diff" id="removed">-#if 0
- if (NULL != *NotifySync)
- {
- ExFreePool (*NotifySync);
- *NotifySync = NULL;
- }
-#endif
</pre><pre class="diff" id="added">+ ExFreePool (NotifySync);
</pre><pre class="diff" id="context"> }
/**********************************************************************
</pre>
</div>
</body>
</html>
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic