This patch simplified Win32 signaling code per discussion in hackers. In
this implementation, each process will have a named (by its pid) mutex,
named shared memory area and named event in global namespace. The process
is
sending/receiving signals as the following:

(*) the process who kill the signal:
 - Grab the named mutex, set signal bit in target process's shared memory
area and SetEvent(), then it is done;

(*) the process who should receive the signal:
 - the main thread of this process could be awakened by the event from
waiting status(like semop()) or CHECK_FOR_INTERRUPTS() actively; -- there
is
no other threads of the process;

Details could be found in this thread and follows:
http://archives.postgresql.org/pgsql-hackers/2005-05/msg01388.php


Regards,
Qingqing
Index: backend/port/win32/signal.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/port/win32/signal.c,v
retrieving revision 1.11
diff -c -r1.11 signal.c
*** backend/port/win32/signal.c 31 Dec 2004 22:00:37 -0000      1.11
--- backend/port/win32/signal.c 2 Jun 2005 12:38:32 -0000
***************
*** 14,43 ****
  #include "postgres.h"
  
  #include <libpq/pqsignal.h>
  
  
! /* 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! */
! static CRITICAL_SECTION pg_signal_crit_sec;
! static int    pg_signal_queue;
  
  static pqsigfunc pg_signal_array[PG_SIGNAL_COUNT];
  static pqsigfunc pg_signal_defaults[PG_SIGNAL_COUNT];
  static int    pg_signal_mask;
  
- DLLIMPORT HANDLE pgwin32_signal_event;
- HANDLE pgwin32_initial_signal_pipe = INVALID_HANDLE_VALUE;
- 
- 
- /* Signal handling thread function */
- static DWORD WINAPI pg_signal_thread(LPVOID param);
  static BOOL WINAPI pg_console_handler(DWORD dwCtrlType);
  
