src/backend/utils/resowner/resowner.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * resowner.c
   4  *        POSTGRES resource owner management code.
   5  *
   6  * Query-lifespan resources are tracked by associating them with
   7  * ResourceOwner objects.  This provides a simple mechanism for ensuring
   8  * that such resources are freed at the right time.
   9  * See utils/resowner/README for more info.
  10  *
  11  *
  12  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  13  * Portions Copyright (c) 1994, Regents of the University of California
  14  *
  15  *
  16  * IDENTIFICATION
  17  *        $PostgreSQL$
  18  *
  19  *-------------------------------------------------------------------------
  20  */
  21 #include "postgres.h"
  22
  23 #include "access/hash.h"
  24 #include "storage/bufmgr.h"
  25 #include "storage/proc.h"
  26 #include "utils/memutils.h"
  27 #include "utils/rel.h"
  28 #include "utils/resowner.h"
  29
  30
  31 /*
  32  * ResourceOwner objects look like this
  33  */
  34 typedef struct ResourceOwnerData
  35 {
  36         ResourceOwner parent;           /* NULL if no parent (toplevel owner) */
  37         ResourceOwner firstchild;       /* head of linked list of children */
  38         ResourceOwner nextchild;        /* next child of same parent */
  39         const char *name;                       /* name (just for debugging) */
  40
  41         /* We have built-in support for remembering owned buffers */
  42         int                     nbuffers;               /* number of owned buffer pins */
  43         Buffer     *buffers;            /* dynamically allocated array */
  44         int                     maxbuffers;             /* currently allocated array size */
  45
  46         /* We have built-in support for remembering catcache references */
  47         int                     ncatrefs;               /* number of owned catcache pins */
  48         HeapTuple  *catrefs;            /* dynamically allocated array */
  49         int                     maxcatrefs;             /* currently allocated array size */
  50
  51         int                     ncatlistrefs;   /* number of owned catcache-list pins */
  52         CatCList  **catlistrefs;        /* dynamically allocated array */
  53         int                     maxcatlistrefs; /* currently allocated array size */
  54
  55         /* We have built-in support for remembering relcache references */
  56         int                     nrelrefs;               /* number of owned relcache pins */
  57         Relation   *relrefs;            /* dynamically allocated array */
  58         int                     maxrelrefs;             /* currently allocated array size */
  59
  60         /* We have built-in support for remembering plancache references */
  61         int                     nplanrefs;              /* number of owned plancache pins */
  62         CachedPlan **planrefs;          /* dynamically allocated array */
  63         int                     maxplanrefs;    /* currently allocated array size */
  64
  65         /* We have built-in support for remembering tupdesc references */
  66         int                     ntupdescs;              /* number of owned tupdesc references */
  67         TupleDesc  *tupdescs;           /* dynamically allocated array */
  68         int                     maxtupdescs;    /* currently allocated array size */
  69 } ResourceOwnerData;
  70
  71
  72 /*****************************************************************************
  73  *        GLOBAL MEMORY                                                                                                                  *
  74  *****************************************************************************/
  75
  76 ResourceOwner CurrentResourceOwner = NULL;
  77 ResourceOwner CurTransactionResourceOwner = NULL;
  78 ResourceOwner TopTransactionResourceOwner = NULL;
  79
  80 /*
  81  * List of add-on callbacks for resource releasing
  82  */
  83 typedef struct ResourceReleaseCallbackItem
  84 {
  85         struct ResourceReleaseCallbackItem *next;
  86         ResourceReleaseCallback callback;
  87         void       *arg;
  88 } ResourceReleaseCallbackItem;
  89
  90 static ResourceReleaseCallbackItem *ResourceRelease_callbacks = NULL;
  91
  92
  93 /* Internal routines */
  94 static void ResourceOwnerReleaseInternal(ResourceOwner owner,
  95                                                          ResourceReleasePhase phase,
  96                                                          bool isCommit,
  97                                                          bool isTopLevel);
  98 static void PrintRelCacheLeakWarning(Relation rel);
  99 static void PrintPlanCacheLeakWarning(CachedPlan *plan);
 100 static void PrintTupleDescLeakWarning(TupleDesc tupdesc);
 101
 102
 103 /*****************************************************************************
 104  *        EXPORTED ROUTINES                                                                                                              *
 105  *****************************************************************************/
 106
 107
 108 /*
 109  * ResourceOwnerCreate
 110  *              Create an empty ResourceOwner.
 111  *
 112  * All ResourceOwner objects are kept in TopMemoryContext, since they should
 113  * only be freed explicitly.
 114  */
 115 ResourceOwner
 116 ResourceOwnerCreate(ResourceOwner parent, const char *name)
 117 {
 118         ResourceOwner owner;
 119
 120         owner = (ResourceOwner) MemoryContextAllocZero(TopMemoryContext,
 121                                                                                                    sizeof(ResourceOwnerData));
 122         owner->name = name;
 123
 124         if (parent)
 125         {
 126                 owner->parent = parent;
 127                 owner->nextchild = parent->firstchild;
 128                 parent->firstchild = owner;
 129         }
 130
 131         return owner;
 132 }
 133
 134 /*
 135  * ResourceOwnerRelease
 136  *              Release all resources owned by a ResourceOwner and its descendants,
 137  *              but don't delete the owner objects themselves.
 138  *
 139  * Note that this executes just one phase of release, and so typically
 140  * must be called three times.  We do it this way because (a) we want to
 141  * do all the recursion separately for each phase, thereby preserving
 142  * the needed order of operations; and (b) xact.c may have other operations
 143  * to do between the phases.
 144  *
 145  * phase: release phase to execute
 146  * isCommit: true for successful completion of a query or transaction,
 147  *                      false for unsuccessful
 148  * isTopLevel: true if completing a main transaction, else false
 149  *
 150  * isCommit is passed because some modules may expect that their resources
 151  * were all released already if the transaction or portal finished normally.
 152  * If so it is reasonable to give a warning (NOT an error) should any
 153  * unreleased resources be present.  When isCommit is false, such warnings
 154  * are generally inappropriate.
 155  *
 156  * isTopLevel is passed when we are releasing TopTransactionResourceOwner
 157  * at completion of a main transaction.  This generally means that *all*
 158  * resources will be released, and so we can optimize things a bit.
 159  */
 160 void
 161 ResourceOwnerRelease(ResourceOwner owner,
 162                                          ResourceReleasePhase phase,
 163                                          bool isCommit,
 164                                          bool isTopLevel)
 165 {
 166         /* Rather than PG_TRY at every level of recursion, set it up once */
 167         ResourceOwner save;
 168
 169         save = CurrentResourceOwner;
 170         PG_TRY();
 171         {
 172                 ResourceOwnerReleaseInternal(owner, phase, isCommit, isTopLevel);
 173         }
 174         PG_CATCH();
 175         {
 176                 CurrentResourceOwner = save;
 177                 PG_RE_THROW();
 178         }
 179         PG_END_TRY();
 180         CurrentResourceOwner = save;
 181 }
 182
 183 static void
 184 ResourceOwnerReleaseInternal(ResourceOwner owner,
 185                                                          ResourceReleasePhase phase,
 186                                                          bool isCommit,
 187                                                          bool isTopLevel)
 188 {
 189         ResourceOwner child;
 190         ResourceOwner save;
 191         ResourceReleaseCallbackItem *item;
 192
 193         /* Recurse to handle descendants */
 194         for (child = owner->firstchild; child != NULL; child = child->nextchild)
 195                 ResourceOwnerReleaseInternal(child, phase, isCommit, isTopLevel);
 196
 197         /*
 198          * Make CurrentResourceOwner point to me, so that ReleaseBuffer etc don't
 199          * get confused.  We needn't PG_TRY here because the outermost level will
 200          * fix it on error abort.
 201          */
 202         save = CurrentResourceOwner;
 203         CurrentResourceOwner = owner;
 204
 205         if (phase == RESOURCE_RELEASE_BEFORE_LOCKS)
 206         {
 207                 /*
 208                  * Release buffer pins.  Note that ReleaseBuffer will remove the
 209                  * buffer entry from my list, so I just have to iterate till there are
 210                  * none.
 211                  *
 212                  * During a commit, there shouldn't be any remaining pins --- that
 213                  * would indicate failure to clean up the executor correctly --- so
 214                  * issue warnings.      In the abort case, just clean up quietly.
 215                  *
 216                  * We are careful to do the releasing back-to-front, so as to avoid
 217                  * O(N^2) behavior in ResourceOwnerForgetBuffer().
 218                  */
 219                 while (owner->nbuffers > 0)
 220                 {
 221                         if (isCommit)
 222                                 PrintBufferLeakWarning(owner->buffers[owner->nbuffers - 1]);
 223                         ReleaseBuffer(owner->buffers[owner->nbuffers - 1]);
 224                 }
 225
 226                 /*
 227                  * Release relcache references.  Note that RelationClose will remove
 228                  * the relref entry from my list, so I just have to iterate till there
 229                  * are none.
 230                  *
 231                  * As with buffer pins, warn if any are left at commit time, and
 232                  * release back-to-front for speed.
 233                  */
 234                 while (owner->nrelrefs > 0)
 235                 {
 236                         if (isCommit)
 237                                 PrintRelCacheLeakWarning(owner->relrefs[owner->nrelrefs - 1]);
 238                         RelationClose(owner->relrefs[owner->nrelrefs - 1]);
 239                 }
 240         }
 241         else if (phase == RESOURCE_RELEASE_LOCKS)
 242         {
 243                 if (isTopLevel)
 244                 {
 245                         /*
 246                          * For a top-level xact we are going to release all locks (or at
 247                          * least all non-session locks), so just do a single lmgr call at
 248                          * the top of the recursion.
 249                          */
 250                         if (owner == TopTransactionResourceOwner)
 251                                 ProcReleaseLocks(isCommit);
 252                 }
 253                 else
 254                 {
 255                         /*
 256                          * Release locks retail.  Note that if we are committing a
 257                          * subtransaction, we do NOT release its locks yet, but transfer
 258                          * them to the parent.
 259                          */
 260                         Assert(owner->parent != NULL);
 261                         if (isCommit)
 262                                 LockReassignCurrentOwner();
 263                         else
 264                                 LockReleaseCurrentOwner();
 265                 }
 266         }
 267         else if (phase == RESOURCE_RELEASE_AFTER_LOCKS)
 268         {
 269                 /*
 270                  * Release catcache references.  Note that ReleaseCatCache will remove
 271                  * the catref entry from my list, so I just have to iterate till there
 272                  * are none.
 273                  *
 274                  * As with buffer pins, warn if any are left at commit time, and
 275                  * release back-to-front for speed.
 276                  */
 277                 while (owner->ncatrefs > 0)
 278                 {
 279                         if (isCommit)
 280                                 PrintCatCacheLeakWarning(owner->catrefs[owner->ncatrefs - 1]);
 281                         ReleaseCatCache(owner->catrefs[owner->ncatrefs - 1]);
 282                 }
 283                 /* Ditto for catcache lists */
 284                 while (owner->ncatlistrefs > 0)
 285                 {
 286                         if (isCommit)
 287                                 PrintCatCacheListLeakWarning(owner->catlistrefs[owner->ncatlistrefs - 1]);
 288                         ReleaseCatCacheList(owner->catlistrefs[owner->ncatlistrefs - 1]);
 289                 }
 290                 /* Ditto for plancache references */
 291                 while (owner->nplanrefs > 0)
 292                 {
 293                         if (isCommit)
 294                                 PrintPlanCacheLeakWarning(owner->planrefs[owner->nplanrefs - 1]);
 295                         ReleaseCachedPlan(owner->planrefs[owner->nplanrefs - 1], true);
 296                 }
 297                 /* Ditto for tupdesc references */
 298                 while (owner->ntupdescs > 0)
 299                 {
 300                         if (isCommit)
 301                                 PrintTupleDescLeakWarning(owner->tupdescs[owner->ntupdescs - 1]);
 302                         DecrTupleDescRefCount(owner->tupdescs[owner->ntupdescs - 1]);
 303                 }
 304
 305                 /* Clean up index scans too */
 306                 ReleaseResources_hash();
 307         }
 308
 309         /* Let add-on modules get a chance too */
 310         for (item = ResourceRelease_callbacks; item; item = item->next)
 311                 (*item->callback) (phase, isCommit, isTopLevel, item->arg);
 312
 313         CurrentResourceOwner = save;
 314 }
 315
 316 /*
 317  * ResourceOwnerDelete
 318  *              Delete an owner object and its descendants.
 319  *
 320  * The caller must have already released all resources in the object tree.
 321  */
 322 void
 323 ResourceOwnerDelete(ResourceOwner owner)
 324 {
 325         /* We had better not be deleting CurrentResourceOwner ... */
 326         Assert(owner != CurrentResourceOwner);
 327
 328         /* And it better not own any resources, either */
 329         Assert(owner->nbuffers == 0);
 330         Assert(owner->ncatrefs == 0);
 331         Assert(owner->ncatlistrefs == 0);
 332         Assert(owner->nrelrefs == 0);
 333         Assert(owner->nplanrefs == 0);
 334         Assert(owner->ntupdescs == 0);
 335
 336         /*
 337          * Delete children.  The recursive call will delink the child from me, so
 338          * just iterate as long as there is a child.
 339          */
 340         while (owner->firstchild != NULL)
 341                 ResourceOwnerDelete(owner->firstchild);
 342
 343         /*
 344          * We delink the owner from its parent before deleting it, so that if
 345          * there's an error we won't have deleted/busted owners still attached to
 346          * the owner tree.      Better a leak than a crash.
 347          */
 348         ResourceOwnerNewParent(owner, NULL);
 349
 350         /* And free the object. */
 351         if (owner->buffers)
 352                 pfree(owner->buffers);
 353         if (owner->catrefs)
 354                 pfree(owner->catrefs);
 355         if (owner->catlistrefs)
 356                 pfree(owner->catlistrefs);
 357         if (owner->relrefs)
 358                 pfree(owner->relrefs);
 359         if (owner->planrefs)
 360                 pfree(owner->planrefs);
 361         if (owner->tupdescs)
 362                 pfree(owner->tupdescs);
 363
 364         pfree(owner);
 365 }
 366
 367 /*
 368  * Fetch parent of a ResourceOwner (returns NULL if top-level owner)
 369  */
 370 ResourceOwner
 371 ResourceOwnerGetParent(ResourceOwner owner)
 372 {
 373         return owner->parent;
 374 }
 375
 376 /*
 377  * Reassign a ResourceOwner to have a new parent
 378  */
 379 void
 380 ResourceOwnerNewParent(ResourceOwner owner,
 381                                            ResourceOwner newparent)
 382 {
 383         ResourceOwner oldparent = owner->parent;
 384
 385         if (oldparent)
 386         {
 387                 if (owner == oldparent->firstchild)
 388                         oldparent->firstchild = owner->nextchild;
 389                 else
 390                 {
 391                         ResourceOwner child;
 392
 393                         for (child = oldparent->firstchild; child; child = child->nextchild)
 394                         {
 395                                 if (owner == child->nextchild)
 396                                 {
 397                                         child->nextchild = owner->nextchild;
 398                                         break;
 399                                 }
 400                         }
 401                 }
 402         }
 403
 404         if (newparent)
 405         {
 406                 Assert(owner != newparent);
 407                 owner->parent = newparent;
 408                 owner->nextchild = newparent->firstchild;
 409                 newparent->firstchild = owner;
 410         }
 411         else
 412         {
 413                 owner->parent = NULL;
 414                 owner->nextchild = NULL;
 415         }
 416 }
 417
 418 /*
 419  * Register or deregister callback functions for resource cleanup
 420  *
 421  * These functions are intended for use by dynamically loaded modules.
 422  * For built-in modules we generally just hardwire the appropriate calls.
 423  *
 424  * Note that the callback occurs post-commit or post-abort, so the callback
 425  * functions can only do noncritical cleanup.
 426  */
 427 void
 428 RegisterResourceReleaseCallback(ResourceReleaseCallback callback, void *arg)
 429 {
 430         ResourceReleaseCallbackItem *item;
 431
 432         item = (ResourceReleaseCallbackItem *)
 433                 MemoryContextAlloc(TopMemoryContext,
 434                                                    sizeof(ResourceReleaseCallbackItem));
 435         item->callback = callback;
 436         item->arg = arg;
 437         item->next = ResourceRelease_callbacks;
 438         ResourceRelease_callbacks = item;
 439 }
 440
 441 void
 442 UnregisterResourceReleaseCallback(ResourceReleaseCallback callback, void *arg)
 443 {
 444         ResourceReleaseCallbackItem *item;
 445         ResourceReleaseCallbackItem *prev;
 446
 447         prev = NULL;
 448         for (item = ResourceRelease_callbacks; item; prev = item, item = item->next)
 449         {
 450                 if (item->callback == callback && item->arg == arg)
 451                 {
 452                         if (prev)
 453                                 prev->next = item->next;
 454                         else
 455                                 ResourceRelease_callbacks = item->next;
 456                         pfree(item);
 457                         break;
 458                 }
 459         }
 460 }
 461
 462
 463 /*
 464  * Make sure there is room for at least one more entry in a ResourceOwner's
 465  * buffer array.
 466  *
 467  * This is separate from actually inserting an entry because if we run out
 468  * of memory, it's critical to do so *before* acquiring the resource.
 469  *
 470  * We allow the case owner == NULL because the bufmgr is sometimes invoked
 471  * outside any transaction (for example, during WAL recovery).
 472  */
 473 void
 474 ResourceOwnerEnlargeBuffers(ResourceOwner owner)
 475 {
 476         int                     newmax;
 477
 478         if (owner == NULL ||
 479                 owner->nbuffers < owner->maxbuffers)
 480                 return;                                 /* nothing to do */
 481
 482         if (owner->buffers == NULL)
 483         {
 484                 newmax = 16;
 485                 owner->buffers = (Buffer *)
 486                         MemoryContextAlloc(TopMemoryContext, newmax * sizeof(Buffer));
 487                 owner->maxbuffers = newmax;
 488         }
 489         else
 490         {
 491                 newmax = owner->maxbuffers * 2;
 492                 owner->buffers = (Buffer *)
 493                         repalloc(owner->buffers, newmax * sizeof(Buffer));
 494                 owner->maxbuffers = newmax;
 495         }
 496 }
 497
 498 /*
 499  * Remember that a buffer pin is owned by a ResourceOwner
 500  *
 501  * Caller must have previously done ResourceOwnerEnlargeBuffers()
 502  *
 503  * We allow the case owner == NULL because the bufmgr is sometimes invoked
 504  * outside any transaction (for example, during WAL recovery).
 505  */
 506 void
 507 ResourceOwnerRememberBuffer(ResourceOwner owner, Buffer buffer)
 508 {
 509         if (owner != NULL)
 510         {
 511                 Assert(owner->nbuffers < owner->maxbuffers);
 512                 owner->buffers[owner->nbuffers] = buffer;
 513                 owner->nbuffers++;
 514         }
 515 }
 516
 517 /*
 518  * Forget that a buffer pin is owned by a ResourceOwner
 519  *
 520  * We allow the case owner == NULL because the bufmgr is sometimes invoked
 521  * outside any transaction (for example, during WAL recovery).
 522  */
 523 void
 524 ResourceOwnerForgetBuffer(ResourceOwner owner, Buffer buffer)
 525 {
 526         if (owner != NULL)
 527         {
 528                 Buffer     *buffers = owner->buffers;
 529                 int                     nb1 = owner->nbuffers - 1;
 530                 int                     i;
 531
 532                 /*
 533                  * Scan back-to-front because it's more likely we are releasing a
 534                  * recently pinned buffer.      This isn't always the case of course, but
 535                  * it's the way to bet.
 536                  */
 537                 for (i = nb1; i >= 0; i--)
 538                 {
 539                         if (buffers[i] == buffer)
 540                         {
 541                                 while (i < nb1)
 542                                 {
 543                                         buffers[i] = buffers[i + 1];
 544                                         i++;
 545                                 }
 546                                 owner->nbuffers = nb1;
 547                                 return;
 548                         }
 549                 }
 550                 elog(ERROR, "buffer %d is not owned by resource owner %s",
 551                          buffer, owner->name);
 552         }
 553 }
 554
 555 /*
 556  * Make sure there is room for at least one more entry in a ResourceOwner's
 557  * catcache reference array.
 558  *
 559  * This is separate from actually inserting an entry because if we run out
 560  * of memory, it's critical to do so *before* acquiring the resource.
 561  */
 562 void
 563 ResourceOwnerEnlargeCatCacheRefs(ResourceOwner owner)
 564 {
 565         int                     newmax;
 566
 567         if (owner->ncatrefs < owner->maxcatrefs)
 568                 return;                                 /* nothing to do */
 569
 570         if (owner->catrefs == NULL)
 571         {
 572                 newmax = 16;
 573                 owner->catrefs = (HeapTuple *)
 574                         MemoryContextAlloc(TopMemoryContext, newmax * sizeof(HeapTuple));
 575                 owner->maxcatrefs = newmax;
 576         }
 577         else
 578         {
 579                 newmax = owner->maxcatrefs * 2;
 580                 owner->catrefs = (HeapTuple *)
 581                         repalloc(owner->catrefs, newmax * sizeof(HeapTuple));
 582                 owner->maxcatrefs = newmax;
 583         }
 584 }
 585
 586 /*
 587  * Remember that a catcache reference is owned by a ResourceOwner
 588  *
 589  * Caller must have previously done ResourceOwnerEnlargeCatCacheRefs()
 590  */
 591 void
 592 ResourceOwnerRememberCatCacheRef(ResourceOwner owner, HeapTuple tuple)
 593 {
 594         Assert(owner->ncatrefs < owner->maxcatrefs);
 595         owner->catrefs[owner->ncatrefs] = tuple;
 596         owner->ncatrefs++;
 597 }
 598
 599 /*
 600  * Forget that a catcache reference is owned by a ResourceOwner
 601  */
 602 void
 603 ResourceOwnerForgetCatCacheRef(ResourceOwner owner, HeapTuple tuple)
 604 {
 605         HeapTuple  *catrefs = owner->catrefs;
 606         int                     nc1 = owner->ncatrefs - 1;
 607         int                     i;
 608
 609         for (i = nc1; i >= 0; i--)
 610         {
 611                 if (catrefs[i] == tuple)
 612                 {
 613                         while (i < nc1)
 614                         {
 615                                 catrefs[i] = catrefs[i + 1];
 616                                 i++;
 617                         }
 618                         owner->ncatrefs = nc1;
 619                         return;
 620                 }
 621         }
 622         elog(ERROR, "catcache reference %p is not owned by resource owner %s",
 623                  tuple, owner->name);
 624 }
 625
 626 /*
 627  * Make sure there is room for at least one more entry in a ResourceOwner's
 628  * catcache-list reference array.
 629  *
 630  * This is separate from actually inserting an entry because if we run out
 631  * of memory, it's critical to do so *before* acquiring the resource.
 632  */
 633 void
 634 ResourceOwnerEnlargeCatCacheListRefs(ResourceOwner owner)
 635 {
 636         int                     newmax;
 637
 638         if (owner->ncatlistrefs < owner->maxcatlistrefs)
 639                 return;                                 /* nothing to do */
 640
 641         if (owner->catlistrefs == NULL)
 642         {
 643                 newmax = 16;
 644                 owner->catlistrefs = (CatCList **)
 645                         MemoryContextAlloc(TopMemoryContext, newmax * sizeof(CatCList *));
 646                 owner->maxcatlistrefs = newmax;
 647         }
 648         else
 649         {
 650                 newmax = owner->maxcatlistrefs * 2;
 651                 owner->catlistrefs = (CatCList **)
 652                         repalloc(owner->catlistrefs, newmax * sizeof(CatCList *));
 653                 owner->maxcatlistrefs = newmax;
 654         }
 655 }
 656
 657 /*
 658  * Remember that a catcache-list reference is owned by a ResourceOwner
 659  *
 660  * Caller must have previously done ResourceOwnerEnlargeCatCacheListRefs()
 661  */
 662 void
 663 ResourceOwnerRememberCatCacheListRef(ResourceOwner owner, CatCList *list)
 664 {
 665         Assert(owner->ncatlistrefs < owner->maxcatlistrefs);
 666         owner->catlistrefs[owner->ncatlistrefs] = list;
 667         owner->ncatlistrefs++;
 668 }
 669
 670 /*
 671  * Forget that a catcache-list reference is owned by a ResourceOwner
 672  */
 673 void
 674 ResourceOwnerForgetCatCacheListRef(ResourceOwner owner, CatCList *list)
 675 {
 676         CatCList  **catlistrefs = owner->catlistrefs;
 677         int                     nc1 = owner->ncatlistrefs - 1;
 678         int                     i;
 679
 680         for (i = nc1; i >= 0; i--)
 681         {
 682                 if (catlistrefs[i] == list)
 683                 {
 684                         while (i < nc1)
 685                         {
 686                                 catlistrefs[i] = catlistrefs[i + 1];
 687                                 i++;
 688                         }
 689                         owner->ncatlistrefs = nc1;
 690                         return;
 691                 }
 692         }
 693         elog(ERROR, "catcache list reference %p is not owned by resource owner %s",
 694                  list, owner->name);
 695 }
 696
 697 /*
 698  * Make sure there is room for at least one more entry in a ResourceOwner's
 699  * relcache reference array.
 700  *
 701  * This is separate from actually inserting an entry because if we run out
 702  * of memory, it's critical to do so *before* acquiring the resource.
 703  */
 704 void
 705 ResourceOwnerEnlargeRelationRefs(ResourceOwner owner)
 706 {
 707         int                     newmax;
 708
 709         if (owner->nrelrefs < owner->maxrelrefs)
 710                 return;                                 /* nothing to do */
 711
 712         if (owner->relrefs == NULL)
 713         {
 714                 newmax = 16;
 715                 owner->relrefs = (Relation *)
 716                         MemoryContextAlloc(TopMemoryContext, newmax * sizeof(Relation));
 717                 owner->maxrelrefs = newmax;
 718         }
 719         else
 720         {
 721                 newmax = owner->maxrelrefs * 2;
 722                 owner->relrefs = (Relation *)
 723                         repalloc(owner->relrefs, newmax * sizeof(Relation));
 724                 owner->maxrelrefs = newmax;
 725         }
 726 }
 727
 728 /*
 729  * Remember that a relcache reference is owned by a ResourceOwner
 730  *
 731  * Caller must have previously done ResourceOwnerEnlargeRelationRefs()
 732  */
 733 void
 734 ResourceOwnerRememberRelationRef(ResourceOwner owner, Relation rel)
 735 {
 736         Assert(owner->nrelrefs < owner->maxrelrefs);
 737         owner->relrefs[owner->nrelrefs] = rel;
 738         owner->nrelrefs++;
 739 }
 740
 741 /*
 742  * Forget that a relcache reference is owned by a ResourceOwner
 743  */
 744 void
 745 ResourceOwnerForgetRelationRef(ResourceOwner owner, Relation rel)
 746 {
 747         Relation   *relrefs = owner->relrefs;
 748         int                     nr1 = owner->nrelrefs - 1;
 749         int                     i;
 750
 751         for (i = nr1; i >= 0; i--)
 752         {
 753                 if (relrefs[i] == rel)
 754                 {
 755                         while (i < nr1)
 756                         {
 757                                 relrefs[i] = relrefs[i + 1];
 758                                 i++;
 759                         }
 760                         owner->nrelrefs = nr1;
 761                         return;
 762                 }
 763         }
 764         elog(ERROR, "relcache reference %s is not owned by resource owner %s",
 765                  RelationGetRelationName(rel), owner->name);
 766 }
 767
 768 /*
 769  * Debugging subroutine
 770  */
 771 static void
 772 PrintRelCacheLeakWarning(Relation rel)
 773 {
 774         elog(WARNING, "relcache reference leak: relation \"%s\" not closed",
 775                  RelationGetRelationName(rel));
 776 }
 777
 778 /*
 779  * Make sure there is room for at least one more entry in a ResourceOwner's
 780  * plancache reference array.
 781  *
 782  * This is separate from actually inserting an entry because if we run out
 783  * of memory, it's critical to do so *before* acquiring the resource.
 784  */
 785 void
 786 ResourceOwnerEnlargePlanCacheRefs(ResourceOwner owner)
 787 {
 788         int                     newmax;
 789
 790         if (owner->nplanrefs < owner->maxplanrefs)
 791                 return;                                 /* nothing to do */
 792
 793         if (owner->planrefs == NULL)
 794         {
 795                 newmax = 16;
 796                 owner->planrefs = (CachedPlan **)
 797                         MemoryContextAlloc(TopMemoryContext, newmax * sizeof(CachedPlan *));
 798                 owner->maxplanrefs = newmax;
 799         }
 800         else
 801         {
 802                 newmax = owner->maxplanrefs * 2;
 803                 owner->planrefs = (CachedPlan **)
 804                         repalloc(owner->planrefs, newmax * sizeof(CachedPlan *));
 805                 owner->maxplanrefs = newmax;
 806         }
 807 }
 808
 809 /*
 810  * Remember that a plancache reference is owned by a ResourceOwner
 811  *
 812  * Caller must have previously done ResourceOwnerEnlargePlanCacheRefs()
 813  */
 814 void
 815 ResourceOwnerRememberPlanCacheRef(ResourceOwner owner, CachedPlan *plan)
 816 {
 817         Assert(owner->nplanrefs < owner->maxplanrefs);
 818         owner->planrefs[owner->nplanrefs] = plan;
 819         owner->nplanrefs++;
 820 }
 821
 822 /*
 823  * Forget that a plancache reference is owned by a ResourceOwner
 824  */
 825 void
 826 ResourceOwnerForgetPlanCacheRef(ResourceOwner owner, CachedPlan *plan)
 827 {
 828         CachedPlan **planrefs = owner->planrefs;
 829         int                     np1 = owner->nplanrefs - 1;
 830         int                     i;
 831
 832         for (i = np1; i >= 0; i--)
 833         {
 834                 if (planrefs[i] == plan)
 835                 {
 836                         while (i < np1)
 837                         {
 838                                 planrefs[i] = planrefs[i + 1];
 839                                 i++;
 840                         }
 841                         owner->nplanrefs = np1;
 842                         return;
 843                 }
 844         }
 845         elog(ERROR, "plancache reference %p is not owned by resource owner %s",
 846                  plan, owner->name);
 847 }
 848
 849 /*
 850  * Debugging subroutine
 851  */
 852 static void
 853 PrintPlanCacheLeakWarning(CachedPlan *plan)
 854 {
 855         elog(WARNING, "plancache reference leak: plan %p not closed", plan);
 856 }
 857
 858 /*
 859  * Make sure there is room for at least one more entry in a ResourceOwner's
 860  * tupdesc reference array.
 861  *
 862  * This is separate from actually inserting an entry because if we run out
 863  * of memory, it's critical to do so *before* acquiring the resource.
 864  */
 865 void
 866 ResourceOwnerEnlargeTupleDescs(ResourceOwner owner)
 867 {
 868         int                     newmax;
 869
 870         if (owner->ntupdescs < owner->maxtupdescs)
 871                 return;                                 /* nothing to do */
 872
 873         if (owner->tupdescs == NULL)
 874         {
 875                 newmax = 16;
 876                 owner->tupdescs = (TupleDesc *)
 877                         MemoryContextAlloc(TopMemoryContext, newmax * sizeof(TupleDesc));
 878                 owner->maxtupdescs = newmax;
 879         }
 880         else
 881         {
 882                 newmax = owner->maxtupdescs * 2;
 883                 owner->tupdescs = (TupleDesc *)
 884                         repalloc(owner->tupdescs, newmax * sizeof(TupleDesc));
 885                 owner->maxtupdescs = newmax;
 886         }
 887 }
 888
 889 /*
 890  * Remember that a tupdesc reference is owned by a ResourceOwner
 891  *
 892  * Caller must have previously done ResourceOwnerEnlargeTupleDescs()
 893  */
 894 void
 895 ResourceOwnerRememberTupleDesc(ResourceOwner owner, TupleDesc tupdesc)
 896 {
 897         Assert(owner->ntupdescs < owner->maxtupdescs);
 898         owner->tupdescs[owner->ntupdescs] = tupdesc;
 899         owner->ntupdescs++;
 900 }
 901
 902 /*
 903  * Forget that a tupdesc reference is owned by a ResourceOwner
 904  */
 905 void
 906 ResourceOwnerForgetTupleDesc(ResourceOwner owner, TupleDesc tupdesc)
 907 {
 908         TupleDesc  *tupdescs = owner->tupdescs;
 909         int                     nt1 = owner->ntupdescs - 1;
 910         int                     i;
 911
 912         for (i = nt1; i >= 0; i--)
 913         {
 914                 if (tupdescs[i] == tupdesc)
 915                 {
 916                         while (i < nt1)
 917                         {
 918                                 tupdescs[i] = tupdescs[i + 1];
 919                                 i++;
 920                         }
 921                         owner->ntupdescs = nt1;
 922                         return;
 923                 }
 924         }
 925         elog(ERROR, "tupdesc reference %p is not owned by resource owner %s",
 926                  tupdesc, owner->name);
 927 }
 928
 929 /*
 930  * Debugging subroutine
 931  */
 932 static void
 933 PrintTupleDescLeakWarning(TupleDesc tupdesc)
 934 {
 935         elog(WARNING,
 936                  "TupleDesc reference leak: TupleDesc %p (%u,%d) still referenced",
 937                  tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
 938 }