Rename PGPROC->vacuumFlags to statusFlags

With more flags associated to a PGPROC entry that are not related to
vacuum (currently existing or planned), the name "statusFlags" describes
its purpose better.

(The same is done to the mirroring PROC_HDR->vacuumFlags.)

No functional changes in this commit.

This was suggested first by Hari Babu Kommi in [1] and then by Michael
Paquier at [2].

[1] https://postgr.es/m/CAJrrPGcsDC-oy1AhqH0JkXYa0Z2AgbuXzHPpByLoBGMxfOZMEQ@mail.gmail.com
[2] https://postgr.es/m/20200820060929[email protected]

Author: Dmitry Dolgov <[email protected]>
Reviewed-by: Álvaro Herrera 
Discussion: https://postgr.es/m/20201116182446.qcg3o6szo2zookyr@localhost

diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index 7940060443112e35571fbe22ed5cbbb701b35f66..873bf9bad9850b4a4cb17bd9e47487ea0af6287c 100644 (file)
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -464,7 +464,7 @@ MarkAsPreparingGuts(GlobalTransaction gxact, TransactionId xid, const char *gid,
    proc->xid = xid;
    Assert(proc->xmin == InvalidTransactionId);
    proc->delayChkpt = false;
-   proc->vacuumFlags = 0;
+   proc->statusFlags = 0;
    proc->pid = 0;
    proc->backendId = InvalidBackendId;
    proc->databaseId = databaseid;

diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 1b6717f727efd5caeb7f845b761af7944056bb00..d89ba3031f9a834fe40a00e693c6a55b9a5d032b 100644 (file)
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -1742,10 +1742,10 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params)
         * might appear to go backwards, which is probably Not Good.
         */
        LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
-       MyProc->vacuumFlags |= PROC_IN_VACUUM;
+       MyProc->statusFlags |= PROC_IN_VACUUM;
        if (params->is_wraparound)
-           MyProc->vacuumFlags |= PROC_VACUUM_FOR_WRAPAROUND;
-       ProcGlobal->vacuumFlags[MyProc->pgxactoff] = MyProc->vacuumFlags;
+           MyProc->statusFlags |= PROC_VACUUM_FOR_WRAPAROUND;
+       ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
        LWLockRelease(ProcArrayLock);
    }
 

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 2cef56f115f4e3265eeb7f07a44fefa1545a7cf1..aa5b97fbacbf173d9594d56b59a694d5625ecdd6 100644 (file)
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -2509,7 +2509,7 @@ do_autovacuum(void)
                           tab->at_datname, tab->at_nspname, tab->at_relname);
            EmitErrorReport();
 
-           /* this resets ProcGlobal->vacuumFlags[i] too */
+           /* this resets ProcGlobal->statusFlags[i] too */
            AbortOutOfAnyTransaction();
            FlushErrorState();
            MemoryContextResetAndDeleteChildren(PortalContext);
@@ -2525,7 +2525,7 @@ do_autovacuum(void)
 
        did_vacuum = true;
 
-       /* ProcGlobal->vacuumFlags[i] are reset at the next end of xact */
+       /* ProcGlobal->statusFlags[i] are reset at the next end of xact */
 
        /* be tidy */
 deleted:
@@ -2702,7 +2702,7 @@ perform_work_item(AutoVacuumWorkItem *workitem)
                   cur_datname, cur_nspname, cur_relname);
        EmitErrorReport();
 
-       /* this resets ProcGlobal->vacuumFlags[i] too */
+       /* this resets ProcGlobal->statusFlags[i] too */
        AbortOutOfAnyTransaction();
        FlushErrorState();
        MemoryContextResetAndDeleteChildren(PortalContext);

diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
index d5cfbeaa4affd00e32d754d49079e938592c5a4c..f1f4df7d70f286ad4d4a06efda0a82fbd133a7a8 100644 (file)
--- a/src/backend/replication/logical/logical.c
+++ b/src/backend/replication/logical/logical.c
@@ -182,8 +182,8 @@ StartupDecodingContext(List *output_plugin_options,
    if (!IsTransactionOrTransactionBlock())
    {
        LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
-       MyProc->vacuumFlags |= PROC_IN_LOGICAL_DECODING;
-       ProcGlobal->vacuumFlags[MyProc->pgxactoff] = MyProc->vacuumFlags;
+       MyProc->statusFlags |= PROC_IN_LOGICAL_DECODING;
+       ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
        LWLockRelease(ProcArrayLock);
    }
 

diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index 09be1d8c4851956ed5ed9affcda01a82140dfd08..5ed955ba0bf4a1768c08e3888e53b6949c34f9db 100644 (file)
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -528,8 +528,8 @@ ReplicationSlotRelease(void)
 
    /* might not have been set when we've been a plain slot */
    LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
-   MyProc->vacuumFlags &= ~PROC_IN_LOGICAL_DECODING;
-   ProcGlobal->vacuumFlags[MyProc->pgxactoff] = MyProc->vacuumFlags;
+   MyProc->statusFlags &= ~PROC_IN_LOGICAL_DECODING;
+   ProcGlobal->statusFlags[MyProc->pgxactoff] = MyProc->statusFlags;
    LWLockRelease(ProcArrayLock);
 }
 

diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
index 66113fb8d36f1967a84905e752c143a9d7ffc558..e2cb6e990d1cc089b6f00d2d3031db7dacb977fd 100644 (file)
--- a/src/backend/storage/ipc/procarray.c
+++ b/src/backend/storage/ipc/procarray.c
@@ -488,13 +488,13 @@ ProcArrayAdd(PGPROC *proc)
            (arrayP->numProcs - index) * sizeof(*ProcGlobal->xids));
    memmove(&ProcGlobal->subxidStates[index + 1], &ProcGlobal->subxidStates[index],
            (arrayP->numProcs - index) * sizeof(*ProcGlobal->subxidStates));
-   memmove(&ProcGlobal->vacuumFlags[index + 1], &ProcGlobal->vacuumFlags[index],
-           (arrayP->numProcs - index) * sizeof(*ProcGlobal->vacuumFlags));
+   memmove(&ProcGlobal->statusFlags[index + 1], &ProcGlobal->statusFlags[index],
+           (arrayP->numProcs - index) * sizeof(*ProcGlobal->statusFlags));
 
    arrayP->pgprocnos[index] = proc->pgprocno;
    ProcGlobal->xids[index] = proc->xid;
    ProcGlobal->subxidStates[index] = proc->subxidStatus;
-   ProcGlobal->vacuumFlags[index] = proc->vacuumFlags;
+   ProcGlobal->statusFlags[index] = proc->statusFlags;
 
    arrayP->numProcs++;
 
@@ -562,7 +562,7 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
    Assert(TransactionIdIsValid(ProcGlobal->xids[proc->pgxactoff] == 0));
    Assert(TransactionIdIsValid(ProcGlobal->subxidStates[proc->pgxactoff].count == 0));
    Assert(TransactionIdIsValid(ProcGlobal->subxidStates[proc->pgxactoff].overflowed == false));
-   ProcGlobal->vacuumFlags[proc->pgxactoff] = 0;
+   ProcGlobal->statusFlags[proc->pgxactoff] = 0;
 
    for (index = 0; index < arrayP->numProcs; index++)
    {
@@ -575,8 +575,8 @@ ProcArrayRemove(PGPROC *proc, TransactionId latestXid)
                    (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->xids));
            memmove(&ProcGlobal->subxidStates[index], &ProcGlobal->subxidStates[index + 1],
                    (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->subxidStates));
-           memmove(&ProcGlobal->vacuumFlags[index], &ProcGlobal->vacuumFlags[index + 1],
-                   (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->vacuumFlags));
+           memmove(&ProcGlobal->statusFlags[index], &ProcGlobal->statusFlags[index + 1],
+                   (arrayP->numProcs - index - 1) * sizeof(*ProcGlobal->statusFlags));
 
            arrayP->pgprocnos[arrayP->numProcs - 1] = -1;   /* for debugging */
            arrayP->numProcs--;
@@ -660,13 +660,13 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid)
 
        /* must be cleared with xid/xmin: */
        /* avoid unnecessarily dirtying shared cachelines */
-       if (proc->vacuumFlags & PROC_VACUUM_STATE_MASK)
+       if (proc->statusFlags & PROC_VACUUM_STATE_MASK)
        {
            Assert(!LWLockHeldByMe(ProcArrayLock));
            LWLockAcquire(ProcArrayLock, LW_SHARED);
-           Assert(proc->vacuumFlags == ProcGlobal->vacuumFlags[proc->pgxactoff]);
-           proc->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
-           ProcGlobal->vacuumFlags[proc->pgxactoff] = proc->vacuumFlags;
+           Assert(proc->statusFlags == ProcGlobal->statusFlags[proc->pgxactoff]);
+           proc->statusFlags &= ~PROC_VACUUM_STATE_MASK;
+           ProcGlobal->statusFlags[proc->pgxactoff] = proc->statusFlags;
            LWLockRelease(ProcArrayLock);
        }
    }
