X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0d7bbc539130580c39e12e289255dd6c1ba18bdc..d2c309b44895ebb12bfd4033bdac809e2b5e67e2:/src/xbt/memory_map.cpp

diff --git a/src/xbt/memory_map.cpp b/src/xbt/memory_map.cpp
index 29640c0d26..35dba46d67 100644
--- a/src/xbt/memory_map.cpp
+++ b/src/xbt/memory_map.cpp
@@ -21,15 +21,18 @@
 #include "memory_map.hpp"
 
 extern "C" {
-
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_memory_map, xbt,
-                                "Logging specific to algorithms for memory_map");
-
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_memory_map, xbt, "Logging specific to algorithms for memory_map");
 }
 
 namespace simgrid {
 namespace xbt {
 
+/**
+ * \todo This function contains many cases that do not allow for a
+ *       recovery. Currently, xbt_abort() is called but we should
+ *       much rather die with the specific reason so that it's easier
+ *       to find out what's going on.
+ */
 XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
 {
 #ifdef __linux__
@@ -37,45 +40,48 @@ XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
   /* to be returned. */
   char* path = bprintf("/proc/%i/maps", (int) pid);
   FILE *fp = std::fopen(path, "r");
-  if(fp == NULL)
+  if (fp == nullptr) {
     std::perror("fopen failed");
-  xbt_assert(fp,
-    "Cannot open %s to investigate the memory map of the process.", path);
+    xbt_die("Cannot open %s to investigate the memory map of the process.", path);
+  }
   free(path);
-  setbuf(fp, NULL);
+  setbuf(fp, nullptr);
 
   std::vector<VmMap> ret;
 
   /* Read one line at the time, parse it and add it to the memory map to be returned */
   ssize_t read; /* Number of bytes readed */
-  char* line = NULL;
+  char* line = nullptr;
   std::size_t n = 0; /* Amount of bytes to read by xbt_getline */
   while ((read = xbt_getline(&line, &n, fp)) != -1) {
+    /**
+     * The lines that we read have this format: (This is just an example)
+     * 00602000-00603000 rw-p 00002000 00:28 1837264                            <complete-path-to-file>
+     */
 
     //fprintf(stderr,"%s", line);
 
     /* Wipeout the new line character */
     line[read - 1] = '\0';
 
-    /* Tokenize the line using spaces as delimiters and store each token */
-    /* in lfields array. We expect 5 tokens/fields */
+    /* Tokenize the line using spaces as delimiters and store each token in lfields array. We expect 5 tokens for 6 fields */
     char* lfields[6];
     lfields[0] = strtok(line, " ");
 
     int i;
-    for (i = 1; i < 6 && lfields[i - 1] != NULL; i++) {
-      lfields[i] = std::strtok(NULL, " ");
+    for (i = 1; i < 6 && lfields[i - 1] != nullptr; i++) {
+      lfields[i] = std::strtok(nullptr, " ");
     }
 
     /* Check to see if we got the expected amount of columns */
     if (i < 6)
-      xbt_abort();
+      xbt_die("The memory map apparently only supplied less than 6 columns. Recovery impossible.");
 
     /* Ok we are good enough to try to get the info we need */
     /* First get the start and the end address of the map   */
     char *tok = std::strtok(lfields[0], "-");
-    if (tok == NULL)
-      xbt_abort();
+    if (tok == nullptr)
+      xbt_die("Start and end address of the map are not concatenated by a hyphen (-). Recovery impossible.");
 
     VmMap memreg;
     char *endptr;
@@ -84,8 +90,8 @@ XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
     if (*endptr != '\0')
       xbt_abort();
 
-    tok = std::strtok(NULL, "-");
-    if (tok == NULL)
+    tok = std::strtok(nullptr, "-");
+    if (tok == nullptr)
       xbt_abort();
 
     memreg.end_addr = std::strtoull(tok, &endptr, 16);
@@ -117,11 +123,14 @@ XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
     if (memreg.prot == 0)
       memreg.prot |= PROT_NONE;
 
-    if (lfields[1][4] == 'p')
+    if (lfields[1][3] == 'p') {
       memreg.flags |= MAP_PRIVATE;
-
-    else if (lfields[1][4] == 's')
+    } else {
       memreg.flags |= MAP_SHARED;
+      if (lfields[1][3] != 's')
+	XBT_WARN("The protection is neither 'p' (private) nor 's' (shared) but '%s'. Let's assume shared, as on b0rken win-ubuntu systems.\nFull line: %s\n"
+		 lfields[1], line);
+    }
 
     /* Get the offset value */
     memreg.offset = std::strtoull(lfields[2], &endptr, 16);
@@ -131,7 +140,7 @@ XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
 
     /* Get the device major:minor bytes */
     tok = std::strtok(lfields[3], ":");
-    if (tok == NULL)
+    if (tok == nullptr)
       xbt_abort();
 
     memreg.dev_major = (char) strtoul(tok, &endptr, 16);
@@ -139,8 +148,8 @@ XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
     if (*endptr != '\0')
       xbt_abort();
 
-    tok = std::strtok(NULL, ":");
-    if (tok == NULL)
+    tok = std::strtok(nullptr, ":");
+    if (tok == nullptr)
       xbt_abort();
 
     memreg.dev_minor = (char) std::strtoul(tok, &endptr, 16);
@@ -159,18 +168,16 @@ XBT_PRIVATE std::vector<VmMap> get_memory_map(pid_t pid)
 
     /* Create space for a new map region in the region's array and copy the */
     /* parsed stuff from the temporal memreg variable */
-    XBT_DEBUG("Found region for %s",
-      !memreg.pathname.empty() ? memreg.pathname.c_str() : "(null)");
+    XBT_DEBUG("Found region for %s", !memreg.pathname.empty() ? memreg.pathname.c_str() : "(null)");
 
     ret.push_back(std::move(memreg));
   }
 
   std::free(line);
   std::fclose(fp);
-  return std::move(ret);
+  return ret;
 #else
-  /* On FreeBSD, kinfo_getvmmap() could be used but mmap() support is disabled
-     anyway. */
+  /* On FreeBSD, kinfo_getvmmap() could be used but mmap() support is disabled anyway. */
   xbt_die("Could not get memory map from process %lli", (long long int) pid);
 #endif
 }