mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 13:55:58 +00:00
257 lines
11 KiB
C
257 lines
11 KiB
C
/* Experimental per-process PowerVR device-backed low-address mmap adapter.
|
|
* No copied/shadow memory, changed device offset or MAP_FIXED replacement.
|
|
* Default is off. Enable only for the identified render-device rdev and the
|
|
* target x86/WoW64 game. Native 64-bit Linux/glibc preload, not an Android ABI DLL.
|
|
*/
|
|
#define _GNU_SOURCE
|
|
#define _LARGEFILE64_SOURCE
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <inttypes.h>
|
|
#include <stdatomic.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/syscall.h>
|
|
#include <unistd.h>
|
|
|
|
#ifndef MAP_FIXED_NOREPLACE
|
|
#define MAP_FIXED_NOREPLACE 0x100000
|
|
#endif
|
|
|
|
static _Atomic uint64_t cursor;
|
|
static _Atomic unsigned logged;
|
|
typedef void *(*map_function)(void *,size_t,int,int,int,off_t);
|
|
typedef void *(*map64_function)(void *,size_t,int,int,int,off64_t);
|
|
static _Atomic(map_function) next_map;
|
|
static _Atomic(map64_function) next_map64;
|
|
_Static_assert(sizeof(off_t) == sizeof(off64_t) && sizeof(off_t) == 8,
|
|
"64-bit host required");
|
|
static __thread int resolving __attribute__((tls_model("initial-exec")));
|
|
static __thread int active __attribute__((tls_model("initial-exec")));
|
|
static void *native_map(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
|
|
{
|
|
map_function next=atomic_load(&next_map);
|
|
if (!next && !resolving) {
|
|
resolving=1;
|
|
next=(map_function)dlsym(RTLD_NEXT,"mmap");
|
|
atomic_store(&next_map,next);
|
|
resolving=0;
|
|
}
|
|
/* Bootstrap only while resolving; otherwise preserve existing preload hooks. */
|
|
if (next) return next(addr,length,prot,flags,fd,offset);
|
|
return (void *)syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
|
|
}
|
|
|
|
static void *native_map64(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
|
|
{
|
|
map64_function next=atomic_load(&next_map64);
|
|
if (!next && !resolving) {
|
|
resolving=1;
|
|
next=(map64_function)dlsym(RTLD_NEXT,"mmap64");
|
|
atomic_store(&next_map64,next);
|
|
resolving=0;
|
|
}
|
|
if (next) return next(addr,length,prot,flags,fd,(off64_t)offset);
|
|
return (void *)syscall(SYS_mmap, addr, length, prot, flags, fd, offset);
|
|
}
|
|
|
|
static void trace_map(const char *kind, size_t n, int prot, int flags, int fd,
|
|
off_t off, const struct stat *st, void *p, int error)
|
|
{
|
|
int saved = errno;
|
|
unsigned count = atomic_fetch_add(&logged, 1);
|
|
if (count < 256 || error != 0) {
|
|
char text[320];
|
|
int nbytes = snprintf(text, sizeof(text),
|
|
"DD_LOW32 %s pid=%ld len=%zu prot=%x flags=%x fd=%d off=%jd mode=%o rdev=%ju ptr=%p errno=%d\n",
|
|
kind, (long)getpid(), n, prot, flags, fd, (intmax_t)off, st ? st->st_mode : 0,
|
|
st ? (uintmax_t)st->st_rdev : 0, p, error);
|
|
if (nbytes > 0) {
|
|
ssize_t written = write(STDERR_FILENO, text,
|
|
(size_t)nbytes < sizeof(text) ? (size_t)nbytes : sizeof(text)-1);
|
|
(void)written;
|
|
}
|
|
}
|
|
errno = saved;
|
|
}
|
|
|
|
static int target_device(int fd, struct stat *st)
|
|
{
|
|
const char *value = getenv("DROIDDECK_LOW32_RDEV");
|
|
char *end = NULL;
|
|
if (!value || !*value || fd < 0) return 0;
|
|
int saved = errno;
|
|
errno = 0;
|
|
uintmax_t expected = strtoumax(value, &end, 10);
|
|
int valid = !errno && end && !*end && expected > 0 &&
|
|
fstat(fd, st) == 0 && S_ISCHR(st->st_mode) &&
|
|
(uintmax_t)st->st_rdev == expected;
|
|
errno = saved;
|
|
return valid;
|
|
}
|
|
|
|
static void *adapted_map(map_function forward, void *addr, size_t length, int prot,
|
|
int flags, int fd, off_t offset)
|
|
{
|
|
const char *mode = getenv("DROIDDECK_LOW32_MODE");
|
|
struct stat st = {0};
|
|
if (mode && !strcmp(mode, "trace")) {
|
|
void *p = forward(addr, length, prot, flags, fd, offset);
|
|
if (fd >= 0 && (prot & PROT_WRITE) && !(prot & PROT_EXEC) &&
|
|
(flags & MAP_TYPE) == MAP_SHARED) {
|
|
int saved=errno;
|
|
(void)fstat(fd,&st);
|
|
errno=saved;
|
|
trace_map("trace", length, prot, flags, fd, offset, &st, p,
|
|
p == MAP_FAILED ? errno : 0);
|
|
}
|
|
return p;
|
|
}
|
|
if (!mode || strcmp(mode, "low32") || addr || !length ||
|
|
(flags & (MAP_ANONYMOUS | MAP_FIXED | MAP_FIXED_NOREPLACE)) ||
|
|
(prot & PROT_EXEC) || (flags & MAP_TYPE) != MAP_SHARED ||
|
|
!target_device(fd, &st))
|
|
return forward(addr, length, prot, flags, fd, offset);
|
|
|
|
const uintptr_t lower = 0x10000000u, upper = 0xffff0000u;
|
|
const uintptr_t step = 0x00400000u;
|
|
if (length > upper-lower) {
|
|
errno = ENOMEM;
|
|
trace_map("too_large", length, prot, flags, fd, offset, &st, MAP_FAILED, errno);
|
|
return MAP_FAILED;
|
|
}
|
|
long page_value=sysconf(_SC_PAGESIZE);
|
|
uintptr_t page=page_value>0?(uintptr_t)page_value:4096;
|
|
uintptr_t rounded=(length+page-1)&~(page-1);
|
|
uintptr_t span=upper-lower;
|
|
uintptr_t compact=(uintptr_t)(atomic_fetch_add(&cursor,rounded)%span);
|
|
if (rounded>span-compact) compact=0;
|
|
unsigned slots = (unsigned)((span-length)/step)+1;
|
|
unsigned start = (unsigned)(compact/step)%slots;
|
|
int original_errno = errno;
|
|
for (unsigned i = 0; i < 1; i++) {
|
|
/* Compact first: hundreds of small driver mappings must not waste a
|
|
* 4MiB address slot each. Coarse search is only for existing Wine holes. */
|
|
uintptr_t hint = lower + (i==0?compact:(uintptr_t)((start+i-1)%slots)*step);
|
|
void *p = forward((void *)hint, length, prot,
|
|
flags|MAP_FIXED_NOREPLACE, fd, offset);
|
|
if (p != MAP_FAILED) {
|
|
uintptr_t first = (uintptr_t)p;
|
|
if (first >= lower && first < upper && length <= upper-first) {
|
|
errno = original_errno;
|
|
trace_map("mapped", length, prot, flags, fd, offset, &st, p, 0);
|
|
return p;
|
|
}
|
|
/* Older kernels can ignore NOREPLACE; never return a high mapping. */
|
|
int saved = errno;
|
|
(void)syscall(SYS_munmap, p, length);
|
|
errno = saved;
|
|
} else if (errno != EEXIST && errno != ENOMEM && errno != EAGAIN) {
|
|
trace_map("rejected", length, prot, flags, fd, offset, &st, p, errno);
|
|
return p;
|
|
}
|
|
}
|
|
/* Pack small allocations into address holes before coarse probing can
|
|
* fragment large holes. Walk
|
|
* this process's current mappings, then use NOREPLACE to tolerate races.
|
|
* No pointer paths or contents are read; only address ranges are used. */
|
|
for (unsigned pass = 0; pass < 2; ++pass) {
|
|
FILE *maps = fopen("/proc/self/maps", "r");
|
|
if (!maps) break;
|
|
char line[512];
|
|
uintptr_t gap_start = lower;
|
|
unsigned lines = 0;
|
|
while (fgets(line, sizeof(line), maps) && ++lines < 65536) {
|
|
uintptr_t first, last;
|
|
if (sscanf(line, "%" SCNxPTR "-%" SCNxPTR, &first, &last) != 2) continue;
|
|
if (last <= gap_start) continue;
|
|
uintptr_t gap_end = first < upper ? first : upper;
|
|
if (gap_end > gap_start && rounded <= gap_end - gap_start) {
|
|
void *p = forward((void *)gap_start, length, prot,
|
|
flags | MAP_FIXED_NOREPLACE, fd, offset);
|
|
if (p != MAP_FAILED) {
|
|
uintptr_t address = (uintptr_t)p;
|
|
if (address >= lower && address < upper && length <= upper - address) {
|
|
fclose(maps);
|
|
errno = original_errno;
|
|
trace_map("mapped_gap", length, prot, flags, fd, offset, &st, p, 0);
|
|
return p;
|
|
}
|
|
(void)syscall(SYS_munmap, p, length);
|
|
} else if (errno != EEXIST && errno != ENOMEM && errno != EAGAIN) {
|
|
int saved = errno;
|
|
fclose(maps);
|
|
errno = saved;
|
|
trace_map("rejected", length, prot, flags, fd, offset, &st, MAP_FAILED, errno);
|
|
return MAP_FAILED;
|
|
}
|
|
}
|
|
if (last > gap_start) gap_start = last;
|
|
if (gap_start >= upper) break;
|
|
}
|
|
if (gap_start < upper && rounded <= upper - gap_start) {
|
|
void *p = forward((void *)gap_start, length, prot,
|
|
flags | MAP_FIXED_NOREPLACE, fd, offset);
|
|
if (p != MAP_FAILED) {
|
|
uintptr_t address = (uintptr_t)p;
|
|
if (address >= lower && address < upper && length <= upper - address) {
|
|
fclose(maps);
|
|
errno = original_errno;
|
|
trace_map("mapped_gap", length, prot, flags, fd, offset, &st, p, 0);
|
|
return p;
|
|
}
|
|
(void)syscall(SYS_munmap, p, length);
|
|
}
|
|
}
|
|
fclose(maps);
|
|
}
|
|
for (unsigned i = 1; i <= slots; i++) {
|
|
/* Last resort if address walking was unavailable or raced. */
|
|
uintptr_t hint = lower + (i==0?compact:(uintptr_t)((start+i-1)%slots)*step);
|
|
void *p = forward((void *)hint, length, prot,
|
|
flags|MAP_FIXED_NOREPLACE, fd, offset);
|
|
if (p != MAP_FAILED) {
|
|
uintptr_t first = (uintptr_t)p;
|
|
if (first >= lower && first < upper && length <= upper-first) {
|
|
errno = original_errno;
|
|
trace_map("mapped", length, prot, flags, fd, offset, &st, p, 0);
|
|
return p;
|
|
}
|
|
/* Older kernels can ignore NOREPLACE; never return a high mapping. */
|
|
int saved = errno;
|
|
(void)syscall(SYS_munmap, p, length);
|
|
errno = saved;
|
|
} else if (errno != EEXIST && errno != ENOMEM && errno != EAGAIN) {
|
|
trace_map("rejected", length, prot, flags, fd, offset, &st, p, errno);
|
|
return p;
|
|
}
|
|
}
|
|
errno = ENOMEM;
|
|
trace_map("no_low_hole", length, prot, flags, fd, offset, &st, MAP_FAILED, errno);
|
|
return MAP_FAILED;
|
|
}
|
|
|
|
static void *intercept_map(map_function forward, void *addr, size_t length,
|
|
int prot, int flags, int fd, off_t offset)
|
|
{
|
|
if (active) return forward(addr,length,prot,flags,fd,offset);
|
|
active=1;
|
|
void *p=adapted_map(forward,addr,length,prot,flags,fd,offset);
|
|
active=0;
|
|
return p;
|
|
}
|
|
|
|
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
|
|
{
|
|
return intercept_map(native_map,addr,length,prot,flags,fd,offset);
|
|
}
|
|
|
|
void *mmap64(void *addr, size_t length, int prot, int flags, int fd, off64_t offset)
|
|
{
|
|
return intercept_map(native_map64,addr,length,prot,flags,fd,(off_t)offset);
|
|
}
|