Skip to content
Snippets Groups Projects
Commit 1a67e486 authored by Bruce Momjian's avatar Bruce Momjian
Browse files

Add shared memory and semaphore routines for Win32.

Also update copyright to be ours, with approval from Jan.
parent d670bf37
Branches
Tags
No related merge requests found
/*-------------------------------------------------------------------------
*
* 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;
}
/*-------------------------------------------------------------------------
*
* 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;
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment