c433f4617f
cygerrno.h. * include/cygwin/config.h (__DYNAMIC_REENT__): Define. * include/cygwin/version.h: Bump API minor version. * cygwin.din: Export __getreent * cygerrno.h: Include errno.h. Fix places where _impure_ptr is used directly to store the errno value. * debug.cc (__set_errno): Ditto. * errno.cc: Remove _RRENT_ONLY define to get errno.cc compiled. * signal.cc: Rename _reent_clib to _REENT throughout. * thread.h (reent_clib): Remove prototype. * thread.cc (reent_clib): Rename reent_clib to __getreent. Return _impure_ptr until MTinterface is initialized. (reent_winsup): Fix a possible SEGV when _r == NULL. Return NULL instead. * MTinterface::fixup_after_fork: Switch reent back to _impure_ptr to keep signal handling running when fork is called from a thread other than the mainthread.
693 lines
19 KiB
C++
693 lines
19 KiB
C++
/* shm.cc: Single unix specification IPC interface for Cygwin.
|
|
|
|
Copyright 2002 Red Hat, Inc.
|
|
|
|
Written by Conrad Scott <conrad.scott@dsl.pipex.com>.
|
|
Based on code by Robert Collins <robert.collins@hotmail.com>.
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
#include "cygerrno.h"
|
|
#include "safe_memory.h"
|
|
#include "sigproc.h"
|
|
|
|
#include "cygserver_ipc.h"
|
|
#include "cygserver_shm.h"
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* class client_shmmgr
|
|
*
|
|
* A singleton class.
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
#define shmmgr (client_shmmgr::instance ())
|
|
|
|
class client_shmmgr
|
|
{
|
|
private:
|
|
class segment_t
|
|
{
|
|
public:
|
|
const int shmid;
|
|
const void *const shmaddr;
|
|
const int shmflg;
|
|
HANDLE hFileMap; // Updated by fixup_shms_after_fork ().
|
|
|
|
segment_t *next;
|
|
|
|
segment_t (const int shmid, const void *const shmaddr, const int shmflg,
|
|
const HANDLE hFileMap)
|
|
: shmid (shmid), shmaddr (shmaddr), shmflg (shmflg), hFileMap (hFileMap),
|
|
next (NULL)
|
|
{}
|
|
};
|
|
|
|
public:
|
|
static client_shmmgr & instance ();
|
|
|
|
void *shmat (int shmid, const void *, int shmflg);
|
|
int shmctl (int shmid, int cmd, struct shmid_ds *);
|
|
int shmdt (const void *);
|
|
int shmget (key_t, size_t, int shmflg);
|
|
|
|
int fixup_shms_after_fork ();
|
|
|
|
private:
|
|
static NO_COPY client_shmmgr *_instance;
|
|
|
|
CRITICAL_SECTION _segments_lock;
|
|
static segment_t *_segments_head; // List of attached segs by shmaddr.
|
|
|
|
static long _shmat_cnt; // No. of attached segs; for info. only.
|
|
|
|
client_shmmgr ();
|
|
~client_shmmgr ();
|
|
|
|
// Undefined (as this class is a singleton):
|
|
client_shmmgr (const client_shmmgr &);
|
|
client_shmmgr & operator= (const client_shmmgr &);
|
|
|
|
segment_t *find (const void *, segment_t **previous = NULL);
|
|
|
|
void *attach (int shmid, const void *, int shmflg, HANDLE & hFileMap);
|
|
|
|
segment_t *new_segment (int shmid, const void *, int shmflg, HANDLE);
|
|
};
|
|
|
|
/* static */ NO_COPY client_shmmgr *client_shmmgr::_instance;
|
|
|
|
/* The following two variables must be inherited by child processes
|
|
* since they are used by fixup_shms_after_fork () to re-attach to the
|
|
* parent's shm segments.
|
|
*/
|
|
/* static */ client_shmmgr::segment_t *client_shmmgr::_segments_head;
|
|
/* static */ long client_shmmgr::_shmat_cnt;
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::instance ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_shmmgr &
|
|
client_shmmgr::instance ()
|
|
{
|
|
if (!_instance)
|
|
_instance = safe_new0 (client_shmmgr);
|
|
|
|
assert (_instance);
|
|
|
|
return *_instance;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::shmat ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
void *
|
|
client_shmmgr::shmat (const int shmid,
|
|
const void *const shmaddr,
|
|
const int shmflg)
|
|
{
|
|
syscall_printf ("shmat (shmid = %d, shmaddr = %p, shmflg = 0%o)",
|
|
shmid, shmaddr, shmflg);
|
|
|
|
EnterCriticalSection (&_segments_lock);
|
|
|
|
HANDLE hFileMap = NULL;
|
|
|
|
void *const ptr = attach (shmid, shmaddr, shmflg, hFileMap);
|
|
|
|
if (ptr)
|
|
new_segment (shmid, ptr, shmflg, hFileMap);
|
|
|
|
LeaveCriticalSection (&_segments_lock);
|
|
|
|
if (ptr)
|
|
syscall_printf ("%p = shmat (shmid = %d, shmaddr = %p, shmflg = 0%o)",
|
|
ptr, shmid, shmaddr, shmflg);
|
|
// else
|
|
// See the syscall_printf in client_shmmgr::attach ().
|
|
|
|
return (ptr ? ptr : (void *) -1);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::shmctl ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
int
|
|
client_shmmgr::shmctl (const int shmid,
|
|
const int cmd,
|
|
struct shmid_ds *const buf)
|
|
{
|
|
syscall_printf ("shmctl (shmid = %d, cmd = 0x%x, buf = %p)",
|
|
shmid, cmd, buf);
|
|
|
|
// Check parameters and set up in parameters as required.
|
|
|
|
const struct shmid_ds *in_buf = NULL;
|
|
|
|
switch (cmd)
|
|
{
|
|
case IPC_SET:
|
|
if (__check_invalid_read_ptr_errno (buf, sizeof (struct shmid_ds)))
|
|
{
|
|
syscall_printf (("-1 [EFAULT] = "
|
|
"shmctl (shmid = %d, cmd = 0x%x, buf = %p)"),
|
|
shmid, cmd, buf);
|
|
set_errno (EFAULT);
|
|
return -1;
|
|
}
|
|
in_buf = buf;
|
|
break;
|
|
|
|
case IPC_STAT:
|
|
case SHM_STAT:
|
|
if (__check_null_invalid_struct_errno (buf, sizeof (struct shmid_ds)))
|
|
{
|
|
syscall_printf (("-1 [EFAULT] = "
|
|
"shmctl (shmid = %d, cmd = 0x%x, buf = %p)"),
|
|
shmid, cmd, buf);
|
|
set_errno (EFAULT);
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case IPC_INFO:
|
|
if (__check_null_invalid_struct_errno (buf, sizeof (struct shminfo)))
|
|
{
|
|
syscall_printf (("-1 [EFAULT] = "
|
|
"shmctl (shmid = %d, cmd = 0x%x, buf = %p)"),
|
|
shmid, cmd, buf);
|
|
set_errno (EFAULT);
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case SHM_INFO:
|
|
if (__check_null_invalid_struct_errno (buf, sizeof (struct shm_info)))
|
|
{
|
|
syscall_printf (("-1 [EFAULT] = "
|
|
"shmctl (shmid = %d, cmd = 0x%x, buf = %p)"),
|
|
shmid, cmd, buf);
|
|
set_errno (EFAULT);
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Create and issue the command.
|
|
|
|
client_request_shm request (shmid, cmd, in_buf);
|
|
|
|
if (request.make_request () == -1 || request.error_code ())
|
|
{
|
|
syscall_printf (("-1 [%d] = "
|
|
"shmctl (shmid = %d, cmd = 0x%x, buf = %p)"),
|
|
request.error_code (), shmid, cmd, buf);
|
|
set_errno (request.error_code ());
|
|
return -1;
|
|
}
|
|
|
|
// Some commands require special processing for their out parameters.
|
|
|
|
int result = 0;
|
|
|
|
switch (cmd)
|
|
{
|
|
case IPC_STAT:
|
|
*buf = request.ds ();
|
|
break;
|
|
|
|
case IPC_INFO:
|
|
*(struct shminfo *) buf = request.shminfo ();
|
|
break;
|
|
|
|
case SHM_STAT: // ipcs(8) i'face.
|
|
result = request.shmid ();
|
|
*buf = request.ds ();
|
|
break;
|
|
|
|
case SHM_INFO: // ipcs(8) i'face.
|
|
result = request.shmid ();
|
|
*(struct shm_info *) buf = request.shm_info ();
|
|
break;
|
|
}
|
|
|
|
syscall_printf ("%d = shmctl (shmid = %d, cmd = 0x%x, buf = %p)",
|
|
result, shmid, cmd, buf);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::shmdt ()
|
|
*
|
|
* According to Posix, the only error condition for this system call
|
|
* is EINVAL if shmaddr is not the address of the start of an attached
|
|
* shared memory segment. Given that, all other errors just generate
|
|
* tracing noise.
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
int
|
|
client_shmmgr::shmdt (const void *const shmaddr)
|
|
{
|
|
syscall_printf ("shmdt (shmaddr = %p)", shmaddr);
|
|
|
|
EnterCriticalSection (&_segments_lock);
|
|
|
|
segment_t *previous = NULL;
|
|
|
|
segment_t *const segptr = find (shmaddr, &previous);
|
|
|
|
if (!segptr)
|
|
{
|
|
LeaveCriticalSection (&_segments_lock);
|
|
syscall_printf ("-1 [EINVAL] = shmdt (shmaddr = %p)", shmaddr);
|
|
set_errno (EINVAL);
|
|
return -1;
|
|
}
|
|
|
|
assert (previous ? previous->next == segptr : _segments_head == segptr);
|
|
|
|
if (previous)
|
|
previous->next = segptr->next;
|
|
else
|
|
_segments_head = segptr->next;
|
|
|
|
LeaveCriticalSection (&_segments_lock);
|
|
|
|
const long cnt = InterlockedDecrement (&_shmat_cnt);
|
|
assert (cnt >= 0);
|
|
|
|
if (!UnmapViewOfFile ((void *) shmaddr))
|
|
syscall_printf (("failed to unmap view "
|
|
"[shmid = %d, handle = %p, shmaddr = %p]:"
|
|
"%E"),
|
|
segptr->shmid, segptr->hFileMap, shmaddr);
|
|
|
|
assert (segptr->hFileMap);
|
|
|
|
if (!CloseHandle (segptr->hFileMap))
|
|
syscall_printf (("failed to close file map handle "
|
|
"[shmid = %d, handle = %p]: %E"),
|
|
segptr->shmid, segptr->hFileMap);
|
|
|
|
client_request_shm request (segptr->shmid);
|
|
|
|
if (request.make_request () == -1 || request.error_code ())
|
|
syscall_printf ("shmdt request failed [shmid = %d, handle = %p]: %s",
|
|
segptr->shmid, segptr->hFileMap,
|
|
strerror (request.error_code ()));
|
|
|
|
safe_delete (segptr);
|
|
|
|
syscall_printf ("0 = shmdt (shmaddr = %p)", shmaddr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::shmget ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
int
|
|
client_shmmgr::shmget (const key_t key, const size_t size, const int shmflg)
|
|
{
|
|
syscall_printf ("shmget (key = 0x%016X, size = %u, shmflg = 0%o)",
|
|
key, size, shmflg);
|
|
|
|
client_request_shm request (key, size, shmflg);
|
|
|
|
if (request.make_request () == -1 || request.error_code ())
|
|
{
|
|
syscall_printf (("-1 [%d] = "
|
|
"shmget (key = 0x%016X, size = %u, shmflg = 0%o)"),
|
|
request.error_code (),
|
|
key, size, shmflg);
|
|
set_errno (request.error_code ());
|
|
return -1;
|
|
}
|
|
|
|
syscall_printf (("%d = shmget (key = 0x%016X, size = %u, shmflg = 0%o)"),
|
|
request.shmid (),
|
|
key, size, shmflg);
|
|
|
|
return request.shmid ();
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::fixup_shms_after_fork ()
|
|
*
|
|
* The hFileMap handles are non-inheritable: so they have to be
|
|
* re-acquired from cygserver.
|
|
*
|
|
* Nb. This routine need not be thread-safe as it is only called at startup.
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
int
|
|
client_shmmgr::fixup_shms_after_fork ()
|
|
{
|
|
debug_printf ("re-attaching to shm segments: %d attached", _shmat_cnt);
|
|
|
|
{
|
|
int length = 0;
|
|
for (segment_t *segptr = _segments_head; segptr; segptr = segptr->next)
|
|
length += 1;
|
|
|
|
if (_shmat_cnt != length)
|
|
{
|
|
system_printf (("state inconsistent: "
|
|
"_shmat_cnt = %d, length of segments list = %d"),
|
|
_shmat_cnt, length);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
for (segment_t *segptr = _segments_head; segptr; segptr = segptr->next)
|
|
if (!attach (segptr->shmid,
|
|
segptr->shmaddr,
|
|
segptr->shmflg & ~SHM_RND,
|
|
segptr->hFileMap))
|
|
{
|
|
system_printf ("fatal error re-attaching to shm segment %d",
|
|
segptr->shmid);
|
|
return 1;
|
|
}
|
|
|
|
if (_shmat_cnt)
|
|
debug_printf ("re-attached all %d shm segments", _shmat_cnt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::client_shmmgr ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_shmmgr::client_shmmgr ()
|
|
{
|
|
InitializeCriticalSection (&_segments_lock);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::~client_shmmgr ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_shmmgr::~client_shmmgr ()
|
|
{
|
|
DeleteCriticalSection (&_segments_lock);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::find ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_shmmgr::segment_t *
|
|
client_shmmgr::find (const void *const shmaddr, segment_t **previous)
|
|
{
|
|
if (previous)
|
|
*previous = NULL;
|
|
|
|
for (segment_t *segptr = _segments_head; segptr; segptr = segptr->next)
|
|
if (segptr->shmaddr == shmaddr)
|
|
return segptr;
|
|
else if (segptr->shmaddr > shmaddr) // The list is sorted by shmaddr.
|
|
return NULL;
|
|
else if (previous)
|
|
*previous = segptr;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::attach ()
|
|
*
|
|
* The body of shmat (), also used by fixup_shms_after_fork ().
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
void *
|
|
client_shmmgr::attach (const int shmid,
|
|
const void *shmaddr,
|
|
const int shmflg,
|
|
HANDLE & hFileMap)
|
|
{
|
|
client_request_shm request (shmid, shmflg);
|
|
|
|
if (request.make_request () == -1 || request.error_code ())
|
|
{
|
|
syscall_printf (("-1 [%d] = "
|
|
"shmat (shmid = %d, shmaddr = %p, shmflg = 0%o)"),
|
|
request.error_code (), shmid, shmaddr, shmflg);
|
|
set_errno (request.error_code ());
|
|
return NULL;
|
|
}
|
|
|
|
int result = 0;
|
|
|
|
const DWORD access = (shmflg & SHM_RDONLY) ? FILE_MAP_READ : FILE_MAP_WRITE;
|
|
|
|
if (shmaddr && (shmflg & SHM_RND))
|
|
shmaddr = (char *) shmaddr - ((ssize_t) shmaddr % SHMLBA);
|
|
|
|
void *const ptr =
|
|
MapViewOfFileEx (request.hFileMap (), access, 0, 0, 0, (void *) shmaddr);
|
|
|
|
if (!ptr)
|
|
{
|
|
syscall_printf (("failed to map view "
|
|
"[shmid = %d, handle = %p, shmaddr = %p]: %E"),
|
|
shmid, request.hFileMap (), shmaddr);
|
|
result = EINVAL; // FIXME
|
|
}
|
|
else if (shmaddr && ptr != shmaddr)
|
|
{
|
|
syscall_printf (("failed to map view at requested address "
|
|
"[shmid = %d, handle = %p]: "
|
|
"requested address = %p, mapped address = %p"),
|
|
shmid, request.hFileMap (),
|
|
shmaddr, ptr);
|
|
result = EINVAL; // FIXME
|
|
}
|
|
|
|
if (result != 0)
|
|
{
|
|
if (!CloseHandle (request.hFileMap ()))
|
|
syscall_printf (("failed to close file map handle "
|
|
"[shmid = %d, handle = %p]: %E"),
|
|
shmid, request.hFileMap ());
|
|
|
|
client_request_shm dt_req (shmid);
|
|
|
|
if (dt_req.make_request () == -1 || dt_req.error_code ())
|
|
syscall_printf ("shmdt request failed [shmid = %d, handle = %p]: %s",
|
|
shmid, request.hFileMap (),
|
|
strerror (dt_req.error_code ()));
|
|
|
|
set_errno (result);
|
|
return NULL;
|
|
}
|
|
|
|
hFileMap = request.hFileMap ();
|
|
return ptr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_shmmgr::new_segment ()
|
|
*
|
|
* Allocate a new segment for the given shmid, file map and address
|
|
* and insert into the segment map.
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_shmmgr::segment_t *
|
|
client_shmmgr::new_segment (const int shmid,
|
|
const void *const shmaddr,
|
|
const int shmflg,
|
|
const HANDLE hFileMap)
|
|
{
|
|
assert (ipc_ext2int_subsys (shmid) == IPC_SHMOP);
|
|
assert (hFileMap);
|
|
assert (shmaddr);
|
|
|
|
segment_t *previous = NULL; // Insert pointer.
|
|
|
|
const segment_t *const tmp = find (shmaddr, &previous);
|
|
|
|
assert (!tmp);
|
|
assert (previous \
|
|
? (!previous->next || previous->next->shmaddr > shmaddr) \
|
|
: (!_segments_head || _segments_head->shmaddr > shmaddr));
|
|
|
|
segment_t *const segptr =
|
|
safe_new (segment_t, shmid, shmaddr, shmflg, hFileMap);
|
|
|
|
assert (segptr);
|
|
|
|
if (previous)
|
|
{
|
|
segptr->next = previous->next;
|
|
previous->next = segptr;
|
|
}
|
|
else
|
|
{
|
|
segptr->next = _segments_head;
|
|
_segments_head = segptr;
|
|
}
|
|
|
|
const long cnt = InterlockedIncrement (&_shmat_cnt);
|
|
assert (cnt > 0);
|
|
|
|
return segptr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* shmat ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
extern "C" void *
|
|
shmat (const int shmid, const void *const shmaddr, const int shmflg)
|
|
{
|
|
sigframe thisframe (mainthread);
|
|
return shmmgr.shmat (shmid, shmaddr, shmflg);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* shmctl ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
extern "C" int
|
|
shmctl (const int shmid, const int cmd, struct shmid_ds *const buf)
|
|
{
|
|
sigframe thisframe (mainthread);
|
|
return shmmgr.shmctl (shmid, cmd, buf);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* shmdt ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
extern "C" int
|
|
shmdt (const void *const shmaddr)
|
|
{
|
|
sigframe thisframe (mainthread);
|
|
return shmmgr.shmdt (shmaddr);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* shmget ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
extern "C" int
|
|
shmget (const key_t key, const size_t size, const int shmflg)
|
|
{
|
|
sigframe thisframe (mainthread);
|
|
return shmmgr.shmget (key, size, shmflg);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* fixup_shms_after_fork ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
int __stdcall
|
|
fixup_shms_after_fork ()
|
|
{
|
|
return shmmgr.fixup_shms_after_fork ();
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_request_shm::client_request_shm ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_request_shm::client_request_shm (const int shmid, const int shmflg)
|
|
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
|
|
{
|
|
_parameters.in.shmop = SHMOP_shmat;
|
|
|
|
_parameters.in.shmid = shmid;
|
|
_parameters.in.shmflg = shmflg;
|
|
|
|
_parameters.in.cygpid = getpid ();
|
|
_parameters.in.winpid = GetCurrentProcessId ();
|
|
_parameters.in.uid = geteuid32 ();
|
|
_parameters.in.gid = getegid32 ();
|
|
|
|
msglen (sizeof (_parameters.in));
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_request_shm::client_request_shm ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_request_shm::client_request_shm (const int shmid,
|
|
const int cmd,
|
|
const struct shmid_ds *const buf)
|
|
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
|
|
{
|
|
_parameters.in.shmop = SHMOP_shmctl;
|
|
|
|
_parameters.in.shmid = shmid;
|
|
_parameters.in.cmd = cmd;
|
|
if (buf)
|
|
_parameters.in.ds = *buf;
|
|
|
|
_parameters.in.cygpid = getpid ();
|
|
_parameters.in.winpid = GetCurrentProcessId ();
|
|
_parameters.in.uid = geteuid32 ();
|
|
_parameters.in.gid = getegid32 ();
|
|
|
|
msglen (sizeof (_parameters.in));
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_request_shm::client_request_shm ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_request_shm::client_request_shm (const int shmid)
|
|
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
|
|
{
|
|
_parameters.in.shmop = SHMOP_shmdt;
|
|
|
|
_parameters.in.shmid = shmid;
|
|
|
|
_parameters.in.cygpid = getpid ();
|
|
_parameters.in.winpid = GetCurrentProcessId ();
|
|
_parameters.in.uid = geteuid32 ();
|
|
_parameters.in.gid = getegid32 ();
|
|
|
|
msglen (sizeof (_parameters.in));
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*
|
|
* client_request_shm::client_request_shm ()
|
|
*---------------------------------------------------------------------------*/
|
|
|
|
client_request_shm::client_request_shm (const key_t key,
|
|
const size_t size,
|
|
const int shmflg)
|
|
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
|
|
{
|
|
_parameters.in.shmop = SHMOP_shmget;
|
|
|
|
_parameters.in.key = key;
|
|
_parameters.in.size = size;
|
|
_parameters.in.shmflg = shmflg;
|
|
|
|
_parameters.in.cygpid = getpid ();
|
|
_parameters.in.winpid = GetCurrentProcessId ();
|
|
_parameters.in.uid = geteuid32 ();
|
|
_parameters.in.gid = getegid32 ();
|
|
|
|
msglen (sizeof (_parameters.in));
|
|
}
|