memtrack/memarea.py at master · py06/memtrack · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#-*- coding: utf-8 -*-
import struct
import os
from page import page

class memarea:
    def __init__(self, area_id, base, end, perm, inode, name, offset, major, minor):
        self.name = name
        self.area_id = area_id
        self.base = base
        self.end = end
        self.perm = perm
        self.inode = inode
        self.offset = offset
        self.dev_maj = major
        self.dev_min = minor

    def is_contained(self, address):
	    if int(self.base, 16) <= int(address, 16) and\
			    int(self.end, 16) > int(address, 16):
		    return True
	    return False

    def get_size(self):
        return self.end - self.base

    def get_base(self):
        return self.base

    def get_end(self):
        return self.end

    def get_perm(self):
        return self.perm

    def get_perm_readable(self):
        str = ""
        if (self.perm[0] == 'r'):
            str = "VM_READ | "
        if (self.perm[1] == 'w'):
            str += "VM_WRITE | "
        if (self.perm[2] == 'x'):
            str += "VM_EXEC | "
        if (self.perm[3] == 'p'):
            str += "VM_PRIVATE"
        return str

    def get_size(self):
        return int(self.end, 16) - int(self.base, 16)

    def get_inode(self):
        return self.inode

    def get_name(self):
        return self.name

    def get_area_id(self):
        return self.area_id

    def set_area_id(self, aid):
        self.area_id = aid

    def get_offset(self):
        return self.offset

    def get_device(self):
        return self.major+":"+self.minor

    def find_pages(self, pid, addr, size):
        pagesize = os.sysconf("SC_PAGE_SIZE")
	pages = self.find_area_pages(pid, int(addr, 16), max(1, int(size) / pagesize))
	found = []
	for i in range(len(pages)):
	    if pages[i].is_contained(addr):
		found.append(pages[i])
		count = int(size) / pagesize
		for j in range(i, i+count):
	            if pages[j].is_contained(addr):
		        found.append(pages[j])
		break;
	return found

    def find_area_pages(self, pid, start, count):
        pagemap = []
        pagesize = os.sysconf("SC_PAGE_SIZE")
	offset  = (start / pagesize) * 8
        with open("/proc/"+pid+"/pagemap", 'rb') as file:
		file.seek(offset, 0)
		for i in range(0, count):
			entry = struct.unpack('Q', file.read(8))[0]
			if not entry:
			    break
                        p = page(entry, start+(i*pagesize))
                        if start + (i*pagesize) >= int(self.end, 16):
                            print "Requesting page outside of memory area"
	                pagemap.append(p)
        return pagemap

    def dump_pages(self, pid, offset=0, count=1):
        pagesize = os.sysconf("SC_PAGE_SIZE")
        pages = self.find_area_pages(pid, int(self.base, 16)+(offset*pagesize)\
                , count)
        self.display()
        for i in range(len(pages)):
            pages[i].display()

    def display(self, short=True):
        if short == True:
            if self.name != "":
                print "{} - @{} (sz={}) perm={} name={}".format(self.area_id,
                    self.base, self.get_size(), self.perm, self.name)
            else:
                print "{} - @{} (sz={}) perm={}".format(self.area_id,
                    self.base, self.get_size(), self.perm)
        else:
            print self.area_id+" Memory range: base = @"+self.get_base()+" (sz="+\
                    str(self.get_size())+")"
	    print "	 permission = "+self.get_perm_readable()+" inode = "+\
                    self.get_inode()+" name = "+self.name