Flush (work in progress)
[mono.git] / mono / io-layer / handles-private.h
index 413db936e9a33a74d7f6e8f811ed3262a577d0a6..b74d5bedf82f743a33566272c91762ddb1916d15 100644 (file)
@@ -4,7 +4,7 @@
  * Author:
  *     Dick Porter (dick@ximian.com)
  *
- * (C) 2002 Ximian, Inc.
+ * (C) 2002-2006 Novell, Inc.
  */
 
 #ifndef _WAPI_HANDLES_PRIVATE_H_
 #include <errno.h>
 #include <signal.h>
 #include <string.h>
+#include <sys/types.h>
 
 #include <mono/io-layer/wapi-private.h>
 #include <mono/io-layer/misc-private.h>
 #include <mono/io-layer/collection.h>
+#include <mono/io-layer/shared.h>
+
+#define _WAPI_PRIVATE_MAX_SLOTS                (1024 * 16)
+#define _WAPI_PRIVATE_HANDLES(x) (_wapi_private_handles [x / _WAPI_HANDLE_INITIAL_COUNT][x % _WAPI_HANDLE_INITIAL_COUNT])
+#define _WAPI_PRIVATE_HAVE_SLOT(x) ((GPOINTER_TO_UINT (x) / _WAPI_PRIVATE_MAX_SLOTS) < _WAPI_PRIVATE_MAX_SLOTS && \
+                                       _wapi_private_handles [GPOINTER_TO_UINT (x) / _WAPI_HANDLE_INITIAL_COUNT] != NULL)
+#define _WAPI_PRIVATE_VALID_SLOT(x) (((x) / _WAPI_HANDLE_INITIAL_COUNT) < _WAPI_PRIVATE_MAX_SLOTS)
 
 #undef DEBUG
 
-extern struct _WapiHandleUnshared *_wapi_private_handles;
+extern struct _WapiHandleUnshared *_wapi_private_handles [];
 extern struct _WapiHandleSharedLayout *_wapi_shared_layout;
 extern struct _WapiFileShareLayout *_wapi_fileshare_layout;
 
 extern guint32 _wapi_fd_reserve;
-extern mono_mutex_t _wapi_global_signal_mutex;
-extern pthread_cond_t _wapi_global_signal_cond;
+extern mono_mutex_t *_wapi_global_signal_mutex;
+extern pthread_cond_t *_wapi_global_signal_cond;
+extern int _wapi_sem_id;
+extern gboolean _wapi_has_shut_down;
 
+extern pid_t _wapi_getpid (void);
 extern gpointer _wapi_handle_new (WapiHandleType type,
                                  gpointer handle_specific);
-extern gpointer _wapi_handle_new_for_existing_ns (WapiHandleType type,
-                                                 gpointer handle_specific,
-                                                 guint32 offset);
 extern gpointer _wapi_handle_new_fd (WapiHandleType type, int fd,
                                     gpointer handle_specific);
+extern gpointer _wapi_handle_new_from_offset (WapiHandleType type,
+                                             guint32 offset,
+                                             gboolean timestamp);
 extern gboolean _wapi_lookup_handle (gpointer handle, WapiHandleType type,
                                     gpointer *handle_specific);
-extern gboolean _wapi_copy_handle (gpointer handle, WapiHandleType type,
-                                  struct _WapiHandleShared *handle_specific);
-extern void _wapi_replace_handle (gpointer handle, WapiHandleType type,
-                                 struct _WapiHandleShared *handle_specific);
-extern gboolean _wapi_try_replace_handle (gpointer handle, WapiHandleType type, struct _WapiHandleShared *handle_specific);
 extern gpointer _wapi_search_handle (WapiHandleType type,
                                     gboolean (*check)(gpointer, gpointer),
                                     gpointer user_data,
-                                    gpointer *handle_specific);
-extern int _wapi_namespace_timestamp_release (gpointer nowptr);
-extern int _wapi_namespace_timestamp (guint32 now);
+                                    gpointer *handle_specific,
+                                    gboolean search_shared);
 extern gint32 _wapi_search_handle_namespace (WapiHandleType type,
                                             gchar *utf8_name);
 extern void _wapi_handle_ref (gpointer handle);
