Files
d2r-mobile/dm/host/compat/linux/compat_linux.c
T
shenleiandClaude Opus 5.5 4d91f80bae Android port (Adreno): Vulkan backend, GameActivity app, touch HUD, lifecycle, minimap quest goals
- host/android: Vulkan replay backend (nvn_vk.c) with pipeline/descriptor caching, ADPF,
  AChoreographer present link; Linux compat layer; Makefile.android (headless dmhost + APK lib)
- android/app: GameActivity shell without Gradle (build_apk.sh), AAudio output, touch HUD port
  (touch_app.c + TouchOverlay.java, three layers: body / joystick / minimap goals),
  lifecycle save-on-background like iOS, art_from_ipa.py for touch / HUD / mapgoal art
- touch: shared touch controls moved from ios/Sources to dm/touch
- patch_nso.py Android ruleset, dmsh_vk.py shader pack, DM_TOUCH_PRODUCT defaults
- hle_audio: AAudio resume waits through STARTING and reopens once on failure
- .gitignore: local resources/ (original game data) never committed

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-14 14:55:05 +09:00

297 lines
16 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Linux / Android 兼容层实现:compat_linux.h 与 include/ 替身头里声明的函数。
// Linux / Android compatibility layer implementation: the functions declared in compat_linux.h and the stand-in headers under include/.
#include "compat_linux.h"
#include <CommonCrypto/CommonDigest.h>
#include <dirent.h>
#include <dispatch/dispatch.h>
#include <limits.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/uio.h>
#include <sys/xattr.h>
// ---- 读自己进程的内存:process_vm_readv 读自己,不可读返回 EFAULT 而不是崩 ----
// ---- Reading our own memory: process_vm_readv on ourselves returns EFAULT for unreadable ranges instead of faulting ----
kern_return_t vm_read_overwrite(mach_port_t task, vm_address_t addr, vm_size_t size, vm_address_t data, vm_size_t *outsize) {
(void)task;
struct iovec l = {(void *)data, size}, r = {(void *)addr, size};
ssize_t n = process_vm_readv(getpid(), &l, 1, &r, 1, 0);
if (n < 0 && errno == ENOSYS) {
// 退路:写进管道再读出;write 遇不可读源地址返回 EFAULT | Fallback: write into a pipe and read back; write returns EFAULT on an unreadable source
int p[2]; if (pipe(p)) return KERN_FAILURE;
n = size <= 65536 ? write(p[1], (void *)addr, size) : -1;
if (n > 0 && read(p[0], (void *)data, (size_t)n) != n) n = -1;
close(p[0]); close(p[1]);
}
if (n != (ssize_t)size) return KERN_INVALID_ADDRESS;
if (outsize) *outsize = size;
return KERN_SUCCESS;
}
kern_return_t task_info(mach_port_t task, task_flavor_t flavor, task_info_t out, mach_msg_type_number_t *count) {
(void)task;
if (flavor != TASK_VM_INFO || *count < TASK_VM_INFO_COUNT) return KERN_FAILURE;
unsigned long long vsz = 0, rss = 0; FILE *f = fopen("/proc/self/statm", "r");
if (!f) return KERN_FAILURE;
int ok = fscanf(f, "%llu %llu", &vsz, &rss) == 2; fclose(f);
if (!ok) return KERN_FAILURE;
uint64_t pg = (uint64_t)sysconf(_SC_PAGESIZE);
task_vm_info_data_t *vi = (task_vm_info_data_t *)out;
vi->virtual_size = vsz * pg; vi->resident_size = vi->phys_footprint = rss * pg;
return KERN_SUCCESS;
}
// ---- pthread 栈:Darwin 的 stackaddr 是栈顶 ----
// ---- pthread stack: Darwin's stackaddr is the stack top ----
static int stack_of(pthread_t t, void **lo, size_t *sz) {
pthread_attr_t a;
if (pthread_getattr_np(t, &a)) return -1;
int r = pthread_attr_getstack(&a, lo, sz);
pthread_attr_destroy(&a);
return r;
}
void *pthread_get_stackaddr_np(pthread_t t) { void *lo; size_t sz; return stack_of(t, &lo, &sz) ? NULL : (char *)lo + sz; }
size_t pthread_get_stacksize_np(pthread_t t) { void *lo; size_t sz; return stack_of(t, &lo, &sz) ? 0 : sz; }
// ---- 文件 ----
// ---- Files ----
int dm_fcntl_getpath(int fd, char *out) {
char p[64]; snprintf(p, sizeof p, "/proc/self/fd/%d", fd);
ssize_t n = readlink(p, out, PATH_MAX - 1);
if (n < 0) return -1;
out[n] = 0; return 0;
}
// 缓冲一律放堆上:clonefile 由存档挂载(svc 门)调用,跑在客体线程的小栈上
// All buffers live on the heap: clonefile is called by save mounting (an svc gate) and runs on a guest thread's small stack
static int copy_xattrs(int sfd, int dfd) {
char *names = malloc(4096), *v = malloc(4096); int r = 0;
ssize_t n = names && v ? flistxattr(sfd, names, 4096) : -1;
for (char *k = names; n > 0 && k < names + n; k += strlen(k) + 1) {
if (strncmp(k, "user.", 5)) continue;
ssize_t vn = fgetxattr(sfd, k, v, 4096);
if (vn >= 0 && fsetxattr(dfd, k, v, (size_t)vn, 0)) { r = -1; break; }
}
free(names); free(v);
return r;
}
static int copy_file(const char *src, const char *dst, mode_t mode) {
int sfd = open(src, O_RDONLY), dfd = sfd < 0 ? -1 : open(dst, O_WRONLY | O_CREAT | O_EXCL, mode);
char *buf = malloc(65536);
int r = sfd < 0 || dfd < 0 || !buf ? -1 : 0; ssize_t n;
while (!r && (n = read(sfd, buf, 65536)) != 0) {
if (n < 0) { r = -1; break; }
for (ssize_t o = 0; o < n;) { ssize_t w = write(dfd, buf + o, (size_t)(n - o)); if (w < 0) { r = -1; break; } o += w; }
}
if (!r) r = copy_xattrs(sfd, dfd);
free(buf);
if (sfd >= 0) close(sfd);
if (dfd >= 0) close(dfd);
return r;
}
static int copy_tree(const char *src, const char *dst) {
struct stat st; if (lstat(src, &st)) return -1;
if (S_ISREG(st.st_mode)) return copy_file(src, dst, st.st_mode & 07777);
if (!S_ISDIR(st.st_mode)) { errno = ENOTSUP; return -1; }
if (mkdir(dst, st.st_mode & 07777)) return -1;
DIR *d = opendir(src); if (!d) return -1;
char *s2 = NULL, *d2 = NULL; struct dirent *e; int r = 0;
while (!r && (e = readdir(d))) {
if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, "..")) continue;
if (asprintf(&s2, "%s/%s", src, e->d_name) < 0 || asprintf(&d2, "%s/%s", dst, e->d_name) < 0) r = -1;
else r = copy_tree(s2, d2);
free(s2); free(d2); s2 = d2 = NULL;
}
closedir(d);
if (!r) { int sfd = open(src, O_RDONLY | O_DIRECTORY), dfd = open(dst, O_RDONLY | O_DIRECTORY);
if (sfd >= 0 && dfd >= 0) r = copy_xattrs(sfd, dfd);
if (sfd >= 0) close(sfd); if (dfd >= 0) close(dfd); }
return r;
}
int clonefile(const char *src, const char *dst, uint32_t flags) {
(void)flags;
struct stat st; if (!lstat(dst, &st)) { errno = EEXIST; return -1; }
return copy_tree(src, dst);
}
int renamex_np(const char *from, const char *to, unsigned flags) {
if (flags & RENAME_SWAP) return (int)syscall(SYS_renameat2, AT_FDCWD, from, AT_FDCWD, to, 2 /* RENAME_EXCHANGE */);
return rename(from, to);
}
// ---- 进程映像 ----
// ---- Process image ----
// 安卓 App 里 /proc/self/exe 是 app_process:GameActivity 在加载 libd2r.so 前设好 DM_ROOT(数据根),这里把「可执行文件」报成 <DM_ROOT>/dmhost,
// 与 adb 无头时 dmhost 和 dm/ 同目录的布局一致——库构造函数(dm/derived.tsv 的经验表等)在 chdir 之前就要用它
// In the Android app /proc/self/exe is app_process: GameActivity sets DM_ROOT (the data root) before loading libd2r.so, and the "executable" is reported as <DM_ROOT>/dmhost,
// matching the adb headless layout where dmhost sits next to dm/ -- library constructors (the EXP table from dm/derived.tsv, etc.) need it before the chdir
int _NSGetExecutablePath(char *buf, uint32_t *size) {
char p[PATH_MAX]; ssize_t n;
#ifdef __ANDROID__
const char *root = getenv("DM_ROOT");
if (root && *root) n = snprintf(p, sizeof p, "%s/dmhost", root); else
#endif
n = readlink("/proc/self/exe", p, sizeof p - 1);
if (n < 0 || n >= (ssize_t)sizeof p) return -1;
p[n] = 0;
if ((uint32_t)n + 1 > *size) { *size = (uint32_t)n + 1; return -1; }
memcpy(buf, p, (size_t)n + 1); return 0;
}
const struct mach_header_64 _mh_execute_header = {0xfeedfacf};
// Mach-O "__DATA,<名>" 登记段 → ELF 段 <名>(DM_SECT),链接器给 __start_<名> / __stop_<名>;未用到的段弱引用为空
// Mach-O "__DATA,<name>" registration section -> ELF section <name> (DM_SECT); the linker provides __start_<name> / __stop_<name>; unused sections are weak and empty
#define SECT(n) extern uint8_t __start_##n[] __attribute__((weak)), __stop_##n[] __attribute__((weak));
SECT(swhle) SECT(swforce) SECT(swnvn)
#undef SECT
uint8_t *getsectiondata(const struct mach_header_64 *mh, const char *seg, const char *sect, unsigned long *size) {
(void)mh; (void)seg;
uint8_t *a = NULL, *b = NULL;
if (!strcmp(sect, "swhle")) a = __start_swhle, b = __stop_swhle;
else if (!strcmp(sect, "swforce")) a = __start_swforce, b = __stop_swforce;
else if (!strcmp(sect, "swnvn")) a = __start_swnvn, b = __stop_swnvn;
*size = a && b ? (unsigned long)(b - a) : 0;
return *size ? a : NULL;
}
// ---- 摘要:MD5 / SHA-1 / SHA-256(只做校验与诊断用,不涉安全) ----
// ---- Digests: MD5 / SHA-1 / SHA-256 (only for checksums and diagnostics, not security) ----
#define ROL(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
#define ROR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
static void md5_block(uint32_t h[4], const uint8_t *p) {
static const uint32_t K[64] = {
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
static const uint8_t S[16] = {7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21};
uint32_t m[16]; for (int i = 0; i < 16; i++) m[i] = p[4 * i] | p[4 * i + 1] << 8 | p[4 * i + 2] << 16 | (uint32_t)p[4 * i + 3] << 24;
uint32_t a = h[0], b = h[1], c = h[2], d = h[3];
for (int i = 0; i < 64; i++) {
uint32_t f; int g;
if (i < 16) f = (b & c) | (~b & d), g = i;
else if (i < 32) f = (d & b) | (~d & c), g = (5 * i + 1) & 15;
else if (i < 48) f = b ^ c ^ d, g = (3 * i + 5) & 15;
else f = c ^ (b | ~d), g = (7 * i) & 15;
uint32_t t = d; d = c; c = b;
b = b + ROL(a + f + K[i] + m[g], S[(i >> 4) * 4 + (i & 3)]);
a = t;
}
h[0] += a; h[1] += b; h[2] += c; h[3] += d;
}
// 通用 Merkle–Damgård 外壳:64 字节块,长度尾按 big 端或 little 端
// Generic Merkle-Damgard wrapper: 64-byte blocks, length trailer big- or little-endian
static void md_run(const uint8_t *p, uint64_t len, int big, void (*blk)(uint32_t *, const uint8_t *), uint32_t *h) {
uint64_t full = len & ~63ull;
for (uint64_t o = 0; o < full; o += 64) blk(h, p + o);
uint8_t t[128] = {0}; size_t r = (size_t)(len - full);
memcpy(t, p + full, r); t[r] = 0x80;
size_t tl = r + 9 <= 64 ? 64 : 128; uint64_t bits = len * 8;
for (int i = 0; i < 8; i++) t[tl - 8 + i] = big ? (uint8_t)(bits >> (56 - 8 * i)) : (uint8_t)(bits >> (8 * i));
for (size_t o = 0; o < tl; o += 64) blk(h, t + o);
}
static void md5_blk(uint32_t *h, const uint8_t *p) { md5_block(h, p); }
unsigned char *CC_MD5(const void *data, CC_LONG len, unsigned char *md) {
uint32_t h[4] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476};
md_run(data, len, 0, md5_blk, h);
for (int i = 0; i < 16; i++) md[i] = (uint8_t)(h[i / 4] >> (8 * (i & 3)));
return md;
}
static void sha1_blk(uint32_t *h, const uint8_t *p) {
uint32_t w[80];
for (int i = 0; i < 16; i++) w[i] = (uint32_t)p[4 * i] << 24 | p[4 * i + 1] << 16 | p[4 * i + 2] << 8 | p[4 * i + 3];
for (int i = 16; i < 80; i++) w[i] = ROL(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
for (int i = 0; i < 80; i++) {
uint32_t f, k;
if (i < 20) f = (b & c) | (~b & d), k = 0x5a827999;
else if (i < 40) f = b ^ c ^ d, k = 0x6ed9eba1;
else if (i < 60) f = (b & c) | (b & d) | (c & d), k = 0x8f1bbcdc;
else f = b ^ c ^ d, k = 0xca62c1d6;
uint32_t t = ROL(a, 5) + f + e + k + w[i]; e = d; d = c; c = ROL(b, 30); b = a; a = t;
}
h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e;
}
unsigned char *CC_SHA1(const void *data, CC_LONG len, unsigned char *md) {
uint32_t h[5] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0};
md_run(data, len, 1, sha1_blk, h);
for (int i = 0; i < 20; i++) md[i] = (uint8_t)(h[i / 4] >> (24 - 8 * (i & 3)));
return md;
}
static void sha256_blk(uint32_t *h, const uint8_t *p) {
static const uint32_t K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
uint32_t w[64];
for (int i = 0; i < 16; i++) w[i] = (uint32_t)p[4 * i] << 24 | p[4 * i + 1] << 16 | p[4 * i + 2] << 8 | p[4 * i + 3];
for (int i = 16; i < 64; i++) {
uint32_t s0 = ROR(w[i - 15], 7) ^ ROR(w[i - 15], 18) ^ (w[i - 15] >> 3), s1 = ROR(w[i - 2], 17) ^ ROR(w[i - 2], 19) ^ (w[i - 2] >> 10);
w[i] = w[i - 16] + s0 + w[i - 7] + s1;
}
uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
for (int i = 0; i < 64; i++) {
uint32_t t1 = hh + (ROR(e, 6) ^ ROR(e, 11) ^ ROR(e, 25)) + ((e & f) ^ (~e & g)) + K[i] + w[i];
uint32_t t2 = (ROR(a, 2) ^ ROR(a, 13) ^ ROR(a, 22)) + ((a & b) ^ (a & c) ^ (b & c));
hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2;
}
h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e; h[5] += f; h[6] += g; h[7] += hh;
}
int CC_SHA256_Init(CC_SHA256_CTX *c) {
static const uint32_t H0[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
memcpy(c->h, H0, sizeof H0); c->len = 0; c->n = 0; return 1;
}
int CC_SHA256_Update(CC_SHA256_CTX *c, const void *data, CC_LONG len) {
const uint8_t *p = data; c->len += len;
while (len) {
if (!c->n && len >= 64) { sha256_blk(c->h, p); p += 64; len -= 64; continue; }
uint32_t k = 64 - c->n < len ? 64 - c->n : len;
memcpy(c->buf + c->n, p, k); c->n += k; p += k; len -= k;
if (c->n == 64) { sha256_blk(c->h, c->buf); c->n = 0; }
}
return 1;
}
int CC_SHA256_Final(unsigned char *md, CC_SHA256_CTX *c) {
uint8_t t[128] = {0}; memcpy(t, c->buf, c->n); t[c->n] = 0x80;
size_t tl = c->n + 9 <= 64 ? 64 : 128; uint64_t bits = c->len * 8;
for (int i = 0; i < 8; i++) t[tl - 8 + i] = (uint8_t)(bits >> (56 - 8 * i));
for (size_t o = 0; o < tl; o += 64) sha256_blk(c->h, t + o);
for (int i = 0; i < 32; i++) md[i] = (uint8_t)(c->h[i / 4] >> (24 - 8 * (i & 3)));
return 1;
}
// ---- dispatch 计数信号量 ----
// ---- dispatch counting semaphore ----
struct dm_dsema { sem_t s; };
dispatch_semaphore_t dispatch_semaphore_create(long value) {
dispatch_semaphore_t d = malloc(sizeof *d);
if (d && sem_init(&d->s, 0, (unsigned)value)) { free(d); d = NULL; }
return d;
}
long dispatch_semaphore_signal(dispatch_semaphore_t d) { sem_post(&d->s); return 0; }
long dispatch_semaphore_wait(dispatch_semaphore_t d, dispatch_time_t timeout) {
if (timeout == DISPATCH_TIME_FOREVER) { while (sem_wait(&d->s) && errno == EINTR) {} return 0; }
if (timeout == DISPATCH_TIME_NOW) return sem_trywait(&d->s) ? 1 : 0;
struct timespec ts = {(time_t)(timeout / 1000000000ull), (long)(timeout % 1000000000ull)}; // 绝对 CLOCK_REALTIME 纳秒 | absolute CLOCK_REALTIME ns
while (sem_timedwait(&d->s, &ts)) if (errno != EINTR) return 1;
return 0;
}
void dispatch_release(void *obj) { struct dm_dsema *d = obj; if (d) { sem_destroy(&d->s); free(d); } }
uint64_t mach_absolute_time(void) { return clock_gettime_nsec_np(CLOCK_MONOTONIC); }