database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-08-05 07:41:25 +03:00
Code Activity

Pgindent win32 signal code.

Browse Source
This commit is contained in:
Bruce Momjian
2004-01-27 00:46:58 +00:00
parent 50491963cb
commit 70d5811514
1 changed files with 214 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

349
src/backend/libpq/pqsignal.c
View File

@@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/libpq/pqsignal.c,v 1.29 2004/01/27 00:45:26 momjian Exp $ * $PostgreSQL: pgsql/src/backend/libpq/pqsignal.c,v 1.30 2004/01/27 00:46:58 momjian Exp $
* *
* NOTES * NOTES
* This shouldn't be in libpq, but the monitor and some other * This shouldn't be in libpq, but the monitor and some other
@@ -169,141 +169,171 @@ pqsignal(int signo, pqsigfunc func)
/* pg_signal_crit_sec is used to protect only pg_signal_queue. That is the only /* pg_signal_crit_sec is used to protect only pg_signal_queue. That is the only
* variable that can be accessed from the signal sending threads! */ * variable that can be accessed from the signal sending threads! */
static CRITICAL_SECTION pg_signal_crit_sec; static CRITICAL_SECTION pg_signal_crit_sec;
static int pg_signal_queue; static int pg_signal_queue;
#define PG_SIGNAL_COUNT 32 #define PG_SIGNAL_COUNT 32
static pqsigfunc pg_signal_array[PG_SIGNAL_COUNT]; static pqsigfunc pg_signal_array[PG_SIGNAL_COUNT];
static pqsigfunc pg_signal_defaults[PG_SIGNAL_COUNT]; static pqsigfunc pg_signal_defaults[PG_SIGNAL_COUNT];
static int pg_signal_mask; static int pg_signal_mask;
HANDLE pgwin32_main_thread_handle; HANDLE pgwin32_main_thread_handle;
/* Signal handling thread function */ /* Signal handling thread function */
static DWORD WINAPI pg_signal_thread(LPVOID param); static DWORD WINAPI pg_signal_thread(LPVOID param);
/* Initialization */ /* Initialization */
void pgwin32_signal_initialize(void) { void
int i; pgwin32_signal_initialize(void)
HANDLE signal_thread_handle; {
InitializeCriticalSection(&pg_signal_crit_sec); int i;
HANDLE signal_thread_handle;
for (i = 0; i < PG_SIGNAL_COUNT; i++) { InitializeCriticalSection(&pg_signal_crit_sec);
pg_signal_array[i] = SIG_DFL;
pg_signal_defaults[i] = SIG_IGN;
}
pg_signal_mask = 0;
pg_signal_queue = 0;
/* Get handle to main thread so we can post calls to it later */ for (i = 0; i < PG_SIGNAL_COUNT; i++)
if (!DuplicateHandle(GetCurrentProcess(),GetCurrentThread(), {
GetCurrentProcess(),&pgwin32_main_thread_handle, pg_signal_array[i] = SIG_DFL;
0,FALSE,DUPLICATE_SAME_ACCESS)) { pg_signal_defaults[i] = SIG_IGN;
fprintf(stderr,gettext("Failed to get main thread handle!\n")); }
exit(1); pg_signal_mask = 0;
} pg_signal_queue = 0;
/* Create thread for handling signals */ /* Get handle to main thread so we can post calls to it later */
signal_thread_handle = CreateThread(NULL,0,pg_signal_thread,NULL,0,NULL); if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
if (signal_thread_handle == NULL) { GetCurrentProcess(), &pgwin32_main_thread_handle,
fprintf(stderr,gettext("Failed to create signal handler thread!\n")); 0, FALSE, DUPLICATE_SAME_ACCESS))
exit(1); {
} fprintf(stderr, gettext("Failed to get main thread handle!\n"));
exit(1);
}
/* Create thread for handling signals */
signal_thread_handle = CreateThread(NULL, 0, pg_signal_thread, NULL, 0, NULL);
if (signal_thread_handle == NULL)
{
fprintf(stderr, gettext("Failed to create signal handler thread!\n"));
exit(1);
}
} }
/* Dispatch all signals currently queued and not blocked /* Dispatch all signals currently queued and not blocked
* Blocked signals are ignored, and will be fired at the time of * Blocked signals are ignored, and will be fired at the time of
* the sigsetmask() call. */ * the sigsetmask() call. */
static void dispatch_queued_signals(void) { static void
int i; dispatch_queued_signals(void)
{
int i;
EnterCriticalSection(&pg_signal_crit_sec); EnterCriticalSection(&pg_signal_crit_sec);
while (pg_signal_queue & ~pg_signal_mask) { while (pg_signal_queue & ~pg_signal_mask)
/* One or more unblocked signals queued for execution */ {
/* One or more unblocked signals queued for execution */
int exec_mask = pg_signal_queue & ~pg_signal_mask; int exec_mask = pg_signal_queue & ~pg_signal_mask;
for (i = 0; i < PG_SIGNAL_COUNT; i++) { for (i = 0; i < PG_SIGNAL_COUNT; i++)
if (exec_mask & sigmask(i)) { {
/* Execute this signal */ if (exec_mask & sigmask(i))
pqsigfunc sig = pg_signal_array[i]; {
if (sig == SIG_DFL) /* Execute this signal */
sig = pg_signal_defaults[i]; pqsigfunc sig = pg_signal_array[i];
pg_signal_queue &= ~sigmask(i);
if (sig != SIG_ERR && sig != SIG_IGN && sig != SIG_DFL) { if (sig == SIG_DFL)
LeaveCriticalSection(&pg_signal_crit_sec); sig = pg_signal_defaults[i];
sig(i); pg_signal_queue &= ~sigmask(i);
EnterCriticalSection(&pg_signal_crit_sec); if (sig != SIG_ERR && sig != SIG_IGN && sig != SIG_DFL)
break; /* Restart outer loop, in case signal mask or queue {
has been modified inside signal handler */ LeaveCriticalSection(&pg_signal_crit_sec);
sig(i);
EnterCriticalSection(&pg_signal_crit_sec);
break; /* Restart outer loop, in case signal mask
* or queue has been modified inside
* signal handler */
}
}
}
} }
} LeaveCriticalSection(&pg_signal_crit_sec);
}
}
LeaveCriticalSection(&pg_signal_crit_sec);
} }
/* signal masking. Only called on main thread, no sync required */ /* signal masking. Only called on main thread, no sync required */
int pqsigsetmask(int mask) { int
int prevmask; pqsigsetmask(int mask)
prevmask = pg_signal_mask; {
pg_signal_mask = mask; int prevmask;
/* Dispatch any signals queued up right away, in case we have prevmask = pg_signal_mask;
unblocked one or more signals previously queued */ pg_signal_mask = mask;
dispatch_queued_signals();
return prevmask; /*
* Dispatch any signals queued up right away, in case we have
* unblocked one or more signals previously queued
*/
dispatch_queued_signals();
return prevmask;
} }
/* signal manipulation. Only called on main thread, no sync required */ /* signal manipulation. Only called on main thread, no sync required */
pqsigfunc pqsignal(int signum, pqsigfunc handler) { pqsigfunc
pqsigfunc prevfunc; pqsignal(int signum, pqsigfunc handler)
if (signum >= PG_SIGNAL_COUNT || signum < 0) {
return SIG_ERR; pqsigfunc prevfunc;
prevfunc = pg_signal_array[signum];
pg_signal_array[signum] = handler; if (signum >= PG_SIGNAL_COUNT || signum < 0)
return prevfunc; return SIG_ERR;
prevfunc = pg_signal_array[signum];
pg_signal_array[signum] = handler;
return prevfunc;
} }
/* signal sending */ /* signal sending */
int pqkill(int pid, int sig) { int
char pipename[128]; pqkill(int pid, int sig)
BYTE sigData = sig; {
BYTE sigRet = 0; char pipename[128];
DWORD bytes; BYTE sigData = sig;
BYTE sigRet = 0;
DWORD bytes;
if (sig >= PG_SIGNAL_COUNT || sig <= 0) { if (sig >= PG_SIGNAL_COUNT || sig <= 0)
errno = EINVAL; {
return -1; errno = EINVAL;
} return -1;
if (pid <= 0) { }
/* No support for process groups */ if (pid <= 0)
errno = EINVAL; {
return -1; /* No support for process groups */
} errno = EINVAL;
wsprintf(pipename,"\\\\.\\pipe\\pgsignal_%i",pid); return -1;
if (!CallNamedPipe(pipename,&sigData,1,&sigRet,1,&bytes,1000)) { }
if (GetLastError() == ERROR_FILE_NOT_FOUND) wsprintf(pipename, "\\\\.\\pipe\\pgsignal_%i", pid);
errno = ESRCH; if (!CallNamedPipe(pipename, &sigData, 1, &sigRet, 1, &bytes, 1000))
else if (GetLastError() == ERROR_ACCESS_DENIED) {
errno = EPERM; if (GetLastError() == ERROR_FILE_NOT_FOUND)
else errno = ESRCH;
errno = EINVAL; else if (GetLastError() == ERROR_ACCESS_DENIED)
return -1; errno = EPERM;
} else
if (bytes != 1 || sigRet != sig) { errno = EINVAL;
errno = ESRCH; return -1;
return -1; }
} if (bytes != 1 || sigRet != sig)
{
errno = ESRCH;
return -1;
}
return 0; return 0;
} }
/* APC callback scheduled on main thread when signals are fired */ /* APC callback scheduled on main thread when signals are fired */
static void CALLBACK pg_signal_apc(ULONG_PTR param) { static void CALLBACK
dispatch_queued_signals(); pg_signal_apc(ULONG_PTR param)
{
dispatch_queued_signals();
} }
/* /*
@@ -314,78 +344,89 @@ static void CALLBACK pg_signal_apc(ULONG_PTR param) {
*/ */
static void pg_queue_signal(int signum) { static void
if (signum >= PG_SIGNAL_COUNT || signum < 0) pg_queue_signal(int signum)
return; {
if (signum >= PG_SIGNAL_COUNT || signum < 0)
return;
EnterCriticalSection(&pg_signal_crit_sec); EnterCriticalSection(&pg_signal_crit_sec);
pg_signal_queue |= sigmask(signum); pg_signal_queue |= sigmask(signum);
LeaveCriticalSection(&pg_signal_crit_sec); LeaveCriticalSection(&pg_signal_crit_sec);
QueueUserAPC(pg_signal_apc,pgwin32_main_thread_handle,(ULONG_PTR)NULL); QueueUserAPC(pg_signal_apc, pgwin32_main_thread_handle, (ULONG_PTR) NULL);
} }
/* Signal dispatching thread */ /* Signal dispatching thread */
static DWORD WINAPI pg_signal_dispatch_thread(LPVOID param) { static DWORD WINAPI
HANDLE pipe = (HANDLE)param; pg_signal_dispatch_thread(LPVOID param)
BYTE sigNum; {
DWORD bytes; HANDLE pipe = (HANDLE) param;
BYTE sigNum;
DWORD bytes;
if (!ReadFile(pipe,&sigNum,1,&bytes,NULL)) { if (!ReadFile(pipe, &sigNum, 1, &bytes, NULL))
/* Client died before sending */ {
CloseHandle(pipe); /* Client died before sending */
return 0; CloseHandle(pipe);
} return 0;
if (bytes != 1) { }
/* Received <bytes> bytes over signal pipe (should be 1) */ if (bytes != 1)
CloseHandle(pipe); {
return 0; /* Received <bytes> bytes over signal pipe (should be 1) */
} CloseHandle(pipe);
WriteFile(pipe,&sigNum,1,&bytes,NULL); /* Don't care if it works or not.. */ return 0;
FlushFileBuffers(pipe); }
DisconnectNamedPipe(pipe); WriteFile(pipe, &sigNum, 1, &bytes, NULL); /* Don't care if it works
CloseHandle(pipe); * or not.. */
FlushFileBuffers(pipe);
DisconnectNamedPipe(pipe);
CloseHandle(pipe);
pg_queue_signal(sigNum); pg_queue_signal(sigNum);
return 0; return 0;
} }
/* Signal handling thread */ /* Signal handling thread */
static DWORD WINAPI pg_signal_thread(LPVOID param) { static DWORD WINAPI
char pipename[128]; pg_signal_thread(LPVOID param)
HANDLE pipe = INVALID_HANDLE_VALUE; {
char pipename[128];
HANDLE pipe = INVALID_HANDLE_VALUE;
wsprintf(pipename,"\\\\.\\pipe\\pgsignal_%i",GetCurrentProcessId()); wsprintf(pipename, "\\\\.\\pipe\\pgsignal_%i", GetCurrentProcessId());
for (;;) { for (;;)
BOOL fConnected; {
HANDLE hThread; BOOL fConnected;
HANDLE hThread;
pipe = CreateNamedPipe(pipename,PIPE_ACCESS_DUPLEX, pipe = CreateNamedPipe(pipename, PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,16,16,1000,NULL); PIPE_UNLIMITED_INSTANCES, 16, 16, 1000, NULL);
if (pipe == INVALID_HANDLE_VALUE) { if (pipe == INVALID_HANDLE_VALUE)
fprintf(stderr,gettext("Failed to create signal listener pipe: %i. Retrying.\n"),(int)GetLastError()); {
SleepEx(500,TRUE); fprintf(stderr, gettext("Failed to create signal listener pipe: %i. Retrying.\n"), (int) GetLastError());
continue; SleepEx(500, TRUE);
} continue;
}
fConnected = ConnectNamedPipe(pipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); fConnected = ConnectNamedPipe(pipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
if (fConnected) { if (fConnected)
hThread = CreateThread(NULL, 0, {
(LPTHREAD_START_ROUTINE)pg_signal_dispatch_thread, hThread = CreateThread(NULL, 0,
(LPVOID)pipe,0,NULL); (LPTHREAD_START_ROUTINE) pg_signal_dispatch_thread,
if (hThread == INVALID_HANDLE_VALUE) { (LPVOID) pipe, 0, NULL);
fprintf(stderr,gettext("Failed to create signal dispatch thread: %i\n"),(int)GetLastError()); if (hThread == INVALID_HANDLE_VALUE)
} fprintf(stderr, gettext("Failed to create signal dispatch thread: %i\n"), (int) GetLastError());
else else
CloseHandle(hThread); CloseHandle(hThread);
} }
else else
/* Connection failed. Cleanup and try again */ /* Connection failed. Cleanup and try again */
CloseHandle(pipe); CloseHandle(pipe);
} }
return 0; return 0;
} }