2 * Debugging tracer of IRPs and Cc* (Cache Manager) calls for W32
\r
3 * Copyright (C) 2003 Jan Kratochvil <project-captive@jankratochvil.net>
\r
5 * This program is free software; you can redistribute it and/or modify
\r
6 * it under the terms of the GNU General Public License as published by
\r
7 * the Free Software Foundation; exactly version 2 of June 1991 is required
\r
9 * This program is distributed in the hope that it will be useful,
\r
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
12 * GNU General Public License for more details.
\r
14 * You should have received a copy of the GNU General Public License
\r
15 * along with this program; if not, write to the Free Software
\r
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
\r
22 #define CACHE_SIZE 0x200
\r
25 #define G_N_ELEMENTS(arr) (sizeof(arr)/sizeof((arr)[0]))
\r
27 NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath);
\r
30 #pragma alloc_text (INIT, DriverEntry)
\r
33 /* Ke*Mutex() would be reentrant but it looked too unclear for me.
\r
34 * Never ExAcquireFastMutex() two FAST_MUTEX once or one FAST_MUTEX twice.
\r
35 * Use Ex*ResourceLite instead of Ex*FastMutex() as it would set IRQL to DPC
\r
36 * and we cannot pass the execution to Cc*() in DPC.
\r
37 * Ex*FastMutex() problem: IRP_MJ_SHUTDOWN: Assertion failure.
\r
39 static ERESOURCE lock_resource;
\r
40 static int lock_resource_count;
\r
41 static PETHREAD lock_resource_CurrentThread;
\r
43 static void lock_init(void)
\r
45 if (ExInitializeResourceLite(&lock_resource))
\r
47 lock_resource_count=0;
\r
48 lock_resource_CurrentThread=NULL;
\r
51 static void lock(void)
\r
53 if (lock_resource_CurrentThread==PsGetCurrentThread()) {
\r
54 if (lock_resource_count<=0)
\r
56 lock_resource_count++;
\r
59 KeEnterCriticalRegion();
\r
60 if (!ExAcquireResourceExclusiveLite(&lock_resource,TRUE))
\r
62 KeLeaveCriticalRegion();
\r
63 if (lock_resource_CurrentThread)
\r
65 if (lock_resource_count)
\r
67 lock_resource_CurrentThread=PsGetCurrentThread();
\r
68 lock_resource_count++;
\r
71 /* We need to _fully_ release the lock if we are passing the control to
\r
72 * callback functions. Single unlock() would free us from our current 'enter:'
\r
73 * lock but another lock() from Cc*() function which called us would be held.
\r
74 * FIXME: Enable of file compression still hangs in CcFlushCache().
\r
76 static void lock_full(int n)
\r
80 if (lock_resource_CurrentThread==PsGetCurrentThread())
\r
82 KeEnterCriticalRegion();
\r
83 if (!ExAcquireResourceExclusiveLite(&lock_resource,TRUE))
\r
85 KeLeaveCriticalRegion();
\r
86 if (lock_resource_CurrentThread)
\r
88 if (lock_resource_count)
\r
90 lock_resource_CurrentThread=PsGetCurrentThread();
\r
91 lock_resource_count+=n;
\r
94 static void unlock(void)
\r
96 if (lock_resource_CurrentThread!=PsGetCurrentThread())
\r
98 if (lock_resource_count<=0)
\r
100 if (--lock_resource_count)
\r
102 lock_resource_CurrentThread=NULL;
\r
103 KeEnterCriticalRegion();
\r
104 ExReleaseResourceLite(&lock_resource);
\r
105 KeLeaveCriticalRegion();
\r
108 static int unlock_full(void)
\r
112 if (lock_resource_CurrentThread!=PsGetCurrentThread())
\r
114 if (lock_resource_count<=0)
\r
116 r=lock_resource_count;
\r
117 lock_resource_count=0;
\r
118 lock_resource_CurrentThread=NULL;
\r
119 KeEnterCriticalRegion();
\r
120 ExReleaseResourceLite(&lock_resource);
\r
121 KeLeaveCriticalRegion();
\r
125 #define DBGPREFIX "TraceFS(0x%08lX/0x%08lX): "
\r
126 #define DBGARG PsGetCurrentProcess(),PsGetCurrentThread()
\r
128 static int dbgindent=0;
\r
130 /* DBGSINGLEENTER*() / DBGSINGLELEAVE*() are protected by lock()/unlock()
\r
131 * to serialize the Cc*() function calls as otherwise the debug dumps
\r
132 * chronology may not match the real core execution chronology inside.
\r
135 /* lock() will protect dbg_unicode_string() static buffer. */
\r
136 #define DBGSINGLE6(fmt,arg1,arg2,arg3,arg4,arg5,arg6) \
\r
137 do { lock(); DbgPrint("%*s" DBGPREFIX fmt "\n",dbgindent,"",DBGARG,arg1,arg2,arg3,arg4,arg5,arg6); unlock(); } while (0)
\r
138 #define DBGSINGLE5(fmt,arg1,arg2,arg3,arg4,arg5) DBGSINGLE6(fmt,arg1,arg2,arg3,arg4,arg5,0)
\r
139 #define DBGSINGLE4(fmt,arg1,arg2,arg3,arg4) DBGSINGLE5(fmt,arg1,arg2,arg3,arg4,0)
\r
140 #define DBGSINGLE3(fmt,arg1,arg2,arg3) DBGSINGLE4(fmt,arg1,arg2,arg3,0)
\r
141 #define DBGSINGLE2(fmt,arg1,arg2) DBGSINGLE3(fmt,arg1,arg2,0)
\r
142 #define DBGSINGLE1(fmt,arg1) DBGSINGLE2(fmt,arg1,0)
\r
143 #define DBGSINGLE0(fmt) DBGSINGLE1(fmt,0)
\r
144 #define DBGSINGLEENTER6(fmt,arg1,arg2,arg3,arg4,arg5,arg6) \
\r
145 do { lock(); DBGSINGLE6("enter: " fmt,arg1,arg2,arg3,arg4,arg5,arg6); dbgindent++; } while (0)
\r
146 #define DBGSINGLEENTER5(fmt,arg1,arg2,arg3,arg4,arg5) DBGSINGLEENTER6(fmt,arg1,arg2,arg3,arg4,arg5,0)
\r
147 #define DBGSINGLEENTER4(fmt,arg1,arg2,arg3,arg4) DBGSINGLEENTER5(fmt,arg1,arg2,arg3,arg4,0)
\r
148 #define DBGSINGLEENTER3(fmt,arg1,arg2,arg3) DBGSINGLEENTER4(fmt,arg1,arg2,arg3,0)
\r
149 #define DBGSINGLEENTER2(fmt,arg1,arg2) DBGSINGLEENTER3(fmt,arg1,arg2,0)
\r
150 #define DBGSINGLEENTER1(fmt,arg1) DBGSINGLEENTER2(fmt,arg1,0)
\r
151 #define DBGSINGLEENTER0(fmt) DBGSINGLEENTER1(fmt,0)
\r
152 #define DBGSINGLELEAVE3(fmt,arg1,arg2,arg3) \
\r
153 do { dbgindent--; DBGSINGLE3("leave: " fmt,arg1,arg2,arg3); unlock(); } while (0)
\r
154 #define DBGSINGLELEAVE2(fmt,arg1,arg2) DBGSINGLELEAVE3(fmt,arg1,arg2,0)
\r
155 #define DBGSINGLELEAVE1(fmt,arg1) DBGSINGLELEAVE2(fmt,arg1,0)
\r
156 #define DBGSINGLELEAVE0(fmt) DBGSINGLELEAVE1(fmt,0)
\r
159 /* We cannot use DbgPrint("%wZ",...) as it must have IRQL PASSIVE_LEVEL which
\r
160 * is not satisfied.
\r
162 static const char *dbg_unicode_string(UNICODE_STRING *unicode_string)
\r
164 static char buf[0x100];
\r
168 if (!unicode_string || !unicode_string->Buffer)
\r
172 for (s=unicode_string->Buffer;s<unicode_string->Buffer+(unicode_string->Length/2);s++) {
\r
173 if (d>=buf+sizeof(buf)-4)
\r
182 NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath)
\r
185 DEVICE_OBJECT *device_object;
\r
189 DBGSINGLEENTER1("DriverEntry: RegistryPath=%s",dbg_unicode_string(RegistryPath));
\r
190 DBGSINGLE1("DriverEntry: %s","$Id$");
\r
192 DriverObject, /* DriverObject */
\r
193 0, /* DeviceExtensionSize */
\r
194 NULL, /* DeviceName; optional */
\r
195 FILE_DEVICE_UNKNOWN, /* DeviceType */
\r
196 0, /* DeviceCharacteristics */
\r
197 FALSE, /* Exclusive */
\r
198 &device_object); /* DeviceObject */
\r
199 DBGSINGLELEAVE1("DriverEntry: r=0x%lX",(long)r);
\r
203 static const char *const dump_irp_mj_FILE_SYSTEM_CONTROL_MinorFunction_names[]={
\r
204 "IRP_MN_USER_FS_REQUEST",
\r
205 "IRP_MN_MOUNT_VOLUME",
\r
206 "IRP_MN_VERIFY_VOLUME",
\r
207 "IRP_MN_LOAD_FILE_SYSTEM",
\r
208 "IRP_MN_KERNEL_CALL",
\r
211 /* Compatibility with DDK; the structures match. */
\r
212 #define FileSystemControl DeviceIoControl
\r
213 #define FsControlCode IoControlCode
\r
214 #ifndef FSCTL_REQUEST_BATCH_OPLOCK
\r
215 #define FSCTL_REQUEST_BATCH_OPLOCK CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 2,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
217 #ifndef FSCTL_LOCK_VOLUME
\r
218 #define FSCTL_LOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
220 #ifndef FSCTL_UNLOCK_VOLUME
\r
221 #define FSCTL_UNLOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 7,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
223 #ifndef FSCTL_DISMOUNT_VOLUME
\r
224 #define FSCTL_DISMOUNT_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 8,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
226 #ifndef FSCTL_MARK_VOLUME_DIRTY
\r
227 #define FSCTL_MARK_VOLUME_DIRTY CTL_CODE(FILE_DEVICE_FILE_SYSTEM,12,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
229 #ifndef FSCTL_SET_COMPRESSION
\r
230 #define FSCTL_SET_COMPRESSION CTL_CODE(FILE_DEVICE_FILE_SYSTEM,16,METHOD_BUFFERED,FILE_READ_DATA|FILE_WRITE_DATA)
\r
232 #ifndef FSCTL_INVALIDATE_VOLUMES
\r
233 #define FSCTL_INVALIDATE_VOLUMES CTL_CODE(FILE_DEVICE_FILE_SYSTEM,21,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
235 #ifndef FSCTL_IS_VOLUME_DIRTY
\r
236 #define FSCTL_IS_VOLUME_DIRTY CTL_CODE(FILE_DEVICE_FILE_SYSTEM,30,METHOD_BUFFERED,FILE_ANY_ACCESS)
\r
238 #ifndef FSCTL_FILE_PREFETCH
\r
239 #define FSCTL_FILE_PREFETCH CTL_CODE(FILE_DEVICE_FILE_SYSTEM,72,METHOD_BUFFERED,FILE_SPECIAL_ACCESS)
\r
242 static struct SectionObjectPointer {
\r
243 FILE_OBJECT *FileObject;
\r
244 PVOID SharedCacheMap;
\r
245 } SectionObjectPointer_cache[CACHE_SIZE];
\r
246 static int SectionObjectPointer_cache_used=0;
\r
248 static struct SectionObjectPointer *SectionObjectPointer_set(FILE_OBJECT *FileObject)
\r
250 struct SectionObjectPointer *sopp;
\r
251 PVOID SharedCacheMap;
\r
253 if (!FileObject->SectionObjectPointer)
\r
255 if (!(SharedCacheMap=FileObject->SectionObjectPointer->SharedCacheMap))
\r
257 for (sopp=SectionObjectPointer_cache;sopp<SectionObjectPointer_cache+SectionObjectPointer_cache_used;sopp++) {
\r
258 if (sopp->FileObject==FileObject || sopp->SharedCacheMap==SharedCacheMap)
\r
261 if (sopp>=SectionObjectPointer_cache+G_N_ELEMENTS(SectionObjectPointer_cache))
\r
263 if (sopp==SectionObjectPointer_cache+SectionObjectPointer_cache_used)
\r
264 SectionObjectPointer_cache_used++;
\r
265 sopp->FileObject=FileObject;
\r
266 sopp->SharedCacheMap=SharedCacheMap;
\r
270 static FILE_OBJECT *SectionObjectPointer_find(SECTION_OBJECT_POINTERS *SectionObjectPointer)
\r
272 struct SectionObjectPointer *sopp;
\r
273 PVOID SharedCacheMap;
\r
275 if (!SectionObjectPointer)
\r
277 if (!(SharedCacheMap=SectionObjectPointer->SharedCacheMap))
\r
279 for (sopp=SectionObjectPointer_cache;sopp<SectionObjectPointer_cache+SectionObjectPointer_cache_used;sopp++) {
\r
280 if (sopp->SharedCacheMap==SharedCacheMap)
\r
281 return sopp->FileObject;
\r
286 static void dump_FileObject(FILE_OBJECT *FileObject)
\r
289 DBGSINGLE0("FileObject=NULL");
\r
292 DBGSINGLE6("FileObject=0x%lX: FileName=%s,ref=%+ld,Flags=0x%lX,SectionObjectPointer=0x%lX,->SharedCacheMap=0x%lX",
\r
294 dbg_unicode_string(&FileObject->FileName),
\r
295 *(LONG *)(((char *)FileObject)-0x18),
\r
297 (long)FileObject->SectionObjectPointer,
\r
298 (!FileObject->SectionObjectPointer ? -1 : (long)FileObject->SectionObjectPointer->SharedCacheMap));
\r
299 SectionObjectPointer_set(FileObject);
\r
302 static FILE_OBJECT *dump_irp_mj(struct _DEVICE_OBJECT *DeviceObject,struct _IRP *Irp)
\r
304 IO_STACK_LOCATION *IoStackLocation;
\r
305 FILE_OBJECT *FileObject;
\r
308 DBGSINGLE0("Irp==NULL");
\r
311 IoStackLocation=IoGetCurrentIrpStackLocation(Irp);
\r
312 if (!IoStackLocation) {
\r
313 DBGSINGLE0("IoStackLocation==NULL");
\r
316 FileObject=IoStackLocation->FileObject;
\r
317 dump_FileObject(FileObject);
\r
319 switch (IoStackLocation->MajorFunction) {
\r
321 DBGSINGLE2("READ: ByteOffset=0x%lX,Length=0x%lX",
\r
322 (long)IoStackLocation->Parameters.Read.ByteOffset.QuadPart,
\r
323 IoStackLocation->Parameters.Read.Length);
\r
326 DBGSINGLE2("WRITE: ByteOffset=0x%lX,Length=0x%lX",
\r
327 (long)IoStackLocation->Parameters.Write.ByteOffset.QuadPart,
\r
328 IoStackLocation->Parameters.Write.Length);
\r
330 case IRP_MJ_FILE_SYSTEM_CONTROL:
\r
331 DBGSINGLE2("FILE_SYSTEM_CONTROL: MinorFunction=%s (%0x%X)",
\r
333 && IoStackLocation->MinorFunction>=0
\r
334 && IoStackLocation->MinorFunction<G_N_ELEMENTS(dump_irp_mj_FILE_SYSTEM_CONTROL_MinorFunction_names))
\r
335 ? dump_irp_mj_FILE_SYSTEM_CONTROL_MinorFunction_names[IoStackLocation->MinorFunction] : "???"),
\r
336 IoStackLocation->MinorFunction);
\r
337 switch (IoStackLocation->MinorFunction) {
\r
338 case IRP_MN_USER_FS_REQUEST: {
\r
339 const char *FsControlCode_name;
\r
340 switch (IoStackLocation->Parameters.FileSystemControl.FsControlCode) {
\r
341 case FSCTL_REQUEST_BATCH_OPLOCK: FsControlCode_name="FSCTL_REQUEST_BATCH_OPLOCK"; break;
\r
342 case FSCTL_LOCK_VOLUME: FsControlCode_name="FSCTL_LOCK_VOLUME"; break;
\r
343 case FSCTL_UNLOCK_VOLUME: FsControlCode_name="FSCTL_UNLOCK_VOLUME"; break;
\r
344 case FSCTL_DISMOUNT_VOLUME: FsControlCode_name="FSCTL_DISMOUNT_VOLUME"; break;
\r
345 case FSCTL_MARK_VOLUME_DIRTY: FsControlCode_name="FSCTL_MARK_VOLUME_DIRTY"; break;
\r
346 case FSCTL_SET_COMPRESSION: FsControlCode_name="FSCTL_SET_COMPRESSION"; break;
\r
347 case FSCTL_INVALIDATE_VOLUMES: FsControlCode_name="FSCTL_INVALIDATE_VOLUMES"; break;
\r
348 case FSCTL_IS_VOLUME_DIRTY: FsControlCode_name="FSCTL_IS_VOLUME_DIRTY"; break;
\r
349 case FSCTL_FILE_PREFETCH: FsControlCode_name="FSCTL_FILE_PREFETCH"; break;
\r
350 default: FsControlCode_name="???"; break;
\r
352 DBGSINGLE2("USER_FS_REQUEST: FsControlCode=%s (0x%X)",FsControlCode_name,
\r
353 IoStackLocation->Parameters.FileSystemControl.FsControlCode);
\r
361 #define TRACEFS_MAJORS \
\r
362 TRACEFS_MAJOR(IRP_MJ_CREATE) \
\r
363 TRACEFS_MAJOR(IRP_MJ_CREATE_NAMED_PIPE) \
\r
364 TRACEFS_MAJOR(IRP_MJ_CLOSE) \
\r
365 TRACEFS_MAJOR(IRP_MJ_READ) \
\r
366 TRACEFS_MAJOR(IRP_MJ_WRITE) \
\r
367 TRACEFS_MAJOR(IRP_MJ_QUERY_INFORMATION) \
\r
368 TRACEFS_MAJOR(IRP_MJ_SET_INFORMATION) \
\r
369 TRACEFS_MAJOR(IRP_MJ_QUERY_EA) \
\r
370 TRACEFS_MAJOR(IRP_MJ_SET_EA) \
\r
371 TRACEFS_MAJOR(IRP_MJ_FLUSH_BUFFERS) \
\r
372 TRACEFS_MAJOR(IRP_MJ_QUERY_VOLUME_INFORMATION) \
\r
373 TRACEFS_MAJOR(IRP_MJ_SET_VOLUME_INFORMATION) \
\r
374 TRACEFS_MAJOR(IRP_MJ_DIRECTORY_CONTROL) \
\r
375 TRACEFS_MAJOR(IRP_MJ_FILE_SYSTEM_CONTROL) \
\r
376 TRACEFS_MAJOR(IRP_MJ_DEVICE_CONTROL) \
\r
377 TRACEFS_MAJOR(IRP_MJ_INTERNAL_DEVICE_CONTROL) \
\r
378 TRACEFS_MAJOR(IRP_MJ_SHUTDOWN) \
\r
379 TRACEFS_MAJOR(IRP_MJ_LOCK_CONTROL) \
\r
380 TRACEFS_MAJOR(IRP_MJ_CLEANUP) \
\r
381 TRACEFS_MAJOR(IRP_MJ_CREATE_MAILSLOT) \
\r
382 TRACEFS_MAJOR(IRP_MJ_QUERY_SECURITY) \
\r
383 TRACEFS_MAJOR(IRP_MJ_SET_SECURITY) \
\r
384 TRACEFS_MAJOR(IRP_MJ_POWER) \
\r
385 TRACEFS_MAJOR(IRP_MJ_SYSTEM_CONTROL) \
\r
386 TRACEFS_MAJOR(IRP_MJ_DEVICE_CHANGE) \
\r
387 TRACEFS_MAJOR(IRP_MJ_QUERY_QUOTA) \
\r
388 TRACEFS_MAJOR(IRP_MJ_SET_QUOTA) \
\r
389 TRACEFS_MAJOR(IRP_MJ_PNP)
\r
392 #define TRACEFS_MAJOR(irp_mj_name) \
\r
393 static NTSTATUS (*tracefs_major_##irp_mj_name##_orig)(IN struct _DEVICE_OBJECT *DeviceObject,IN struct _IRP *Irp); \
\r
394 static NTSTATUS tracefs_major_##irp_mj_name(IN struct _DEVICE_OBJECT *DeviceObject,IN struct _IRP *Irp) \
\r
398 FILE_OBJECT *FileObject; \
\r
400 DBGSINGLEENTER0( #irp_mj_name ); \
\r
401 FileObject=dump_irp_mj(DeviceObject,Irp); \
\r
402 /* Prevent deadlock during display of File Explorer directory listing. \
\r
403 * Needed at least for IRP_MJ_DIRECTORY_CONTROL and IRP_MJ_CLOSE. \
\r
405 locked=unlock_full(); \
\r
406 r=(*tracefs_major_##irp_mj_name##_orig)(DeviceObject,Irp); \
\r
407 lock_full(locked); \
\r
408 /* Dump_irp_mj() would crash here even now IRP_MJ_READ; \
\r
409 * Invalid FileObject address gets detected. \
\r
411 dump_FileObject(FileObject); \
\r
412 DBGSINGLELEAVE1( #irp_mj_name ": r=0x%lX",(long)r); \
\r
418 #undef TRACEFS_MAJOR
\r
421 VOID IoRegisterFileSystem(IN OUT PDEVICE_OBJECT DeviceObject);
\r
422 VOID ToRegisterFileSystem(IN OUT PDEVICE_OBJECT DeviceObject)
\r
424 DBGSINGLEENTER0("IoRegisterFileSystem");
\r
426 #define TRACEFS_MAJOR(irp_mj_name) do { \
\r
427 tracefs_major_##irp_mj_name##_orig=DeviceObject->DriverObject->MajorFunction[irp_mj_name]; \
\r
428 DeviceObject->DriverObject->MajorFunction[irp_mj_name]=tracefs_major_##irp_mj_name; \
\r
433 #undef TRACEFS_MAJOR
\r
435 IoRegisterFileSystem(DeviceObject);
\r
436 DBGSINGLELEAVE0("IoRegisterFileSystem");
\r
440 static char PsCreateSystemThread_bogusthread;
\r
442 NTSTATUS TsCreateSystemThread(
\r
443 OUT PHANDLE ThreadHandle,
\r
444 IN ULONG DesiredAccess,
\r
445 IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
\r
446 IN HANDLE ProcessHandle OPTIONAL,
\r
447 OUT PCLIENT_ID ClientId OPTIONAL,
\r
448 IN PKSTART_ROUTINE StartRoutine,
\r
449 IN PVOID StartContext
\r
452 DBGSINGLEENTER1("PsCreateSystemThread: StartRoutine=0x%lX",(long)StartRoutine);
\r
454 *ThreadHandle=(HANDLE)&PsCreateSystemThread_bogusthread;
\r
455 DBGSINGLELEAVE0("PsCreateSystemThread");
\r
456 return STATUS_SUCCESS;
\r
465 DBGSINGLEENTER0("ZwClose");
\r
466 if (Handle==(HANDLE)&PsCreateSystemThread_bogusthread) {
\r
467 DBGSINGLELEAVE0("ZwClose: bogusthread catched");
\r
468 return STATUS_SUCCESS;
\r
470 DBGSINGLELEAVE0("ZwClose: passed");
\r
471 return ZwClose(Handle);
\r
477 IN PFILE_OBJECT FileObject,
\r
478 IN ULONG BytesToWrite,
\r
480 IN BOOLEAN Retrying
\r
484 IN PFILE_OBJECT FileObject,
\r
485 IN ULONG BytesToWrite,
\r
487 IN BOOLEAN Retrying
\r
492 DBGSINGLEENTER4("CcCanIWrite: FileObject=0x%lX,BytesToWrite=0x%lX,Wait=%d,Retrying=%d",
\r
493 (long)FileObject,BytesToWrite,Wait,Retrying);
\r
494 dump_FileObject(FileObject);
\r
501 DBGSINGLELEAVE1("CcCanIWrite: r=%d",r);
\r
507 IN PFILE_OBJECT FileObject,
\r
508 IN PLARGE_INTEGER FileOffset,
\r
512 OUT PIO_STATUS_BLOCK IoStatus
\r
516 IN PFILE_OBJECT FileObject,
\r
517 IN PLARGE_INTEGER FileOffset,
\r
521 OUT PIO_STATUS_BLOCK IoStatus
\r
526 DBGSINGLEENTER5("CcCopyRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Wait=%d,Buffer=0x%lX",
\r
527 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Wait,(long)Buffer);
\r
528 dump_FileObject(FileObject);
\r
537 DBGSINGLELEAVE3("CcCopyRead: r=%d,IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
538 r,(!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
544 IN PFILE_OBJECT FileObject,
\r
545 IN PLARGE_INTEGER FileOffset,
\r
552 IN PFILE_OBJECT FileObject,
\r
553 IN PLARGE_INTEGER FileOffset,
\r
561 DBGSINGLEENTER5("CcCopyWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Wait=%d,Buffer=0x%lX",
\r
562 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Wait,(long)Buffer);
\r
563 dump_FileObject(FileObject);
\r
571 DBGSINGLELEAVE1("CcCopyWrite: r=%d",r);
\r
576 VOID (*PCC_POST_DEFERRED_WRITE) (
\r
582 IN PFILE_OBJECT FileObject,
\r
583 IN PCC_POST_DEFERRED_WRITE PostRoutine,
\r
586 IN ULONG BytesToWrite,
\r
587 IN BOOLEAN Retrying
\r
590 IN PFILE_OBJECT FileObject,
\r
591 IN PCC_POST_DEFERRED_WRITE PostRoutine,
\r
594 IN ULONG BytesToWrite,
\r
595 IN BOOLEAN Retrying
\r
598 DBGSINGLEENTER6("CcDeferWrite: FileObject=0x%lX,PostRoutine=0x%lX,Context1=0x%lX,Context2=0x%lX,"
\r
599 "BytesToWrite=0x%lX,Retrying=%d",
\r
600 (long)FileObject,(long)PostRoutine,(long)Context1,(long)Context2,
\r
601 BytesToWrite,Retrying);
\r
602 dump_FileObject(FileObject);
\r
611 DBGSINGLELEAVE0("CcDeferWrite");
\r
616 IN PFILE_OBJECT FileObject,
\r
617 IN ULONG FileOffset,
\r
619 IN ULONG PageCount,
\r
621 OUT PIO_STATUS_BLOCK IoStatus
\r
625 IN PFILE_OBJECT FileObject,
\r
626 IN ULONG FileOffset,
\r
628 IN ULONG PageCount,
\r
630 OUT PIO_STATUS_BLOCK IoStatus
\r
633 DBGSINGLEENTER5("CcFastCopyRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,PageCount=0x%lX,Buffer=0x%lX",
\r
634 (long)FileObject,FileOffset,Length,PageCount,(long)Buffer);
\r
635 dump_FileObject(FileObject);
\r
644 DBGSINGLELEAVE2("CcFastCopyRead: IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
645 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
650 IN PFILE_OBJECT FileObject,
\r
651 IN ULONG FileOffset,
\r
657 IN PFILE_OBJECT FileObject,
\r
658 IN ULONG FileOffset,
\r
663 DBGSINGLEENTER4("CcFastCopyWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Buffer=0x%lX",
\r
664 (long)FileObject,FileOffset,Length,(long)Buffer);
\r
665 dump_FileObject(FileObject);
\r
672 DBGSINGLELEAVE0("CcFastCopyWrite");
\r
677 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
678 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
680 OUT PIO_STATUS_BLOCK IoStatus OPTIONAL
\r
684 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
685 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
687 OUT PIO_STATUS_BLOCK IoStatus OPTIONAL
\r
690 DBGSINGLEENTER4("CcFlushCache: SectionObjectPointer=0x%lX,->SharedCacheMap=0x%lX,FileOffset=0x%lX,Length=0x%lX",
\r
691 (long)SectionObjectPointer,
\r
692 (!SectionObjectPointer ? -1 : (long)SectionObjectPointer->SharedCacheMap),
\r
693 (!FileOffset ? -1 : (long)FileOffset->QuadPart),Length);
\r
694 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
696 SectionObjectPointer,
\r
701 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
702 DBGSINGLELEAVE2("CcFlushCache: IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
703 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
707 VOID (*PDIRTY_PAGE_ROUTINE) (
\r
708 IN PFILE_OBJECT FileObject,
\r
709 IN PLARGE_INTEGER FileOffset,
\r
711 IN PLARGE_INTEGER OldestLsn,
\r
712 IN PLARGE_INTEGER NewestLsn,
\r
717 static PDIRTY_PAGE_ROUTINE TcGetDirtyPages_DirtyPageRoutine_orig;
\r
718 static BOOLEAN TcGetDirtyPages_DirtyPageRoutine_used=FALSE;
\r
720 static VOID TcGetDirtyPages_DirtyPageRoutine(IN PFILE_OBJECT FileObject,IN PLARGE_INTEGER FileOffset,IN ULONG Length,
\r
721 IN PLARGE_INTEGER OldestLsn,IN PLARGE_INTEGER NewestLsn,IN PVOID Context1,IN PVOID Context2)
\r
723 DBGSINGLEENTER5("DirtyPageRoutine: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,"
\r
724 "OldestLsn=0x%lX,NewestLsn=0x%lX,Context1,Context2",
\r
725 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,
\r
726 (!OldestLsn ? -1 : (long)OldestLsn->QuadPart),(!NewestLsn ? -1 : (long)NewestLsn->QuadPart));
\r
727 dump_FileObject(FileObject);
\r
728 (*TcGetDirtyPages_DirtyPageRoutine_orig)(FileObject,FileOffset,Length,OldestLsn,NewestLsn,Context1,Context2);
\r
729 DBGSINGLELEAVE0("DirtyPageRoutine");
\r
734 IN PVOID LogHandle,
\r
735 IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
\r
741 IN PVOID LogHandle,
\r
742 IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
\r
749 DBGSINGLEENTER4("CcGetDirtyPages: LogHandle=0x%lX,DirtyPageRoutine=0x%lX,Context1=0x%lX,Context2=0x%lX",
\r
750 (long)LogHandle,(long)DirtyPageRoutine,(long)Context1,(long)Context2);
\r
751 if (TcGetDirtyPages_DirtyPageRoutine_used)
\r
752 DBGSINGLE0("CcGetDirtyPages: ERROR: TcGetDirtyPages_DirtyPageRoutine_used");
\r
754 TcGetDirtyPages_DirtyPageRoutine_used=TRUE;
\r
755 TcGetDirtyPages_DirtyPageRoutine_orig=DirtyPageRoutine;
\r
756 DirtyPageRoutine=TcGetDirtyPages_DirtyPageRoutine;
\r
758 r=CcGetDirtyPages (
\r
764 if (DirtyPageRoutine==TcGetDirtyPages_DirtyPageRoutine)
\r
765 TcGetDirtyPages_DirtyPageRoutine_used=FALSE;
\r
766 DBGSINGLELEAVE1("CcGetDirtyPages: r=0x%lX",(long)r.QuadPart);
\r
770 typedef BOOLEAN (*PACQUIRE_FOR_LAZY_WRITE)(IN PVOID Context,IN BOOLEAN Wait);
\r
771 typedef VOID (*PRELEASE_FROM_LAZY_WRITE)(IN PVOID Context);
\r
772 typedef BOOLEAN (*PACQUIRE_FOR_READ_AHEAD)(IN PVOID Context,IN BOOLEAN Wait);
\r
773 typedef VOID (*PRELEASE_FROM_READ_AHEAD)(IN PVOID Context);
\r
774 typedef struct _CACHE_MANAGER_CALLBACKS {
\r
775 PACQUIRE_FOR_LAZY_WRITE AcquireForLazyWrite;
\r
776 PRELEASE_FROM_LAZY_WRITE ReleaseFromLazyWrite;
\r
777 PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead;
\r
778 PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead;
\r
779 } CACHE_MANAGER_CALLBACKS,*PCACHE_MANAGER_CALLBACKS;
\r
781 static struct Callbacks {
\r
782 FILE_OBJECT *FileObject;
\r
783 CACHE_MANAGER_CALLBACKS Callbacks;
\r
784 PVOID LazyWriteContext;
\r
785 } Callbacks_cache[CACHE_SIZE];
\r
786 static int Callbacks_cache_used=0;
\r
788 static struct Callbacks *Callbacks_set(FILE_OBJECT *FileObject,CACHE_MANAGER_CALLBACKS *Callbacks,PVOID LazyWriteContext)
\r
790 struct Callbacks *callbacksp;
\r
792 for (callbacksp=Callbacks_cache;callbacksp<Callbacks_cache+Callbacks_cache_used;callbacksp++) {
\r
793 if (callbacksp->FileObject==FileObject)
\r
796 if (callbacksp>=Callbacks_cache+G_N_ELEMENTS(Callbacks_cache))
\r
798 if (callbacksp==Callbacks_cache+Callbacks_cache_used)
\r
799 Callbacks_cache_used++;
\r
800 callbacksp->FileObject=FileObject;
\r
801 callbacksp->Callbacks=*Callbacks;
\r
802 callbacksp->LazyWriteContext=LazyWriteContext;
\r
806 static BOOLEAN TcInitializeCacheMap_AcquireForLazyWrite(IN PVOID Context,IN BOOLEAN Wait)
\r
808 struct Callbacks *callbacksp=Context;
\r
812 DBGSINGLEENTER3("AcquireForLazyWrite: FileObject=0x%lX,Context=0x%lX,Wait=%d",
\r
813 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext,Wait);
\r
814 dump_FileObject(callbacksp->FileObject);
\r
815 /* Prevent deadlock during File Explorer copy to our destination. */
\r
816 locked=unlock_full();
\r
817 r=(*callbacksp->Callbacks.AcquireForLazyWrite)(callbacksp->LazyWriteContext,Wait);
\r
819 DBGSINGLELEAVE1("AcquireForLazyWrite: r=%d",r);
\r
823 static VOID TcInitializeCacheMap_ReleaseFromLazyWrite(IN PVOID Context)
\r
825 struct Callbacks *callbacksp=Context;
\r
828 DBGSINGLEENTER2("ReleaseFromLazyWrite: FileObject=0x%lX,Context=0x%lX",
\r
829 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext);
\r
830 dump_FileObject(callbacksp->FileObject);
\r
831 /* Prevent deadlock during File Explorer copy to our destination. */
\r
832 locked=unlock_full();
\r
833 (*callbacksp->Callbacks.ReleaseFromLazyWrite)(callbacksp->LazyWriteContext);
\r
835 DBGSINGLELEAVE0("ReleaseFromLazyWrite");
\r
838 static BOOLEAN TcInitializeCacheMap_AcquireForReadAhead(IN PVOID Context,IN BOOLEAN Wait)
\r
840 struct Callbacks *callbacksp=Context;
\r
844 DBGSINGLEENTER3("AcquireForReadAhead: FileObject=0x%lX,Context=0x%lX,Wait=%d",
\r
845 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext,Wait);
\r
846 dump_FileObject(callbacksp->FileObject);
\r
847 /* Prevent deadlock during File Explorer copy to our destination. */
\r
848 locked=unlock_full();
\r
849 r=(*callbacksp->Callbacks.AcquireForReadAhead)(callbacksp->LazyWriteContext,Wait);
\r
851 DBGSINGLELEAVE1("AcquireForReadAhead: r=%d",r);
\r
855 static VOID TcInitializeCacheMap_ReleaseFromReadAhead(IN PVOID Context)
\r
857 struct Callbacks *callbacksp=Context;
\r
860 DBGSINGLEENTER2("ReleaseFromReadAhead: FileObject=0x%lX,Context=0x%lX",
\r
861 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext);
\r
862 dump_FileObject(callbacksp->FileObject);
\r
863 /* Prevent deadlock during File Explorer copy to our destination. */
\r
864 locked=unlock_full();
\r
865 (*callbacksp->Callbacks.ReleaseFromReadAhead)(callbacksp->LazyWriteContext);
\r
867 DBGSINGLELEAVE0("ReleaseFromReadAhead");
\r
870 static CACHE_MANAGER_CALLBACKS TcInitializeCacheMap_Callbacks={
\r
871 TcInitializeCacheMap_AcquireForLazyWrite,
\r
872 TcInitializeCacheMap_ReleaseFromLazyWrite,
\r
873 TcInitializeCacheMap_AcquireForReadAhead,
\r
874 TcInitializeCacheMap_ReleaseFromReadAhead,
\r
877 typedef struct _CC_FILE_SIZES {
\r
878 LARGE_INTEGER AllocationSize;
\r
879 LARGE_INTEGER FileSize;
\r
880 LARGE_INTEGER ValidDataLength;
\r
881 } CC_FILE_SIZES,*PCC_FILE_SIZES;
\r
884 CcInitializeCacheMap (
\r
885 IN PFILE_OBJECT FileObject,
\r
886 IN PCC_FILE_SIZES FileSizes,
\r
887 IN BOOLEAN PinAccess,
\r
888 IN PCACHE_MANAGER_CALLBACKS Callbacks,
\r
889 IN PVOID LazyWriteContext
\r
892 TcInitializeCacheMap (
\r
893 IN PFILE_OBJECT FileObject,
\r
894 IN PCC_FILE_SIZES FileSizes,
\r
895 IN BOOLEAN PinAccess,
\r
896 IN PCACHE_MANAGER_CALLBACKS Callbacks,
\r
897 IN PVOID LazyWriteContext
\r
900 struct Callbacks *callbacksp;
\r
902 DBGSINGLEENTER5("CcInitializeCacheMap: FileObject=0x%lX,"
\r
903 "FileSizes,->AllocationSize=0x%lX,->FileSize=0x%lX,->ValidDataLength=0x%lX,"
\r
904 "PinAccess=%d,Callbacks,LazyWriteContext",
\r
906 (!FileSizes ? -1 : (long)FileSizes->AllocationSize.QuadPart),
\r
907 (!FileSizes ? -1 : (long)FileSizes->FileSize.QuadPart),
\r
908 (!FileSizes ? -1 : (long)FileSizes->ValidDataLength.QuadPart),
\r
910 dump_FileObject(FileObject);
\r
911 if ((callbacksp=Callbacks_set(FileObject,Callbacks,LazyWriteContext))) {
\r
912 Callbacks=&TcInitializeCacheMap_Callbacks;
\r
913 LazyWriteContext=callbacksp;
\r
914 if (Callbacks->AcquireForLazyWrite !=TcInitializeCacheMap_AcquireForLazyWrite)
\r
915 DBGSINGLE1("CcInitializeCacheMap: ERROR: AcquireForLazyWrite =0x%lX",Callbacks->AcquireForLazyWrite);
\r
916 if (Callbacks->ReleaseFromLazyWrite!=TcInitializeCacheMap_ReleaseFromLazyWrite)
\r
917 DBGSINGLE1("CcInitializeCacheMap: ERROR: ReleaseFromLazyWrite=0x%lX",Callbacks->ReleaseFromLazyWrite);
\r
918 if (Callbacks->AcquireForReadAhead !=TcInitializeCacheMap_AcquireForReadAhead)
\r
919 DBGSINGLE1("CcInitializeCacheMap: ERROR: AcquireForReadAhead =0x%lX",Callbacks->AcquireForReadAhead);
\r
920 if (Callbacks->ReleaseFromReadAhead!=TcInitializeCacheMap_ReleaseFromReadAhead)
\r
921 DBGSINGLE1("CcInitializeCacheMap: ERROR: ReleaseFromReadAhead=0x%lX",Callbacks->ReleaseFromReadAhead);
\r
923 CcInitializeCacheMap (
\r
930 dump_FileObject(FileObject);
\r
931 DBGSINGLELEAVE0("CcInitializeCacheMap");
\r
936 IN PFILE_OBJECT FileObject,
\r
937 IN PLARGE_INTEGER FileOffset,
\r
945 IN PFILE_OBJECT FileObject,
\r
946 IN PLARGE_INTEGER FileOffset,
\r
955 DBGSINGLEENTER4("CcMapData: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Flags=0x%lX",
\r
956 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Flags);
\r
957 dump_FileObject(FileObject);
\r
966 DBGSINGLELEAVE3("CcMapData: r=%d,Bcb=0x%lX,Buffer=0x%lX",
\r
967 r,(!Bcb ? -1 : (long)*Bcb),(!Buffer ? -1 : (long)*Buffer));
\r
973 IN PFILE_OBJECT FileObject,
\r
974 IN PLARGE_INTEGER FileOffset,
\r
976 OUT PMDL *MdlChain,
\r
977 OUT PIO_STATUS_BLOCK IoStatus
\r
981 IN PFILE_OBJECT FileObject,
\r
982 IN PLARGE_INTEGER FileOffset,
\r
984 OUT PMDL *MdlChain,
\r
985 OUT PIO_STATUS_BLOCK IoStatus
\r
988 DBGSINGLEENTER3("CcMdlRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX",
\r
989 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length);
\r
990 dump_FileObject(FileObject);
\r
998 DBGSINGLELEAVE3("CcMdlRead: MdlChain=0x%lX,IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
999 (!MdlChain ? -1 : (long)*MdlChain),
\r
1000 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
1004 CcMdlReadComplete (
\r
1005 IN PFILE_OBJECT FileObject,
\r
1009 TcMdlReadComplete (
\r
1010 IN PFILE_OBJECT FileObject,
\r
1014 DBGSINGLEENTER2("CcMdlReadComplete: FileObject=0x%lX,MdlChain=0x%lX",
\r
1015 (long)FileObject,(long)MdlChain);
\r
1016 dump_FileObject(FileObject);
\r
1017 CcMdlReadComplete (
\r
1021 DBGSINGLELEAVE0("CcMdlReadComplete");
\r
1026 IN PFILE_OBJECT FileObject,
\r
1031 IN PFILE_OBJECT FileObject,
\r
1035 DBGSINGLEENTER2("CcMdlWriteAbort: FileObject=0x%lX,MdlChain=0x%lX",
\r
1036 (long)FileObject,(long)MdlChain);
\r
1037 dump_FileObject(FileObject);
\r
1042 DBGSINGLELEAVE0("CcMdlWriteAbort");
\r
1046 CcMdlWriteComplete (
\r
1047 IN PFILE_OBJECT FileObject,
\r
1048 IN PLARGE_INTEGER FileOffset,
\r
1052 TcMdlWriteComplete (
\r
1053 IN PFILE_OBJECT FileObject,
\r
1054 IN PLARGE_INTEGER FileOffset,
\r
1058 DBGSINGLEENTER3("CcMdlWriteComplete: FileObject=0x%lX,FileOffset=0x%lX,MdlChain=0x%lX",
\r
1059 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),(long)MdlChain);
\r
1060 dump_FileObject(FileObject);
\r
1061 CcMdlWriteComplete (
\r
1066 DBGSINGLELEAVE0("CcMdlWriteComplete");
\r
1071 IN PFILE_OBJECT FileObject,
\r
1072 IN PLARGE_INTEGER FileOffset,
\r
1079 IN PFILE_OBJECT FileObject,
\r
1080 IN PLARGE_INTEGER FileOffset,
\r
1088 DBGSINGLEENTER4("CcPinMappedData: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Flags=0x%lX",
\r
1089 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Flags);
\r
1090 dump_FileObject(FileObject);
\r
1091 r=CcPinMappedData (
\r
1098 DBGSINGLELEAVE2("CcPinMappedData: r=%d,Bcb=0x%lX",
\r
1099 r,(!Bcb ? -1 : (long)*Bcb));
\r
1105 IN PFILE_OBJECT FileObject,
\r
1106 IN PLARGE_INTEGER FileOffset,
\r
1114 IN PFILE_OBJECT FileObject,
\r
1115 IN PLARGE_INTEGER FileOffset,
\r
1124 DBGSINGLEENTER4("CcPinRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Flags=0x%lX",
\r
1125 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Flags);
\r
1126 dump_FileObject(FileObject);
\r
1135 DBGSINGLELEAVE3("CcPinRead: r=%d,Bcb=0x%lX,Buffer=0x%lX",
\r
1136 r,(!Bcb ? -1 : (long)*Bcb),(!Buffer ? -1 : (long)*Buffer));
\r
1141 CcPrepareMdlWrite (
\r
1142 IN PFILE_OBJECT FileObject,
\r
1143 IN PLARGE_INTEGER FileOffset,
\r
1145 OUT PMDL *MdlChain,
\r
1146 OUT PIO_STATUS_BLOCK IoStatus
\r
1149 TcPrepareMdlWrite (
\r
1150 IN PFILE_OBJECT FileObject,
\r
1151 IN PLARGE_INTEGER FileOffset,
\r
1153 OUT PMDL *MdlChain,
\r
1154 OUT PIO_STATUS_BLOCK IoStatus
\r
1157 DBGSINGLEENTER3("CcPrepareMdlWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX",
\r
1158 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length);
\r
1159 dump_FileObject(FileObject);
\r
1160 CcPrepareMdlWrite (
\r
1167 DBGSINGLELEAVE3("CcPrepareMdlWrite: MdlChain=0x%lX,IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
1168 (!MdlChain ? -1 : (long)*MdlChain),
\r
1169 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
1173 CcPreparePinWrite (
\r
1174 IN PFILE_OBJECT FileObject,
\r
1175 IN PLARGE_INTEGER FileOffset,
\r
1183 TcPreparePinWrite (
\r
1184 IN PFILE_OBJECT FileObject,
\r
1185 IN PLARGE_INTEGER FileOffset,
\r
1195 DBGSINGLEENTER5("CcPreparePinWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Zero=%d,Flags=0x%lX",
\r
1196 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Zero,Flags);
\r
1197 dump_FileObject(FileObject);
\r
1198 r=CcPreparePinWrite (
\r
1207 DBGSINGLELEAVE3("CcPreparePinWrite: r=%d,Bcb=0x%lX,Buffer=0x%lX",
\r
1208 r,(!Bcb ? -1 : (long)*Bcb),(!Buffer ? -1 : (long)*Buffer));
\r
1213 CcPurgeCacheSection (
\r
1214 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
1215 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
1217 IN BOOLEAN UninitializeCacheMaps
\r
1220 TcPurgeCacheSection (
\r
1221 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
1222 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
1224 IN BOOLEAN UninitializeCacheMaps
\r
1229 DBGSINGLEENTER5("CcPurgeCacheSection: SectionObjectPointer=0x%lX,->SharedCacheMap=0x%lX,FileOffset=0x%lX,Length=0x%lX,"
\r
1230 "UninitializeCacheMaps=%d",
\r
1231 (long)SectionObjectPointer,
\r
1232 (!SectionObjectPointer ? -1 : (long)SectionObjectPointer->SharedCacheMap),
\r
1233 (!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,
\r
1234 UninitializeCacheMaps);
\r
1235 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
1236 r=CcPurgeCacheSection (
\r
1237 SectionObjectPointer,
\r
1240 UninitializeCacheMaps
\r
1242 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
1243 DBGSINGLELEAVE1("CcPurgeCacheSection: r=%d",r);
\r
1258 DBGSINGLEENTER1("CcRemapBcb: Bcb=0x%lX",(long)Bcb);
\r
1262 DBGSINGLELEAVE1("CcRemapBcb: r=0x%lX",(long)r);
\r
1267 CcSetAdditionalCacheAttributes (
\r
1268 IN PFILE_OBJECT FileObject,
\r
1269 IN BOOLEAN DisableReadAhead,
\r
1270 IN BOOLEAN DisableWriteBehind
\r
1273 TcSetAdditionalCacheAttributes (
\r
1274 IN PFILE_OBJECT FileObject,
\r
1275 IN BOOLEAN DisableReadAhead,
\r
1276 IN BOOLEAN DisableWriteBehind
\r
1279 DBGSINGLEENTER3("CcSetAdditionalCacheAttributes: FileObject=0x%lX,DisableReadAhead=%d,DisableWriteBehind=%d",
\r
1280 (long)FileObject,DisableReadAhead,DisableWriteBehind);
\r
1281 dump_FileObject(FileObject);
\r
1282 CcSetAdditionalCacheAttributes (
\r
1285 DisableWriteBehind
\r
1287 DBGSINGLELEAVE0("CcSetAdditionalCacheAttributes");
\r
1291 CcSetBcbOwnerPointer (
\r
1293 IN PVOID OwnerPointer
\r
1296 TcSetBcbOwnerPointer (
\r
1298 IN PVOID OwnerPointer
\r
1301 DBGSINGLEENTER2("CcSetBcbOwnerPointer: Bcb=0x%lX,OwnerPointer=0x%lX",
\r
1302 (long)Bcb,(long)OwnerPointer);
\r
1303 CcSetBcbOwnerPointer (
\r
1307 DBGSINGLELEAVE0("CcSetBcbOwnerPointer");
\r
1311 CcSetDirtyPinnedData (
\r
1313 IN PLARGE_INTEGER Lsn OPTIONAL
\r
1316 TcSetDirtyPinnedData (
\r
1318 IN PLARGE_INTEGER Lsn OPTIONAL
\r
1321 DBGSINGLEENTER2("CcSetDirtyPinnedData: BcbVoid=0x%lX,Lsn=0x%lX",
\r
1322 (long)BcbVoid,(!Lsn ? -1 : (long)Lsn->QuadPart));
\r
1323 CcSetDirtyPinnedData (
\r
1327 DBGSINGLELEAVE0("CcSetDirtyPinnedData");
\r
1332 IN PFILE_OBJECT FileObject,
\r
1333 IN PCC_FILE_SIZES FileSizes
\r
1337 IN PFILE_OBJECT FileObject,
\r
1338 IN PCC_FILE_SIZES FileSizes
\r
1341 DBGSINGLEENTER4("CcSetFileSizes: FileObject=0x%lX,"
\r
1342 "FileSizes,->AllocationSize=0x%lX,->FileSize=0x%lX,->ValidDataLength=0x%lX",
\r
1344 (!FileSizes ? -1 : (long)FileSizes->AllocationSize.QuadPart),
\r
1345 (!FileSizes ? -1 : (long)FileSizes->FileSize.QuadPart),
\r
1346 (!FileSizes ? -1 : (long)FileSizes->ValidDataLength.QuadPart));
\r
1347 dump_FileObject(FileObject);
\r
1352 DBGSINGLELEAVE0("CcSetFileSizes");
\r
1355 typedef VOID (*PFLUSH_TO_LSN)(IN PVOID LogHandle,IN LARGE_INTEGER Lsn);
\r
1357 static struct LogHandle {
\r
1359 PFLUSH_TO_LSN FlushToLsnRoutine;
\r
1360 } LogHandle_cache[CACHE_SIZE];
\r
1361 static int LogHandle_cache_used=0;
\r
1363 static BOOLEAN LogHandle_set(PVOID LogHandle,PFLUSH_TO_LSN FlushToLsnRoutine)
\r
1365 struct LogHandle *loghandlep;
\r
1367 for (loghandlep=LogHandle_cache;loghandlep<LogHandle_cache+LogHandle_cache_used;loghandlep++) {
\r
1368 if (loghandlep->LogHandle==LogHandle)
\r
1371 if (loghandlep>=LogHandle_cache+G_N_ELEMENTS(LogHandle_cache))
\r
1373 if (loghandlep==LogHandle_cache+LogHandle_cache_used)
\r
1374 LogHandle_cache_used++;
\r
1375 loghandlep->LogHandle=LogHandle;
\r
1376 loghandlep->FlushToLsnRoutine=FlushToLsnRoutine;
\r
1380 static PFLUSH_TO_LSN LogHandle_find(PVOID LogHandle)
\r
1382 struct LogHandle *loghandlep;
\r
1384 for (loghandlep=LogHandle_cache;loghandlep<LogHandle_cache+LogHandle_cache_used;loghandlep++) {
\r
1385 if (loghandlep->LogHandle==LogHandle)
\r
1386 return loghandlep->FlushToLsnRoutine;
\r
1391 static VOID TcSetLogHandleForFile_FlushToLsnRoutine(IN PVOID LogHandle,IN LARGE_INTEGER Lsn)
\r
1393 PFLUSH_TO_LSN FlushToLsnRoutine;
\r
1396 DBGSINGLEENTER2("FlushToLsnRoutine: LogHandle=0x%lX,Lsn=0x%lX",
\r
1397 (long)LogHandle,(long)Lsn.QuadPart);
\r
1398 /* Prevent deadlock during display of File Explorer directory listing. */
\r
1399 locked=unlock_full();
\r
1400 if ((FlushToLsnRoutine=LogHandle_find(LogHandle)))
\r
1401 (*FlushToLsnRoutine)(LogHandle,Lsn);
\r
1402 lock_full(locked);
\r
1403 DBGSINGLELEAVE0("FlushToLsnRoutine");
\r
1407 CcSetLogHandleForFile (
\r
1408 IN PFILE_OBJECT FileObject,
\r
1409 IN PVOID LogHandle,
\r
1410 IN PFLUSH_TO_LSN FlushToLsnRoutine
\r
1413 TcSetLogHandleForFile (
\r
1414 IN PFILE_OBJECT FileObject,
\r
1415 IN PVOID LogHandle,
\r
1416 IN PFLUSH_TO_LSN FlushToLsnRoutine
\r
1419 DBGSINGLEENTER3("CcSetLogHandleForFile: FileObject=0x%lX,LogHandle=0x%lX,FlushToLsnRoutine=0x%lX",
\r
1420 (long)FileObject,(long)LogHandle,(long)FlushToLsnRoutine);
\r
1421 dump_FileObject(FileObject);
\r
1422 if (LogHandle_set(LogHandle,FlushToLsnRoutine))
\r
1423 FlushToLsnRoutine=TcSetLogHandleForFile_FlushToLsnRoutine;
\r
1424 CcSetLogHandleForFile (
\r
1429 DBGSINGLELEAVE0("CcSetLogHandleForFile");
\r
1433 CcSetReadAheadGranularity (
\r
1434 IN PFILE_OBJECT FileObject,
\r
1435 IN ULONG Granularity
\r
1438 TcSetReadAheadGranularity (
\r
1439 IN PFILE_OBJECT FileObject,
\r
1440 IN ULONG Granularity
\r
1443 DBGSINGLEENTER2("CcSetReadAheadGranularity: FileObject=0x%lX,Granularity=0x%lX",
\r
1444 (long)FileObject,Granularity);
\r
1445 dump_FileObject(FileObject);
\r
1446 CcSetReadAheadGranularity (
\r
1450 DBGSINGLELEAVE0("CcSetReadAheadGranularity");
\r
1453 typedef struct _CACHE_UNINITIALIZE_EVENT {
\r
1454 struct _CACHE_UNINITIALIZE_EVENT *Next;
\r
1456 } CACHE_UNINITIALIZE_EVENT,*PCACHE_UNINITIALIZE_EVENT;
\r
1459 CcUninitializeCacheMap (
\r
1460 IN PFILE_OBJECT FileObject,
\r
1461 IN PLARGE_INTEGER TruncateSize OPTIONAL,
\r
1462 IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL
\r
1465 TcUninitializeCacheMap (
\r
1466 IN PFILE_OBJECT FileObject,
\r
1467 IN PLARGE_INTEGER TruncateSize OPTIONAL,
\r
1468 IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL
\r
1473 DBGSINGLEENTER3("CcUninitializeCacheMap: FileObject=0x%lX,TruncateSize=0x%lX,UninitializeCompleteEvent=0x%lX",
\r
1474 (long)FileObject,(!TruncateSize ? -1 : (long)TruncateSize->QuadPart),(long)UninitializeCompleteEvent);
\r
1475 dump_FileObject(FileObject);
\r
1476 r=CcUninitializeCacheMap (
\r
1479 UninitializeCompleteEvent
\r
1481 dump_FileObject(FileObject);
\r
1482 DBGSINGLELEAVE1("CcUninitializeCacheMap: r=%d",r);
\r
1495 DBGSINGLEENTER1("CcUnpinData: Bcb=0x%lX",(long)Bcb);
\r
1499 DBGSINGLELEAVE0("CcUnpinData");
\r
1503 CcUnpinDataForThread (
\r
1505 IN ERESOURCE_THREAD ResourceThreadId
\r
1508 TcUnpinDataForThread (
\r
1510 IN ERESOURCE_THREAD ResourceThreadId
\r
1513 DBGSINGLEENTER2("CcUnpinDataForThread: Bcb=0x%lX,ResourceThreadId=0x%lX",
\r
1514 (long)Bcb,(long)ResourceThreadId);
\r
1515 CcUnpinDataForThread (
\r
1519 DBGSINGLELEAVE0("CcUnpinDataForThread");
\r
1523 CcWaitForCurrentLazyWriterActivity (
\r
1527 TcWaitForCurrentLazyWriterActivity (
\r
1533 DBGSINGLEENTER0("CcWaitForCurrentLazyWriterActivity");
\r
1534 r=CcWaitForCurrentLazyWriterActivity (
\r
1536 DBGSINGLELEAVE1("CcWaitForCurrentLazyWriterActivity: r=0x%lX",r);
\r
1542 IN PFILE_OBJECT FileObject,
\r
1543 IN PLARGE_INTEGER StartOffset,
\r
1544 IN PLARGE_INTEGER EndOffset,
\r
1549 IN PFILE_OBJECT FileObject,
\r
1550 IN PLARGE_INTEGER StartOffset,
\r
1551 IN PLARGE_INTEGER EndOffset,
\r
1557 DBGSINGLEENTER4("CcZeroData: FileObject=0x%lX,StartOffset=0x%lX,EndOffset=0x%lX,Wait=%d",
\r
1559 (!StartOffset ? -1 : (long)StartOffset->QuadPart),
\r
1560 (!EndOffset ? -1 : (long)EndOffset->QuadPart),
\r
1562 dump_FileObject(FileObject);
\r
1569 DBGSINGLELEAVE1("CcZeroData: r=%d",r);
\r
1574 CcIsThereDirtyData (
\r
1578 TcIsThereDirtyData (
\r
1584 DBGSINGLEENTER1("CcIsThereDirtyData: Vpb=0x%lX",(long)Vpb);
\r
1585 r=CcIsThereDirtyData (
\r
1588 DBGSINGLELEAVE1("CcIsThereDirtyData: r=%d",r);
\r
1601 DBGSINGLEENTER1("CcRepinBcb: Bcb=0x%lX",(long)Bcb);
\r
1605 DBGSINGLELEAVE0("CcRepinBcb");
\r
1609 CcUnpinRepinnedBcb (
\r
1611 IN BOOLEAN WriteThrough,
\r
1612 OUT PIO_STATUS_BLOCK IoStatus
\r
1615 TcUnpinRepinnedBcb (
\r
1617 IN BOOLEAN WriteThrough,
\r
1618 OUT PIO_STATUS_BLOCK IoStatus
\r
1621 DBGSINGLEENTER2("CcUnpinRepinnedBcb: Bcb=0x%lX,WriteThrough=%d",
\r
1622 (long)Bcb,WriteThrough);
\r
1623 CcUnpinRepinnedBcb (
\r
1628 DBGSINGLELEAVE2("CcUnpinRepinnedBcb: IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
1629 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r