reactos/ntoskrnl/ob/object.c

   1 /* $Id: object.c,v 1.79 2004/07/18 13:03:43 ekohl 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   PSECURITY_DESCRIPTOR NewSecurityDescriptor = NULL;
 351
 352   assert_irql(APC_LEVEL);
 353
 354   DPRINT("ObCreateObject(Type %p ObjectAttributes %p, Object %p)\n",
 355          Type, ObjectAttributes, Object);
 356
 357   if (Type == NULL)
 358     {
 359       DPRINT1("Invalid object type!\n");
 360       return STATUS_INVALID_PARAMETER;
 361     }
 362
 363   if (ObjectAttributes != NULL &&
 364       ObjectAttributes->ObjectName != NULL &&
 365       ObjectAttributes->ObjectName->Buffer != NULL)
 366     {
 367       Status = ObFindObject(ObjectAttributes,
 368                             &Parent,
 369                             &RemainingPath,
 370                             NULL);
 371       if (!NT_SUCCESS(Status))
 372         {
 373           DPRINT("ObFindObject() failed! (Status 0x%x)\n", Status);
 374           return(Status);
 375         }
 376     }
 377   else
 378     {
 379       RtlInitUnicodeString(&RemainingPath, NULL);
 380     }
 381
 382   Header = (POBJECT_HEADER)ExAllocatePoolWithTag(NonPagedPool,
 383                                                  OBJECT_ALLOC_SIZE(ObjectSize),
 384                                                  Type->Tag);
 385   if (Header == NULL)
 386     return STATUS_INSUFFICIENT_RESOURCES;
 387   RtlZeroMemory(Header, OBJECT_ALLOC_SIZE(ObjectSize));
 388
 389   /* Initialize the object header */
 390   Header->HandleCount = 0;
 391   Header->RefCount = 1;
 392   Header->ObjectType = Type;
 393   if (ObjectAttributes != NULL &&
 394       ObjectAttributes->Attributes & OBJ_PERMANENT)
 395     {
 396       Header->Permanent = TRUE;
 397     }
 398   else
 399     {
 400       Header->Permanent = FALSE;
 401     }
 402
 403   if (ObjectAttributes != NULL &&
 404       ObjectAttributes->Attributes & OBJ_INHERIT)
 405     {
 406       Header->Inherit = TRUE;
 407     }
 408   else
 409     {
 410       Header->Inherit = FALSE;
 411     }
 412
 413   RtlInitUnicodeString(&(Header->Name),NULL);
 414
 415   if (Parent != NULL)
 416     {
 417       ParentHeader = BODY_TO_HEADER(Parent);
 418     }
 419
 420   if (ParentHeader != NULL &&
 421       ParentHeader->ObjectType == ObDirectoryType &&
 422       RemainingPath.Buffer != NULL)
 423     {
 424       NamePtr = RemainingPath.Buffer;
 425       if (*NamePtr == L'\\')
 426         NamePtr++;
 427
 428       ObpAddEntryDirectory(Parent,
 429                            Header,
 430                            NamePtr);
 431
 432       ObjectAttached = TRUE;
 433     }
 434
 435   if (Header->ObjectType->Create != NULL)
 436     {
 437       DPRINT("Calling %x\n", Header->ObjectType->Create);
 438       Status = Header->ObjectType->Create(HEADER_TO_BODY(Header),
 439                                           Parent,
 440                                           RemainingPath.Buffer,
 441                                           ObjectAttributes);
 442       if (!NT_SUCCESS(Status))
 443         {
 444           if (ObjectAttached == TRUE)
 445             {
 446               ObpRemoveEntryDirectory(Header);
 447             }
 448           if (Parent)
 449             {
 450               ObDereferenceObject(Parent);
 451             }
 452           RtlFreeUnicodeString(&Header->Name);
 453           RtlFreeUnicodeString(&RemainingPath);
 454           ExFreePool(Header);
 455           return(Status);
 456         }
 457     }
 458   RtlFreeUnicodeString(&RemainingPath);
 459
 460   /* Build the new security descriptor */
 461   Status = SeAssignSecurity((ParentHeader != NULL) ? ParentHeader->SecurityDescriptor : NULL,
 462                             (ObjectAttributes != NULL) ? ObjectAttributes->SecurityDescriptor : NULL,
 463                             &NewSecurityDescriptor,
 464                             (Header->ObjectType == ObDirectoryType),
 465                             NULL, //SubjectContext,
 466                             Header->ObjectType->Mapping,
 467                             PagedPool);
 468   if (NT_SUCCESS(Status))
 469     {
 470       DPRINT("NewSecurityDescriptor %p\n", NewSecurityDescriptor);
 471
 472       if (Header->ObjectType->Security != NULL)
 473         {
 474           /* FIXME: Call the security method */
 475           Status = STATUS_SUCCESS;
 476         }
 477       else
 478         {
 479           /* Assign the security descriptor to the object header */
 480           Status = ObpAddSecurityDescriptor(NewSecurityDescriptor,
 481                                             &Header->SecurityDescriptor);
 482           DPRINT("Object security descriptor %p\n", Header->SecurityDescriptor);
 483         }
 484
 485       /* Release the new security descriptor */
 486       SeDeassignSecurity(&NewSecurityDescriptor);
 487     }
 488
 489   if (Object != NULL)
 490     {
 491       *Object = HEADER_TO_BODY(Header);
 492     }
 493
 494   return(STATUS_SUCCESS);
 495 }
 496
 497
 498 /*
 499  * FUNCTION: Increments the pointer reference count for a given object
 500  * ARGUMENTS:
 501  *         ObjectBody = Object's body
 502  *         DesiredAccess = Desired access to the object
 503  *         ObjectType = Points to the object type structure
 504  *         AccessMode = Type of access check to perform
 505  * RETURNS: Status
 506  *
 507  * @implemented
 508  */
 509 NTSTATUS STDCALL
 510 ObReferenceObjectByPointer(IN PVOID Object,
 511                            IN ACCESS_MASK DesiredAccess,
 512                            IN POBJECT_TYPE ObjectType,
 513                            IN KPROCESSOR_MODE AccessMode)
 514 {
 515    POBJECT_HEADER Header;
 516
 517    DPRINT("ObReferenceObjectByPointer(Object %x, ObjectType %x)\n",
 518           Object,ObjectType);
 519
 520    Header = BODY_TO_HEADER(Object);
 521
 522    if (ObjectType != NULL && Header->ObjectType != ObjectType)
 523      {
 524         DPRINT("Failed %x (type was %x %S) should be %x %S\n",
 525                 Header,
 526                 Header->ObjectType,
 527                 Header->ObjectType->TypeName.Buffer,
 528                 ObjectType,
 529     ObjectType->TypeName.Buffer);
 530         return(STATUS_UNSUCCESSFUL);
 531      }
 532    if (Header->ObjectType == PsProcessType)
 533      {
 534         DPRINT("Ref p 0x%x refcount %d type %x ",
 535                 Object, Header->RefCount, PsProcessType);
 536         DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 537      }
 538    if (Header->ObjectType == PsThreadType)
 539      {
 540         DPRINT("Deref t 0x%x with refcount %d type %x ",
 541                 Object, Header->RefCount, PsThreadType);
 542         DPRINT("eip %x\n", ((PULONG)&Object)[-1]);
 543      }
 544
 545    if (Header->CloseInProcess)
 546    {
 547       if (Header->ObjectType == PsProcessType)
 548         {
 549           return STATUS_PROCESS_IS_TERMINATING;
 550         }
 551       if (Header->ObjectType == PsThreadType)
 552         {
 553           return STATUS_THREAD_IS_TERMINATING;
 554         }
 555       return(STATUS_UNSUCCESSFUL);
 556    }
 557
 558    InterlockedIncrement(&Header->RefCount);
 559
 560    return(STATUS_SUCCESS);
 561 }
 562
 563
 564 /*
 565  * @implemented
 566  */
 567 NTSTATUS STDCALL
 568 ObOpenObjectByPointer(IN POBJECT Object,
 569                       IN ULONG HandleAttributes,
 570                       IN PACCESS_STATE PassedAccessState,
 571                       IN ACCESS_MASK DesiredAccess,
 572                       IN POBJECT_TYPE ObjectType,
 573                       IN KPROCESSOR_MODE AccessMode,
 574                       OUT PHANDLE Handle)
 575 {
 576    NTSTATUS Status;
 577
 578    DPRINT("ObOpenObjectByPointer()\n");
 579
 580    Status = ObReferenceObjectByPointer(Object,
 581                                        0,
 582                                        ObjectType,
 583                                        AccessMode);
 584    if (!NT_SUCCESS(Status))
 585      {
 586         return Status;
 587      }
 588
 589    Status = ObCreateHandle(PsGetCurrentProcess(),
 590                            Object,
 591                            DesiredAccess,
 592                            (BOOLEAN)(HandleAttributes & OBJ_INHERIT),
 593                            Handle);
 594
 595    ObDereferenceObject(Object);
 596
 597    return STATUS_SUCCESS;
 598 }
 599
 600
 601 static NTSTATUS
 602 ObpDeleteObject(POBJECT_HEADER Header)
 603 {
 604   DPRINT("ObPerformRetentionChecks(Header %p)\n", Header);
 605   if (KeGetCurrentIrql() != PASSIVE_LEVEL)
 606     {
 607       DPRINT("ObpPerformRetentionChecks called at an unsupported IRQL.  Use ObpPerformRetentionChecksDpcLevel instead.\n");
 608       KEBUGCHECK(0);
 609     }
 610
 611   if (Header->SecurityDescriptor != NULL)
 612     {
 613       ObpRemoveSecurityDescriptor(Header->SecurityDescriptor);
 614     }
 615
 616   if (Header->ObjectType != NULL &&
 617       Header->ObjectType->Delete != NULL)
 618     {
 619       Header->ObjectType->Delete(HEADER_TO_BODY(Header));
 620     }
 621
 622   if (Header->Name.Buffer != NULL)
 623     {
 624       ObpRemoveEntryDirectory(Header);
 625       RtlFreeUnicodeString(&Header->Name);
 626     }
 627
 628   DPRINT("ObPerformRetentionChecks() = Freeing object\n");
 629   ExFreePool(Header);
 630
 631   return(STATUS_SUCCESS);
 632 }
 633
 634
 635 VOID STDCALL
 636 ObpDeleteObjectWorkRoutine (IN PVOID Parameter)
 637 {
 638   PRETENTION_CHECK_PARAMS Params = (PRETENTION_CHECK_PARAMS)Parameter;
 639   /* ULONG Tag; */ /* See below */
 640
 641   assert(Params);
 642   assert(KeGetCurrentIrql() == PASSIVE_LEVEL); /* We need PAGED_CODE somewhere... */
 643
 644   /* Turn this on when we have ExFreePoolWithTag
 645   Tag = Params->ObjectHeader->ObjectType->Tag; */
 646   ObpDeleteObject(Params->ObjectHeader);
 647   ExFreePool(Params);
 648   /* ExFreePoolWithTag(Params, Tag); */
 649 }
 650
 651
 652 STATIC NTSTATUS
 653 ObpDeleteObjectDpcLevel(IN POBJECT_HEADER ObjectHeader,
 654                         IN LONG OldRefCount)
 655 {
 656   if (ObjectHeader->RefCount < 0)
 657     {
 658       CPRINT("Object %p/%p has invalid reference count (%d)\n",
 659              ObjectHeader, HEADER_TO_BODY(ObjectHeader),
 660              ObjectHeader->RefCount);
 661       KEBUGCHECK(0);
 662     }
 663
 664   if (ObjectHeader->HandleCount < 0)
 665     {
 666       CPRINT("Object %p/%p has invalid handle count (%d)\n",
 667              ObjectHeader, HEADER_TO_BODY(ObjectHeader),
 668              ObjectHeader->HandleCount);
 669       KEBUGCHECK(0);
 670     }
 671
 672   if (ObjectHeader->CloseInProcess)
 673     {
 674       KEBUGCHECK(0);
 675       return STATUS_UNSUCCESSFUL;
 676     }
 677   ObjectHeader->CloseInProcess = TRUE;
 678
 679   switch (KeGetCurrentIrql ())
 680     {
 681     case PASSIVE_LEVEL:
 682       return ObpDeleteObject (ObjectHeader);
 683
 684     case APC_LEVEL:
 685     case DISPATCH_LEVEL:
 686       {
 687         PRETENTION_CHECK_PARAMS Params;
 688
 689         /*
 690           We use must succeed pool here because if the allocation fails
 691           then we leak memory.
 692         */
 693         Params = (PRETENTION_CHECK_PARAMS)
 694           ExAllocatePoolWithTag(NonPagedPoolMustSucceed,
 695                                 sizeof(RETENTION_CHECK_PARAMS),
 696                                 ObjectHeader->ObjectType->Tag);
 697         Params->ObjectHeader = ObjectHeader;
 698         ExInitializeWorkItem(&Params->WorkItem,
 699                              ObpDeleteObjectWorkRoutine,
 700                              (PVOID)Params);
 701         ExQueueWorkItem(&Params->WorkItem,
 702                         CriticalWorkQueue);
 703       }
 704       return STATUS_PENDING;
 705
 706     default:
 707       DPRINT("ObpPerformRetentionChecksDpcLevel called at unsupported "
 708              "IRQL %u!\n", KeGetCurrentIrql());
 709       KEBUGCHECK(0);
 710       return STATUS_UNSUCCESSFUL;
 711     }
 712
 713   return STATUS_SUCCESS;
 714 }
 715
 716
 717 /**********************************************************************
 718  * NAME                                                 EXPORTED
 719  *      ObfReferenceObject@4
 720  *
 721  * DESCRIPTION
 722  *      Increments a given object's reference count and performs
 723  *      retention checks.
 724  *
 725  * ARGUMENTS
 726  *  ObjectBody = Body of the object.
 727  *
 728  * RETURN VALUE
 729  *      None.
 730  *
 731  * @implemented
 732  */
 733 VOID FASTCALL
 734 ObfReferenceObject(IN PVOID Object)
 735 {
 736   POBJECT_HEADER Header;
 737
 738   assert(Object);
 739
 740   Header = BODY_TO_HEADER(Object);
 741
 742   /* No one should be referencing an object once we are deleting it. */
 743   if (Header->CloseInProcess)
 744     {
 745       KEBUGCHECK(0);
 746     }
 747
 748   (VOID)InterlockedIncrement(&Header->RefCount);
 749 }
 750
 751
 752 /**********************************************************************
 753  * NAME                                                 EXPORTED
 754  *      ObfDereferenceObject@4
 755  *
 756  * DESCRIPTION
 757  *      Decrements a given object's reference count and performs
 758  *      retention checks.
 759  *
 760  * ARGUMENTS
 761  *      ObjectBody = Body of the object.
 762  *
 763  * RETURN VALUE
 764  *      None.
 765  *
 766  * @implemented
 767  */
 768 VOID FASTCALL
 769 ObfDereferenceObject(IN PVOID Object)
 770 {
 771   POBJECT_HEADER Header;
 772   LONG NewRefCount;
 773   BOOL Permanent;
 774   ULONG HandleCount;
 775
 776   assert(Object);
 777
 778   /* Extract the object header. */
 779   Header = BODY_TO_HEADER(Object);
 780   Permanent = Header->Permanent;
 781   HandleCount = Header->HandleCount;
 782
 783   /*
 784      Drop our reference and get the new count so we can tell if this was the
 785      last reference.
 786   */
 787   NewRefCount = InterlockedDecrement(&Header->RefCount);
 788   assert(NewRefCount >= 0);
 789
 790   /* Check whether the object can now be deleted. */
 791   if (NewRefCount == 0 &&
 792       HandleCount == 0 &&
 793       !Permanent)
 794     {
 795       ObpDeleteObjectDpcLevel(Header, NewRefCount);
 796     }
 797 }
 798
 799
 800 /**********************************************************************
 801  * NAME                                                 EXPORTED
 802  *      ObGetObjectPointerCount@4
 803  *
 804  * DESCRIPTION
 805  *      Retrieves the pointer(reference) count of the given object.
 806  *
 807  * ARGUMENTS
 808  *      ObjectBody = Body of the object.
 809  *
 810  * RETURN VALUE
 811  *      Reference count.
 812  *
 813  * @implemented
 814  */
 815 ULONG STDCALL
 816 ObGetObjectPointerCount(PVOID Object)
 817 {
 818   POBJECT_HEADER Header;
 819
 820   assert(Object);
 821   Header = BODY_TO_HEADER(Object);
 822
 823   return(Header->RefCount);
 824 }
 825
 826
 827 /**********************************************************************
 828  * NAME                                                 INTERNAL
 829  *      ObGetObjectHandleCount@4
 830  *
 831  * DESCRIPTION
 832  *      Retrieves the handle count of the given object.
 833  *
 834  * ARGUMENTS
 835  *      ObjectBody = Body of the object.
 836  *
 837  * RETURN VALUE
 838  *      Reference count.
 839  */
 840 ULONG
 841 ObGetObjectHandleCount(PVOID Object)
 842 {
 843   POBJECT_HEADER Header;
 844
 845   assert(Object);
 846   Header = BODY_TO_HEADER(Object);
 847
 848   return(Header->HandleCount);
 849 }
 850
 851
 852 /**********************************************************************
 853  * NAME                                                 EXPORTED
 854  *      ObDereferenceObject@4
 855  *
 856  * DESCRIPTION
 857  *      Decrements a given object's reference count and performs
 858  *      retention checks.
 859  *
 860  * ARGUMENTS
 861  *      ObjectBody = Body of the object.
 862  *
 863  * RETURN VALUE
 864  *      None.
 865  *
 866  * @implemented
 867  */
 868
 869 #ifdef ObDereferenceObject
 870 #undef ObDereferenceObject
 871 #endif
 872
 873 VOID STDCALL
 874 ObDereferenceObject(IN PVOID Object)
 875 {
 876   ObfDereferenceObject(Object);
 877 }
 878
 879 /* EOF */