Projet_SETI_RISC-V/riscv-gnu-toolchain/newlib/winsup/cygwin/shm.cc

/* 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;
}