diff options
Diffstat (limited to 'src/backend/commands/async.c')
| -rw-r--r-- | src/backend/commands/async.c | 196 |
1 files changed, 114 insertions, 82 deletions
diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c index fb1c116bc47..0e3cb83aa93 100644 --- a/src/backend/commands/async.c +++ b/src/backend/commands/async.c @@ -6,7 +6,7 @@ * Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.46 1999/04/25 19:27:43 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.47 1999/05/25 16:08:15 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -31,17 +31,17 @@ * relname to a list of outstanding NOTIFY requests. Actual processing * happens if and only if we reach transaction commit. At that time (in * routine AtCommit_Notify) we scan pg_listener for matching relnames. - * If the listenerPID in a matching tuple is ours, we just send a notify + * If the listenerPID in a matching tuple is ours, we just send a notify * message to our own front end. If it is not ours, and "notification" * is not already nonzero, we set notification to our own PID and send a * SIGUSR2 signal to the receiving process (indicated by listenerPID). * BTW: if the signal operation fails, we presume that the listener backend - * crashed without removing this tuple, and remove the tuple for it. + * crashed without removing this tuple, and remove the tuple for it. * * 4. Upon receipt of a SIGUSR2 signal, the signal handler can call inbound- * notify processing immediately if this backend is idle (ie, it is * waiting for a frontend command and is not within a transaction block). - * Otherwise the handler may only set a flag, which will cause the + * Otherwise the handler may only set a flag, which will cause the * processing to occur just before we next go idle. * * 5. Inbound-notify processing consists of scanning pg_listener for tuples @@ -53,7 +53,7 @@ * * Note that the system's use of pg_listener is confined to very short * intervals at the end of a transaction that contains NOTIFY statements, - * or during the transaction caused by an inbound SIGUSR2. So the fact that + * or during the transaction caused by an inbound SIGUSR2. So the fact that * pg_listener is a global resource shouldn't cause too much performance * problem. But application authors ought to be discouraged from doing * LISTEN or UNLISTEN near the start of a long transaction --- that would @@ -109,8 +109,8 @@ extern CommandDest whereToSendOutput; /* * State for outbound notifies consists of a list of all relnames NOTIFYed - * in the current transaction. We do not actually perform a NOTIFY until - * and unless the transaction commits. pendingNotifies is NULL if no + * in the current transaction. We do not actually perform a NOTIFY until + * and unless the transaction commits. pendingNotifies is NULL if no * NOTIFYs have been done in the current transaction. */ static Dllist *pendingNotifies = NULL; @@ -125,8 +125,8 @@ static Dllist *pendingNotifies = NULL; * does not grok "volatile", you'd be best advised to compile this file * with all optimization turned off. */ -static volatile int notifyInterruptEnabled = 0; -static volatile int notifyInterruptOccurred = 0; +static volatile int notifyInterruptEnabled = 0; +static volatile int notifyInterruptOccurred = 0; /* True if we've registered an on_shmem_exit cleanup (or at least tried to). */ static int unlistenExitRegistered = 0; @@ -142,7 +142,7 @@ static void ClearPendingNotifies(void); /* *-------------------------------------------------------------- - * Async_Notify + * Async_Notify * * This is executed by the SQL notify command. * @@ -164,28 +164,29 @@ Async_Notify(char *relname) /* * We allocate list memory from the global malloc pool to ensure that - * it will live until we want to use it. This is probably not necessary - * any longer, since we will use it before the end of the transaction. - * DLList only knows how to use malloc() anyway, but we could probably - * palloc() the strings... + * it will live until we want to use it. This is probably not + * necessary any longer, since we will use it before the end of the + * transaction. DLList only knows how to use malloc() anyway, but we + * could probably palloc() the strings... */ if (!pendingNotifies) pendingNotifies = DLNewList(); notifyName = strdup(relname); DLAddHead(pendingNotifies, DLNewElem(notifyName)); + /* * NOTE: we could check to see if pendingNotifies already has an entry - * for relname, and thus avoid making duplicate entries. However, most - * apps probably don't notify the same name multiple times per transaction, - * so we'd likely just be wasting cycles to make such a check. - * AsyncExistsPendingNotify() doesn't really care whether the list - * contains duplicates... + * for relname, and thus avoid making duplicate entries. However, + * most apps probably don't notify the same name multiple times per + * transaction, so we'd likely just be wasting cycles to make such a + * check. AsyncExistsPendingNotify() doesn't really care whether the + * list contains duplicates... */ } /* *-------------------------------------------------------------- - * Async_Listen + * Async_Listen * * This is executed by the SQL listen command. * @@ -274,7 +275,7 @@ Async_Listen(char *relname, int pid) /* * now that we are listening, make sure we will unlisten before dying. */ - if (! unlistenExitRegistered) + if (!unlistenExitRegistered) { if (on_shmem_exit(Async_UnlistenOnExit, (caddr_t) NULL) < 0) elog(NOTICE, "Async_Listen: out of shmem_exit slots"); @@ -284,7 +285,7 @@ Async_Listen(char *relname, int pid) /* *-------------------------------------------------------------- - * Async_Unlisten + * Async_Unlisten * * This is executed by the SQL unlisten command. * @@ -326,14 +327,16 @@ Async_Unlisten(char *relname, int pid) UnlockRelation(lRel, AccessExclusiveLock); heap_close(lRel); } - /* We do not complain about unlistening something not being listened; + + /* + * We do not complain about unlistening something not being listened; * should we? */ } /* *-------------------------------------------------------------- - * Async_UnlistenAll + * Async_UnlistenAll * * Unlisten all relations for this backend. * @@ -379,7 +382,7 @@ Async_UnlistenAll() /* *-------------------------------------------------------------- - * Async_UnlistenOnExit + * Async_UnlistenOnExit * * Clean up the pg_listener table at backend exit. * @@ -398,11 +401,12 @@ Async_UnlistenAll() static void Async_UnlistenOnExit() { + /* - * We need to start/commit a transaction for the unlisten, - * but if there is already an active transaction we had better - * abort that one first. Otherwise we'd end up committing changes - * that probably ought to be discarded. + * We need to start/commit a transaction for the unlisten, but if + * there is already an active transaction we had better abort that one + * first. Otherwise we'd end up committing changes that probably + * ought to be discarded. */ AbortOutOfAnyTransaction(); /* Now we can do the unlisten */ @@ -413,7 +417,7 @@ Async_UnlistenOnExit() /* *-------------------------------------------------------------- - * AtCommit_Notify + * AtCommit_Notify * * This is called at transaction commit. * @@ -450,12 +454,14 @@ AtCommit_Notify() int32 listenerPID; if (!pendingNotifies) - return; /* no NOTIFY statements in this transaction */ + return; /* no NOTIFY statements in this + * transaction */ - /* NOTIFY is disabled if not normal processing mode. - * This test used to be in xact.c, but it seems cleaner to do it here. + /* + * NOTIFY is disabled if not normal processing mode. This test used to + * be in xact.c, but it seems cleaner to do it here. */ - if (! IsNormalProcessingMode()) + if (!IsNormalProcessingMode()) { ClearPendingNotifies(); return; @@ -487,10 +493,13 @@ AtCommit_Notify() if (listenerPID == MyProcPid) { - /* Self-notify: no need to bother with table update. + + /* + * Self-notify: no need to bother with table update. * Indeed, we *must not* clear the notification field in - * this path, or we could lose an outside notify, which'd be - * bad for applications that ignore self-notify messages. + * this path, or we could lose an outside notify, which'd + * be bad for applications that ignore self-notify + * messages. */ TPRINTF(TRACE_NOTIFY, "AtCommit_Notify: notifying self"); NotifyMyFrontEnd(relname, listenerPID); @@ -499,23 +508,27 @@ AtCommit_Notify() { TPRINTF(TRACE_NOTIFY, "AtCommit_Notify: notifying pid %d", listenerPID); + /* - * If someone has already notified this listener, - * we don't bother modifying the table, but we do still send - * a SIGUSR2 signal, just in case that backend missed the - * earlier signal for some reason. It's OK to send the signal - * first, because the other guy can't read pg_listener until - * we unlock it. + * If someone has already notified this listener, we don't + * bother modifying the table, but we do still send a + * SIGUSR2 signal, just in case that backend missed the + * earlier signal for some reason. It's OK to send the + * signal first, because the other guy can't read + * pg_listener until we unlock it. */ #ifdef HAVE_KILL if (kill(listenerPID, SIGUSR2) < 0) { - /* Get rid of pg_listener entry if it refers to a PID + + /* + * Get rid of pg_listener entry if it refers to a PID * that no longer exists. Presumably, that backend * crashed without deleting its pg_listener entries. - * This code used to only delete the entry if errno==ESRCH, - * but as far as I can see we should just do it for any - * failure (certainly at least for EPERM too...) + * This code used to only delete the entry if + * errno==ESRCH, but as far as I can see we should + * just do it for any failure (certainly at least for + * EPERM too...) */ heap_delete(lRel, &lTuple->t_self, NULL); } @@ -536,6 +549,7 @@ AtCommit_Notify() } heap_endscan(sRel); + /* * We do not do RelationUnsetLockForWrite(lRel) here, because the * transaction is about to be committed anyway. @@ -549,7 +563,7 @@ AtCommit_Notify() /* *-------------------------------------------------------------- - * AtAbort_Notify + * AtAbort_Notify * * This is called at transaction abort. * @@ -569,7 +583,7 @@ AtAbort_Notify() /* *-------------------------------------------------------------- - * Async_NotifyHandler + * Async_NotifyHandler * * This is the signal handler for SIGUSR2. * @@ -588,25 +602,30 @@ AtAbort_Notify() void Async_NotifyHandler(SIGNAL_ARGS) { + /* - * Note: this is a SIGNAL HANDLER. You must be very wary what you do here. - * Some helpful soul had this routine sprinkled with TPRINTFs, which would - * likely lead to corruption of stdio buffers if they were ever turned on. + * Note: this is a SIGNAL HANDLER. You must be very wary what you do + * here. Some helpful soul had this routine sprinkled with TPRINTFs, + * which would likely lead to corruption of stdio buffers if they were + * ever turned on. */ if (notifyInterruptEnabled) { - /* I'm not sure whether some flavors of Unix might allow another - * SIGUSR2 occurrence to recursively interrupt this routine. - * To cope with the possibility, we do the same sort of dance that - * EnableNotifyInterrupt must do --- see that routine for comments. + + /* + * I'm not sure whether some flavors of Unix might allow another + * SIGUSR2 occurrence to recursively interrupt this routine. To + * cope with the possibility, we do the same sort of dance that + * EnableNotifyInterrupt must do --- see that routine for + * comments. */ notifyInterruptEnabled = 0; /* disable any recursive signal */ notifyInterruptOccurred = 1; /* do at least one iteration */ for (;;) { notifyInterruptEnabled = 1; - if (! notifyInterruptOccurred) + if (!notifyInterruptOccurred) break; notifyInterruptEnabled = 0; if (notifyInterruptOccurred) @@ -621,14 +640,18 @@ Async_NotifyHandler(SIGNAL_ARGS) } else { - /* In this path it is NOT SAFE to do much of anything, except this: */ + + /* + * In this path it is NOT SAFE to do much of anything, except + * this: + */ notifyInterruptOccurred = 1; } } /* * -------------------------------------------------------------- - * EnableNotifyInterrupt + * EnableNotifyInterrupt * * This is called by the PostgresMain main loop just before waiting * for a frontend command. If we are truly idle (ie, *not* inside @@ -652,26 +675,27 @@ EnableNotifyInterrupt(void) * notifyInterruptOccurred and then set notifyInterruptEnabled, we * could fail to respond promptly to a signal that happens in between * those two steps. (A very small time window, perhaps, but Murphy's - * Law says you can hit it...) Instead, we first set the enable flag, - * then test the occurred flag. If we see an unserviced interrupt - * has occurred, we re-clear the enable flag before going off to do - * the service work. (That prevents re-entrant invocation of - * ProcessIncomingNotify() if another interrupt occurs.) - * If an interrupt comes in between the setting and clearing of - * notifyInterruptEnabled, then it will have done the service - * work and left notifyInterruptOccurred zero, so we have to check - * again after clearing enable. The whole thing has to be in a loop - * in case another interrupt occurs while we're servicing the first. - * Once we get out of the loop, enable is set and we know there is no + * Law says you can hit it...) Instead, we first set the enable flag, + * then test the occurred flag. If we see an unserviced interrupt has + * occurred, we re-clear the enable flag before going off to do the + * service work. (That prevents re-entrant invocation of + * ProcessIncomingNotify() if another interrupt occurs.) If an + * interrupt comes in between the setting and clearing of + * notifyInterruptEnabled, then it will have done the service work and + * left notifyInterruptOccurred zero, so we have to check again after + * clearing enable. The whole thing has to be in a loop in case + * another interrupt occurs while we're servicing the first. Once we + * get out of the loop, enable is set and we know there is no * unserviced interrupt. * * NB: an overenthusiastic optimizing compiler could easily break this - * code. Hopefully, they all understand what "volatile" means these days. + * code. Hopefully, they all understand what "volatile" means these + * days. */ for (;;) { notifyInterruptEnabled = 1; - if (! notifyInterruptOccurred) + if (!notifyInterruptOccurred) break; notifyInterruptEnabled = 0; if (notifyInterruptOccurred) @@ -686,7 +710,7 @@ EnableNotifyInterrupt(void) /* * -------------------------------------------------------------- - * DisableNotifyInterrupt + * DisableNotifyInterrupt * * This is called by the PostgresMain main loop just after receiving * a frontend command. Signal handler execution of inbound notifies @@ -702,7 +726,7 @@ DisableNotifyInterrupt(void) /* * -------------------------------------------------------------- - * ProcessIncomingNotify + * ProcessIncomingNotify * * Deal with arriving NOTIFYs from other backends. * This is called either directly from the SIGUSR2 signal handler, @@ -777,6 +801,7 @@ ProcessIncomingNotify(void) } } heap_endscan(sRel); + /* * We do not do RelationUnsetLockForWrite(lRel) here, because the * transaction is about to be committed anyway. @@ -785,7 +810,10 @@ ProcessIncomingNotify(void) CommitTransactionCommand(); - /* Must flush the notify messages to ensure frontend gets them promptly. */ + /* + * Must flush the notify messages to ensure frontend gets them + * promptly. + */ pq_flush(); PS_SET_STATUS("idle"); @@ -800,20 +828,22 @@ NotifyMyFrontEnd(char *relname, int32 listenerPID) if (whereToSendOutput == Remote) { StringInfoData buf; + pq_beginmessage(&buf); pq_sendbyte(&buf, 'A'); pq_sendint(&buf, listenerPID, sizeof(int32)); pq_sendstring(&buf, relname); pq_endmessage(&buf); - /* NOTE: we do not do pq_flush() here. For a self-notify, it will + + /* + * NOTE: we do not do pq_flush() here. For a self-notify, it will * happen at the end of the transaction, and for incoming notifies - * ProcessIncomingNotify will do it after finding all the notifies. + * ProcessIncomingNotify will do it after finding all the + * notifies. */ } else - { elog(NOTICE, "NOTIFY for %s", relname); - } } /* Does pendingNotifies include the given relname? @@ -847,10 +877,12 @@ ClearPendingNotifies() if (pendingNotifies) { - /* Since the referenced strings are malloc'd, we have to scan the + + /* + * Since the referenced strings are malloc'd, we have to scan the * list and delete them individually. If we used palloc for the - * strings then we could just do DLFreeList to get rid of both - * the list nodes and the list base... + * strings then we could just do DLFreeList to get rid of both the + * list nodes and the list base... */ while ((p = DLRemHead(pendingNotifies)) != NULL) { |