@@ -58,10 +63,13 @@ extern void _wapi_handle_register_capabilities (WapiHandleType type,
                                                WapiHandleCapability caps);
 extern gboolean _wapi_handle_test_capabilities (gpointer handle,
                                                WapiHandleCapability caps);
-extern void _wapi_handle_ops_close (gpointer handle);
+extern void _wapi_handle_ops_close (gpointer handle, gpointer data);
 extern void _wapi_handle_ops_signal (gpointer handle);
 extern gboolean _wapi_handle_ops_own (gpointer handle);
 extern gboolean _wapi_handle_ops_isowned (gpointer handle);
+extern guint32 _wapi_handle_ops_special_wait (gpointer handle,
+                                             guint32 timeout);
+extern void _wapi_handle_ops_prewait (gpointer handle);
 
 extern gboolean _wapi_handle_count_signalled_handles (guint32 numhandles,
                                                      gpointer *handles,
@@ -70,52 +78,41 @@ extern gboolean _wapi_handle_count_signalled_handles (guint32 numhandles,
                                                      guint32 *lowest);
 extern void _wapi_handle_unlock_handles (guint32 numhandles,
                                         gpointer *handles);
-extern int _wapi_handle_wait_signal (void);
-extern int _wapi_handle_timedwait_signal (struct timespec *timeout);
-extern int _wapi_handle_wait_signal_poll_share (void);
-extern int _wapi_handle_timedwait_signal_poll_share (struct timespec *timeout);
-extern int _wapi_handle_wait_signal_handle (gpointer handle);
+extern int _wapi_handle_wait_signal (gboolean poll);
+extern int _wapi_handle_timedwait_signal (struct timespec *timeout, gboolean poll);
+extern int _wapi_handle_wait_signal_handle (gpointer handle, gboolean alertable);
 extern int _wapi_handle_timedwait_signal_handle (gpointer handle,
-                                                struct timespec *timeout);
-extern gboolean _wapi_handle_process_fork (guint32 cmd, guint32 env,
-                                          guint32 dir, gboolean inherit,
-                                          guint32 flags,
-                                          gpointer stdin_handle,
-                                          gpointer stdout_handle,
-                                          gpointer stderr_handle,
-                                          gpointer *process_handle,
-                                          gpointer *thread_handle,
-                                          guint32 *pid, guint32 *tid);
-
-extern gboolean _wapi_handle_process_kill (pid_t pid, guint32 signo,
-                                          gint *err);
+                                                                                                struct timespec *timeout, gboolean alertable, gboolean poll);
 extern gboolean _wapi_handle_get_or_set_share (dev_t device, ino_t inode,
                                               guint32 new_sharemode,
                                               guint32 new_access,
                                               guint32 *old_sharemode,
                                               guint32 *old_access,
                                               struct _WapiFileShare **info);
-extern void _wapi_handle_check_share (struct _WapiFileShare *share_info);
+extern void _wapi_handle_check_share (struct _WapiFileShare *share_info,
+                                     int fd);
 extern void _wapi_handle_dump (void);
 extern void _wapi_handle_update_refs (void);
+extern void _wapi_handle_foreach (WapiHandleType type,
+                                       gboolean (*on_each)(gpointer test, gpointer user),
+                                       gpointer user_data);
 
 /* This is OK to use for atomic writes of individual struct members, as they
  * are independent
  */
-#define WAPI_SHARED_HANDLE_METADATA(handle) _wapi_shared_layout->metadata[_wapi_private_handles[GPOINTER_TO_UINT((handle))].u.shared.offset]
+#define WAPI_SHARED_HANDLE_DATA(handle) _wapi_shared_layout->handles[_WAPI_PRIVATE_HANDLES(GPOINTER_TO_UINT((handle))).u.shared.offset]
 