@@ -695,10 +695,10 @@ ProcArrayEndTransactionInternal(PGPROC *proc, TransactionId latestXid)
 
    /* must be cleared with xid/xmin: */
    /* avoid unnecessarily dirtying shared cachelines */
-   if (proc->vacuumFlags & PROC_VACUUM_STATE_MASK)
+   if (proc->statusFlags & PROC_VACUUM_STATE_MASK)
    {
-       proc->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
-       ProcGlobal->vacuumFlags[proc->pgxactoff] = proc->vacuumFlags;
+       proc->statusFlags &= ~PROC_VACUUM_STATE_MASK;
+       ProcGlobal->statusFlags[proc->pgxactoff] = proc->statusFlags;
    }
 
    /* Clear the subtransaction-XID cache too while holding the lock */
@@ -875,7 +875,7 @@ ProcArrayClearTransaction(PGPROC *proc)
    proc->xmin = InvalidTransactionId;
    proc->recoveryConflictPending = false;
 
-   Assert(!(proc->vacuumFlags & PROC_VACUUM_STATE_MASK));
+   Assert(!(proc->statusFlags & PROC_VACUUM_STATE_MASK));
    Assert(!proc->delayChkpt);
 
    /*
@@ -1710,7 +1710,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
    {
        int         pgprocno = arrayP->pgprocnos[index];
        PGPROC     *proc = &allProcs[pgprocno];
-       int8        vacuumFlags = ProcGlobal->vacuumFlags[index];
+       int8        statusFlags = ProcGlobal->statusFlags[index];
        TransactionId xid;
        TransactionId xmin;
 
@@ -1745,7 +1745,7 @@ ComputeXidHorizons(ComputeXidHorizonsResult *h)
         * removed, as long as pg_subtrans is not truncated) or doing logical
         * decoding (which manages xmin separately, check below).
         */
-       if (vacuumFlags & (PROC_IN_VACUUM | PROC_IN_LOGICAL_DECODING))
+       if (statusFlags & (PROC_IN_VACUUM | PROC_IN_LOGICAL_DECODING))
            continue;
 
        /* shared tables need to take backends in all database into account */
@@ -2194,7 +2194,7 @@ GetSnapshotData(Snapshot snapshot)
        TransactionId *xip = snapshot->xip;
        int        *pgprocnos = arrayP->pgprocnos;
        XidCacheStatus *subxidStates = ProcGlobal->subxidStates;
-       uint8      *allVacuumFlags = ProcGlobal->vacuumFlags;
+       uint8      *allStatusFlags = ProcGlobal->statusFlags;
 
        /*
         * First collect set of pgxactoff/xids that need to be included in the
@@ -2204,7 +2204,7 @@ GetSnapshotData(Snapshot snapshot)
        {
            /* Fetch xid just once - see GetNewTransactionId */
            TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]);
-           uint8       vacuumFlags;
+           uint8       statusFlags;
 
            Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff);
 
@@ -2243,8 +2243,8 @@ GetSnapshotData(Snapshot snapshot)
             * Skip over backends doing logical decoding which manages xmin
             * separately (check below) and ones running LAZY VACUUM.
             */
-           vacuumFlags = allVacuumFlags[pgxactoff];
-           if (vacuumFlags & (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM))
+           statusFlags = allStatusFlags[pgxactoff];
+           if (statusFlags & (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM))
                continue;
 
            if (NormalTransactionIdPrecedes(xid, xmin))
