src/simix/smx_io.c

   1 /* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "smx_private.h"
   8 #include "xbt/sysdep.h"
   9 #include "xbt/log.h"
  10 #include "xbt/dict.h"
  11 #include "mc/mc.h"
  12
  13 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_io, simix,
  14                                 "Logging specific to SIMIX (io)");
  15
  16
  17 //SIMIX FILE READ
  18 void SIMIX_pre_file_read(smx_simcall_t simcall, void *ptr, size_t size,
  19                          size_t nmemb, smx_file_t stream)
  20 {
  21   smx_action_t action = SIMIX_file_read(simcall->issuer, ptr, size, nmemb, stream);
  22   xbt_fifo_push(action->simcalls, simcall);
  23   simcall->issuer->waiting_action = action;
  24 }
  25
  26 smx_action_t SIMIX_file_read(smx_process_t process, void* ptr, size_t size, size_t nmemb, smx_file_t stream)
  27 {
  28   smx_action_t action;
  29   smx_host_t host = process->smx_host;
  30
  31   /* check if the host is active */
  32   if (surf_workstation_model->extension.
  33       workstation.get_state(host) != SURF_RESOURCE_ON) {
  34     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
  35            sg_host_name(host));
  36   }
  37
  38   action = xbt_mallocator_get(simix_global->action_mallocator);
  39   action->type = SIMIX_ACTION_IO;
  40   action->name = NULL;
  41 #ifdef HAVE_TRACING
  42   action->category = NULL;
  43 #endif
  44
  45   action->io.host = host;
  46   action->io.surf_io = surf_workstation_model->extension.workstation.read(host, ptr, size, nmemb, stream->surf_file);
  47
  48   surf_workstation_model->action_data_set(action->io.surf_io, action);
  49   XBT_DEBUG("Create io action %p", action);
  50
  51   return action;
  52 }
  53
  54 //SIMIX FILE WRITE
  55 void SIMIX_pre_file_write(smx_simcall_t simcall, const void *ptr, size_t size,
  56                           size_t nmemb, smx_file_t stream)
  57 {
  58   smx_action_t action = SIMIX_file_write(simcall->issuer, ptr, size, nmemb, stream);
  59   xbt_fifo_push(action->simcalls, simcall);
  60   simcall->issuer->waiting_action = action;
  61 }
  62
  63 smx_action_t SIMIX_file_write(smx_process_t process, const void* ptr, size_t size, size_t nmemb, smx_file_t stream)
  64 {
  65   smx_action_t action;
  66   smx_host_t host = process->smx_host;
  67
  68   /* check if the host is active */
  69   if (surf_workstation_model->extension.
  70       workstation.get_state(host) != SURF_RESOURCE_ON) {
  71     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
  72            sg_host_name(host));
  73   }
  74
  75   action = xbt_mallocator_get(simix_global->action_mallocator);
  76   action->type = SIMIX_ACTION_IO;
  77   action->name = NULL;
  78 #ifdef HAVE_TRACING
  79   action->category = NULL;
  80 #endif
  81
  82   action->io.host = host;
  83   action->io.surf_io = surf_workstation_model->extension.workstation.write(host, ptr, size, nmemb, stream->surf_file);
  84
  85   surf_workstation_model->action_data_set(action->io.surf_io, action);
  86   XBT_DEBUG("Create io action %p", action);
  87
  88   return action;
  89 }
  90
  91 //SIMIX FILE OPEN
  92 void SIMIX_pre_file_open(smx_simcall_t simcall, const char* mount,
  93                          const char* path, const char* mode)
  94 {
  95   smx_action_t action = SIMIX_file_open(simcall->issuer, mount, path, mode);
  96   xbt_fifo_push(action->simcalls, simcall);
  97   simcall->issuer->waiting_action = action;
  98 }
  99
 100 smx_action_t SIMIX_file_open(smx_process_t process ,const char* mount, const char* path, const char* mode)
 101 {
 102   smx_action_t action;
 103   smx_host_t host = process->smx_host;
 104
 105   /* check if the host is active */
 106   if (surf_workstation_model->extension.
 107       workstation.get_state(host) != SURF_RESOURCE_ON) {
 108     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
 109            sg_host_name(host));
 110   }
 111
 112   action = xbt_mallocator_get(simix_global->action_mallocator);
 113   action->type = SIMIX_ACTION_IO;
 114   action->name = NULL;
 115 #ifdef HAVE_TRACING
 116   action->category = NULL;
 117 #endif
 118
 119   action->io.host = host;
 120   action->io.surf_io = surf_workstation_model->extension.workstation.open(host, mount, path, mode);
 121
 122   surf_workstation_model->action_data_set(action->io.surf_io, action);
 123   XBT_DEBUG("Create io action %p", action);
 124
 125   return action;
 126 }
 127
 128 //SIMIX FILE CLOSE
 129 void SIMIX_pre_file_close(smx_simcall_t simcall, smx_file_t fp)
 130 {
 131   smx_action_t action = SIMIX_file_close(simcall->issuer, fp);
 132   xbt_fifo_push(action->simcalls, simcall);
 133   simcall->issuer->waiting_action = action;
 134 }
 135
 136 smx_action_t SIMIX_file_close(smx_process_t process, smx_file_t fp)
 137 {
 138   smx_action_t action;
 139   smx_host_t host = process->smx_host;
 140
 141   /* check if the host is active */
 142   if (surf_workstation_model->extension.
 143       workstation.get_state(host) != SURF_RESOURCE_ON) {
 144     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
 145            sg_host_name(host));
 146   }
 147
 148   action = xbt_mallocator_get(simix_global->action_mallocator);
 149   action->type = SIMIX_ACTION_IO;
 150   action->name = NULL;
 151 #ifdef HAVE_TRACING
 152   action->category = NULL;
 153 #endif
 154
 155   action->io.host = host;
 156   action->io.surf_io = surf_workstation_model->extension.workstation.close(host, fp->surf_file);
 157
 158   surf_workstation_model->action_data_set(action->io.surf_io, action);
 159   XBT_DEBUG("Create io action %p", action);
 160
 161   return action;
 162 }
 163
 164 //SIMIX FILE STAT
 165 void SIMIX_pre_file_stat(smx_simcall_t simcall, smx_file_t fd, s_file_stat_t *buf)
 166 {
 167   smx_action_t action = SIMIX_file_stat(simcall->issuer, fd, *buf);
 168   xbt_fifo_push(action->simcalls, simcall);
 169   simcall->issuer->waiting_action = action;
 170 }
 171
 172 smx_action_t SIMIX_file_stat(smx_process_t process, smx_file_t fd, s_file_stat_t buf)
 173 {
 174   smx_action_t action;
 175   smx_host_t host = process->smx_host;
 176   /* check if the host is active */
 177   if (surf_workstation_model->extension.
 178       workstation.get_state(host) != SURF_RESOURCE_ON) {
 179     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
 180            sg_host_name(host));
 181   }
 182
 183   action = xbt_mallocator_get(simix_global->action_mallocator);
 184   action->type = SIMIX_ACTION_IO;
 185   action->name = NULL;
 186 #ifdef HAVE_TRACING
 187   action->category = NULL;
 188 #endif
 189
 190   action->io.host = host;
 191   action->io.surf_io = surf_workstation_model->extension.workstation.stat(host, fd->surf_file);
 192
 193   surf_workstation_model->action_data_set(action->io.surf_io, action);
 194   XBT_DEBUG("Create io action %p", action);
 195
 196   return action;
 197 }
 198
 199 //SIMIX FILE UNLINK
 200 void SIMIX_pre_file_unlink(smx_simcall_t simcall, smx_file_t fd)
 201 {
 202   smx_action_t action = SIMIX_file_unlink(simcall->issuer, fd);
 203   xbt_fifo_push(action->simcalls, simcall);
 204   simcall->issuer->waiting_action = action;
 205 }
 206
 207 smx_action_t SIMIX_file_unlink(smx_process_t process, smx_file_t fd)
 208 {
 209   smx_action_t action;
 210   smx_host_t host = process->smx_host;
 211   /* check if the host is active */
 212   if (surf_workstation_model->extension.
 213       workstation.get_state(host) != SURF_RESOURCE_ON) {
 214     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
 215            sg_host_name(host));
 216   }
 217
 218   action = xbt_mallocator_get(simix_global->action_mallocator);
 219   action->type = SIMIX_ACTION_IO;
 220   action->name = NULL;
 221 #ifdef HAVE_TRACING
 222   action->category = NULL;
 223 #endif
 224
 225   action->io.host = host;
 226   action->io.surf_io = surf_workstation_model->extension.workstation.unlink(host, fd->surf_file);
 227
 228   surf_workstation_model->action_data_set(action->io.surf_io, action);
 229   XBT_DEBUG("Create io action %p", action);
 230
 231   return action;
 232 }
 233
 234 //SIMIX FILE LS
 235 void SIMIX_pre_file_ls(smx_simcall_t simcall,
 236                        const char* mount, const char* path)
 237 {
 238   smx_action_t action = SIMIX_file_ls(simcall->issuer, mount, path);
 239   xbt_fifo_push(action->simcalls, simcall);
 240   simcall->issuer->waiting_action = action;
 241 }
 242 smx_action_t SIMIX_file_ls(smx_process_t process, const char* mount, const char *path)
 243 {
 244   smx_action_t action;
 245   smx_host_t host = process->smx_host;
 246   /* check if the host is active */
 247   if (surf_workstation_model->extension.workstation.get_state(host) != SURF_RESOURCE_ON) {
 248     THROWF(host_error, 0, "Host %s failed, you cannot call this function",
 249            sg_host_name(host));
 250   }
 251
 252   action = xbt_mallocator_get(simix_global->action_mallocator);
 253   action->type = SIMIX_ACTION_IO;
 254   action->name = NULL;
 255 #ifdef HAVE_TRACING
 256   action->category = NULL;
 257 #endif
 258
 259   action->io.host = host;
 260   action->io.surf_io = surf_workstation_model->extension.workstation.ls(host,mount,path);
 261
 262   surf_workstation_model->action_data_set(action->io.surf_io, action);
 263   XBT_DEBUG("Create io action %p", action);
 264   return action;
 265 }
 266
 267 static void free_file_stat(void *p)
 268 {
 269   file_stat_t fs = p;
 270   xbt_free(fs->date);
 271   xbt_free(fs->group);
 272   xbt_free(fs->time);
 273   xbt_free(fs->user);
 274   xbt_free(fs->user_rights);
 275   xbt_free(fs);
 276 }
 277
 278 void SIMIX_post_io(smx_action_t action)
 279 {
 280   xbt_fifo_item_t i;
 281   smx_simcall_t simcall;
 282   char* key;
 283   xbt_dict_cursor_t cursor = NULL;
 284   s_file_stat_t *dst = NULL;
 285   s_file_stat_t *src = NULL;
 286
 287   xbt_fifo_foreach(action->simcalls,i,simcall,smx_simcall_t) {
 288     switch (simcall->call) {
 289     case SIMCALL_FILE_OPEN:;
 290       smx_file_t tmp = xbt_new(s_smx_file_t,1);
 291       tmp->surf_file = (action->io.surf_io)->file;
 292       simcall_file_open__set__result(simcall, tmp);
 293       break;
 294
 295     case SIMCALL_FILE_CLOSE:
 296       xbt_free(simcall_file_close__get__fp(simcall));
 297       simcall_file_close__set__result(simcall, 0);
 298       break;
 299
 300     case SIMCALL_FILE_WRITE:
 301       simcall_file_write__set__result(simcall, (action->io.surf_io)->cost);
 302       break;
 303
 304     case SIMCALL_FILE_READ:
 305       simcall_file_read__set__result(simcall, (action->io.surf_io)->cost);
 306       break;
 307
 308     case SIMCALL_FILE_STAT:
 309       simcall_file_stat__set__result(simcall, 0);
 310       dst = simcall_file_stat__get__buf(simcall);
 311       src = &((action->io.surf_io)->stat);
 312       file_stat_copy(src,dst);
 313       break;
 314
 315     case SIMCALL_FILE_UNLINK:
 316       xbt_free(simcall_file_unlink__get__fd(simcall));
 317       simcall_file_unlink__set__result(simcall, 0);
 318       break;
 319
 320     case SIMCALL_FILE_LS:
 321       xbt_dict_foreach((action->io.surf_io)->ls_dict,cursor,key, src){
 322         // if there is a stat we have to duplicate it
 323         if(src){
 324           dst = xbt_new0(s_file_stat_t,1);
 325           file_stat_copy(src, dst);
 326           xbt_dict_set((action->io.surf_io)->ls_dict,key,dst,free_file_stat);
 327         }
 328       }
 329       simcall_file_ls__set__result(simcall, (action->io.surf_io)->ls_dict);
 330       break;
 331
 332     default:
 333       break;
 334     }
 335   }
 336
 337   switch (surf_workstation_model->action_state_get(action->io.surf_io)) {
 338
 339     case SURF_ACTION_FAILED:
 340       action->state = SIMIX_FAILED;
 341       break;
 342
 343     case SURF_ACTION_DONE:
 344       action->state = SIMIX_DONE;
 345       break;
 346
 347     default:
 348       THROW_IMPOSSIBLE;
 349       break;
 350   }
 351
 352   SIMIX_io_finish(action);
 353 }
 354
 355 void SIMIX_io_destroy(smx_action_t action)
 356 {
 357   XBT_DEBUG("Destroy action %p", action);
 358   if (action->io.surf_io)
 359     action->io.surf_io->model_obj->action_unref(action->io.surf_io);
 360   xbt_mallocator_release(simix_global->action_mallocator, action);
 361 }
 362
 363 void SIMIX_io_finish(smx_action_t action)
 364 {
 365   xbt_fifo_item_t item;
 366   smx_simcall_t simcall;
 367
 368   xbt_fifo_foreach(action->simcalls, item, simcall, smx_simcall_t) {
 369
 370     switch (action->state) {
 371
 372       case SIMIX_DONE:
 373         /* do nothing, action done */
 374         break;
 375
 376       case SIMIX_FAILED:
 377         SMX_EXCEPTION(simcall->issuer, io_error, 0, "IO failed");
 378         break;
 379
 380       case SIMIX_CANCELED:
 381         SMX_EXCEPTION(simcall->issuer, cancel_error, 0, "Canceled");
 382         break;
 383
 384       default:
 385         xbt_die("Internal error in SIMIX_io_finish: unexpected action state %d",
 386             (int)action->state);
 387     }
 388
 389     if (surf_workstation_model->extension.
 390         workstation.get_state(simcall->issuer->smx_host) != SURF_RESOURCE_ON) {
 391       simcall->issuer->context->iwannadie = 1;
 392     }
 393
 394     simcall->issuer->waiting_action = NULL;
 395     SIMIX_simcall_answer(simcall);
 396   }
 397
 398   /* We no longer need it */
 399   SIMIX_io_destroy(action);
 400 }