rostests/kmtests/ntos_io/IoCreateFile.c

   1 /*
   2  * PROJECT:         ReactOS kernel-mode tests
   3  * LICENSE:         LGPLv2+ - See COPYING.LIB in the top level directory
   4  * PURPOSE:         Kernel-Mode Test Suite Io Regressions KM-Test (IoCreateFile)
   5  * PROGRAMMER:      Pierre Schweitzer <pierre@reactos.org>
   6  */
   7
   8 #include <kmt_test.h>
   9
  10 static UNICODE_STRING SystemRoot = RTL_CONSTANT_STRING(L"\\SystemRoot\\");
  11 static UNICODE_STRING Regedit = RTL_CONSTANT_STRING(L"regedit.exe");
  12 static UNICODE_STRING Foobar = RTL_CONSTANT_STRING(L"foobar.exe");
  13 static UNICODE_STRING SystemRootRegedit = RTL_CONSTANT_STRING(L"\\SystemRoot\\regedit.exe");
  14 static UNICODE_STRING SystemRootFoobar = RTL_CONSTANT_STRING(L"\\SystemRoot\\foobar.exe");
  15 static UNICODE_STRING SystemRootFoobarFoobar = RTL_CONSTANT_STRING(L"\\SystemRoot\\foobar\\foobar.exe");
  16 static UNICODE_STRING FoobarFoobar = RTL_CONSTANT_STRING(L"foobar\\foobar.exe");
  17
  18 static
  19 VOID
  20 NTAPI
  21 KernelModeTest(IN PVOID Context)
  22 {
  23     NTSTATUS Status;
  24     IO_STATUS_BLOCK IoStatusBlock;
  25     OBJECT_ATTRIBUTES ObjectAttributes;
  26     HANDLE ParentHandle, SystemRootHandle, TargetHandle;
  27     PFILE_OBJECT ParentFileObject, TargetFileObject, SystemRootFileObject;
  28
  29     UNREFERENCED_PARAMETER(Context);
  30
  31     /* Kernelmode mandatory for IoCreateFile */
  32     ok(ExGetPreviousMode() == KernelMode, "UserMode returned!\n");
  33
  34     /* First of all, open \\SystemRoot
  35      * We're interested in 3 pieces of information about it:
  36      * -> Its target (it's a symlink): \Windows or \ReactOS
  37      * -> Its associated File Object
  38      * -> Its associated FCB
  39      */
  40     TargetFileObject = NULL;
  41     IoStatusBlock.Status = 0xFFFFFFFF;
  42     TargetHandle = INVALID_HANDLE_VALUE;
  43     IoStatusBlock.Information = 0xFFFFFFFF;
  44     InitializeObjectAttributes(&ObjectAttributes,
  45                                &SystemRoot,
  46                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
  47                                NULL, NULL);
  48     Status = ZwOpenFile(&TargetHandle,
  49                         GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
  50                         &ObjectAttributes,
  51                         &IoStatusBlock,
  52                         FILE_SHARE_READ | FILE_SHARE_WRITE,
  53                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
  54     ok_eq_hex(Status, STATUS_SUCCESS);
  55     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
  56     if (Status == STATUS_SUCCESS)
  57     {
  58         Status = ObReferenceObjectByHandle(TargetHandle,
  59                                            FILE_READ_DATA,
  60 #ifdef _PROPER_NT_EXPORTS
  61                                            *IoFileObjectType,
  62 #else
  63                                            IoFileObjectType,
  64 #endif
  65                                            KernelMode,
  66                                            (PVOID *)&TargetFileObject,
  67                                            NULL);
  68         ok_eq_hex(Status, STATUS_SUCCESS);
  69     }
  70
  71     ok(TargetFileObject != NULL, "Not target to continue!\n");
  72     if (TargetFileObject == NULL)
  73     {
  74         if (TargetHandle != INVALID_HANDLE_VALUE)
  75         {
  76             ObCloseHandle(TargetHandle, KernelMode);
  77         }
  78         return;
  79     }
  80
  81     /* Open target directory of \SystemRoot\Regedit.exe
  82      * This must lead to \SystemRoot opening
  83      */
  84     IoStatusBlock.Status = 0xFFFFFFFF;
  85     IoStatusBlock.Information = 0xFFFFFFFF;
  86     InitializeObjectAttributes(&ObjectAttributes,
  87                                &SystemRootRegedit,
  88                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
  89                                NULL, NULL);
  90     Status = IoCreateFile(&ParentHandle,
  91                           GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
  92                           &ObjectAttributes,
  93                           &IoStatusBlock,
  94                           NULL,
  95                           0,
  96                           FILE_SHARE_READ | FILE_SHARE_WRITE,
  97                           FILE_OPEN,
  98                           FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
  99                           NULL,
 100                           0,
 101                           CreateFileTypeNone,
 102                           NULL,
 103                           IO_OPEN_TARGET_DIRECTORY);
 104     ok_eq_hex(Status, STATUS_SUCCESS);
 105     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 106     if (Status == STATUS_SUCCESS)
 107     {
 108         Status = ObReferenceObjectByHandle(ParentHandle,
 109                                            FILE_READ_DATA,
 110 #ifdef _PROPER_NT_EXPORTS
 111                                            *IoFileObjectType,
 112 #else
 113                                            IoFileObjectType,
 114 #endif
 115                                            KernelMode,
 116                                            (PVOID *)&ParentFileObject,
 117                                            NULL);
 118         ok_eq_hex(Status, STATUS_SUCCESS);
 119         if (Status == STATUS_SUCCESS)
 120         {
 121             /* At that point, file object must point to \SystemRoot
 122              * But must not be the same FO than target (diverted file object)
 123              * This means FCB & FileName are equal
 124              * But CCB & FO are different
 125              * CCB must be != NULL, otherwise it means open failed
 126              */
 127             ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
 128             ok_eq_pointer(ParentFileObject->RelatedFileObject, NULL);
 129             ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
 130             ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
 131             ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
 132             ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
 133             ObDereferenceObject(ParentFileObject);
 134         }
 135         /* Because target exists FSD must signal it */
 136         ok_eq_long(IoStatusBlock.Information, FILE_EXISTS);
 137         ObCloseHandle(ParentHandle, KernelMode);
 138     }
 139
 140     /* Do the same with relative open */
 141     IoStatusBlock.Status = 0xFFFFFFFF;
 142     IoStatusBlock.Information = 0xFFFFFFFF;
 143     InitializeObjectAttributes(&ObjectAttributes,
 144                                &SystemRoot,
 145                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 146                                NULL, NULL);
 147     Status = ZwOpenFile(&SystemRootHandle,
 148                         GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 149                         &ObjectAttributes,
 150                         &IoStatusBlock,
 151                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 152                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
 153     ok_eq_hex(Status, STATUS_SUCCESS);
 154     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 155     if (Status == STATUS_SUCCESS)
 156     {
 157         IoStatusBlock.Status = 0xFFFFFFFF;
 158         IoStatusBlock.Information = 0xFFFFFFFF;
 159         InitializeObjectAttributes(&ObjectAttributes,
 160                                    &Regedit,
 161                                    OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 162                                    SystemRootHandle,
 163                                    NULL);
 164         Status = IoCreateFile(&ParentHandle,
 165                               GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 166                               &ObjectAttributes,
 167                               &IoStatusBlock,
 168                               NULL,
 169                               0,
 170                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 171                               FILE_OPEN,
 172                               FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 173                               NULL,
 174                               0,
 175                               CreateFileTypeNone,
 176                               NULL,
 177                               IO_OPEN_TARGET_DIRECTORY);
 178         ok_eq_hex(Status, STATUS_SUCCESS);
 179         ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 180         if (Status == STATUS_SUCCESS)
 181         {
 182             Status = ObReferenceObjectByHandle(ParentHandle,
 183                                                FILE_READ_DATA,
 184 #ifdef _PROPER_NT_EXPORTS
 185                                                *IoFileObjectType,
 186 #else
 187                                                IoFileObjectType,
 188 #endif
 189                                                KernelMode,
 190                                                (PVOID *)&ParentFileObject,
 191                                                NULL);
 192             ok_eq_hex(Status, STATUS_SUCCESS);
 193             if (Status == STATUS_SUCCESS)
 194             {
 195                 ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
 196                 ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
 197                 ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
 198                 ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
 199                 ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
 200                 Status = ObReferenceObjectByHandle(SystemRootHandle,
 201                                                    FILE_READ_DATA,
 202 #ifdef _PROPER_NT_EXPORTS
 203                                                    *IoFileObjectType,
 204 #else
 205                                                    IoFileObjectType,
 206 #endif
 207                                                    KernelMode,
 208                                                    (PVOID *)&SystemRootFileObject,
 209                                                    NULL);
 210                 ok_eq_hex(Status, STATUS_SUCCESS);
 211                 if (Status == STATUS_SUCCESS)
 212                 {
 213                     ok_eq_pointer(ParentFileObject->RelatedFileObject, SystemRootFileObject);
 214                     ok(ParentFileObject->RelatedFileObject != TargetFileObject, "File objects must be different\n");
 215                     ok(SystemRootFileObject != TargetFileObject, "File objects must be different\n");
 216                     ObDereferenceObject(SystemRootFileObject);
 217                 }
 218                 ObDereferenceObject(ParentFileObject);
 219             }
 220             ok_eq_long(IoStatusBlock.Information, FILE_EXISTS);
 221             ObCloseHandle(ParentHandle, KernelMode);
 222         }
 223         ObCloseHandle(SystemRootHandle, KernelMode);
 224     }
 225
 226     /* *** */
 227
 228     /* Now redo the same scheme, but using a target that doesn't exist
 229      * The difference will be in IoStatusBlock.Information, the FSD will
 230      * inform that the target doesn't exist.
 231      * Clear for rename :-)
 232      */
 233     IoStatusBlock.Status = 0xFFFFFFFF;
 234     IoStatusBlock.Information = 0xFFFFFFFF;
 235     InitializeObjectAttributes(&ObjectAttributes,
 236                                &SystemRootFoobar,
 237                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 238                                NULL, NULL);
 239     Status = IoCreateFile(&ParentHandle,
 240                           GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 241                           &ObjectAttributes,
 242                           &IoStatusBlock,
 243                           NULL,
 244                           0,
 245                           FILE_SHARE_READ | FILE_SHARE_WRITE,
 246                           FILE_OPEN,
 247                           FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 248                           NULL,
 249                           0,
 250                           CreateFileTypeNone,
 251                           NULL,
 252                           IO_OPEN_TARGET_DIRECTORY);
 253     ok_eq_hex(Status, STATUS_SUCCESS);
 254     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 255     if (Status == STATUS_SUCCESS)
 256     {
 257         Status = ObReferenceObjectByHandle(ParentHandle,
 258                                            FILE_READ_DATA,
 259 #ifdef _PROPER_NT_EXPORTS
 260                                            *IoFileObjectType,
 261 #else
 262                                            IoFileObjectType,
 263 #endif
 264
 265                                            KernelMode,
 266                                            (PVOID *)&ParentFileObject,
 267                                            NULL);
 268         ok_eq_hex(Status, STATUS_SUCCESS);
 269         if (Status == STATUS_SUCCESS)
 270         {
 271             ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
 272             ok_eq_pointer(ParentFileObject->RelatedFileObject, NULL);
 273             ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
 274             ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
 275             ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
 276             ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
 277             ObDereferenceObject(ParentFileObject);
 278         }
 279         ok_eq_long(IoStatusBlock.Information, FILE_DOES_NOT_EXIST);
 280         ObCloseHandle(ParentHandle, KernelMode);
 281     }
 282
 283     IoStatusBlock.Status = 0xFFFFFFFF;
 284     IoStatusBlock.Information = 0xFFFFFFFF;
 285     InitializeObjectAttributes(&ObjectAttributes,
 286                                &SystemRoot,
 287                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 288                                NULL, NULL);
 289     Status = ZwOpenFile(&SystemRootHandle,
 290                         GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 291                         &ObjectAttributes,
 292                         &IoStatusBlock,
 293                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 294                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
 295     ok_eq_hex(Status, STATUS_SUCCESS);
 296     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 297     if (Status == STATUS_SUCCESS)
 298     {
 299         IoStatusBlock.Status = 0xFFFFFFFF;
 300         IoStatusBlock.Information = 0xFFFFFFFF;
 301         InitializeObjectAttributes(&ObjectAttributes,
 302                                    &Foobar,
 303                                    OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 304                                    SystemRootHandle,
 305                                    NULL);
 306         Status = IoCreateFile(&ParentHandle,
 307                               GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 308                               &ObjectAttributes,
 309                               &IoStatusBlock,
 310                               NULL,
 311                               0,
 312                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 313                               FILE_OPEN,
 314                               FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 315                               NULL,
 316                               0,
 317                               CreateFileTypeNone,
 318                               NULL,
 319                               IO_OPEN_TARGET_DIRECTORY);
 320         ok_eq_hex(Status, STATUS_SUCCESS);
 321         ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 322         if (Status == STATUS_SUCCESS)
 323         {
 324             Status = ObReferenceObjectByHandle(ParentHandle,
 325                                                FILE_READ_DATA,
 326 #ifdef _PROPER_NT_EXPORTS
 327                                                *IoFileObjectType,
 328 #else
 329                                                IoFileObjectType,
 330 #endif
 331
 332                                                KernelMode,
 333                                                (PVOID *)&ParentFileObject,
 334                                                NULL);
 335             ok_eq_hex(Status, STATUS_SUCCESS);
 336             if (Status == STATUS_SUCCESS)
 337             {
 338                 ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
 339                 ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
 340                 ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
 341                 ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
 342                 ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
 343                 Status = ObReferenceObjectByHandle(SystemRootHandle,
 344                                                    FILE_READ_DATA,
 345 #ifdef _PROPER_NT_EXPORTS
 346                                                    *IoFileObjectType,
 347 #else
 348                                                    IoFileObjectType,
 349 #endif
 350
 351                                                    KernelMode,
 352                                                    (PVOID *)&SystemRootFileObject,
 353                                                    NULL);
 354                 ok_eq_hex(Status, STATUS_SUCCESS);
 355                 if (Status == STATUS_SUCCESS)
 356                 {
 357                     ok_eq_pointer(ParentFileObject->RelatedFileObject, SystemRootFileObject);
 358                     ok(ParentFileObject->RelatedFileObject != TargetFileObject, "File objects must be different\n");
 359                     ok(SystemRootFileObject != TargetFileObject, "File objects must be different\n");
 360                     ObDereferenceObject(SystemRootFileObject);
 361                 }
 362                 ObDereferenceObject(ParentFileObject);
 363             }
 364             ok_eq_long(IoStatusBlock.Information, FILE_DOES_NOT_EXIST);
 365             ObCloseHandle(ParentHandle, KernelMode);
 366         }
 367         ObCloseHandle(SystemRootHandle, KernelMode);
 368     }
 369
 370     ObDereferenceObject(TargetFileObject);
 371     ObCloseHandle(TargetHandle, KernelMode);
 372
 373     /* *** */
 374
 375     /* Direct target open of something that doesn't exist */
 376     IoStatusBlock.Status = 0xFFFFFFFF;
 377     IoStatusBlock.Information = 0xFFFFFFFF;
 378     InitializeObjectAttributes(&ObjectAttributes,
 379                                &SystemRootFoobarFoobar,
 380                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 381                                NULL, NULL);
 382     Status = IoCreateFile(&ParentHandle,
 383                           GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 384                           &ObjectAttributes,
 385                           &IoStatusBlock,
 386                           NULL,
 387                           0,
 388                           FILE_SHARE_READ | FILE_SHARE_WRITE,
 389                           FILE_OPEN,
 390                           FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 391                           NULL,
 392                           0,
 393                           CreateFileTypeNone,
 394                           NULL,
 395                           IO_OPEN_TARGET_DIRECTORY);
 396     ok_eq_hex(Status, STATUS_OBJECT_PATH_NOT_FOUND);
 397     ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
 398     if (Status == STATUS_SUCCESS)
 399     {
 400         ObCloseHandle(ParentHandle, KernelMode);
 401     }
 402
 403     /* Relative target open of something that doesn't exist */
 404     IoStatusBlock.Status = 0xFFFFFFFF;
 405     IoStatusBlock.Information = 0xFFFFFFFF;
 406     InitializeObjectAttributes(&ObjectAttributes,
 407                                &SystemRoot,
 408                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 409                                NULL, NULL);
 410     Status = ZwOpenFile(&SystemRootHandle,
 411                         GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 412                         &ObjectAttributes,
 413                         &IoStatusBlock,
 414                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 415                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
 416     ok_eq_hex(Status, STATUS_SUCCESS);
 417     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 418     if (Status == STATUS_SUCCESS)
 419     {
 420         IoStatusBlock.Status = 0xFFFFFFFF;
 421         IoStatusBlock.Information = 0xFFFFFFFF;
 422         InitializeObjectAttributes(&ObjectAttributes,
 423                                    &FoobarFoobar,
 424                                    OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 425                                    SystemRootHandle,
 426                                    NULL);
 427         Status = IoCreateFile(&ParentHandle,
 428                               GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 429                               &ObjectAttributes,
 430                               &IoStatusBlock,
 431                               NULL,
 432                               0,
 433                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 434                               FILE_OPEN,
 435                               FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 436                               NULL,
 437                               0,
 438                               CreateFileTypeNone,
 439                               NULL,
 440                               IO_OPEN_TARGET_DIRECTORY);
 441         ok_eq_hex(Status, STATUS_OBJECT_PATH_NOT_FOUND);
 442         ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
 443         if (Status == STATUS_SUCCESS)
 444         {
 445             ObCloseHandle(ParentHandle, KernelMode);
 446         }
 447         ObCloseHandle(SystemRootHandle, KernelMode);
 448     }
 449 }
 450
 451 static
 452 VOID
 453 NTAPI
 454 UserModeTest(VOID)
 455 {
 456     NTSTATUS Status;
 457     IO_STATUS_BLOCK IoStatusBlock;
 458     OBJECT_ATTRIBUTES ObjectAttributes;
 459     HANDLE ParentHandle, SystemRootHandle;
 460
 461     ok(ExGetPreviousMode() == UserMode, "KernelMode returned!\n");
 462
 463     /* Attempt direct target open */
 464     IoStatusBlock.Status = 0xFFFFFFFF;
 465     IoStatusBlock.Information = 0xFFFFFFFF;
 466     InitializeObjectAttributes(&ObjectAttributes,
 467                                &SystemRootRegedit,
 468                                OBJ_CASE_INSENSITIVE,
 469                                NULL, NULL);
 470     Status = IoCreateFile(&ParentHandle,
 471                           GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 472                           &ObjectAttributes,
 473                           &IoStatusBlock,
 474                           NULL,
 475                           0,
 476                           FILE_SHARE_READ | FILE_SHARE_WRITE,
 477                           FILE_OPEN,
 478                           FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 479                           NULL,
 480                           0,
 481                           CreateFileTypeNone,
 482                           NULL,
 483                           IO_OPEN_TARGET_DIRECTORY);
 484     ok_eq_hex(Status, STATUS_ACCESS_VIOLATION);
 485     ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
 486     if (Status == STATUS_SUCCESS)
 487     {
 488         ObCloseHandle(ParentHandle, KernelMode);
 489     }
 490
 491     /* Attempt relative target open */
 492     IoStatusBlock.Status = 0xFFFFFFFF;
 493     IoStatusBlock.Information = 0xFFFFFFFF;
 494     InitializeObjectAttributes(&ObjectAttributes,
 495                                &SystemRoot,
 496                                OBJ_CASE_INSENSITIVE,
 497                                NULL, NULL);
 498     Status = ZwOpenFile(&SystemRootHandle,
 499                         GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 500                         &ObjectAttributes,
 501                         &IoStatusBlock,
 502                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 503                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
 504     ok_eq_hex(Status, STATUS_SUCCESS);
 505     ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
 506     if (Status == STATUS_SUCCESS)
 507     {
 508         IoStatusBlock.Status = 0xFFFFFFFF;
 509         IoStatusBlock.Information = 0xFFFFFFFF;
 510         InitializeObjectAttributes(&ObjectAttributes,
 511                                    &Regedit,
 512                                    OBJ_CASE_INSENSITIVE,
 513                                    SystemRootHandle,
 514                                    NULL);
 515         Status = IoCreateFile(&ParentHandle,
 516                               GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
 517                               &ObjectAttributes,
 518                               &IoStatusBlock,
 519                               NULL,
 520                               0,
 521                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 522                               FILE_OPEN,
 523                               FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
 524                               NULL,
 525                               0,
 526                               CreateFileTypeNone,
 527                               NULL,
 528                               IO_OPEN_TARGET_DIRECTORY);
 529         ok_eq_hex(Status, STATUS_ACCESS_VIOLATION);
 530         ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
 531         if (Status == STATUS_SUCCESS)
 532         {
 533             ObCloseHandle(ParentHandle, KernelMode);
 534         }
 535         ObCloseHandle(SystemRootHandle, KernelMode);
 536     }
 537 }
 538
 539 START_TEST(IoCreateFile)
 540 {
 541     NTSTATUS Status;
 542     OBJECT_ATTRIBUTES ObjectAttributes;
 543     HANDLE ThreadHandle;
 544     PVOID ThreadObject = NULL;
 545
 546     /* Justify the next comment/statement */
 547     UserModeTest();
 548
 549     /* We've to be in kernel mode, so spawn a thread */
 550     InitializeObjectAttributes(&ObjectAttributes,
 551                                NULL,
 552                                OBJ_KERNEL_HANDLE,
 553                                NULL,
 554                                NULL);
 555     Status = PsCreateSystemThread(&ThreadHandle,
 556                                   SYNCHRONIZE,
 557                                   &ObjectAttributes,
 558                                   NULL,
 559                                   NULL,
 560                                   KernelModeTest,
 561                                   NULL);
 562     ok_eq_hex(Status, STATUS_SUCCESS);
 563     if (Status == STATUS_SUCCESS)
 564     {
 565         /* Then, just wait on our thread to finish */
 566         Status = ObReferenceObjectByHandle(ThreadHandle,
 567                                            SYNCHRONIZE,
 568 #ifdef _PROPER_NT_EXPORTS
 569                                            *PsThreadType,
 570 #else
 571                                            PsThreadType,
 572 #endif
 573                                            KernelMode,
 574                                            &ThreadObject,
 575                                            NULL);
 576         ObCloseHandle(ThreadHandle, KernelMode);
 577
 578         Status = KeWaitForSingleObject(ThreadObject,
 579                                        Executive,
 580                                        KernelMode,
 581                                        FALSE,
 582                                        NULL);
 583         ok_eq_hex(Status, STATUS_SUCCESS);
 584         ObDereferenceObject(ThreadObject);
 585     }
 586 }