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 DBGSINGLE5("FileObject=0x%lX: FileName=%s,Flags=0x%lX,SectionObjectPointer=0x%lX,->SharedCacheMap=0x%lX",
\r
294 dbg_unicode_string(&FileObject->FileName),FileObject->Flags,
\r
295 (long)FileObject->SectionObjectPointer,
\r
296 (!FileObject->SectionObjectPointer ? -1 : (long)FileObject->SectionObjectPointer->SharedCacheMap));
\r
297 SectionObjectPointer_set(FileObject);
\r
300 static FILE_OBJECT *dump_irp_mj(struct _DEVICE_OBJECT *DeviceObject,struct _IRP *Irp)
\r
302 IO_STACK_LOCATION *IoStackLocation;
\r
303 FILE_OBJECT *FileObject;
\r
306 DBGSINGLE0("Irp==NULL");
\r
309 IoStackLocation=IoGetCurrentIrpStackLocation(Irp);
\r
310 if (!IoStackLocation) {
\r
311 DBGSINGLE0("IoStackLocation==NULL");
\r
314 FileObject=IoStackLocation->FileObject;
\r
315 dump_FileObject(FileObject);
\r
317 switch (IoStackLocation->MajorFunction) {
\r
319 DBGSINGLE2("READ: ByteOffset=0x%lX,Length=0x%lX",
\r
320 (long)IoStackLocation->Parameters.Read.ByteOffset.QuadPart,
\r
321 IoStackLocation->Parameters.Read.Length);
\r
324 DBGSINGLE2("WRITE: ByteOffset=0x%lX,Length=0x%lX",
\r
325 (long)IoStackLocation->Parameters.Write.ByteOffset.QuadPart,
\r
326 IoStackLocation->Parameters.Write.Length);
\r
328 case IRP_MJ_FILE_SYSTEM_CONTROL:
\r
329 DBGSINGLE2("FILE_SYSTEM_CONTROL: MinorFunction=%s (%0x%X)",
\r
331 && IoStackLocation->MinorFunction>=0
\r
332 && IoStackLocation->MinorFunction<G_N_ELEMENTS(dump_irp_mj_FILE_SYSTEM_CONTROL_MinorFunction_names))
\r
333 ? dump_irp_mj_FILE_SYSTEM_CONTROL_MinorFunction_names[IoStackLocation->MinorFunction] : "???"),
\r
334 IoStackLocation->MinorFunction);
\r
335 switch (IoStackLocation->MinorFunction) {
\r
336 case IRP_MN_USER_FS_REQUEST: {
\r
337 const char *FsControlCode_name;
\r
338 switch (IoStackLocation->Parameters.FileSystemControl.FsControlCode) {
\r
339 case FSCTL_REQUEST_BATCH_OPLOCK: FsControlCode_name="FSCTL_REQUEST_BATCH_OPLOCK"; break;
\r
340 case FSCTL_LOCK_VOLUME: FsControlCode_name="FSCTL_LOCK_VOLUME"; break;
\r
341 case FSCTL_UNLOCK_VOLUME: FsControlCode_name="FSCTL_UNLOCK_VOLUME"; break;
\r
342 case FSCTL_DISMOUNT_VOLUME: FsControlCode_name="FSCTL_DISMOUNT_VOLUME"; break;
\r
343 case FSCTL_MARK_VOLUME_DIRTY: FsControlCode_name="FSCTL_MARK_VOLUME_DIRTY"; break;
\r
344 case FSCTL_SET_COMPRESSION: FsControlCode_name="FSCTL_SET_COMPRESSION"; break;
\r
345 case FSCTL_INVALIDATE_VOLUMES: FsControlCode_name="FSCTL_INVALIDATE_VOLUMES"; break;
\r
346 case FSCTL_IS_VOLUME_DIRTY: FsControlCode_name="FSCTL_IS_VOLUME_DIRTY"; break;
\r
347 case FSCTL_FILE_PREFETCH: FsControlCode_name="FSCTL_FILE_PREFETCH"; break;
\r
348 default: FsControlCode_name="???"; break;
\r
350 DBGSINGLE2("USER_FS_REQUEST: FsControlCode=%s (0x%X)",FsControlCode_name,
\r
351 IoStackLocation->Parameters.FileSystemControl.FsControlCode);
\r
359 #define TRACEFS_MAJORS \
\r
360 TRACEFS_MAJOR(IRP_MJ_CREATE) \
\r
361 TRACEFS_MAJOR(IRP_MJ_CREATE_NAMED_PIPE) \
\r
362 TRACEFS_MAJOR(IRP_MJ_CLOSE) \
\r
363 TRACEFS_MAJOR(IRP_MJ_READ) \
\r
364 TRACEFS_MAJOR(IRP_MJ_WRITE) \
\r
365 TRACEFS_MAJOR(IRP_MJ_QUERY_INFORMATION) \
\r
366 TRACEFS_MAJOR(IRP_MJ_SET_INFORMATION) \
\r
367 TRACEFS_MAJOR(IRP_MJ_QUERY_EA) \
\r
368 TRACEFS_MAJOR(IRP_MJ_SET_EA) \
\r
369 TRACEFS_MAJOR(IRP_MJ_FLUSH_BUFFERS) \
\r
370 TRACEFS_MAJOR(IRP_MJ_QUERY_VOLUME_INFORMATION) \
\r
371 TRACEFS_MAJOR(IRP_MJ_SET_VOLUME_INFORMATION) \
\r
372 TRACEFS_MAJOR(IRP_MJ_DIRECTORY_CONTROL) \
\r
373 TRACEFS_MAJOR(IRP_MJ_FILE_SYSTEM_CONTROL) \
\r
374 TRACEFS_MAJOR(IRP_MJ_DEVICE_CONTROL) \
\r
375 TRACEFS_MAJOR(IRP_MJ_INTERNAL_DEVICE_CONTROL) \
\r
376 TRACEFS_MAJOR(IRP_MJ_SHUTDOWN) \
\r
377 TRACEFS_MAJOR(IRP_MJ_LOCK_CONTROL) \
\r
378 TRACEFS_MAJOR(IRP_MJ_CLEANUP) \
\r
379 TRACEFS_MAJOR(IRP_MJ_CREATE_MAILSLOT) \
\r
380 TRACEFS_MAJOR(IRP_MJ_QUERY_SECURITY) \
\r
381 TRACEFS_MAJOR(IRP_MJ_SET_SECURITY) \
\r
382 TRACEFS_MAJOR(IRP_MJ_POWER) \
\r
383 TRACEFS_MAJOR(IRP_MJ_SYSTEM_CONTROL) \
\r
384 TRACEFS_MAJOR(IRP_MJ_DEVICE_CHANGE) \
\r
385 TRACEFS_MAJOR(IRP_MJ_QUERY_QUOTA) \
\r
386 TRACEFS_MAJOR(IRP_MJ_SET_QUOTA) \
\r
387 TRACEFS_MAJOR(IRP_MJ_PNP)
\r
390 #define TRACEFS_MAJOR(irp_mj_name) \
\r
391 static NTSTATUS (*tracefs_major_##irp_mj_name##_orig)(IN struct _DEVICE_OBJECT *DeviceObject,IN struct _IRP *Irp); \
\r
392 static NTSTATUS tracefs_major_##irp_mj_name(IN struct _DEVICE_OBJECT *DeviceObject,IN struct _IRP *Irp) \
\r
396 FILE_OBJECT *FileObject; \
\r
398 DBGSINGLEENTER0( #irp_mj_name ); \
\r
399 FileObject=dump_irp_mj(DeviceObject,Irp); \
\r
400 /* Prevent deadlock during display of File Explorer directory listing. \
\r
401 * Needed at least for IRP_MJ_DIRECTORY_CONTROL and IRP_MJ_CLOSE. \
\r
403 locked=unlock_full(); \
\r
404 r=(*tracefs_major_##irp_mj_name##_orig)(DeviceObject,Irp); \
\r
405 lock_full(locked); \
\r
406 /* Dump_irp_mj() would crash here even now IRP_MJ_READ; \
\r
407 * Invalid FileObject address gets detected. \
\r
409 dump_FileObject(FileObject); \
\r
410 DBGSINGLELEAVE1( #irp_mj_name ": r=0x%lX",(long)r); \
\r
416 #undef TRACEFS_MAJOR
\r
419 VOID IoRegisterFileSystem(IN OUT PDEVICE_OBJECT DeviceObject);
\r
420 VOID ToRegisterFileSystem(IN OUT PDEVICE_OBJECT DeviceObject)
\r
422 DBGSINGLEENTER0("IoRegisterFileSystem");
\r
424 #define TRACEFS_MAJOR(irp_mj_name) do { \
\r
425 tracefs_major_##irp_mj_name##_orig=DeviceObject->DriverObject->MajorFunction[irp_mj_name]; \
\r
426 DeviceObject->DriverObject->MajorFunction[irp_mj_name]=tracefs_major_##irp_mj_name; \
\r
431 #undef TRACEFS_MAJOR
\r
433 IoRegisterFileSystem(DeviceObject);
\r
434 DBGSINGLELEAVE0("IoRegisterFileSystem");
\r
438 static char PsCreateSystemThread_bogusthread;
\r
440 NTSTATUS TsCreateSystemThread(
\r
441 OUT PHANDLE ThreadHandle,
\r
442 IN ULONG DesiredAccess,
\r
443 IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
\r
444 IN HANDLE ProcessHandle OPTIONAL,
\r
445 OUT PCLIENT_ID ClientId OPTIONAL,
\r
446 IN PKSTART_ROUTINE StartRoutine,
\r
447 IN PVOID StartContext
\r
450 DBGSINGLEENTER1("PsCreateSystemThread: StartRoutine=0x%lX",(long)StartRoutine);
\r
452 *ThreadHandle=(HANDLE)&PsCreateSystemThread_bogusthread;
\r
453 DBGSINGLELEAVE0("PsCreateSystemThread");
\r
454 return STATUS_SUCCESS;
\r
463 DBGSINGLEENTER0("ZwClose");
\r
464 if (Handle==(HANDLE)&PsCreateSystemThread_bogusthread) {
\r
465 DBGSINGLELEAVE0("ZwClose: bogusthread catched");
\r
466 return STATUS_SUCCESS;
\r
468 DBGSINGLELEAVE0("ZwClose: passed");
\r
469 return ZwClose(Handle);
\r
475 IN PFILE_OBJECT FileObject,
\r
476 IN ULONG BytesToWrite,
\r
478 IN BOOLEAN Retrying
\r
482 IN PFILE_OBJECT FileObject,
\r
483 IN ULONG BytesToWrite,
\r
485 IN BOOLEAN Retrying
\r
490 DBGSINGLEENTER4("CcCanIWrite: FileObject=0x%lX,BytesToWrite=0x%lX,Wait=%d,Retrying=%d",
\r
491 (long)FileObject,BytesToWrite,Wait,Retrying);
\r
492 dump_FileObject(FileObject);
\r
499 DBGSINGLELEAVE1("CcCanIWrite: r=%d",r);
\r
505 IN PFILE_OBJECT FileObject,
\r
506 IN PLARGE_INTEGER FileOffset,
\r
510 OUT PIO_STATUS_BLOCK IoStatus
\r
514 IN PFILE_OBJECT FileObject,
\r
515 IN PLARGE_INTEGER FileOffset,
\r
519 OUT PIO_STATUS_BLOCK IoStatus
\r
524 DBGSINGLEENTER5("CcCopyRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Wait=%d,Buffer=0x%lX",
\r
525 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Wait,(long)Buffer);
\r
526 dump_FileObject(FileObject);
\r
535 DBGSINGLELEAVE3("CcCopyRead: r=%d,IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
536 r,(!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
542 IN PFILE_OBJECT FileObject,
\r
543 IN PLARGE_INTEGER FileOffset,
\r
550 IN PFILE_OBJECT FileObject,
\r
551 IN PLARGE_INTEGER FileOffset,
\r
559 DBGSINGLEENTER5("CcCopyWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Wait=%d,Buffer=0x%lX",
\r
560 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Wait,(long)Buffer);
\r
561 dump_FileObject(FileObject);
\r
569 DBGSINGLELEAVE1("CcCopyWrite: r=%d",r);
\r
574 VOID (*PCC_POST_DEFERRED_WRITE) (
\r
580 IN PFILE_OBJECT FileObject,
\r
581 IN PCC_POST_DEFERRED_WRITE PostRoutine,
\r
584 IN ULONG BytesToWrite,
\r
585 IN BOOLEAN Retrying
\r
588 IN PFILE_OBJECT FileObject,
\r
589 IN PCC_POST_DEFERRED_WRITE PostRoutine,
\r
592 IN ULONG BytesToWrite,
\r
593 IN BOOLEAN Retrying
\r
596 DBGSINGLEENTER6("CcDeferWrite: FileObject=0x%lX,PostRoutine=0x%lX,Context1=0x%lX,Context2=0x%lX,"
\r
597 "BytesToWrite=0x%lX,Retrying=%d",
\r
598 (long)FileObject,(long)PostRoutine,(long)Context1,(long)Context2,
\r
599 BytesToWrite,Retrying);
\r
600 dump_FileObject(FileObject);
\r
609 DBGSINGLELEAVE0("CcDeferWrite");
\r
614 IN PFILE_OBJECT FileObject,
\r
615 IN ULONG FileOffset,
\r
617 IN ULONG PageCount,
\r
619 OUT PIO_STATUS_BLOCK IoStatus
\r
623 IN PFILE_OBJECT FileObject,
\r
624 IN ULONG FileOffset,
\r
626 IN ULONG PageCount,
\r
628 OUT PIO_STATUS_BLOCK IoStatus
\r
631 DBGSINGLEENTER5("CcFastCopyRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,PageCount=0x%lX,Buffer=0x%lX",
\r
632 (long)FileObject,FileOffset,Length,PageCount,(long)Buffer);
\r
633 dump_FileObject(FileObject);
\r
642 DBGSINGLELEAVE2("CcFastCopyRead: IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
643 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
648 IN PFILE_OBJECT FileObject,
\r
649 IN ULONG FileOffset,
\r
655 IN PFILE_OBJECT FileObject,
\r
656 IN ULONG FileOffset,
\r
661 DBGSINGLEENTER4("CcFastCopyWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Buffer=0x%lX",
\r
662 (long)FileObject,FileOffset,Length,(long)Buffer);
\r
663 dump_FileObject(FileObject);
\r
670 DBGSINGLELEAVE0("CcFastCopyWrite");
\r
675 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
676 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
678 OUT PIO_STATUS_BLOCK IoStatus OPTIONAL
\r
682 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
683 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
685 OUT PIO_STATUS_BLOCK IoStatus OPTIONAL
\r
688 DBGSINGLEENTER4("CcFlushCache: SectionObjectPointer=0x%lX,->SharedCacheMap=0x%lX,FileOffset=0x%lX,Length=0x%lX",
\r
689 (long)SectionObjectPointer,
\r
690 (!SectionObjectPointer ? -1 : (long)SectionObjectPointer->SharedCacheMap),
\r
691 (!FileOffset ? -1 : (long)FileOffset->QuadPart),Length);
\r
692 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
694 SectionObjectPointer,
\r
699 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
700 DBGSINGLELEAVE2("CcFlushCache: IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
701 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
705 VOID (*PDIRTY_PAGE_ROUTINE) (
\r
706 IN PFILE_OBJECT FileObject,
\r
707 IN PLARGE_INTEGER FileOffset,
\r
709 IN PLARGE_INTEGER OldestLsn,
\r
710 IN PLARGE_INTEGER NewestLsn,
\r
715 static PDIRTY_PAGE_ROUTINE TcGetDirtyPages_DirtyPageRoutine_orig;
\r
716 static BOOLEAN TcGetDirtyPages_DirtyPageRoutine_used=FALSE;
\r
718 static VOID TcGetDirtyPages_DirtyPageRoutine(IN PFILE_OBJECT FileObject,IN PLARGE_INTEGER FileOffset,IN ULONG Length,
\r
719 IN PLARGE_INTEGER OldestLsn,IN PLARGE_INTEGER NewestLsn,IN PVOID Context1,IN PVOID Context2)
\r
721 DBGSINGLEENTER5("DirtyPageRoutine: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,"
\r
722 "OldestLsn=0x%lX,NewestLsn=0x%lX,Context1,Context2",
\r
723 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,
\r
724 (!OldestLsn ? -1 : (long)OldestLsn->QuadPart),(!NewestLsn ? -1 : (long)NewestLsn->QuadPart));
\r
725 dump_FileObject(FileObject);
\r
726 (*TcGetDirtyPages_DirtyPageRoutine_orig)(FileObject,FileOffset,Length,OldestLsn,NewestLsn,Context1,Context2);
\r
727 DBGSINGLELEAVE0("DirtyPageRoutine");
\r
732 IN PVOID LogHandle,
\r
733 IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
\r
739 IN PVOID LogHandle,
\r
740 IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,
\r
747 DBGSINGLEENTER4("CcGetDirtyPages: LogHandle=0x%lX,DirtyPageRoutine=0x%lX,Context1=0x%lX,Context2=0x%lX",
\r
748 (long)LogHandle,(long)DirtyPageRoutine,(long)Context1,(long)Context2);
\r
749 if (TcGetDirtyPages_DirtyPageRoutine_used)
\r
750 DBGSINGLE0("CcGetDirtyPages: ERROR: TcGetDirtyPages_DirtyPageRoutine_used");
\r
752 TcGetDirtyPages_DirtyPageRoutine_used=TRUE;
\r
753 TcGetDirtyPages_DirtyPageRoutine_orig=DirtyPageRoutine;
\r
754 DirtyPageRoutine=TcGetDirtyPages_DirtyPageRoutine;
\r
756 r=CcGetDirtyPages (
\r
762 if (DirtyPageRoutine==TcGetDirtyPages_DirtyPageRoutine)
\r
763 TcGetDirtyPages_DirtyPageRoutine_used=FALSE;
\r
764 DBGSINGLELEAVE1("CcGetDirtyPages: r=0x%lX",(long)r.QuadPart);
\r
768 typedef BOOLEAN (*PACQUIRE_FOR_LAZY_WRITE)(IN PVOID Context,IN BOOLEAN Wait);
\r
769 typedef VOID (*PRELEASE_FROM_LAZY_WRITE)(IN PVOID Context);
\r
770 typedef BOOLEAN (*PACQUIRE_FOR_READ_AHEAD)(IN PVOID Context,IN BOOLEAN Wait);
\r
771 typedef VOID (*PRELEASE_FROM_READ_AHEAD)(IN PVOID Context);
\r
772 typedef struct _CACHE_MANAGER_CALLBACKS {
\r
773 PACQUIRE_FOR_LAZY_WRITE AcquireForLazyWrite;
\r
774 PRELEASE_FROM_LAZY_WRITE ReleaseFromLazyWrite;
\r
775 PACQUIRE_FOR_READ_AHEAD AcquireForReadAhead;
\r
776 PRELEASE_FROM_READ_AHEAD ReleaseFromReadAhead;
\r
777 } CACHE_MANAGER_CALLBACKS,*PCACHE_MANAGER_CALLBACKS;
\r
779 static struct Callbacks {
\r
780 FILE_OBJECT *FileObject;
\r
781 CACHE_MANAGER_CALLBACKS Callbacks;
\r
782 PVOID LazyWriteContext;
\r
783 } Callbacks_cache[CACHE_SIZE];
\r
784 static int Callbacks_cache_used=0;
\r
786 static struct Callbacks *Callbacks_set(FILE_OBJECT *FileObject,CACHE_MANAGER_CALLBACKS *Callbacks,PVOID LazyWriteContext)
\r
788 struct Callbacks *callbacksp;
\r
790 for (callbacksp=Callbacks_cache;callbacksp<Callbacks_cache+Callbacks_cache_used;callbacksp++) {
\r
791 if (callbacksp->FileObject==FileObject)
\r
794 if (callbacksp>=Callbacks_cache+G_N_ELEMENTS(Callbacks_cache))
\r
796 if (callbacksp==Callbacks_cache+Callbacks_cache_used)
\r
797 Callbacks_cache_used++;
\r
798 callbacksp->FileObject=FileObject;
\r
799 callbacksp->Callbacks=*Callbacks;
\r
800 callbacksp->LazyWriteContext=LazyWriteContext;
\r
804 static BOOLEAN TcInitializeCacheMap_AcquireForLazyWrite(IN PVOID Context,IN BOOLEAN Wait)
\r
806 struct Callbacks *callbacksp=Context;
\r
810 DBGSINGLEENTER3("AcquireForLazyWrite: FileObject=0x%lX,Context=0x%lX,Wait=%d",
\r
811 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext,Wait);
\r
812 dump_FileObject(callbacksp->FileObject);
\r
813 /* Prevent deadlock during File Explorer copy to our destination. */
\r
814 locked=unlock_full();
\r
815 r=(*callbacksp->Callbacks.AcquireForLazyWrite)(callbacksp->LazyWriteContext,Wait);
\r
817 DBGSINGLELEAVE1("AcquireForLazyWrite: r=%d",r);
\r
821 static VOID TcInitializeCacheMap_ReleaseFromLazyWrite(IN PVOID Context)
\r
823 struct Callbacks *callbacksp=Context;
\r
826 DBGSINGLEENTER2("ReleaseFromLazyWrite: FileObject=0x%lX,Context=0x%lX",
\r
827 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext);
\r
828 dump_FileObject(callbacksp->FileObject);
\r
829 /* Prevent deadlock during File Explorer copy to our destination. */
\r
830 locked=unlock_full();
\r
831 (*callbacksp->Callbacks.ReleaseFromLazyWrite)(callbacksp->LazyWriteContext);
\r
833 DBGSINGLELEAVE0("ReleaseFromLazyWrite");
\r
836 static BOOLEAN TcInitializeCacheMap_AcquireForReadAhead(IN PVOID Context,IN BOOLEAN Wait)
\r
838 struct Callbacks *callbacksp=Context;
\r
842 DBGSINGLEENTER3("AcquireForReadAhead: FileObject=0x%lX,Context=0x%lX,Wait=%d",
\r
843 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext,Wait);
\r
844 dump_FileObject(callbacksp->FileObject);
\r
845 /* Prevent deadlock during File Explorer copy to our destination. */
\r
846 locked=unlock_full();
\r
847 r=(*callbacksp->Callbacks.AcquireForReadAhead)(callbacksp->LazyWriteContext,Wait);
\r
849 DBGSINGLELEAVE1("AcquireForReadAhead: r=%d",r);
\r
853 static VOID TcInitializeCacheMap_ReleaseFromReadAhead(IN PVOID Context)
\r
855 struct Callbacks *callbacksp=Context;
\r
858 DBGSINGLEENTER2("ReleaseFromReadAhead: FileObject=0x%lX,Context=0x%lX",
\r
859 (long)callbacksp->FileObject,(long)callbacksp->LazyWriteContext);
\r
860 dump_FileObject(callbacksp->FileObject);
\r
861 /* Prevent deadlock during File Explorer copy to our destination. */
\r
862 locked=unlock_full();
\r
863 (*callbacksp->Callbacks.ReleaseFromReadAhead)(callbacksp->LazyWriteContext);
\r
865 DBGSINGLELEAVE0("ReleaseFromReadAhead");
\r
868 static CACHE_MANAGER_CALLBACKS TcInitializeCacheMap_Callbacks={
\r
869 TcInitializeCacheMap_AcquireForLazyWrite,
\r
870 TcInitializeCacheMap_ReleaseFromLazyWrite,
\r
871 TcInitializeCacheMap_AcquireForReadAhead,
\r
872 TcInitializeCacheMap_ReleaseFromReadAhead,
\r
875 typedef struct _CC_FILE_SIZES {
\r
876 LARGE_INTEGER AllocationSize;
\r
877 LARGE_INTEGER FileSize;
\r
878 LARGE_INTEGER ValidDataLength;
\r
879 } CC_FILE_SIZES,*PCC_FILE_SIZES;
\r
882 CcInitializeCacheMap (
\r
883 IN PFILE_OBJECT FileObject,
\r
884 IN PCC_FILE_SIZES FileSizes,
\r
885 IN BOOLEAN PinAccess,
\r
886 IN PCACHE_MANAGER_CALLBACKS Callbacks,
\r
887 IN PVOID LazyWriteContext
\r
890 TcInitializeCacheMap (
\r
891 IN PFILE_OBJECT FileObject,
\r
892 IN PCC_FILE_SIZES FileSizes,
\r
893 IN BOOLEAN PinAccess,
\r
894 IN PCACHE_MANAGER_CALLBACKS Callbacks,
\r
895 IN PVOID LazyWriteContext
\r
898 struct Callbacks *callbacksp;
\r
900 DBGSINGLEENTER5("CcInitializeCacheMap: FileObject=0x%lX,"
\r
901 "FileSizes,->AllocationSize=0x%lX,->FileSize=0x%lX,->ValidDataLength=0x%lX,"
\r
902 "PinAccess=%d,Callbacks,LazyWriteContext",
\r
904 (!FileSizes ? -1 : (long)FileSizes->AllocationSize.QuadPart),
\r
905 (!FileSizes ? -1 : (long)FileSizes->FileSize.QuadPart),
\r
906 (!FileSizes ? -1 : (long)FileSizes->ValidDataLength.QuadPart),
\r
908 dump_FileObject(FileObject);
\r
909 if ((callbacksp=Callbacks_set(FileObject,Callbacks,LazyWriteContext))) {
\r
910 Callbacks=&TcInitializeCacheMap_Callbacks;
\r
911 LazyWriteContext=callbacksp;
\r
912 if (Callbacks->AcquireForLazyWrite !=TcInitializeCacheMap_AcquireForLazyWrite)
\r
913 DBGSINGLE1("CcInitializeCacheMap: ERROR: AcquireForLazyWrite =0x%lX",Callbacks->AcquireForLazyWrite);
\r
914 if (Callbacks->ReleaseFromLazyWrite!=TcInitializeCacheMap_ReleaseFromLazyWrite)
\r
915 DBGSINGLE1("CcInitializeCacheMap: ERROR: ReleaseFromLazyWrite=0x%lX",Callbacks->ReleaseFromLazyWrite);
\r
916 if (Callbacks->AcquireForReadAhead !=TcInitializeCacheMap_AcquireForReadAhead)
\r
917 DBGSINGLE1("CcInitializeCacheMap: ERROR: AcquireForReadAhead =0x%lX",Callbacks->AcquireForReadAhead);
\r
918 if (Callbacks->ReleaseFromReadAhead!=TcInitializeCacheMap_ReleaseFromReadAhead)
\r
919 DBGSINGLE1("CcInitializeCacheMap: ERROR: ReleaseFromReadAhead=0x%lX",Callbacks->ReleaseFromReadAhead);
\r
921 CcInitializeCacheMap (
\r
928 dump_FileObject(FileObject);
\r
929 DBGSINGLELEAVE0("CcInitializeCacheMap");
\r
934 IN PFILE_OBJECT FileObject,
\r
935 IN PLARGE_INTEGER FileOffset,
\r
943 IN PFILE_OBJECT FileObject,
\r
944 IN PLARGE_INTEGER FileOffset,
\r
953 DBGSINGLEENTER4("CcMapData: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Flags=0x%lX",
\r
954 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Flags);
\r
955 dump_FileObject(FileObject);
\r
964 DBGSINGLELEAVE3("CcMapData: r=%d,Bcb=0x%lX,Buffer=0x%lX",
\r
965 r,(!Bcb ? -1 : (long)*Bcb),(!Buffer ? -1 : (long)*Buffer));
\r
971 IN PFILE_OBJECT FileObject,
\r
972 IN PLARGE_INTEGER FileOffset,
\r
974 OUT PMDL *MdlChain,
\r
975 OUT PIO_STATUS_BLOCK IoStatus
\r
979 IN PFILE_OBJECT FileObject,
\r
980 IN PLARGE_INTEGER FileOffset,
\r
982 OUT PMDL *MdlChain,
\r
983 OUT PIO_STATUS_BLOCK IoStatus
\r
986 DBGSINGLEENTER3("CcMdlRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX",
\r
987 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length);
\r
988 dump_FileObject(FileObject);
\r
996 DBGSINGLELEAVE3("CcMdlRead: MdlChain=0x%lX,IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
997 (!MdlChain ? -1 : (long)*MdlChain),
\r
998 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
1002 CcMdlReadComplete (
\r
1003 IN PFILE_OBJECT FileObject,
\r
1007 TcMdlReadComplete (
\r
1008 IN PFILE_OBJECT FileObject,
\r
1012 DBGSINGLEENTER2("CcMdlReadComplete: FileObject=0x%lX,MdlChain=0x%lX",
\r
1013 (long)FileObject,(long)MdlChain);
\r
1014 dump_FileObject(FileObject);
\r
1015 CcMdlReadComplete (
\r
1019 DBGSINGLELEAVE0("CcMdlReadComplete");
\r
1024 IN PFILE_OBJECT FileObject,
\r
1029 IN PFILE_OBJECT FileObject,
\r
1033 DBGSINGLEENTER2("CcMdlWriteAbort: FileObject=0x%lX,MdlChain=0x%lX",
\r
1034 (long)FileObject,(long)MdlChain);
\r
1035 dump_FileObject(FileObject);
\r
1040 DBGSINGLELEAVE0("CcMdlWriteAbort");
\r
1044 CcMdlWriteComplete (
\r
1045 IN PFILE_OBJECT FileObject,
\r
1046 IN PLARGE_INTEGER FileOffset,
\r
1050 TcMdlWriteComplete (
\r
1051 IN PFILE_OBJECT FileObject,
\r
1052 IN PLARGE_INTEGER FileOffset,
\r
1056 DBGSINGLEENTER3("CcMdlWriteComplete: FileObject=0x%lX,FileOffset=0x%lX,MdlChain=0x%lX",
\r
1057 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),(long)MdlChain);
\r
1058 dump_FileObject(FileObject);
\r
1059 CcMdlWriteComplete (
\r
1064 DBGSINGLELEAVE0("CcMdlWriteComplete");
\r
1069 IN PFILE_OBJECT FileObject,
\r
1070 IN PLARGE_INTEGER FileOffset,
\r
1077 IN PFILE_OBJECT FileObject,
\r
1078 IN PLARGE_INTEGER FileOffset,
\r
1086 DBGSINGLEENTER4("CcPinMappedData: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Flags=0x%lX",
\r
1087 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Flags);
\r
1088 dump_FileObject(FileObject);
\r
1089 r=CcPinMappedData (
\r
1096 DBGSINGLELEAVE2("CcPinMappedData: r=%d,Bcb=0x%lX",
\r
1097 r,(!Bcb ? -1 : (long)*Bcb));
\r
1103 IN PFILE_OBJECT FileObject,
\r
1104 IN PLARGE_INTEGER FileOffset,
\r
1112 IN PFILE_OBJECT FileObject,
\r
1113 IN PLARGE_INTEGER FileOffset,
\r
1122 DBGSINGLEENTER4("CcPinRead: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Flags=0x%lX",
\r
1123 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Flags);
\r
1124 dump_FileObject(FileObject);
\r
1133 DBGSINGLELEAVE3("CcPinRead: r=%d,Bcb=0x%lX,Buffer=0x%lX",
\r
1134 r,(!Bcb ? -1 : (long)*Bcb),(!Buffer ? -1 : (long)*Buffer));
\r
1139 CcPrepareMdlWrite (
\r
1140 IN PFILE_OBJECT FileObject,
\r
1141 IN PLARGE_INTEGER FileOffset,
\r
1143 OUT PMDL *MdlChain,
\r
1144 OUT PIO_STATUS_BLOCK IoStatus
\r
1147 TcPrepareMdlWrite (
\r
1148 IN PFILE_OBJECT FileObject,
\r
1149 IN PLARGE_INTEGER FileOffset,
\r
1151 OUT PMDL *MdlChain,
\r
1152 OUT PIO_STATUS_BLOCK IoStatus
\r
1155 DBGSINGLEENTER3("CcPrepareMdlWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX",
\r
1156 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length);
\r
1157 dump_FileObject(FileObject);
\r
1158 CcPrepareMdlWrite (
\r
1165 DBGSINGLELEAVE3("CcPrepareMdlWrite: MdlChain=0x%lX,IoStatus->Status=0x%lX,IoStatus->Information=0x%lX",
\r
1166 (!MdlChain ? -1 : (long)*MdlChain),
\r
1167 (!IoStatus ? -1 : (long)IoStatus->Status),(!IoStatus ? -1 : (long)IoStatus->Information));
\r
1171 CcPreparePinWrite (
\r
1172 IN PFILE_OBJECT FileObject,
\r
1173 IN PLARGE_INTEGER FileOffset,
\r
1181 TcPreparePinWrite (
\r
1182 IN PFILE_OBJECT FileObject,
\r
1183 IN PLARGE_INTEGER FileOffset,
\r
1193 DBGSINGLEENTER5("CcPreparePinWrite: FileObject=0x%lX,FileOffset=0x%lX,Length=0x%lX,Zero=%d,Flags=0x%lX",
\r
1194 (long)FileObject,(!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,Zero,Flags);
\r
1195 dump_FileObject(FileObject);
\r
1196 r=CcPreparePinWrite (
\r
1205 DBGSINGLELEAVE3("CcPreparePinWrite: r=%d,Bcb=0x%lX,Buffer=0x%lX",
\r
1206 r,(!Bcb ? -1 : (long)*Bcb),(!Buffer ? -1 : (long)*Buffer));
\r
1211 CcPurgeCacheSection (
\r
1212 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
1213 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
1215 IN BOOLEAN UninitializeCacheMaps
\r
1218 TcPurgeCacheSection (
\r
1219 IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
\r
1220 IN PLARGE_INTEGER FileOffset OPTIONAL,
\r
1222 IN BOOLEAN UninitializeCacheMaps
\r
1227 DBGSINGLEENTER5("CcPurgeCacheSection: SectionObjectPointer=0x%lX,->SharedCacheMap=0x%lX,FileOffset=0x%lX,Length=0x%lX,"
\r
1228 "UninitializeCacheMaps=%d",
\r
1229 (long)SectionObjectPointer,
\r
1230 (!SectionObjectPointer ? -1 : (long)SectionObjectPointer->SharedCacheMap),
\r
1231 (!FileOffset ? -1 : (long)FileOffset->QuadPart),Length,
\r
1232 UninitializeCacheMaps);
\r
1233 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
1234 r=CcPurgeCacheSection (
\r
1235 SectionObjectPointer,
\r
1238 UninitializeCacheMaps
\r
1240 dump_FileObject(SectionObjectPointer_find(SectionObjectPointer));
\r
1241 DBGSINGLELEAVE1("CcPurgeCacheSection: r=%d",r);
\r
1256 DBGSINGLEENTER1("CcRemapBcb: Bcb=0x%lX",(long)Bcb);
\r
1260 DBGSINGLELEAVE1("CcRemapBcb: r=0x%lX",(long)r);
\r
1265 CcSetAdditionalCacheAttributes (
\r
1266 IN PFILE_OBJECT FileObject,
\r
1267 IN BOOLEAN DisableReadAhead,
\r
1268 IN BOOLEAN DisableWriteBehind
\r
1271 TcSetAdditionalCacheAttributes (
\r
1272 IN PFILE_OBJECT FileObject,
\r
1273 IN BOOLEAN DisableReadAhead,
\r
1274 IN BOOLEAN DisableWriteBehind
\r
1277 DBGSINGLEENTER3("CcSetAdditionalCacheAttributes: FileObject=0x%lX,DisableReadAhead=%d,DisableWriteBehind=%d",
\r
1278 (long)FileObject,DisableReadAhead,DisableWriteBehind);
\r
1279 dump_FileObject(FileObject);
\r
1280 CcSetAdditionalCacheAttributes (
\r
1283 DisableWriteBehind
\r
1285 DBGSINGLELEAVE0("CcSetAdditionalCacheAttributes");
\r
1289 CcSetBcbOwnerPointer (
\r
1291 IN PVOID OwnerPointer
\r
1294 TcSetBcbOwnerPointer (
\r
1296 IN PVOID OwnerPointer
\r
1299 DBGSINGLEENTER2("CcSetBcbOwnerPointer: Bcb=0x%lX,OwnerPointer=0x%lX",
\r
1300 (long)Bcb,(long)OwnerPointer);
\r
1301 CcSetBcbOwnerPointer (
\r
1305 DBGSINGLELEAVE0("CcSetBcbOwnerPointer");
\r
1309 CcSetDirtyPinnedData (
\r
1311 IN PLARGE_INTEGER Lsn OPTIONAL
\r
1314 TcSetDirtyPinnedData (
\r
1316 IN PLARGE_INTEGER Lsn OPTIONAL
\r
1319 DBGSINGLEENTER2("CcSetDirtyPinnedData: BcbVoid=0x%lX,Lsn=0x%lX",
\r
1320 (long)BcbVoid,(!Lsn ? -1 : (long)Lsn->QuadPart));
\r
1321 CcSetDirtyPinnedData (
\r
1325 DBGSINGLELEAVE0("CcSetDirtyPinnedData");
\r
1330 IN PFILE_OBJECT FileObject,
\r
1331 IN PCC_FILE_SIZES FileSizes
\r
1335 IN PFILE_OBJECT FileObject,
\r
1336 IN PCC_FILE_SIZES FileSizes
\r
1339 DBGSINGLEENTER4("CcSetFileSizes: FileObject=0x%lX,"
\r
1340 "FileSizes,->AllocationSize=0x%lX,->FileSize=0x%lX,->ValidDataLength=0x%lX",
\r
1342 (!FileSizes ? -1 : (long)FileSizes->AllocationSize.QuadPart),
\r
1343 (!FileSizes ? -1 : (long)FileSizes->FileSize.QuadPart),
\r
1344 (!FileSizes ? -1 : (long)FileSizes->ValidDataLength.QuadPart));
\r
1345 dump_FileObject(FileObject);
\r
1350 DBGSINGLELEAVE0("CcSetFileSizes");
\r
1353 typedef VOID (*PFLUSH_TO_LSN)(IN PVOID LogHandle,IN LARGE_INTEGER Lsn);
\r
1355 static struct LogHandle {
\r
1357 PFLUSH_TO_LSN FlushToLsnRoutine;
\r
1358 } LogHandle_cache[CACHE_SIZE];
\r
1359 static int LogHandle_cache_used=0;
\r
1361 static BOOLEAN LogHandle_set(PVOID LogHandle,PFLUSH_TO_LSN FlushToLsnRoutine)
\r
1363 struct LogHandle *loghandlep;
\r
1365 for (loghandlep=LogHandle_cache;loghandlep<LogHandle_cache+LogHandle_cache_used;loghandlep++) {
\r
1366 if (loghandlep->LogHandle==LogHandle)
\r
1369 if (loghandlep>=LogHandle_cache+G_N_ELEMENTS(LogHandle_cache))
\r
1371 if (loghandlep==LogHandle_cache+LogHandle_cache_used)
\r
1372 LogHandle_cache_used++;
\r
1373 loghandlep->LogHandle=LogHandle;
\r
1374 loghandlep->FlushToLsnRoutine=FlushToLsnRoutine;
\r
1378 static PFLUSH_TO_LSN LogHandle_find(PVOID LogHandle)
\r
1380 struct LogHandle *loghandlep;
\r
1382 for (loghandlep=LogHandle_cache;loghandlep<LogHandle_cache+LogHandle_cache_used;loghandlep++) {
\r
1383 if (loghandlep->LogHandle==LogHandle)
\r
1384 return loghandlep->FlushToLsnRoutine;
\r
1389 static VOID TcSetLogHandleForFile_FlushToLsnRoutine(IN PVOID LogHandle,IN LARGE_INTEGER Lsn)
\r
1391 PFLUSH_TO_LSN FlushToLsnRoutine;
\r
1394 DBGSINGLEENTER2("FlushToLsnRoutine: LogHandle=0x%lX,Lsn=0x%lX",
\r
1395 (long)LogHandle,(long)Lsn.QuadPart);
\r
1396 /* Prevent deadlock during display of File Explorer directory listing. */
\r
1397 locked=unlock_full();
\r
1398 if ((FlushToLsnRoutine=LogHandle_find(LogHandle)))
\r
1399 (*FlushToLsnRoutine)(LogHandle,Lsn);
\r
1400 lock_full(locked);
\r
1401 DBGSINGLELEAVE0("FlushToLsnRoutine");
\r
1405 CcSetLogHandleForFile (
\r
1406 IN PFILE_OBJECT FileObject,
\r
1407 IN PVOID LogHandle,
\r
1408 IN PFLUSH_TO_LSN FlushToLsnRoutine
\r
1411 TcSetLogHandleForFile (
\r
1412 IN PFILE_OBJECT FileObject,
\r
1413 IN PVOID LogHandle,
\r
1414 IN PFLUSH_TO_LSN FlushToLsnRoutine
\r
1417 DBGSINGLEENTER3("CcSetLogHandleForFile: FileObject=0x%lX,LogHandle=0x%lX,FlushToLsnRoutine=0x%lX",
\r
1418 (long)FileObject,(long)LogHandle,(long)FlushToLsnRoutine);
\r
1419 dump_FileObject(FileObject);
\r
1420 if (LogHandle_set(LogHandle,FlushToLsnRoutine))
\r
1421 FlushToLsnRoutine=TcSetLogHandleForFile_FlushToLsnRoutine;
\r
1422 CcSetLogHandleForFile (
\r
1427 DBGSINGLELEAVE0("CcSetLogHandleForFile");
\r
1431 CcSetReadAheadGranularity (
\r
1432 IN PFILE_OBJECT FileObject,
\r
1433 IN ULONG Granularity
\r
1436 TcSetReadAheadGranularity (
\r
1437 IN PFILE_OBJECT FileObject,
\r
1438 IN ULONG Granularity
\r
1441 DBGSINGLEENTER2("CcSetReadAheadGranularity: FileObject=0x%lX,Granularity=0x%lX",
\r
1442 (long)FileObject,Granularity);
\r
1443 dump_FileObject(FileObject);
\r
1444 CcSetReadAheadGranularity (
\r
1448 DBGSINGLELEAVE0("CcSetReadAheadGranularity");
\r
1451 typedef struct _CACHE_UNINITIALIZE_EVENT {
\r
1452 struct _CACHE_UNINITIALIZE_EVENT *Next;
\r
1454 } CACHE_UNINITIALIZE_EVENT,*PCACHE_UNINITIALIZE_EVENT;
\r
1457 CcUninitializeCacheMap (
\r
1458 IN PFILE_OBJECT FileObject,
\r
1459 IN PLARGE_INTEGER TruncateSize OPTIONAL,
\r
1460 IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL
\r
1463 TcUninitializeCacheMap (
\r
1464 IN PFILE_OBJECT FileObject,
\r
1465 IN PLARGE_INTEGER TruncateSize OPTIONAL,
\r
1466 IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL
\r
1471 DBGSINGLEENTER3("CcUninitializeCacheMap: FileObject=0x%lX,TruncateSize=0x%lX,UninitializeCompleteEvent=0x%lX",
\r
1472 (long)FileObject,(!TruncateSize ? -1 : (long)TruncateSize->QuadPart),(long)UninitializeCompleteEvent);
\r
1473 dump_FileObject(FileObject);
\r
1474 r=CcUninitializeCacheMap (
\r
1477 UninitializeCompleteEvent
\r
1479 dump_FileObject(FileObject);
\r
1480 DBGSINGLELEAVE1("CcUninitializeCacheMap: r=%d",r);
\r
1493 DBGSINGLEENTER1("CcUnpinData: Bcb=0x%lX",(long)Bcb);
\r
1497 DBGSINGLELEAVE0("CcUnpinData");
\r
1501 CcUnpinDataForThread (
\r
1503 IN ERESOURCE_THREAD ResourceThreadId
\r
1506 TcUnpinDataForThread (
\r
1508 IN ERESOURCE_THREAD ResourceThreadId
\r
1511 DBGSINGLEENTER2("CcUnpinDataForThread: Bcb=0x%lX,ResourceThreadId=0x%lX",
\r
1512 (long)Bcb,(long)ResourceThreadId);
\r
1513 CcUnpinDataForThread (
\r
1517 DBGSINGLELEAVE0("CcUnpinDataForThread");
\r
1521 CcWaitForCurrentLazyWriterActivity (
\r
1525 TcWaitForCurrentLazyWriterActivity (
\r
1531 DBGSINGLEENTER0("CcWaitForCurrentLazyWriterActivity");
\r
1532 r=CcWaitForCurrentLazyWriterActivity (
\r
1534 DBGSINGLELEAVE1("CcWaitForCurrentLazyWriterActivity: r=0x%lX",r);
\r
1540 IN PFILE_OBJECT FileObject,
\r
1541 IN PLARGE_INTEGER StartOffset,
\r
1542 IN PLARGE_INTEGER EndOffset,
\r
1547 IN PFILE_OBJECT FileObject,
\r
1548 IN PLARGE_INTEGER StartOffset,
\r
1549 IN PLARGE_INTEGER EndOffset,
\r
1555 DBGSINGLEENTER4("CcZeroData: FileObject=0x%lX,StartOffset=0x%lX,EndOffset=0x%lX,Wait=%d",
\r
1557 (!StartOffset ? -1 : (long)StartOffset->QuadPart),
\r
1558 (!EndOffset ? -1 : (long)EndOffset->QuadPart),
\r
1560 dump_FileObject(FileObject);
\r
1567 DBGSINGLELEAVE1("CcZeroData: r=%d",r);
\r