mono/mini/wapihandles.c

   1 #include <config.h>
   2 #include <glib.h>
   3
   4 #ifdef PLATFORM_WIN32
   5
   6 int mini_wapi_hps (int argc, char **argv)
   7 {
   8         return 0;
   9 }
  10
  11 int mini_wapi_semdel (int argc, char **argv)
  12 {
  13         return 0;
  14 }
  15
  16 #else
  17
  18 #include <errno.h>
  19 #include <sys/types.h>
  20 #include <sys/ipc.h>
  21 #include <sys/sem.h>
  22 #include <mono/io-layer/io-layer.h>
  23
  24 /* We're digging into handle internals here... */
  25 #include <mono/io-layer/handles-private.h>
  26 #include <mono/io-layer/wapi-private.h>
  27 #include <mono/io-layer/shared.h>
  28 #include <mono/io-layer/collection.h>
  29
  30 static const guchar *unused_details (struct _WapiHandleShared *handle);
  31 static const guchar *unshared_details (struct _WapiHandleShared *handle);
  32 static const guchar *thread_details (struct _WapiHandleShared *handle);
  33 static const guchar *namedmutex_details (struct _WapiHandleShared *handle);
  34 static const guchar *namedsem_details (struct _WapiHandleShared *handle);
  35 static const guchar *namedevent_details (struct _WapiHandleShared *handle);
  36 static const guchar *process_details (struct _WapiHandleShared *handle);
  37
  38 /* This depends on the ordering of the enum WapiHandleType in
  39  * io-layer/wapi-private.h
  40  */
  41 static const guchar * (*details[])(struct _WapiHandleShared *)=
  42 {
  43         unused_details,
  44         unshared_details,               /* file */
  45         unshared_details,               /* console */
  46         thread_details,
  47         unshared_details,               /* sem */
  48         unshared_details,               /* mutex */
  49         unshared_details,               /* event */
  50         unshared_details,               /* socket */
  51         unshared_details,               /* find */
  52         process_details,
  53         unshared_details,               /* pipe */
  54         namedmutex_details,
  55         namedsem_details,
  56         namedevent_details,
  57         unused_details,
  58 };
  59
  60 int mini_wapi_hps (int argc, char **argv)
  61 {
  62         guint32 i;
  63         guint32 now;
  64
  65         _wapi_shared_layout = _wapi_shm_attach(WAPI_SHM_DATA);
  66         if (_wapi_shared_layout == NULL) {
  67                 g_error ("Failed to attach shared memory!");
  68                 exit (-1);
  69         }
  70
  71         _wapi_fileshare_layout = _wapi_shm_attach(WAPI_SHM_FILESHARE);
  72         if (_wapi_fileshare_layout == NULL) {
  73                 g_error ("Failed to attach fileshare shared memory!");
  74                 exit (-1);
  75         }
  76
  77         if (argc > 1) {
  78                 _wapi_shm_semaphores_init ();
  79                 _wapi_collection_init ();
  80                 _wapi_handle_collect ();
  81         }
  82
  83         g_print ("collection: %d sem: 0x%x\n",
  84                  _wapi_shared_layout->collection_count,
  85                  _wapi_shared_layout->sem_key);
  86
  87         now = (guint32)(time(NULL) & 0xFFFFFFFF);
  88         for (i = 0; i < _WAPI_HANDLE_INITIAL_COUNT; i++) {
  89                 struct _WapiHandleShared *shared;
  90
  91                 shared = &_wapi_shared_layout->handles[i];
  92                 if (shared->type != WAPI_HANDLE_UNUSED) {
  93                         g_print ("%3x (%3d) [%7s] %4u %s (%s)\n",
  94                                  i, shared->handle_refs,
  95                                  _wapi_handle_typename[shared->type],
  96                                  now - shared->timestamp,
  97                                  shared->signalled?"Sg":"Un",
  98                                  details[shared->type](shared));
  99                 }
 100         }
 101
 102         g_print ("Fileshare hwm: %d\n", _wapi_fileshare_layout->hwm);
 103
 104         for (i = 0; i <= _wapi_fileshare_layout->hwm; i++) {
 105                 struct _WapiFileShare *file_share;
 106
 107                 file_share = &_wapi_fileshare_layout->share_info[i];
 108                 if (file_share->handle_refs > 0) {
 109                         g_print ("dev: 0x%llx ino: %lld open pid: %d share: 0x%x access: 0x%x refs: %d\n", file_share->device, file_share->inode, file_share->opened_by_pid, file_share->sharemode, file_share->access, file_share->handle_refs);
 110                 }
 111         }
 112
 113         exit (0);
 114 }
 115
 116 static const guchar *unused_details (struct _WapiHandleShared *handle)
 117 {
 118         return("unused details");
 119 }
 120
 121 static const guchar *unshared_details (struct _WapiHandleShared *handle)
 122 {
 123         return("unshared details");
 124 }
 125
 126 static const guchar *thread_details (struct _WapiHandleShared *handle)
 127 {
 128         static guchar buf[80];
 129         struct _WapiHandle_thread *thr=&handle->u.thread;
 130
 131         g_snprintf (buf, sizeof(buf),
 132                     "proc: %d, state: %d, exit: %u, join: %d",
 133                     thr->owner_pid, thr->state, thr->exitstatus,
 134                     thr->joined);
 135
 136         return(buf);
 137 }
 138
 139 static const guchar *namedmutex_details (struct _WapiHandleShared *handle)
 140 {
 141         static guchar buf[80];
 142         gchar *name;
 143         struct _WapiHandle_namedmutex *mut=&handle->u.namedmutex;
 144
 145         name = mut->sharedns.name;
 146
 147         g_snprintf (buf, sizeof(buf), "[%15s] own: %5d:%5ld, count: %5u",
 148                     name==NULL?(gchar *)"":name, mut->pid, mut->tid,
 149                     mut->recursion);
 150
 151         return(buf);
 152 }
 153
 154 static const guchar *namedsem_details (struct _WapiHandleShared *handle)
 155 {
 156         static guchar buf[80];
 157         gchar *name;
 158         struct _WapiHandle_namedsem *sem = &handle->u.namedsem;
 159
 160         name = sem->sharedns.name;
 161
 162         g_snprintf (buf, sizeof(buf), "[%15s] val: %5u, max: %5d",
 163                     name == NULL?(gchar *)"":name, sem->val, sem->max);
 164
 165         return(buf);
 166 }
 167
 168 static const guchar *namedevent_details (struct _WapiHandleShared *handle)
 169 {
 170         static guchar buf[80];
 171         gchar *name;
 172         struct _WapiHandle_namedevent *event = &handle->u.namedevent;
 173
 174         name = event->sharedns.name;
 175
 176         g_snprintf (buf, sizeof(buf), "[%15s] %s count: %5u",
 177                     name == NULL?(gchar *)"":name,
 178                     event->manual?"Manual":"Auto", event->set_count);
 179
 180         return(buf);
 181 }
 182
 183 static const guchar *process_details (struct _WapiHandleShared *handle)
 184 {
 185         static guchar buf[80];
 186         gchar *name;
 187         struct _WapiHandle_process *proc=&handle->u.process;
 188
 189         name = proc->proc_name;
 190
 191         g_snprintf (buf, sizeof(buf), "[%25.25s] pid: %5u exit: %u",
 192                     name==NULL?(gchar *)"":name, proc->id, proc->exitstatus);
 193
 194         return(buf);
 195 }
 196
 197 /* The old handles/semdel.c */
 198 int mini_wapi_semdel (int argc, char **argv)
 199 {
 200         int sem_id, ret;
 201
 202         _wapi_shared_layout = _wapi_shm_attach(WAPI_SHM_DATA);
 203         if (_wapi_shared_layout == FALSE) {
 204                 exit (0);
 205         }
 206
 207         sem_id = semget (_wapi_shared_layout->sem_key, _WAPI_SHARED_SEM_COUNT, 0600);
 208         if (sem_id != -1) {
 209                 ret = semctl (sem_id, IPC_RMID, 0);
 210                 if (ret == -1) {
 211                         g_message ("Error deleting semaphore: %s",
 212                                    g_strerror (errno));
 213                 }
 214         }
 215
 216         exit (0);
 217 }
 218
 219 #endif
 220