Add shared memory and semaphore routines for Win32.

Also update copyright to be ours, with approval from Jan.

diff --git a/src/backend/port/win32/sem.c b/src/backend/port/win32/sem.c
new file mode 100644 (file)
index 0000000..33a2965
--- /dev/null
+++ b/src/backend/port/win32/sem.c
@@ -0,0 +1,239 @@
+/*-------------------------------------------------------------------------
+ *
+ * sem.c
+ *       Microsoft Windows Win32 Semaphores Emulation
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+#include "storage/shmem.h"
+
+#include <errno.h>
+
+typedef struct {
+       int                     m_numSems;
+       off_t           m_semaphoreHandles;     // offset from beginning of header
+       off_t           m_semaphoreCounts;      // offset from beginning of header
+} win32_sem_set_hdr;
+
+/* Control of a semaphore pool. The pool is an area in which we stored all
+** the semIds of the pool. The first long is the number of semaphore
+** allocated in the pool followed by semaphore handles
+*/
+
+int
+semctl(int semId, int semNum, int flag, union semun semun)
+{
+       win32_sem_set_hdr* the_set = (win32_sem_set_hdr*)MAKE_PTR(semId);
+
+       /* semNum might be 0 */
+       /* semun.array contains the sem initial values */
+       int* sem_counts = (int*)((off_t)the_set + the_set->m_semaphoreCounts);
+
+       /* Fix the count of all sem of the pool to semun.array */
+       if (flag == SETALL)
+       {
+               int i;
+               struct sembuf sops;
+               sops.sem_flg = IPC_NOWAIT;
+
+               for (i = 0; i < the_set->m_numSems; ++i) {
+                       if (semun.array[i] == sem_counts[i])
+                               continue; /* Nothing to do */
+
+                       if (semun.array[i] < sem_counts[i])
+                               sops.sem_op = -1;
+                       else
+                               sops.sem_op = 1;
+
+                       sops.sem_num = i;
+                               
+                       /* Quickly lock/unlock the semaphore (if we can) */
+                       if (semop(semId, &sops, 1) < 0)
+                               return -1;
+               }
+               return 1;
+       }
+
+       /* Fix the count of one semaphore to semun.val */
+       else if (flag == SETVAL)
+       {
+               if (semun.val != sem_counts[semNum]) {
+                       struct sembuf sops;
+                       sops.sem_flg = IPC_NOWAIT;
+                       sops.sem_num = semNum;
+
+                       if (semun.val < sem_counts[semNum])
+                               sops.sem_op = -1;
+                       else
+                               sops.sem_op = 1;
+                               
+                       /* Quickly lock/unlock the semaphore (if we can) */
+                       if (semop(semId, &sops, 1) < 0)
+                               return -1;
+               }
+
+               return 1;
+       }
+
+       /* Delete the pool */
+       else if (flag == IPC_RMID)
+       {
+               int i;
+               HANDLE* sem_handles = (HANDLE*)((off_t)the_set + the_set->m_semaphoreHandles);
+
+               /* Loop over all semaphore to delete them */
+               for (i = 0; i < the_set->m_numSems; ++i)
+                       CloseHandle(sem_handles[i]);
+
+               return 1;
+       }
+
+       /* Get the current semaphore count */
+       else if (flag == GETNCNT)
+       {
+               return the_set->m_numSems;
+       }
+
+       /* Get the current semaphore count of the first semaphore in the pool */
+       else if (flag == GETVAL)
+       {
+               return sem_counts[semNum];
+       }
+
+       /* Other commands not yet supported */
+       else
+       {
+               errno = EINVAL;
+               return -1;
+       }
+}
+
+/* Find a pool id based on IPC key */
+int
+semget(int semKey, int semNum, int flags)
+{
+       char semname[32];
+       char cur_num[20];
+       DWORD last_error;
+       char* num_part;
+       bool ans = true;
+       SECURITY_ATTRIBUTES sec_attrs;
+       HANDLE cur_handle;
+       bool found = false;
+       Size sem_set_size = sizeof(win32_sem_set_hdr) + semNum * (sizeof(HANDLE) + sizeof(int));
+       HANDLE* sem_handles = NULL;
+       int* sem_counts = NULL;
+
+       sec_attrs.nLength = sizeof(sec_attrs);
+       sec_attrs.lpSecurityDescriptor = NULL;
+       sec_attrs.bInheritHandle = TRUE;
+
+       sprintf(semname, "PG_SEMSET.%d.", semKey);
+       num_part = semname + strlen(semname);
+
+       strcpy(num_part, _itoa(_getpid() * -1, cur_num, 10));   /* For shared memory, include the pid */
+       win32_sem_set_hdr* new_set = (win32_sem_set_hdr*)ShmemInitStruct(semname, sem_set_size, &found);
+
+       if (found) {
+               /* This should *never* happen */
+               errno = EEXIST;
+               return -1;
+       }
+
+       new_set->m_numSems = semNum;
+       new_set->m_semaphoreHandles = sizeof(win32_sem_set_hdr);        // array starts after header
+       new_set->m_semaphoreCounts = new_set->m_semaphoreHandles + (sizeof(HANDLE) * semNum);
+
+       sem_handles = (HANDLE*)((off_t)new_set + new_set->m_semaphoreHandles);
+       sem_counts = (int*)((off_t)new_set + new_set->m_semaphoreCounts);
+
+       for (int i=0; i<semNum && ans; ++i) {
+               strcpy(num_part, _itoa(i, cur_num, 10));
+
+               if (flags & IPC_CREAT)
+                       cur_handle = CreateSemaphore(&sec_attrs, 0, 1, semname);
+               else
+                       cur_handle = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, semname);
+
+               sem_handles[i] = cur_handle;
+
+               last_error = GetLastError();
+               if (!cur_handle)
+               {
+                       errno = EACCES;
+                       ans = false;
+               }
+               else if (last_error == ERROR_ALREADY_EXISTS && (flags & (IPC_CREAT | IPC_EXCL)))
+               {
+                       errno = EEXIST;
+                       ans = false;
+               }
+       }
+
+       if (ans) {
+               return MAKE_OFFSET(new_set);
+       } else {
+               // Blow away what we've got right now...
+               for (int i=0; i<semNum; ++i) {
+                       if (sem_handles[i])
+                               CloseHandle(sem_handles[i]);
+                       else
+                               break;
+               }
+
+               return -1;
+       }
+}
+
+/* Acquire or release in the semaphore pool */
+int
+semop(int semId, struct sembuf * sops, int nsops)
+{
+       win32_sem_set_hdr* the_set = (win32_sem_set_hdr*)MAKE_PTR(semId);
+       HANDLE* sem_handles = (HANDLE*)((off_t)the_set + the_set->m_semaphoreHandles);
+       int* sem_counts = (int*)((off_t)the_set + the_set->m_semaphoreCounts);
+       HANDLE cur_handle;
+
+       if (nsops != 1) {
+               /* Not supported (we return on 1st success, and don't cancel earlier ops) */
+               errno = E2BIG;
+               return -1;
+       }
+
+       cur_handle = sem_handles[sops[0].sem_num];
+
+       if (sops[0].sem_op == -1)
+       {
+               DWORD ret;
+               if (sops[0].sem_flg & IPC_NOWAIT)
+                       ret = WaitForSingleObject(cur_handle, 0);
+               else
+                       ret = WaitForSingleObject(cur_handle, INFINITE);
+
+               if (ret == WAIT_OBJECT_0) {
+                       /* We got it! */
+                       sem_counts[sops[0].sem_num]--;
+                       return 0;
+               } else if (ret == WAIT_TIMEOUT)
+                       /* Couldn't get it */
+                       errno = EAGAIN;
+               else
+                       errno = EIDRM;
+       }
+       else if (sops[0].sem_op > 0) {
+               /* Don't want the lock anymore */
+               sem_counts[sops[0].sem_num]++;
+               ReleaseSemaphore(cur_handle, sops[0].sem_op, NULL);
+               return 0;
+       }
+       else
+               /* Not supported */
+               errno = ERANGE;
+
+       /* If we get down here, then something is wrong */
+       return -1;
+}

