Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
62bac67f99da308275a05aa5125815ad6b1336c1
[simgrid.git] / src / smpi / internals / smpi_memory.cpp
1 /* Copyright (c) 2015-2017. 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 <cerrno>
7 #include <climits>
8 #include <cstdint>
9 #include <cstdio>
10 #include <cstdlib>
11 #include <cstring>
12 #include <deque>
13 #include <fcntl.h>
14 #include <sys/stat.h>
15 #include <sys/types.h>
16 #include <vector>
17
18 #ifndef WIN32
19 #include <sys/mman.h>
20 #include <unistd.h>
21
22 #include "src/internal_config.h"
23 #include "src/xbt/memory_map.hpp"
24
25 #include "private.hpp"
26 #include "smpi_process.hpp"
27
28 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_memory, smpi, "Memory layout support for SMPI");
29
30 int smpi_loaded_page      = -1;
31 char* smpi_data_exe_start = nullptr;
32 int smpi_data_exe_size    = 0;
33 int smpi_privatize_global_variables;
34 static void* smpi_data_exe_copy;
35
36 // We keep a copy of all the privatization regions: We can then delete everything easily by iterating over this
37 // collection and nothing can be leaked. We could also iterate over all actors but we would have to be diligent when two
38 // actors use the same privatization region (so, smart pointers would have to be used etc.)
39 // Use a std::deque so that pointers remain valid after push_back().
40 static std::deque<s_smpi_privatization_region_t> smpi_privatization_regions;
41
42 static const int PROT_RWX = (PROT_READ | PROT_WRITE | PROT_EXEC);
43 static const int PROT_RW  = (PROT_READ | PROT_WRITE );
44 XBT_ATTRIB_UNUSED static const int PROT_RX  = (PROT_READ | PROT_EXEC );
45
46 void smpi_get_executable_global_size()
47 {
48   char buffer[PATH_MAX];
49   char* full_name = realpath(xbt_binary_name, buffer);
50   if (full_name == nullptr)
51     xbt_die("Could not resolve binary file name");
52
53   std::vector<simgrid::xbt::VmMap> map = simgrid::xbt::get_memory_map(getpid());
54   for (auto i = map.begin(); i != map.end() ; ++i) {
55     // TODO, In practice, this implementation would not detect a completely
56     // anonymous data segment. This does not happen in practice, however.
57
58     // File backed RW entry:
59     if (i->pathname == full_name && (i->prot & PROT_RWX) == PROT_RW) {
60       smpi_data_exe_start = (char*)i->start_addr;
61       smpi_data_exe_size  = i->end_addr - i->start_addr;
62       ++i;
63       /* Here we are making the assumption that a suitable empty region
64          following the rw- area is the end of the data segment. It would
65          be better to check with the size of the data segment. */
66       if (i != map.end() && i->pathname.empty() && (i->prot & PROT_RWX) == PROT_RW &&
67           (char*)i->start_addr == smpi_data_exe_start + smpi_data_exe_size) {
68         smpi_data_exe_size = (char*)i->end_addr - smpi_data_exe_start;
69       }
70       return;
71     }
72   }
73   xbt_die("Did not find my data segment.");
74 }
75 #endif
76
77 #if HAVE_SANITIZE_ADDRESS
78 #include <sanitizer/asan_interface.h>
79 static void* asan_safe_memcpy(void* dest, void* src, size_t n)
80 {
81   char* psrc  = static_cast<char*>(src);
82   char* pdest = static_cast<char*>(dest);
83   for (size_t i = 0; i < n;) {
84     while (i < n && __asan_address_is_poisoned(psrc + i))
85       ++i;
86     if (i < n) {
87       char* p  = static_cast<char*>(__asan_region_is_poisoned(psrc + i, n - i));
88       size_t j = p ? (p - psrc) : n;
89       memcpy(pdest + i, psrc + i, j - i);
90       i = j;
91     }
92   }
93   return dest;
94 }
95 #else
96 #define asan_safe_memcpy(dest, src, n) memcpy(dest, src, n)
97 #endif
98
99 /** Map a given SMPI privatization segment (make a SMPI process active) */
100 void smpi_switch_data_segment(int dest) {
101   if (smpi_loaded_page == dest)//no need to switch, we've already loaded the one we want
102     return;
103
104   // So the job:
105   smpi_really_switch_data_segment(dest);
106 }
107
108 /** Map a given SMPI privatization segment (make a SMPI process active)  even if SMPI thinks it is already active
109  *
110  *  When doing a state restoration, the state of the restored variables  might not be consistent with the state of the
111  *  virtual memory. In this case, we to change the data segment.
112  */
113 void smpi_really_switch_data_segment(int dest)
114 {
115   if (smpi_data_exe_size == 0) // no need to switch
116     return;
117
118 #if HAVE_PRIVATIZATION
119   // FIXME, cross-process support (mmap across process when necessary)
120   simgrid::smpi::Process* process = smpi_process_remote(dest);
121   int current                     = process->privatized_region()->file_descriptor;
122   XBT_DEBUG("Switching data frame to the one of process %d", dest);
123   void* tmp =
124       mmap(TOPAGE(smpi_data_exe_start), smpi_data_exe_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, current, 0);
125   if (tmp != TOPAGE(smpi_data_exe_start))
126     xbt_die("Couldn't map the new region (errno %d): %s", errno, strerror(errno));
127   smpi_loaded_page = dest;
128 #endif
129 }
130
131 int smpi_is_privatization_file(char* file)
132 {
133   const std::string buffer_path("/dev/shm/my-buffer-");
134   return buffer_path.compare(0, std::string::npos, file, buffer_path.length()) == 0;
135 }
136
137 /**
138  * @brief Makes a backup of the segment in memory that stores the global variables of a process.
139  *        This backup is then used to initialize the global variables for every single
140  *        process that is added, regardless of the progress of the simulation.
141  */
142 void smpi_backup_global_memory_segment()
143 {
144 #if HAVE_PRIVATIZATION
145   smpi_get_executable_global_size();
146
147   XBT_DEBUG("bss+data segment found : size %d starting at %p", smpi_data_exe_size, smpi_data_exe_start);
148
149   if (smpi_data_exe_size == 0) { // no need to do anything as global variables don't exist
150     smpi_privatize_global_variables=false;
151     return;
152   }
153
154   smpi_data_exe_copy = ::operator new(smpi_data_exe_size);
155   // Make a copy of the data segment. This clean copy is retained over the whole runtime
156   // of the simulation and can be used to initialize a dynamically added, new process.
157   asan_safe_memcpy(smpi_data_exe_copy, TOPAGE(smpi_data_exe_start), smpi_data_exe_size);
158 #else /* ! HAVE_PRIVATIZATION */
159   smpi_privatize_global_variables = false;
160   xbt_die("You are trying to use privatization on a system that does not support it. Don't.");
161   return;
162 #endif
163 }
164
165 // Initializes the memory mapping for a single process and returns the privatization region
166 smpi_privatization_region_t smpi_init_global_memory_segment_process()
167 {
168   int file_descriptor;
169   void* address = nullptr;
170   char path[24];
171   int status;
172
173   do {
174     snprintf(path, sizeof(path), "/smpi-buffer-%06x", rand() % 0xffffffU);
175     file_descriptor = shm_open(path, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
176   } while (file_descriptor == -1 && errno == EEXIST);
177   if (file_descriptor < 0) {
178     if (errno == EMFILE) {
179       xbt_die("Impossible to create temporary file for memory mapping: %s\n\
180 The open() system call failed with the EMFILE error code (too many files). \n\n\
181 This means that you reached the system limits concerning the amount of files per process. \
182 This is not a surprise if you are trying to virtualize many processes on top of SMPI. \
183 Don't panic -- you should simply increase your system limits and try again. \n\n\
184 First, check what your limits are:\n\
185   cat /proc/sys/fs/file-max # Gives you the system-wide limit\n\
186   ulimit -Hn                # Gives you the per process hard limit\n\
187   ulimit -Sn                # Gives you the per process soft limit\n\
188   cat /proc/self/limits     # Displays any per-process limitation (including the one given above)\n\n\
189 If one of these values is less than the amount of MPI processes that you try to run, then you got the explanation of this error. \
190 Ask the Internet about tutorials on how to increase the files limit such as: https://rtcamp.com/tutorials/linux/increase-open-files-limit/",
191               strerror(errno));
192     }
193     xbt_die("Impossible to create temporary file for memory mapping: %s", strerror(errno));
194   }
195
196   status = ftruncate(file_descriptor, smpi_data_exe_size);
197   if (status)
198     xbt_die("Impossible to set the size of the temporary file for memory mapping");
199
200   /* Ask for a free region */
201   address = mmap(nullptr, smpi_data_exe_size, PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);
202   if (address == MAP_FAILED)
203     xbt_die("Couldn't find a free region for memory mapping");
204
205   status = shm_unlink(path);
206   if (status)
207     xbt_die("Impossible to unlink temporary file for memory mapping");
208
209   // initialize the values
210   asan_safe_memcpy(address, smpi_data_exe_copy, smpi_data_exe_size);
211
212   // store the address of the mapping for further switches
213   smpi_privatization_regions.emplace_back(s_smpi_privatization_region_t{address, file_descriptor});
214
215   return &smpi_privatization_regions.back();
216 }
217
218 void smpi_destroy_global_memory_segments(){
219   if (smpi_data_exe_size == 0) // no need to switch
220     return;
221 #if HAVE_PRIVATIZATION
222   for (auto const& region : smpi_privatization_regions) {
223     if (munmap(region.address, smpi_data_exe_size) < 0)
224       XBT_WARN("Unmapping of fd %d failed: %s", region.file_descriptor, strerror(errno));
225     close(region.file_descriptor);
226   }
227   smpi_privatization_regions.clear();
228   ::operator delete(smpi_data_exe_copy);
229 #endif
230 }
231