newlib/winsup/cygwin/shm.cc
Corinna Vinschen 1f34405fea Cygwin: shmat: use mmap allocator strategy on 64 bit
This avoids collisions of shmat maps with Windows own datastructures
when allocating top-down.

This patch moves the mmap_allocator class definition into its
own files and just uses it from mmap and shmat.
2019-08-08 11:27:52 +02:00

400 lines
11 KiB
C++

/* shm.cc: XSI IPC interface for Cygwin.
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/queue.h>
#include <unistd.h>
#include "pinfo.h"
#include "sigproc.h"
#include "cygserver_shm.h"
#include "cygtls.h"
#include "sync.h"
#include "ntdll.h"
#include "mmap_alloc.h"
/* __getpagesize is only available from libcygwin.a */
#undef SHMLBA
#define SHMLBA (wincap.allocation_granularity ())
/*
* client_request_shm Constructors
*/
client_request_shm::client_request_shm (int shmid,
const void *shmaddr,
int shmflg)
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
{
_parameters.in.shmop = SHMOP_shmat;
ipc_set_proc_info (_parameters.in.ipcblk);
_parameters.in.atargs.shmid = shmid;
_parameters.in.atargs.shmaddr = shmaddr;
_parameters.in.atargs.shmflg = shmflg;
msglen (sizeof (_parameters.in));
}
client_request_shm::client_request_shm (int shmid,
int cmd,
struct shmid_ds *buf)
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
{
_parameters.in.shmop = SHMOP_shmctl;
ipc_set_proc_info (_parameters.in.ipcblk);
_parameters.in.ctlargs.shmid = shmid;
_parameters.in.ctlargs.cmd = cmd;
_parameters.in.ctlargs.buf = buf;
msglen (sizeof (_parameters.in));
}
client_request_shm::client_request_shm (const void *shmaddr)
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
{
_parameters.in.shmop = SHMOP_shmdt;
ipc_set_proc_info (_parameters.in.ipcblk);
_parameters.in.dtargs.shmaddr = shmaddr;
msglen (sizeof (_parameters.in));
}
client_request_shm::client_request_shm (key_t key,
size_t size,
int shmflg)
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
{
_parameters.in.shmop = SHMOP_shmget;
ipc_set_proc_info (_parameters.in.ipcblk);
_parameters.in.getargs.key = key;
_parameters.in.getargs.size = size;
_parameters.in.getargs.shmflg = shmflg;
msglen (sizeof (_parameters.in));
}
client_request_shm::client_request_shm (proc *p1)
: client_request (CYGSERVER_REQUEST_SHM, &_parameters, sizeof (_parameters))
{
_parameters.in.shmop = SHMOP_shmfork;
ipc_set_proc_info (_parameters.in.ipcblk, true);
_parameters.in.forkargs = *p1;
}
/* List of shmid's with file mapping HANDLE and size, returned by shmget. */
struct shm_shmid_list {
SLIST_ENTRY (shm_shmid_list) ssh_next;
int shmid;
vm_object_t hdl;
size_t size;
int ref_count;
};
static SLIST_HEAD (, shm_shmid_list) ssh_list;
/* List of attached mappings, as returned by shmat. */
struct shm_attached_list {
SLIST_ENTRY (shm_attached_list) sph_next;
vm_object_t ptr;
shm_shmid_list *parent;
ULONG access;
};
static SLIST_HEAD (, shm_attached_list) sph_list;
static NO_COPY muto shm_guard;
#define SLIST_LOCK() (shm_guard.init ("shm_guard")->acquire ())
#define SLIST_UNLOCK() (shm_guard.release ())
int __stdcall
fixup_shms_after_fork ()
{
if (!SLIST_FIRST (&sph_list))
return 0;
pinfo p (myself->ppid);
proc parent = { myself->ppid, p->dwProcessId, p->uid, p->gid };
client_request_shm request (&parent);
if (request.make_request () == -1 || request.retval () == -1)
{
syscall_printf ("-1 [%d] = fixup_shms_after_fork ()", request.error_code ());
set_errno (request.error_code ());
return 0;
}
shm_attached_list *sph_entry;
/* Reconstruct map from list... */
SLIST_FOREACH (sph_entry, &sph_list, sph_next)
{
NTSTATUS status;
vm_object_t ptr = sph_entry->ptr;
SIZE_T viewsize = sph_entry->parent->size;
status = NtMapViewOfSection (sph_entry->parent->hdl, NtCurrentProcess (),
&ptr, 0, sph_entry->parent->size, NULL,
&viewsize, ViewShare, 0, sph_entry->access);
if (!NT_SUCCESS (status) || ptr != sph_entry->ptr)
api_fatal ("fixup_shms_after_fork: NtMapViewOfSection (%p), status %y. Terminating.",
sph_entry->ptr, status);
}
return 0;
}
/*
* XSI shmaphore API. These are exported by the DLL.
*/
extern "C" void *
shmat (int shmid, const void *shmaddr, int shmflg)
{
syscall_printf ("shmat (shmid = %d, shmaddr = %p, shmflg = %y)",
shmid, shmaddr, shmflg);
SLIST_LOCK ();
shm_shmid_list *ssh_entry;
SLIST_FOREACH (ssh_entry, &ssh_list, ssh_next)
{
if (ssh_entry->shmid == shmid)
break;
}
if (!ssh_entry)
{
/* The shmid is unknown to this process so far. Try to get it from
the server if it exists. Use special internal call to shmget,
which interprets the key as a shmid and only returns a valid
shmid if one exists. Since shmctl inserts a new entry for this
shmid into ssh_list automatically, we just have to go through
that list again. If that still fails, well, bad luck. */
if (shmid && shmget ((key_t) shmid, 0, IPC_KEY_IS_SHMID) != -1)
{
SLIST_FOREACH (ssh_entry, &ssh_list, ssh_next)
{
if (ssh_entry->shmid == shmid)
break;
}
}
if (!ssh_entry)
{
/* Invalid shmid */
set_errno (EINVAL);
SLIST_UNLOCK ();
return (void *) -1;
}
}
/* Early increment ref counter. This allows further actions to run with
unlocked lists, because shmdt or shmctl(IPC_RMID) won't delete this
ssh_entry. */
++ssh_entry->ref_count;
SLIST_UNLOCK ();
vm_object_t attach_va = NULL;
if (shmaddr)
{
if (shmflg & SHM_RND)
attach_va = (vm_object_t)((vm_offset_t)shmaddr & ~(SHMLBA-1));
else
attach_va = (vm_object_t)shmaddr;
/* Don't even bother to call anything if shmaddr is NULL or
not aligned. */
if (!attach_va || (vm_offset_t)attach_va % SHMLBA)
{
set_errno (EINVAL);
--ssh_entry->ref_count;
return (void *) -1;
}
}
/* Try allocating memory before calling cygserver. */
shm_attached_list *sph_entry = new (shm_attached_list);
if (!sph_entry)
{
set_errno (ENOMEM);
--ssh_entry->ref_count;
return (void *) -1;
}
NTSTATUS status;
SIZE_T viewsize = ssh_entry->size;
#ifdef __x86_64__
vm_object_t ptr = mmap_alloc.alloc (NULL, viewsize, false);
#else
vm_object_t ptr = NULL;
#endif
ULONG access = (shmflg & SHM_RDONLY) ? PAGE_READONLY : PAGE_READWRITE;
status = NtMapViewOfSection (ssh_entry->hdl, NtCurrentProcess (), &ptr, 0,
ssh_entry->size, NULL, &viewsize, ViewShare,
MEM_TOP_DOWN, access);
if (!NT_SUCCESS (status))
{
__seterrno_from_nt_status (status);
delete sph_entry;
--ssh_entry->ref_count;
return (void *) -1;
}
/* Use returned ptr address as is, so it's stored using the exact value
in cygserver. */
client_request_shm request (shmid, ptr, shmflg & ~SHM_RND);
if (request.make_request () == -1 || request.ptrval () == NULL)
{
syscall_printf ("-1 [%d] = shmat ()", request.error_code ());
UnmapViewOfFile (ptr);
delete sph_entry;
set_errno (request.error_code ());
--ssh_entry->ref_count;
return (void *) -1;
}
sph_entry->ptr = ptr;
sph_entry->parent = ssh_entry;
sph_entry->access = access;
SLIST_LOCK ();
SLIST_INSERT_HEAD (&sph_list, sph_entry, sph_next);
SLIST_UNLOCK ();
return ptr;
}
extern "C" int
shmctl (int shmid, int cmd, struct shmid_ds *buf)
{
syscall_printf ("shmctl (shmid = %d, cmd = %d, buf = %p)",
shmid, cmd, buf);
__try
{
client_request_shm request (shmid, cmd, buf);
if (request.make_request () == -1 || request.retval () == -1)
{
syscall_printf ("-1 [%d] = shmctl ()", request.error_code ());
set_errno (request.error_code ());
__leave;
}
if (cmd == IPC_RMID)
{
/* Cleanup */
shm_shmid_list *ssh_entry, *ssh_next_entry;
SLIST_LOCK ();
SLIST_FOREACH_SAFE (ssh_entry, &ssh_list, ssh_next, ssh_next_entry)
{
if (ssh_entry->shmid == shmid)
{
/* Remove this entry from the list and close the handle
only if it's not in use anymore. */
if (ssh_entry->ref_count <= 0)
{
SLIST_REMOVE (&ssh_list, ssh_entry, shm_shmid_list,
ssh_next);
CloseHandle (ssh_entry->hdl);
delete ssh_entry;
}
break;
}
}
SLIST_UNLOCK ();
}
return request.retval ();
}
__except (EFAULT) {}
__endtry
return -1;
}
extern "C" int
shmdt (const void *shmaddr)
{
syscall_printf ("shmdt (shmaddr = %p)", shmaddr);
client_request_shm request (shmaddr);
if (request.make_request () == -1 || request.retval () == -1)
{
syscall_printf ("-1 [%d] = shmdt ()", request.error_code ());
set_errno (request.error_code ());
return -1;
}
shm_attached_list *sph_entry, *sph_next_entry;
/* Remove map from list... */
SLIST_LOCK ();
SLIST_FOREACH_SAFE (sph_entry, &sph_list, sph_next, sph_next_entry)
{
if (sph_entry->ptr == shmaddr)
{
SLIST_REMOVE (&sph_list, sph_entry, shm_attached_list, sph_next);
/* ...unmap view... */
UnmapViewOfFile (sph_entry->ptr);
/* ...and, if this was the last reference to this shared section... */
shm_shmid_list *ssh_entry = sph_entry->parent;
if (--ssh_entry->ref_count <= 0)
{
/* ...delete parent entry and close handle. */
SLIST_REMOVE (&ssh_list, ssh_entry, shm_shmid_list, ssh_next);
CloseHandle (ssh_entry->hdl);
delete ssh_entry;
}
delete sph_entry;
break;
}
}
SLIST_UNLOCK ();
return request.retval ();
}
extern "C" int
shmget (key_t key, size_t size, int shmflg)
{
syscall_printf ("shmget (key = %U, size = %d, shmflg = %y)",
key, size, shmflg);
/* Try allocating memory before calling cygserver. */
shm_shmid_list *ssh_new_entry = new (shm_shmid_list);
if (!ssh_new_entry)
{
set_errno (ENOMEM);
return -1;
}
client_request_shm request (key, size, shmflg);
if (request.make_request () == -1 || request.retval () == -1)
{
syscall_printf ("-1 [%d] = shmget ()", request.error_code ());
delete ssh_new_entry;
set_errno (request.error_code ());
return -1;
}
int shmid = request.retval (); /* Shared mem ID */
vm_object_t hdl = request.objval (); /* HANDLE associated with it. */
shm_shmid_list *ssh_entry;
SLIST_LOCK ();
SLIST_FOREACH (ssh_entry, &ssh_list, ssh_next)
{
if (ssh_entry->shmid == shmid)
{
/* We already maintain an entry for this shmid. That means,
the hdl returned by cygserver is a superfluous duplicate
of the original hdl maintained by cygserver. We can safely
delete it. */
CloseHandle (hdl);
delete ssh_new_entry;
SLIST_UNLOCK ();
return shmid;
}
}
/* We arrive here only if shmid is a new one for this process. Add the
shmid and hdl value to the list. */
ssh_new_entry->shmid = shmid;
ssh_new_entry->hdl = hdl;
/* Fetch segment size from server. If this is an already existing segment,
the size value in this shmget call is supposed to be meaningless. */
struct shmid_ds stat;
client_request_shm stat_req (shmid, IPC_STAT, &stat);
if (stat_req.make_request () == -1 || stat_req.retval () == -1)
ssh_new_entry->size = size;
else
ssh_new_entry->size = stat.shm_segsz;
ssh_new_entry->ref_count = 0;
SLIST_INSERT_HEAD (&ssh_list, ssh_new_entry, ssh_next);
SLIST_UNLOCK ();
return shmid;
}