-/* Use this for read-only accesses to shared handle structs, so that
- * if a handle is updated we always look at the latest copy.  For
- * write access, use handle_copy/handle_replace so that all the
- * handle-type-specific data is updated atomically.
- */
-#define WAPI_SHARED_HANDLE_TYPED_DATA(handle, type) _wapi_shared_layout->handles[_wapi_shared_layout->metadata[_wapi_private_handles[GPOINTER_TO_UINT((handle))].u.shared.offset].offset].u.type
+#define WAPI_SHARED_HANDLE_TYPED_DATA(handle, type) _wapi_shared_layout->handles[_WAPI_PRIVATE_HANDLES(GPOINTER_TO_UINT((handle))).u.shared.offset].u.type
 
 static inline WapiHandleType _wapi_handle_type (gpointer handle)
 {
        guint32 idx = GPOINTER_TO_UINT(handle);
        
-       return(_wapi_private_handles[idx].type);
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return(WAPI_HANDLE_COUNT);      /* An impossible type */
+       }
+       
+       return(_WAPI_PRIVATE_HANDLES(idx).type);
 }
 
 static inline void _wapi_handle_set_signal_state (gpointer handle,
@@ -126,9 +123,13 @@ static inline void _wapi_handle_set_signal_state (gpointer handle,
        struct _WapiHandleUnshared *handle_data;
        int thr_ret;
 
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return;
+       }
+       
        g_assert (!_WAPI_SHARED_HANDLE(_wapi_handle_type (handle)));
        
-       handle_data = &_wapi_private_handles[idx];
+       handle_data = &_WAPI_PRIVATE_HANDLES(idx);
        
 #ifdef DEBUG
        g_message ("%s: setting state of %p to %s (broadcast %s)", __func__,
@@ -138,6 +139,15 @@ static inline void _wapi_handle_set_signal_state (gpointer handle,
        if (state == TRUE) {
                /* Tell everyone blocking on a single handle */
 
+               /* The condition the global signal cond is waiting on is the signalling of
+                * _any_ handle. So lock it before setting the signalled state.
+                */
+               pthread_cleanup_push ((void(*)(void *))mono_mutex_unlock_in_cleanup, (void *)_wapi_global_signal_mutex);
+               thr_ret = mono_mutex_lock (_wapi_global_signal_mutex);
+               if (thr_ret != 0)
+                       g_warning ("Bad call to mono_mutex_lock result %d for global signal mutex", thr_ret);
+               g_assert (thr_ret == 0);
+
                /* This function _must_ be called with
                 * handle->signal_mutex locked
                 */
@@ -145,24 +155,29 @@ static inline void _wapi_handle_set_signal_state (gpointer handle,
                
                if (broadcast == TRUE) {
                        thr_ret = pthread_cond_broadcast (&handle_data->signal_cond);
+                       if (thr_ret != 0)
+                               g_warning ("Bad call to pthread_cond_broadcast result %d for handle %p", thr_ret, handle);
                        g_assert (thr_ret == 0);
                } else {
                        thr_ret = pthread_cond_signal (&handle_data->signal_cond);
+                       if (thr_ret != 0)
+                               g_warning ("Bad call to pthread_cond_signal result %d for handle %p", thr_ret, handle);
                        g_assert (thr_ret == 0);
                }
 
                /* Tell everyone blocking on multiple handles that something
                 * was signalled
-                */
-               pthread_cleanup_push ((void(*)(void *))mono_mutex_unlock_in_cleanup, (void *)&_wapi_global_signal_mutex);
-               thr_ret = mono_mutex_lock (&_wapi_global_signal_mutex);
-               g_assert (thr_ret == 0);
-                       
-               thr_ret = pthread_cond_broadcast (&_wapi_global_signal_cond);
+                */                     
+               thr_ret = pthread_cond_broadcast (_wapi_global_signal_cond);
+               if (thr_ret != 0)
+                       g_warning ("Bad call to pthread_cond_broadcast result %d for handle %p", thr_ret, handle);
                g_assert (thr_ret == 0);
                        
-               thr_ret = mono_mutex_unlock (&_wapi_global_signal_mutex);
+               thr_ret = mono_mutex_unlock (_wapi_global_signal_mutex);
+               if (thr_ret != 0)
+                       g_warning ("Bad call to mono_mutex_unlock result %d for global signal mutex", thr_ret);
                g_assert (thr_ret == 0);
+
                pthread_cleanup_pop (0);
        } else {
                handle_data->signalled=state;
@@ -175,32 +190,38 @@ static inline void _wapi_shared_handle_set_signal_state (gpointer handle,
        guint32 idx = GPOINTER_TO_UINT(handle);
        struct _WapiHandleUnshared *handle_data;
        struct _WapiHandle_shared_ref *ref;
-       struct _WapiHandleSharedMetadata *shared_meta;
+       struct _WapiHandleShared *shared_data;
+       
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return;
+       }
        
        g_assert (_WAPI_SHARED_HANDLE(_wapi_handle_type (handle)));
        
-       handle_data = &_wapi_private_handles[idx];
+       handle_data = &_WAPI_PRIVATE_HANDLES(idx);
        
        ref = &handle_data->u.shared;
-       shared_meta = &_wapi_shared_layout->metadata[ref->offset];
-       shared_meta->signalled = state;
+       shared_data = &_wapi_shared_layout->handles[ref->offset];
+       shared_data->signalled = state;
 
 #ifdef DEBUG
        g_message ("%s: signalled shared handle offset 0x%x", __func__,
                   ref->offset);
 #endif
-
-       InterlockedIncrement (&_wapi_shared_layout->signal_count);
 }
 
 static inline gboolean _wapi_handle_issignalled (gpointer handle)
 {
        guint32 idx = GPOINTER_TO_UINT(handle);
        
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return(FALSE);
+       }
+       
        if (_WAPI_SHARED_HANDLE(_wapi_handle_type (handle))) {
-               return(WAPI_SHARED_HANDLE_METADATA(handle).signalled);
+               return(WAPI_SHARED_HANDLE_DATA(handle).signalled);
        } else {
-               return(_wapi_private_handles[idx].signalled);
+               return(_WAPI_PRIVATE_HANDLES(idx).signalled);
        }
 }
 
@@ -210,7 +231,7 @@ static inline int _wapi_handle_lock_signal_mutex (void)
        g_message ("%s: lock global signal mutex", __func__);
 #endif
 
-       return(mono_mutex_lock (&_wapi_global_signal_mutex));
+       return(mono_mutex_lock (_wapi_global_signal_mutex));
 }
 
 /* the parameter makes it easier to call from a pthread cleanup handler */
@@ -220,7 +241,7 @@ static inline int _wapi_handle_unlock_signal_mutex (void *unused)
        g_message ("%s: unlock global signal mutex", __func__);
 #endif
 
-       return(mono_mutex_unlock (&_wapi_global_signal_mutex));
+       return(mono_mutex_unlock (_wapi_global_signal_mutex));
 }
 
 static inline int _wapi_handle_lock_handle (gpointer handle)
@@ -231,30 +252,44 @@ static inline int _wapi_handle_lock_handle (gpointer handle)
        g_message ("%s: locking handle %p", __func__, handle);
 #endif
 
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return(0);
+       }
+       
        _wapi_handle_ref (handle);
        
        if (_WAPI_SHARED_HANDLE (_wapi_handle_type (handle))) {
                return(0);
        }
        
