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-2006 Novell, Inc.
   8  */
   9
  10 #ifndef _WAPI_PRIVATE_H_
  11 #define _WAPI_PRIVATE_H_
  12
  13 #include <config.h>
  14 #include <glib.h>
  15 #include <sys/stat.h>
  16
  17 #include <mono/io-layer/handles.h>
  18 #include <mono/io-layer/io.h>
  19
  20 /* Increment this whenever an incompatible change is made to the
  21  * shared handle structure.
  22  */
  23 #define _WAPI_HANDLE_VERSION 12
  24
  25 typedef enum {
  26         WAPI_HANDLE_UNUSED=0,
  27         WAPI_HANDLE_FILE,
  28         WAPI_HANDLE_CONSOLE,
  29         WAPI_HANDLE_THREAD,
  30         WAPI_HANDLE_SEM,
  31         WAPI_HANDLE_MUTEX,
  32         WAPI_HANDLE_EVENT,
  33         WAPI_HANDLE_SOCKET,
  34         WAPI_HANDLE_FIND,
  35         WAPI_HANDLE_PROCESS,
  36         WAPI_HANDLE_PIPE,
  37         WAPI_HANDLE_NAMEDMUTEX,
  38         WAPI_HANDLE_NAMEDSEM,
  39         WAPI_HANDLE_NAMEDEVENT,
  40         WAPI_HANDLE_COUNT
  41 } WapiHandleType;
  42
  43 extern const char *_wapi_handle_typename[];
  44
  45 #define _WAPI_SHARED_HANDLE(type) (type == WAPI_HANDLE_PROCESS || \
  46                                    type == WAPI_HANDLE_NAMEDMUTEX || \
  47                                    type == WAPI_HANDLE_NAMEDSEM || \
  48                                    type == WAPI_HANDLE_NAMEDEVENT)
  49
  50 #define _WAPI_FD_HANDLE(type) (type == WAPI_HANDLE_FILE || \
  51                                type == WAPI_HANDLE_CONSOLE || \
  52                                type == WAPI_HANDLE_SOCKET || \
  53                                type == WAPI_HANDLE_PIPE)
  54
  55 #define _WAPI_SHARED_NAMESPACE(type) (type == WAPI_HANDLE_NAMEDMUTEX || \
  56                                       type == WAPI_HANDLE_NAMEDSEM || \
  57                                       type == WAPI_HANDLE_NAMEDEVENT)
  58
  59 typedef struct
  60 {
  61         gchar name[MAX_PATH + 1];
  62 } WapiSharedNamespace;
  63
  64 typedef enum {
  65         WAPI_HANDLE_CAP_WAIT=0x01,
  66         WAPI_HANDLE_CAP_SIGNAL=0x02,
  67         WAPI_HANDLE_CAP_OWN=0x04,
  68         WAPI_HANDLE_CAP_SPECIAL_WAIT=0x08
  69 } WapiHandleCapability;
  70
  71 struct _WapiHandleOps
  72 {
  73         void (*close)(gpointer handle, gpointer data);
  74
  75         /* SignalObjectAndWait */
  76         void (*signal)(gpointer signal);
  77
  78         /* Called by WaitForSingleObject and WaitForMultipleObjects,
  79          * with the handle locked (shared handles aren't locked.)
  80          * Returns TRUE if ownership was established, false otherwise.
  81          */
  82         gboolean (*own_handle)(gpointer handle);
  83
  84         /* Called by WaitForSingleObject and WaitForMultipleObjects, if the
  85          * handle in question is "ownable" (ie mutexes), to see if the current
  86          * thread already owns this handle
  87          */
  88         gboolean (*is_owned)(gpointer handle);
  89
  90         /* Called by WaitForSingleObject and WaitForMultipleObjects,
  91          * if the handle in question needs a special wait function
  92          * instead of using the normal handle signal mechanism.
  93          * Returns the WaitForSingleObject return code.
  94          */
  95         guint32 (*special_wait)(gpointer handle, guint32 timeout);
  96
  97         /* Called by WaitForSingleObject and WaitForMultipleObjects,
  98          * if the handle in question needs some preprocessing before the
  99          * signal wait.
 100          */
 101         void (*prewait)(gpointer handle);
 102 };
 103
 104 #include <mono/io-layer/event-private.h>
 105 #include <mono/io-layer/io-private.h>
 106 #include <mono/io-layer/mutex-private.h>
 107 #include <mono/io-layer/semaphore-private.h>
 108 #include <mono/io-layer/socket-private.h>
 109 #include <mono/io-layer/thread-private.h>
 110 #include <mono/io-layer/process-private.h>
 111
 112 struct _WapiHandle_shared_ref
 113 {
 114         /* This will be split 16:16 with the shared file segment in
 115          * the top half, when I implement space increases
 116          */
 117         guint32 offset;
 118 };
 119
 120 #define _WAPI_HANDLE_INITIAL_COUNT 256
 121
 122 struct _WapiHandleUnshared
 123 {
 124         WapiHandleType type;
 125         guint ref;
 126         gboolean signalled;
 127         mono_mutex_t signal_mutex;
 128         pthread_cond_t signal_cond;
 129
 130         union
 131         {
 132                 struct _WapiHandle_event event;
 133                 struct _WapiHandle_file file;
 134                 struct _WapiHandle_find find;
 135                 struct _WapiHandle_mutex mutex;
 136                 struct _WapiHandle_sem sem;
 137                 struct _WapiHandle_socket sock;
 138                 struct _WapiHandle_thread thread;
 139                 struct _WapiHandle_shared_ref shared;
 140         } u;
 141 };
 142
 143 struct _WapiHandleShared
 144 {
 145         WapiHandleType type;
 146         guint32 timestamp;
 147         guint32 handle_refs;
 148         volatile gboolean signalled;
 149
 150         union
 151         {
 152                 struct _WapiHandle_process process;
 153                 struct _WapiHandle_namedmutex namedmutex;
 154                 struct _WapiHandle_namedsem namedsem;
 155                 struct _WapiHandle_namedevent namedevent;
 156         } u;
 157 };
 158
 159 #define _WAPI_SHARED_SEM_NAMESPACE 0
 160 /*#define _WAPI_SHARED_SEM_COLLECTION 1*/
 161 #define _WAPI_SHARED_SEM_FILESHARE 2
 162 #define _WAPI_SHARED_SEM_SHARED_HANDLES 3
 163 #define _WAPI_SHARED_SEM_PROCESS_COUNT_LOCK 6
 164 #define _WAPI_SHARED_SEM_PROCESS_COUNT 7
 165 #define _WAPI_SHARED_SEM_COUNT 8        /* Leave some future expansion space */
 166
 167 struct _WapiHandleSharedLayout
 168 {
 169         volatile guint32 collection_count;
 170         volatile key_t sem_key;
 171
 172         struct _WapiHandleShared handles[_WAPI_HANDLE_INITIAL_COUNT];
 173 };
 174
 175 #define _WAPI_FILESHARE_SIZE 102400
 176
 177 struct _WapiFileShare
 178 {
 179 #ifdef WAPI_FILE_SHARE_PLATFORM_EXTRA_DATA
 180         WAPI_FILE_SHARE_PLATFORM_EXTRA_DATA
 181 #endif
 182         dev_t device;
 183         ino_t inode;
 184         pid_t opened_by_pid;
 185         guint32 sharemode;
 186         guint32 access;
 187         guint32 handle_refs;
 188         guint32 timestamp;
 189 };
 190
 191 struct _WapiFileShareLayout
 192 {
 193         guint32 hwm;
 194
 195         struct _WapiFileShare share_info[_WAPI_FILESHARE_SIZE];
 196 };
 197
 198
 199
 200 #define _WAPI_HANDLE_INVALID (gpointer)-1
 201
 202 #endif /* _WAPI_PRIVATE_H_ */