mono/io-layer/wapi-private.h

   1 /*
   2  * wapi-private.h:  internal definitions of handles and shared memory layout
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * (C) 2002 Ximian, Inc.
   8  */
   9
  10 #ifndef _WAPI_PRIVATE_H_
  11 #define _WAPI_PRIVATE_H_
  12
  13 #include <config.h>
  14 #include <glib.h>
  15
  16 #include <mono/io-layer/handles.h>
  17 #include <mono/io-layer/io.h>
  18 #include <mono/io-layer/daemon-private.h>
  19
  20 /* Shared threads don't seem to work yet */
  21 #undef _POSIX_THREAD_PROCESS_SHARED
  22
  23 /* Catch this here rather than corrupt the shared data at runtime */
  24 #if MONO_SIZEOF_SUNPATH==0
  25 #error configure failed to discover size of unix socket path
  26 #endif
  27
  28 /* Increment this whenever an incompatible change is made to the
  29  * shared handle structure.
  30  */
  31 #define _WAPI_HANDLE_VERSION 1
  32
  33 typedef enum {
  34         WAPI_HANDLE_UNUSED=0,
  35         WAPI_HANDLE_FILE,
  36         WAPI_HANDLE_CONSOLE,
  37         WAPI_HANDLE_THREAD,
  38         WAPI_HANDLE_SEM,
  39         WAPI_HANDLE_MUTEX,
  40         WAPI_HANDLE_EVENT,
  41         WAPI_HANDLE_SOCKET,
  42         WAPI_HANDLE_FIND,
  43         WAPI_HANDLE_PROCESS,
  44         WAPI_HANDLE_PIPE,
  45         WAPI_HANDLE_COUNT,
  46 } WapiHandleType;
  47
  48 typedef enum {
  49         WAPI_HANDLE_CAP_WAIT=0x01,
  50         WAPI_HANDLE_CAP_SIGNAL=0x02,
  51         WAPI_HANDLE_CAP_OWN=0x04,
  52 } WapiHandleCapability;
  53
  54 struct _WapiHandleOps
  55 {
  56         void (*close_shared)(gpointer handle);
  57         void (*close_private)(gpointer handle);
  58
  59         /* SignalObjectAndWait */
  60         void (*signal)(gpointer signal);
  61
  62         /* Called by WaitForSingleObject and WaitForMultipleObjects,
  63          * with the handle locked
  64          */
  65         void (*own_handle)(gpointer handle);
  66
  67         /* Called by WaitForSingleObject and WaitForMultipleObjects, if the
  68          * handle in question is "ownable" (ie mutexes), to see if the current
  69          * thread already owns this handle
  70          */
  71         gboolean (*is_owned)(gpointer handle);
  72 };
  73
  74 #include <mono/io-layer/event-private.h>
  75 #include <mono/io-layer/io-private.h>
  76 #include <mono/io-layer/mutex-private.h>
  77 #include <mono/io-layer/semaphore-private.h>
  78 #include <mono/io-layer/socket-private.h>
  79 #include <mono/io-layer/thread-private.h>
  80 #include <mono/io-layer/process-private.h>
  81
  82 struct _WapiHandleShared
  83 {
  84         WapiHandleType type;
  85         guint ref;
  86         gboolean signalled;
  87         mono_mutex_t signal_mutex;
  88         pthread_cond_t signal_cond;
  89
  90         union
  91         {
  92                 struct _WapiHandle_event event;
  93                 struct _WapiHandle_file file;
  94                 struct _WapiHandle_find find;
  95                 struct _WapiHandle_mutex mutex;
  96                 struct _WapiHandle_sem sem;
  97                 struct _WapiHandle_socket sock;
  98                 struct _WapiHandle_thread thread;
  99                 struct _WapiHandle_process process;
 100         } u;
 101 };
 102
 103 #define _WAPI_HANDLES_PER_SEGMENT 4096
 104 #define _WAPI_HANDLE_INVALID (gpointer)-1
 105
 106 #define _WAPI_SHM_SCRATCH_SIZE 512000
 107
 108 /*
 109  * This is the layout of the shared scratch data.  When the data array
 110  * is filled, it will be expanded by _WAPI_SHM_SCRATCH_SIZE
 111  * bytes. (scratch data is always copied out of the shared memory, so
 112  * it doesn't matter that the mapping will move around.)
 113  */
 114 struct _WapiHandleScratch
 115 {
 116         guint32 data_len;
 117
 118         /* This is set to TRUE by the daemon.  It determines whether a
 119          * resize will go via mremap() or just realloc().
 120          */
 121         gboolean is_shared;
 122         guchar scratch_data[0];
 123 };
 124
 125 /*
 126  * This is the layout of the shared memory segments.  When the handles
 127  * array is filled, another shared memory segment will be allocated
 128  * with the same structure.  This is to avoid having the shared memory
 129  * potentially move if it is resized and remapped.
 130  *
 131  * Note that the additional segments have the same structure, but only
 132  * the handle array is used.
 133  */
 134 struct _WapiHandleShared_list
 135 {
 136         guchar daemon[MONO_SIZEOF_SUNPATH];
 137         _wapi_daemon_status daemon_running;
 138
 139 #if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1
 140         mono_mutex_t signal_mutex;
 141         pthread_cond_t signal_cond;
 142 #endif
 143
 144         /* This holds the number of segments */
 145         guint32 num_segments;
 146         struct _WapiHandleShared handles[_WAPI_HANDLES_PER_SEGMENT];
 147 };
 148
 149 struct _WapiHandlePrivate
 150 {
 151         WapiHandleType type;
 152
 153         union
 154         {
 155                 struct _WapiHandlePrivate_event event;
 156                 struct _WapiHandlePrivate_file file;
 157                 struct _WapiHandlePrivate_find find;
 158                 struct _WapiHandlePrivate_mutex mutex;
 159                 struct _WapiHandlePrivate_sem sem;
 160                 struct _WapiHandlePrivate_socket sock;
 161                 struct _WapiHandlePrivate_thread thread;
 162                 struct _WapiHandlePrivate_process process;
 163         } u;
 164 };
 165
 166 /* Per-process handle info. For lookup convenience, each segment and
 167  * index matches the corresponding shared data.
 168  *
 169  * Note that the additional segments have the same structure, but only
 170  * the handle array is used.
 171  */
 172 struct _WapiHandlePrivate_list
 173 {
 174 #if !defined(_POSIX_THREAD_PROCESS_SHARED) || _POSIX_THREAD_PROCESS_SHARED == -1
 175         mono_mutex_t signal_mutex;
 176         pthread_cond_t signal_cond;
 177 #endif
 178
 179         struct _WapiHandlePrivate handles[_WAPI_HANDLES_PER_SEGMENT];
 180 };
 181
 182
 183 #endif /* _WAPI_PRIVATE_H_ */