reactos/ntoskrnl/ob/object.c

   1 /* $Id: object.c,v 1.73 2003/12/30 18:52:05 fireball Exp $
   2  *
   3  * COPYRIGHT:     See COPYING in the top level directory
   4  * PROJECT:       ReactOS kernel
   5  * FILE:          ntoskrnl/ob/object.c
   6  * PURPOSE:       Implements generic object managment functions
   7  * PROGRAMMERS    David Welch (welch@cwcom.net), Skywing (skywing@valhallalegends.com)
   8  * UPDATE HISTORY:
   9  *               10/06/98: Created
  10  *               09/13/03: Fixed various ObXxx routines to not call retention
  11  *                         checks directly at a raised IRQL.
  12  */
  13
  14 /* INCLUDES *****************************************************************/
  15
  16 #define NTOS_MODE_KERNEL
  17 #include <ntos.h>
  18 #include <roscfg.h>
  19 #include <internal/ob.h>
  20 #include <internal/ps.h>
  21 #include <internal/id.h>
  22 #include <internal/ke.h>
  23
  24 #define NDEBUG
  25 #include <internal/debug.h>
  26
  27
  28 typedef struct _RETENTION_CHECK_PARAMS
  29 {
  30   WORK_QUEUE_ITEM WorkItem;
  31   POBJECT_HEADER ObjectHeader;
  32 } RETENTION_CHECK_PARAMS, *PRETENTION_CHECK_PARAMS;
  33
  34
  35 /* FUNCTIONS ************************************************************/
  36
  37 PVOID HEADER_TO_BODY(POBJECT_HEADER obj)
  38 {
  39    return(((char*)obj)+sizeof(OBJECT_HEADER)-sizeof(COMMON_BODY_HEADER));
  40 }
  41
  42
  43 POBJECT_HEADER BODY_TO_HEADER(PVOID body)
  44 {
  45    PCOMMON_BODY_HEADER chdr = (PCOMMON_BODY_HEADER)body;
  46    return(CONTAINING_RECORD((&(chdr->Type)),OBJECT_HEADER,Type));
  47 }
  48
  49
  50 /**********************************************************************
  51  * NAME                                                 PRIVATE
  52  *      ObFindObject@16
  53  *
  54  * DESCRIPTION
  55  *
  56  * ARGUMENTS
  57  *      ObjectAttributes
  58  *
  59  *      ReturnedObject
  60  *
  61  *      RemainigPath
  62  *              Pointer to a unicode string that will contain the
  63  *              remaining path if the function returns successfully.
  64  *              The caller must free the buffer after use by calling
  65  *              RtlFreeUnicodeString ().
  66  *
  67  *      ObjectType
  68  *              Optional pointer to an object type. This is used to
  69  *              descide if a symbolic link object will be parsed or not.
  70  *
  71  * RETURN VALUE
  72  */
  73 NTSTATUS
  74 ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
  75              PVOID* ReturnedObject,
  76              PUNICODE_STRING RemainingPath,
  77              POBJECT_TYPE ObjectType)
  78 {
  79    PVOID NextObject;
  80    PVOID CurrentObject;
  81    PVOID RootObject;
  82    POBJECT_HEADER CurrentHeader;
  83    NTSTATUS Status;
  84    PWSTR current;
  85    UNICODE_STRING PathString;
  86    ULONG Attributes;
  87    PUNICODE_STRING ObjectName;
  88
  89    DPRINT("ObFindObject(ObjectAttributes %x, ReturnedObject %x, "
  90           "RemainingPath %x)\n",ObjectAttributes,ReturnedObject,RemainingPath);
  91    DPRINT("ObjectAttributes->ObjectName %wZ\n",
  92           ObjectAttributes->ObjectName);
  93
  94    RtlInitUnicodeString (RemainingPath, NULL);
  95
  96    if (ObjectAttributes->RootDirectory == NULL)
  97      {
  98         ObReferenceObjectByPointer(NameSpaceRoot,
  99                                    DIRECTORY_TRAVERSE,
 100                                    NULL,
 101                                    UserMode);
 102         CurrentObject = NameSpaceRoot;
 103      }
 104    else
 105      {
 106         Status = ObReferenceObjectByHandle(ObjectAttributes->RootDirectory,
 107                                            DIRECTORY_TRAVERSE,
 108                                            NULL,
 109                                            UserMode,
 110                                            &CurrentObject,
 111                                            NULL);
 112         if (!NT_SUCCESS(Status))
 113           {
 114              return(Status);
 115           }
 116      }
 117
 118   ObjectName = ObjectAttributes->ObjectName;
 119   if (ObjectName->Length == 0 ||
 120       ObjectName->Buffer[0] == UNICODE_NULL)
 121     {
 122       *ReturnedObject = CurrentObject;
 123       return STATUS_SUCCESS;
 124     }
 125
 126   if (ObjectAttributes->RootDirectory == NULL &&
 127       ObjectName->Buffer[0] != L'\\')
 128     {
 129       ObDereferenceObject (CurrentObject);
 130       return STATUS_UNSUCCESSFUL;
 131     }
 132
 133   /* Create a zero-terminated copy of the object name */
 134   PathString.Length = ObjectName->Length;
 135   PathString.MaximumLength = ObjectName->Length + sizeof(WCHAR);
 136   PathString.Buffer = ExAllocatePool (NonPagedPool,
 137                                       PathString.MaximumLength);
 138   if (PathString.Buffer == NULL)
 139     {
 140       ObDereferenceObject (CurrentObject);
 141       return STATUS_INSUFFICIENT_RESOURCES;
 142     }
 143
 144   RtlCopyMemory (PathString.Buffer,
 145                  ObjectName->Buffer,
 146                  ObjectName->Length);
 147   PathString.Buffer[PathString.Length / sizeof(WCHAR)] = UNICODE_NULL;
 148
 149   current = PathString.Buffer;
 150
 151    RootObject = CurrentObject;
 152    Attributes = ObjectAttributes->Attributes;
 153    if (ObjectType == ObSymbolicLinkType)
 154      Attributes |= OBJ_OPENLINK;
 155
 156    while (TRUE)
 157      {
 158         DPRINT("current %S\n",current);
 159         CurrentHeader = BODY_TO_HEADER(CurrentObject);
 160
 161         DPRINT("Current ObjectType %wZ\n",
 162                &CurrentHeader->ObjectType->TypeName);
 163
 164         if (CurrentHeader->ObjectType->Parse == NULL)
 165           {
 166              DPRINT("Current object can't parse\n");
 167              break;
 168           }
 169         Status = CurrentHeader->ObjectType->Parse(CurrentObject,
 170                                                   &NextObject,
 171                                                   &PathString,
 172                                                   &current,
 173                                                   Attributes);
 174         if (Status == STATUS_REPARSE)
 175           {
 176              /* reparse the object path */
 177              NextObject = RootObject;
 178              current = PathString.Buffer;
 179
 180              ObReferenceObjectByPointer(NextObject,
 181                                         DIRECTORY_TRAVERSE,
 182                                         NULL,
 183                                         UserMode);
 184           }
 185
 186         if (NextObject == NULL)
 187           {
 188              break;
 189           }
 190         ObDereferenceObject(CurrentObject);
 191         CurrentObject = NextObject;
 192      }
 193
 194    if (current)
 195       RtlCreateUnicodeString (RemainingPath, current);
 196    RtlFreeUnicodeString (&PathString);
 197    *ReturnedObject = CurrentObject;
 198
 199    return(STATUS_SUCCESS);
 200 }
 201
 202
 203 /**********************************************************************
 204  * NAME                                                 EXPORTED
 205  *      ObQueryNameString@16
 206  *
 207  * DESCRIPTION
 208  *
 209  * ARGUMENTS
 210  *
 211  * RETURN VALUE
 212  *
 213  * @implemented
 214  */
 215 NTSTATUS STDCALL
 216 ObQueryNameString (IN PVOID Object,
 217                    OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
 218                    IN ULONG Length,
 219                    OUT PULONG ReturnLength)
 220 {
 221   POBJECT_NAME_INFORMATION LocalInfo;
 222   POBJECT_HEADER ObjectHeader;
 223   ULONG LocalReturnLength;
 224   NTSTATUS Status;
 225
 226   *ReturnLength = 0;
 227
 228   if (Length < sizeof(OBJECT_NAME_INFORMATION) + sizeof(WCHAR))
 229     return STATUS_INVALID_BUFFER_SIZE;
 230
 231   ObjectNameInfo->Name.MaximumLength = (USHORT)(Length - sizeof(OBJECT_NAME_INFORMATION));
 232   ObjectNameInfo->Name.Length = 0;
 233   ObjectNameInfo->Name.Buffer =
 234     (PWCHAR)((ULONG_PTR)ObjectNameInfo + sizeof(OBJECT_NAME_INFORMATION));
 235   ObjectNameInfo->Name.Buffer[0] = 0;
 236
 237   ObjectHeader = BODY_TO_HEADER(Object);
 238
 239   if (ObjectHeader->ObjectType != NULL &&
 240       ObjectHeader->ObjectType->QueryName != NULL)
 241     {
 242       DPRINT ("Calling %x\n", ObjectHeader->ObjectType->QueryName);
 243       Status = ObjectHeader->ObjectType->QueryName (Object,
 244                                                     ObjectNameInfo,
 245                                                     Length,
 246                                                     ReturnLength);
 247     }
 248   else if (ObjectHeader->Name.Length > 0 && ObjectHeader->Name.Buffer != NULL)
 249     {
 250       DPRINT ("Object does not have a 'QueryName' function\n");
 251
 252       if (ObjectHeader->Parent == NameSpaceRoot)
 253         {
 254           DPRINT ("Reached the root directory\n");
 255           ObjectNameInfo->Name.Length = 0;
 256           ObjectNameInfo->Name.Buffer[0] = 0;
 257           Status = STATUS_SUCCESS;
 258         }
 259       else if (ObjectHeader->Parent != NULL)
 260         {
 261           LocalInfo = ExAllocatePool (NonPagedPool,
 262                                       sizeof(OBJECT_NAME_INFORMATION) +
 263                                       MAX_PATH * sizeof(WCHAR));
 264           if (LocalInfo == NULL)
 265             return STATUS_INSUFFICIENT_RESOURCES;
 266
 267           Status = ObQueryNameString (ObjectHeader->Parent,
 268                                       LocalInfo,
 269                                       MAX_PATH * sizeof(WCHAR),
 270                                       &LocalReturnLength);
 271           if (!NT_SUCCESS (Status))
 272             {
 273               ExFreePool (LocalInfo);
 274               return Status;
 275             }
 276
 277           Status = RtlAppendUnicodeStringToString (&ObjectNameInfo->Name,
 278                                                    &LocalInfo->Name);
 279
 280           ExFreePool (LocalInfo);
 281
 282           if (!NT_SUCCESS (Status))
 283             return Status;
 284         }
 285
 286       DPRINT ("Object path %wZ\n", &ObjectHeader->Name);
 287       Status = RtlAppendUnicodeToString (&ObjectNameInfo->Name,
 288                                          L"\\");
 289       if (!NT_SUCCESS (Status))
 290         return Status;
 291
 292       Status = RtlAppendUnicodeStringToString (&ObjectNameInfo->Name,
 293                                                &ObjectHeader->Name);
 294     }
 295   else
 296     {
 297       DPRINT ("Object is unnamed\n");
 298
 299       ObjectNameInfo->Name.MaximumLength = 0;
 300       ObjectNameInfo->Name.Length = 0;
 301       ObjectNameInfo->Name.Buffer = NULL;
 302
 303       Status = STATUS_SUCCESS;
 304     }
 305
 306   if (NT_SUCCESS (Status))
 307     {
 308       ObjectNameInfo->Name.MaximumLength =
 309         (ObjectNameInfo->Name.Length) ? ObjectNameInfo->Name.Length + sizeof(WCHAR) : 0;
 310       *ReturnLength =
 311         sizeof(OBJECT_NAME_INFORMATION) + ObjectNameInfo->Name.MaximumLength;
 312       DPRINT ("Returned object path: %wZ\n", &ObjectNameInfo->Name);
 313     }
 314
 315   return Status;
 316 }
 317
 318
 319 /**********************************************************************
 320  * NAME                                                 EXPORTED
 321  *      ObCreateObject@36
 322  *
 323  * DESCRIPTION
 324  *
 325  * ARGUMENTS
 326  *
 327  * RETURN VALUE
 328  *      Status
 329  *
 330  * @implemented
 331  */
 332 NTSTATUS STDCALL
 333 ObCreateObject (IN KPROCESSOR_MODE ObjectAttributesAccessMode OPTIONAL,
 334                 IN POBJECT_TYPE Type,
 335                 IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
 336                 IN KPROCESSOR_MODE AccessMode,
 337                 IN OUT PVOID ParseContext OPTIONAL,
 338                 IN ULONG ObjectSize,
 339                 IN ULONG PagedPoolCharge OPTIONAL,
 340                 IN ULONG NonPagedPoolCharge OPTIONAL,
 341                 OUT PVOID *Object)
 342 {
 343   PVOID Parent = NULL;
 344   UNICODE_STRING RemainingPath;
 345   POBJECT_HEADER Header;
 346   POBJECT_HEADER ParentHeader = NULL;
 347   NTSTATUS Status;
 348   BOOLEAN ObjectAttached = FALSE;
 349   PWCHAR NamePtr;
 350
 351   assert_irql(APC_LEVEL);
 352
 353   DPRINT("ObCreateObject(Type %p ObjectAttributes %p, Object %p)\n",
 354          Type, ObjectAttributes, Object);
 355
 356   if (ObjectAttributes != NULL &&
 357       ObjectAttributes->ObjectName != NULL &&
 358       ObjectAttributes->ObjectName->Buffer != NULL)
 359     {
 360       Status = ObFindObject(ObjectAttributes,
 361                             &Parent,
 362                             &RemainingPath,
 363                             NULL);
 364       if (!NT_SUCCESS(Status))
 365         {
 366           DPRINT("ObFindObject() failed! (Status 0x%x)\n", Status);
 367           return(Status);
 368         }
 369     }
 370   else
 371     {
 372       RtlInitUnicodeString(&RemainingPath, NULL);
 373     }
 374
 375   Header = (POBJECT_HEADER)ExAllocatePoolWithTag(NonPagedPool,
 376                                                  OBJECT_ALLOC_SIZE(ObjectSize),
 377                                                  Type->Tag);
 378   if (Header == NULL)
 379     return STATUS_INSUFFICIENT_RESOURCES;
 380
 381   /* Initialize the object header */
 382   Header->HandleCount = 0;
 383   Header->RefCount = 1;
 384   Header->ObjectType = Type;
 385   if (ObjectAttributes != NULL &&
 386       ObjectAttributes->Attributes & OBJ_PERMANENT)
 387     {
 388       Header->Permanent = TRUE;
 389     }
 390   else
 391     {
 392       Header->Permanent = FALSE;
 393     }
 394
 395   if (ObjectAttributes != NULL &&
 396       ObjectAttributes->Attributes & OBJ_INHERIT)
 397     {
 398       Header->Inherit = TRUE;
 399     }
 400   else
 401     {
 402       Header->Inherit = FALSE;
 403     }
 404
 405   RtlInitUnicodeString(&(Header->Name),NULL);
 406
 407   if (Parent != NULL)
 408     {
 409       ParentHeader = BODY_TO_HEADER(Parent);
 410     }
 411
 412   if (ParentHeader != NULL &&
 413       ParentHeader->ObjectType == ObDirectoryType &&
 414       RemainingPath.Buffer != NULL)
 415     {
 416       NamePtr = RemainingPath.Buffer;
 417       if (*NamePtr == L'\\')
 418         NamePtr++;
 419
 420       ObpAddEntryDirectory(Parent,
 421                            Header,
 422                            NamePtr);
 423
 424       ObjectAttached = TRUE;
 425     }
 426
 427   if ((Header->ObjectType != NULL) &&
 428       (Header->ObjectType->Create != NULL))
 429     {
 430       DPRINT("Calling %x\n", Header->ObjectType->Create);
 431       Status = Header->ObjectType->Create(HEADER_TO_BODY(Header),
 432                                           Parent,
 433                                           RemainingPath.Buffer,
 434                                           ObjectAttributes);
 435       if (!NT_SUCCESS(Status))
 436         {
 437           if (ObjectAttached == TRUE)
 438             {
 439               ObpRemoveEntryDirectory(Header);
 440             }
 441           if (Parent)
 442             {
 443               ObDereferenceObject(Parent);
 444             }
 445           RtlFreeUnicodeString(&Header->Name);
 446           RtlFreeUnicodeString(&RemainingPath);
 447           ExFreePool(Header);
 448           return(Status);
 449         }
 450     }
 451   RtlFreeUnicodeString( &RemainingPath );
 452
 453   if (Object != NULL)
 454     {
 455       *Object = HEADER_TO_BODY(Header);
 456     }
 457
 458   return(STATUS_SUCCESS);
 459 }
 460
 461
 462 /*
 463  * @implemented
 464  */
 465 NTSTATUS STDCALL
 466 ObReferenceObjectByPointer(IN PVOID Object,
 467                            IN ACCESS_MASK DesiredAccess,
 468                            IN POBJECT_TYPE ObjectType,
 469                            IN KPROCESSOR_MODE AccessMode)
 470 /*
 471  * FUNCTION: Increments the pointer reference count for a given object
 472  * ARGUMENTS:
 473  *         ObjectBody = Object's body
 474  *         DesiredAccess = Desired access to the object
 475  *         ObjectType = Points to the object type structure
 476  *         AccessMode = Type of access check to perform
 477  * RETURNS: Status
 478  */
 479 {
 480    POBJECT_HEADER Header;
 481
 482    DPRINT("ObReferenceObjectByPointer(Object %x, ObjectType %x)\n",
 483           Object,ObjectType);
 484
 485    Header = BODY_TO_HEADER(Object);
 486
 487    if (ObjectType != NULL && Header->ObjectType != ObjectType)
 488      {
 489         DPRINT("Failed %x (type was %x %S) should be %x %S\n",
 490                 Header,
 491                 Header->ObjectType,
 492                 Header->ObjectType->TypeName.Buffer,
 493                 ObjectType,
 494     ObjectType->TypeName.Buffer);
 495         return(STATUS_UNSUCCESSFUL);
 496      }
 497    if (Header->ObjectType == PsProcessType)
 498      {
 499         DPRINT("Ref p 0x%x refcount %d type %x ",
 500                 Object, Header->RefCount, PsProcessType);
 501         DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 502      }
 503    if (Header->ObjectType == PsThreadType)
 504      {
 505         DPRINT("Deref t 0x%x with refcount %d type %x ",
 506                 Object, Header->RefCount, PsThreadType);
 507         DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 508      }
 509
 510    if (Header->CloseInProcess)
 511    {
 512       if (Header->ObjectType == PsProcessType)
 513         {
 514           return STATUS_PROCESS_IS_TERMINATING;
 515         }
 516       if (Header->ObjectType == PsThreadType)
 517         {
 518           return STATUS_THREAD_IS_TERMINATING;
 519         }
 520       return(STATUS_UNSUCCESSFUL);
 521    }
 522
 523    InterlockedIncrement(&Header->RefCount);
 524
 525    return(STATUS_SUCCESS);
 526 }
 527
 528
 529 /*
 530  * @implemented
 531  */
 532 NTSTATUS STDCALL
 533 ObOpenObjectByPointer(IN POBJECT Object,
 534                       IN ULONG HandleAttributes,
 535                       IN PACCESS_STATE PassedAccessState,
 536                       IN ACCESS_MASK DesiredAccess,
 537                       IN POBJECT_TYPE ObjectType,
 538                       IN KPROCESSOR_MODE AccessMode,
 539                       OUT PHANDLE Handle)
 540 {
 541    NTSTATUS Status;
 542
 543    DPRINT("ObOpenObjectByPointer()\n");
 544
 545    Status = ObReferenceObjectByPointer(Object,
 546                                        0,
 547                                        ObjectType,
 548                                        AccessMode);
 549    if (!NT_SUCCESS(Status))
 550      {
 551         return Status;
 552      }
 553
 554    Status = ObCreateHandle(PsGetCurrentProcess(),
 555                            Object,
 556                            DesiredAccess,
 557                            (BOOLEAN)(HandleAttributes & OBJ_INHERIT),
 558                            Handle);
 559
 560    ObDereferenceObject(Object);
 561
 562    return STATUS_SUCCESS;
 563 }
 564
 565
 566 static NTSTATUS
 567 ObpPerformRetentionChecks(POBJECT_HEADER Header)
 568 {
 569   DPRINT("ObPerformRetentionChecks(Header %p)\n", Header);
 570   if (KeGetCurrentIrql() != PASSIVE_LEVEL)
 571     {
 572       DPRINT("ObpPerformRetentionChecks called at an unsupported IRQL.  Use ObpPerformRetentionChecksDpcLevel instead.\n");
 573       KEBUGCHECK(0);
 574     }
 575
 576   if (Header->ObjectType != NULL &&
 577       Header->ObjectType->Delete != NULL)
 578     {
 579       Header->ObjectType->Delete(HEADER_TO_BODY(Header));
 580     }
 581
 582   if (Header->Name.Buffer != NULL)
 583     {
 584       ObpRemoveEntryDirectory(Header);
 585       RtlFreeUnicodeString(&Header->Name);
 586     }
 587
 588   DPRINT("ObPerformRetentionChecks() = Freeing object\n");
 589   ExFreePool(Header);
 590
 591   return(STATUS_SUCCESS);
 592 }
 593
 594
 595 VOID STDCALL
 596 ObpPerformRetentionChecksWorkRoutine (IN PVOID Parameter)
 597 {
 598   PRETENTION_CHECK_PARAMS Params = (PRETENTION_CHECK_PARAMS)Parameter;
 599   /* ULONG Tag; */ /* See below */
 600
 601   assert(Params);
 602   assert(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */
 603
 604   /* Turn this on when we have ExFreePoolWithTag
 605   Tag = Params->ObjectHeader->ObjectType->Tag; */
 606   ObpPerformRetentionChecks(Params->ObjectHeader);
 607   ExFreePool(Params);
 608   /* ExFreePoolWithTag(Params, Tag); */
 609 }
 610
 611
 612 static NTSTATUS
 613 ObpPerformRetentionChecksDpcLevel(IN POBJECT_HEADER ObjectHeader)
 614 {
 615   if (ObjectHeader->RefCount < 0)
 616     {
 617       CPRINT("Object %p/%p has invalid reference count (%d)\n",
 618              ObjectHeader, HEADER_TO_BODY(ObjectHeader), ObjectHeader->RefCount);
 619       KEBUGCHECK(0);
 620     }
 621
 622   if (ObjectHeader->HandleCount < 0)
 623     {
 624       CPRINT("Object %p/%p has invalid handle count (%d)\n",
 625              ObjectHeader, HEADER_TO_BODY(ObjectHeader), ObjectHeader->HandleCount);
 626       KEBUGCHECK(0);
 627     }
 628
 629   if (ObjectHeader->RefCount == 0 &&
 630       ObjectHeader->HandleCount == 0 &&
 631       ObjectHeader->Permanent == FALSE)
 632     {
 633       if (ObjectHeader->CloseInProcess)
 634         {
 635           KEBUGCHECK(0);
 636           return STATUS_UNSUCCESSFUL;
 637         }
 638       ObjectHeader->CloseInProcess = TRUE;
 639
 640       switch (KeGetCurrentIrql ())
 641         {
 642           case PASSIVE_LEVEL:
 643             return ObpPerformRetentionChecks (ObjectHeader);
 644
 645           case APC_LEVEL:
 646           case DISPATCH_LEVEL:
 647             {
 648               PRETENTION_CHECK_PARAMS Params;
 649
 650               /*
 651                * Can we get rid of this NonPagedPoolMustSucceed call and still be a
 652                * 'must succeed' function?  I don't like to bugcheck on no memory!
 653                */
 654               Params = (PRETENTION_CHECK_PARAMS)ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
 655                                                                       sizeof(RETENTION_CHECK_PARAMS),
 656                                                                       ObjectHeader->ObjectType->Tag);
 657               Params->ObjectHeader = ObjectHeader;
 658               ExInitializeWorkItem(&Params->WorkItem,
 659                                    ObpPerformRetentionChecksWorkRoutine,
 660                                    (PVOID)Params);
 661               ExQueueWorkItem(&Params->WorkItem,
 662                               CriticalWorkQueue);
 663             }
 664             return STATUS_PENDING;
 665
 666           default:
 667             DPRINT("ObpPerformRetentionChecksDpcLevel called at unsupported IRQL %u!\n",
 668                    KeGetCurrentIrql());
 669             KEBUGCHECK(0);
 670             return STATUS_UNSUCCESSFUL;
 671         }
 672     }
 673
 674   return STATUS_SUCCESS;
 675 }
 676
 677
 678 /**********************************************************************
 679  * NAME                                                 EXPORTED
 680  *      ObfReferenceObject@4
 681  *
 682  * DESCRIPTION
 683  *      Increments a given object's reference count and performs
 684  *      retention checks.
 685  *
 686  * ARGUMENTS
 687  *  ObjectBody = Body of the object.
 688  *
 689  * RETURN VALUE
 690  *      None.
 691  *
 692  * @implemented
 693  */
 694 VOID FASTCALL
 695 ObfReferenceObject(IN PVOID Object)
 696 {
 697   POBJECT_HEADER Header;
 698
 699   assert(Object);
 700
 701   Header = BODY_TO_HEADER(Object);
 702
 703   if (Header->CloseInProcess)
 704     {
 705       KEBUGCHECK(0);
 706     }
 707   InterlockedIncrement(&Header->RefCount);
 708
 709   ObpPerformRetentionChecksDpcLevel(Header);
 710 }
 711
 712
 713 /**********************************************************************
 714  * NAME                                                 EXPORTED
 715  *      ObfDereferenceObject@4
 716  *
 717  * DESCRIPTION
 718  *      Decrements a given object's reference count and performs
 719  *      retention checks.
 720  *
 721  * ARGUMENTS
 722  *      ObjectBody = Body of the object.
 723  *
 724  * RETURN VALUE
 725  *      None.
 726  *
 727  * @implemented
 728  */
 729 VOID FASTCALL
 730 ObfDereferenceObject(IN PVOID Object)
 731 {
 732   POBJECT_HEADER Header;
 733   extern POBJECT_TYPE PsProcessType;
 734
 735   assert(Object);
 736
 737   Header = BODY_TO_HEADER(Object);
 738
 739   if (Header->ObjectType == PsProcessType)
 740     {
 741       DPRINT("Deref p 0x%x with refcount %d type %x ",
 742              Object, Header->RefCount, PsProcessType);
 743       DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 744     }
 745
 746   if (Header->ObjectType == PsThreadType)
 747     {
 748       DPRINT("Deref t 0x%x with refcount %d type %x ",
 749              Object, Header->RefCount, PsThreadType);
 750       DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 751     }
 752
 753   InterlockedDecrement(&Header->RefCount);
 754
 755   ObpPerformRetentionChecksDpcLevel(Header);
 756 }
 757
 758
 759 /**********************************************************************
 760  * NAME                                                 EXPORTED
 761  *      ObGetObjectPointerCount@4
 762  *
 763  * DESCRIPTION
 764  *      Retrieves the pointer(reference) count of the given object.
 765  *
 766  * ARGUMENTS
 767  *      ObjectBody = Body of the object.
 768  *
 769  * RETURN VALUE
 770  *      Reference count.
 771  *
 772  * @implemented
 773  */
 774 ULONG STDCALL
 775 ObGetObjectPointerCount(PVOID Object)
 776 {
 777   POBJECT_HEADER Header;
 778
 779   assert(Object);
 780   Header = BODY_TO_HEADER(Object);
 781
 782   return(Header->RefCount);
 783 }
 784
 785
 786 /**********************************************************************
 787  * NAME                                                 INTERNAL
 788  *      ObGetObjectHandleCount@4
 789  *
 790  * DESCRIPTION
 791  *      Retrieves the handle count of the given object.
 792  *
 793  * ARGUMENTS
 794  *      ObjectBody = Body of the object.
 795  *
 796  * RETURN VALUE
 797  *      Reference count.
 798  */
 799 ULONG
 800 ObGetObjectHandleCount(PVOID Object)
 801 {
 802   POBJECT_HEADER Header;
 803
 804   assert(Object);
 805   Header = BODY_TO_HEADER(Object);
 806
 807   return(Header->HandleCount);
 808 }
 809
 810
 811 /**********************************************************************
 812  * NAME                                                 EXPORTED
 813  *      ObDereferenceObject@4
 814  *
 815  * DESCRIPTION
 816  *      Decrements a given object's reference count and performs
 817  *      retention checks.
 818  *
 819  * ARGUMENTS
 820  *      ObjectBody = Body of the object.
 821  *
 822  * RETURN VALUE
 823  *      None.
 824  *
 825  * @implemented
 826  */
 827
 828 #ifdef ObDereferenceObject
 829 #undef ObDereferenceObject
 830 #endif
 831
 832 VOID STDCALL
 833 ObDereferenceObject(IN PVOID Object)
 834 {
 835   ObfDereferenceObject(Object);
 836 }
 837
 838 /* EOF */