- Stop using ObfXXX and IofXXX in C code. This is bad style. Always use the non-f...
[reactos.git] / reactos / ntoskrnl / fsrtl / notify.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/fsrtl/notify.c
5 * PURPOSE: Change Notifications and Sync for File System Drivers
6 * PROGRAMMERS: Pierre Schweitzer
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* PRIVATE FUNCTIONS *********************************************************/
16
17 VOID
18 FsRtlNotifyCompleteIrpList(IN PNOTIFY_CHANGE NotifyChange,
19 IN NTSTATUS Status);
20
21 BOOLEAN
22 FsRtlNotifySetCancelRoutine(IN PIRP Irp,
23 IN PNOTIFY_CHANGE NotifyChange OPTIONAL);
24
25 VOID
26 NTAPI
27 FsRtlCancelNotify(IN PDEVICE_OBJECT DeviceObject,
28 IN PIRP Irp)
29 {
30 IoReleaseCancelSpinLock(Irp->CancelIrql);
31 UNIMPLEMENTED;
32 }
33
34 /*
35 * @implemented
36 */
37 VOID
38 FsRtlCheckNotifyForDelete(IN PLIST_ENTRY NotifyList,
39 IN PVOID FsContext)
40 {
41 PLIST_ENTRY NextEntry;
42 PNOTIFY_CHANGE NotifyChange;
43
44 if (!IsListEmpty(NotifyList))
45 {
46 /* Browse the notifications list to find the matching entry */
47 for (NextEntry = NotifyList->Flink;
48 NextEntry != NotifyList;
49 NextEntry = NextEntry->Flink)
50 {
51 NotifyChange = CONTAINING_RECORD(NextEntry, NOTIFY_CHANGE, NotifyList);
52 /* If the current record matches with the given context, it's the good one */
53 if (NotifyChange->FsContext == FsContext && !IsListEmpty(&(NotifyChange->NotifyIrps)))
54 {
55 FsRtlNotifyCompleteIrpList(NotifyChange, STATUS_DELETE_PENDING);
56 }
57 }
58 }
59 }
60
61 PNOTIFY_CHANGE
62 FsRtlIsNotifyOnList(IN PLIST_ENTRY NotifyList,
63 IN PVOID FsContext)
64 {
65 PLIST_ENTRY NextEntry;
66 PNOTIFY_CHANGE NotifyChange;
67
68 if (!IsListEmpty(NotifyList))
69 {
70 /* Browse the notifications list to find the matching entry */
71 for (NextEntry = NotifyList->Flink;
72 NextEntry != NotifyList;
73 NextEntry = NextEntry->Flink)
74 {
75 NotifyChange = CONTAINING_RECORD(NextEntry, NOTIFY_CHANGE, NotifyList);
76 /* If the current record matches with the given context, it's the good one */
77 if (NotifyChange->FsContext == FsContext)
78 {
79 return NotifyChange;
80 }
81 }
82 }
83 return NULL;
84 }
85
86 VOID
87 FORCEINLINE
88 FsRtlNotifyAcquireFastMutex(IN PREAL_NOTIFY_SYNC RealNotifySync)
89 {
90 ULONG_PTR CurrentThread = (ULONG_PTR)KeGetCurrentThread();
91
92 /* Only acquire fast mutex if it's not already acquired by the current thread */
93 if (RealNotifySync->OwningThread != CurrentThread)
94 {
95 ExAcquireFastMutexUnsafe(&(RealNotifySync->FastMutex));
96 RealNotifySync->OwningThread = CurrentThread;
97 }
98 /* Whatever the case, keep trace of the attempt to acquire fast mutex */
99 RealNotifySync->OwnerCount++;
100 }
101
102 /*
103 * @implemented
104 */
105 VOID
106 FsRtlNotifyCompleteIrp(IN PIRP Irp,
107 IN PNOTIFY_CHANGE NotifyChange,
108 IN ULONG DataLength,
109 IN NTSTATUS Status,
110 IN BOOLEAN SkipCompletion)
111 {
112 PVOID Buffer;
113 PIO_STACK_LOCATION Stack;
114
115 PAGED_CODE();
116
117 /* Check if we need to complete */
118 if (!FsRtlNotifySetCancelRoutine(Irp, NotifyChange) && SkipCompletion)
119 {
120 return;
121 }
122
123 /* No succes => no data to return just complete */
124 if (Status != STATUS_SUCCESS)
125 {
126 goto Completion;
127 }
128
129 /* Ensure there's something to return */
130 Stack = IoGetCurrentIrpStackLocation(Irp);
131 if (!DataLength || Stack->Parameters.NotifyDirectory.Length < DataLength)
132 {
133 Status = STATUS_NOTIFY_ENUM_DIR;
134 goto Completion;
135 }
136
137 /* Ensture there's a buffer where to find data */
138 if (!NotifyChange->AllocatedBuffer)
139 {
140 Irp->IoStatus.Information = DataLength;
141 NotifyChange->Buffer = NULL;
142 goto Completion;
143 }
144
145 /* Now, browse all the way to return data
146 * and find the one that will work. We will
147 * return data whatever happens
148 */
149 if (Irp->AssociatedIrp.SystemBuffer)
150 {
151 Buffer = Irp->AssociatedIrp.SystemBuffer;
152 goto CopyAndComplete;
153 }
154
155 if (Irp->MdlAddress)
156 {
157 Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
158 goto CopyAndComplete;
159 }
160
161 if (!(Stack->Control & SL_PENDING_RETURNED))
162 {
163 Buffer = Irp->UserBuffer;
164 goto CopyAndComplete;
165 }
166
167 Irp->Flags |= (IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER | IRP_SYNCHRONOUS_PAGING_IO);
168 Irp->AssociatedIrp.SystemBuffer = NotifyChange->AllocatedBuffer;
169 /* Nothing to copy */
170 goto ReleaseAndComplete;
171
172 CopyAndComplete:
173 _SEH2_TRY
174 {
175 RtlCopyMemory(Buffer, NotifyChange->AllocatedBuffer, DataLength);
176 }
177 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
178 {
179 /* Do nothing */
180 }
181 _SEH2_END;
182
183 ReleaseAndComplete:
184 PsReturnProcessPagedPoolQuota(NotifyChange->OwningProcess, NotifyChange->ThisBufferLength);
185
186 /* Release buffer UNLESS it's used */
187 if (NotifyChange->AllocatedBuffer != Irp->AssociatedIrp.SystemBuffer &&
188 NotifyChange->AllocatedBuffer)
189 {
190 ExFreePoolWithTag(NotifyChange->AllocatedBuffer, 0);
191 }
192
193 /* Prepare for return */
194 NotifyChange->AllocatedBuffer = 0;
195 NotifyChange->ThisBufferLength = 0;
196 Irp->IoStatus.Information = DataLength;
197 NotifyChange->Buffer = NULL;
198
199 /* Finally complete */
200 Completion:
201 IoMarkIrpPending(Irp);
202 Irp->IoStatus.Status = Status;
203 IoCompleteRequest(Irp, EVENT_INCREMENT);
204 }
205
206 /*
207 * @implemented
208 */
209 VOID
210 FsRtlNotifyCompleteIrpList(IN PNOTIFY_CHANGE NotifyChange,
211 IN NTSTATUS Status)
212 {
213 PIRP Irp;
214 ULONG DataLength;
215 PLIST_ENTRY NextEntry;
216
217 DataLength = NotifyChange->DataLength;
218
219 NotifyChange->Flags &= (INVALIDATE_BUFFERS | WATCH_TREE);
220 NotifyChange->DataLength = 0;
221 NotifyChange->LastEntry = 0;
222
223 while (!IsListEmpty(&(NotifyChange->NotifyIrps)))
224 {
225 /* We take the first entry */
226 NextEntry = RemoveHeadList(&(NotifyChange->NotifyIrps));
227 Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
228 /* We complete it */
229 FsRtlNotifyCompleteIrp(Irp, NotifyChange, DataLength, Status, TRUE);
230 /* If we're notifying success, just notify first one */
231 if (Status == STATUS_SUCCESS)
232 break;
233 }
234 }
235
236 VOID
237 FORCEINLINE
238 FsRtlNotifyReleaseFastMutex(IN PREAL_NOTIFY_SYNC RealNotifySync)
239 {
240 RealNotifySync->OwnerCount--;
241 /* Release the fast mutex only if no other instance needs it */
242 if (!RealNotifySync->OwnerCount)
243 {
244 ExReleaseFastMutexUnsafe(&(RealNotifySync->FastMutex));
245 RealNotifySync->OwningThread = (ULONG_PTR)0;
246 }
247 }
248
249 /*
250 * @implemented
251 */
252 BOOLEAN
253 FsRtlNotifySetCancelRoutine(IN PIRP Irp,
254 IN PNOTIFY_CHANGE NotifyChange OPTIONAL)
255 {
256 PDRIVER_CANCEL CancelRoutine;
257
258 /* Acquire cancel lock */
259 IoAcquireCancelSpinLock(&Irp->CancelIrql);
260
261 /* If NotifyChange was given */
262 if (NotifyChange)
263 {
264 /* First get cancel routine */
265 CancelRoutine = IoSetCancelRoutine(Irp, NULL);
266 Irp->IoStatus.Information = 0;
267 /* Release cancel lock */
268 IoReleaseCancelSpinLock(Irp->CancelIrql);
269 /* If there was a cancel routine */
270 if (CancelRoutine)
271 {
272 /* Decrease reference count */
273 InterlockedDecrement((PLONG)&NotifyChange->ReferenceCount);
274 /* Notify that we removed cancel routine */
275 return TRUE;
276 }
277 }
278 else
279 {
280 /* If IRP is cancel, call FsRtl cancel routine */
281 if (Irp->Cancel)
282 {
283 FsRtlCancelNotify(NULL, Irp);
284 }
285 else
286 {
287 /* Otherwise, define FsRtl cancel routine as IRP cancel routine */
288 IoSetCancelRoutine(Irp, FsRtlCancelNotify);
289 /* Release lock */
290 IoReleaseCancelSpinLock(Irp->CancelIrql);
291 }
292 }
293
294 /* Return that we didn't removed cancel routine */
295 return FALSE;
296 }
297
298 /* PUBLIC FUNCTIONS **********************************************************/
299
300 /*++
301 * @name FsRtlNotifyChangeDirectory
302 * @implemented
303 *
304 * Lets FSD know if changes occures in the specified directory.
305 * Directory will be reenumerated.
306 *
307 * @param NotifySync
308 * Synchronization object pointer
309 *
310 * @param FsContext
311 * Used to identify the notify structure
312 *
313 * @param FullDirectoryName
314 * String (A or W) containing the full directory name
315 *
316 * @param NotifyList
317 * Notify list pointer (to head)
318 *
319 * @param WatchTree
320 * True to notify changes in subdirectories too
321 *
322 * @param CompletionFilter
323 * Used to define types of changes to notify
324 *
325 * @param NotifyIrp
326 * IRP pointer to complete notify operation. It can be null
327 *
328 * @return None
329 *
330 * @remarks This function only redirects to FsRtlNotifyFilterChangeDirectory.
331 *
332 *--*/
333 VOID
334 NTAPI
335 FsRtlNotifyChangeDirectory(IN PNOTIFY_SYNC NotifySync,
336 IN PVOID FsContext,
337 IN PSTRING FullDirectoryName,
338 IN PLIST_ENTRY NotifyList,
339 IN BOOLEAN WatchTree,
340 IN ULONG CompletionFilter,
341 IN PIRP NotifyIrp)
342 {
343 FsRtlNotifyFilterChangeDirectory(NotifySync,
344 NotifyList,
345 FsContext,
346 FullDirectoryName,
347 WatchTree,
348 TRUE,
349 CompletionFilter,
350 NotifyIrp,
351 NULL,
352 NULL,
353 NULL);
354 }
355
356 /*++
357 * @name FsRtlNotifyCleanup
358 * @implemented
359 *
360 * Called by FSD when all handles to FileObject (identified by FsContext) are closed
361 *
362 * @param NotifySync
363 * Synchronization object pointer
364 *
365 * @param NotifyList
366 * Notify list pointer (to head)
367 *
368 * @param FsContext
369 * Used to identify the notify structure
370 *
371 * @return None
372 *
373 * @remarks None
374 *
375 *--*/
376 VOID
377 NTAPI
378 FsRtlNotifyCleanup(IN PNOTIFY_SYNC NotifySync,
379 IN PLIST_ENTRY NotifyList,
380 IN PVOID FsContext)
381 {
382 PNOTIFY_CHANGE NotifyChange;
383 PREAL_NOTIFY_SYNC RealNotifySync;
384 PSECURITY_SUBJECT_CONTEXT SubjectContext = NULL;
385
386 /* Get real structure hidden behind the opaque pointer */
387 RealNotifySync = (PREAL_NOTIFY_SYNC)NotifySync;
388
389 /* Acquire the fast mutex */
390 FsRtlNotifyAcquireFastMutex(RealNotifySync);
391
392 _SEH2_TRY
393 {
394 /* Find if there's a matching notification with the FsContext */
395 NotifyChange = FsRtlIsNotifyOnList(NotifyList, FsContext);
396 if (NotifyChange)
397 {
398 /* Mark it as to know that cleanup is in process */
399 NotifyChange->Flags |= CLEANUP_IN_PROCESS;
400
401 /* If there are pending IRPs, complete them using the STATUS_NOTIFY_CLEANUP status */
402 if (!IsListEmpty(&NotifyChange->NotifyIrps))
403 {
404 FsRtlNotifyCompleteIrpList(NotifyChange, STATUS_NOTIFY_CLEANUP);
405 }
406
407 /* Decrease reference number and if 0 is reached, it's time to do complete cleanup */
408 if (!InterlockedDecrement((PLONG)&(NotifyChange->ReferenceCount)))
409 {
410 /* Remove it from the notifications list */
411 RemoveEntryList(&NotifyChange->NotifyList);
412
413 /* In case there was an allocated buffer, free it */
414 if (NotifyChange->AllocatedBuffer)
415 {
416 PsReturnProcessPagedPoolQuota(NotifyChange->OwningProcess, NotifyChange->ThisBufferLength);
417 ExFreePool(NotifyChange->AllocatedBuffer);
418 }
419
420 /* In case there the string was set, get the captured subject security context */
421 if (NotifyChange->FullDirectoryName)
422 {
423 SubjectContext = NotifyChange->SubjectContext;
424 }
425
426 /* Finally, free the notification, as it's not needed anymore */
427 ExFreePool(NotifyChange);
428 }
429 }
430 }
431 _SEH2_FINALLY
432 {
433 /* Release fast mutex */
434 FsRtlNotifyReleaseFastMutex(RealNotifySync);
435
436 /* If the subject security context was captured, release and free it */
437 if (SubjectContext)
438 {
439 SeReleaseSubjectContext(SubjectContext);
440 ExFreePool(SubjectContext);
441 }
442 }
443 _SEH2_END;
444 }
445
446 /*++
447 * @name FsRtlNotifyFilterChangeDirectory
448 * @unimplemented
449 *
450 * FILLME
451 *
452 * @param NotifySync
453 * FILLME
454 *
455 * @param NotifyList
456 * FILLME
457 *
458 * @param FsContext
459 * FILLME
460 *
461 * @param FullDirectoryName
462 * FILLME
463 *
464 * @param WatchTree
465 * FILLME
466 *
467 * @param IgnoreBuffer
468 * FILLME
469 *
470 * @param CompletionFilter
471 * FILLME
472 *
473 * @param NotifyIrp
474 * FILLME
475 *
476 * @param TraverseCallback
477 * FILLME
478 *
479 * @param SubjectContext
480 * FILLME
481 *
482 * @param FilterCallback
483 * FILLME
484 *
485 * @return None
486 *
487 * @remarks None
488 *
489 *--*/
490 VOID
491 NTAPI
492 FsRtlNotifyFilterChangeDirectory(IN PNOTIFY_SYNC NotifySync,
493 IN PLIST_ENTRY NotifyList,
494 IN PVOID FsContext,
495 IN PSTRING FullDirectoryName,
496 IN BOOLEAN WatchTree,
497 IN BOOLEAN IgnoreBuffer,
498 IN ULONG CompletionFilter,
499 IN PIRP NotifyIrp,
500 IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL,
501 IN PSECURITY_SUBJECT_CONTEXT SubjectContext OPTIONAL,
502 IN PFILTER_REPORT_CHANGE FilterCallback OPTIONAL)
503 {
504 ULONG SavedLength;
505 PIO_STACK_LOCATION Stack;
506 PNOTIFY_CHANGE NotifyChange;
507 PREAL_NOTIFY_SYNC RealNotifySync;
508
509 PAGED_CODE();
510
511 DPRINT("FsRtlNotifyFilterChangeDirectory(): %p, %p, %p, %wZ, %d, %d, %u, %p, %p, %p, %p\n",
512 NotifySync, NotifyList, FsContext, FullDirectoryName, WatchTree, IgnoreBuffer, CompletionFilter, NotifyIrp,
513 TraverseCallback, SubjectContext, FilterCallback);
514
515 /* Get real structure hidden behind the opaque pointer */
516 RealNotifySync = (PREAL_NOTIFY_SYNC)NotifySync;
517
518 /* Acquire the fast mutex */
519 FsRtlNotifyAcquireFastMutex(RealNotifySync);
520
521 _SEH2_TRY
522 {
523 /* If we have no IRP, FSD is performing a cleanup */
524 if (!NotifyIrp)
525 {
526 /* So, we delete */
527 FsRtlCheckNotifyForDelete(NotifyList, FsContext);
528 _SEH2_LEAVE;
529 }
530
531 NotifyIrp->IoStatus.Status = STATUS_SUCCESS;
532 NotifyIrp->IoStatus.Information = (ULONG_PTR)NULL;
533
534 Stack = IoGetCurrentIrpStackLocation(NotifyIrp);
535 /* If FileObject's been cleaned up, just return */
536 if (Stack->FileObject->Flags & FO_CLEANUP_COMPLETE)
537 {
538 IoMarkIrpPending(NotifyIrp);
539 NotifyIrp->IoStatus.Status = STATUS_NOTIFY_CLEANUP;
540 IoCompleteRequest(NotifyIrp, EVENT_INCREMENT);
541 _SEH2_LEAVE;
542 }
543
544 /* Try to find a matching notification has been already registered */
545 NotifyChange = FsRtlIsNotifyOnList(NotifyList, FsContext);
546 if (NotifyChange)
547 {
548 /* If it's been found, and is cleaned up, immediatly complete */
549 if (NotifyChange->Flags & CLEANUP_IN_PROCESS)
550 {
551 IoMarkIrpPending(NotifyIrp);
552 NotifyIrp->IoStatus.Status = STATUS_NOTIFY_CLEANUP;
553 IoCompleteRequest(NotifyIrp, EVENT_INCREMENT);
554 }
555 /* Or if it's about to be deleted, complete */
556 else if (NotifyChange->Flags & DELETE_IN_PROCESS)
557 {
558 IoMarkIrpPending(NotifyIrp);
559 NotifyIrp->IoStatus.Status = STATUS_DELETE_PENDING;
560 IoCompleteRequest(NotifyIrp, EVENT_INCREMENT);
561 }
562 /* Complete if there is directory enumeration and no buffer available any more */
563 if ((NotifyChange->Flags & INVALIDATE_BUFFERS) && (NotifyChange->Flags & ENUMERATE_DIR))
564 {
565 NotifyChange->Flags &= ~INVALIDATE_BUFFERS;
566 IoMarkIrpPending(NotifyIrp);
567 NotifyIrp->IoStatus.Status = STATUS_NOTIFY_ENUM_DIR;
568 IoCompleteRequest(NotifyIrp, EVENT_INCREMENT);
569 }
570 /* If no data yet, or directory enumeration, handle */
571 else if (NotifyChange->DataLength == 0 || (NotifyChange->Flags & ENUMERATE_DIR))
572 {
573 goto HandleIRP;
574 }
575 /* Else, just complete with we have */
576 else
577 {
578 SavedLength = NotifyChange->DataLength;
579 NotifyChange->DataLength = 0;
580 FsRtlNotifyCompleteIrp(NotifyIrp, NotifyChange, SavedLength, STATUS_SUCCESS, FALSE);
581 }
582
583 _SEH2_LEAVE;
584 }
585
586 /* Allocate new notification */
587 NotifyChange = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE,
588 sizeof(NOTIFY_CHANGE), 'FSrN');
589 RtlZeroMemory(NotifyChange, sizeof(NOTIFY_CHANGE));
590
591 /* Set basic information */
592 NotifyChange->NotifySync = NotifySync;
593 NotifyChange->FsContext = FsContext;
594 NotifyChange->StreamID = Stack->FileObject->FsContext;
595 NotifyChange->TraverseCallback = TraverseCallback;
596 NotifyChange->SubjectContext = SubjectContext;
597 NotifyChange->FullDirectoryName = FullDirectoryName;
598 NotifyChange->FilterCallback = FilterCallback;
599 InitializeListHead(&(NotifyChange->NotifyIrps));
600
601 /* Keep trace of WatchTree */
602 if (WatchTree)
603 {
604 NotifyChange->Flags |= WATCH_TREE;
605 }
606
607 /* If string is empty, faulty to ANSI */
608 if (FullDirectoryName->Length == 0)
609 {
610 NotifyChange->CharacterSize = sizeof(CHAR);
611 }
612 else
613 {
614 /* If it can't contain WCHAR, it's ANSI */
615 if (FullDirectoryName->Length < sizeof(WCHAR))
616 {
617 NotifyChange->CharacterSize = sizeof(CHAR);
618 }
619 /* First char is \, so in unicode, right part is 0
620 * whereas in ANSI it contains next char
621 */
622 else if (((CHAR*)FullDirectoryName->Buffer)[1] == 0)
623 {
624 NotifyChange->CharacterSize = sizeof(WCHAR);
625 }
626 else
627 {
628 NotifyChange->CharacterSize = sizeof(CHAR);
629 }
630
631 /* Now, check is user is willing to watch root */
632 if (FullDirectoryName->Length == NotifyChange->CharacterSize)
633 {
634 NotifyChange->Flags |= WATCH_ROOT;
635 }
636 }
637
638 NotifyChange->CompletionFilter = CompletionFilter;
639
640 /* In case we have not to ignore buffer , keep its length */
641 if (!IgnoreBuffer)
642 {
643 NotifyChange->BufferLength = Stack->Parameters.NotifyDirectory.Length;
644 }
645
646 NotifyChange->OwningProcess = NotifyIrp->Tail.Overlay.Thread->ThreadsProcess;
647
648 /* Insert the notification into the notification list */
649 InsertTailList(NotifyList, &(NotifyChange->NotifyList));
650
651 NotifyChange->ReferenceCount = 1;
652
653 HandleIRP:
654 /* Associate the notification to the IRP */
655 NotifyIrp->IoStatus.Information = (ULONG_PTR)NotifyChange;
656 /* The IRP is pending */
657 IoMarkIrpPending(NotifyIrp);
658 /* Insert the IRP in the IRP list */
659 InsertTailList(&(NotifyChange->NotifyIrps), &(NotifyIrp->Tail.Overlay.ListEntry));
660 /* Increment reference count */
661 InterlockedIncrement((PLONG)&(NotifyChange->ReferenceCount));
662 /* Set cancel routine to FsRtl one */
663 FsRtlNotifySetCancelRoutine(NotifyIrp, NULL);
664 }
665 _SEH2_FINALLY
666 {
667 /* Release fast mutex */
668 FsRtlNotifyReleaseFastMutex(RealNotifySync);
669
670 /* If the subject security context was captured and there's no notify */
671 if (SubjectContext && (!NotifyChange || FullDirectoryName))
672 {
673 SeReleaseSubjectContext(SubjectContext);
674 ExFreePool(SubjectContext);
675 }
676 }
677 _SEH2_END;
678 }
679
680 /*++
681 * @name FsRtlNotifyFilterReportChange
682 * @unimplemented
683 *
684 * FILLME
685 *
686 * @param NotifySync
687 * FILLME
688 *
689 * @param NotifyList
690 * FILLME
691 *
692 * @param FullTargetName
693 * FILLME
694 *
695 * @param TargetNameOffset
696 * FILLME
697 *
698 * @param StreamName
699 * FILLME
700 *
701 * @param NormalizedParentName
702 * FILLME
703 *
704 * @param FilterMatch
705 * FILLME
706 *
707 * @param Action
708 * FILLME
709 *
710 * @param TargetContext
711 * FILLME
712 *
713 * @param FilterContext
714 * FILLME
715 *
716 * @return None
717 *
718 * @remarks None
719 *
720 *--*/
721 VOID
722 NTAPI
723 FsRtlNotifyFilterReportChange(IN PNOTIFY_SYNC NotifySync,
724 IN PLIST_ENTRY NotifyList,
725 IN PSTRING FullTargetName,
726 IN USHORT TargetNameOffset,
727 IN PSTRING StreamName OPTIONAL,
728 IN PSTRING NormalizedParentName OPTIONAL,
729 IN ULONG FilterMatch,
730 IN ULONG Action,
731 IN PVOID TargetContext,
732 IN PVOID FilterContext)
733 {
734 KeBugCheck(FILE_SYSTEM);
735 }
736
737 /*++
738 * @name FsRtlNotifyFullChangeDirectory
739 * @implemented
740 *
741 * Lets FSD know if changes occures in the specified directory.
742 *
743 * @param NotifySync
744 * Synchronization object pointer
745 *
746 * @param NotifyList
747 * Notify list pointer (to head)
748 *
749 * @param FsContext
750 * Used to identify the notify structure
751 *
752 * @param FullDirectoryName
753 * String (A or W) containing the full directory name
754 *
755 * @param WatchTree
756 * True to notify changes in subdirectories too
757 *
758 * @param IgnoreBuffer
759 * True to reenumerate directory. It's ignored it NotifyIrp is null
760 *
761 * @param CompletionFilter
762 * Used to define types of changes to notify
763 *
764 * @param NotifyIrp
765 * IRP pointer to complete notify operation. It can be null
766 *
767 * @param TraverseCallback
768 * Pointer to a callback function. It's called each time a change is
769 * done in a subdirectory of the main directory. It's ignored it NotifyIrp
770 * is null
771 *
772 * @param SubjectContext
773 * Pointer to pass to SubjectContext member of TraverseCallback.
774 * It's freed after use. It's ignored it NotifyIrp is null
775 *
776 * @return None
777 *
778 * @remarks This function only redirects to FsRtlNotifyFilterChangeDirectory.
779 *
780 *--*/
781 VOID
782 NTAPI
783 FsRtlNotifyFullChangeDirectory(IN PNOTIFY_SYNC NotifySync,
784 IN PLIST_ENTRY NotifyList,
785 IN PVOID FsContext,
786 IN PSTRING FullDirectoryName,
787 IN BOOLEAN WatchTree,
788 IN BOOLEAN IgnoreBuffer,
789 IN ULONG CompletionFilter,
790 IN PIRP NotifyIrp,
791 IN PCHECK_FOR_TRAVERSE_ACCESS TraverseCallback OPTIONAL,
792 IN PSECURITY_SUBJECT_CONTEXT SubjectContext OPTIONAL)
793 {
794 FsRtlNotifyFilterChangeDirectory(NotifySync,
795 NotifyList,
796 FsContext,
797 FullDirectoryName,
798 WatchTree,
799 IgnoreBuffer,
800 CompletionFilter,
801 NotifyIrp,
802 TraverseCallback,
803 SubjectContext,
804 NULL);
805 }
806
807 /*++
808 * @name FsRtlNotifyFullReportChange
809 * @implemented
810 *
811 * Complets the pending notify IRPs.
812 *
813 * @param NotifySync
814 * Synchronization object pointer
815 *
816 * @param NotifyList
817 * Notify list pointer (to head)
818 *
819 * @param FullTargetName
820 * String (A or W) containing the full directory name that changed
821 *
822 * @param TargetNameOffset
823 * Offset, in FullTargetName, of the final component that is in the changed directory
824 *
825 * @param StreamName
826 * String (A or W) containing a stream name
827 *
828 * @param NormalizedParentName
829 * String (A or W) containing the full directory name that changed with long names
830 *
831 * @param FilterMatch
832 * Flags that will be compared to the completion filter
833 *
834 * @param Action
835 * Action code to store in user's buffer
836 *
837 * @param TargetContext
838 * Pointer to a callback function. It's called each time a change is
839 * done in a subdirectory of the main directory.
840 *
841 * @return None
842 *
843 * @remarks This function only redirects to FsRtlNotifyFilterReportChange.
844 *
845 *--*/
846 VOID
847 NTAPI
848 FsRtlNotifyFullReportChange(IN PNOTIFY_SYNC NotifySync,
849 IN PLIST_ENTRY NotifyList,
850 IN PSTRING FullTargetName,
851 IN USHORT TargetNameOffset,
852 IN PSTRING StreamName OPTIONAL,
853 IN PSTRING NormalizedParentName OPTIONAL,
854 IN ULONG FilterMatch,
855 IN ULONG Action,
856 IN PVOID TargetContext)
857 {
858 FsRtlNotifyFilterReportChange(NotifySync,
859 NotifyList,
860 FullTargetName,
861 TargetNameOffset,
862 StreamName,
863 NormalizedParentName,
864 FilterMatch,
865 Action,
866 TargetContext,
867 NULL);
868 }
869
870 /*++
871 * @name FsRtlNotifyInitializeSync
872 * @implemented
873 *
874 * Allocates the internal structure associated with notifications.
875 *
876 * @param NotifySync
877 * Opaque pointer. It will receive the address of the allocated internal structure.
878 *
879 * @return None
880 *
881 * @remarks This function raise an exception in case of a failure.
882 *
883 *--*/
884 VOID
885 NTAPI
886 FsRtlNotifyInitializeSync(IN PNOTIFY_SYNC *NotifySync)
887 {
888 PREAL_NOTIFY_SYNC RealNotifySync;
889
890 *NotifySync = NULL;
891
892 RealNotifySync = ExAllocatePoolWithTag(NonPagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE,
893 sizeof(REAL_NOTIFY_SYNC), 'FSNS');
894 ExInitializeFastMutex(&(RealNotifySync->FastMutex));
895 RealNotifySync->OwningThread = 0;
896 RealNotifySync->OwnerCount = 0;
897
898 *NotifySync = RealNotifySync;
899 }
900
901 /*++
902 * @name FsRtlNotifyReportChange
903 * @implemented
904 *
905 * Complets the pending notify IRPs.
906 *
907 * @param NotifySync
908 * Synchronization object pointer
909 *
910 * @param NotifyList
911 * Notify list pointer (to head)
912 *
913 * @param FullTargetName
914 * String (A or W) containing the full directory name that changed
915 *
916 * @param FileNamePartLength
917 * Length of the final component that is in the changed directory
918 *
919 * @param FilterMatch
920 * Flags that will be compared to the completion filter
921 *
922 * @return None
923 *
924 * @remarks This function only redirects to FsRtlNotifyFilterReportChange.
925 *
926 *--*/
927 VOID
928 NTAPI
929 FsRtlNotifyReportChange(IN PNOTIFY_SYNC NotifySync,
930 IN PLIST_ENTRY NotifyList,
931 IN PSTRING FullTargetName,
932 IN PUSHORT FileNamePartLength,
933 IN ULONG FilterMatch)
934 {
935 FsRtlNotifyFilterReportChange(NotifySync,
936 NotifyList,
937 FullTargetName,
938 FullTargetName->Length - *FileNamePartLength,
939 NULL,
940 NULL,
941 FilterMatch,
942 0,
943 NULL,
944 NULL);
945 }
946
947 /*++
948 * @name FsRtlNotifyUninitializeSync
949 * @implemented
950 *
951 * Uninitialize a NOTIFY_SYNC object
952 *
953 * @param NotifySync
954 * Address of a pointer to a PNOTIFY_SYNC object previously
955 * initialized by FsRtlNotifyInitializeSync()
956 *
957 * @return None
958 *
959 * @remarks None
960 *
961 *--*/
962 VOID
963 NTAPI
964 FsRtlNotifyUninitializeSync(IN PNOTIFY_SYNC *NotifySync)
965 {
966 if (*NotifySync)
967 {
968 ExFreePoolWithTag(*NotifySync, 'FSNS');
969 *NotifySync = NULL;
970 }
971 }
972