-       return(mono_mutex_lock (&_wapi_private_handles[idx].signal_mutex));
+       return(mono_mutex_lock (&_WAPI_PRIVATE_HANDLES(idx).signal_mutex));
 }
 
 static inline int _wapi_handle_trylock_handle (gpointer handle)
 {
        guint32 idx = GPOINTER_TO_UINT(handle);
+       int ret;
        
 #ifdef DEBUG
        g_message ("%s: locking handle %p", __func__, handle);
 #endif
 
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return(0);
+       }
+       
        _wapi_handle_ref (handle);
        
        if (_WAPI_SHARED_HANDLE (_wapi_handle_type (handle))) {
                return(0);
        }
 
-       return(mono_mutex_trylock (&_wapi_private_handles[idx].signal_mutex));
+       ret = mono_mutex_trylock (&_WAPI_PRIVATE_HANDLES(idx).signal_mutex);
+       if (ret != 0) {
+               _wapi_handle_unref (handle);
+       }
+       
+       return(ret);
 }
 
 static inline int _wapi_handle_unlock_handle (gpointer handle)
@@ -266,55 +301,22 @@ static inline int _wapi_handle_unlock_handle (gpointer handle)
        g_message ("%s: unlocking handle %p", __func__, handle);
 #endif
        
+       if (!_WAPI_PRIVATE_VALID_SLOT (idx)) {
+               return(0);
+       }
+       
        if (_WAPI_SHARED_HANDLE (_wapi_handle_type (handle))) {
                _wapi_handle_unref (handle);
                return(0);
        }
        