@@ -2483,11 +2483,11 @@ ProcArrayInstallImportedXmin(TransactionId xmin,
    {
        int         pgprocno = arrayP->pgprocnos[index];
        PGPROC     *proc = &allProcs[pgprocno];
-       int         vacuumFlags = ProcGlobal->vacuumFlags[index];
+       int         statusFlags = ProcGlobal->statusFlags[index];
        TransactionId xid;
 
        /* Ignore procs running LAZY VACUUM */
-       if (vacuumFlags & PROC_IN_VACUUM)
+       if (statusFlags & PROC_IN_VACUUM)
            continue;
 
        /* We are only interested in the specific virtual transaction. */
@@ -3142,7 +3142,7 @@ IsBackendPid(int pid)
  * If excludeXmin0 is true, skip processes with xmin = 0.
  * If allDbs is false, skip processes attached to other databases.
  * If excludeVacuum isn't zero, skip processes for which
- *     (vacuumFlags & excludeVacuum) is not zero.
+ *     (statusFlags & excludeVacuum) is not zero.
  *
  * Note: the purpose of the limitXmin and excludeXmin0 parameters is to
  * allow skipping backends whose oldest live snapshot is no older than
@@ -3176,12 +3176,12 @@ GetCurrentVirtualXIDs(TransactionId limitXmin, bool excludeXmin0,
    {
        int         pgprocno = arrayP->pgprocnos[index];
        PGPROC     *proc = &allProcs[pgprocno];
-       uint8       vacuumFlags = ProcGlobal->vacuumFlags[index];
+       uint8       statusFlags = ProcGlobal->statusFlags[index];
 
        if (proc == MyProc)
            continue;
 
-       if (excludeVacuum & vacuumFlags)
+       if (excludeVacuum & statusFlags)
            continue;
 
        if (allDbs || proc->databaseId == MyDatabaseId)
@@ -3596,7 +3596,7 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared)
        {
            int         pgprocno = arrayP->pgprocnos[index];
            PGPROC     *proc = &allProcs[pgprocno];
-           uint8       vacuumFlags = ProcGlobal->vacuumFlags[index];
+           uint8       statusFlags = ProcGlobal->statusFlags[index];
 
            if (proc->databaseId != databaseId)
                continue;
@@ -3610,7 +3610,7 @@ CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared)
            else
            {
                (*nbackends)++;
-               if ((vacuumFlags & PROC_IS_AUTOVACUUM) &&
+               if ((statusFlags & PROC_IS_AUTOVACUUM) &&
                    nautovacs < MAXAUTOVACPIDS)
                    autovac_pids[nautovacs++] = proc->pid;
            }

diff --git a/src/backend/storage/lmgr/deadlock.c b/src/backend/storage/lmgr/deadlock.c
index e1246b8a4da17a29ba86394618190812b9029b2f..cb7a8f0fd28cdbb01e7f3f033d94ca0a5e898bab 100644 (file)
--- a/src/backend/storage/lmgr/deadlock.c
+++ b/src/backend/storage/lmgr/deadlock.c
@@ -618,7 +618,7 @@ FindLockCycleRecurseMember(PGPROC *checkProc,
                     * that an autovacuum won't be canceled with less than
                     * deadlock_timeout grace period.
                     *
-                    * Note we read vacuumFlags without any locking.  This is
+                    * Note we read statusFlags without any locking.  This is
                     * OK only for checking the PROC_IS_AUTOVACUUM flag,
                     * because that flag is set at process start and never
                     * reset.  There is logic elsewhere to avoid canceling an
@@ -628,7 +628,7 @@ FindLockCycleRecurseMember(PGPROC *checkProc,
                     * ProcArrayLock.
                     */
                    if (checkProc == MyProc &&
-                       proc->vacuumFlags & PROC_IS_AUTOVACUUM)
+                       proc->statusFlags & PROC_IS_AUTOVACUUM)
                        blocking_autovacuum_proc = proc;
 
                    /* We're done looking at this proclock */

diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index 88566bd9fab09a6f69a05aacb8e5166ebad1b285..d1738c65f57cac54c810b05c1129a7fce4f31147 100644 (file)
--- a/src/backend/storage/lmgr/proc.c
+++ b/src/backend/storage/lmgr/proc.c
@@ -111,7 +111,7 @@ ProcGlobalShmemSize(void)
 
    size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->xids)));
    size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->subxidStates)));
-   size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->vacuumFlags)));
+   size = add_size(size, mul_size(TotalProcs, sizeof(*ProcGlobal->statusFlags)));
 
    return size;
 }
@@ -210,8 +210,8 @@ InitProcGlobal(void)
    MemSet(ProcGlobal->xids, 0, TotalProcs * sizeof(*ProcGlobal->xids));
    ProcGlobal->subxidStates = (XidCacheStatus *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->subxidStates));
    MemSet(ProcGlobal->subxidStates, 0, TotalProcs * sizeof(*ProcGlobal->subxidStates));
