modules/rostests/kmtests/ntos_cc/CcPinMappedData_drv.c

   1 /*
   2  * PROJECT:         ReactOS kernel-mode tests
   3  * LICENSE:         LGPLv2.1+ - See COPYING.LIB in the top level directory
   4  * PURPOSE:         Test driver for CcPinMappedData function
   5  * PROGRAMMER:      Pierre Schweitzer <pierre@reactos.org>
   6  */
   7
   8 #include <kmt_test.h>
   9
  10 #define NDEBUG
  11 #include <debug.h>
  12
  13 #define IOCTL_START_TEST  1
  14 #define IOCTL_FINISH_TEST 2
  15
  16 typedef struct _TEST_FCB
  17 {
  18     FSRTL_ADVANCED_FCB_HEADER Header;
  19     SECTION_OBJECT_POINTERS SectionObjectPointers;
  20     FAST_MUTEX HeaderMutex;
  21 } TEST_FCB, *PTEST_FCB;
  22
  23 typedef struct _TEST_CONTEXT
  24 {
  25     PVOID Bcb;
  26     PVOID Buffer;
  27     ULONG Length;
  28 } TEST_CONTEXT, *PTEST_CONTEXT;
  29
  30 static ULONG TestTestId = -1;
  31 static PFILE_OBJECT TestFileObject;
  32 static PDEVICE_OBJECT TestDeviceObject;
  33 static KMT_IRP_HANDLER TestIrpHandler;
  34 static KMT_MESSAGE_HANDLER TestMessageHandler;
  35
  36 NTSTATUS
  37 TestEntry(
  38     _In_ PDRIVER_OBJECT DriverObject,
  39     _In_ PCUNICODE_STRING RegistryPath,
  40     _Out_ PCWSTR *DeviceName,
  41     _Inout_ INT *Flags)
  42 {
  43     NTSTATUS Status = STATUS_SUCCESS;
  44
  45     PAGED_CODE();
  46
  47     UNREFERENCED_PARAMETER(RegistryPath);
  48
  49     *DeviceName = L"CcPinMappedData";
  50     *Flags = TESTENTRY_NO_EXCLUSIVE_DEVICE |
  51              TESTENTRY_BUFFERED_IO_DEVICE |
  52              TESTENTRY_NO_READONLY_DEVICE;
  53
  54     KmtRegisterIrpHandler(IRP_MJ_READ, NULL, TestIrpHandler);
  55     KmtRegisterMessageHandler(0, NULL, TestMessageHandler);
  56
  57
  58     return Status;
  59 }
  60
  61 VOID
  62 TestUnload(
  63     _In_ PDRIVER_OBJECT DriverObject)
  64 {
  65     PAGED_CODE();
  66 }
  67
  68 BOOLEAN
  69 NTAPI
  70 AcquireForLazyWrite(
  71     _In_ PVOID Context,
  72     _In_ BOOLEAN Wait)
  73 {
  74     return TRUE;
  75 }
  76
  77 VOID
  78 NTAPI
  79 ReleaseFromLazyWrite(
  80     _In_ PVOID Context)
  81 {
  82     return;
  83 }
  84
  85 BOOLEAN
  86 NTAPI
  87 AcquireForReadAhead(
  88     _In_ PVOID Context,
  89     _In_ BOOLEAN Wait)
  90 {
  91     return TRUE;
  92 }
  93
  94 VOID
  95 NTAPI
  96 ReleaseFromReadAhead(
  97     _In_ PVOID Context)
  98 {
  99     return;
 100 }
 101
 102 static CACHE_MANAGER_CALLBACKS Callbacks = {
 103     AcquireForLazyWrite,
 104     ReleaseFromLazyWrite,
 105     AcquireForReadAhead,
 106     ReleaseFromReadAhead,
 107 };
 108
 109 static CC_FILE_SIZES FileSizes = {
 110     RTL_CONSTANT_LARGE_INTEGER((LONGLONG)0x4000), // .AllocationSize
 111     RTL_CONSTANT_LARGE_INTEGER((LONGLONG)0x4000), // .FileSize
 112     RTL_CONSTANT_LARGE_INTEGER((LONGLONG)0x4000)  // .ValidDataLength
 113 };
 114
 115 static
 116 PVOID
 117 MapAndLockUserBuffer(
 118     _In_ _Out_ PIRP Irp,
 119     _In_ ULONG BufferLength)
 120 {
 121     PMDL Mdl;
 122
 123     if (Irp->MdlAddress == NULL)
 124     {
 125         Mdl = IoAllocateMdl(Irp->UserBuffer, BufferLength, FALSE, FALSE, Irp);
 126         if (Mdl == NULL)
 127         {
 128             return NULL;
 129         }
 130
 131         _SEH2_TRY
 132         {
 133             MmProbeAndLockPages(Mdl, Irp->RequestorMode, IoWriteAccess);
 134         }
 135         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 136         {
 137             IoFreeMdl(Mdl);
 138             Irp->MdlAddress = NULL;
 139             _SEH2_YIELD(return NULL);
 140         }
 141         _SEH2_END;
 142     }
 143
 144     return MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
 145 }
 146
 147 static
 148 VOID
 149 PerformTest(
 150     ULONG TestId,
 151     PDEVICE_OBJECT DeviceObject)
 152 {
 153     PVOID Bcb, PinBcb, NewBcb;
 154     BOOLEAN Ret;
 155     PULONG Buffer;
 156     PTEST_FCB Fcb;
 157     LARGE_INTEGER Offset;
 158
 159     ok_eq_pointer(TestFileObject, NULL);
 160     ok_eq_pointer(TestDeviceObject, NULL);
 161     ok_eq_ulong(TestTestId, -1);
 162
 163     TestDeviceObject = DeviceObject;
 164     TestTestId = TestId;
 165     TestFileObject = IoCreateStreamFileObject(NULL, DeviceObject);
 166     if (!skip(TestFileObject != NULL, "Failed to allocate FO\n"))
 167     {
 168         Fcb = ExAllocatePool(NonPagedPool, sizeof(TEST_FCB));
 169         if (!skip(Fcb != NULL, "ExAllocatePool failed\n"))
 170         {
 171             RtlZeroMemory(Fcb, sizeof(TEST_FCB));
 172             ExInitializeFastMutex(&Fcb->HeaderMutex);
 173             FsRtlSetupAdvancedHeader(&Fcb->Header, &Fcb->HeaderMutex);
 174
 175             TestFileObject->FsContext = Fcb;
 176             TestFileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
 177
 178             KmtStartSeh();
 179             CcInitializeCacheMap(TestFileObject, &FileSizes, TRUE, &Callbacks, NULL);
 180             KmtEndSeh(STATUS_SUCCESS);
 181
 182             if (!skip(CcIsFileCached(TestFileObject) == TRUE, "CcInitializeCacheMap failed\n"))
 183             {
 184                 if (TestId == 0)
 185                 {
 186                     Ret = FALSE;
 187                     Offset.QuadPart = 0;
 188                     KmtStartSeh();
 189                     Ret = CcMapData(TestFileObject, &Offset, FileSizes.FileSize.QuadPart - Offset.QuadPart, MAP_WAIT, &Bcb, (PVOID *)&Buffer);
 190                     KmtEndSeh(STATUS_SUCCESS);
 191
 192                     if (!skip(Ret == TRUE, "CcMapData failed\n"))
 193                     {
 194                         Ret = FALSE;
 195                         PinBcb = Bcb;
 196                         ok_eq_ulong(Buffer[0x3000 / sizeof(ULONG)], 0xDEADBABE);
 197
 198                         KmtStartSeh();
 199                         Ret = CcPinMappedData(TestFileObject, &Offset, FileSizes.FileSize.QuadPart - Offset.QuadPart, PIN_WAIT, &PinBcb);
 200                         KmtEndSeh(STATUS_SUCCESS);
 201
 202                         if (!skip(Ret == TRUE, "CcPinMappedData failed\n"))
 203                         {
 204                             ok(Bcb != PinBcb, "Returned same BCB!\n");
 205                             ok(*(PUSHORT)PinBcb == 0x2FD, "Not a BCB: %x\n", *(PUSHORT)PinBcb);
 206
 207                             /* Previous BCB isn't valid anymore! */
 208                             Bcb = PinBcb;
 209                         }
 210
 211                         CcUnpinData(Bcb);
 212                     }
 213                 }
 214                 else if (TestId == 1)
 215                 {
 216                     Ret = FALSE;
 217                     Offset.QuadPart = 0;
 218                     KmtStartSeh();
 219                     Ret = CcPinRead(TestFileObject, &Offset, FileSizes.FileSize.QuadPart - Offset.QuadPart, PIN_WAIT, &PinBcb, (PVOID *)&Buffer);
 220                     KmtEndSeh(STATUS_SUCCESS);
 221
 222                     if (!skip(Ret == TRUE, "CcPinRead failed\n"))
 223                     {
 224                         ok(*(PUSHORT)PinBcb == 0x2FD, "Not a BCB: %x\n", *(PUSHORT)PinBcb);
 225                         ok_eq_ulong(Buffer[0x3000 / sizeof(ULONG)], 0xDEADBABE);
 226
 227                         Ret = FALSE;
 228                         KmtStartSeh();
 229                         Ret = CcMapData(TestFileObject, &Offset, FileSizes.FileSize.QuadPart - Offset.QuadPart, MAP_WAIT, &Bcb, (PVOID *)&Buffer);
 230                         KmtEndSeh(STATUS_SUCCESS);
 231
 232                         if (!skip(Ret == TRUE, "CcMapData failed\n"))
 233                         {
 234                             ok(Bcb != PinBcb, "Returned same BCB!\n");
 235
 236                             Ret = FALSE;
 237                             NewBcb = Bcb;
 238                             KmtStartSeh();
 239                             Ret = CcPinMappedData(TestFileObject, &Offset, FileSizes.FileSize.QuadPart - Offset.QuadPart, PIN_WAIT, &NewBcb);
 240                             KmtEndSeh(STATUS_SUCCESS);
 241
 242                             if (!skip(Ret == TRUE, "CcPinMappedData failed\n"))
 243                             {
 244                                 ok(Bcb != NewBcb, "Returned same BCB!\n");
 245                                 ok_eq_pointer(NewBcb, PinBcb);
 246                                 ok(*(PUSHORT)NewBcb == 0x2FD, "Not a BCB: %x\n", *(PUSHORT)NewBcb);
 247
 248                                 /* Previous BCB isn't valid anymore! */
 249                                 Bcb = NewBcb;
 250                             }
 251
 252                             CcUnpinData(Bcb);
 253                         }
 254
 255                         CcUnpinData(PinBcb);
 256                     }
 257                 }
 258             }
 259         }
 260     }
 261 }
 262
 263
 264 static
 265 VOID
 266 CleanupTest(
 267     ULONG TestId,
 268     PDEVICE_OBJECT DeviceObject)
 269 {
 270     LARGE_INTEGER Zero = RTL_CONSTANT_LARGE_INTEGER(0LL);
 271     CACHE_UNINITIALIZE_EVENT CacheUninitEvent;
 272
 273     ok_eq_pointer(TestDeviceObject, DeviceObject);
 274     ok_eq_ulong(TestTestId, TestId);
 275
 276     if (!skip(TestFileObject != NULL, "No test FO\n"))
 277     {
 278         if (CcIsFileCached(TestFileObject))
 279         {
 280             KeInitializeEvent(&CacheUninitEvent.Event, NotificationEvent, FALSE);
 281             CcUninitializeCacheMap(TestFileObject, &Zero, &CacheUninitEvent);
 282             KeWaitForSingleObject(&CacheUninitEvent.Event, Executive, KernelMode, FALSE, NULL);
 283         }
 284
 285         if (TestFileObject->FsContext != NULL)
 286         {
 287             ExFreePool(TestFileObject->FsContext);
 288             TestFileObject->FsContext = NULL;
 289             TestFileObject->SectionObjectPointer = NULL;
 290         }
 291
 292         ObDereferenceObject(TestFileObject);
 293     }
 294
 295     TestFileObject = NULL;
 296     TestDeviceObject = NULL;
 297     TestTestId = -1;
 298 }
 299
 300
 301 static
 302 NTSTATUS
 303 TestMessageHandler(
 304     _In_ PDEVICE_OBJECT DeviceObject,
 305     _In_ ULONG ControlCode,
 306     _In_opt_ PVOID Buffer,
 307     _In_ SIZE_T InLength,
 308     _Inout_ PSIZE_T OutLength)
 309 {
 310     NTSTATUS Status = STATUS_SUCCESS;
 311
 312     FsRtlEnterFileSystem();
 313
 314     switch (ControlCode)
 315     {
 316         case IOCTL_START_TEST:
 317             ok_eq_ulong((ULONG)InLength, sizeof(ULONG));
 318             PerformTest(*(PULONG)Buffer, DeviceObject);
 319             break;
 320
 321         case IOCTL_FINISH_TEST:
 322             ok_eq_ulong((ULONG)InLength, sizeof(ULONG));
 323             CleanupTest(*(PULONG)Buffer, DeviceObject);
 324             break;
 325
 326         default:
 327             Status = STATUS_NOT_IMPLEMENTED;
 328             break;
 329     }
 330
 331     FsRtlExitFileSystem();
 332
 333     return Status;
 334 }
 335
 336 static
 337 NTSTATUS
 338 TestIrpHandler(
 339     _In_ PDEVICE_OBJECT DeviceObject,
 340     _In_ PIRP Irp,
 341     _In_ PIO_STACK_LOCATION IoStack)
 342 {
 343     NTSTATUS Status;
 344
 345     PAGED_CODE();
 346
 347     DPRINT("IRP %x/%x\n", IoStack->MajorFunction, IoStack->MinorFunction);
 348     ASSERT(IoStack->MajorFunction == IRP_MJ_READ);
 349
 350     FsRtlEnterFileSystem();
 351
 352     Status = STATUS_NOT_SUPPORTED;
 353     Irp->IoStatus.Information = 0;
 354
 355     if (IoStack->MajorFunction == IRP_MJ_READ)
 356     {
 357         PMDL Mdl;
 358         ULONG Length;
 359         PVOID Buffer;
 360         LARGE_INTEGER Offset;
 361
 362         Offset = IoStack->Parameters.Read.ByteOffset;
 363         Length = IoStack->Parameters.Read.Length;
 364
 365         ok_eq_pointer(DeviceObject, TestDeviceObject);
 366         ok_eq_pointer(IoStack->FileObject, TestFileObject);
 367
 368         ok(FlagOn(Irp->Flags, IRP_NOCACHE), "Not coming from Cc\n");
 369
 370         ok_irql(APC_LEVEL);
 371         ok((Offset.QuadPart % PAGE_SIZE == 0 || Offset.QuadPart == 0), "Offset is not aligned: %I64i\n", Offset.QuadPart);
 372         ok(Length % PAGE_SIZE == 0, "Length is not aligned: %I64i\n", Length);
 373
 374         ok(Irp->AssociatedIrp.SystemBuffer == NULL, "A SystemBuffer was allocated!\n");
 375         Buffer = MapAndLockUserBuffer(Irp, Length);
 376         ok(Buffer != NULL, "Null pointer!\n");
 377         RtlFillMemory(Buffer, Length, 0xBA);
 378
 379         Status = STATUS_SUCCESS;
 380         if (Offset.QuadPart <= 0x3000 && Offset.QuadPart + Length > 0x3000)
 381         {
 382             *(PULONG)((ULONG_PTR)Buffer + (ULONG_PTR)(0x3000 - Offset.QuadPart)) = 0xDEADBABE;
 383         }
 384
 385         Mdl = Irp->MdlAddress;
 386         ok(Mdl != NULL, "Null pointer for MDL!\n");
 387         ok((Mdl->MdlFlags & MDL_PAGES_LOCKED) != 0, "MDL not locked\n");
 388         ok((Mdl->MdlFlags & MDL_SOURCE_IS_NONPAGED_POOL) == 0, "MDL from non paged\n");
 389         ok((Mdl->MdlFlags & MDL_IO_PAGE_READ) != 0, "Non paging IO\n");
 390         ok((Irp->Flags & IRP_PAGING_IO) != 0, "Non paging IO\n");
 391
 392         Irp->IoStatus.Information = Length;
 393     }
 394
 395     if (Status == STATUS_PENDING)
 396     {
 397         IoMarkIrpPending(Irp);
 398         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 399         Status = STATUS_PENDING;
 400     }
 401     else
 402     {
 403         Irp->IoStatus.Status = Status;
 404         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 405     }
 406
 407     FsRtlExitFileSystem();
 408
 409     return Status;
 410 }