Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
b6721f6d2e3f2d8b2e92249c960465cbdccabb0c
[simgrid.git] / src / mc / mc_checkpoint.c
1 /* Copyright (c) 2008-2012 Da SimGrid Team. All rights reserved.            */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include <libgen.h>
7 #include "mc_private.h"
8 #include "xbt/module.h"
9
10 #include "../simix/smx_private.h"
11
12 #include <libunwind.h>
13
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_checkpoint, mc,
15                                 "Logging specific to mc_checkpoint");
16
17 void *start_text_libsimgrid;
18 void *start_plt_libsimgrid, *end_plt_libsimgrid;
19 void *start_plt_binary, *end_plt_binary;
20 char *libsimgrid_path;
21 void *start_data_libsimgrid;
22 void *start_text_binary;
23 void *end_raw_heap;
24
25 static mc_mem_region_t MC_region_new(int type, void *start_addr, size_t size);
26 static void MC_region_restore(mc_mem_region_t reg);
27 static void MC_region_destroy(mc_mem_region_t reg);
28
29 static void MC_snapshot_add_region(mc_snapshot_t snapshot, int type, void *start_addr, size_t size);
30
31 static void add_value(xbt_dynar_t *list, const char *type, unsigned long int val);
32 static xbt_dynar_t take_snapshot_stacks(void *heap);
33 static xbt_strbuff_t get_local_variables_values(void *stack_context, void *heap);
34 static void print_local_variables_values(xbt_dynar_t all_variables);
35 static void *get_stack_pointer(void *stack_context, void *heap);
36
37 static void snapshot_stack_free(mc_snapshot_stack_t s);
38
39 static mc_mem_region_t MC_region_new(int type, void *start_addr, size_t size)
40 {
41   mc_mem_region_t new_reg = xbt_new0(s_mc_mem_region_t, 1);
42   new_reg->type = type;
43   new_reg->start_addr = start_addr;
44   new_reg->size = size;
45   new_reg->data = xbt_malloc0(size);
46   memcpy(new_reg->data, start_addr, size);
47
48   XBT_DEBUG("New region : type : %d, data : %p, size : %zu", type, new_reg->data, size);
49   
50   return new_reg;
51 }
52
53 static void MC_region_restore(mc_mem_region_t reg)
54 {
55   /*FIXME: check if start_addr is still mapped, if it is not, then map it
56     before copying the data */
57  
58   memcpy(reg->start_addr, reg->data, reg->size);
59  
60   return;
61 }
62
63 static void MC_region_destroy(mc_mem_region_t reg)
64 {
65   xbt_free(reg->data);
66   xbt_free(reg);
67 }
68
69 static void MC_snapshot_add_region(mc_snapshot_t snapshot, int type, void *start_addr, size_t size)
70 {
71   mc_mem_region_t new_reg = MC_region_new(type, start_addr, size);
72   snapshot->regions = xbt_realloc(snapshot->regions, (snapshot->num_reg + 1) * sizeof(mc_mem_region_t));
73   snapshot->regions[snapshot->num_reg] = new_reg;
74   snapshot->num_reg++;
75   return;
76
77
78 void MC_take_snapshot(mc_snapshot_t snapshot)
79 {
80   unsigned int i = 0;
81   s_map_region_t reg;
82   memory_map_t maps = get_memory_map();
83
84   /* Save the std heap and the writable mapped pages of libsimgrid */
85   while (i < maps->mapsize) {
86     reg = maps->regions[i];
87     if ((reg.prot & PROT_WRITE)){
88       if (maps->regions[i].pathname == NULL){
89         if (reg.start_addr == std_heap){ // only save the std heap (and not the raw one)
90           MC_snapshot_add_region(snapshot, 0, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
91         }
92         i++;
93       } else {
94         if (!memcmp(basename(maps->regions[i].pathname), "libsimgrid", 10)){
95           MC_snapshot_add_region(snapshot, 1, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
96           i++;
97           reg = maps->regions[i];
98           while(reg.pathname == NULL && (reg.prot & PROT_WRITE) && i < maps->mapsize){
99             MC_snapshot_add_region(snapshot, 1, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
100             i++;
101             reg = maps->regions[i];
102           }
103         }else{
104           i++;
105         } 
106       }
107     }else{
108       i++;
109     }
110   }
111
112   free_memory_map(maps);
113 }
114
115 mc_snapshot_t MC_take_snapshot_liveness()
116 {
117
118   raw_mem_set = (mmalloc_get_current_heap() == raw_heap);
119
120   MC_SET_RAW_MEM;
121
122   mc_snapshot_t snapshot = xbt_new0(s_mc_snapshot_t, 1);
123
124   unsigned int i = 0;
125   s_map_region_t reg;
126   memory_map_t maps = get_memory_map();
127   int nb_reg = 0;
128   void *heap = NULL;
129
130   /* Save the std heap and the writable mapped pages of libsimgrid */
131   while (i < maps->mapsize) {
132     reg = maps->regions[i];
133     if ((reg.prot & PROT_WRITE)){
134       if (maps->regions[i].pathname == NULL){
135         if (reg.start_addr == std_heap){ // only save the std heap (and not the raw one)
136           MC_snapshot_add_region(snapshot, 0, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
137           heap = snapshot->regions[nb_reg]->data;
138           nb_reg++;
139         }else if(reg.start_addr == raw_heap){
140           end_raw_heap = reg.end_addr;
141         }
142         i++;
143       } else {
144         if (!memcmp(basename(maps->regions[i].pathname), "libsimgrid", 10)){
145           MC_snapshot_add_region(snapshot, 1, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
146           start_data_libsimgrid = reg.start_addr;
147           nb_reg++;
148           i++;
149           reg = maps->regions[i];
150           while(reg.pathname == NULL && (reg.prot & PROT_WRITE) && i < maps->mapsize){
151             MC_snapshot_add_region(snapshot, 1, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
152             i++;
153             reg = maps->regions[i];
154             nb_reg++;
155           }
156         } else {
157           if (!memcmp(basename(maps->regions[i].pathname), basename(xbt_binary_name), strlen(basename(xbt_binary_name)))){
158             MC_snapshot_add_region(snapshot, 2, reg.start_addr, (char*)reg.end_addr - (char*)reg.start_addr);
159             nb_reg++;
160           }
161           i++;
162         }
163       }
164     }else if ((reg.prot & PROT_READ)){
165       if (maps->regions[i].pathname != NULL){
166         if (!memcmp(basename(maps->regions[i].pathname), "libsimgrid", 10)){
167           start_text_libsimgrid = reg.start_addr;
168           libsimgrid_path = strdup(maps->regions[i].pathname);
169         }else{
170           if (!memcmp(basename(maps->regions[i].pathname), basename(xbt_binary_name), strlen(basename(xbt_binary_name)))){
171             start_text_binary = reg.start_addr;
172           }
173         }
174       }
175       i++;
176     }else{
177       i++;
178     }
179   }
180
181   snapshot->stacks = take_snapshot_stacks(heap);
182   
183   free_memory_map(maps);
184
185   MC_UNSET_RAW_MEM;
186
187   if(raw_mem_set)
188     MC_SET_RAW_MEM;
189
190   return snapshot;
191
192 }
193
194 void MC_restore_snapshot(mc_snapshot_t snapshot)
195 {
196   unsigned int i;
197   for(i=0; i < snapshot->num_reg; i++){
198     MC_region_restore(snapshot->regions[i]);
199   }
200
201 }
202
203 void MC_free_snapshot(mc_snapshot_t snapshot)
204 {
205   unsigned int i;
206   for(i=0; i < snapshot->num_reg; i++)
207     MC_region_destroy(snapshot->regions[i]);
208
209   xbt_dynar_free(&(snapshot->stacks));
210   xbt_free(snapshot);
211 }
212
213
214 void get_libsimgrid_plt_section(){
215
216   FILE *fp;
217   char *line = NULL;            /* Temporal storage for each line that is readed */
218   ssize_t read;                 /* Number of bytes readed */
219   size_t n = 0;                 /* Amount of bytes to read by getline */
220
221   char *lfields[7];
222   int i, plt_not_found = 1;
223   unsigned long int size, offset;
224
225   if(libsimgrid_path == NULL)
226     libsimgrid_path = get_libsimgrid_path();
227
228   char *command = bprintf("objdump --section-headers %s", libsimgrid_path);
229
230   fp = popen(command, "r");
231
232   if(fp == NULL)
233     perror("popen failed");
234
235   while ((read = getline(&line, &n, fp)) != -1 && plt_not_found == 1) {
236
237     if(n == 0)
238       continue;
239
240     /* Wipeout the new line character */
241     line[read - 1] = '\0';
242
243     lfields[0] = strtok(line, " ");
244
245     if(lfields[0] == NULL)
246       continue;
247
248     if(strcmp(lfields[0], "Sections:") == 0 || strcmp(lfields[0], "Idx") == 0 || strncmp(lfields[0], libsimgrid_path, strlen(libsimgrid_path)) == 0)
249       continue;
250
251     for (i = 1; i < 7 && lfields[i - 1] != NULL; i++) {
252       lfields[i] = strtok(NULL, " ");
253     }
254
255     if(i>=6){
256       if(strcmp(lfields[1], ".plt") == 0){
257         size = strtoul(lfields[2], NULL, 16);
258         offset = strtoul(lfields[5], NULL, 16);
259         start_plt_libsimgrid = (char *)start_text_libsimgrid + offset;
260         end_plt_libsimgrid = (char *)start_plt_libsimgrid + size;
261         plt_not_found = 0;
262       }
263     }
264     
265   }
266
267   free(command);
268   free(line);
269   pclose(fp);
270
271 }
272
273 void get_binary_plt_section(){
274
275   FILE *fp;
276   char *line = NULL;            /* Temporal storage for each line that is readed */
277   ssize_t read;                 /* Number of bytes readed */
278   size_t n = 0;                 /* Amount of bytes to read by getline */
279
280   char *lfields[7];
281   int i, plt_not_found = 1;
282   unsigned long int size, offset;
283
284   char *command = bprintf( "objdump --section-headers %s", xbt_binary_name);
285
286   fp = popen(command, "r");
287
288   if(fp == NULL)
289     perror("popen failed");
290
291   while ((read = getline(&line, &n, fp)) != -1 && plt_not_found == 1) {
292
293     if(n == 0)
294       continue;
295
296     /* Wipeout the new line character */
297     line[read - 1] = '\0';
298
299     lfields[0] = strtok(line, " ");
300
301     if(lfields[0] == NULL)
302       continue;
303
304     if(strcmp(lfields[0], "Sections:") == 0 || strcmp(lfields[0], "Idx") == 0 || strncmp(lfields[0], basename(xbt_binary_name), strlen(xbt_binary_name)) == 0)
305       continue;
306
307     for (i = 1; i < 7 && lfields[i - 1] != NULL; i++) {
308       lfields[i] = strtok(NULL, " ");
309     }
310
311     if(i>=6){
312       if(strcmp(lfields[1], ".plt") == 0){
313         size = strtoul(lfields[2], NULL, 16);
314         offset = strtoul(lfields[5], NULL, 16);
315         start_plt_binary = (char *)start_text_binary + offset;
316         end_plt_binary = (char *)start_plt_binary + size;
317         plt_not_found = 0;
318       }
319     }
320     
321     
322   }
323
324   free(command);
325   free(line);
326   pclose(fp);
327
328 }
329
330 static void add_value(xbt_dynar_t *list, const char *type, unsigned long int val){
331   variable_value_t value = xbt_new0(s_variable_value_t, 1);
332   value->type = strdup(type);
333   if(strcmp(type, "value") == 0){
334     value->value.res = val;
335   }else{
336     value->value.address = (void *)val;
337   }
338   xbt_dynar_push(*list, &value);
339 }
340
341 static xbt_dynar_t take_snapshot_stacks(void *heap){
342
343   xbt_dynar_t res = xbt_dynar_new(sizeof(s_mc_snapshot_stack_t), NULL);
344
345   unsigned int cursor1 = 0;
346   stack_region_t current_stack;
347   
348   xbt_dynar_foreach(stacks_areas, cursor1, current_stack){
349     mc_snapshot_stack_t st = xbt_new(s_mc_snapshot_stack_t, 1);
350     st->local_variables = get_local_variables_values(current_stack->context, heap);
351     st->stack_pointer = get_stack_pointer(current_stack->context, heap);
352     xbt_dynar_push(res, &st);
353   }
354
355   return res;
356
357 }
358
359 static void *get_stack_pointer(void *stack_context, void *heap){
360
361   unw_cursor_t c;
362   int ret;
363   unw_word_t sp;
364
365   ret = unw_init_local(&c, (unw_context_t *)stack_context);
366   if(ret < 0){
367     XBT_INFO("unw_init_local failed");
368     xbt_abort();
369   }
370
371   unw_get_reg(&c, UNW_REG_SP, &sp);
372
373   return ((char *)heap + (size_t)(((char *)((long)sp) - (char*)std_heap)));
374
375 }
376
377 static xbt_strbuff_t get_local_variables_values(void *stack_context, void *heap){
378   
379   unw_cursor_t c;
380   int ret;
381   //char *stack_name;
382
383   char frame_name[256];
384   
385   ret = unw_init_local(&c, (unw_context_t *)stack_context);
386   if(ret < 0){
387     XBT_INFO("unw_init_local failed");
388     xbt_abort();
389   }
390
391   //stack_name = strdup(((smx_process_t)((smx_ctx_sysv_t)(stack->address))->super.data)->name);
392
393   unw_word_t ip, sp, off;
394   dw_frame_t frame;
395  
396   xbt_dynar_t compose = xbt_dynar_new(sizeof(variable_value_t), NULL);
397
398   xbt_strbuff_t variables = xbt_strbuff_new();
399   xbt_dict_cursor_t dict_cursor;
400   char *variable_name;
401   dw_local_variable_t current_variable;
402   unsigned int cursor = 0, cursor2 = 0;
403   dw_location_entry_t entry = NULL;
404   dw_location_t location_entry = NULL;
405   unw_word_t res;
406   int frame_found = 0;
407   void *frame_pointer_address = NULL;
408   long true_ip;
409
410   while(ret >= 0){
411
412     unw_get_reg(&c, UNW_REG_IP, &ip);
413     unw_get_reg(&c, UNW_REG_SP, &sp);
414
415     unw_get_proc_name (&c, frame_name, sizeof (frame_name), &off);
416
417     xbt_strbuff_append(variables, bprintf("ip=%s\n", frame_name));
418
419     frame = xbt_dict_get_or_null(mc_local_variables, frame_name);
420
421     if(frame == NULL){
422       ret = unw_step(&c);
423       continue;
424     }
425
426     true_ip = (long)frame->low_pc + (long)off;
427
428     /* Get frame pointer */
429     switch(frame->frame_base->type){
430     case e_dw_loclist:
431       while((cursor < xbt_dynar_length(frame->frame_base->location.loclist)) && frame_found == 0){
432         entry = xbt_dynar_get_as(frame->frame_base->location.loclist, cursor, dw_location_entry_t);
433         if((true_ip >= entry->lowpc) && (true_ip < entry->highpc)){
434           frame_found = 1;
435           switch(entry->location->type){
436           case e_dw_compose:
437             xbt_dynar_reset(compose);
438             cursor2 = 0;
439             while(cursor2 < xbt_dynar_length(entry->location->location.compose)){
440               location_entry = xbt_dynar_get_as(entry->location->location.compose, cursor2, dw_location_t);
441               switch(location_entry->type){
442               case e_dw_register:
443                 unw_get_reg(&c, location_entry->location.reg, &res);
444                 add_value(&compose, "address", (long)res);
445                 break;
446               case e_dw_bregister_op:
447                 unw_get_reg(&c, location_entry->location.breg_op.reg, &res);
448                 add_value(&compose, "address", (long)res + location_entry->location.breg_op.offset);
449                 break;
450               default:
451                 xbt_dynar_reset(compose);
452                 break;
453               }
454               cursor2++;
455             }
456
457             if(xbt_dynar_length(compose) > 0){
458               frame_pointer_address = xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.address ; 
459             }
460             break;
461           default :
462             frame_pointer_address = NULL;
463             break;
464           }
465         }
466         cursor++;
467       }
468       break;
469     default :
470       frame_pointer_address = NULL;
471       break;
472     }
473
474     frame_found = 0;
475     cursor = 0;
476
477     //XBT_INFO("Frame %s", frame->name);
478
479     xbt_dict_foreach(frame->variables, dict_cursor, variable_name, current_variable){
480       if(current_variable->location != NULL){
481         switch(current_variable->location->type){
482         case e_dw_compose:
483           xbt_dynar_reset(compose);
484           cursor = 0;
485           while(cursor < xbt_dynar_length(current_variable->location->location.compose)){
486             location_entry = xbt_dynar_get_as(current_variable->location->location.compose, cursor, dw_location_t);
487             switch(location_entry->type){
488             case e_dw_register:
489               unw_get_reg(&c, location_entry->location.reg, &res);
490               add_value(&compose, "value", (long)res);
491               break;
492             case e_dw_bregister_op:
493               unw_get_reg(&c, location_entry->location.breg_op.reg, &res);
494               add_value(&compose, "address", (long)res + location_entry->location.breg_op.offset);
495               break;
496             case e_dw_fbregister_op:
497               if(frame_pointer_address != NULL)
498                 add_value(&compose, "address", (long)((char *)frame_pointer_address + location_entry->location.fbreg_op));
499               break;
500             default:
501               xbt_dynar_reset(compose);
502               break;
503             }
504             cursor++;
505           }
506           
507           if(xbt_dynar_length(compose) > 0){
508             if(strcmp(xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->type, "value") == 0){
509               //XBT_INFO("Variable : %s - value : %lx", current_variable->name, xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.res);
510               xbt_strbuff_append(variables, bprintf("%s=%lx\n", current_variable->name, xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.res));
511             }else{
512               if(*((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1,variable_value_t)->value.address) == NULL){
513                 //XBT_INFO("Variable : %s - address : NULL", current_variable->name);
514                 xbt_strbuff_append(variables, bprintf("%s=NULL\n", current_variable->name));
515               }else if(((long)*((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1,variable_value_t)->value.address) > 0xffffffff) || ((long)*((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1,variable_value_t)->value.address) < (long)start_text_binary)){
516                 //XBT_INFO("Variable : %s - value : %zd", current_variable->name, (size_t)*((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.address));
517                 xbt_strbuff_append(variables, bprintf("%s=%zd\n", current_variable->name, (size_t)*((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.address)));
518               }else{
519                 //XBT_INFO("Variable : %s - address : %p", current_variable->name, *((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.address));  
520                 xbt_strbuff_append(variables, bprintf("%s=%p\n", current_variable->name, *((void**)xbt_dynar_get_as(compose, xbt_dynar_length(compose) - 1, variable_value_t)->value.address)));
521               }
522             }
523           }else{
524             //XBT_INFO("Variable %s undefined", current_variable->name);
525             xbt_strbuff_append(variables, bprintf("%s=undefined\n", current_variable->name));
526           }
527           break;
528         default :
529           break;
530         }
531       }else{
532         //XBT_INFO("Variable : %s, no location", current_variable->name);
533         xbt_strbuff_append(variables, bprintf("%s=undefined\n", current_variable->name));
534       }
535     }    
536  
537     ret = unw_step(&c);
538
539     //XBT_INFO(" ");
540      
541   }
542
543   //free(stack_name);
544
545   return variables;
546
547 }
548
549 static void print_local_variables_values(xbt_dynar_t all_variables){
550
551   unsigned cursor = 0;
552   mc_snapshot_stack_t stack;
553
554   xbt_dynar_foreach(all_variables, cursor, stack){
555     XBT_INFO("%s", stack->local_variables->data);
556   }
557 }
558
559
560 static void snapshot_stack_free(mc_snapshot_stack_t s){
561   if(s){
562     xbt_free(s->local_variables->data);
563     xbt_free(s->local_variables);
564     xbt_free(s);
565   }
566 }
567
568 void snapshot_stack_free_voidp(void *s){
569   snapshot_stack_free((mc_snapshot_stack_t) * (void **) s);
570 }