X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fio-layer%2Fwapi-private.h;h=5dc0e6360732ab36004c9347d9e0538c85203d74;hb=aae20b33d0f5235361bf19210c2a6f7d7ce88aa7;hp=59ec8defe3037214d26acb25c9f19a2a3f6477d1;hpb=7ff8f29ff29fa3f08ef305ac43ef079097323286;p=mono.git diff --git a/mono/io-layer/wapi-private.h b/mono/io-layer/wapi-private.h index 59ec8defe30..5dc0e636073 100644 --- a/mono/io-layer/wapi-private.h +++ b/mono/io-layer/wapi-private.h @@ -15,17 +15,6 @@ #include #include -#include - -/* for non-GCC compilers where Glib gives an empty pretty function - * macro create one that gives file & line number instead - */ -#ifndef __GNUC__ -#undef G_GNUC_PRETTY_FUNCTION -#define STRINGIZE_HELPER(exp) #exp -#define STRINGIZE(exp) STRINGIZE_HELPER(exp) -#define G_GNUC_PRETTY_FUNCTION __FILE__ "(" STRINGIZE(__LINE__) ")" -#endif /* Catch this here rather than corrupt the shared data at runtime */ #if MONO_SIZEOF_SUNPATH==0 @@ -35,7 +24,7 @@ /* Increment this whenever an incompatible change is made to the * shared handle structure. */ -#define _WAPI_HANDLE_VERSION 1 +#define _WAPI_HANDLE_VERSION 7 typedef enum { WAPI_HANDLE_UNUSED=0, @@ -49,40 +38,59 @@ typedef enum { WAPI_HANDLE_FIND, WAPI_HANDLE_PROCESS, WAPI_HANDLE_PIPE, + WAPI_HANDLE_NAMEDMUTEX, WAPI_HANDLE_COUNT } WapiHandleType; -#define _WAPI_SHARED_NAMESPACE(type) (type==WAPI_HANDLE_MUTEX) +extern const char *_wapi_handle_typename[]; + +#define _WAPI_SHARED_HANDLE(type) (type == WAPI_HANDLE_PROCESS || \ + type == WAPI_HANDLE_NAMEDMUTEX) + +#define _WAPI_FD_HANDLE(type) (type == WAPI_HANDLE_FILE || \ + type == WAPI_HANDLE_CONSOLE || \ + type == WAPI_HANDLE_SOCKET || \ + type == WAPI_HANDLE_PIPE) + +#define _WAPI_SHARED_NAMESPACE(type) (type == WAPI_HANDLE_NAMEDMUTEX) typedef struct { - guint32 name; + gchar name[MAX_PATH + 1]; } WapiSharedNamespace; typedef enum { WAPI_HANDLE_CAP_WAIT=0x01, WAPI_HANDLE_CAP_SIGNAL=0x02, - WAPI_HANDLE_CAP_OWN=0x04 + WAPI_HANDLE_CAP_OWN=0x04, + WAPI_HANDLE_CAP_SPECIAL_WAIT=0x08 } WapiHandleCapability; struct _WapiHandleOps { - void (*close_shared)(gpointer handle); - void (*close_private)(gpointer handle); + void (*close)(gpointer handle, gpointer data); /* SignalObjectAndWait */ void (*signal)(gpointer signal); /* Called by WaitForSingleObject and WaitForMultipleObjects, - * with the handle locked + * with the handle locked (shared handles aren't locked.) + * Returns TRUE if ownership was established, false otherwise. */ - void (*own_handle)(gpointer handle); + gboolean (*own_handle)(gpointer handle); /* Called by WaitForSingleObject and WaitForMultipleObjects, if the * handle in question is "ownable" (ie mutexes), to see if the current * thread already owns this handle */ gboolean (*is_owned)(gpointer handle); + + /* Called by WaitForSingleObject and WaitForMultipleObjects, + * if the handle in question needs a special wait function + * instead of using the normal handle signal mechanism. + * Returns the WaitForSingleObject return code. + */ + guint32 (*special_wait)(gpointer handle, guint32 timeout); }; #include @@ -93,10 +101,18 @@ struct _WapiHandleOps #include #include -/* Shared threads don't seem to work yet */ -#undef _POSIX_THREAD_PROCESS_SHARED +struct _WapiHandle_shared_ref +{ + /* This will be split 16:16 with the shared file segment in + * the top half, when I implement space increases + */ + guint32 offset; +}; -struct _WapiHandleShared +#define _WAPI_HANDLE_INITIAL_COUNT 4096 +#define _WAPI_HEADROOM 16 + +struct _WapiHandleUnshared { WapiHandleType type; guint ref; @@ -112,89 +128,76 @@ struct _WapiHandleShared struct _WapiHandle_mutex mutex; struct _WapiHandle_sem sem; struct _WapiHandle_socket sock; + struct _WapiHandle_shared_ref shared; + + /* Move thread data into the private set, while + * problems with cleaning up shared handles are fixed + */ struct _WapiHandle_thread thread; - struct _WapiHandle_process process; } u; }; -#define _WAPI_HANDLES_PER_SEGMENT 4096 -#define _WAPI_HANDLE_INVALID (gpointer)-1 - -#define _WAPI_SHM_SCRATCH_SIZE 512000 - -/* - * This is the layout of the shared scratch data. When the data array - * is filled, it will be expanded by _WAPI_SHM_SCRATCH_SIZE - * bytes. (scratch data is always copied out of the shared memory, so - * it doesn't matter that the mapping will move around.) - */ -struct _WapiHandleScratch +struct _WapiHandleSharedMetadata { - guint32 data_len; - - /* This is set to TRUE by the daemon. It determines whether a - * resize will go via mremap() or just realloc(). - */ - gboolean is_shared; - guchar scratch_data[MONO_ZERO_ARRAY_LENGTH]; + volatile guint32 offset; + guint32 timestamp; + volatile gboolean signalled; }; -/* - * This is the layout of the shared memory segments. When the handles - * array is filled, another shared memory segment will be allocated - * with the same structure. This is to avoid having the shared memory - * potentially move if it is resized and remapped. - * - * Note that the additional segments have the same structure, but only - * the handle array is used. - */ -struct _WapiHandleShared_list +struct _WapiHandleShared { - guchar daemon[MONO_SIZEOF_SUNPATH]; - _wapi_daemon_status daemon_running; + WapiHandleType type; + gboolean stale; -#if defined(_POSIX_THREAD_PROCESS_SHARED) && _POSIX_THREAD_PROCESS_SHARED != -1 - mono_mutex_t signal_mutex; - pthread_cond_t signal_cond; -#endif - - /* This holds the number of segments */ - guint32 num_segments; - struct _WapiHandleShared handles[_WAPI_HANDLES_PER_SEGMENT]; + union + { + /* Leave this one while the thread is in the private + * set, so the shared space doesn't change size + */ + struct _WapiHandle_thread thread; + struct _WapiHandle_process process; + struct _WapiHandle_namedmutex namedmutex; + } u; }; -struct _WapiHandlePrivate +#define _WAPI_SHARED_SEM_NAMESPACE 0 +#define _WAPI_SHARED_SEM_COLLECTION 1 +#define _WAPI_SHARED_SEM_SHARE 2 +#define _WAPI_SHARED_SEM_HANDLE 3 +#define _WAPI_SHARED_SEM_COUNT 8 /* Leave some future expansion space */ + +struct _WapiHandleSharedLayout { - WapiHandleType type; + volatile guint32 signal_count; + volatile guint32 collection_count; + volatile key_t sem_key; + + struct _WapiHandleSharedMetadata metadata[_WAPI_HANDLE_INITIAL_COUNT]; + struct _WapiHandleShared handles[_WAPI_HANDLE_INITIAL_COUNT]; +}; - union - { - struct _WapiHandlePrivate_event event; - struct _WapiHandlePrivate_file file; - struct _WapiHandlePrivate_find find; - struct _WapiHandlePrivate_mutex mutex; - struct _WapiHandlePrivate_sem sem; - struct _WapiHandlePrivate_socket sock; - struct _WapiHandlePrivate_thread thread; - struct _WapiHandlePrivate_process process; - } u; +#define _WAPI_FILESHARE_SIZE 102400 + +struct _WapiFileShare +{ + dev_t device; + ino_t inode; + pid_t opened_by_pid; + guint32 sharemode; + guint32 access; + guint32 handle_refs; + guint32 timestamp; }; -/* Per-process handle info. For lookup convenience, each segment and - * index matches the corresponding shared data. - * - * Note that the additional segments have the same structure, but only - * the handle array is used. - */ -struct _WapiHandlePrivate_list +struct _WapiFileShareLayout { -#if !defined(_POSIX_THREAD_PROCESS_SHARED) || _POSIX_THREAD_PROCESS_SHARED == -1 - mono_mutex_t signal_mutex; - pthread_cond_t signal_cond; -#endif + guint32 hwm; - struct _WapiHandlePrivate handles[_WAPI_HANDLES_PER_SEGMENT]; + struct _WapiFileShare share_info[_WAPI_FILESHARE_SIZE]; }; + +#define _WAPI_HANDLE_INVALID (gpointer)-1 + #endif /* _WAPI_PRIVATE_H_ */