Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cb495f0eef6e6dcf9d7d27777debeb5060982309
[simgrid.git] / src / mc / sosp / Snapshot.cpp
1 /* Copyright (c) 2014-2022. The 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 "src/mc/sosp/Snapshot.hpp"
7 #include "src/mc/mc_config.hpp"
8 #include "src/mc/mc_hash.hpp"
9
10 #include <cstddef> /* std::size_t */
11
12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_snapshot, mc, "Taking and restoring snapshots");
13 namespace simgrid {
14 namespace mc {
15 /************************************* Take Snapshot ************************************/
16 /****************************************************************************************/
17
18 void Snapshot::snapshot_regions(RemoteProcess* process)
19 {
20   snapshot_regions_.clear();
21
22   for (auto const& object_info : process->object_infos)
23     add_region(RegionType::Data, object_info.get(), object_info->start_rw, object_info->end_rw - object_info->start_rw);
24
25   const s_xbt_mheap_t* heap = process->get_heap();
26   void* start_heap = heap->base;
27   void* end_heap   = heap->breakval;
28
29   add_region(RegionType::Heap, nullptr, start_heap, (char*)end_heap - (char*)start_heap);
30   heap_bytes_used_ = mmalloc_get_bytes_used_remote(heap->heaplimit, process->get_malloc_info());
31 }
32
33 /** @brief Checks whether the variable is in scope for a given IP.
34  *
35  *  A variable may be defined only from a given value of IP.
36  *
37  *  @param var   Variable description
38  *  @param scope Scope description
39  *  @param ip    Instruction pointer
40  *  @return      true if the variable is valid
41  * */
42 static bool valid_variable(const simgrid::mc::Variable* var, simgrid::mc::Frame* scope, const void* ip)
43 {
44   // The variable is not yet valid:
45   if (scope->range.begin() + var->start_scope > (std::uint64_t)ip)
46     return false;
47   else
48     return true;
49 }
50
51 static void fill_local_variables_values(mc_stack_frame_t stack_frame, Frame* scope,
52                                         std::vector<s_local_variable_t>& result)
53 {
54   if (not scope || not scope->range.contain(stack_frame->ip))
55     return;
56
57   for (const Variable& current_variable : scope->variables) {
58     if (not valid_variable(&current_variable, scope, (void*)stack_frame->ip))
59       continue;
60
61     if (not current_variable.type) {
62       XBT_VERB("Ignore local variable without type: '%s' [%s]", current_variable.name.c_str(),
63                stack_frame->frame->name.c_str());
64       continue;
65     }
66
67     s_local_variable_t new_var;
68     new_var.subprogram = stack_frame->frame;
69     new_var.ip         = stack_frame->ip;
70     new_var.name       = current_variable.name;
71     new_var.type       = current_variable.type;
72     new_var.address    = nullptr;
73
74     if (current_variable.address != nullptr)
75       new_var.address = current_variable.address;
76     else if (not current_variable.location_list.empty()) {
77       dwarf::Location location = simgrid::dwarf::resolve(current_variable.location_list, current_variable.object_info,
78                                                          &(stack_frame->unw_cursor), (void*)stack_frame->frame_base,
79                                                          &mc_model_checker->get_remote_process());
80
81       xbt_assert(location.in_memory(), "Cannot handle non-address variable");
82       new_var.address = location.address();
83     } else
84       xbt_die("No address");
85
86     result.push_back(std::move(new_var));
87   }
88
89   // Recursive processing of nested scopes:
90   for (Frame& nested_scope : scope->scopes)
91     fill_local_variables_values(stack_frame, &nested_scope, result);
92 }
93
94 static std::vector<s_local_variable_t> get_local_variables_values(std::vector<s_mc_stack_frame_t>& stack_frames)
95 {
96   std::vector<s_local_variable_t> variables;
97   for (s_mc_stack_frame_t& stack_frame : stack_frames)
98     fill_local_variables_values(&stack_frame, stack_frame.frame, variables);
99   return variables;
100 }
101
102 static std::vector<s_mc_stack_frame_t> unwind_stack_frames(UnwindContext* stack_context)
103 {
104   const RemoteProcess* process = &mc_model_checker->get_remote_process();
105   std::vector<s_mc_stack_frame_t> result;
106
107   unw_cursor_t c = stack_context->cursor();
108
109   // TODO, check condition check (unw_init_local==0 means end of frame)
110
111   while (true) {
112     s_mc_stack_frame_t stack_frame;
113
114     stack_frame.unw_cursor = c;
115
116     unw_word_t ip;
117     unw_word_t sp;
118
119     unw_get_reg(&c, UNW_REG_IP, &ip);
120     unw_get_reg(&c, UNW_REG_SP, &sp);
121
122     stack_frame.ip = ip;
123     stack_frame.sp = sp;
124
125     // TODO, use real addresses in frame_t instead of fixing it here
126
127     Frame* frame              = process->find_function(remote(ip));
128     stack_frame.frame         = frame;
129
130     if (frame) {
131       stack_frame.frame_name = frame->name;
132       stack_frame.frame_base = (unw_word_t)frame->frame_base(c);
133     } else {
134       stack_frame.frame_base = 0;
135       stack_frame.frame_name = std::string();
136     }
137
138     result.push_back(std::move(stack_frame));
139
140     /* Stop before context switch with maestro */
141     if (frame != nullptr && frame->name == "smx_ctx_wrapper")
142       break;
143
144     int ret = unw_step(&c);
145     xbt_assert(ret >= 0, "Error while unwinding stack");
146     xbt_assert(ret != 0, "Unexpected end of stack.");
147   }
148
149   xbt_assert(not result.empty(), "unw_init_local failed");
150
151   return result;
152 }
153
154 void Snapshot::snapshot_stacks(RemoteProcess* process)
155 {
156   for (auto const& stack : process->stack_areas()) {
157     s_mc_snapshot_stack_t st;
158
159     // Read the context from remote process:
160     unw_context_t context;
161     process->read_bytes(&context, sizeof(context), remote(stack.context));
162
163     st.context.initialize(process, &context);
164
165     st.stack_frames    = unwind_stack_frames(&st.context);
166     st.local_variables = get_local_variables_values(st.stack_frames);
167
168     unw_word_t sp = st.stack_frames[0].sp;
169
170     stacks_.push_back(std::move(st));
171
172     size_t stack_size = (char*)stack.address + stack.size - (char*)sp;
173     stack_sizes_.push_back(stack_size);
174   }
175 }
176
177 static void snapshot_handle_ignore(Snapshot* snapshot)
178 {
179   xbt_assert(snapshot->get_remote_process());
180
181   // Copy the memory:
182   for (auto const& region : snapshot->get_remote_process()->ignored_regions()) {
183     s_mc_snapshot_ignored_data_t ignored_data;
184     ignored_data.start = (void*)region.addr;
185     ignored_data.data.resize(region.size);
186     // TODO, we should do this once per privatization segment:
187     snapshot->get_remote_process()->read_bytes(ignored_data.data.data(), region.size, remote(region.addr));
188     snapshot->ignored_data_.push_back(std::move(ignored_data));
189   }
190
191   // Zero the memory:
192   for (auto const& region : snapshot->get_remote_process()->ignored_regions())
193     snapshot->get_remote_process()->clear_bytes(remote(region.addr), region.size);
194 }
195
196 static void snapshot_ignore_restore(const simgrid::mc::Snapshot* snapshot)
197 {
198   for (auto const& ignored_data : snapshot->ignored_data_)
199     snapshot->get_remote_process()->write_bytes(ignored_data.data.data(), ignored_data.data.size(),
200                                                 remote(ignored_data.start));
201 }
202
203 Snapshot::Snapshot(long num_state, RemoteProcess* process) : AddressSpace(process), num_state_(num_state)
204 {
205   XBT_DEBUG("Taking snapshot %ld", num_state);
206
207   for (auto const& p : process->actors())
208     enabled_processes_.insert(p.copy.get_buffer()->get_pid());
209
210   snapshot_handle_ignore(this);
211
212   /* Save the std heap and the writable mapped pages of libsimgrid and binary */
213   snapshot_regions(process);
214
215   to_ignore_ = process->ignored_heap();
216
217   if (_sg_mc_max_visited_states > 0 || not _sg_mc_property_file.get().empty()) {
218     snapshot_stacks(process);
219     hash_ = simgrid::mc::hash(*this);
220   }
221
222   snapshot_ignore_restore(this);
223 }
224
225 void Snapshot::add_region(RegionType type, ObjectInformation* object_info, void* start_addr, std::size_t size)
226 {
227   if (type == RegionType::Data)
228     xbt_assert(object_info, "Missing object info for object.");
229   else if (type == RegionType::Heap)
230     xbt_assert(not object_info, "Unexpected object info for heap region.");
231
232   auto* region = new Region(type, start_addr, size);
233   region->object_info(object_info);
234   snapshot_regions_.push_back(std::unique_ptr<Region>(region));
235 }
236
237 void* Snapshot::read_bytes(void* buffer, std::size_t size, RemotePtr<void> address, ReadOptions options) const
238 {
239   const Region* region = this->get_region((void*)address.address());
240   if (region) {
241     void* res = region->read(buffer, (void*)address.address(), size);
242     if (buffer == res || options & ReadOptions::lazy())
243       return res;
244     else {
245       memcpy(buffer, res, size);
246       return buffer;
247     }
248   } else
249     return this->get_remote_process()->read_bytes(buffer, size, address, options);
250 }
251 /** @brief Find the snapshotted region from a pointer
252  *
253  *  @param addr     Pointer
254  * */
255 Region* Snapshot::get_region(const void* addr) const
256 {
257   size_t n = snapshot_regions_.size();
258   for (size_t i = 0; i != n; ++i) {
259     Region* region = snapshot_regions_[i].get();
260     if (not(region && region->contain(simgrid::mc::remote(addr))))
261       continue;
262
263     return region;
264   }
265
266   return nullptr;
267 }
268
269 /** @brief Find the snapshotted region from a pointer, with a hinted_region */
270 Region* Snapshot::get_region(const void* addr, Region* hinted_region) const
271 {
272   if (hinted_region->contain(simgrid::mc::remote(addr)))
273     return hinted_region;
274   else
275     return get_region(addr);
276 }
277
278 void Snapshot::restore(RemoteProcess* process) const
279 {
280   XBT_DEBUG("Restore snapshot %ld", num_state_);
281
282   // Restore regions
283   for (std::unique_ptr<Region> const& region : snapshot_regions_) {
284     if (region) // privatized variables are not snapshotted
285       region.get()->restore();
286   }
287
288   snapshot_ignore_restore(this);
289   process->clear_cache();
290 }
291
292 } // namespace mc
293 } // namespace simgrid