diff --git a/src/backend/port/win32/shm.c b/src/backend/port/win32/shm.c
new file mode 100644 (file)
index 0000000..20aaf1f
--- /dev/null
+++ b/src/backend/port/win32/shm.c
@@ -0,0 +1,120 @@
+/*-------------------------------------------------------------------------
+ *
+ * shm.c
+ *       Microsoft Windows Win32 Shared Memory Emulation
+ *
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+#include "windows.h"
+
+#include <stdio.h>
+#include <errno.h>
+
+static DWORD s_segsize = 0;
+
+/* Detach from a shared mem area based on its address */
+int
+shmdt(const void *shmaddr)
+{
+       if (UnmapViewOfFile(shmaddr))
+               return 0;
+       else
+               return -1;
+}
+
+/* Attach to an existing area */
+void *
+shmat(int memId, void* shmaddr, int flag)
+{
+       /* KEW_TODO -- shmat needs to count # attached to shared mem */
+       void *lpmem = MapViewOfFileEx((HANDLE)memId,
+                         FILE_MAP_WRITE | FILE_MAP_READ,
+                         0, 0, /* (DWORD)pshmdsc->segsize */ s_segsize, shmaddr);
+
+       if (lpmem == NULL) {
+               lpmem = (void *)-1;
+               errno = GetLastError();
+       }
+
+    return lpmem;
+}
+
+/* Control a shared mem area */
+int
+shmctl(int shmid, int flag, struct shmid_ds * dummy)
+{
+       if (flag == IPC_RMID)
+       {
+               /* Delete the area */
+               CloseHandle((HANDLE)shmid);
+               return 0;
+       }
+       if (flag == IPC_STAT)
+       {
+               /* Can only test for if exists */
+               int hmap = shmget(shmid, 0, 0);
+               if (hmap < 0) {
+                       /* Shared memory does not exist */
+                       errno = EINVAL;
+                       return -1;
+               }
+               else {
+                       /* Shared memory does exist and must be in use */
+                       shmctl(hmap, IPC_RMID, NULL);   /* Release our hold on it */
+                       errno = 0;
+                       return 0;
+               }
+       }
+
+       errno = EINVAL;
+       return -1;
+}
+
+/* Get an area based on the IPC key */
+int
+shmget(int memKey, int size, int flag)
+{
+    HANDLE  hmap;
+       char szShareMem[32];
+       DWORD dwRet;
+
+    s_segsize = size;
+    sprintf(szShareMem, "sharemem.%d", memKey);
+
+       if (flag & IPC_CREAT) {
+               hmap = CreateFileMapping((HANDLE)0xFFFFFFFF,  /* Use the swap file    */
+                                        NULL,
+                                        PAGE_READWRITE,      /* Memory is Read/Write */
+                                        0L,                  /* Size Upper 32 Bits   */
+                                        (DWORD)s_segsize,      /* Size Lower 32 bits*/
+                                        szShareMem);
+       }
+       else {
+               hmap = OpenFileMapping(FILE_MAP_ALL_ACCESS,
+                                                               FALSE,
+                                                               szShareMem);
+               if (!hmap) {
+                       errno = ENOENT;
+                       return -1;
+               }
+       }
+
+       dwRet = GetLastError();
+       if (dwRet == ERROR_ALREADY_EXISTS && hmap && (flag & (IPC_CREAT | IPC_EXCL))) {
+               /* Caller wanted to create the segment -- error if already exists */
+               CloseHandle(hmap);
+               errno = EEXIST;
+               return -1;
+       }
+       else if (!hmap)
+       {
+               /* Unable to get shared memory */
+               return -1;
+       }
+
+    return (int)hmap;
+}