/* posix_ipc.cc: POSIX IPC API for Cygwin.
- Copyright 2007 Red Hat, Inc.
-
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
details. */
#include "winsup.h"
+#include "shared_info.h"
#include "thread.h"
#include "path.h"
-#include "cygerrno.h"
#include "cygtls.h"
#include "fhandler.h"
#include "dtable.h"
#include "cygheap.h"
-#include "security.h"
#include "sigproc.h"
-#include <sys/stat.h>
+#include "ntdll.h"
+#include "tls_pbuf.h"
+#include <io.h>
#include <sys/mman.h>
#include <sys/param.h>
-#include <fcntl.h>
-#include <pwd.h>
#include <stdlib.h>
-#include <limits.h>
#include <unistd.h>
-#include <stdarg.h>
#include <mqueue.h>
#include <semaphore.h>
-struct
+/* The prefix_len is the length of the path prefix including trailing "/"
+ (or "/sem." for semaphores) as well as the trailing NUL. */
+static struct
{
const char *prefix;
- const size_t max_len;
+ const size_t prefix_len;
const char *description;
} ipc_names[] = {
- { "/dev/shm", CYG_MAX_PATH - 10, "POSIX shared memory object" },
- { "/dev/mqueue", CYG_MAX_PATH - 13, "POSIX message queue" },
- { "/dev/shm", CYG_MAX_PATH - 14, "POSIX semaphore" }
+ { "/dev/shm", 10, "POSIX shared memory object" },
+ { "/dev/mqueue", 13, "POSIX message queue" },
+ { "/dev/shm", 14, "POSIX semaphore" }
};
enum ipc_type_t
};
static bool
-check_path (char *res_name, ipc_type_t type, const char *name)
+check_path (char *res_name, ipc_type_t type, const char *name, size_t len)
{
- /* Note that we require the existance of the apprpriate /dev subdirectories
+ /* Note that we require the existance of the appropriate /dev subdirectories
for POSIX IPC object support, similar to Linux (which supports the
directories, but doesn't require to mount them). We don't create
these directory here, that's the task of the installer. But we check
set_errno (EINVAL);
return false;
}
- /* Name must start with a single slash. */
- if (!name || name[0] != '/' || name[1] == '/' || !name[1])
+ /* Apart from handling backslash like slash, the naming rules are identical
+ to Linux, including the names and requirements for subdirectories, if
+ the name contains further slashes. */
+ /* Name must not be empty and has to start with a slash (or backslash) */
+ if (!name || !strchr ("/\\", name[0]))
{
debug_printf ("Invalid %s name '%s'", ipc_names[type].description, name);
set_errno (EINVAL);
return false;
}
- if (strlen (name) > ipc_names[type].max_len)
+ /* Name must not consist of just a single slash (or backslash) */
+ if (!name[1])
+ {
+ debug_printf ("Invalid %s name '%s'", ipc_names[type].description, name);
+ set_errno (ENOENT);
+ return false;
+ }
+ /* Name must not contain slashes after the leading one */
+ if (strpbrk (name + 1, "/\\"))
+ {
+ debug_printf ("Invalid %s name '%s'", ipc_names[type].description, name);
+ set_errno (EACCES);
+ return false;
+ }
+ /* Length must be less than or equal to NAME_MAX, or NAME_MAX - 4 in
+ case of semaphores, due to the leading "sem." prefix */
+ if (len > NAME_MAX - (type == semaphore ? strlen ("sem.") : 0))
{
debug_printf ("%s name '%s' too long", ipc_names[type].description, name);
set_errno (ENAMETOOLONG);
}
static int
-ipc_mutex_init (HANDLE *pmtx, const char *name)
+ipc_mutex_lock (HANDLE mtx, bool eintr)
{
- char buf[CYG_MAX_PATH];
- __small_sprintf (buf, "%scyg_pmtx/%s", cygheap->shared_prefix, name);
- *pmtx = CreateMutex (&sec_all, FALSE, buf);
- if (!*pmtx)
- debug_printf ("failed: %E\n");
- return *pmtx ? 0 : geterrno_from_win_error ();
-}
-
-static int
-ipc_mutex_lock (HANDLE mtx)
-{
- HANDLE h[2] = { mtx, signal_arrived };
-
- switch (WaitForMultipleObjects (2, h, FALSE, INFINITE))
- {
+ switch (cygwait (mtx, cw_infinite, cw_cancel | cw_cancel_self
+ | (eintr ? cw_sig_eintr : cw_sig_restart)))
+ {
case WAIT_OBJECT_0:
case WAIT_ABANDONED_0:
return 0;
- case WAIT_OBJECT_0 + 1:
+ case WAIT_SIGNALED:
set_errno (EINTR);
return 1;
default:
break;
- }
+ }
return geterrno_from_win_error ();
}
return ReleaseMutex (mtx) ? 0 : geterrno_from_win_error ();
}
-static inline int
-ipc_mutex_close (HANDLE mtx)
-{
- return CloseHandle (mtx) ? 0 : geterrno_from_win_error ();
-}
-
-static int
-ipc_cond_init (HANDLE *pevt, const char *name)
-{
- char buf[CYG_MAX_PATH];
- __small_sprintf (buf, "%scyg_pevt/%s", cygheap->shared_prefix, name);
- *pevt = CreateEvent (&sec_all, TRUE, FALSE, buf);
- if (!*pevt)
- debug_printf ("failed: %E\n");
- return *pevt ? 0 : geterrno_from_win_error ();
-}
-
static int
ipc_cond_timedwait (HANDLE evt, HANDLE mtx, const struct timespec *abstime)
{
- struct timeval tv;
- DWORD timeout;
- HANDLE h[2] = { mtx, evt };
-
- if (!abstime)
- timeout = INFINITE;
- else if (abstime->tv_sec < 0
- || abstime->tv_nsec < 0
- || abstime->tv_nsec > 999999999)
- return EINVAL;
- else
- {
- gettimeofday (&tv, NULL);
- /* Check for immediate timeout. */
- if (tv.tv_sec > abstime->tv_sec
- || (tv.tv_sec == abstime->tv_sec
- && tv.tv_usec > abstime->tv_nsec / 1000))
- return ETIMEDOUT;
- timeout = (abstime->tv_sec - tv.tv_sec) * 1000;
- timeout += (abstime->tv_nsec / 1000 - tv.tv_usec) / 1000;
+ HANDLE w4[4] = { evt, };
+ DWORD cnt = 2;
+ DWORD timer_idx = 0;
+ int ret = 0;
+
+ wait_signal_arrived here (w4[1]);
+ if ((w4[cnt] = pthread::get_cancel_event ()) != NULL)
+ ++cnt;
+ if (abstime)
+ {
+ if (!valid_timespec (*abstime))
+ return EINVAL;
+
+ /* If a timeout is set, we create a waitable timer to wait for.
+ This is the easiest way to handle the absolute timeout value, given
+ that NtSetTimer also takes absolute times and given the double
+ dependency on evt *and* mtx, which requires to call WFMO twice. */
+ NTSTATUS status;
+ LARGE_INTEGER duetime;
+
+ timer_idx = cnt++;
+ status = NtCreateTimer (&w4[timer_idx], TIMER_ALL_ACCESS, NULL,
+ NotificationTimer);
+ if (!NT_SUCCESS (status))
+ return geterrno_from_nt_status (status);
+ timespec_to_filetime (abstime, &duetime);
+ status = NtSetTimer (w4[timer_idx], &duetime, NULL, NULL, FALSE, 0, NULL);
+ if (!NT_SUCCESS (status))
+ {
+ NtClose (w4[timer_idx]);
+ return geterrno_from_nt_status (status);
+ }
}
- if (ipc_mutex_unlock (mtx))
- return -1;
- switch (WaitForMultipleObjects (2, h, TRUE, timeout))
- {
+ ResetEvent (evt);
+ if ((ret = ipc_mutex_unlock (mtx)) != 0)
+ return ret;
+ /* Everything's set up, so now wait for the event to be signalled. */
+restart1:
+ switch (WaitForMultipleObjects (cnt, w4, FALSE, INFINITE))
+ {
case WAIT_OBJECT_0:
- case WAIT_ABANDONED_0:
- ResetEvent (evt);
- return 0;
- case WAIT_TIMEOUT:
- ipc_mutex_lock (mtx);
- return ETIMEDOUT;
+ break;
+ case WAIT_OBJECT_0 + 1:
+ if (_my_tls.call_signal_handler ())
+ goto restart1;
+ ret = EINTR;
+ break;
+ case WAIT_OBJECT_0 + 2:
+ if (timer_idx != 2)
+ pthread::static_cancel_self ();
+ fallthrough;
+ case WAIT_OBJECT_0 + 3:
+ ret = ETIMEDOUT;
+ break;
default:
+ ret = geterrno_from_win_error ();
break;
- }
- return geterrno_from_win_error ();
+ }
+ if (ret == 0)
+ {
+ /* At this point we need to lock the mutex. The wait is practically
+ the same as before, just that we now wait on the mutex instead of the
+ event. */
+ restart2:
+ w4[0] = mtx;
+ switch (WaitForMultipleObjects (cnt, w4, FALSE, INFINITE))
+ {
+ case WAIT_OBJECT_0:
+ case WAIT_ABANDONED_0:
+ break;
+ case WAIT_OBJECT_0 + 1:
+ if (_my_tls.call_signal_handler ())
+ goto restart2;
+ ret = EINTR;
+ break;
+ case WAIT_OBJECT_0 + 2:
+ if (timer_idx != 2)
+ pthread_testcancel ();
+ fallthrough;
+ case WAIT_OBJECT_0 + 3:
+ ret = ETIMEDOUT;
+ break;
+ default:
+ ret = geterrno_from_win_error ();
+ break;
+ }
+ }
+ if (timer_idx)
+ {
+ if (ret != ETIMEDOUT)
+ NtCancelTimer (w4[timer_idx], NULL);
+ NtClose (w4[timer_idx]);
+ }
+ return ret;
}
-static inline int
+static inline void
ipc_cond_signal (HANDLE evt)
{
- return SetEvent (evt) ? 0 : geterrno_from_win_error ();
-}
-
-static inline int
-ipc_cond_close (HANDLE evt)
-{
- return CloseHandle (evt) ? 0 : geterrno_from_win_error ();
+ SetEvent (evt);
}
class ipc_flock
{
- struct __flock64 fl;
+ struct flock fl;
public:
ipc_flock () { memset (&fl, 0, sizeof fl); }
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = size;
- return fcntl (fd, F_SETLKW, &fl);
+ return fcntl64 (fd, F_SETLKW, &fl);
}
int unlock (int fd)
{
if (!fl.l_len)
return 0;
fl.l_type = F_UNLCK;
- return fcntl (fd, F_SETLKW, &fl);
+ return fcntl64 (fd, F_SETLKW, &fl);
}
};
extern "C" int
shm_open (const char *name, int oflag, mode_t mode)
{
- char shmname[CYG_MAX_PATH];
+ size_t len = strlen (name);
+ char shmname[ipc_names[shmem].prefix_len + len];
- if (!check_path (shmname, shmem, name))
+ if (!check_path (shmname, shmem, name, len))
return -1;
/* Check for valid flags. */
return -1;
}
- return open (shmname, oflag, mode & 0777);
+ return open (shmname, oflag | O_CLOEXEC, mode & 0777);
}
extern "C" int
shm_unlink (const char *name)
{
- char shmname[CYG_MAX_PATH];
+ size_t len = strlen (name);
+ char shmname[ipc_names[shmem].prefix_len + len];
- if (!check_path (shmname, shmem, name))
+ if (!check_path (shmname, shmem, name, len))
return -1;
return unlink (shmname);
files are created under /dev/mqueue. mq_timedsend and mq_timedreceive
are implemented additionally. */
-struct mq_hdr
-{
- struct mq_attr mqh_attr; /* the queue's attributes */
- long mqh_head; /* index of first message */
- long mqh_free; /* index of first free message */
- long mqh_nwait; /* #threads blocked in mq_receive() */
- pid_t mqh_pid; /* nonzero PID if mqh_event set */
- char mqh_uname[36]; /* unique name used to identify synchronization
- objects connected to this queue */
- struct sigevent mqh_event; /* for mq_notify() */
-};
-
-struct msg_hdr
-{
- long msg_next; /* index of next on linked list */
- ssize_t msg_len; /* actual length */
- unsigned int msg_prio; /* priority */
-};
-
-struct mq_info
-{
- struct mq_hdr *mqi_hdr; /* start of mmap'ed region */
- unsigned long mqi_magic; /* magic number if open */
- int mqi_flags; /* flags for this process */
- HANDLE mqi_lock; /* mutex lock */
- HANDLE mqi_wait; /* and condition variable */
-};
-
-#define MQI_MAGIC 0x98765432UL
-
-#define MSGSIZE(i) roundup((i), sizeof(long))
-
-#define MAX_TRIES 10 /* for waiting for initialization */
-
-struct mq_attr defattr = { 0, 10, 8192, 0 }; /* Linux defaults. */
-
-extern "C" _off64_t lseek64 (int, _off64_t, int);
-extern "C" void *mmap64 (void *, size_t, int, int, int, _off64_t);
-
extern "C" mqd_t
mq_open (const char *name, int oflag, ...)
{
- int i, fd, nonblock, created;
- long msgsize, index;
- _off64_t filesize = 0;
va_list ap;
- mode_t mode;
- int8_t *mptr;
- struct __stat64 statbuff;
- struct mq_hdr *mqhdr;
- struct msg_hdr *msghdr;
- struct mq_attr *attr;
- struct mq_info *mqinfo;
- LUID luid;
- char mqname[CYG_MAX_PATH];
+ mode_t mode = 0;
+ fhandler_mqueue *fh = NULL;
+ struct mq_attr *attr = NULL;
- if (!check_path (mqname, mqueue, name))
- return (mqd_t) -1;
+ size_t len = strlen (name);
+ char mqname[ipc_names[mqueue].prefix_len + len];
- myfault efault;
- if (efault.faulted (EFAULT))
+ if (!check_path (mqname, mqueue, name, len))
return (mqd_t) -1;
- oflag &= (O_CREAT | O_EXCL | O_NONBLOCK);
- created = 0;
- nonblock = oflag & O_NONBLOCK;
- oflag &= ~O_NONBLOCK;
- mptr = (int8_t *) MAP_FAILED;
- mqinfo = NULL;
-
-again:
- if (oflag & O_CREAT)
+ __try
{
- va_start (ap, oflag); /* init ap to final named argument */
- mode = va_arg (ap, mode_t) & ~S_IXUSR;
- attr = va_arg (ap, struct mq_attr *);
- va_end (ap);
-
- /* Open and specify O_EXCL and user-execute */
- fd = open (mqname, oflag | O_EXCL | O_RDWR, mode | S_IXUSR);
- if (fd < 0)
- {
- if (errno == EEXIST && (oflag & O_EXCL) == 0)
- goto exists; /* already exists, OK */
- return (mqd_t) -1;
- }
- created = 1;
- /* First one to create the file initializes it */
- if (attr == NULL)
- attr = &defattr;
- else if (attr->mq_maxmsg <= 0 || attr->mq_msgsize <= 0)
+ if (oflag & O_CREAT)
{
- set_errno (EINVAL);
- goto err;
- }
- /* Calculate and set the file size */
- msgsize = MSGSIZE (attr->mq_msgsize);
- filesize = sizeof (struct mq_hdr)
- + (attr->mq_maxmsg * (sizeof (struct msg_hdr) + msgsize));
- if (lseek64 (fd, filesize - 1, SEEK_SET) == -1)
- goto err;
- if (write (fd, "", 1) == -1)
- goto err;
-
- /* Memory map the file */
- mptr = (int8_t *) mmap64 (NULL, (size_t) filesize, PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, 0);
- if (mptr == (int8_t *) MAP_FAILED)
- goto err;
-
- /* Allocate one mq_info{} for the queue */
- if (!(mqinfo = (struct mq_info *) malloc (sizeof (struct mq_info))))
- goto err;
- mqinfo->mqi_hdr = mqhdr = (struct mq_hdr *) mptr;
- mqinfo->mqi_magic = MQI_MAGIC;
- mqinfo->mqi_flags = nonblock;
-
- /* Initialize header at beginning of file */
- /* Create free list with all messages on it */
- mqhdr->mqh_attr.mq_flags = 0;
- mqhdr->mqh_attr.mq_maxmsg = attr->mq_maxmsg;
- mqhdr->mqh_attr.mq_msgsize = attr->mq_msgsize;
- mqhdr->mqh_attr.mq_curmsgs = 0;
- mqhdr->mqh_nwait = 0;
- mqhdr->mqh_pid = 0;
- if (!AllocateLocallyUniqueId (&luid))
- {
- __seterrno ();
- goto err;
+ va_start (ap, oflag); /* init ap to final named argument */
+ mode = va_arg (ap, mode_t) & ~S_IXUSR;
+ attr = va_arg (ap, struct mq_attr *);
+ va_end (ap);
}
- __small_sprintf (mqhdr->mqh_uname, "cyg%016X%08x%08x",
- hash_path_name (0,mqname),
- luid.HighPart, luid.LowPart);
- mqhdr->mqh_head = 0;
- index = sizeof (struct mq_hdr);
- mqhdr->mqh_free = index;
- for (i = 0; i < attr->mq_maxmsg - 1; i++)
- {
- msghdr = (struct msg_hdr *) &mptr[index];
- index += sizeof (struct msg_hdr) + msgsize;
- msghdr->msg_next = index;
- }
- msghdr = (struct msg_hdr *) &mptr[index];
- msghdr->msg_next = 0; /* end of free list */
-
- /* Initialize mutex & condition variable */
- i = ipc_mutex_init (&mqinfo->mqi_lock, mqhdr->mqh_uname);
- if (i != 0)
- goto pthreaderr;
-
- i = ipc_cond_init (&mqinfo->mqi_wait, mqhdr->mqh_uname);
- if (i != 0)
- goto pthreaderr;
-
- /* Initialization complete, turn off user-execute bit */
- if (fchmod (fd, mode) == -1)
- goto err;
- close (fd);
- return ((mqd_t) mqinfo);
- }
-exists:
- /* Open the file then memory map */
- if ((fd = open (mqname, O_RDWR)) < 0)
- {
- if (errno == ENOENT && (oflag & O_CREAT))
- goto again;
- goto err;
- }
- /* Make certain initialization is complete */
- for (i = 0; i < MAX_TRIES; i++)
- {
- if (stat64 (mqname, &statbuff) == -1)
+ /* Create file descriptor for mqueue */
+ cygheap_fdnew fd;
+
+ if (fd < 0)
+ __leave;
+ fh = (fhandler_mqueue *) build_fh_name (mqname,
+ PC_OPEN | PC_POSIX
+ | PC_SYM_NOFOLLOW | PC_NULLEMPTY,
+ NULL);
+ if (!fh)
+ __leave;
+
+ if (fh->mq_open (oflag, mode, attr))
{
- if (errno == ENOENT && (oflag & O_CREAT))
- {
- close (fd);
- goto again;
- }
- goto err;
+ fd = fh;
+ return (mqd_t) fd;
}
- if ((statbuff.st_mode & S_IXUSR) == 0)
- break;
- sleep (1);
}
- if (i == MAX_TRIES)
+ __except (EFAULT) {}
+ __endtry
+ if (fh)
+ delete fh;
+ return (mqd_t) -1;
+}
+
+static struct mq_info *
+get_mqinfo (cygheap_fdget &fd)
+{
+ if (fd >= 0)
{
- set_errno (ETIMEDOUT);
- goto err;
+ fhandler_mqueue *fh = fd->is_mqueue ();
+ if (fh)
+ return fh->mqinfo ();
+ set_errno (EINVAL);
}
-
- filesize = statbuff.st_size;
- mptr = (int8_t *) mmap64 (NULL, (size_t) filesize, PROT_READ | PROT_WRITE,
- MAP_SHARED, fd, 0);
- if (mptr == (int8_t *) MAP_FAILED)
- goto err;
- close (fd);
-
- /* Allocate one mq_info{} for each open */
- if (!(mqinfo = (struct mq_info *) malloc (sizeof (struct mq_info))))
- goto err;
- mqinfo->mqi_hdr = mqhdr = (struct mq_hdr *) mptr;
- mqinfo->mqi_magic = MQI_MAGIC;
- mqinfo->mqi_flags = nonblock;
-
- /* Initialize mutex & condition variable */
- i = ipc_mutex_init (&mqinfo->mqi_lock, mqhdr->mqh_uname);
- if (i != 0)
- goto pthreaderr;
-
- i = ipc_cond_init (&mqinfo->mqi_wait, mqhdr->mqh_uname);
- if (i != 0)
- goto pthreaderr;
-
- return (mqd_t) mqinfo;
-
-pthreaderr:
- errno = i;
-err:
- /* Don't let following function calls change errno */
- save_errno save;
-
- if (created)
- unlink (mqname);
- if (mptr != (int8_t *) MAP_FAILED)
- munmap((void *) mptr, (size_t) filesize);
- if (mqinfo)
- free (mqinfo);
- close (fd);
- return (mqd_t) -1;
+ return NULL;
}
extern "C" int
{
int n;
struct mq_hdr *mqhdr;
- struct mq_attr *attr;
+ struct mq_fattr *attr;
struct mq_info *mqinfo;
-
- myfault efault;
- if (efault.faulted (EBADF))
- return -1;
- mqinfo = (struct mq_info *) mqd;
- if (mqinfo->mqi_magic != MQI_MAGIC)
+ __try
{
- set_errno (EBADF);
- return -1;
- }
- mqhdr = mqinfo->mqi_hdr;
- attr = &mqhdr->mqh_attr;
- if ((n = ipc_mutex_lock (mqinfo->mqi_lock)) != 0)
- {
- errno = n;
- return -1;
- }
- mqstat->mq_flags = mqinfo->mqi_flags; /* per-open */
- mqstat->mq_maxmsg = attr->mq_maxmsg; /* remaining three per-queue */
- mqstat->mq_msgsize = attr->mq_msgsize;
- mqstat->mq_curmsgs = attr->mq_curmsgs;
+ cygheap_fdget fd ((int) mqd, true);
+ mqinfo = get_mqinfo (fd);
+ if (mqinfo->mqi_magic != MQI_MAGIC)
+ {
+ set_errno (EBADF);
+ __leave;
+ }
+ mqhdr = mqinfo->mqi_hdr;
+ attr = &mqhdr->mqh_attr;
+ if ((n = ipc_mutex_lock (mqinfo->mqi_lock, false)) != 0)
+ {
+ errno = n;
+ __leave;
+ }
+ mqstat->mq_flags = mqinfo->mqi_flags; /* per-open */
+ mqstat->mq_maxmsg = attr->mq_maxmsg; /* remaining three per-queue */
+ mqstat->mq_msgsize = attr->mq_msgsize;
+ mqstat->mq_curmsgs = attr->mq_curmsgs;
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return 0;
-}
+ ipc_mutex_unlock (mqinfo->mqi_lock);
+ return 0;
+ }
+ __except (EBADF) {}
+ __endtry
+ return -1;
+}
extern "C" int
mq_setattr (mqd_t mqd, const struct mq_attr *mqstat, struct mq_attr *omqstat)
{
int n;
- struct mq_hdr *mqhdr;
- struct mq_attr *attr;
+ struct mq_hdr *mqhdr;
+ struct mq_fattr *attr;
struct mq_info *mqinfo;
- myfault efault;
- if (efault.faulted (EBADF))
- return -1;
-
- mqinfo = (struct mq_info *) mqd;
- if (mqinfo->mqi_magic != MQI_MAGIC)
- {
- set_errno (EBADF);
- return -1;
- }
- mqhdr = mqinfo->mqi_hdr;
- attr = &mqhdr->mqh_attr;
- if ((n = ipc_mutex_lock (mqinfo->mqi_lock)) != 0)
+ __try
{
- errno = n;
- return -1;
- }
+ cygheap_fdget fd ((int) mqd, true);
+ mqinfo = get_mqinfo (fd);
+ if (mqinfo->mqi_magic != MQI_MAGIC)
+ {
+ set_errno (EBADF);
+ __leave;
+ }
+ mqhdr = mqinfo->mqi_hdr;
+ attr = &mqhdr->mqh_attr;
+ if ((n = ipc_mutex_lock (mqinfo->mqi_lock, false)) != 0)
+ {
+ errno = n;
+ __leave;
+ }
- if (omqstat != NULL)
- {
- omqstat->mq_flags = mqinfo->mqi_flags; /* previous attributes */
- omqstat->mq_maxmsg = attr->mq_maxmsg;
- omqstat->mq_msgsize = attr->mq_msgsize;
- omqstat->mq_curmsgs = attr->mq_curmsgs; /* and current status */
- }
+ if (omqstat != NULL)
+ {
+ omqstat->mq_flags = mqinfo->mqi_flags; /* previous attributes */
+ omqstat->mq_maxmsg = attr->mq_maxmsg;
+ omqstat->mq_msgsize = attr->mq_msgsize;
+ omqstat->mq_curmsgs = attr->mq_curmsgs; /* and current status */
+ }
- if (mqstat->mq_flags & O_NONBLOCK)
- mqinfo->mqi_flags |= O_NONBLOCK;
- else
- mqinfo->mqi_flags &= ~O_NONBLOCK;
+ if (mqstat->mq_flags & O_NONBLOCK)
+ mqinfo->mqi_flags |= O_NONBLOCK;
+ else
+ mqinfo->mqi_flags &= ~O_NONBLOCK;
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return 0;
+ ipc_mutex_unlock (mqinfo->mqi_lock);
+ return 0;
+ }
+ __except (EBADF) {}
+ __endtry
+ return -1;
}
extern "C" int
pid_t pid;
struct mq_hdr *mqhdr;
struct mq_info *mqinfo;
-
- myfault efault;
- if (efault.faulted (EBADF))
- return -1;
- mqinfo = (struct mq_info *) mqd;
- if (mqinfo->mqi_magic != MQI_MAGIC)
- {
- set_errno (EBADF);
- return -1;
- }
- mqhdr = mqinfo->mqi_hdr;
- if ((n = ipc_mutex_lock (mqinfo->mqi_lock)) != 0)
- {
- errno = n;
- return -1;
- }
-
- pid = getpid ();
- if (!notification)
- {
- if (mqhdr->mqh_pid == pid)
- mqhdr->mqh_pid = 0; /* unregister calling process */
- }
- else
+ __try
{
- if (mqhdr->mqh_pid != 0)
+ cygheap_fdget fd ((int) mqd, true);
+ mqinfo = get_mqinfo (fd);
+ if (mqinfo->mqi_magic != MQI_MAGIC)
{
- if (kill (mqhdr->mqh_pid, 0) != -1 || errno != ESRCH)
+ set_errno (EBADF);
+ __leave;
+ }
+ mqhdr = mqinfo->mqi_hdr;
+ if ((n = ipc_mutex_lock (mqinfo->mqi_lock, false)) != 0)
+ {
+ errno = n;
+ __leave;
+ }
+
+ pid = getpid ();
+ if (!notification)
+ {
+ if (mqhdr->mqh_pid == pid)
+ mqhdr->mqh_pid = 0; /* unregister calling process */
+ }
+ else
+ {
+ if (mqhdr->mqh_pid != 0)
{
- set_errno (EBUSY);
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return -1;
+ if (kill (mqhdr->mqh_pid, 0) != -1 || errno != ESRCH)
+ {
+ set_errno (EBUSY);
+ ipc_mutex_unlock (mqinfo->mqi_lock);
+ __leave;
+ }
}
+ mqhdr->mqh_pid = pid;
+ mqhdr->mqh_event = *notification;
}
- mqhdr->mqh_pid = pid;
- mqhdr->mqh_event = *notification;
- }
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return 0;
-}
+ ipc_mutex_unlock (mqinfo->mqi_lock);
+ return 0;
+ }
+ __except (EBADF) {}
+ __endtry
+ return -1;
+}
static int
_mq_send (mqd_t mqd, const char *ptr, size_t len, unsigned int prio,
int8_t *mptr;
struct sigevent *sigev;
struct mq_hdr *mqhdr;
- struct mq_attr *attr;
+ struct mq_fattr *attr;
struct msg_hdr *msghdr, *nmsghdr, *pmsghdr;
- struct mq_info *mqinfo;
+ struct mq_info *mqinfo = NULL;
+ bool ipc_mutex_locked = false;
+ int ret = -1;
- myfault efault;
- if (efault.faulted (EBADF))
- return -1;
-
- mqinfo = (struct mq_info *) mqd;
- if (mqinfo->mqi_magic != MQI_MAGIC)
- {
- set_errno (EBADF);
- return -1;
- }
- if (prio > MQ_PRIO_MAX)
- {
- set_errno (EINVAL);
- return -1;
- }
+ pthread_testcancel ();
- mqhdr = mqinfo->mqi_hdr; /* struct pointer */
- mptr = (int8_t *) mqhdr; /* byte pointer */
- attr = &mqhdr->mqh_attr;
- if ((n = ipc_mutex_lock (mqinfo->mqi_lock)) != 0)
+ __try
{
- errno = n;
- return -1;
- }
+ cygheap_fdget fd ((int) mqd);
+ mqinfo = get_mqinfo (fd);
+ if (mqinfo->mqi_magic != MQI_MAGIC)
+ {
+ set_errno (EBADF);
+ __leave;
+ }
+ if (prio >= MQ_PRIO_MAX)
+ {
+ set_errno (EINVAL);
+ __leave;
+ }
- if (len > (size_t) attr->mq_msgsize)
- {
- set_errno (EMSGSIZE);
- goto err;
- }
- if (attr->mq_curmsgs == 0)
- {
- if (mqhdr->mqh_pid != 0 && mqhdr->mqh_nwait == 0)
+ mqhdr = mqinfo->mqi_hdr; /* struct pointer */
+ mptr = (int8_t *) mqhdr; /* byte pointer */
+ attr = &mqhdr->mqh_attr;
+ if ((n = ipc_mutex_lock (mqinfo->mqi_lock, true)) != 0)
{
- sigev = &mqhdr->mqh_event;
- if (sigev->sigev_notify == SIGEV_SIGNAL)
- sigqueue (mqhdr->mqh_pid, sigev->sigev_signo, sigev->sigev_value);
- mqhdr->mqh_pid = 0; /* unregister */
+ errno = n;
+ __leave;
}
- }
- else if (attr->mq_curmsgs >= attr->mq_maxmsg)
- {
- /* Queue is full */
- if (mqinfo->mqi_flags & O_NONBLOCK)
+ ipc_mutex_locked = true;
+ if (len > (size_t) attr->mq_msgsize)
{
- set_errno (EAGAIN);
- goto err;
+ set_errno (EMSGSIZE);
+ __leave;
+ }
+ if (attr->mq_curmsgs == 0)
+ {
+ if (mqhdr->mqh_pid != 0 && mqhdr->mqh_nwait == 0)
+ {
+ sigev = &mqhdr->mqh_event;
+ if (sigev->sigev_notify == SIGEV_SIGNAL)
+ sigqueue (mqhdr->mqh_pid, sigev->sigev_signo,
+ sigev->sigev_value);
+ mqhdr->mqh_pid = 0; /* unregister */
+ }
+ }
+ else if (attr->mq_curmsgs >= attr->mq_maxmsg)
+ {
+ /* Queue is full */
+ if (mqinfo->mqi_flags & O_NONBLOCK)
+ {
+ set_errno (EAGAIN);
+ __leave;
+ }
+ /* Wait for room for one message on the queue */
+ while (attr->mq_curmsgs >= attr->mq_maxmsg)
+ {
+ int ret = ipc_cond_timedwait (mqinfo->mqi_waitsend,
+ mqinfo->mqi_lock, abstime);
+ if (ret != 0)
+ {
+ set_errno (ret);
+ __leave;
+ }
+ }
}
- /* Wait for room for one message on the queue */
- while (attr->mq_curmsgs >= attr->mq_maxmsg)
- ipc_cond_timedwait (mqinfo->mqi_wait, mqinfo->mqi_lock, abstime);
- }
- /* nmsghdr will point to new message */
- if ((freeindex = mqhdr->mqh_free) == 0)
- api_fatal ("mq_send: curmsgs = %ld; free = 0", attr->mq_curmsgs);
+ /* nmsghdr will point to new message */
+ if ((freeindex = mqhdr->mqh_free) == 0)
+ api_fatal ("mq_send: curmsgs = %ld; free = 0", attr->mq_curmsgs);
- nmsghdr = (struct msg_hdr *) &mptr[freeindex];
- nmsghdr->msg_prio = prio;
- nmsghdr->msg_len = len;
- memcpy (nmsghdr + 1, ptr, len); /* copy message from caller */
- mqhdr->mqh_free = nmsghdr->msg_next; /* new freelist head */
+ nmsghdr = (struct msg_hdr *) &mptr[freeindex];
+ nmsghdr->msg_prio = prio;
+ nmsghdr->msg_len = len;
+ memcpy (nmsghdr + 1, ptr, len); /* copy message from caller */
+ mqhdr->mqh_free = nmsghdr->msg_next; /* new freelist head */
- /* Find right place for message in linked list */
- index = mqhdr->mqh_head;
- pmsghdr = (struct msg_hdr *) &(mqhdr->mqh_head);
- while (index)
- {
- msghdr = (struct msg_hdr *) &mptr[index];
- if (prio > msghdr->msg_prio)
+ /* Find right place for message in linked list */
+ index = mqhdr->mqh_head;
+ pmsghdr = (struct msg_hdr *) &(mqhdr->mqh_head);
+ while (index)
{
- nmsghdr->msg_next = index;
+ msghdr = (struct msg_hdr *) &mptr[index];
+ if (prio > msghdr->msg_prio)
+ {
+ nmsghdr->msg_next = index;
+ pmsghdr->msg_next = freeindex;
+ break;
+ }
+ index = msghdr->msg_next;
+ pmsghdr = msghdr;
+ }
+ if (index == 0)
+ {
+ /* Queue was empty or new goes at end of list */
pmsghdr->msg_next = freeindex;
- break;
+ nmsghdr->msg_next = 0;
}
- index = msghdr->msg_next;
- pmsghdr = msghdr;
- }
- if (index == 0)
- {
- /* Queue was empty or new goes at end of list */
- pmsghdr->msg_next = freeindex;
- nmsghdr->msg_next = 0;
- }
- /* Wake up anyone blocked in mq_receive waiting for a message */
- if (attr->mq_curmsgs == 0)
- ipc_cond_signal (mqinfo->mqi_wait);
- attr->mq_curmsgs++;
+ /* Wake up anyone blocked in mq_receive waiting for a message */
+ if (attr->mq_curmsgs == 0)
+ ipc_cond_signal (mqinfo->mqi_waitrecv);
+ attr->mq_curmsgs++;
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return 0;
-
-err:
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return -1;
+ ret = 0;
+ }
+ __except (EBADF) {}
+ __endtry
+ if (ipc_mutex_locked)
+ ipc_mutex_unlock (mqinfo->mqi_lock);
+ return ret;
}
extern "C" int
int n;
long index;
int8_t *mptr;
- ssize_t len;
- struct mq_hdr *mqhdr;
- struct mq_attr *attr;
+ ssize_t len = -1;
+ struct mq_hdr *mqhdr;
+ struct mq_fattr *attr;
struct msg_hdr *msghdr;
struct mq_info *mqinfo;
+ bool ipc_mutex_locked = false;
- myfault efault;
- if (efault.faulted (EBADF))
- return -1;
-
- mqinfo = (struct mq_info *) mqd;
- if (mqinfo->mqi_magic != MQI_MAGIC)
- {
- set_errno (EBADF);
- return -1;
- }
- mqhdr = mqinfo->mqi_hdr; /* struct pointer */
- mptr = (int8_t *) mqhdr; /* byte pointer */
- attr = &mqhdr->mqh_attr;
- if ((n = ipc_mutex_lock (mqinfo->mqi_lock)) != 0)
- {
- errno = n;
- return -1;
- }
+ pthread_testcancel ();
- if (maxlen < (size_t) attr->mq_msgsize)
+ __try
{
- set_errno (EMSGSIZE);
- goto err;
- }
- if (attr->mq_curmsgs == 0) /* queue is empty */
- {
- if (mqinfo->mqi_flags & O_NONBLOCK)
+ cygheap_fdget fd ((int) mqd);
+ mqinfo = get_mqinfo (fd);
+ if (mqinfo->mqi_magic != MQI_MAGIC)
{
- set_errno (EAGAIN);
- goto err;
+ set_errno (EBADF);
+ __leave;
+ }
+ mqhdr = mqinfo->mqi_hdr; /* struct pointer */
+ mptr = (int8_t *) mqhdr; /* byte pointer */
+ attr = &mqhdr->mqh_attr;
+ if ((n = ipc_mutex_lock (mqinfo->mqi_lock, true)) != 0)
+ {
+ errno = n;
+ __leave;
+ }
+ ipc_mutex_locked = true;
+ if (maxlen < (size_t) attr->mq_msgsize)
+ {
+ set_errno (EMSGSIZE);
+ __leave;
+ }
+ if (attr->mq_curmsgs == 0) /* queue is empty */
+ {
+ if (mqinfo->mqi_flags & O_NONBLOCK)
+ {
+ set_errno (EAGAIN);
+ __leave;
+ }
+ /* Wait for a message to be placed onto queue */
+ mqhdr->mqh_nwait++;
+ while (attr->mq_curmsgs == 0)
+ {
+ int ret = ipc_cond_timedwait (mqinfo->mqi_waitrecv,
+ mqinfo->mqi_lock, abstime);
+ if (ret != 0)
+ {
+ set_errno (ret);
+ __leave;
+ }
+ }
+ mqhdr->mqh_nwait--;
}
- /* Wait for a message to be placed onto queue */
- mqhdr->mqh_nwait++;
- while (attr->mq_curmsgs == 0)
- ipc_cond_timedwait (mqinfo->mqi_wait, mqinfo->mqi_lock, abstime);
- mqhdr->mqh_nwait--;
- }
-
- if ((index = mqhdr->mqh_head) == 0)
- api_fatal ("mq_receive: curmsgs = %ld; head = 0", attr->mq_curmsgs);
-
- msghdr = (struct msg_hdr *) &mptr[index];
- mqhdr->mqh_head = msghdr->msg_next; /* new head of list */
- len = msghdr->msg_len;
- memcpy(ptr, msghdr + 1, len); /* copy the message itself */
- if (priop != NULL)
- *priop = msghdr->msg_prio;
- /* Just-read message goes to front of free list */
- msghdr->msg_next = mqhdr->mqh_free;
- mqhdr->mqh_free = index;
+ if ((index = mqhdr->mqh_head) == 0)
+ api_fatal ("mq_receive: curmsgs = %ld; head = 0", attr->mq_curmsgs);
- /* Wake up anyone blocked in mq_send waiting for room */
- if (attr->mq_curmsgs == attr->mq_maxmsg)
- ipc_cond_signal (mqinfo->mqi_wait);
- attr->mq_curmsgs--;
+ msghdr = (struct msg_hdr *) &mptr[index];
+ mqhdr->mqh_head = msghdr->msg_next; /* new head of list */
+ len = msghdr->msg_len;
+ memcpy(ptr, msghdr + 1, len); /* copy the message itself */
+ if (priop != NULL)
+ *priop = msghdr->msg_prio;
+
+ /* Just-read message goes to front of free list */
+ msghdr->msg_next = mqhdr->mqh_free;
+ mqhdr->mqh_free = index;
- ipc_mutex_unlock (mqinfo->mqi_lock);
+ /* Wake up anyone blocked in mq_send waiting for room */
+ if (attr->mq_curmsgs == attr->mq_maxmsg)
+ ipc_cond_signal (mqinfo->mqi_waitsend);
+ attr->mq_curmsgs--;
+ }
+ __except (EBADF) {}
+ __endtry
+ if (ipc_mutex_locked)
+ ipc_mutex_unlock (mqinfo->mqi_lock);
return len;
-
-err:
- ipc_mutex_unlock (mqinfo->mqi_lock);
- return -1;
}
extern "C" ssize_t
extern "C" int
mq_close (mqd_t mqd)
{
- long msgsize, filesize;
- struct mq_hdr *mqhdr;
- struct mq_attr *attr;
- struct mq_info *mqinfo;
-
- myfault efault;
- if (efault.faulted (EBADF))
- return -1;
-
- mqinfo = (struct mq_info *) mqd;
- if (mqinfo->mqi_magic != MQI_MAGIC)
+ __try
{
- set_errno (EBADF);
- return -1;
- }
- mqhdr = mqinfo->mqi_hdr;
- attr = &mqhdr->mqh_attr;
-
- if (mq_notify (mqd, NULL)) /* unregister calling process */
- return -1;
+ cygheap_fdget fd ((int) mqd, true);
+ if (!fd->is_mqueue ())
+ {
+ set_errno (EBADF);
+ __leave;
+ }
- msgsize = MSGSIZE (attr->mq_msgsize);
- filesize = sizeof (struct mq_hdr)
- + (attr->mq_maxmsg * (sizeof (struct msg_hdr) + msgsize));
- if (munmap (mqinfo->mqi_hdr, filesize) == -1)
- return -1;
+ if (mq_notify (mqd, NULL)) /* unregister calling process */
+ __leave;
- mqinfo->mqi_magic = 0; /* just in case */
- ipc_cond_close (mqinfo->mqi_wait);
- ipc_mutex_close (mqinfo->mqi_lock);
- free (mqinfo);
- return 0;
+ fd->isclosed (true);
+ fd->close ();
+ fd.release ();
+ return 0;
+ }
+ __except (EBADF) {}
+ __endtry
+ return -1;
}
extern "C" int
mq_unlink (const char *name)
{
- char mqname[CYG_MAX_PATH];
+ size_t len = strlen (name);
+ char mqname[ipc_names[mqueue].prefix_len + len];
- if (!check_path (mqname, mqueue, name))
+ if (!check_path (mqname, mqueue, name, len))
return -1;
if (unlink (mqname) == -1)
return -1;
the already existing semaphore class in thread.cc. Using a file backed
solution allows to implement kernel persistent named semaphores. */
+#define MAX_TRIES 10 /* for waiting for initialization */
+
struct sem_finfo
{
unsigned int value;
extern "C" sem_t *
sem_open (const char *name, int oflag, ...)
{
- int i, fd, created;
+ int i, fd = -1, created = 0;
va_list ap;
mode_t mode = 0;
unsigned int value = 0;
- struct __stat64 statbuff;
+ struct stat statbuff;
sem_t *sem = SEM_FAILED;
sem_finfo sf;
- char semname[CYG_MAX_PATH];
bool wasopen = false;
ipc_flock file;
- if (!check_path (semname, semaphore, name))
- return SEM_FAILED;
+ size_t len = strlen (name);
+ char semname[ipc_names[semaphore].prefix_len + len];
- myfault efault;
- if (efault.faulted (EFAULT))
+ if (!check_path (semname, semaphore, name, len))
return SEM_FAILED;
- created = 0;
- oflag &= (O_CREAT | O_EXCL);
-
-again:
- if (oflag & O_CREAT)
+ __try
{
- va_start (ap, oflag); /* init ap to final named argument */
- mode = va_arg (ap, mode_t) & ~S_IXUSR;
- value = va_arg (ap, unsigned int);
- va_end (ap);
+ oflag &= (O_CREAT | O_EXCL);
- /* Open and specify O_EXCL and user-execute */
- fd = open (semname, oflag | O_EXCL | O_RDWR, mode | S_IXUSR);
- if (fd < 0)
- {
- if (errno == EEXIST && (oflag & O_EXCL) == 0)
- goto exists; /* already exists, OK */
- return SEM_FAILED;
- }
- created = 1;
- /* First one to create the file initializes it. */
- if (!AllocateLocallyUniqueId (&sf.luid))
- {
- __seterrno ();
- goto err;
+ again:
+ if (oflag & O_CREAT)
+ {
+ va_start (ap, oflag); /* init ap to final named argument */
+ mode = va_arg (ap, mode_t) & ~S_IXUSR;
+ value = va_arg (ap, unsigned int);
+ va_end (ap);
+
+ /* Open and specify O_EXCL and user-execute */
+ fd = open (semname, oflag | O_EXCL | O_RDWR | O_CLOEXEC,
+ mode | S_IXUSR);
+ if (fd < 0)
+ {
+ if (errno == EEXIST && (oflag & O_EXCL) == 0)
+ goto exists; /* already exists, OK */
+ return SEM_FAILED;
+ }
+ created = 1;
+ /* First one to create the file initializes it. */
+ NtAllocateLocallyUniqueId (&sf.luid);
+ sf.value = value;
+ sf.hash = hash_path_name (0, semname);
+ if (write (fd, &sf, sizeof sf) != sizeof sf)
+ __leave;
+ sem = semaphore::open (sf.hash, sf.luid, fd, oflag, mode, value,
+ wasopen);
+ if (sem == SEM_FAILED)
+ __leave;
+ /* Initialization complete, turn off user-execute bit */
+ if (fchmod (fd, mode) == -1)
+ __leave;
+ /* Don't close (fd); */
+ return sem;
}
- sf.value = value;
- sf.hash = hash_path_name (0, semname);
- if (write (fd, &sf, sizeof sf) != sizeof sf)
- goto err;
- sem = semaphore::open (sf.hash, sf.luid, fd, oflag, mode, value, wasopen);
- if (sem == SEM_FAILED)
- goto err;
- /* Initialization complete, turn off user-execute bit */
- if (fchmod (fd, mode) == -1)
- goto err;
- /* Don't close (fd); */
- return sem;
- }
-exists:
- /* Open the file and fetch the semaphore name. */
- if ((fd = open (semname, O_RDWR)) < 0)
- {
- if (errno == ENOENT && (oflag & O_CREAT))
- goto again;
- goto err;
- }
- /* Make certain initialization is complete */
- for (i = 0; i < MAX_TRIES; i++)
- {
- if (stat64 (semname, &statbuff) == -1)
+ exists:
+ /* Open the file and fetch the semaphore name. */
+ if ((fd = open (semname, O_RDWR | O_CLOEXEC)) < 0)
{
if (errno == ENOENT && (oflag & O_CREAT))
+ goto again;
+ __leave;
+ }
+ /* Make certain initialization is complete */
+ for (i = 0; i < MAX_TRIES; i++)
+ {
+ if (stat64 (semname, &statbuff) == -1)
{
- close (fd);
- goto again;
+ if (errno == ENOENT && (oflag & O_CREAT))
+ {
+ close (fd);
+ fd = -1;
+ goto again;
+ }
+ __leave;
}
- goto err;
+ if ((statbuff.st_mode & S_IXUSR) == 0)
+ break;
+ sleep (1);
}
- if ((statbuff.st_mode & S_IXUSR) == 0)
- break;
- sleep (1);
- }
- if (i == MAX_TRIES)
- {
- set_errno (ETIMEDOUT);
- goto err;
+ if (i == MAX_TRIES)
+ {
+ set_errno (ETIMEDOUT);
+ __leave;
+ }
+ if (file.lock (fd, sizeof sf))
+ __leave;
+ if (read (fd, &sf, sizeof sf) != sizeof sf)
+ __leave;
+ sem = semaphore::open (sf.hash, sf.luid, fd, oflag, mode, sf.value,
+ wasopen);
+ file.unlock (fd);
+ if (sem == SEM_FAILED)
+ __leave;
+ /* If wasopen is set, the semaphore was already opened and we already have
+ an open file descriptor pointing to the file. This means, we have to
+ close the file descriptor created in this call. It won't be stored
+ anywhere anyway. */
+ if (wasopen)
+ close (fd);
+ return sem;
}
- if (file.lock (fd, sizeof sf))
- goto err;
- if (read (fd, &sf, sizeof sf) != sizeof sf)
- goto err;
- sem = semaphore::open (sf.hash, sf.luid, fd, oflag, mode, sf.value, wasopen);
- file.unlock (fd);
- if (sem == SEM_FAILED)
- goto err;
- /* If wasopen is set, the semaphore was already opened and we already have
- an open file descriptor pointing to the file. This means, we have to
- close the file descriptor created in this call. It won't be stored
- anywhere anyway. */
- if (wasopen)
- close (fd);
- return sem;
-
-err:
+ __except (EFAULT) {}
+ __endtry
/* Don't let following function calls change errno */
save_errno save;
- file.unlock (fd);
+ if (fd >= 0)
+ file.unlock (fd);
if (created)
unlink (semname);
if (sem != SEM_FAILED)
semaphore::close (sem);
- close (fd);
+ if (fd >= 0)
+ close (fd);
return SEM_FAILED;
}
+extern "C" off_t lseek64 (int, off_t, int);
+
int
_sem_close (sem_t *sem, bool do_close)
{
if (semaphore::getinternal (sem, &fd, &sf.hash, &sf.luid, &sf.value) == -1)
return -1;
if (!file.lock (fd, sizeof sf)
- && lseek64 (fd, 0LL, SEEK_SET) != (_off64_t) -1
+ && lseek64 (fd, 0LL, SEEK_SET) != (off_t) -1
&& write (fd, &sf, sizeof sf) == sizeof sf)
ret = do_close ? semaphore::close (sem) : 0;
extern "C" int
sem_unlink (const char *name)
{
- char semname[CYG_MAX_PATH];
+ size_t len = strlen (name);
+ char semname[ipc_names[semaphore].prefix_len + len];
- if (!check_path (semname, semaphore, name))
+ if (!check_path (semname, semaphore, name, len))
return -1;
if (unlink (semname) == -1)
return -1;
git://sourceware.org / newlib-cygwin.git / blobdiff