root/trunk/postgresql/8.3.1.patch

Revision 1, 51.1 kB (checked in by jesus, 6 years ago)

First post!

  • src/include/Makefile

    old new  
    1515 
    1616all: pg_config.h pg_config_os.h 
    1717 
     18pg_trace.h:     ../backend/utils/probes.d 
     19        $(DTRACE) $(DTRACEFLAGS) -h -s ../backend/utils/probes.d -o pg_trace.h.tmp 
     20        sed -e 's/#if _DTRACE_VERSION/#ifdef ENABLE_DTRACE/;' < pg_trace.h.tmp > pg_trace.h 
     21        rm -f pg_trace.h.tmp 
    1822 
    1923# Subdirectories containing headers for server-side dev 
    2024SUBDIRS = access bootstrap catalog commands executor lib libpq mb \ 
  • src/backend/executor/nodeNestloop.c

    old new  
    6767        List       *otherqual; 
    6868        ExprContext *econtext; 
    6969 
     70        POSTGRESQL_EXEC_NESTLOOP((uintptr_t)node); 
     71 
    7072        /* 
    7173         * get information from the node 
    7274         */ 
  • src/backend/executor/nodeSubplan.c

    old new  
    8181        ExprContext *innerecontext = node->innerecontext; 
    8282        TupleTableSlot *slot; 
    8383 
     84        POSTGRESQL_EXEC_SUBPLAN_HASH((uintptr_t)node); 
     85 
    8486        /* Shouldn't have any direct correlation Vars */ 
    8587        if (subplan->parParam != NIL || node->args != NIL) 
    8688                elog(ERROR, "hashed subplan with direct correlation not supported"); 
     
    216218        ListCell   *l; 
    217219        ArrayBuildState *astate = NULL; 
    218220 
     221        POSTGRESQL_EXEC_SUBPLAN_SCAN((uintptr_t)node); 
     222 
    219223        /* 
    220224         * We are probably in a short-lived expression-evaluation context. Switch 
    221225         * to the per-query context for manipulating the child plan's chgParam, 
  • src/backend/executor/nodeUnique.c

    old new  
    4545        TupleTableSlot *slot; 
    4646        PlanState  *outerPlan; 
    4747 
     48        POSTGRESQL_EXEC_UNIQUE((uintptr_t)node); 
     49 
    4850        /* 
    4951         * get information from the node 
    5052         */ 
  • src/backend/executor/nodeHash.c

    old new  
    7070        ExprContext *econtext; 
    7171        uint32          hashvalue; 
    7272 
     73        POSTGRESQL_EXEC_HASH_MULTI((uintptr_t)node); 
     74 
    7375        /* must provide our own instrumentation support */ 
    7476        if (node->ps.instrument) 
    7577                InstrStartNode(node->ps.instrument); 
  • src/backend/executor/nodeSetOp.c

    old new  
    5050        TupleTableSlot *resultTupleSlot; 
    5151        PlanState  *outerPlan; 
    5252 
     53        POSTGRESQL_EXEC_SETOP((uintptr_t)node); 
     54 
    5355        /* 
    5456         * get information from the node 
    5557         */ 
  • src/backend/executor/nodeGroup.c

    old new  
    4848        econtext = node->ss.ps.ps_ExprContext; 
    4949        numCols = ((Group *) node->ss.ps.plan)->numCols; 
    5050        grpColIdx = ((Group *) node->ss.ps.plan)->grpColIdx; 
     51        POSTGRESQL_EXEC_GROUP((uintptr_t)node, numCols); 
    5152 
    5253        /* 
    5354         * The ScanTupleSlot holds the (copied) first tuple of each group. 
  • src/backend/executor/nodeMaterial.c

    old new  
    4545        bool            eof_tuplestore; 
    4646        TupleTableSlot *slot; 
    4747 
     48        POSTGRESQL_EXEC_MATERIAL((uintptr_t)node); 
     49 
    4850        /* 
    4951         * get state info from node 
    5052         */ 
  • src/backend/executor/nodeAgg.c

    old new  
    806806        if (node->agg_done) 
    807807                return NULL; 
    808808 
     809        POSTGRESQL_EXEC_AGG((uintptr_t)node, ((Agg *) node->ss.ps.plan)->aggstrategy); 
     810 
    809811        if (((Agg *) node->ss.ps.plan)->aggstrategy == AGG_HASHED) 
    810812        { 
    811813                if (!node->table_filled) 
  • src/backend/executor/nodeHashjoin.c

    old new  
    5858        uint32          hashvalue; 
    5959        int                     batchno; 
    6060 
     61        POSTGRESQL_EXEC_HASHJOIN((uintptr_t)node); 
    6162        /* 
    6263         * get information from HashJoin node 
    6364         */ 
  • src/backend/executor/nodeLimit.c

    old new  
    4141        TupleTableSlot *slot; 
    4242        PlanState  *outerPlan; 
    4343 
     44        POSTGRESQL_EXEC_LIMIT((uintptr_t)node); 
     45 
    4446        /* 
    4547         * get information from the node 
    4648         */ 
  • src/backend/executor/nodeMergejoin.c

    old new  
    568568        bool            doFillOuter; 
    569569        bool            doFillInner; 
    570570 
     571        POSTGRESQL_EXEC_MERGEJOIN((uintptr_t)node); 
     572 
    571573        /* 
    572574         * get information from node 
    573575         */ 
  • src/backend/executor/execScan.c

    old new  
    6060        qual = node->ps.qual; 
    6161        projInfo = node->ps.ps_ProjInfo; 
    6262 
     63        POSTGRESQL_EXEC_SCAN((uintptr_t)node, ((Scan *)node->ps.plan)->scanrelid, (uintptr_t)accessMtd); 
     64 
    6365        /* 
    6466         * If we have neither a qual to check nor a projection to do, just skip 
    6567         * all the overhead and return the raw scan tuple. 
  • src/backend/executor/nodeSort.c

    old new  
    5151 
    5252        estate = node->ss.ps.state; 
    5353        dir = estate->es_direction; 
     54 
     55        POSTGRESQL_EXEC_SORT((uintptr_t)node, dir); 
     56 
    5457        tuplesortstate = (Tuplesortstate *) node->tuplesortstate; 
    5558 
    5659        /* 
  • src/backend/utils/probes.d

    old new  
    99 
    1010provider postgresql { 
    1111 
     12probe statement__start(const char *); 
     13probe mark__dirty(uint32_t); 
     14probe local__mark__dirty(uint32_t); 
     15probe slru__readpage__entry(uintptr_t, uint32_t, uint32_t, uint32_t); 
     16probe slru__readpage__return(uint32_t); 
     17probe slru__readpage__ro(uintptr_t, uint32_t, uint32_t); 
     18probe slru__writepage__entry(uintptr_t, uint32_t, uint32_t); 
     19probe slru__writepage__return(); 
     20probe slru__readpage__physical__entry(uintptr_t, char *, uint32_t, uint32_t); 
     21probe slru__readpage__physical__return(uint32_t, uint32_t, uint32_t); 
     22probe slru__writepage__physical__entry(uintptr_t, uint32_t, uint32_t); 
     23probe slru__writepage__physical__return(uint32_t, uint32_t, uint32_t); 
     24probe xlog__insert(uint32_t, uint32_t); 
     25probe xlog__switch(); 
     26probe xlog__checkpoint(uint32_t, uint32_t); 
     27probe clog__checkpoint__entry(); 
     28probe clog__checkpoint__return(); 
     29probe multixact__checkpoint__entry(); 
     30probe multixact__checkpoint__return(); 
     31probe subtrans__checkpoint__entry(); 
     32probe subtrans__checkpoint__return(); 
     33probe twophase__checkpoint__entry(); 
     34probe twophase__checkpoint__return(); 
     35probe xlog__checkpoint__entry(uint32_t, uint32_t); 
     36probe xlog__checkpoint__return(); 
     37probe buffers__checkpoint__entry(uint32_t); 
     38probe buffers__checkpoint__return(); 
     39probe buffer__sync__entry(uint32_t, uint32_t); 
     40probe buffer__sync__written(uint32_t); 
     41probe buffer__sync__return(uint32_t, uint32_t, uint32_t); 
     42probe buffer__flush__entry(uint32_t, uint32_t, uint32_t, uint32_t); 
     43probe buffer__flush__return(uint32_t, uint32_t, uint32_t, uint32_t); 
     44probe exec__scan(uintptr_t, uint32_t, uintptr_t); 
     45probe exec__agg(uintptr_t, uint32_t); 
     46probe exec__group(uintptr_t, uint32_t); 
     47probe exec__hash__multi(uintptr_t); 
     48probe exec__hashjoin(uintptr_t); 
     49probe exec__limit(uintptr_t); 
     50probe exec__material(uintptr_t); 
     51probe exec__mergejoin(uintptr_t); 
     52probe exec__nestloop(uintptr_t); 
     53probe exec__setop(uintptr_t); 
     54probe exec__sort(uintptr_t, uint32_t); 
     55probe exec__subplan__hash(uintptr_t); 
     56probe exec__subplan__scan(uintptr_t); 
     57probe exec__unique(uintptr_t); 
     58probe autovacuum__start(uint32_t, char *); 
     59probe autovacuum__relation(uint32_t, char *, char *, char *); 
    1260probe transaction__start(int); 
    1361probe transaction__commit(int); 
    1462probe transaction__abort(int); 
  • src/backend/postmaster/pgstat.c

    old new  
    18911891        TimestampTz start_timestamp; 
    18921892        int                     len; 
    18931893 
     1894        POSTGRESQL_STATEMENT_START((char *)cmd_str); 
     1895 
    18941896        if (!pgstat_track_activities || !beentry) 
    18951897                return; 
    18961898 
  • src/backend/postmaster/autovacuum.c

    old new  
    16011601                InitPostgres(NULL, dbid, NULL, &dbname); 
    16021602                SetProcessingMode(NormalProcessing); 
    16031603                set_ps_display(dbname, false); 
     1604                POSTGRESQL_AUTOVACUUM_START(dbid, dbname); 
    16041605                ereport(DEBUG1, 
    16051606                                (errmsg("autovacuum: processing database \"%s\"", dbname))); 
    16061607 
     
    21222123                { 
    21232124                        /* have at it */ 
    21242125                        MemoryContextSwitchTo(TopTransactionContext); 
     2126                        POSTGRESQL_AUTOVACUUM_RELATION(tab->at_relid, datname, nspname, relname); 
    21252127                        autovacuum_do_vac_analyze(tab->at_relid, 
    21262128                                                                          tab->at_dovacuum, 
    21272129                                                                          tab->at_doanalyze, 
  • src/backend/access/transam/xact.c

    old new  
    14791479        Assert(MyProc->backendId == vxid.backendId); 
    14801480        MyProc->lxid = vxid.localTransactionId; 
    14811481 
    1482         PG_TRACE1(transaction__start, vxid.localTransactionId); 
     1482        POSTGRESQL_TRANSACTION_START(vxid.localTransactionId); 
    14831483 
    14841484        /* 
    14851485         * set transaction_timestamp() (a/k/a now()).  We want this to be the same 
     
    16041604         */ 
    16051605        latestXid = RecordTransactionCommit(); 
    16061606 
    1607         PG_TRACE1(transaction__commit, MyProc->lxid); 
     1607        POSTGRESQL_TRANSACTION_COMMIT(MyProc->lxid); 
    16081608 
    16091609        /* 
    16101610         * Let others know about no transaction in progress by me. Note that this 
     
    19901990         */ 
    19911991        latestXid = RecordTransactionAbort(false); 
    19921992 
    1993         PG_TRACE1(transaction__abort, MyProc->lxid); 
     1993        POSTGRESQL_TRANSACTION_ABORT(MyProc->lxid); 
    19941994 
    19951995        /* 
    19961996         * Let others know about no transaction in progress by me. Note that this 
  • src/backend/access/transam/subtrans.c

    old new  
    281281         * it merely to improve the odds that writing of dirty pages is done by 
    282282         * the checkpoint process and not by backends. 
    283283         */ 
     284        POSTGRESQL_SUBTRANS_CHECKPOINT_ENTRY(); 
    284285        SimpleLruFlush(SubTransCtl, true); 
     286        POSTGRESQL_SUBTRANS_CHECKPOINT_RETURN(); 
    285287} 
    286288 
    287289 
  • src/backend/access/transam/xlog.c

    old new  
    475475        if (info & XLR_INFO_MASK) 
    476476                elog(PANIC, "invalid xlog info mask %02X", info); 
    477477 
     478        POSTGRESQL_XLOG_INSERT(rmid, info); 
     479 
    478480        /* 
    479481         * In bootstrap mode, we don't actually log anything but XLOG resources; 
    480482         * return a phony record pointer. 
     
    903905                XLogwrtRqst FlushRqst; 
    904906                XLogRecPtr      OldSegEnd; 
    905907 
     908                POSTGRESQL_XLOG_SWITCH(); 
     909 
    906910                LWLockAcquire(WALWriteLock, LW_EXCLUSIVE); 
    907911 
    908912                /* 
     
    58245828        checkPoint.nextXid = ShmemVariableCache->nextXid; 
    58255829        LWLockRelease(XidGenLock); 
    58265830 
     5831        POSTGRESQL_XLOG_CHECKPOINT_ENTRY(flags, checkPoint.nextXid); 
     5832 
    58275833        /* Increase XID epoch if we've wrapped around since last checkpoint */ 
    58285834        checkPoint.nextXidEpoch = ControlFile->checkPointCopy.nextXidEpoch; 
    58295835        if (checkPoint.nextXid < ControlFile->checkPointCopy.nextXid) 
     
    59495955                LogCheckpointEnd(); 
    59505956 
    59515957        LWLockRelease(CheckpointLock); 
     5958        POSTGRESQL_XLOG_CHECKPOINT_RETURN(); 
    59525959} 
    59535960 
    59545961/* 
  • src/backend/access/transam/multixact.c

    old new  
    15261526void 
    15271527CheckPointMultiXact(void) 
    15281528{ 
     1529        POSTGRESQL_MULTIXACT_CHECKPOINT_ENTRY(); 
     1530 
    15291531        /* Flush dirty MultiXact pages to disk */ 
    15301532        SimpleLruFlush(MultiXactOffsetCtl, true); 
    15311533        SimpleLruFlush(MultiXactMemberCtl, true); 
     
    15401542         */ 
    15411543        if (!InRecovery) 
    15421544                TruncateMultiXact(); 
     1545 
     1546        POSTGRESQL_MULTIXACT_CHECKPOINT_RETURN(); 
    15431547} 
    15441548 
    15451549/* 
  • src/backend/access/transam/clog.c

    old new  
    323323CheckPointCLOG(void) 
    324324{ 
    325325        /* Flush dirty CLOG pages to disk */ 
     326        POSTGRESQL_CLOG_CHECKPOINT_ENTRY(); 
    326327        SimpleLruFlush(ClogCtl, true); 
     328        POSTGRESQL_CLOG_CHECKPOINT_RETURN(); 
    327329} 
    328330 
    329331 
  • src/backend/access/transam/slru.c

    old new  
    372372{ 
    373373        SlruShared      shared = ctl->shared; 
    374374 
     375        POSTGRESQL_SLRU_READPAGE_ENTRY((uintptr_t)ctl, pageno, write_ok, xid); 
     376 
    375377        /* Outer loop handles restart if we must wait for someone else's I/O */ 
    376378        for (;;) 
    377379        { 
     
    399401                        } 
    400402                        /* Otherwise, it's ready to use */ 
    401403                        SlruRecentlyUsed(shared, slotno); 
    402                         return slotno
     404                        goto traceout
    403405                } 
    404406 
    405407                /* We found no match; assert we selected a freeable slot */ 
     
    446448                        SlruReportIOError(ctl, pageno, xid); 
    447449 
    448450                SlruRecentlyUsed(shared, slotno); 
     451 
     452                traceout: 
     453                POSTGRESQL_SLRU_READPAGE_RETURN(slotno); 
    449454                return slotno; 
    450455        } 
    451456} 
     
    470475        SlruShared      shared = ctl->shared; 
    471476        int                     slotno; 
    472477 
     478        POSTGRESQL_SLRU_READPAGE_RO((uintptr_t)ctl, pageno, xid); 
     479 
    473480        /* Try to find the page while holding only shared lock */ 
    474481        LWLockAcquire(shared->ControlLock, LW_SHARED); 
    475482 
     
    511518        int                     pageno = shared->page_number[slotno]; 
    512519        bool            ok; 
    513520 
     521        POSTGRESQL_SLRU_WRITEPAGE_ENTRY((uintptr_t)ctl, pageno, slotno); 
     522 
    514523        /* If a write is in progress, wait for it to finish */ 
    515524        while (shared->page_status[slotno] == SLRU_PAGE_WRITE_IN_PROGRESS && 
    516525                   shared->page_number[slotno] == pageno) 
     
    525534        if (!shared->page_dirty[slotno] || 
    526535                shared->page_status[slotno] != SLRU_PAGE_VALID || 
    527536                shared->page_number[slotno] != pageno) 
    528                 return
     537                goto traceout
    529538 
    530539        /* 
    531540         * Mark the slot write-busy, and clear the dirtybit.  After this point, a 
     
    569578        /* Now it's okay to ereport if we failed */ 
    570579        if (!ok) 
    571580                SlruReportIOError(ctl, pageno, InvalidTransactionId); 
     581 
     582        traceout: 
     583        POSTGRESQL_SLRU_WRITEPAGE_RETURN(); 
    572584} 
    573585 
    574586/* 
     
    590602        int                     offset = rpageno * BLCKSZ; 
    591603        char            path[MAXPGPATH]; 
    592604        int                     fd; 
     605        bool            retval = false; 
    593606 
    594607        SlruFileName(ctl, path, segno); 
    595608 
     609        POSTGRESQL_SLRU_READPAGE_PHYSICAL_ENTRY((uintptr_t)ctl, path, pageno, slotno); 
     610 
    596611        /* 
    597612         * In a crash-and-restart situation, it's possible for us to receive 
    598613         * commands to set the commit status of transactions whose bits are in 
     
    607622                { 
    608623                        slru_errcause = SLRU_OPEN_FAILED; 
    609624                        slru_errno = errno; 
    610                         return false; 
     625                        retval = false; 
     626                        goto traceout; 
    611627                } 
    612628 
    613629                ereport(LOG, 
    614630                                (errmsg("file \"%s\" doesn't exist, reading as zeroes", 
    615631                                                path))); 
    616632                MemSet(shared->page_buffer[slotno], 0, BLCKSZ); 
    617                 return true; 
     633                retval = true; 
     634                goto traceout; 
    618635        } 
    619636 
    620637        if (lseek(fd, (off_t) offset, SEEK_SET) < 0) 
     
    622639                slru_errcause = SLRU_SEEK_FAILED; 
    623640                slru_errno = errno; 
    624641                close(fd); 
    625                 return false; 
     642                retval = false; 
     643                goto traceout; 
    626644        } 
    627645 
    628646        errno = 0; 
     
    631649                slru_errcause = SLRU_READ_FAILED; 
    632650                slru_errno = errno; 
    633651                close(fd); 
    634                 return false; 
     652                retval = false; 
     653                goto traceout; 
    635654        } 
    636655 
    637656        if (close(fd)) 
    638657        { 
    639658                slru_errcause = SLRU_CLOSE_FAILED; 
    640659                slru_errno = errno; 
    641                 return false; 
     660                retval = false; 
     661                goto traceout; 
    642662        } 
    643663 
    644         return true; 
     664        retval = true; 
     665 
     666        traceout: 
     667        POSTGRESQL_SLRU_READPAGE_PHYSICAL_RETURN(retval, slru_errcause, slru_errno); 
     668        return retval; 
    645669} 
    646670 
    647671/* 
     
    667691        int                     offset = rpageno * BLCKSZ; 
    668692        char            path[MAXPGPATH]; 
    669693        int                     fd = -1; 
     694        bool            retval = false; 
    670695 
     696        POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_ENTRY((uintptr_t)ctl, pageno, slotno); 
     697 
    671698        /* 
    672699         * Honor the write-WAL-before-data rule, if appropriate, so that we do not 
    673700         * write out data before associated WAL records.  This is the same action 
     
    753780                { 
    754781                        slru_errcause = SLRU_OPEN_FAILED; 
    755782                        slru_errno = errno; 
    756                         return false; 
     783                        retval = false; 
     784                        goto traceout; 
    757785                } 
    758786 
    759787                if (fdata) 
     
    781809                slru_errno = errno; 
    782810                if (!fdata) 
    783811                        close(fd); 
    784                 return false; 
     812                retval = false; 
     813                goto traceout; 
    785814        } 
    786815 
    787816        errno = 0; 
     
    794823                slru_errno = errno; 
    795824                if (!fdata) 
    796825                        close(fd); 
    797                 return false; 
     826                retval = false; 
     827                goto traceout; 
    798828        } 
    799829 
    800830        /* 
     
    808838                        slru_errcause = SLRU_FSYNC_FAILED; 
    809839                        slru_errno = errno; 
    810840                        close(fd); 
    811                         return false; 
     841                        retval = false; 
     842                        goto traceout; 
    812843                } 
    813844 
    814845                if (close(fd)) 
    815846                { 
    816847                        slru_errcause = SLRU_CLOSE_FAILED; 
    817848                        slru_errno = errno; 
    818                         return false; 
     849                        retval = false; 
     850                        goto traceout; 
    819851                } 
    820852        } 
    821853 
    822         return true; 
     854        retval = true; 
     855        traceout: 
     856        POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_RETURN(retval, slru_errcause, slru_errno); 
     857        return retval; 
    823858} 
    824859 
    825860/* 
  • src/backend/access/transam/twophase.c

    old new  
    13761376         */ 
    13771377        if (max_prepared_xacts <= 0) 
    13781378                return;                                 /* nothing to do */ 
     1379 
     1380        POSTGRESQL_TWOPHASE_CHECKPOINT_ENTRY(); 
     1381 
    13791382        xids = (TransactionId *) palloc(max_prepared_xacts * sizeof(TransactionId)); 
    13801383        nxids = 0; 
    13811384 
     
    14331436        } 
    14341437 
    14351438        pfree(xids); 
     1439 
     1440        POSTGRESQL_TWOPHASE_CHECKPOINT_RETURN(); 
    14361441} 
    14371442 
    14381443/* 
  • src/backend/storage/lmgr/lock.c

    old new  
    787787                 * Sleep till someone wakes me up. 
    788788                 */ 
    789789 
    790                 PG_TRACE2(lock__startwait, locktag->locktag_field2, lockmode); 
     790                POSTGRESQL_LOCK_STARTWAIT(locktag->locktag_field2, lockmode); 
    791791 
    792792                WaitOnLock(locallock, owner); 
    793793 
    794                 PG_TRACE2(lock__endwait, locktag->locktag_field2, lockmode); 
     794                POSTGRESQL_LOCK_ENDWAIT(locktag->locktag_field2, lockmode); 
    795795 
    796796                /* 
    797797                 * NOTE: do not do any material change of state between here and 
  • src/backend/storage/lmgr/lwlock.c

    old new  
    447447                block_counts[lockid]++; 
    448448#endif 
    449449 
    450                 PG_TRACE2(lwlock__startwait, lockid, mode); 
     450                POSTGRESQL_LWLOCK_STARTWAIT(lockid, mode); 
    451451 
    452452                for (;;) 
    453453                { 
     
    458458                        extraWaits++; 
    459459                } 
    460460 
    461                 PG_TRACE2(lwlock__endwait, lockid, mode); 
     461                POSTGRESQL_LWLOCK_ENDWAIT(lockid, mode); 
    462462 
    463463                LOG_LWDEBUG("LWLockAcquire", lockid, "awakened"); 
    464464 
     
    469469        /* We are done updating shared state of the lock itself. */ 
    470470        SpinLockRelease(&lock->mutex); 
    471471 
    472         PG_TRACE2(lwlock__acquire, lockid, mode); 
     472        POSTGRESQL_LWLOCK_ACQUIRE(lockid, mode); 
    473473 
    474474        /* Add lock to list of locks held by this backend */ 
    475475        held_lwlocks[num_held_lwlocks++] = lockid; 
     
    540540                /* Failed to get lock, so release interrupt holdoff */ 
    541541                RESUME_INTERRUPTS(); 
    542542                LOG_LWDEBUG("LWLockConditionalAcquire", lockid, "failed"); 
    543                 PG_TRACE2(lwlock__condacquire__fail, lockid, mode); 
     543                POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(lockid, mode); 
    544544        } 
    545545        else 
    546546        { 
    547547                /* Add lock to list of locks held by this backend */ 
    548548                held_lwlocks[num_held_lwlocks++] = lockid; 
    549                 PG_TRACE2(lwlock__condacquire, lockid, mode); 
     549                POSTGRESQL_LWLOCK_CONDACQUIRE(lockid, mode); 
    550550        } 
    551551 
    552552        return !mustwait; 
     
    631631        /* We are done updating shared state of the lock itself. */ 
    632632        SpinLockRelease(&lock->mutex); 
    633633 
    634         PG_TRACE1(lwlock__release, lockid); 
     634        POSTGRESQL_LWLOCK_RELEASE(lockid); 
    635635 
    636636        /* 
    637637         * Awaken any waiters I removed from the queue. 
  • src/backend/storage/buffer/bufmgr.c

    old new  
    809809        bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED); 
    810810 
    811811        UnlockBufHdr(bufHdr); 
     812        POSTGRESQL_MARK_DIRTY(buffer); 
    812813} 
    813814 
    814815/* 
     
    10501051         * Note that we don't read the buffer alloc count here --- that should be 
    10511052         * left untouched till the next BgBufferSync() call. 
    10521053         */ 
     1054        POSTGRESQL_BUFFER_SYNC_ENTRY(NBuffers, num_to_write); 
    10531055        buf_id = StrategySyncStart(NULL, NULL); 
    10541056        num_to_scan = NBuffers; 
    10551057        num_written = 0; 
     
    10731075                { 
    10741076                        if (SyncOneBuffer(buf_id, false) & BUF_WRITTEN) 
    10751077                        { 
     1078                                POSTGRESQL_BUFFER_SYNC_WRITTEN(buf_id); 
    10761079                                BgWriterStats.m_buf_written_checkpoints++; 
    10771080                                num_written++; 
    10781081 
     
    11071110         * Update checkpoint statistics. As noted above, this doesn't include 
    11081111         * buffers written by other backends or bgwriter scan. 
    11091112         */ 
     1113        POSTGRESQL_BUFFER_SYNC_RETURN(NBuffers, num_written, num_to_write); 
    11101114        CheckpointStats.ckpt_bufs_written += num_written; 
    11111115} 
    11121116 
     
    16091613void 
    16101614CheckPointBuffers(int flags) 
    16111615{ 
     1616        POSTGRESQL_BUFFERS_CHECKPOINT_ENTRY(flags); 
    16121617        CheckpointStats.ckpt_write_t = GetCurrentTimestamp(); 
    16131618        BufferSync(flags); 
    16141619        CheckpointStats.ckpt_sync_t = GetCurrentTimestamp(); 
    16151620        smgrsync(); 
    16161621        CheckpointStats.ckpt_sync_end_t = GetCurrentTimestamp(); 
     1622        POSTGRESQL_BUFFERS_CHECKPOINT_RETURN(); 
    16171623} 
    16181624 
    16191625 
     
    17051711        if (!StartBufferIO(buf, false)) 
    17061712                return; 
    17071713 
     1714        POSTGRESQL_BUFFER_FLUSH_ENTRY(buf->tag.rnode.dbNode, buf->tag.rnode.spcNode, buf->tag.rnode.relNode, buf->tag.blockNum); 
     1715 
    17081716        /* Setup error traceback support for ereport() */ 
    17091717        errcontext.callback = buffer_write_error_callback; 
    17101718        errcontext.arg = (void *) buf; 
     
    17411749 
    17421750        BufferFlushCount++; 
    17431751 
     1752        POSTGRESQL_BUFFER_FLUSH_RETURN(buf->tag.rnode.dbNode, buf->tag.rnode.spcNode, buf->tag.rnode.relNode, buf->tag.blockNum); 
     1753 
    17441754        /* 
    17451755         * Mark the buffer as clean (unless BM_JUST_DIRTIED has become set) and 
    17461756         * end the io_in_progress state. 
  • src/backend/storage/buffer/localbuf.c

    old new  
    236236 
    237237        bufHdr = &LocalBufferDescriptors[bufid]; 
    238238        bufHdr->flags |= BM_DIRTY; 
     239        POSTGRESQL_LOCAL_MARK_DIRTY(buffer); 
    239240} 
    240241 
    241242/* 
  • src/include/pg_trace.h

    old new  
    1 /* ---------- 
    2  *      pg_trace.h 
    3  * 
    4  *      Definitions for the PostgreSQL tracing framework 
    5  * 
    6  *      Copyright (c) 2006-2008, PostgreSQL Global Development Group 
    7  * 
    8  *      $PostgreSQL: pgsql/src/include/pg_trace.h,v 1.3 2008/01/02 02:42:06 momjian Exp $ 
    9  * ---------- 
     1/* 
     2 * Generated by dtrace(1M). 
    103 */ 
    114 
    12 #ifndef PG_TRACE_H 
    13 #define PG_TRACE_H 
     5#ifndef        _PG_TRACE_H_TMP 
     6#define        _PG_TRACE_H_TMP 
    147 
     8#include <unistd.h> 
     9 
     10#ifdef  __cplusplus 
     11extern "C" { 
     12#endif 
     13 
    1514#ifdef ENABLE_DTRACE 
    1615 
    17 #include <sys/sdt.h> 
     16#define POSTGRESQL_AUTOVACUUM_RELATION(arg0, arg1, arg2, arg3) \ 
     17        __dtrace_postgresql___autovacuum__relation(arg0, arg1, arg2, arg3) 
     18#define POSTGRESQL_AUTOVACUUM_RELATION_ENABLED() \ 
     19        __dtraceenabled_postgresql___autovacuum__relation() 
     20#define POSTGRESQL_AUTOVACUUM_START(arg0, arg1) \ 
     21        __dtrace_postgresql___autovacuum__start(arg0, arg1) 
     22#define POSTGRESQL_AUTOVACUUM_START_ENABLED() \ 
     23        __dtraceenabled_postgresql___autovacuum__start() 
     24#define POSTGRESQL_BUFFER_FLUSH_ENTRY(arg0, arg1, arg2, arg3) \ 
     25        __dtrace_postgresql___buffer__flush__entry(arg0, arg1, arg2, arg3) 
     26#define POSTGRESQL_BUFFER_FLUSH_ENTRY_ENABLED() \ 
     27        __dtraceenabled_postgresql___buffer__flush__entry() 
     28#define POSTGRESQL_BUFFER_FLUSH_RETURN(arg0, arg1, arg2, arg3) \ 
     29        __dtrace_postgresql___buffer__flush__return(arg0, arg1, arg2, arg3) 
     30#define POSTGRESQL_BUFFER_FLUSH_RETURN_ENABLED() \ 
     31        __dtraceenabled_postgresql___buffer__flush__return() 
     32#define POSTGRESQL_BUFFER_SYNC_ENTRY(arg0, arg1) \ 
     33        __dtrace_postgresql___buffer__sync__entry(arg0, arg1) 
     34#define POSTGRESQL_BUFFER_SYNC_ENTRY_ENABLED() \ 
     35        __dtraceenabled_postgresql___buffer__sync__entry() 
     36#define POSTGRESQL_BUFFER_SYNC_RETURN(arg0, arg1, arg2) \ 
     37        __dtrace_postgresql___buffer__sync__return(arg0, arg1, arg2) 
     38#define POSTGRESQL_BUFFER_SYNC_RETURN_ENABLED() \ 
     39        __dtraceenabled_postgresql___buffer__sync__return() 
     40#define POSTGRESQL_BUFFER_SYNC_WRITTEN(arg0) \ 
     41        __dtrace_postgresql___buffer__sync__written(arg0) 
     42#define POSTGRESQL_BUFFER_SYNC_WRITTEN_ENABLED() \ 
     43        __dtraceenabled_postgresql___buffer__sync__written() 
     44#define POSTGRESQL_BUFFERS_CHECKPOINT_ENTRY(arg0) \ 
     45        __dtrace_postgresql___buffers__checkpoint__entry(arg0) 
     46#define POSTGRESQL_BUFFERS_CHECKPOINT_ENTRY_ENABLED() \ 
     47        __dtraceenabled_postgresql___buffers__checkpoint__entry() 
     48#define POSTGRESQL_BUFFERS_CHECKPOINT_RETURN() \ 
     49        __dtrace_postgresql___buffers__checkpoint__return() 
     50#define POSTGRESQL_BUFFERS_CHECKPOINT_RETURN_ENABLED() \ 
     51        __dtraceenabled_postgresql___buffers__checkpoint__return() 
     52#define POSTGRESQL_CLOG_CHECKPOINT_ENTRY() \ 
     53        __dtrace_postgresql___clog__checkpoint__entry() 
     54#define POSTGRESQL_CLOG_CHECKPOINT_ENTRY_ENABLED() \ 
     55        __dtraceenabled_postgresql___clog__checkpoint__entry() 
     56#define POSTGRESQL_CLOG_CHECKPOINT_RETURN() \ 
     57        __dtrace_postgresql___clog__checkpoint__return() 
     58#define POSTGRESQL_CLOG_CHECKPOINT_RETURN_ENABLED() \ 
     59        __dtraceenabled_postgresql___clog__checkpoint__return() 
     60#define POSTGRESQL_EXEC_AGG(arg0, arg1) \ 
     61        __dtrace_postgresql___exec__agg(arg0, arg1) 
     62#define POSTGRESQL_EXEC_AGG_ENABLED() \ 
     63        __dtraceenabled_postgresql___exec__agg() 
     64#define POSTGRESQL_EXEC_GROUP(arg0, arg1) \ 
     65        __dtrace_postgresql___exec__group(arg0, arg1) 
     66#define POSTGRESQL_EXEC_GROUP_ENABLED() \ 
     67        __dtraceenabled_postgresql___exec__group() 
     68#define POSTGRESQL_EXEC_HASH_MULTI(arg0) \ 
     69        __dtrace_postgresql___exec__hash__multi(arg0) 
     70#define POSTGRESQL_EXEC_HASH_MULTI_ENABLED() \ 
     71        __dtraceenabled_postgresql___exec__hash__multi() 
     72#define POSTGRESQL_EXEC_HASHJOIN(arg0) \ 
     73        __dtrace_postgresql___exec__hashjoin(arg0) 
     74#define POSTGRESQL_EXEC_HASHJOIN_ENABLED() \ 
     75        __dtraceenabled_postgresql___exec__hashjoin() 
     76#define POSTGRESQL_EXEC_LIMIT(arg0) \ 
     77        __dtrace_postgresql___exec__limit(arg0) 
     78#define POSTGRESQL_EXEC_LIMIT_ENABLED() \ 
     79        __dtraceenabled_postgresql___exec__limit() 
     80#define POSTGRESQL_EXEC_MATERIAL(arg0) \ 
     81        __dtrace_postgresql___exec__material(arg0) 
     82#define POSTGRESQL_EXEC_MATERIAL_ENABLED() \ 
     83        __dtraceenabled_postgresql___exec__material() 
     84#define POSTGRESQL_EXEC_MERGEJOIN(arg0) \ 
     85        __dtrace_postgresql___exec__mergejoin(arg0) 
     86#define POSTGRESQL_EXEC_MERGEJOIN_ENABLED() \ 
     87        __dtraceenabled_postgresql___exec__mergejoin() 
     88#define POSTGRESQL_EXEC_NESTLOOP(arg0) \ 
     89        __dtrace_postgresql___exec__nestloop(arg0) 
     90#define POSTGRESQL_EXEC_NESTLOOP_ENABLED() \ 
     91        __dtraceenabled_postgresql___exec__nestloop() 
     92#define POSTGRESQL_EXEC_SCAN(arg0, arg1, arg2) \ 
     93        __dtrace_postgresql___exec__scan(arg0, arg1, arg2) 
     94#define POSTGRESQL_EXEC_SCAN_ENABLED() \ 
     95        __dtraceenabled_postgresql___exec__scan() 
     96#define POSTGRESQL_EXEC_SETOP(arg0) \ 
     97        __dtrace_postgresql___exec__setop(arg0) 
     98#define POSTGRESQL_EXEC_SETOP_ENABLED() \ 
     99        __dtraceenabled_postgresql___exec__setop() 
     100#define POSTGRESQL_EXEC_SORT(arg0, arg1) \ 
     101        __dtrace_postgresql___exec__sort(arg0, arg1) 
     102#define POSTGRESQL_EXEC_SORT_ENABLED() \ 
     103        __dtraceenabled_postgresql___exec__sort() 
     104#define POSTGRESQL_EXEC_SUBPLAN_HASH(arg0) \ 
     105        __dtrace_postgresql___exec__subplan__hash(arg0) 
     106#define POSTGRESQL_EXEC_SUBPLAN_HASH_ENABLED() \ 
     107        __dtraceenabled_postgresql___exec__subplan__hash() 
     108#define POSTGRESQL_EXEC_SUBPLAN_SCAN(arg0) \ 
     109        __dtrace_postgresql___exec__subplan__scan(arg0) 
     110#define POSTGRESQL_EXEC_SUBPLAN_SCAN_ENABLED() \ 
     111        __dtraceenabled_postgresql___exec__subplan__scan() 
     112#define POSTGRESQL_EXEC_UNIQUE(arg0) \ 
     113        __dtrace_postgresql___exec__unique(arg0) 
     114#define POSTGRESQL_EXEC_UNIQUE_ENABLED() \ 
     115        __dtraceenabled_postgresql___exec__unique() 
     116#define POSTGRESQL_LOCAL_MARK_DIRTY(arg0) \ 
     117        __dtrace_postgresql___local__mark__dirty(arg0) 
     118#define POSTGRESQL_LOCAL_MARK_DIRTY_ENABLED() \ 
     119        __dtraceenabled_postgresql___local__mark__dirty() 
     120#define POSTGRESQL_LOCK_ENDWAIT(arg0, arg1) \ 
     121        __dtrace_postgresql___lock__endwait(arg0, arg1) 
     122#define POSTGRESQL_LOCK_ENDWAIT_ENABLED() \ 
     123        __dtraceenabled_postgresql___lock__endwait() 
     124#define POSTGRESQL_LOCK_STARTWAIT(arg0, arg1) \ 
     125        __dtrace_postgresql___lock__startwait(arg0, arg1) 
     126#define POSTGRESQL_LOCK_STARTWAIT_ENABLED() \ 
     127        __dtraceenabled_postgresql___lock__startwait() 
     128#define POSTGRESQL_LWLOCK_ACQUIRE(arg0, arg1) \ 
     129        __dtrace_postgresql___lwlock__acquire(arg0, arg1) 
     130#define POSTGRESQL_LWLOCK_ACQUIRE_ENABLED() \ 
     131        __dtraceenabled_postgresql___lwlock__acquire() 
     132#define POSTGRESQL_LWLOCK_CONDACQUIRE(arg0, arg1) \ 
     133        __dtrace_postgresql___lwlock__condacquire(arg0, arg1) 
     134#define POSTGRESQL_LWLOCK_CONDACQUIRE_ENABLED() \ 
     135        __dtraceenabled_postgresql___lwlock__condacquire() 
     136#define POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(arg0, arg1) \ 
     137        __dtrace_postgresql___lwlock__condacquire__fail(arg0, arg1) 
     138#define POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL_ENABLED() \ 
     139        __dtraceenabled_postgresql___lwlock__condacquire__fail() 
     140#define POSTGRESQL_LWLOCK_ENDWAIT(arg0, arg1) \ 
     141        __dtrace_postgresql___lwlock__endwait(arg0, arg1) 
     142#define POSTGRESQL_LWLOCK_ENDWAIT_ENABLED() \ 
     143        __dtraceenabled_postgresql___lwlock__endwait() 
     144#define POSTGRESQL_LWLOCK_RELEASE(arg0) \ 
     145        __dtrace_postgresql___lwlock__release(arg0) 
     146#define POSTGRESQL_LWLOCK_RELEASE_ENABLED() \ 
     147        __dtraceenabled_postgresql___lwlock__release() 
     148#define POSTGRESQL_LWLOCK_STARTWAIT(arg0, arg1) \ 
     149        __dtrace_postgresql___lwlock__startwait(arg0, arg1) 
     150#define POSTGRESQL_LWLOCK_STARTWAIT_ENABLED() \ 
     151        __dtraceenabled_postgresql___lwlock__startwait() 
     152#define POSTGRESQL_MARK_DIRTY(arg0) \ 
     153        __dtrace_postgresql___mark__dirty(arg0) 
     154#define POSTGRESQL_MARK_DIRTY_ENABLED() \ 
     155        __dtraceenabled_postgresql___mark__dirty() 
     156#define POSTGRESQL_MULTIXACT_CHECKPOINT_ENTRY() \ 
     157        __dtrace_postgresql___multixact__checkpoint__entry() 
     158#define POSTGRESQL_MULTIXACT_CHECKPOINT_ENTRY_ENABLED() \ 
     159        __dtraceenabled_postgresql___multixact__checkpoint__entry() 
     160#define POSTGRESQL_MULTIXACT_CHECKPOINT_RETURN() \ 
     161        __dtrace_postgresql___multixact__checkpoint__return() 
     162#define POSTGRESQL_MULTIXACT_CHECKPOINT_RETURN_ENABLED() \ 
     163        __dtraceenabled_postgresql___multixact__checkpoint__return() 
     164#define POSTGRESQL_SLRU_READPAGE_ENTRY(arg0, arg1, arg2, arg3) \ 
     165        __dtrace_postgresql___slru__readpage__entry(arg0, arg1, arg2, arg3) 
     166#define POSTGRESQL_SLRU_READPAGE_ENTRY_ENABLED() \ 
     167        __dtraceenabled_postgresql___slru__readpage__entry() 
     168#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_ENTRY(arg0, arg1, arg2, arg3) \ 
     169        __dtrace_postgresql___slru__readpage__physical__entry(arg0, arg1, arg2, arg3) 
     170#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_ENTRY_ENABLED() \ 
     171        __dtraceenabled_postgresql___slru__readpage__physical__entry() 
     172#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_RETURN(arg0, arg1, arg2) \ 
     173        __dtrace_postgresql___slru__readpage__physical__return(arg0, arg1, arg2) 
     174#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_RETURN_ENABLED() \ 
     175        __dtraceenabled_postgresql___slru__readpage__physical__return() 
     176#define POSTGRESQL_SLRU_READPAGE_RETURN(arg0) \ 
     177        __dtrace_postgresql___slru__readpage__return(arg0) 
     178#define POSTGRESQL_SLRU_READPAGE_RETURN_ENABLED() \ 
     179        __dtraceenabled_postgresql___slru__readpage__return() 
     180#define POSTGRESQL_SLRU_READPAGE_RO(arg0, arg1, arg2) \ 
     181        __dtrace_postgresql___slru__readpage__ro(arg0, arg1, arg2) 
     182#define POSTGRESQL_SLRU_READPAGE_RO_ENABLED() \ 
     183        __dtraceenabled_postgresql___slru__readpage__ro() 
     184#define POSTGRESQL_SLRU_WRITEPAGE_ENTRY(arg0, arg1, arg2) \ 
     185        __dtrace_postgresql___slru__writepage__entry(arg0, arg1, arg2) 
     186#define POSTGRESQL_SLRU_WRITEPAGE_ENTRY_ENABLED() \ 
     187        __dtraceenabled_postgresql___slru__writepage__entry() 
     188#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_ENTRY(arg0, arg1, arg2) \ 
     189        __dtrace_postgresql___slru__writepage__physical__entry(arg0, arg1, arg2) 
     190#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_ENTRY_ENABLED() \ 
     191        __dtraceenabled_postgresql___slru__writepage__physical__entry() 
     192#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_RETURN(arg0, arg1, arg2) \ 
     193        __dtrace_postgresql___slru__writepage__physical__return(arg0, arg1, arg2) 
     194#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_RETURN_ENABLED() \ 
     195        __dtraceenabled_postgresql___slru__writepage__physical__return() 
     196#define POSTGRESQL_SLRU_WRITEPAGE_RETURN() \ 
     197        __dtrace_postgresql___slru__writepage__return() 
     198#define POSTGRESQL_SLRU_WRITEPAGE_RETURN_ENABLED() \ 
     199        __dtraceenabled_postgresql___slru__writepage__return() 
     200#define POSTGRESQL_STATEMENT_START(arg0) \ 
     201        __dtrace_postgresql___statement__start(arg0) 
     202#define POSTGRESQL_STATEMENT_START_ENABLED() \ 
     203        __dtraceenabled_postgresql___statement__start() 
     204#define POSTGRESQL_SUBTRANS_CHECKPOINT_ENTRY() \ 
     205        __dtrace_postgresql___subtrans__checkpoint__entry() 
     206#define POSTGRESQL_SUBTRANS_CHECKPOINT_ENTRY_ENABLED() \ 
     207        __dtraceenabled_postgresql___subtrans__checkpoint__entry() 
     208#define POSTGRESQL_SUBTRANS_CHECKPOINT_RETURN() \ 
     209        __dtrace_postgresql___subtrans__checkpoint__return() 
     210#define POSTGRESQL_SUBTRANS_CHECKPOINT_RETURN_ENABLED() \ 
     211        __dtraceenabled_postgresql___subtrans__checkpoint__return() 
     212#define POSTGRESQL_TRANSACTION_ABORT(arg0) \ 
     213        __dtrace_postgresql___transaction__abort(arg0) 
     214#define POSTGRESQL_TRANSACTION_ABORT_ENABLED() \ 
     215        __dtraceenabled_postgresql___transaction__abort() 
     216#define POSTGRESQL_TRANSACTION_COMMIT(arg0) \ 
     217        __dtrace_postgresql___transaction__commit(arg0) 
     218#define POSTGRESQL_TRANSACTION_COMMIT_ENABLED() \ 
     219        __dtraceenabled_postgresql___transaction__commit() 
     220#define POSTGRESQL_TRANSACTION_START(arg0) \ 
     221        __dtrace_postgresql___transaction__start(arg0) 
     222#define POSTGRESQL_TRANSACTION_START_ENABLED() \ 
     223        __dtraceenabled_postgresql___transaction__start() 
     224#define POSTGRESQL_TWOPHASE_CHECKPOINT_ENTRY() \ 
     225        __dtrace_postgresql___twophase__checkpoint__entry() 
     226#define POSTGRESQL_TWOPHASE_CHECKPOINT_ENTRY_ENABLED() \ 
     227        __dtraceenabled_postgresql___twophase__checkpoint__entry() 
     228#define POSTGRESQL_TWOPHASE_CHECKPOINT_RETURN() \ 
     229        __dtrace_postgresql___twophase__checkpoint__return() 
     230#define POSTGRESQL_TWOPHASE_CHECKPOINT_RETURN_ENABLED() \ 
     231        __dtraceenabled_postgresql___twophase__checkpoint__return() 
     232#define POSTGRESQL_XLOG_CHECKPOINT(arg0, arg1) \ 
     233        __dtrace_postgresql___xlog__checkpoint(arg0, arg1) 
     234#define POSTGRESQL_XLOG_CHECKPOINT_ENABLED() \ 
     235        __dtraceenabled_postgresql___xlog__checkpoint() 
     236#define POSTGRESQL_XLOG_CHECKPOINT_ENTRY(arg0, arg1) \ 
     237        __dtrace_postgresql___xlog__checkpoint__entry(arg0, arg1) 
     238#define POSTGRESQL_XLOG_CHECKPOINT_ENTRY_ENABLED() \ 
     239        __dtraceenabled_postgresql___xlog__checkpoint__entry() 
     240#define POSTGRESQL_XLOG_CHECKPOINT_RETURN() \ 
     241        __dtrace_postgresql___xlog__checkpoint__return() 
     242#define POSTGRESQL_XLOG_CHECKPOINT_RETURN_ENABLED() \ 
     243        __dtraceenabled_postgresql___xlog__checkpoint__return() 
     244#define POSTGRESQL_XLOG_INSERT(arg0, arg1) \ 
     245        __dtrace_postgresql___xlog__insert(arg0, arg1) 
     246#define POSTGRESQL_XLOG_INSERT_ENABLED() \ 
     247        __dtraceenabled_postgresql___xlog__insert() 
     248#define POSTGRESQL_XLOG_SWITCH() \ 
     249        __dtrace_postgresql___xlog__switch() 
     250#define POSTGRESQL_XLOG_SWITCH_ENABLED() \ 
     251        __dtraceenabled_postgresql___xlog__switch() 
    18252 
    19 /* 
    20  * The PG_TRACE macros are mapped to the appropriate macros used by DTrace. 
    21  * 
    22  * Only one DTrace provider called "postgresql" will be used for PostgreSQL, 
    23  * so the name is hard-coded here to avoid having to specify it in the 
    24  * source code. 
    25  */ 
    26253 
    27 #define PG_TRACE(name) \ 
    28         DTRACE_PROBE(postgresql, name) 
    29 #define PG_TRACE1(name, arg1) \ 
    30         DTRACE_PROBE1(postgresql, name, arg1) 
    31 #define PG_TRACE2(name, arg1, arg2) \ 
    32         DTRACE_PROBE2(postgresql, name, arg1, arg2) 
    33 #define PG_TRACE3(name, arg1, arg2, arg3) \ 
    34         DTRACE_PROBE3(postgresql, name, arg1, arg2, arg3) 
    35 #define PG_TRACE4(name, arg1, arg2, arg3, arg4) \ 
    36         DTRACE_PROBE4(postgresql, name, arg1, arg2, arg3, arg4) 
    37 #define PG_TRACE5(name, arg1, arg2, arg3, arg4, arg5) \ 
    38         DTRACE_PROBE5(postgresql, name, arg1, arg2, arg3, arg4, arg5) 
    39 #else                                                   /* not ENABLE_DTRACE */ 
     254extern void __dtrace_postgresql___autovacuum__relation(uint32_t, char *, char *, char *); 
     255extern int __dtraceenabled_postgresql___autovacuum__relation(void); 
     256extern void __dtrace_postgresql___autovacuum__start(uint32_t, char *); 
     257extern int __dtraceenabled_postgresql___autovacuum__start(void); 
     258extern void __dtrace_postgresql___buffer__flush__entry(uint32_t, uint32_t, uint32_t, uint32_t); 
     259extern int __dtraceenabled_postgresql___buffer__flush__entry(void); 
     260extern void __dtrace_postgresql___buffer__flush__return(uint32_t, uint32_t, uint32_t, uint32_t); 
     261extern int __dtraceenabled_postgresql___buffer__flush__return(void); 
     262extern void __dtrace_postgresql___buffer__sync__entry(uint32_t, uint32_t); 
     263extern int __dtraceenabled_postgresql___buffer__sync__entry(void); 
     264extern void __dtrace_postgresql___buffer__sync__return(uint32_t, uint32_t, uint32_t); 
     265extern int __dtraceenabled_postgresql___buffer__sync__return(void); 
     266extern void __dtrace_postgresql___buffer__sync__written(uint32_t); 
     267extern int __dtraceenabled_postgresql___buffer__sync__written(void); 
     268extern void __dtrace_postgresql___buffers__checkpoint__entry(uint32_t); 
     269extern int __dtraceenabled_postgresql___buffers__checkpoint__entry(void); 
     270extern void __dtrace_postgresql___buffers__checkpoint__return(void); 
     271extern int __dtraceenabled_postgresql___buffers__checkpoint__return(void); 
     272extern void __dtrace_postgresql___clog__checkpoint__entry(void); 
     273extern int __dtraceenabled_postgresql___clog__checkpoint__entry(void); 
     274extern void __dtrace_postgresql___clog__checkpoint__return(void); 
     275extern int __dtraceenabled_postgresql___clog__checkpoint__return(void); 
     276extern void __dtrace_postgresql___exec__agg(uintptr_t, uint32_t); 
     277extern int __dtraceenabled_postgresql___exec__agg(void); 
     278extern void __dtrace_postgresql___exec__group(uintptr_t, uint32_t); 
     279extern int __dtraceenabled_postgresql___exec__group(void); 
     280extern void __dtrace_postgresql___exec__hash__multi(uintptr_t); 
     281extern int __dtraceenabled_postgresql___exec__hash__multi(void); 
     282extern void __dtrace_postgresql___exec__hashjoin(uintptr_t); 
     283extern int __dtraceenabled_postgresql___exec__hashjoin(void); 
     284extern void __dtrace_postgresql___exec__limit(uintptr_t); 
     285extern int __dtraceenabled_postgresql___exec__limit(void); 
     286extern void __dtrace_postgresql___exec__material(uintptr_t); 
     287extern int __dtraceenabled_postgresql___exec__material(void); 
     288extern void __dtrace_postgresql___exec__mergejoin(uintptr_t); 
     289extern int __dtraceenabled_postgresql___exec__mergejoin(void); 
     290extern void __dtrace_postgresql___exec__nestloop(uintptr_t); 
     291extern int __dtraceenabled_postgresql___exec__nestloop(void); 
     292extern void __dtrace_postgresql___exec__scan(uintptr_t, uint32_t, uintptr_t); 
     293extern int __dtraceenabled_postgresql___exec__scan(void); 
     294extern void __dtrace_postgresql___exec__setop(uintptr_t); 
     295extern int __dtraceenabled_postgresql___exec__setop(void); 
     296extern void __dtrace_postgresql___exec__sort(uintptr_t, uint32_t); 
     297extern int __dtraceenabled_postgresql___exec__sort(void); 
     298extern void __dtrace_postgresql___exec__subplan__hash(uintptr_t); 
     299extern int __dtraceenabled_postgresql___exec__subplan__hash(void); 
     300extern void __dtrace_postgresql___exec__subplan__scan(uintptr_t); 
     301extern int __dtraceenabled_postgresql___exec__subplan__scan(void); 
     302extern void __dtrace_postgresql___exec__unique(uintptr_t); 
     303extern int __dtraceenabled_postgresql___exec__unique(void); 
     304extern void __dtrace_postgresql___local__mark__dirty(uint32_t); 
     305extern int __dtraceenabled_postgresql___local__mark__dirty(void); 
     306extern void __dtrace_postgresql___lock__endwait(int, int); 
     307extern int __dtraceenabled_postgresql___lock__endwait(void); 
     308extern void __dtrace_postgresql___lock__startwait(int, int); 
     309extern int __dtraceenabled_postgresql___lock__startwait(void); 
     310extern void __dtrace_postgresql___lwlock__acquire(int, int); 
     311extern int __dtraceenabled_postgresql___lwlock__acquire(void); 
     312extern void __dtrace_postgresql___lwlock__condacquire(int, int); 
     313extern int __dtraceenabled_postgresql___lwlock__condacquire(void); 
     314extern void __dtrace_postgresql___lwlock__condacquire__fail(int, int); 
     315extern int __dtraceenabled_postgresql___lwlock__condacquire__fail(void); 
     316extern void __dtrace_postgresql___lwlock__endwait(int, int); 
     317extern int __dtraceenabled_postgresql___lwlock__endwait(void); 
     318extern void __dtrace_postgresql___lwlock__release(int); 
     319extern int __dtraceenabled_postgresql___lwlock__release(void); 
     320extern void __dtrace_postgresql___lwlock__startwait(int, int); 
     321extern int __dtraceenabled_postgresql___lwlock__startwait(void); 
     322extern void __dtrace_postgresql___mark__dirty(uint32_t); 
     323extern int __dtraceenabled_postgresql___mark__dirty(void); 
     324extern void __dtrace_postgresql___multixact__checkpoint__entry(void); 
     325extern int __dtraceenabled_postgresql___multixact__checkpoint__entry(void); 
     326extern void __dtrace_postgresql___multixact__checkpoint__return(void); 
     327extern int __dtraceenabled_postgresql___multixact__checkpoint__return(void); 
     328extern void __dtrace_postgresql___slru__readpage__entry(uintptr_t, uint32_t, uint32_t, uint32_t); 
     329extern int __dtraceenabled_postgresql___slru__readpage__entry(void); 
     330extern void __dtrace_postgresql___slru__readpage__physical__entry(uintptr_t, char *, uint32_t, uint32_t); 
     331extern int __dtraceenabled_postgresql___slru__readpage__physical__entry(void); 
     332extern void __dtrace_postgresql___slru__readpage__physical__return(uint32_t, uint32_t, uint32_t); 
     333extern int __dtraceenabled_postgresql___slru__readpage__physical__return(void); 
     334extern void __dtrace_postgresql___slru__readpage__return(uint32_t); 
     335extern int __dtraceenabled_postgresql___slru__readpage__return(void); 
     336extern void __dtrace_postgresql___slru__readpage__ro(uintptr_t, uint32_t, uint32_t); 
     337extern int __dtraceenabled_postgresql___slru__readpage__ro(void); 
     338extern void __dtrace_postgresql___slru__writepage__entry(uintptr_t, uint32_t, uint32_t); 
     339extern int __dtraceenabled_postgresql___slru__writepage__entry(void); 
     340extern void __dtrace_postgresql___slru__writepage__physical__entry(uintptr_t, uint32_t, uint32_t); 
     341extern int __dtraceenabled_postgresql___slru__writepage__physical__entry(void); 
     342extern void __dtrace_postgresql___slru__writepage__physical__return(uint32_t, uint32_t, uint32_t); 
     343extern int __dtraceenabled_postgresql___slru__writepage__physical__return(void); 
     344extern void __dtrace_postgresql___slru__writepage__return(void); 
     345extern int __dtraceenabled_postgresql___slru__writepage__return(void); 
     346extern void __dtrace_postgresql___statement__start(char *); 
     347extern int __dtraceenabled_postgresql___statement__start(void); 
     348extern void __dtrace_postgresql___subtrans__checkpoint__entry(void); 
     349extern int __dtraceenabled_postgresql___subtrans__checkpoint__entry(void); 
     350extern void __dtrace_postgresql___subtrans__checkpoint__return(void); 
     351extern int __dtraceenabled_postgresql___subtrans__checkpoint__return(void); 
     352extern void __dtrace_postgresql___transaction__abort(int); 
     353extern int __dtraceenabled_postgresql___transaction__abort(void); 
     354extern void __dtrace_postgresql___transaction__commit(int); 
     355extern int __dtraceenabled_postgresql___transaction__commit(void); 
     356extern void __dtrace_postgresql___transaction__start(int); 
     357extern int __dtraceenabled_postgresql___transaction__start(void); 
     358extern void __dtrace_postgresql___twophase__checkpoint__entry(void); 
     359extern int __dtraceenabled_postgresql___twophase__checkpoint__entry(void); 
     360extern void __dtrace_postgresql___twophase__checkpoint__return(void); 
     361extern int __dtraceenabled_postgresql___twophase__checkpoint__return(void); 
     362extern void __dtrace_postgresql___xlog__checkpoint(uint32_t, uint32_t); 
     363extern int __dtraceenabled_postgresql___xlog__checkpoint(void); 
     364extern void __dtrace_postgresql___xlog__checkpoint__entry(uint32_t, uint32_t); 
     365extern int __dtraceenabled_postgresql___xlog__checkpoint__entry(void); 
     366extern void __dtrace_postgresql___xlog__checkpoint__return(void); 
     367extern int __dtraceenabled_postgresql___xlog__checkpoint__return(void); 
     368extern void __dtrace_postgresql___xlog__insert(uint32_t, uint32_t); 
     369extern int __dtraceenabled_postgresql___xlog__insert(void); 
     370extern void __dtrace_postgresql___xlog__switch(void); 
     371extern int __dtraceenabled_postgresql___xlog__switch(void); 
    40372 
    41 /* 
    42  * Unless DTrace is explicitly enabled with --enable-dtrace, the PG_TRACE 
    43  * macros will expand to no-ops. 
    44  */ 
     373#else 
    45374 
    46 #define PG_TRACE(name) 
    47 #define PG_TRACE1(name, arg1) 
    48 #define PG_TRACE2(name, arg1, arg2) 
    49 #define PG_TRACE3(name, arg1, arg2, arg3) 
    50 #define PG_TRACE4(name, arg1, arg2, arg3, arg4) 
    51 #define PG_TRACE5(name, arg1, arg2, arg3, arg4, arg5) 
    52 #endif   /* not ENABLE_DTRACE */ 
     375#define POSTGRESQL_AUTOVACUUM_RELATION(arg0, arg1, arg2, arg3) 
     376#define POSTGRESQL_AUTOVACUUM_RELATION_ENABLED() (0) 
     377#define POSTGRESQL_AUTOVACUUM_START(arg0, arg1) 
     378#define POSTGRESQL_AUTOVACUUM_START_ENABLED() (0) 
     379#define POSTGRESQL_BUFFER_FLUSH_ENTRY(arg0, arg1, arg2, arg3) 
     380#define POSTGRESQL_BUFFER_FLUSH_ENTRY_ENABLED() (0) 
     381#define POSTGRESQL_BUFFER_FLUSH_RETURN(arg0, arg1, arg2, arg3) 
     382#define POSTGRESQL_BUFFER_FLUSH_RETURN_ENABLED() (0) 
     383#define POSTGRESQL_BUFFER_SYNC_ENTRY(arg0, arg1) 
     384#define POSTGRESQL_BUFFER_SYNC_ENTRY_ENABLED() (0) 
     385#define POSTGRESQL_BUFFER_SYNC_RETURN(arg0, arg1, arg2) 
     386#define POSTGRESQL_BUFFER_SYNC_RETURN_ENABLED() (0) 
     387#define POSTGRESQL_BUFFER_SYNC_WRITTEN(arg0) 
     388#define POSTGRESQL_BUFFER_SYNC_WRITTEN_ENABLED() (0) 
     389#define POSTGRESQL_BUFFERS_CHECKPOINT_ENTRY(arg0) 
     390#define POSTGRESQL_BUFFERS_CHECKPOINT_ENTRY_ENABLED() (0) 
     391#define POSTGRESQL_BUFFERS_CHECKPOINT_RETURN() 
     392#define POSTGRESQL_BUFFERS_CHECKPOINT_RETURN_ENABLED() (0) 
     393#define POSTGRESQL_CLOG_CHECKPOINT_ENTRY() 
     394#define POSTGRESQL_CLOG_CHECKPOINT_ENTRY_ENABLED() (0) 
     395#define POSTGRESQL_CLOG_CHECKPOINT_RETURN() 
     396#define POSTGRESQL_CLOG_CHECKPOINT_RETURN_ENABLED() (0) 
     397#define POSTGRESQL_EXEC_AGG(arg0, arg1) 
     398#define POSTGRESQL_EXEC_AGG_ENABLED() (0) 
     399#define POSTGRESQL_EXEC_GROUP(arg0, arg1) 
     400#define POSTGRESQL_EXEC_GROUP_ENABLED() (0) 
     401#define POSTGRESQL_EXEC_HASH_MULTI(arg0) 
     402#define POSTGRESQL_EXEC_HASH_MULTI_ENABLED() (0) 
     403#define POSTGRESQL_EXEC_HASHJOIN(arg0) 
     404#define POSTGRESQL_EXEC_HASHJOIN_ENABLED() (0) 
     405#define POSTGRESQL_EXEC_LIMIT(arg0) 
     406#define POSTGRESQL_EXEC_LIMIT_ENABLED() (0) 
     407#define POSTGRESQL_EXEC_MATERIAL(arg0) 
     408#define POSTGRESQL_EXEC_MATERIAL_ENABLED() (0) 
     409#define POSTGRESQL_EXEC_MERGEJOIN(arg0) 
     410#define POSTGRESQL_EXEC_MERGEJOIN_ENABLED() (0) 
     411#define POSTGRESQL_EXEC_NESTLOOP(arg0) 
     412#define POSTGRESQL_EXEC_NESTLOOP_ENABLED() (0) 
     413#define POSTGRESQL_EXEC_SCAN(arg0, arg1, arg2) 
     414#define POSTGRESQL_EXEC_SCAN_ENABLED() (0) 
     415#define POSTGRESQL_EXEC_SETOP(arg0) 
     416#define POSTGRESQL_EXEC_SETOP_ENABLED() (0) 
     417#define POSTGRESQL_EXEC_SORT(arg0, arg1) 
     418#define POSTGRESQL_EXEC_SORT_ENABLED() (0) 
     419#define POSTGRESQL_EXEC_SUBPLAN_HASH(arg0) 
     420#define POSTGRESQL_EXEC_SUBPLAN_HASH_ENABLED() (0) 
     421#define POSTGRESQL_EXEC_SUBPLAN_SCAN(arg0) 
     422#define POSTGRESQL_EXEC_SUBPLAN_SCAN_ENABLED() (0) 
     423#define POSTGRESQL_EXEC_UNIQUE(arg0) 
     424#define POSTGRESQL_EXEC_UNIQUE_ENABLED() (0) 
     425#define POSTGRESQL_LOCAL_MARK_DIRTY(arg0) 
     426#define POSTGRESQL_LOCAL_MARK_DIRTY_ENABLED() (0) 
     427#define POSTGRESQL_LOCK_ENDWAIT(arg0, arg1) 
     428#define POSTGRESQL_LOCK_ENDWAIT_ENABLED() (0) 
     429#define POSTGRESQL_LOCK_STARTWAIT(arg0, arg1) 
     430#define POSTGRESQL_LOCK_STARTWAIT_ENABLED() (0) 
     431#define POSTGRESQL_LWLOCK_ACQUIRE(arg0, arg1) 
     432#define POSTGRESQL_LWLOCK_ACQUIRE_ENABLED() (0) 
     433#define POSTGRESQL_LWLOCK_CONDACQUIRE(arg0, arg1) 
     434#define POSTGRESQL_LWLOCK_CONDACQUIRE_ENABLED() (0) 
     435#define POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(arg0, arg1) 
     436#define POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL_ENABLED() (0) 
     437#define POSTGRESQL_LWLOCK_ENDWAIT(arg0, arg1) 
     438#define POSTGRESQL_LWLOCK_ENDWAIT_ENABLED() (0) 
     439#define POSTGRESQL_LWLOCK_RELEASE(arg0) 
     440#define POSTGRESQL_LWLOCK_RELEASE_ENABLED() (0) 
     441#define POSTGRESQL_LWLOCK_STARTWAIT(arg0, arg1) 
     442#define POSTGRESQL_LWLOCK_STARTWAIT_ENABLED() (0) 
     443#define POSTGRESQL_MARK_DIRTY(arg0) 
     444#define POSTGRESQL_MARK_DIRTY_ENABLED() (0) 
     445#define POSTGRESQL_MULTIXACT_CHECKPOINT_ENTRY() 
     446#define POSTGRESQL_MULTIXACT_CHECKPOINT_ENTRY_ENABLED() (0) 
     447#define POSTGRESQL_MULTIXACT_CHECKPOINT_RETURN() 
     448#define POSTGRESQL_MULTIXACT_CHECKPOINT_RETURN_ENABLED() (0) 
     449#define POSTGRESQL_SLRU_READPAGE_ENTRY(arg0, arg1, arg2, arg3) 
     450#define POSTGRESQL_SLRU_READPAGE_ENTRY_ENABLED() (0) 
     451#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_ENTRY(arg0, arg1, arg2, arg3) 
     452#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_ENTRY_ENABLED() (0) 
     453#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_RETURN(arg0, arg1, arg2) 
     454#define POSTGRESQL_SLRU_READPAGE_PHYSICAL_RETURN_ENABLED() (0) 
     455#define POSTGRESQL_SLRU_READPAGE_RETURN(arg0) 
     456#define POSTGRESQL_SLRU_READPAGE_RETURN_ENABLED() (0) 
     457#define POSTGRESQL_SLRU_READPAGE_RO(arg0, arg1, arg2) 
     458#define POSTGRESQL_SLRU_READPAGE_RO_ENABLED() (0) 
     459#define POSTGRESQL_SLRU_WRITEPAGE_ENTRY(arg0, arg1, arg2) 
     460#define POSTGRESQL_SLRU_WRITEPAGE_ENTRY_ENABLED() (0) 
     461#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_ENTRY(arg0, arg1, arg2) 
     462#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_ENTRY_ENABLED() (0) 
     463#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_RETURN(arg0, arg1, arg2) 
     464#define POSTGRESQL_SLRU_WRITEPAGE_PHYSICAL_RETURN_ENABLED() (0) 
     465#define POSTGRESQL_SLRU_WRITEPAGE_RETURN() 
     466#define POSTGRESQL_SLRU_WRITEPAGE_RETURN_ENABLED() (0) 
     467#define POSTGRESQL_STATEMENT_START(arg0) 
     468#define POSTGRESQL_STATEMENT_START_ENABLED() (0) 
     469#define POSTGRESQL_SUBTRANS_CHECKPOINT_ENTRY() 
     470#define POSTGRESQL_SUBTRANS_CHECKPOINT_ENTRY_ENABLED() (0) 
     471#define POSTGRESQL_SUBTRANS_CHECKPOINT_RETURN() 
     472#define POSTGRESQL_SUBTRANS_CHECKPOINT_RETURN_ENABLED() (0) 
     473#define POSTGRESQL_TRANSACTION_ABORT(arg0) 
     474#define POSTGRESQL_TRANSACTION_ABORT_ENABLED() (0) 
     475#define POSTGRESQL_TRANSACTION_COMMIT(arg0) 
     476#define POSTGRESQL_TRANSACTION_COMMIT_ENABLED() (0) 
     477#define POSTGRESQL_TRANSACTION_START(arg0) 
     478#define POSTGRESQL_TRANSACTION_START_ENABLED() (0) 
     479#define POSTGRESQL_TWOPHASE_CHECKPOINT_ENTRY() 
     480#define POSTGRESQL_TWOPHASE_CHECKPOINT_ENTRY_ENABLED() (0) 
     481#define POSTGRESQL_TWOPHASE_CHECKPOINT_RETURN() 
     482#define POSTGRESQL_TWOPHASE_CHECKPOINT_RETURN_ENABLED() (0) 
     483#define POSTGRESQL_XLOG_CHECKPOINT(arg0, arg1) 
     484#define POSTGRESQL_XLOG_CHECKPOINT_ENABLED() (0) 
     485#define POSTGRESQL_XLOG_CHECKPOINT_ENTRY(arg0, arg1) 
     486#define POSTGRESQL_XLOG_CHECKPOINT_ENTRY_ENABLED() (0) 
     487#define POSTGRESQL_XLOG_CHECKPOINT_RETURN() 
     488#define POSTGRESQL_XLOG_CHECKPOINT_RETURN_ENABLED() (0) 
     489#define POSTGRESQL_XLOG_INSERT(arg0, arg1) 
     490#define POSTGRESQL_XLOG_INSERT_ENABLED() (0) 
     491#define POSTGRESQL_XLOG_SWITCH() 
     492#define POSTGRESQL_XLOG_SWITCH_ENABLED() (0) 
    53493 
    54 #endif   /* PG_TRACE_H */ 
     494#endif 
     495 
     496 
     497#ifdef  __cplusplus 
     498
     499#endif 
     500 
     501#endif  /* _PG_TRACE_H_TMP */ 
Note: See TracBrowser for help on using the browser.