int bgw_flags;
BgWorkerStartTime bgw_start_time;
int bgw_restart_time; /* in seconds, or BGW_NEVER_RESTART */
- bgworker_main_type bgw_main;
- char bgw_library_name[BGW_MAXLEN]; /* only if bgw_main is NULL */
- char bgw_function_name[BGW_MAXLEN]; /* only if bgw_main is NULL */
+ char bgw_library_name[BGW_MAXLEN];
+ char bgw_function_name[BGW_MAXLEN];
Datum bgw_main_arg;
char bgw_extra[BGW_EXTRALEN];
int bgw_notify_pid;
process in case of a crash.
</para>
- <para>
- <structfield>bgw_main</structfield> is a pointer to the function to run when
- the process is started. This field can only safely be used to launch
- functions within the core server, because shared libraries may be loaded
- at different starting addresses in different backend processes. This will
- happen on all platforms when the library is loaded using any mechanism
- other than <xref linkend="guc-shared-preload-libraries">. Even when that
- mechanism is used, address space layout variations will still occur on
- Windows, and when <literal>EXEC_BACKEND</> is used. Therefore, most users
- of this API should set this field to NULL. If it is non-NULL, it takes
- precedence over <structfield>bgw_library_name</> and
- <structfield>bgw_function_name</>.
- </para>
-
<para>
<structfield>bgw_library_name</structfield> is the name of a library in
which the initial entry point for the background worker should be sought.
The named library will be dynamically loaded by the worker process and
<structfield>bgw_function_name</structfield> will be used to identify the
- function to be called. If loading a function from the core code,
- <structfield>bgw_main</> should be set instead.
+ function to be called. If loading a function from the core code, this must
+ be set to "postgres".
</para>
<para>
<para>
<structfield>bgw_main_arg</structfield> is the <type>Datum</> argument
- to the background worker main function. Regardless of whether that
- function is specified via <structfield>bgw_main</> or via the combination
- of <function>bgw_library_name</> and <function>bgw_function_name</>,
- this main function should take a single argument of type <type>Datum</>
- and return <type>void</>. <structfield>bgw_main_arg</structfield> will be
- passed as the argument. In addition, the global variable
- <literal>MyBgworkerEntry</literal>
+ to the background worker main function. This main function should take a
+ single argument of type <type>Datum</> and return <type>void</>.
+ <structfield>bgw_main_arg</structfield> will be passed as the argument.
+ In addition, the global variable <literal>MyBgworkerEntry</literal>
points to a copy of the <structname>BackgroundWorker</structname> structure
passed at registration time; the worker may find it helpful to examine
this structure.
<para>
Signals are initially blocked when control reaches the
- <structfield>bgw_main</> function, and must be unblocked by it; this is to
+ background worker's main function, and must be unblocked by it; this is to
allow the process to customize its signal handlers, if necessary.
Signals can be unblocked in the new process by calling
<function>BackgroundWorkerUnblockSignals</> and blocked by calling
/* Private functions. */
static void HandleParallelMessage(ParallelContext *pcxt, int i, StringInfo msg);
static void ParallelExtensionTrampoline(dsm_segment *seg, shm_toc *toc);
-static void ParallelWorkerMain(Datum main_arg);
static void WaitForParallelWorkersToExit(ParallelContext *pcxt);
| BGWORKER_CLASS_PARALLEL;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_restart_time = BGW_NEVER_RESTART;
- worker.bgw_main = ParallelWorkerMain;
+ sprintf(worker.bgw_library_name, "postgres");
+ sprintf(worker.bgw_function_name, "ParallelWorkerMain");
worker.bgw_main_arg = UInt32GetDatum(dsm_segment_handle(pcxt->seg));
worker.bgw_notify_pid = MyProcPid;
memset(&worker.bgw_extra, 0, BGW_EXTRALEN);
/*
* Main entrypoint for parallel workers.
*/
-static void
+void
ParallelWorkerMain(Datum main_arg)
{
dsm_segment *seg;
#include <unistd.h>
#include "libpq/pqsignal.h"
+#include "access/parallel.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/postmaster.h"
#include "replication/logicallauncher.h"
+#include "replication/logicalworker.h"
#include "storage/dsm.h"
#include "storage/ipc.h"
#include "storage/latch.h"
static BackgroundWorkerArray *BackgroundWorkerData;
/*
- * List of workers that are allowed to be started outside of
- * shared_preload_libraries.
+ * List of internal background workers. These are used for mapping the
+ * function name to actual function when building with EXEC_BACKEND and also
+ * to allow these to be loaded outside of shared_preload_libraries.
*/
-static const bgworker_main_type InternalBGWorkers[] = {
- ApplyLauncherMain,
- NULL
+typedef struct InternalBGWorkerMain
+{
+ char *bgw_function_name;
+ bgworker_main_type bgw_main;
+} InternalBGWorkerMain;
+
+static const InternalBGWorkerMain InternalBGWorkers[] = {
+ {"ParallelWorkerMain", ParallelWorkerMain},
+ {"ApplyLauncherMain", ApplyLauncherMain},
+ {"ApplyWorkerMain", ApplyWorkerMain},
+ /* Dummy entry marking end of the array. */
+ {NULL, NULL}
};
+static bgworker_main_type GetInternalBgWorkerMain(BackgroundWorker *worker);
+
/*
* Calculate shared memory needed.
*/
rw->rw_worker.bgw_flags = slot->worker.bgw_flags;
rw->rw_worker.bgw_start_time = slot->worker.bgw_start_time;
rw->rw_worker.bgw_restart_time = slot->worker.bgw_restart_time;
- rw->rw_worker.bgw_main = slot->worker.bgw_main;
rw->rw_worker.bgw_main_arg = slot->worker.bgw_main_arg;
memcpy(rw->rw_worker.bgw_extra, slot->worker.bgw_extra, BGW_EXTRALEN);
}
/*
- * If bgw_main is set, we use that value as the initial entrypoint.
- * However, if the library containing the entrypoint wasn't loaded at
- * postmaster startup time, passing it as a direct function pointer is not
- * possible. To work around that, we allow callers for whom a function
- * pointer is not available to pass a library name (which will be loaded,
- * if necessary) and a function name (which will be looked up in the named
- * library).
+ * For internal workers set the entry point to known function address.
+ * Otherwise use the entry point specified by library name (which will
+ * be loaded, if necessary) and a function name (which will be looked up
+ * in the named library).
*/
- if (worker->bgw_main != NULL)
- entrypt = worker->bgw_main;
- else
+ entrypt = GetInternalBgWorkerMain(worker);
+
+ if (entrypt == NULL)
entrypt = (bgworker_main_type)
load_external_function(worker->bgw_library_name,
worker->bgw_function_name,
{
RegisteredBgWorker *rw;
static int numworkers = 0;
- bool internal = false;
- int i;
if (!IsUnderPostmaster)
ereport(DEBUG1,
(errmsg("registering background worker \"%s\"", worker->bgw_name)));
- for (i = 0; InternalBGWorkers[i]; i++)
- {
- if (worker->bgw_main == InternalBGWorkers[i])
- {
- internal = true;
- break;
- }
- }
-
- if (!process_shared_preload_libraries_in_progress && !internal)
+ if (!process_shared_preload_libraries_in_progress &&
+ GetInternalBgWorkerMain(worker) == NULL)
{
if (!IsUnderPostmaster)
ereport(LOG,
if (signal_postmaster)
SendPostmasterSignal(PMSIGNAL_BACKGROUND_WORKER_CHANGE);
}
+
+/*
+ * Search the known internal worker array and return its main function
+ * pointer if found.
+ *
+ * Returns NULL if not known internal worker.
+ */
+static bgworker_main_type
+GetInternalBgWorkerMain(BackgroundWorker *worker)
+{
+ int i;
+
+ /* Internal workers always have to use postgres as library name. */
+ if (strncmp(worker->bgw_library_name, "postgres", BGW_MAXLEN) != 0)
+ return NULL;
+
+ for (i = 0; InternalBGWorkers[i].bgw_function_name; i++)
+ {
+ if (strncmp(InternalBGWorkers[i].bgw_function_name,
+ worker->bgw_function_name, BGW_MAXLEN) == 0)
+ return InternalBGWorkers[i].bgw_main;
+ }
+
+ return NULL;
+}
bgw.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
bgw.bgw_start_time = BgWorkerStart_RecoveryFinished;
- bgw.bgw_main = ApplyWorkerMain;
+ snprintf(bgw.bgw_library_name, BGW_MAXLEN, "postgres");
+ snprintf(bgw.bgw_function_name, BGW_MAXLEN, "ApplyWorkerMain");
if (OidIsValid(relid))
snprintf(bgw.bgw_name, BGW_MAXLEN,
"logical replication worker for subscription %u sync %u", subid, relid);
bgw.bgw_flags = BGWORKER_SHMEM_ACCESS |
BGWORKER_BACKEND_DATABASE_CONNECTION;
bgw.bgw_start_time = BgWorkerStart_RecoveryFinished;
- bgw.bgw_main = ApplyLauncherMain;
+ snprintf(bgw.bgw_library_name, BGW_MAXLEN, "postgres");
+ snprintf(bgw.bgw_function_name, BGW_MAXLEN, "ApplyLauncherMain");
snprintf(bgw.bgw_name, BGW_MAXLEN,
"logical replication launcher");
bgw.bgw_restart_time = 5;
extern void AtEOSubXact_Parallel(bool isCommit, SubTransactionId mySubId);
extern void ParallelWorkerReportLastRecEnd(XLogRecPtr last_xlog_end);
+extern void ParallelWorkerMain(Datum main_arg);
+
#endif /* PARALLEL_H */
int bgw_flags;
BgWorkerStartTime bgw_start_time;
int bgw_restart_time; /* in seconds, or BGW_NEVER_RESTART */
- bgworker_main_type bgw_main;
- char bgw_library_name[BGW_MAXLEN]; /* only if bgw_main is NULL */
- char bgw_function_name[BGW_MAXLEN]; /* only if bgw_main is NULL */
+ char bgw_library_name[BGW_MAXLEN];
+ char bgw_function_name[BGW_MAXLEN];
Datum bgw_main_arg;
char bgw_extra[BGW_EXTRALEN];
pid_t bgw_notify_pid; /* SIGUSR1 this backend on start/stop */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS;
worker.bgw_start_time = BgWorkerStart_ConsistentState;
worker.bgw_restart_time = BGW_NEVER_RESTART;
- worker.bgw_main = NULL; /* new worker might not have library loaded */
sprintf(worker.bgw_library_name, "test_shm_mq");
sprintf(worker.bgw_function_name, "test_shm_mq_main");
snprintf(worker.bgw_name, BGW_MAXLEN, "test_shm_mq");
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = BGW_NEVER_RESTART;
- worker.bgw_main = worker_spi_main;
+ sprintf(worker.bgw_library_name, "worker_spi");
+ sprintf(worker.bgw_function_name, "worker_spi_main");
worker.bgw_notify_pid = 0;
/*
BGWORKER_BACKEND_DATABASE_CONNECTION;
worker.bgw_start_time = BgWorkerStart_RecoveryFinished;
worker.bgw_restart_time = BGW_NEVER_RESTART;
- worker.bgw_main = NULL; /* new worker might not have library loaded */
sprintf(worker.bgw_library_name, "worker_spi");
sprintf(worker.bgw_function_name, "worker_spi_main");
snprintf(worker.bgw_name, BGW_MAXLEN, "worker %d", i);
projects / postgresql / commitdiff