-   ProcGlobal->vacuumFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->vacuumFlags));
-   MemSet(ProcGlobal->vacuumFlags, 0, TotalProcs * sizeof(*ProcGlobal->vacuumFlags));
+   ProcGlobal->statusFlags = (uint8 *) ShmemAlloc(TotalProcs * sizeof(*ProcGlobal->statusFlags));
+   MemSet(ProcGlobal->statusFlags, 0, TotalProcs * sizeof(*ProcGlobal->statusFlags));
 
    for (i = 0; i < TotalProcs; i++)
    {
@@ -393,10 +393,10 @@ InitProcess(void)
    MyProc->tempNamespaceId = InvalidOid;
    MyProc->isBackgroundWorker = IsBackgroundWorker;
    MyProc->delayChkpt = false;
-   MyProc->vacuumFlags = 0;
+   MyProc->statusFlags = 0;
    /* NB -- autovac launcher intentionally does not set IS_AUTOVACUUM */
    if (IsAutoVacuumWorkerProcess())
-       MyProc->vacuumFlags |= PROC_IS_AUTOVACUUM;
+       MyProc->statusFlags |= PROC_IS_AUTOVACUUM;
    MyProc->lwWaiting = false;
    MyProc->lwWaitMode = 0;
    MyProc->waitLock = NULL;
@@ -574,7 +574,7 @@ InitAuxiliaryProcess(void)
    MyProc->tempNamespaceId = InvalidOid;
    MyProc->isBackgroundWorker = IsBackgroundWorker;
    MyProc->delayChkpt = false;
-   MyProc->vacuumFlags = 0;
+   MyProc->statusFlags = 0;
    MyProc->lwWaiting = false;
    MyProc->lwWaitMode = 0;
    MyProc->waitLock = NULL;
@@ -1310,7 +1310,7 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
        if (deadlock_state == DS_BLOCKED_BY_AUTOVACUUM && allow_autovacuum_cancel)
        {
            PGPROC     *autovac = GetBlockingAutoVacuumPgproc();
-           uint8       vacuumFlags;
+           uint8       statusFlags;
 
            LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
 
@@ -1318,9 +1318,9 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
             * Only do it if the worker is not working to protect against Xid
             * wraparound.
             */
-           vacuumFlags = ProcGlobal->vacuumFlags[autovac->pgxactoff];
-           if ((vacuumFlags & PROC_IS_AUTOVACUUM) &&
-               !(vacuumFlags & PROC_VACUUM_FOR_WRAPAROUND))
+           statusFlags = ProcGlobal->statusFlags[autovac->pgxactoff];
+           if ((statusFlags & PROC_IS_AUTOVACUUM) &&
+               !(statusFlags & PROC_VACUUM_FOR_WRAPAROUND))
            {
                int         pid = autovac->pid;
                StringInfoData locktagbuf;

diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
index 9c9a50ae457fd8a580410772abdffcad9cb74e4b..1067f58f51b52b9f4607d4b252d468975ca20312 100644 (file)
--- a/src/include/storage/proc.h
+++ b/src/include/storage/proc.h
@@ -49,7 +49,7 @@ struct XidCache
 };
 
 /*
- * Flags for ProcGlobal->vacuumFlags[]
+ * Flags for PGPROC->statusFlags and PROC_HDR->statusFlags[]
  */
 #define        PROC_IS_AUTOVACUUM  0x01    /* is it an autovac worker? */
 #define        PROC_IN_VACUUM      0x02    /* currently running lazy vacuum */
@@ -175,9 +175,10 @@ struct PGPROC
 
    bool        delayChkpt;     /* true if this proc delays checkpoint start */
 
-   uint8       vacuumFlags;    /* this backend's vacuum flags, see PROC_*
+   uint8       statusFlags;    /* this backend's status flags, see PROC_*
                                 * above. mirrored in
-                                * ProcGlobal->vacuumFlags[pgxactoff] */
+                                * ProcGlobal->statusFlags[pgxactoff] */
+
    /*
     * Info to allow us to wait for synchronous replication, if needed.
     * waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend.
@@ -273,7 +274,7 @@ extern PGDLLIMPORT PGPROC *MyProc;
  * allow for as tight loops accessing the data as possible. Second, to prevent
  * updates of frequently changing data (e.g. xmin) from invalidating
  * cachelines also containing less frequently changing data (e.g. xid,
- * vacuumFlags). Third to condense frequently accessed data into as few
+ * statusFlags). Third to condense frequently accessed data into as few
  * cachelines as possible.
  *
  * There are two main reasons to have the data mirrored between these dense
@@ -315,10 +316,10 @@ typedef struct PROC_HDR
    XidCacheStatus *subxidStates;
 
    /*
-    * Array mirroring PGPROC.vacuumFlags for each PGPROC currently in the
+    * Array mirroring PGPROC.statusFlags for each PGPROC currently in the
     * procarray.
     */
-   uint8      *vacuumFlags;
+   uint8      *statusFlags;
 
    /* Length of allProcs array */
    uint32      allProcCount;