reactos/ntoskrnl/ob/object.c

   1 /* $Id: object.c,v 1.77 2004/03/12 00:46:35 dwelch 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 = NameSpaceRoot;
 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   RtlZeroMemory(Header, OBJECT_ALLOC_SIZE(ObjectSize));
 381
 382   /* Initialize the object header */
 383   Header->HandleCount = 0;
 384   Header->RefCount = 1;
 385   Header->ObjectType = Type;
 386   if (ObjectAttributes != NULL &&
 387       ObjectAttributes->Attributes & OBJ_PERMANENT)
 388     {
 389       Header->Permanent = TRUE;
 390     }
 391   else
 392     {
 393       Header->Permanent = FALSE;
 394     }
 395
 396   if (ObjectAttributes != NULL &&
 397       ObjectAttributes->Attributes & OBJ_INHERIT)
 398     {
 399       Header->Inherit = TRUE;
 400     }
 401   else
 402     {
 403       Header->Inherit = FALSE;
 404     }
 405
 406   RtlInitUnicodeString(&(Header->Name),NULL);
 407
 408   if (Parent != NULL)
 409     {
 410       ParentHeader = BODY_TO_HEADER(Parent);
 411     }
 412
 413   if (ParentHeader != NULL &&
 414       ParentHeader->ObjectType == ObDirectoryType &&
 415       RemainingPath.Buffer != NULL)
 416     {
 417       NamePtr = RemainingPath.Buffer;
 418       if (*NamePtr == L'\\')
 419         NamePtr++;
 420
 421       ObpAddEntryDirectory(Parent,
 422                            Header,
 423                            NamePtr);
 424
 425       ObjectAttached = TRUE;
 426     }
 427
 428   if ((Header->ObjectType != NULL) &&
 429       (Header->ObjectType->Create != NULL))
 430     {
 431       DPRINT("Calling %x\n", Header->ObjectType->Create);
 432       Status = Header->ObjectType->Create(HEADER_TO_BODY(Header),
 433                                           Parent,
 434                                           RemainingPath.Buffer,
 435                                           ObjectAttributes);
 436       if (!NT_SUCCESS(Status))
 437         {
 438           if (ObjectAttached == TRUE)
 439             {
 440               ObpRemoveEntryDirectory(Header);
 441             }
 442           if (Parent)
 443             {
 444               ObDereferenceObject(Parent);
 445             }
 446           RtlFreeUnicodeString(&Header->Name);
 447           RtlFreeUnicodeString(&RemainingPath);
 448           ExFreePool(Header);
 449           return(Status);
 450         }
 451     }
 452   RtlFreeUnicodeString( &RemainingPath );
 453
 454   if (Object != NULL)
 455     {
 456       *Object = HEADER_TO_BODY(Header);
 457     }
 458
 459   return(STATUS_SUCCESS);
 460 }
 461
 462
 463 /*
 464  * @implemented
 465  */
 466 NTSTATUS STDCALL
 467 ObReferenceObjectByPointer(IN PVOID Object,
 468                            IN ACCESS_MASK DesiredAccess,
 469                            IN POBJECT_TYPE ObjectType,
 470                            IN KPROCESSOR_MODE AccessMode)
 471 /*
 472  * FUNCTION: Increments the pointer reference count for a given object
 473  * ARGUMENTS:
 474  *         ObjectBody = Object's body
 475  *         DesiredAccess = Desired access to the object
 476  *         ObjectType = Points to the object type structure
 477  *         AccessMode = Type of access check to perform
 478  * RETURNS: Status
 479  */
 480 {
 481    POBJECT_HEADER Header;
 482
 483    DPRINT("ObReferenceObjectByPointer(Object %x, ObjectType %x)\n",
 484           Object,ObjectType);
 485
 486    Header = BODY_TO_HEADER(Object);
 487
 488    if (ObjectType != NULL && Header->ObjectType != ObjectType)
 489      {
 490         DPRINT("Failed %x (type was %x %S) should be %x %S\n",
 491                 Header,
 492                 Header->ObjectType,
 493                 Header->ObjectType->TypeName.Buffer,
 494                 ObjectType,
 495     ObjectType->TypeName.Buffer);
 496         return(STATUS_UNSUCCESSFUL);
 497      }
 498    if (Header->ObjectType == PsProcessType)
 499      {
 500         DPRINT("Ref p 0x%x refcount %d type %x ",
 501                 Object, Header->RefCount, PsProcessType);
 502         DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 503      }
 504    if (Header->ObjectType == PsThreadType)
 505      {
 506         DPRINT("Deref t 0x%x with refcount %d type %x ",
 507                 Object, Header->RefCount, PsThreadType);
 508         DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 509      }
 510
 511    if (Header->CloseInProcess)
 512    {
 513       if (Header->ObjectType == PsProcessType)
 514         {
 515           return STATUS_PROCESS_IS_TERMINATING;
 516         }
 517       if (Header->ObjectType == PsThreadType)
 518         {
 519           return STATUS_THREAD_IS_TERMINATING;
 520         }
 521       return(STATUS_UNSUCCESSFUL);
 522    }
 523
 524    InterlockedIncrement(&Header->RefCount);
 525
 526    return(STATUS_SUCCESS);
 527 }
 528
 529
 530 /*
 531  * @implemented
 532  */
 533 NTSTATUS STDCALL
 534 ObOpenObjectByPointer(IN POBJECT Object,
 535                       IN ULONG HandleAttributes,
 536                       IN PACCESS_STATE PassedAccessState,
 537                       IN ACCESS_MASK DesiredAccess,
 538                       IN POBJECT_TYPE ObjectType,
 539                       IN KPROCESSOR_MODE AccessMode,
 540                       OUT PHANDLE Handle)
 541 {
 542    NTSTATUS Status;
 543
 544    DPRINT("ObOpenObjectByPointer()\n");
 545
 546    Status = ObReferenceObjectByPointer(Object,
 547                                        0,
 548                                        ObjectType,
 549                                        AccessMode);
 550    if (!NT_SUCCESS(Status))
 551      {
 552         return Status;
 553      }
 554
 555    Status = ObCreateHandle(PsGetCurrentProcess(),
 556                            Object,
 557                            DesiredAccess,
 558                            (BOOLEAN)(HandleAttributes & OBJ_INHERIT),
 559                            Handle);
 560
 561    ObDereferenceObject(Object);
 562
 563    return STATUS_SUCCESS;
 564 }
 565
 566
 567 static NTSTATUS
 568 ObpDeleteObject(POBJECT_HEADER Header)
 569 {
 570   DPRINT("ObPerformRetentionChecks(Header %p)\n", Header);
 571   if (KeGetCurrentIrql() != PASSIVE_LEVEL)
 572     {
 573       DPRINT("ObpPerformRetentionChecks called at an unsupported IRQL.  Use ObpPerformRetentionChecksDpcLevel instead.\n");
 574       KEBUGCHECK(0);
 575     }
 576
 577   if (Header->ObjectType != NULL &&
 578       Header->ObjectType->Delete != NULL)
 579     {
 580       Header->ObjectType->Delete(HEADER_TO_BODY(Header));
 581     }
 582
 583   if (Header->Name.Buffer != NULL)
 584     {
 585       ObpRemoveEntryDirectory(Header);
 586       RtlFreeUnicodeString(&Header->Name);
 587     }
 588
 589   DPRINT("ObPerformRetentionChecks() = Freeing object\n");
 590   ExFreePool(Header);
 591
 592   return(STATUS_SUCCESS);
 593 }
 594
 595
 596 VOID STDCALL
 597 ObpDeleteObjectWorkRoutine (IN PVOID Parameter)
 598 {
 599   PRETENTION_CHECK_PARAMS Params = (PRETENTION_CHECK_PARAMS)Parameter;
 600   /* ULONG Tag; */ /* See below */
 601
 602   assert(Params);
 603   assert(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */
 604
 605   /* Turn this on when we have ExFreePoolWithTag
 606   Tag = Params->ObjectHeader->ObjectType->Tag; */
 607   ObpDeleteObject(Params->ObjectHeader);
 608   ExFreePool(Params);
 609   /* ExFreePoolWithTag(Params, Tag); */
 610 }
 611
 612
 613 STATIC NTSTATUS
 614 ObpDeleteObjectDpcLevel(IN POBJECT_HEADER ObjectHeader,
 615                         IN LONG OldRefCount)
 616 {
 617   if (ObjectHeader->RefCount < 0)
 618     {
 619       CPRINT("Object %p/%p has invalid reference count (%d)\n",
 620              ObjectHeader, HEADER_TO_BODY(ObjectHeader),
 621              ObjectHeader->RefCount);
 622       KEBUGCHECK(0);
 623     }
 624
 625   if (ObjectHeader->HandleCount < 0)
 626     {
 627       CPRINT("Object %p/%p has invalid handle count (%d)\n",
 628              ObjectHeader, HEADER_TO_BODY(ObjectHeader),
 629              ObjectHeader->HandleCount);
 630       KEBUGCHECK(0);
 631     }
 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 ObpDeleteObject (ObjectHeader);
 644
 645     case APC_LEVEL:
 646     case DISPATCH_LEVEL:
 647       {
 648         PRETENTION_CHECK_PARAMS Params;
 649
 650         /*
 651           We use must succeed pool here because if the allocation fails
 652           then we leak memory.
 653         */
 654         Params = (PRETENTION_CHECK_PARAMS)
 655           ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
 656                                 sizeof(RETENTION_CHECK_PARAMS),
 657                                 ObjectHeader->ObjectType->Tag);
 658         Params->ObjectHeader = ObjectHeader;
 659         ExInitializeWorkItem(&Params->WorkItem,
 660                              ObpDeleteObjectWorkRoutine,
 661                              (PVOID)Params);
 662         ExQueueWorkItem(&Params->WorkItem,
 663                         CriticalWorkQueue);
 664       }
 665       return STATUS_PENDING;
 666
 667     default:
 668       DPRINT("ObpPerformRetentionChecksDpcLevel called at unsupported "
 669              "IRQL %u!\n", KeGetCurrentIrql());
 670       KEBUGCHECK(0);
 671       return STATUS_UNSUCCESSFUL;
 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   /* No one should be referencing an object once we are deleting it. */
 704   if (Header->CloseInProcess)
 705     {
 706       KEBUGCHECK(0);
 707     }
 708
 709   (VOID)InterlockedIncrement(&Header->RefCount);
 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   LONG NewRefCount;
 734   BOOL Permanent;
 735   ULONG HandleCount;
 736
 737   assert(Object);
 738
 739   /* Extract the object header. */
 740   Header = BODY_TO_HEADER(Object);
 741   Permanent = Header->Permanent;
 742   HandleCount = Header->HandleCount;
 743
 744   /*
 745      Drop our reference and get the new count so we can tell if this was the
 746      last reference.
 747   */
 748   NewRefCount = InterlockedDecrement(&Header->RefCount);
 749   assert(NewRefCount >= 0);
 750
 751   /* Check whether the object can now be deleted. */
 752   if (NewRefCount == 0 &&
 753       HandleCount == 0 &&
 754       !Permanent)
 755     {
 756       ObpDeleteObjectDpcLevel(Header, NewRefCount);
 757     }
 758 }
 759
 760
 761 /**********************************************************************
 762  * NAME                                                 EXPORTED
 763  *      ObGetObjectPointerCount@4
 764  *
 765  * DESCRIPTION
 766  *      Retrieves the pointer(reference) count of the given object.
 767  *
 768  * ARGUMENTS
 769  *      ObjectBody = Body of the object.
 770  *
 771  * RETURN VALUE
 772  *      Reference count.
 773  *
 774  * @implemented
 775  */
 776 ULONG STDCALL
 777 ObGetObjectPointerCount(PVOID Object)
 778 {
 779   POBJECT_HEADER Header;
 780
 781   assert(Object);
 782   Header = BODY_TO_HEADER(Object);
 783
 784   return(Header->RefCount);
 785 }
 786
 787
 788 /**********************************************************************
 789  * NAME                                                 INTERNAL
 790  *      ObGetObjectHandleCount@4
 791  *
 792  * DESCRIPTION
 793  *      Retrieves the handle count of the given object.
 794  *
 795  * ARGUMENTS
 796  *      ObjectBody = Body of the object.
 797  *
 798  * RETURN VALUE
 799  *      Reference count.
 800  */
 801 ULONG
 802 ObGetObjectHandleCount(PVOID Object)
 803 {
 804   POBJECT_HEADER Header;
 805
 806   assert(Object);
 807   Header = BODY_TO_HEADER(Object);
 808
 809   return(Header->HandleCount);
 810 }
 811
 812
 813 /**********************************************************************
 814  * NAME                                                 EXPORTED
 815  *      ObDereferenceObject@4
 816  *
 817  * DESCRIPTION
 818  *      Decrements a given object's reference count and performs
 819  *      retention checks.
 820  *
 821  * ARGUMENTS
 822  *      ObjectBody = Body of the object.
 823  *
 824  * RETURN VALUE
 825  *      None.
 826  *
 827  * @implemented
 828  */
 829
 830 #ifdef ObDereferenceObject
 831 #undef ObDereferenceObject
 832 #endif
 833
 834 VOID STDCALL
 835 ObDereferenceObject(IN PVOID Object)
 836 {
 837   ObfDereferenceObject(Object);
 838 }
 839
 840 /* EOF */