-       ret = mono_mutex_unlock (&_wapi_private_handles[idx].signal_mutex);
+       ret = mono_mutex_unlock (&_WAPI_PRIVATE_HANDLES(idx).signal_mutex);
 
        _wapi_handle_unref (handle);
        
        return(ret);
 }
 
-static inline int _wapi_timestamp_exclusion (volatile gint32 *timestamp,
-                                            guint32 now)
-{
-       guint32 then;
-       int ret;
-
-       then = InterlockedCompareExchange (timestamp, now, 0);
-       if (then == 0) {
-               ret = 0;
-       } else if (now - then > 10) {
-               /* Try to overwrite the previous
-                * attempt, but make sure noone else
-                * got in first
-                */
-               g_warning ("%s: Breaking a previous timestamp", __func__);
-                               
-               ret = InterlockedCompareExchange (timestamp, now,
-                                                 then) == then?0:EBUSY;
-       } else {
-               /* Someone else is working on this one */
-               ret = EBUSY;
-       }
-                       
-       return(ret);
-}
-
-static inline int _wapi_timestamp_release (volatile gint32 *timestamp,
-                                          guint32 now)
-{
-       /* The timestamp can be either: now, in which case we reset
-        * it; 0, in which case we don't do anything; any other value,
-        * in which case we don't do anything because someone else is
-        * in charge of resetting it.
-        */
-       return(InterlockedCompareExchange (timestamp, 0, now) != now);
-}
-
 static inline void _wapi_handle_spin (guint32 ms)
 {
        struct timespec sleepytime;
@@ -327,29 +329,47 @@ static inline void _wapi_handle_spin (guint32 ms)
        nanosleep (&sleepytime, NULL);
 }
 
+static inline int _wapi_handle_lock_shared_handles (void)
+{
+       return(_wapi_shm_sem_lock (_WAPI_SHARED_SEM_SHARED_HANDLES));
+}
+
+static inline int _wapi_handle_trylock_shared_handles (void)
+{
+       return(_wapi_shm_sem_trylock (_WAPI_SHARED_SEM_SHARED_HANDLES));
+}
+
+static inline int _wapi_handle_unlock_shared_handles (void)
+{
+       return(_wapi_shm_sem_unlock (_WAPI_SHARED_SEM_SHARED_HANDLES));
+}
+
+static inline int _wapi_namespace_lock (void)
+{
+       return(_wapi_shm_sem_lock (_WAPI_SHARED_SEM_NAMESPACE));
+}
+
+/* This signature makes it easier to use in pthread cleanup handlers */
+static inline int _wapi_namespace_unlock (gpointer data G_GNUC_UNUSED)
+{
+       return(_wapi_shm_sem_unlock (_WAPI_SHARED_SEM_NAMESPACE));
+}
+
 static inline void _wapi_handle_share_release (struct _WapiFileShare *info)
 {
-       guint32 now;
        int thr_ret;
        
        g_assert (info->handle_refs > 0);
        
        /* Prevent new entries racing with us */
-       do {
-               now = (guint32)(time(NULL) & 0xFFFFFFFF);
-               
-               thr_ret = _wapi_timestamp_exclusion (&_wapi_fileshare_layout->share_check, now);
-               if (thr_ret == EBUSY) {
-                       _wapi_handle_spin (100);
-               }
-       } while (thr_ret == EBUSY);
+       thr_ret = _wapi_shm_sem_lock (_WAPI_SHARED_SEM_FILESHARE);
        g_assert(thr_ret == 0);
 
-       if (InterlockedDecrement (&info->handle_refs) == 0) {
+       if (InterlockedDecrement ((gint32 *)&info->handle_refs) == 0) {
                memset (info, '\0', sizeof(struct _WapiFileShare));
        }
 
-       thr_ret = _wapi_timestamp_release (&_wapi_fileshare_layout->share_check, now);
+       thr_ret = _wapi_shm_sem_unlock (_WAPI_SHARED_SEM_FILESHARE);
 }
 
 #endif /* _WAPI_HANDLES_PRIVATE_H_ */