diff options
| -rw-r--r-- | winsup/cygwin/ChangeLog | 29 | ||||
| -rw-r--r-- | winsup/cygwin/cygwin.din | 4 | ||||
| -rw-r--r-- | winsup/cygwin/include/cygwin/version.h | 3 | ||||
| -rw-r--r-- | winsup/cygwin/include/semaphore.h | 4 | ||||
| -rw-r--r-- | winsup/cygwin/pthread.cc | 65 | ||||
| -rw-r--r-- | winsup/cygwin/thread.cc | 201 | ||||
| -rw-r--r-- | winsup/cygwin/thread.h | 10 |
7 files changed, 297 insertions, 19 deletions
diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog index 6223194bb..7b5704167 100644 --- a/winsup/cygwin/ChangeLog +++ b/winsup/cygwin/ChangeLog @@ -1,5 +1,34 @@ 2003-10-27 Corinna Vinschen <corinna@vinschen.de> + * cygwin.din: Add sem_close, sem_getvalue, sem_open and sem_timedwait. + * pthread.cc (+mangle_sem_name): New function. + (sem_open): Ditto. + (sem_close: Ditto. + (sem_timedwait): Ditto. + (sem_getvalue): Ditto. + * thread.cc (semaphore::semaphore): Rearrange member initialization. + Use appropriate security attribute for process shared semaphores. + (semaphore::semaphore): New constructor for named semaphores. + (semaphore::~semaphore): Care for semaphore name. + (semaphore::_post): Accomodate failing ReleaseSemaphore. Use value + returned by ReleaseSemaphore vor currentvalue. + (semaphore::_getvalue): New method. + (semaphore::_timedwait): Ditto. + (semaphore::_fixup_after_fork): Rearrange. Don't fail for process + shared semaphores. + (semaphore::open): New method. + (semaphore::timedwait): Ditto. + (semaphore::post): Fix return value. Set errno appropriately. + (semaphore::getvalue): New method. + * thread.h (class semaphore): Add prototypes for open, getvalue, + timedwait, _getvalue, _timedwait. Add prototypes for new constructor. + Add name member. + * include/semaphore.h: Add prototypes for sem_open, sem_close, + sem_timedwait and sem_getvalue. + include/cygwin/version.h: Bump API minor number. + +2003-10-27 Corinna Vinschen <corinna@vinschen.de> + * miscfunc.cc (__check_invalid_read_ptr): New function. * winsup.h: Declare. diff --git a/winsup/cygwin/cygwin.din b/winsup/cygwin/cygwin.din index a65ccb21d..8f3cdf3c8 100644 --- a/winsup/cygwin/cygwin.din +++ b/winsup/cygwin/cygwin.din @@ -1122,9 +1122,13 @@ _seed48 = seed48 seekdir _seekdir = seekdir _seekdir64 = seekdir64 +sem_close sem_destroy +sem_getvalue sem_init +sem_open sem_post +sem_timedwait sem_trywait sem_wait setbuf diff --git a/winsup/cygwin/include/cygwin/version.h b/winsup/cygwin/include/cygwin/version.h index 0e26b0840..a3214e445 100644 --- a/winsup/cygwin/include/cygwin/version.h +++ b/winsup/cygwin/include/cygwin/version.h @@ -221,13 +221,14 @@ details. */ optreset, __check_rhosts_file, __rcmd_errstr. 95: Export shmat, shmctl, shmdt, shmget. 96: CW_GET_ERRNO_FROM_WINERROR addition to external.cc + 97: Export sem_open, sem_close, sem_timedwait, sem_getvalue. */ /* Note that we forgot to bump the api for ualarm, strtoll, strtoull */ #define CYGWIN_VERSION_API_MAJOR 0 -#define CYGWIN_VERSION_API_MINOR 96 +#define CYGWIN_VERSION_API_MINOR 97 /* There is also a compatibity version number associated with the shared memory regions. It is incremented when incompatible diff --git a/winsup/cygwin/include/semaphore.h b/winsup/cygwin/include/semaphore.h index 860c2bfca..96f7c6f88 100644 --- a/winsup/cygwin/include/semaphore.h +++ b/winsup/cygwin/include/semaphore.h @@ -30,9 +30,13 @@ extern "C" /* Semaphores */ int sem_init (sem_t * sem, int pshared, unsigned int value); int sem_destroy (sem_t * sem); + sem_t *sem_open (const char *name, int oflag, ...); + int sem_close (sem_t *sem); int sem_wait (sem_t * sem); int sem_trywait (sem_t * sem); + int sem_timedwait (sem_t * sem, const struct timespec *abstime); int sem_post (sem_t * sem); + int sem_getvalue (sem_t * sem, int *sval); #ifdef __cplusplus } diff --git a/winsup/cygwin/pthread.cc b/winsup/cygwin/pthread.cc index 57b746ba5..275e566ab 100644 --- a/winsup/cygwin/pthread.cc +++ b/winsup/cygwin/pthread.cc @@ -12,7 +12,9 @@ #include "winsup.h" #include "thread.h" -#include "errno.h" +#include "cygerrno.h" +#include <stdarg.h> +#include <sys/fcntl.h> extern "C" { @@ -157,6 +159,55 @@ sem_destroy (sem_t * sem) return semaphore::destroy (sem); } +/* Mangle semaphore name to follow windows naming rules. Prepend "Global\" + if running on terminal service aware machine. Substitute invalid backslash + by forward slash characters, hoping not to collide. */ +static bool +mangle_sem_name (char *mangled, const char *name) +{ + if (check_null_empty_str_errno (name)) + return false; + int len = strlen (name); + if (len > MAX_PATH + || (wincap.has_terminal_services () && len > MAX_PATH - 7)) + { + set_errno (EINVAL); + return false; + } + strcpy (mangled, wincap.has_terminal_services () ? "Global\\" : ""); + char *d = mangled + strlen (mangled); + const char *s = name; + while (*s) + *d++ = (*s == '\\') ? '/' : *s++; + *d = '\0'; + return true; +} + +sem_t * +sem_open (const char *name, int oflag, ...) +{ + mode_t mode = 0; + unsigned int value = 0; + if (oflag & O_CREAT) + { + va_list ap; + va_start (ap, oflag); + mode = va_arg (ap, mode_t); + value = va_arg (ap, unsigned int); + va_end (ap); + } + char mangled_name[MAX_PATH + 1]; + if (!mangle_sem_name (mangled_name, name)) + return NULL; + return semaphore::open (mangled_name, oflag, mode, value); +} + +int +sem_close (sem_t * sem) +{ + return semaphore::destroy (sem); +} + int sem_wait (sem_t * sem) { @@ -170,9 +221,21 @@ sem_trywait (sem_t * sem) } int +sem_timedwait (sem_t * sem, const struct timespec *abstime) +{ + return semaphore::timedwait (sem, abstime); +} + +int sem_post (sem_t * sem) { return semaphore::post (sem); } +int +sem_getvalue (sem_t * sem, int *sval) +{ + return semaphore::getvalue (sem, sval); +} + } diff --git a/winsup/cygwin/thread.cc b/winsup/cygwin/thread.cc index bf5f0da24..679cde71c 100644 --- a/winsup/cygwin/thread.cc +++ b/winsup/cygwin/thread.cc @@ -41,6 +41,7 @@ details. */ #include <semaphore.h> #include <stdio.h> #include <sys/timeb.h> +#include <sys/fcntl.h> extern int threadsafe; @@ -1631,14 +1632,65 @@ pthread_mutexattr::~pthread_mutexattr () List<semaphore> semaphore::semaphores; -semaphore::semaphore (int pshared, unsigned int value):verifyable_object (SEM_MAGIC) +semaphore::semaphore (int pshared, unsigned int value) +: verifyable_object (SEM_MAGIC), + shared (pshared), + currentvalue (value), + name (NULL) { - this->win32_obj_id = ::CreateSemaphore (&sec_none_nih, value, LONG_MAX, - NULL); + SECURITY_ATTRIBUTES sa = (pshared != PTHREAD_PROCESS_PRIVATE) + ? sec_all : sec_none_nih; + this->win32_obj_id = ::CreateSemaphore (&sa, value, LONG_MAX, NULL); if (!this->win32_obj_id) magic = 0; - this->shared = pshared; - currentvalue = value; + + semaphores.insert (this); +} + +semaphore::semaphore (const char *sem_name, int oflag, mode_t mode, + unsigned int value) +: verifyable_object (SEM_MAGIC), + shared (PTHREAD_PROCESS_SHARED), + currentvalue (value), /* Unused for named semaphores. */ + name (NULL) +{ + if (oflag & O_CREAT) + { + SECURITY_ATTRIBUTES sa = sec_all; + if (allow_ntsec) + set_security_attribute (mode, &sa, alloca (4096), 4096); + this->win32_obj_id = ::CreateSemaphore (&sa, value, LONG_MAX, sem_name); + if (!this->win32_obj_id) + magic = 0; + if (GetLastError () == ERROR_ALREADY_EXISTS && (oflag & O_EXCL)) + { + __seterrno (); + CloseHandle (this->win32_obj_id); + magic = 0; + } + } + else + { + this->win32_obj_id = ::OpenSemaphore (SEMAPHORE_ALL_ACCESS, FALSE, + sem_name); + if (!this->win32_obj_id) + { + __seterrno (); + magic = 0; + } + } + if (magic) + { + name = new char [strlen (sem_name + 1)]; + if (!name) + { + set_errno (ENOSPC); + CloseHandle (this->win32_obj_id); + magic = 0; + } + else + strcpy (name, sem_name); + } semaphores.insert (this); } @@ -1648,15 +1700,37 @@ semaphore::~semaphore () if (win32_obj_id) CloseHandle (win32_obj_id); + delete [] name; + semaphores.remove (this); } void semaphore::_post () { - /* we can't use the currentvalue, because the wait functions don't let us access it */ - ReleaseSemaphore (win32_obj_id, 1, NULL); - currentvalue++; + if (ReleaseSemaphore (win32_obj_id, 1, ¤tvalue)) + currentvalue++; +} + +int +semaphore::_getvalue (int *sval) +{ + long val; + + switch (WaitForSingleObject (win32_obj_id, 0)) + { + case WAIT_OBJECT_0: + ReleaseSemaphore (win32_obj_id, 1, &val); + *sval = val + 1; + break; + case WAIT_TIMEOUT: + *sval = 0; + break; + default: + set_errno (EAGAIN); + return -1; + } + return 0; } int @@ -1674,6 +1748,43 @@ semaphore::_trywait () return 0; } +int +semaphore::_timedwait (const struct timespec *abstime) +{ + struct timeval tv; + long waitlength; + + if (__check_invalid_read_ptr (abstime, sizeof *abstime)) + { + /* According to SUSv3, abstime need not be checked for validity, + if the semaphore can be locked immediately. */ + if (!_trywait ()) + return 0; + set_errno (EINVAL); + return -1; + } + + gettimeofday (&tv, NULL); + waitlength = abstime->tv_sec * 1000 + abstime->tv_nsec / (1000 * 1000); + waitlength -= tv.tv_sec * 1000 + tv.tv_usec / 1000; + if (waitlength < 0) + waitlength = 0; + switch (pthread::cancelable_wait (win32_obj_id, waitlength)) + { + case WAIT_OBJECT_0: + currentvalue--; + break; + case WAIT_TIMEOUT: + set_errno (ETIMEDOUT); + return -1; + default: + debug_printf ("cancelable_wait failed. %E"); + __seterrno (); + return -1; + } + return 0; +} + void semaphore::_wait () { @@ -1691,13 +1802,15 @@ semaphore::_wait () void semaphore::_fixup_after_fork () { - debug_printf ("sem %x in _fixup_after_fork", this); - if (shared != PTHREAD_PROCESS_PRIVATE) - api_fatal ("doesn't understand PROCESS_SHARED semaphores variables"); - /* FIXME: duplicate code here and in the constructor. */ - this->win32_obj_id = ::CreateSemaphore (&sec_none_nih, currentvalue, LONG_MAX, NULL); - if (!win32_obj_id) - api_fatal ("failed to create new win32 semaphore"); + if (shared == PTHREAD_PROCESS_PRIVATE) + { + debug_printf ("sem %x in _fixup_after_fork", this); + /* FIXME: duplicate code here and in the constructor. */ + this->win32_obj_id = ::CreateSemaphore (&sec_none_nih, currentvalue, + LONG_MAX, NULL); + if (!win32_obj_id) + api_fatal ("failed to create new win32 semaphore, error %d"); + } } verifyable_object::verifyable_object (long verifyer): @@ -3102,6 +3215,33 @@ semaphore::destroy (sem_t *sem) return 0; } +sem_t * +semaphore::open (const char *name, int oflag, mode_t mode, unsigned int value) +{ + if (value > SEM_VALUE_MAX) + { + set_errno (EINVAL); + return NULL; + } + + sem_t *sem = new sem_t; + if (!sem) + { + set_errno (ENOMEM); + return NULL; + } + + *sem = new semaphore (name, oflag, mode, value); + + if (!is_good_object (sem)) + { + delete *sem; + delete sem; + return NULL; + } + return sem; +} + int semaphore::wait (sem_t *sem) { @@ -3130,15 +3270,44 @@ semaphore::trywait (sem_t *sem) } int +semaphore::timedwait (sem_t *sem, const struct timespec *abstime) +{ + if (!is_good_object (sem)) + { + set_errno (EINVAL); + return -1; + } + + return (*sem)->_timedwait (abstime); +} + +int semaphore::post (sem_t *sem) { if (!is_good_object (sem)) - return EINVAL; + { + set_errno (EINVAL); + return -1; + } (*sem)->_post (); return 0; } +int +semaphore::getvalue (sem_t *sem, int *sval) +{ + + if (!is_good_object (sem) + || __check_null_invalid_struct (sval, sizeof (int))) + { + set_errno (EINVAL); + return -1; + } + + return (*sem)->_getvalue (sval); +} + /* pthread_null */ pthread * pthread_null::get_null_pthread () diff --git a/winsup/cygwin/thread.h b/winsup/cygwin/thread.h index 575310958..d6fffedb8 100644 --- a/winsup/cygwin/thread.h +++ b/winsup/cygwin/thread.h @@ -710,15 +710,21 @@ public: /* API calls */ static int init (sem_t * sem, int pshared, unsigned int value); static int destroy (sem_t * sem); + static sem_t *open (const char *name, int oflag, mode_t mode, + unsigned int value); static int wait (sem_t * sem); - static int trywait (sem_t * sem); static int post (sem_t * sem); + static int getvalue (sem_t * sem, int *sval); + static int trywait (sem_t * sem); + static int timedwait (sem_t * sem, const struct timespec *abstime); HANDLE win32_obj_id; int shared; long currentvalue; + char *name; semaphore (int, unsigned int); + semaphore (const char *name, int oflag, mode_t mode, unsigned int value); ~semaphore (); class semaphore * next; @@ -731,7 +737,9 @@ public: private: void _wait (); void _post (); + int _getvalue (int *sval); int _trywait (); + int _timedwait (const struct timespec *abstime); void _fixup_after_fork (); |