fork/m-overlay

git clone https://git.julia.blue/fork/m-overlay

blackops7799Backport the linux memory manager4b06a2a

gui
5.9 KiB253 linesraw
1local ffi = require("ffi")
2local log = require("log")
3
4local format = string.format
5local sub = string.sub
6
7local cast = ffi.cast
8local cdef = ffi.cdef
9local load = ffi.load
10local metatype = ffi.metatype
11local new = ffi.new
12local typeof = ffi.typeof
13local sizeof = ffi.sizeof
14local string = ffi.string
15local errno = ffi.errno
16
17local lshift = bit.lshift
18local rshift = bit.rshift
19local bswap = bit.bswap
20local band = bit.band
21local bor = bit.bor
22
23local libc = ffi.C
24
25cdef [[
26char *strerror(int errnum);
27
28typedef signed int pid_t;
29
30typedef struct {
31	pid_t pid;
32	unsigned __int64  dolphin_base_addr;
33} MEMORY_STRUCT;
34
35typedef struct {
36	void *iov_base;	/* pointer to start of buffer */
37	size_t iov_len;	/* size of buffer in bytes */
38} iovec;
39
40int process_vm_readv(pid_t pid,
41						 iovec *local_iov,
42						 unsigned long liovcnt,
43						 iovec *remote_iov,
44						 unsigned long riovcnt,
45						 unsigned long flags);
46
47int process_vm_writev(pid_t pid,
48						  iovec *local_iov,
49						  unsigned long liovcnt,
50						  iovec *remote_iov,
51						  unsigned long riovcnt,
52						  unsigned long flags);
53
54typedef unsigned short ino_t; 	   /* i-node number */
55typedef unsigned long  off_t;	   /* offset within a file */
56
57typedef struct {
58	ino_t          d_ino;       /* Inode number */
59	off_t          d_off;       /* Not an offset; see below */
60	unsigned short d_reclen;    /* Length of this record */
61	unsigned char  d_type;      /* Type of file; not supported
62								  by all filesystem types */
63	char           name[256];   /* Null-terminated filename */
64} dirent;
65typedef struct __dirstream DIR;
66
67int access(const char *path, int amode);
68DIR *opendir(const char *name);
69int closedir(DIR *dirp);
70dirent *readdir(DIR *dirp);
71]]
72
73local MEMORY = {}
74MEMORY.__index = MEMORY
75MEMORY.init = metatype("MEMORY_STRUCT", MEMORY)
76
77function MEMORY:findprocess(name)
78	if self:hasProcess() then return false end
79
80	local dir = libc.opendir("/proc/")
81
82	if dir == nil then
83		local message = string(libc.strerror(errno()))
84		error("error opening directory /proc/: " .. message)
85	else
86		local entry
87		while true do
88			entry = libc.readdir(dir)
89			if entry == nil then break end -- end of list
90			local pid = string(entry.name)
91			local f = io.open("/proc/" .. pid .. "/comm")
92			if f then
93				local line = f:read("*line")
94				if line == "dolphin-emu" or line == "dolphin-emu-qt2" or line == "dolphin-emu-wx" then
95					self.pid = tonumber(pid)
96				end
97				f:close()
98			end
99		end
100		libc.closedir(dir)
101	end
102
103	return self:hasProcess()
104end
105
106function MEMORY:isProcessActive()
107	if self.pid ~= 0 then
108		return libc.access("/proc/" .. self.pid, 0) == 0
109	end
110	return false
111end
112
113function MEMORY:hasProcess()
114	return self.pid ~= 0
115end
116
117function MEMORY:hasGamecubeRAMOffset()
118	return self.dolphin_base_addr ~= 0
119end
120
121function MEMORY:close()
122	if self:hasProcess() then
123		self.pid = 0
124		self.dolphin_base_addr = 0
125	end
126end
127
128function MEMORY:__gc()
129	self:close()
130end
131
132function MEMORY:findGamecubeRAMOffset()
133	if self:hasProcess() then
134		local f = io.open("/proc/" .. self.pid .. "/maps")
135		if f then
136			local line
137			while true do
138				line = f:read("*line")
139				if not line then break end -- EOF
140				if #line > 74 then
141					if sub(line, 74, 74 + 18) == "/dev/shm/dolphinmem" or sub(line, 74, 74 + 19) == "/dev/shm/dolphin-emu" then
142						local startAddr, endAddr = line:match("^(%x-)%-(%x-)%s")
143						if startAddr and endAddr then
144							-- Convert hex values to number
145							startAddr = tonumber(startAddr, 16)
146							endAddr = tonumber(endAddr, 16)
147							if (endAddr - startAddr) == 0x2000000 then
148								self.dolphin_base_addr = startAddr
149								log.debug("Gamecube memory found: %08X", tonumber(self.dolphin_base_addr))
150								f:close()
151								return true
152							end
153						end
154					end
155				end
156			end
157			f:close()
158		end
159	end
160
161	return false
162end
163
164local function read(mem, addr, output, size)
165	local localvec = new("iovec[1]")
166	local remotevec = new("iovec[1]")
167
168	local ramaddr = mem.dolphin_base_addr + (addr % 0x80000000)	
169
170	localvec[0].iov_base = output
171	localvec[0].iov_len = size
172
173	remotevec[0].iov_base = cast("void*", ramaddr)
174	remotevec[0].iov_len = size
175
176	local read = libc.process_vm_readv(mem.pid, localvec, 1, remotevec, 1, 0)
177
178	if read == size then
179		return true
180	else
181		mem:close()
182		return false
183	end
184end
185
186function MEMORY:readByte(addr)
187	if not self:hasProcess() then return 0 end
188	local output = new("int8_t[1]")
189	read(self, addr, output, sizeof(output))
190	return output[0]
191end
192
193function MEMORY:readBool(addr)
194	return self:readByte(addr) == 1
195end
196
197function MEMORY:readUByte(addr)
198	if not self:hasProcess() then return 0 end
199	local output = new("uint8_t[1]")
200	read(self, addr, output, sizeof(output))
201	return output[0]
202end
203
204local function bswap16(n)
205	return bor(rshift(n, 8), lshift(band(n, 0xFF), 8))
206end
207
208function MEMORY:readShort(addr)
209	if not self:hasProcess() then return 0 end
210	local output = new("int16_t[1]")
211	read(self, addr, output, sizeof(output))
212	return bswap16(output[0])
213end
214
215function MEMORY:readUShort(addr)
216	if not self:hasProcess() then return 0 end
217	local output = new("uint16_t[1]")
218	read(self, addr, output, sizeof(output))
219	return bswap16(output[0])
220end
221
222local flatconversion = ffi.new("union { uint32_t i; float f; }")
223
224function MEMORY:readFloat(addr)
225	if not self:hasProcess() then return 0 end
226	local output = new("uint32_t[1]")
227	read(self, addr, output, sizeof(output))
228	flatconversion.i = bswap(output[0])
229	return flatconversion.f
230end
231
232function MEMORY:readInt(addr)
233	if not self:hasProcess() then return 0 end
234	local output = new("int32_t[1]")
235	read(self, addr, output, sizeof(output))
236	return bswap(output[0])
237end
238
239function MEMORY:readUInt(addr)
240	if not self:hasProcess() then return 0 end
241	local output = new("uint32_t[1]")
242	read(self, addr, output, sizeof(output))
243	return bswap(output[0])
244end
245
246function MEMORY:read(addr, len)
247	if not self:hasProcess() then return "" end
248	local output = new("unsigned char[?]", len)
249	read(self, addr, output, sizeof(output))
250	return string(output, sizeof(output))
251end
252
253return MEMORY