! /* Sleep function that can be interrupted by signals */
  void
  pgwin32_backend_usleep(long microsec)
  {
!       if (WaitForSingleObject(pgwin32_signal_event, (microsec < 500 ? 1 : 
(microsec + 500) / 1000)) == WAIT_OBJECT_0)
        {
                pgwin32_dispatch_queued_signals();
                errno = EINTR;
--- 14,57 ----
  #include "postgres.h"
  
  #include <libpq/pqsignal.h>
+ #include "miscadmin.h"
  
+ /* Simplified ereport for this module */
+ #define ereport_signal(elevel, msg)   \
+       ereport((elevel), \
+                       (errmsg_internal("%s: error code: %d", (msg), 
(int)GetLastError())));
+ 
+ /* Lock/Unlock signal area primitives */
+ #define lock_signal_shmem()   \
+ do { \
+       if (WaitForSingleObject(MySignalShmem->mutex, INFINITE) != 
WAIT_OBJECT_0)       \
+               ereport_signal(ERROR, "failed to wait on signal mutex");        
\
+ }while(0)
+ 
+ #define unlock_signal_shmem() \
+ do{   \
+       if (!ReleaseMutex(MySignalShmem->mutex))        \
+               ereport_signal(ERROR, "failed to release signal mutex");        
\
+ }while(0)
  
! /* Point to signal shared memory of current process */
! DLLIMPORT Win32SignalShmemStruct      *MySignalShmem;
  
  static pqsigfunc pg_signal_array[PG_SIGNAL_COUNT];
  static pqsigfunc pg_signal_defaults[PG_SIGNAL_COUNT];
  static int    pg_signal_mask;
  
  static BOOL WINAPI pg_console_handler(DWORD dwCtrlType);
  
! /* 
!  * pgwin32_backend_usleep
!  *            Sleep function that can be interrupted by signals 
!  */
  void
  pgwin32_backend_usleep(long microsec)
  {
!       if (WaitForSingleObject(pgwin32_signal_event, (microsec < 500 ? 
!                                                                       1 : 
(microsec + 500) / 1000)) == WAIT_OBJECT_0)
        {
                pgwin32_dispatch_queued_signals();
                errno = EINTR;
***************
*** 45,101 ****
        }
  }
  
! 
! /* Initialization */
  void
  pgwin32_signal_initialize(void)
  {
        int                     i;
!       HANDLE          signal_thread_handle;
! 
!       InitializeCriticalSection(&pg_signal_crit_sec);
  
        for (i = 0; i < PG_SIGNAL_COUNT; i++)
        {
                pg_signal_array[i] = SIG_DFL;
                pg_signal_defaults[i] = SIG_IGN;
        }
        pg_signal_mask = 0;
-       pg_signal_queue = 0;
  
!       /* Create the global event handle used to flag signals */
!       pgwin32_signal_event = CreateEvent(NULL, TRUE, FALSE, NULL);
!       if (pgwin32_signal_event == NULL)
!               ereport(FATAL,
!                               (errmsg_internal("failed to create signal 
event: %d", (int) GetLastError())));
! 
!       /* Create thread for handling signals */
!       signal_thread_handle = CreateThread(NULL, 0, pg_signal_thread, NULL, 0, 
NULL);
!       if (signal_thread_handle == NULL)
!               ereport(FATAL,
!                       (errmsg_internal("failed to create signal handler 
thread")));
  
        /* Create console control handle to pick up Ctrl-C etc */
        if (!SetConsoleCtrlHandler(pg_console_handler, TRUE))
!               ereport(FATAL,
!                        (errmsg_internal("failed to set console control 
handler")));
  }
  
! 
! /* Dispatch all signals currently queued and not blocked
!  * Blocked signals are ignored, and will be fired at the time of
!  * the sigsetmask() call. */
  void
  pgwin32_dispatch_queued_signals(void)
  {
        int                     i;
  
!       EnterCriticalSection(&pg_signal_crit_sec);
!       while (pg_signal_queue & ~pg_signal_mask)
        {
                /* One or more unblocked signals queued for execution */
! 
!               int                     exec_mask = pg_signal_queue & 
~pg_signal_mask;
  
                for (i = 0; i < PG_SIGNAL_COUNT; i++)
                {
--- 59,152 ----
        }
  }
  
! /* 
!  * pgwin32_signal_initialize
!  *            Allocate and initialize signal emulation shared memory, 
!  *            including a mutex protecting the whole area, an event 
!  *            notifying that a signal was sent to current process, and 
!  *            a queue saving signals. All of them are in global namespace. 
!  */
  void
  pgwin32_signal_initialize(void)
  {
        int                     i;
!       char            name[64];
!       HANDLE          hShmem;
!       SECURITY_ATTRIBUTES sa;
! 
!       ZeroMemory(&sa, sizeof(sa));
!       sa.nLength = sizeof(sa);
!       sa.bInheritHandle = FALSE;      
  
+       /* Initialize the local part */
        for (i = 0; i < PG_SIGNAL_COUNT; i++)
        {
                pg_signal_array[i] = SIG_DFL;
                pg_signal_defaults[i] = SIG_IGN;
        }
        pg_signal_mask = 0;
  
!       /*
!        * Create my signal shared memory area. If any of step failed, 
!        * we will exit the process and rely on the windows system
!        * to do the clean up.
!        */
!       wsprintf(name, "%s.%d", SIGNAL_SHMEM_PREFIX, MyProcPid);
!       if (NULL != (hShmem = OpenFileMapping(FILE_MAP_ALL_ACCESS,
!                                                  FALSE,
!                                                  name)))
!               ereport(FATAL, 
!                       (errmsg_internal("shmem segement \"%s\" already 
exists", name)));
!       
!       if (NULL == (hShmem = CreateFileMapping((HANDLE) 0xFFFFFFFF,            
!                                                        NULL, PAGE_READWRITE,  
                
!                                                        0L, (DWORD) 
sizeof(Win32SignalShmemStruct),
!                                                        name)))
!               ereport_signal(FATAL, 
!                                       "out of shared memory for signaling");
!       
!       if (NULL == (MySignalShmem = MapViewOfFile(hShmem, 
!                                                       FILE_MAP_ALL_ACCESS, 
!                                                       0, 0, 0)))
!               ereport_signal(FATAL, 
!                                       "failed to attach to signal area");
! 
!       /* Create the global event */
!       wsprintf(name, "%s.%d", SIGNAL_EVENT_PREFIX, MyProcPid);
!       if (NULL == (MySignalShmem->event = CreateEvent(&sa, 
!                                                       TRUE, FALSE, name)))
!               ereport_signal(FATAL, 
!                                       "failed to create signal event");
! 
!       /* Create the global mutex */
!       wsprintf(name, "%s.%d", SIGNAL_MUTEX_PREFIX, MyProcPid);
!       if (NULL == (MySignalShmem->mutex = CreateMutex(&sa, 
!                                                       FALSE, name)))
!               ereport_signal(FATAL, 
!                                       "failed to create signal mutex");       
  
        /* Create console control handle to pick up Ctrl-C etc */
        if (!SetConsoleCtrlHandler(pg_console_handler, TRUE))
!               ereport_signal(FATAL, 
!                                       "failed to set console control");       
  }
  
! /* 
!  * pgwin32_dispatch_queued_signals
!  *            Dispatch all signals currently queued and not blocked
!  *            Blocked signals are ignored, and will be fired at the 
!  *      time of the sigsetmask() call. 
!  */
  void
  pgwin32_dispatch_queued_signals(void)
  {
        int                     i;
  
!       lock_signal_shmem();
!       while (MySignalShmem->queue & ~pg_signal_mask)
        {
                /* One or more unblocked signals queued for execution */
!               int                     exec_mask = MySignalShmem->queue & 
~pg_signal_mask;
  
                for (i = 0; i < PG_SIGNAL_COUNT; i++)
                {
***************
*** 106,129 ****
  
                                if (sig == SIG_DFL)
                                        sig = pg_signal_defaults[i];
!                               pg_signal_queue &= ~sigmask(i);
                                if (sig != SIG_ERR && sig != SIG_IGN && sig != 
SIG_DFL)
                                {
!                                       
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 */
                                }
                        }
                }
        }
!       ResetEvent(pgwin32_signal_event);
!       LeaveCriticalSection(&pg_signal_crit_sec);
  }
  
! /* signal masking. Only called on main thread, no sync required */
  int
  pqsigsetmask(int mask)
  {
--- 157,188 ----
  
                                if (sig == SIG_DFL)
                                        sig = pg_signal_defaults[i];
!                               MySignalShmem->queue &= ~sigmask(i);
                                if (sig != SIG_ERR && sig != SIG_IGN && sig != 
SIG_DFL)
                                {
!                                       unlock_signal_shmem();
                                        sig(i);
!                                       lock_signal_shmem();
! 
!                                       /* 
!                                        * Restart outer loop, in case signal 
mask or
!                                        * queue has been modified inside 
signal handler 
!                                        */
!                                       break;          
                                }
                        }
                }
        }
!       unlock_signal_shmem();
!       
!       if (!ResetEvent(MySignalShmem->event))
!               ereport_signal(ERROR, "failed to reset signal waiting event");  
  }
  
! /* 
!  * pqsigsetmask
!  *            Signal masking emulation in win32. 
!  */
  int
  pqsigsetmask(int mask)
  {
***************
*** 141,148 ****
        return prevmask;
  }
  
! 
! /* signal manipulation. Only called on main thread, no sync required */
  pqsigfunc
  pqsignal(int signum, pqsigfunc handler)
  {
--- 200,209 ----
        return prevmask;
  }
  
! /* 
!  * pqsignal
!  *            Function signal() emulation in win32
!  */
  pqsigfunc
  pqsignal(int signum, pqsigfunc handler)
  {
***************
*** 155,286 ****
        return prevfunc;
  }
  
! /* Create the signal listener pipe for specified pid */
! HANDLE
! pgwin32_create_signal_listener(pid_t pid)
! {
!       char            pipename[128];
!       HANDLE          pipe;
! 
!       wsprintf(pipename, "\\\\.\\pipe\\pgsignal_%d", (int) pid);
! 
!       pipe = CreateNamedPipe(pipename, PIPE_ACCESS_DUPLEX,
!                                                  PIPE_TYPE_MESSAGE | 
PIPE_READMODE_MESSAGE | PIPE_WAIT,
!                                                  PIPE_UNLIMITED_INSTANCES, 
16, 16, 1000, NULL);
! 
!       if (pipe == INVALID_HANDLE_VALUE)
!               ereport(ERROR,
!                               (errmsg("could not create signal listener pipe 
for pid %d: error code %d",
!                                               (int) pid, (int) 
GetLastError())));
! 
!       return pipe;
! }
! 
! 
! /*
!  * All functions below execute on the signal handler thread
!  * and must be synchronized as such!
!  * NOTE! The only global variable that can be used is
!  * pg_signal_queue!
   */
- 
- 
  void
  pg_queue_signal(int signum)
  {
        if (signum >= PG_SIGNAL_COUNT || signum <= 0)
                return;
  
!       EnterCriticalSection(&pg_signal_crit_sec);
!       pg_signal_queue |= sigmask(signum);
!       LeaveCriticalSection(&pg_signal_crit_sec);
! 
!       SetEvent(pgwin32_signal_event);
! }
! 
! /* Signal dispatching thread */
! static DWORD WINAPI
! pg_signal_dispatch_thread(LPVOID param)
! {
!       HANDLE          pipe = (HANDLE) param;
!       BYTE            sigNum;
!       DWORD           bytes;
! 
!       if (!ReadFile(pipe, &sigNum, 1, &bytes, NULL))
!       {
!               /* Client died before sending */
!               CloseHandle(pipe);
!               return 0;
!       }
!       if (bytes != 1)
!       {
!               /* Received <bytes> bytes over signal pipe (should be 1) */
!               CloseHandle(pipe);
!               return 0;
!       }
!       WriteFile(pipe, &sigNum, 1, &bytes, NULL);      /* Don't care if it 
works
!                                                                               
                 * or not.. */
!       FlushFileBuffers(pipe);
!       DisconnectNamedPipe(pipe);
!       CloseHandle(pipe);
! 
!       pg_queue_signal(sigNum);
!       return 0;
  }
  
! /* Signal handling thread */
! static DWORD WINAPI
! pg_signal_thread(LPVOID param)
! {
!       char            pipename[128];
!       HANDLE      pipe = pgwin32_initial_signal_pipe;
! 
!       wsprintf(pipename, "\\\\.\\pipe\\pgsignal_%d", GetCurrentProcessId());
! 
!       for (;;)
!       {
!               BOOL            fConnected;
!               HANDLE          hThread;
! 
!               if (pipe == INVALID_HANDLE_VALUE)
!               {
!                       pipe = CreateNamedPipe(pipename, PIPE_ACCESS_DUPLEX,
!                                                                  
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
!                                                                  
PIPE_UNLIMITED_INSTANCES, 16, 16, 1000, NULL);
! 
!                       if (pipe == INVALID_HANDLE_VALUE)
!                       {
!                               write_stderr("could not create signal listener 
pipe: error code %d; retrying\n", (int) GetLastError());
!                               SleepEx(500, FALSE);
!                               continue;
!                       }
!               }
! 
!               fConnected = ConnectNamedPipe(pipe, NULL) ? TRUE : 
(GetLastError() == ERROR_PIPE_CONNECTED);
!               if (fConnected)
!               {
!                       hThread = CreateThread(NULL, 0,
!                                         (LPTHREAD_START_ROUTINE) 
pg_signal_dispatch_thread,
!                                                                  (LPVOID) 
pipe, 0, NULL);
!                       if (hThread == INVALID_HANDLE_VALUE)
!                               write_stderr("could not create signal dispatch 
thread: error code %d\n",
!                                                        (int) GetLastError());
!                       else
!                               CloseHandle(hThread);
!               }
!               else
!                       /* Connection failed. Cleanup and try again */
!                       CloseHandle(pipe);
! 
!               /* Set up so we create a new pipe on next loop */
!               pipe = INVALID_HANDLE_VALUE;
!       }
!       return 0;
! }
! 
! 
! /* Console control handler will execute on a thread created
!    by the OS at the time of invocation */
  static BOOL WINAPI
  pg_console_handler(DWORD dwCtrlType)
  {
--- 216,244 ----
        return prevfunc;
  }
  
! /* 
!  * pg_queue_signal
!  *            Trigger a signal handling of current process
   */
  void
  pg_queue_signal(int signum)
  {
        if (signum >= PG_SIGNAL_COUNT || signum <= 0)
                return;
  
!       lock_signal_shmem();
!       MySignalShmem->queue |= sigmask(signum);
!       unlock_signal_shmem();
! 
!       if (!SetEvent(MySignalShmem->event))
!               ereport_signal(ERROR, "failed to set signal waiting event");    
  }
  
! /* 
!  * pg_console_handler
!  *            Console control handler will execute on a thread created
!  *            by the OS at the time of invocation 
!  */
  static BOOL WINAPI
  pg_console_handler(DWORD dwCtrlType)
  {
Index: backend/postmaster/postmaster.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/postmaster/postmaster.c,v
retrieving revision 1.451
diff -c -r1.451 postmaster.c
*** backend/postmaster/postmaster.c     15 May 2005 00:26:18 -0000      1.451
--- backend/postmaster/postmaster.c     2 Jun 2005 12:28:15 -0000
***************
*** 332,338 ****
        pid_t PostmasterPid;
  #ifdef WIN32
        HANDLE PostmasterHandle;
-       HANDLE initial_signal_pipe;
        HANDLE syslogPipe[2];
  #else
        int syslogPipe[2];
--- 332,337 ----
***************
*** 3606,3614 ****
  
  #ifdef WIN32
        param->PostmasterHandle = PostmasterHandle;
-       write_duplicated_handle(&param->initial_signal_pipe,
-                                                       
pgwin32_create_signal_listener(childPid),
-                                                       childProcess);
  #endif
  
        memcpy(&param->syslogPipe, &syslogPipe, sizeof(syslogPipe));
--- 3605,3610 ----
***************
*** 3626,3654 ****
  
  #ifdef WIN32
  /*
-  * Duplicate a handle for usage in a child process, and write the child
-  * process instance of the handle to the parameter file.
-  */
- static void
- write_duplicated_handle(HANDLE *dest, HANDLE src, HANDLE childProcess)
- {
-       HANDLE hChild = INVALID_HANDLE_VALUE;
- 
-       if (!DuplicateHandle(GetCurrentProcess(),
-                                                src,
-                                                childProcess,
-                                                &hChild,
-                                                0,
-                                                TRUE,
-                                                DUPLICATE_CLOSE_SOURCE | 
DUPLICATE_SAME_ACCESS))
-               ereport(ERROR,
-                               (errmsg_internal("could not duplicate handle to 
be written to backend parameter file: error code %d",
-                                                                (int) 
GetLastError())));
- 
-       *dest = hChild;
- }
- 
- /*
   * Duplicate a socket for usage in a child process, and write the resulting
   * structure to the parameter file.
   * This is required because a number of LSPs (Layered Service Providers) very
--- 3622,3627 ----
***************
*** 3808,3814 ****
  
  #ifdef WIN32
        PostmasterHandle = param->PostmasterHandle;
-       pgwin32_initial_signal_pipe = param->initial_signal_pipe;
  #endif
  
        memcpy(&syslogPipe, &param->syslogPipe, sizeof(syslogPipe));
--- 3781,3786 ----
Index: port/kill.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/port/kill.c,v
retrieving revision 1.6
diff -c -r1.6 kill.c
*** port/kill.c 31 Dec 2004 22:03:53 -0000      1.6
--- port/kill.c 2 Jun 2005 12:30:54 -0000
***************
*** 17,61 ****
  #include "c.h"
  
  #ifdef WIN32
! /* signal sending */
  int
  pgkill(int pid, int sig)
  {
!       char            pipename[128];
!       BYTE            sigData = sig;
!       BYTE            sigRet = 0;
!       DWORD           bytes;
  
!       /* we allow signal 0 here, but it will be ignored in pg_queue_signal */
        if (sig >= PG_SIGNAL_COUNT || sig < 0)
!       {
!               errno = EINVAL;
!               return -1;
!       }
        if (pid <= 0)
!       {
!               /* No support for process groups */
!               errno = EINVAL;
!               return -1;
!       }
!       wsprintf(pipename, "\\\\.\\pipe\\pgsignal_%i", pid);
!       if (!CallNamedPipe(pipename, &sigData, 1, &sigRet, 1, &bytes, 1000))
!       {
!               if (GetLastError() == ERROR_FILE_NOT_FOUND)
!                       errno = ESRCH;
!               else if (GetLastError() == ERROR_ACCESS_DENIED)
!                       errno = EPERM;
!               else
!                       errno = EINVAL;
!               return -1;
!       }
!       if (bytes != 1 || sigRet != sig)
!       {
!               errno = ESRCH;
!               return -1;
!       }
  
!       return 0;
  }
  
  #endif
--- 17,120 ----
  #include "c.h"
  
  #ifdef WIN32
! 
! /* Convenience macro to set errno and return */
! #define set_error_and_return(e)       \
! do{   \
!       if (shmem)      UnmapViewOfFile(shmem); \
!       if (hShmem)     CloseHandle(hShmem);    \
!       if (hEvent)     CloseHandle(hEvent);    \
!       if (hMutex)     CloseHandle(hMutex);    \
!       \
!       errno = (e); \
!       return ((e) == 0)? 0 : -1;      \
! } while (0)
! 
! /* 
!  * pgkill
!  *            kill() win32 emulation. 
!  * 
!  *      pgkill() will fail if: 
!  *            [EINVAL] The value of the sig argument is an invalid 
!  *                             or target process id <= 0.
!  *            [ESRCH]  No process can be found corresponding to that 
!  *                             specified by pid.  
!  *    [EPERM]  Any other win32 system call fails.
!  */
  int
  pgkill(int pid, int sig)
  {
!       char    name[64];
!       HANDLE  hShmem, hMutex, hEvent;
!       Win32SignalShmemStruct *shmem;
! 
!       shmem  = NULL;
!       hShmem = NULL;
!       hMutex = NULL;
!       hEvent = NULL;
  
!       /* we allow signal 0 here, and handle later */
        if (sig >= PG_SIGNAL_COUNT || sig < 0)
!               set_error_and_return(EINVAL);
!       
!       /* No support for process groups */
        if (pid <= 0)
!               set_error_and_return(EINVAL);
!       
!       /* 
!        * Attach to the signaling shared memory. If it is attachable,
!        * we decide that the process is alive. 
!        */
!       wsprintf(name, "%s.%d", SIGNAL_SHMEM_PREFIX, pid);
!       if (NULL == (hShmem = OpenFileMapping(FILE_MAP_ALL_ACCESS, 
!                                                               FALSE, 
!                                                               name)))
!               set_error_and_return(ESRCH);
!       
!       if (sig == 0)
!               set_error_and_return(0);
! 
!       if (NULL == (shmem = MapViewOfFile(hShmem,         
!                                                       FILE_MAP_ALL_ACCESS,   
!                                                       0, 0, 0)))        
!               set_error_and_return(EPERM);
! 
!       /* Grab the mutex */
!       wsprintf(name, "%s.%d", SIGNAL_MUTEX_PREFIX, pid);
!       if (NULL == (hMutex = OpenMutex(MUTEX_ALL_ACCESS, 
!                                                               FALSE, name)))
!               set_error_and_return(EPERM);
! 
!       if (WaitForSingleObject(hMutex, INFINITE) != WAIT_OBJECT_0)     
!               set_error_and_return(EPERM);
! 
!       /* Write down the signal number */
!       shmem->queue |= sigmask(sig);
!       
!       /* 
!        * If we can't release the mutex, we have to exit the
!        * process to make mutex released by the system. If we 
!        * can't set the event, that's really awkward, but the 
!        * target process would find out the signal when next
!        * set event is successfully done. 
!        */
!       if (!ReleaseMutex(hMutex))
!               set_error_and_return(EPERM);
! 
!       if (!UnmapViewOfFile(shmem))
!               set_error_and_return(EPERM);
! 
!       /* Set event */
!       wsprintf(name, "%s.%d", SIGNAL_EVENT_PREFIX, pid);
!       if (NULL == (hEvent = OpenEvent(EVENT_ALL_ACCESS, 
!                                                               FALSE, name)))
!               set_error_and_return(EPERM);
! 
!       if (!SetEvent(hEvent))
!               set_error_and_return(EPERM);
  
!       /* Successfully done */
!       set_error_and_return(0);
  }
  
  #endif
Index: include/port/win32.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/include/port/win32.h,v
retrieving revision 1.45
diff -c -r1.45 win32.h
*** include/port/win32.h        20 May 2005 14:53:26 -0000      1.45
--- include/port/win32.h        2 Jun 2005 12:36:49 -0000
***************
*** 144,149 ****
--- 144,161 ----
  #define SIGUSR1                               30
  #define SIGUSR2                               31
  
+ /* signaling variables name prefix */
+ #define SIGNAL_SHMEM_PREFIX           "Global\\PostgreSQL.SignalShmem"
+ #define SIGNAL_MUTEX_PREFIX           "Global\\PostgreSQL.SignalMutex"
+ #define SIGNAL_EVENT_PREFIX           "Global\\PostgreSQL.SignalEvent"
+ 
+ /* signal shared memory structure */
+ typedef struct Win32SignalShmemStruct{
+       HANDLE  mutex;
+       HANDLE  event;
+       int             queue;
+ }Win32SignalShmemStruct;
+ 
  struct timezone
  {
        int                     tz_minuteswest; /* Minutes west of GMT.  */
***************
*** 212,225 ****
  
  
  /* In backend/port/win32/signal.c */
- extern DLLIMPORT HANDLE pgwin32_signal_event;
- extern HANDLE pgwin32_initial_signal_pipe;
- 
  void          pgwin32_signal_initialize(void);
- HANDLE                pgwin32_create_signal_listener(pid_t pid);
  void          pgwin32_dispatch_queued_signals(void);
  void          pg_queue_signal(int signum);
  
  #ifndef FRONTEND
  #define pg_usleep(t) pgwin32_backend_usleep(t)
  void          pgwin32_backend_usleep(long microsec);
--- 224,237 ----
  
  
  /* In backend/port/win32/signal.c */
  void          pgwin32_signal_initialize(void);
  void          pgwin32_dispatch_queued_signals(void);
  void          pg_queue_signal(int signum);
  
+ extern DLLIMPORT Win32SignalShmemStruct       *MySignalShmem;
+ 
+ #define pgwin32_signal_event  (MySignalShmem->event)
+ 
  #ifndef FRONTEND
  #define pg_usleep(t) pgwin32_backend_usleep(t)
  void          pgwin32_backend_usleep(long microsec);
---------------------------(end of broadcast)---------------------------
TIP 2: you can get off all lists at once with the unregister command
    (send "unregister YourEmailAddressHere" to [EMAIL PROTECTED])

Reply via email to