ajout tp1

tp/tp1/src/scripts/vmap.py

@@ -0,0 +1,159 @@
+#!/usr/bin/python
+# coding=utf-8
+
+"""Tool to analyze and display the contents of /proc/<pid>/maps"""
+
+import re
+import itertools
+import argparse
+from dataclasses import dataclass
+
+MAPS_LINE_RE = re.compile(r"""
+    (?P<addr_start>[0-9a-f]+)-(?P<addr_end>[0-9a-f]+)\s+  # Address
+    (?P<perms>\S+)\s+                                     # Permissions
+    (?P<offset>[0-9a-f]+)\s+                              # Map offset
+    (?P<dev>\S+)\s+                                       # Device node
+    (?P<inode>\d+)\s+                                     # Inode
+    (?P<pathname>.*)\s+                                   # Pathname
+""", re.VERBOSE)
+
+
+def human_bytes(size):
+    modifier = 1
+    while size > 1024:
+        modifier *= 1024
+        size /= 1024
+    return "%.1f%s" % (size, {
+        1024**0: 'b',
+        1024**1: 'k',
+        1024**2: 'M',
+        1024**3: 'G',
+        1024**4: 'T',
+    }.get(modifier, " x%d" % modifier))
+
+
+@dataclass
+class Record:
+    addr_start: int
+    addr_end: int
+    perms: str
+    offset: int
+    dev: str
+    inode: int
+    pathname: str
+
+    @property
+    def size(self):
+        return self.addr_end - self.addr_start
+
+    @property
+    def human_size(self):
+        return human_bytes(self.size)
+
+    @property
+    def readable(self):
+        return self.perms[0] == "r"
+
+    @property
+    def writable(self):
+        return self.perms[1] == "w"
+
+    @property
+    def executable(self):
+        return self.perms[2] == "x"
+
+    @property
+    def shared(self):
+        return self.perms[3] == "s"
+
+    @property
+    def private(self):
+        return self.perms[3] == "p"
+
+    @classmethod
+    def parse(self, pid):
+        records = []
+        with open("/proc/%d/maps" % pid) as fd:
+            for line in fd:
+                m = MAPS_LINE_RE.match(line)
+                if not m:
+                    print("Skipping: %s" % line)
+                    continue
+                addr_start, addr_end, perms, offset, dev, inode, pathname = m.groups()
+                addr_start = int(addr_start, 16)
+                addr_end = int(addr_end, 16)
+                offset = int(offset, 16)
+                records.append(Record(
+                    addr_start=addr_start,
+                    addr_end=addr_end,
+                    perms=perms,
+                    offset=offset,
+                    dev=dev,
+                    inode=inode,
+                    pathname=pathname,
+                ))
+        return records
+
+    @classmethod
+    def aggregate(self, records, only_used=False, only_private=False):
+
+        named_records = {}
+        anonymous_records = []
+        for record in records:
+            if only_private and not record.private:
+                continue
+            if only_used and not record.readable and not record.writable and not record.shared and not record.pathname:
+                continue
+            if record.pathname:
+                if record.pathname in named_records:
+                    other = named_records[record.pathname]
+                    named_records[record.pathname] = Record(
+                        min(record.addr_start, other.addr_start),
+                        max(record.addr_end, other.addr_end),
+                        perms=''.join("?" if c1 != c2 else c1 for c1, c2 in zip(record.perms, other.perms)),
+                        offset=0,
+                        dev='',
+                        inode='',
+                        pathname=record.pathname,
+                    )
+                else:
+                    named_records[record.pathname] = record
+            else:
+                anonymous_records.append(record)
+
+        return list(sorted(
+            itertools.chain(anonymous_records, named_records.values()),
+            key=lambda r: r.size,
+            reverse=True,
+        ))
+
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("pid", type=int, help="Process identifier (pid)")
+    parser.add_argument("--only-used", "-u", action="store_true", help="Only show used pages (non readable, writable, executable and private pages)")
+    parser.add_argument("--only-private", "-p", action="store_true", help="Only show private pages")
+    args = parser.parse_args()
+
+    records = Record.parse(args.pid)
+    #records = Record.aggregate(records, only_used=args.only_used, only_private=args.only_private)
+
+    print("\t".join([
+        "% 16s" % "Start of range",
+        "% 16s" % "End of range",
+        "% 12s" % "Size",
+        "% 4s" % "Perms",
+        "Path",
+    ]))
+    for record in records:
+        print("\t".join([
+            "%016x" % record.addr_start,
+            "%016x" % record.addr_end,
+            "% 12s" % record.human_size,
+            "% 4s" % record.perms,
+            record.pathname,
+        ]))
+
+    print("")
+    print("Total: %s" % human_bytes(sum(r.size for r in records)))