From 4bcd4e3cca3a4ff2398b2f327a4c21c1ed678b27 Mon Sep 17 00:00:00 2001 From: maxjivi05 Date: Fri, 23 Oct 2026 09:02:47 -0400 Subject: [PATCH 1/4] perf: droiddeck-ntsync without signal-mask syscalls, waits that skip the queue, and per-thread device references --- README.md | 2 +- tools/linuxfs/preload/ntsync.c | 283 +++++++++++++----- tools/tests/test_ntsync_preload.py | 456 +++++++++++++++++++++++++++++ 3 files changed, 671 insertions(+), 70 deletions(-) create mode 100644 tools/tests/test_ntsync_preload.py diff --git a/README.md b/README.md index fb86fa6534..7fd8cfbdbd 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ Compatibility and performance vary by device; hardware validation is limited. De ## Credits and licence -GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). Epic Games and GOG support build on [Phobos’s](https://github.com/phobos665) adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl), respectively. The registry entries a GOG game's install script (`goggame-.script`) sets are read the way [Heroic Games Launcher](https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher)'s GOG setup (GPL-3.0) reads them. LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence, which also starts the arm64 emulator AppImages whose own runtime cannot run its extractor on Android. The Steam client's audio goes through [@The412Banner](https://github.com/The412Banner)'s [DirectAudio](https://github.com/The412Banner/directaudio) PulseAudio sink (LGPL-2.1-or-later), built from `tools/directaudio/sink` with its request size kept to its ring so clients are not asked to queue 100 ms ahead. mmap ring-buffer controller input was developed by ribbit384 ([WinNative #345](https://github.com/WinNative-Emu/WinNative/pull/345)). Why the x86-64 Steam client refused the arm64 client's sign-in was checked by reading Steam's saved token with the `ConnectCache` format from [deadlock-api-ingest](https://github.com/deadlock-api/deadlock-api-ingest). x86 programs that link OpenSSL 3 under FEX use the copy in the [Steam Linux Runtime 4.0](https://gitlab.steamos.cloud/steamrt/steamrt) platform. Hooks written with `WriteProcessMemory` into code [FEX](https://github.com/FEX-Emu/FEX) has translated go through `/proc//mem` again when the kernel refuses `process_vm_writev`, as [Wine](https://gitlab.winehq.org/wine/wine)'s `server/ptrace.c` wrote them before Wine 11. x86 Linux games under FEX get the same `/etc/asound.conf` that [pressure-vessel](https://gitlab.steamos.cloud/steamrt/steam-runtime-tools) writes into the Steam Linux Runtime, so ALSA plays through PulseAudio. Games render with [Mesa](https://gitlab.freedesktop.org/mesa/mesa) Turnip's own per-render-pass choice between tile memory and system memory, while the Steam client keeps `TU_DEBUG=sysmem`; [FEX](https://github.com/FEX-Emu/FEX)'s code disk cache was checked in its source and is already on through Proton. The proot fast path picks the guest name of a host file bound under several names in the order [PRoot](https://github.com/proot-me/proot)'s `path/binding.c` (GPL-2.0-or-later) sorts its bindings, so links and `/proc/self/fd` read back as they do through proot. The session's [PipeWire](https://gitlab.freedesktop.org/pipewire/pipewire) (MIT) opens its sockets with the per-socket access settings documented in its `module-access.c`, and [WirePlumber](https://gitlab.freedesktop.org/pipewire/wireplumber) (MIT) keeps those clients at full permissions through its `access.rules`. Wine write watches use the userfaultfd support in [Proton](https://github.com/ValveSoftware/wine)'s `dlls/ntdll/unix/virtual.c` (LGPL-2.1-or-later): libblsession gives it the arm64 syscall number and answers its `PAGEMAP_SCAN` from `/proc/self/pagemap` where Android refuses the ioctl. Wine on arm64 sets a thread's full context by raising `SIGUSR2` from `syscall_dispatcher_return_slowpath` in [Wine](https://gitlab.winehq.org/wine/wine)'s `dlls/ntdll/unix/signal_arm64.c` (LGPL-2.1-or-later); libblsession runs that handler in place on a frame laid out as the [Linux](https://github.com/torvalds/linux) kernel's `arch/arm64/kernel/signal.c` builds it and returns through `rt_sigreturn`, so proot does not stop the thread for it. Wine's process list reads each process's memory counters from `/proc//status` in `fill_vm_counters` ([Wine](https://gitlab.winehq.org/wine/wine) `dlls/ntdll/unix/process.c`, LGPL-2.1-or-later), so libblsession gives those reads the kernel's file instead of a copy with `TracerPid` cleared. See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve. +GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). Epic Games and GOG support build on [Phobos’s](https://github.com/phobos665) adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl), respectively. The registry entries a GOG game's install script (`goggame-.script`) sets are read the way [Heroic Games Launcher](https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher)'s GOG setup (GPL-3.0) reads them. LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence, which also starts the arm64 emulator AppImages whose own runtime cannot run its extractor on Android. The Steam client's audio goes through [@The412Banner](https://github.com/The412Banner)'s [DirectAudio](https://github.com/The412Banner/directaudio) PulseAudio sink (LGPL-2.1-or-later), built from `tools/directaudio/sink` with its request size kept to its ring so clients are not asked to queue 100 ms ahead. mmap ring-buffer controller input was developed by ribbit384 ([WinNative #345](https://github.com/WinNative-Emu/WinNative/pull/345)). Why the x86-64 Steam client refused the arm64 client's sign-in was checked by reading Steam's saved token with the `ConnectCache` format from [deadlock-api-ingest](https://github.com/deadlock-api/deadlock-api-ingest). x86 programs that link OpenSSL 3 under FEX use the copy in the [Steam Linux Runtime 4.0](https://gitlab.steamos.cloud/steamrt/steamrt) platform. Hooks written with `WriteProcessMemory` into code [FEX](https://github.com/FEX-Emu/FEX) has translated go through `/proc//mem` again when the kernel refuses `process_vm_writev`, as [Wine](https://gitlab.winehq.org/wine/wine)'s `server/ptrace.c` wrote them before Wine 11. x86 Linux games under FEX get the same `/etc/asound.conf` that [pressure-vessel](https://gitlab.steamos.cloud/steamrt/steam-runtime-tools) writes into the Steam Linux Runtime, so ALSA plays through PulseAudio. Games render with [Mesa](https://gitlab.freedesktop.org/mesa/mesa) Turnip's own per-render-pass choice between tile memory and system memory, while the Steam client keeps `TU_DEBUG=sysmem`; [FEX](https://github.com/FEX-Emu/FEX)'s code disk cache was checked in its source and is already on through Proton. The proot fast path picks the guest name of a host file bound under several names in the order [PRoot](https://github.com/proot-me/proot)'s `path/binding.c` (GPL-2.0-or-later) sorts its bindings, so links and `/proc/self/fd` read back as they do through proot. The session's [PipeWire](https://gitlab.freedesktop.org/pipewire/pipewire) (MIT) opens its sockets with the per-socket access settings documented in its `module-access.c`, and [WirePlumber](https://gitlab.freedesktop.org/pipewire/wireplumber) (MIT) keeps those clients at full permissions through its `access.rules`. Wine write watches use the userfaultfd support in [Proton](https://github.com/ValveSoftware/wine)'s `dlls/ntdll/unix/virtual.c` (LGPL-2.1-or-later): libblsession gives it the arm64 syscall number and answers its `PAGEMAP_SCAN` from `/proc/self/pagemap` where Android refuses the ioctl. Wine on arm64 sets a thread's full context by raising `SIGUSR2` from `syscall_dispatcher_return_slowpath` in [Wine](https://gitlab.winehq.org/wine/wine)'s `dlls/ntdll/unix/signal_arm64.c` (LGPL-2.1-or-later); libblsession runs that handler in place on a frame laid out as the [Linux](https://github.com/torvalds/linux) kernel's `arch/arm64/kernel/signal.c` builds it and returns through `rt_sigreturn`, so proot does not stop the thread for it. Wine's process list reads each process's memory counters from `/proc//status` in `fill_vm_counters` ([Wine](https://gitlab.winehq.org/wine/wine) `dlls/ntdll/unix/process.c`, LGPL-2.1-or-later), so libblsession gives those reads the kernel's file instead of a copy with `TracerPid` cleared. droiddeck-ntsync is checked against the object, wait and error semantics documented for the [Linux](https://github.com/torvalds/linux) ntsync driver in `Documentation/userspace-api/ntsync.rst` (GPL-2.0). See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve. XR glasses support builds on WinNative's VITURE glasses work. VITURE protocol details were checked against [XRLinuxDriver](https://github.com/wheaney/XRLinuxDriver) by [@wheaney](https://github.com/wheaney), including the VITURE protocol header it ships, [ar-drivers-rs](https://github.com/badicsalex/ar-drivers-rs) by [@badicsalex](https://github.com/badicsalex) and the [go-macos/iokit VITURE package](https://pkg.go.dev/github.com/go-macos/iokit/viture); the optional VITURE SDK belongs to VITURE and is not included. RayNeo support adapts [@informalTechCode](https://github.com/informalTechCode)'s [RayNeo-Air-Series-3DoF-Scaffold](https://github.com/informalTechCode/RayNeo-Air-Series-3DoF-Scaffold) (Apache-2.0) and references [@verncat](https://github.com/verncat)'s [RayNeo-Air-3S-Pro-OpenVR](https://github.com/verncat/RayNeo-Air-3S-Pro-OpenVR) (MIT) and [Monado](https://gitlab.freedesktop.org/monado/monado) (BSL-1.0); see [docs/third-party/rayneo](docs/third-party/rayneo/README.md). XREAL 1S support references [XRLinuxDriver](https://github.com/wheaney/XRLinuxDriver) and [xrealOneDeviceKit](https://github.com/wheaney/xrealOneDeviceKit) by @wheaney, [xreal_one_driver](https://github.com/rohitsangwan01/xreal_one_driver) by [@rohitsangwan01](https://github.com/rohitsangwan01) (MIT) and [xr-tools](https://github.com/0xcaff/xr-tools) by [@0xcaff](https://github.com/0xcaff). Rokid support follows the Rokid protocol notes in [ar-drivers-rs](https://github.com/badicsalex/ar-drivers-rs) and @badicsalex's [Void Computing write-ups](https://voidcomputing.hu/blog/worse-better-prettier/), and [Monado](https://gitlab.freedesktop.org/monado/monado)'s Rokid driver. The REDMAGIC glasses-display findings draw on [@mekhontsev](https://github.com/mekhontsev)'s [MagicDesk investigation](https://github.com/mekhontsev/magicdesk/blob/main/docs/xr-resolution-fix.md) and [@Coding-BR](https://github.com/Coding-BR)'s [decompiled Nubia kernel](https://github.com/Coding-BR/android_kernel_nubia_sm8850_qwjujube). VITURE, RayNeo, XREAL, Rokid and REDMAGIC are trademarks of their owners; this project is not affiliated with them. diff --git a/tools/linuxfs/preload/ntsync.c b/tools/linuxfs/preload/ntsync.c index b920b49f92..2b1c790459 100644 --- a/tools/linuxfs/preload/ntsync.c +++ b/tools/linuxfs/preload/ntsync.c @@ -68,12 +68,13 @@ struct ns_wait_args { #define NS_PROCS 256u #define NS_FDS 65536 #define NS_DEVS 8 -#define NS_VERSION 1u +#define NS_VERSION 2u #define NS_HEAD_MAGIC 0x31434e5953544e44ull #define NS_DEV_MAGIC 0x4e54445600000000ull #define NS_OBJ_MAGIC 0x27ull #define NS_WAITERS 0x80000000u #define NS_SWEEP_NS 2000000000ull +#define NS_SPIN_NS 4000ull #define NS_DEAD 0xffffffffu #ifndef CLOSE_RANGE_CLOEXEC @@ -144,6 +145,7 @@ struct ns_q { uint32_t waiting; uint32_t inuse; uint32_t next_free; + uint32_t sleeping; struct ns_ent ent[NS_ENTS]; }; @@ -255,19 +257,104 @@ static void ns_unlock(uint32_t *w) { } } -static void ns_block(sigset_t *old) { - sigset_t s; - sigfillset(&s); - sigdelset(&s, SIGSEGV); - sigdelset(&s, SIGBUS); - sigdelset(&s, SIGILL); - sigdelset(&s, SIGFPE); - sigdelset(&s, SIGTRAP); - pthread_sigmask(SIG_BLOCK, &s, old); +#define NS_DEFER 4 + +struct ns_cs { + int depth; + int count; + int sigs[NS_DEFER]; + siginfo_t info[NS_DEFER]; +}; + +static __thread struct ns_cs ns_cs; +static uintptr_t ns_handlers[_NSIG]; +static uint8_t ns_siginfo[_NSIG]; + +int bl_from_ntdll(const void *caller) __attribute__((visibility("hidden"))); + +static int ns_deferrable(int sig) { + return sig > 0 && sig < _NSIG && sig != SIGKILL && sig != SIGSTOP && sig != SIGSEGV && sig != SIGBUS && sig != SIGILL + && sig != SIGFPE && sig != SIGTRAP && sig != SIGSYS; } -static void ns_restore(const sigset_t *old) { - pthread_sigmask(SIG_SETMASK, old, NULL); +static int ns_defer(int sig, const siginfo_t *si) { + struct ns_cs *cs = &ns_cs; + if (sig < SIGRTMIN) + for (int i = 0; i < cs->count; i++) + if (cs->sigs[i] == sig) return 1; + if (cs->count >= NS_DEFER) return 0; + cs->sigs[cs->count] = sig; + if (si) memcpy(&cs->info[cs->count], si, sizeof(*si)); + else memset(&cs->info[cs->count], 0, sizeof(*si)); + cs->count++; + return 1; +} + +static void ns_trampoline(int sig, siginfo_t *si, void *uc) { + if (__atomic_load_n(&ns_cs.depth, __ATOMIC_RELAXED) > 0 && ns_defer(sig, si)) return; + uintptr_t h = __atomic_load_n(&ns_handlers[sig], __ATOMIC_ACQUIRE); + if (!h) return; + if (__atomic_load_n(&ns_siginfo[sig], __ATOMIC_RELAXED)) ((void (*)(int, siginfo_t *, void *))h)(sig, si, uc); + else ((void (*)(int))h)(sig); +} + +static void ns_flush(void) { + struct ns_cs *cs = &ns_cs; + int n = cs->count, sigs[NS_DEFER]; + siginfo_t info[NS_DEFER]; + memcpy(sigs, cs->sigs, sizeof(sigs)); + memcpy(info, cs->info, sizeof(info)); + cs->count = 0; + int saved = errno; + pid_t pid = getpid(), tid = (pid_t)ns_self(); + for (int i = 0; i < n; i++) + if (syscall(SYS_rt_tgsigqueueinfo, pid, tid, sigs[i], &info[i]) != 0) syscall(SYS_tgkill, pid, tid, sigs[i]); + errno = saved; +} + +static void ns_block(void) { + ns_cs.depth++; + __atomic_signal_fence(__ATOMIC_SEQ_CST); +} + +static void ns_restore(void) { + __atomic_signal_fence(__ATOMIC_SEQ_CST); + if (--ns_cs.depth == 0) { + __atomic_signal_fence(__ATOMIC_SEQ_CST); + if (ns_cs.count) ns_flush(); + } +} + +int sigaction(int sig, const struct sigaction *act, struct sigaction *old) { + static int (*real)(int, const struct sigaction *, struct sigaction *); + if (!real) real = (int (*)(int, const struct sigaction *, struct sigaction *))dlsym(RTLD_NEXT, "sigaction"); + if (!real) { + errno = ENOSYS; + return -1; + } + if (!ns_deferrable(sig) || !ns_on()) return real(sig, act, old); + uintptr_t prev = __atomic_load_n(&ns_handlers[sig], __ATOMIC_ACQUIRE); + uint8_t prev_info = __atomic_load_n(&ns_siginfo[sig], __ATOMIC_RELAXED); + struct sigaction mine; + const struct sigaction *use = act; + if (act && act->sa_handler != SIG_DFL && act->sa_handler != SIG_IGN && bl_from_ntdll(__builtin_return_address(0))) { + mine = *act; + mine.sa_sigaction = ns_trampoline; + mine.sa_flags |= SA_SIGINFO; + __atomic_store_n(&ns_siginfo[sig], (act->sa_flags & SA_SIGINFO) ? 1 : 0, __ATOMIC_RELAXED); + __atomic_store_n(&ns_handlers[sig], (uintptr_t)act->sa_sigaction, __ATOMIC_RELEASE); + use = &mine; + } + int r = real(sig, use, old); + if (r != 0 && use == &mine) { + __atomic_store_n(&ns_siginfo[sig], prev_info, __ATOMIC_RELAXED); + __atomic_store_n(&ns_handlers[sig], prev, __ATOMIC_RELEASE); + } + if (r == 0 && old && old->sa_sigaction == ns_trampoline) { + old->sa_sigaction = (void (*)(int, siginfo_t *, void *))prev; + if (!prev_info) old->sa_flags &= ~SA_SIGINFO; + } + return r; } static inline struct ns_obj *ns_obj(struct ns_head *h, uint32_t s) { @@ -378,10 +465,11 @@ static int ns_claim(struct ns_q *q, int32_t index) { if (dead) return 0; } int32_t want = -1; - return __atomic_compare_exchange_n(&q->signaled, &want, index, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED); + return __atomic_compare_exchange_n(&q->signaled, &want, index, 0, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); } static void ns_wake(struct ns_q *q) { + if (!__atomic_load_n(&q->sleeping, __ATOMIC_SEQ_CST)) return; int saved = errno; ns_futex(&q->signaled, FUTEX_WAKE, 1, NULL, 0); errno = saved; @@ -618,14 +706,13 @@ static void ns_dev_put_locked(struct ns_dev *d) { static void ns_dev_put(struct ns_dev *d) { if (__atomic_sub_fetch(&d->refs, 1, __ATOMIC_ACQ_REL)) return; - sigset_t old; int saved = errno; - ns_block(&old); + ns_block(); pthread_mutex_lock(&ns_mx); uint32_t zero = 0; if (d->h && __atomic_compare_exchange_n(&d->refs, &zero, NS_DEAD, 0, __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE)) ns_release(d); pthread_mutex_unlock(&ns_mx); - ns_restore(&old); + ns_restore(); errno = saved; } @@ -682,20 +769,18 @@ static void ns_forget_locked(int fd) { } static void ns_forget(int fd) { - sigset_t old; int saved = errno; - ns_block(&old); + ns_block(); pthread_mutex_lock(&ns_mx); ns_forget_locked(fd); pthread_mutex_unlock(&ns_mx); - ns_restore(&old); + ns_restore(); errno = saved; } static uint64_t ns_adopt(struct ns_dev *d, uint32_t tag, int fd, uint32_t gen, uint32_t s) { uint64_t e = 0; - sigset_t old; - ns_block(&old); + ns_block(); pthread_mutex_lock(&ns_mx); if (!d->h || d->tag != tag || !ns_table() || ns_attach(d) < 0 || s >= NS_SLOTS) goto out; if ((e = __atomic_load_n(&ns_fdt[fd], __ATOMIC_ACQUIRE))) goto out; @@ -710,7 +795,7 @@ static uint64_t ns_adopt(struct ns_dev *d, uint32_t tag, int fd, uint32_t gen, u ns_unlock(&o->lock); out: pthread_mutex_unlock(&ns_mx); - ns_restore(&old); + ns_restore(); return e; } @@ -719,8 +804,7 @@ static uint64_t ns_note_device(int fd) { uint64_t e = 0; if (syscall(SYS_fstat, fd, &st) != 0 || !S_ISREG(st.st_mode)) return 0; if (((uint64_t)st.st_size & ~0xffffull) != NS_DEV_MAGIC) return 0; - sigset_t old; - ns_block(&old); + ns_block(); pthread_mutex_lock(&ns_mx); struct ns_dev *d = ns_table() ? ns_map(fd, (uint32_t)st.st_size & 0xffff, (uint64_t)st.st_ino) : NULL; if (d) { @@ -732,7 +816,7 @@ static uint64_t ns_note_device(int fd) { } } pthread_mutex_unlock(&ns_mx); - ns_restore(&old); + ns_restore(); return e; } @@ -773,15 +857,14 @@ static int ns_ready(struct ns_dev *d) { static void ns_thread_gone(void *p) { struct ns_tls *t = p; - if (!t || !t->d || !t->q) return; - sigset_t old; + if (!t || !t->d) return; struct ns_dev *d = t->d; - ns_block(&old); - ns_free_q(d->h, t->q - 1); + ns_block(); + if (t->q) ns_free_q(d->h, t->q - 1); t->q = 0; t->waiting = 0; t->d = NULL; - ns_restore(&old); + ns_restore(); ns_dev_put(d); } @@ -789,24 +872,36 @@ static void ns_key_init(void) { pthread_key_create(&ns_key, ns_thread_gone); } -static struct ns_q *ns_thread_q(struct ns_dev *d, uint32_t *qi) { - struct ns_head *h = d->h; - if (ns_tq.d && ns_tq.q && ns_tq.waiting) { - ns_drop_q(ns_tq.d->h, ns_tq.q - 1); - ns_tq.waiting = 0; - } - if (ns_tq.d == d && ns_tq.q) { - *qi = ns_tq.q - 1; - return ns_q(h, *qi); - } - if (ns_tq.d && ns_tq.q) { - struct ns_dev *old = ns_tq.d; - ns_free_q(old->h, ns_tq.q - 1); +static int ns_hold(struct ns_dev *d) { + if (ns_tq.d == d) return 1; + if (!ns_dev_get(d)) return 0; + struct ns_dev *old = ns_tq.d; + if (old) { + ns_block(); + if (ns_tq.q) ns_free_q(old->h, ns_tq.q - 1); ns_tq.q = 0; + ns_tq.waiting = 0; ns_tq.d = NULL; + ns_restore(); ns_dev_put(old); } pthread_once(&ns_once, ns_key_init); + ns_tq.d = d; + pthread_setspecific(ns_key, &ns_tq); + return 1; +} + +static struct ns_q *ns_thread_q(struct ns_dev *d, uint32_t *qi) { + struct ns_head *h = d->h; + if (ns_tq.d != d) return NULL; + if (ns_tq.q && ns_tq.waiting) { + ns_drop_q(h, ns_tq.q - 1); + ns_tq.waiting = 0; + } + if (ns_tq.q) { + *qi = ns_tq.q - 1; + return ns_q(h, *qi); + } uint32_t i; if (!ns_pop(h, &h->q_free, 0, &i) && !ns_grow(&h->q_hwm, NS_QS, &i)) { ns_sweep_dead(h); @@ -815,22 +910,19 @@ static struct ns_q *ns_thread_q(struct ns_dev *d, uint32_t *qi) { struct ns_q *q = ns_q(h, i); q->proc = (uint32_t)d->proc; q->waiting = 0; + q->sleeping = 0; q->inuse = 1; - __atomic_add_fetch(&d->refs, 1, __ATOMIC_ACQ_REL); - ns_tq.d = d; ns_tq.q = i + 1; ns_tq.waiting = 0; - pthread_setspecific(ns_key, &ns_tq); *qi = i; return q; } static int ns_create(struct ns_dev *d, int type, uint32_t a, uint32_t b) { struct ns_head *h = d->h; - sigset_t old; int fd = -1, err = 0; uint32_t s = 0; - ns_block(&old); + ns_block(); pthread_mutex_lock(&ns_mx); if (!ns_table() || ns_attach(d) < 0) { err = ENOMEM; @@ -879,7 +971,7 @@ static int ns_create(struct ns_dev *d, int type, uint32_t a, uint32_t b) { ns_unlock(&o->lock); out: pthread_mutex_unlock(&ns_mx); - ns_restore(&old); + ns_restore(); if (fd < 0) errno = err; return fd; } @@ -890,6 +982,20 @@ static int ns_expired(const struct ns_wait_args *args) { return (uint64_t)now.tv_sec * 1000000000ull + (uint64_t)now.tv_nsec >= args->timeout; } +static uint64_t ns_now(void) { + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + return (uint64_t)now.tv_sec * 1000000000ull + (uint64_t)now.tv_nsec; +} + +static void ns_spin(struct ns_q *q) { + uint64_t end = ns_now() + NS_SPIN_NS; + for (unsigned i = 1; __atomic_load_n(&q->signaled, __ATOMIC_ACQUIRE) == -1; i++) { + ns_relax(); + if (!(i & 63) && ns_now() >= end) return; + } +} + static int ns_sleep(struct ns_q *q, const struct ns_wait_args *args) { struct timespec ts, *tsp = NULL; int op = FUTEX_WAIT_BITSET | ((args->flags & NS_WAIT_REALTIME) ? FUTEX_CLOCK_REALTIME : 0); @@ -898,14 +1004,45 @@ static int ns_sleep(struct ns_q *q, const struct ns_wait_args *args) { ts.tv_nsec = (long)(args->timeout % 1000000000ull); tsp = &ts; } - while (__atomic_load_n(&q->signaled, __ATOMIC_ACQUIRE) == -1) { - if (tsp && ns_expired(args)) return ETIMEDOUT; - if (ns_futex(&q->signaled, op, (uint32_t)-1, tsp, FUTEX_BITSET_MATCH_ANY) == -1) { - if (errno == ETIMEDOUT) return ETIMEDOUT; - if (errno == EINTR) return EINTR; - } + ns_spin(q); + int ret = 0; + __atomic_store_n(&q->sleeping, 1, __ATOMIC_SEQ_CST); + while (!ret && __atomic_load_n(&q->signaled, __ATOMIC_SEQ_CST) == -1) { + if (tsp && ns_expired(args)) ret = ETIMEDOUT; + else if (ns_futex(&q->signaled, op, (uint32_t)-1, tsp, FUTEX_BITSET_MATCH_ANY) == -1 && (errno == ETIMEDOUT || errno == EINTR)) + ret = errno; } - return 0; + __atomic_store_n(&q->sleeping, 0, __ATOMIC_RELAXED); + return ret; +} + +static int ns_try_any(struct ns_head *h, const uint32_t *slots, const uint32_t *gens, uint32_t total, uint32_t owner, int *dead) { + for (uint32_t i = 0; i < total; i++) { + struct ns_obj *o = ns_obj(h, slots[i]); + ns_lock(&o->lock); + int busy = o->type == NS_FREE || o->gen != gens[i] || o->any_head || o->all_hint; + if (!busy && ns_signaled(o, owner)) { + switch (o->type) { + case NS_SEM: + o->a--; + break; + case NS_MUTEX: + *dead = (int)o->ownerdead; + o->ownerdead = 0; + o->a++; + o->b = owner; + break; + case NS_EVENT: + if (!o->a) o->b = 0; + break; + } + ns_unlock(&o->lock); + return (int)i; + } + ns_unlock(&o->lock); + if (busy) return -1; + } + return -2; } static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { @@ -927,12 +1064,23 @@ static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { for (uint32_t j = 0; j < i; j++) if (slots[j] == slots[i]) return EINVAL; } - sigset_t old; - ns_block(&old); + ns_block(); + if (!all && !ns_tq.waiting) { + int dead = 0, got = ns_try_any(h, slots, gens, total, args.owner, &dead); + if (got >= 0) { + ns_restore(); + ua->index = (uint32_t)got; + return dead ? EOWNERDEAD : 0; + } + if (got == -2 && args.timeout != UINT64_MAX && ns_expired(&args)) { + ns_restore(); + return ETIMEDOUT; + } + } uint32_t qi; struct ns_q *q = ns_ready(d) ? ns_thread_q(d, &qi) : NULL; if (!q) { - ns_restore(&old); + ns_restore(); return ENOMEM; } ns_maybe_sweep(h); @@ -1004,16 +1152,15 @@ static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { } int ret = 0; if (!bad && __atomic_load_n(&q->signaled, __ATOMIC_ACQUIRE) == -1) { - sigset_t held; - ns_restore(&old); + ns_restore(); ret = ns_sleep(q, &args); - ns_block(&held); + ns_block(); } ns_drop_q(h, qi); ns_tq.waiting = 0; int32_t got = __atomic_load_n(&q->signaled, __ATOMIC_ACQUIRE); int dead = (int)q->ownerdead; - ns_restore(&old); + ns_restore(); if (bad) return EINVAL; if (got != -1) { ua->index = (uint32_t)got; @@ -1061,12 +1208,11 @@ static int ns_obj_ioctl(struct ns_dev *d, uint64_t e, unsigned long req, void *a return ENOTTY; } if (type != (uint32_t)want) return EINVAL; - sigset_t old; - ns_block(&old); + ns_block(); int all = ns_lock_obj(h, o); if (o->type != (uint32_t)want || o->gen != gen) { ns_unlock_obj(h, o, all); - ns_restore(&old); + ns_restore(); return EINVAL; } switch (req) { @@ -1133,7 +1279,7 @@ static int ns_obj_ioctl(struct ns_dev *d, uint64_t e, unsigned long req, void *a } } ns_unlock_obj(h, o, all); - ns_restore(&old); + ns_restore(); if (ret) return ret; if (req == NS_SEM_RELEASE || req == NS_EVENT_SET || req == NS_EVENT_RESET || req == NS_EVENT_PULSE) memcpy(arg, &prev, sizeof(prev)); @@ -1176,9 +1322,8 @@ int bl_ntsync_ioctl(int fd, unsigned long req, void *arg, int *rc) { uint64_t e = ns_lookup(fd); if (!e) return 0; struct ns_dev *d = &ns_devs[(e >> 56) & 7]; - if (!ns_dev_get(d)) return 0; + if (!ns_hold(d)) return 0; int out = 0, err = (e & NS_E_DEVICE) ? ns_dev_ioctl(d, req, arg, &out) : ns_obj_ioctl(d, e, req, arg); - ns_dev_put(d); if (err) { errno = err; *rc = -1; diff --git a/tools/tests/test_ntsync_preload.py b/tools/tests/test_ntsync_preload.py new file mode 100644 index 0000000000..e05178c8d4 --- /dev/null +++ b/tools/tests/test_ntsync_preload.py @@ -0,0 +1,456 @@ +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + +PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload" + +NTDLL = r""" +#define _GNU_SOURCE +#include +#include + +int install_handler(int sig, void (*fn)(int, siginfo_t *, void *), void **seen) { + struct sigaction sa, old; + memset(&sa, 0, sizeof(sa)); + sa.sa_sigaction = fn; + sa.sa_flags = SA_SIGINFO | SA_RESTART; + sigemptyset(&sa.sa_mask); + if (sigaction(sig, &sa, NULL) != 0) return -1; + if (sigaction(sig, NULL, &old) != 0) return -1; + *seen = (void *)old.sa_sigaction; + return 0; +} +""" + +PROGRAM = r""" +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct sem_args { uint32_t count, max; }; +struct mutex_args { uint32_t owner, count; }; +struct event_args { uint32_t manual, signaled; }; +struct wait_args { uint64_t timeout, objs; uint32_t count, index, flags, owner, alert, pad; }; +#define NT_CREATE_SEM _IOW('N', 0x80, struct sem_args) +#define NT_SEM_RELEASE _IOWR('N', 0x81, uint32_t) +#define NT_WAIT_ANY _IOWR('N', 0x82, struct wait_args) +#define NT_WAIT_ALL _IOWR('N', 0x83, struct wait_args) +#define NT_CREATE_MUTEX _IOW('N', 0x84, struct mutex_args) +#define NT_MUTEX_UNLOCK _IOWR('N', 0x85, struct mutex_args) +#define NT_MUTEX_KILL _IOW('N', 0x86, uint32_t) +#define NT_CREATE_EVENT _IOW('N', 0x87, struct event_args) +#define NT_EVENT_SET _IOR('N', 0x88, uint32_t) +#define NT_EVENT_RESET _IOR('N', 0x89, uint32_t) +#define NT_EVENT_PULSE _IOR('N', 0x8a, uint32_t) +#define NT_SEM_READ _IOR('N', 0x8b, struct sem_args) +#define NT_MUTEX_READ _IOR('N', 0x8c, struct mutex_args) +#define NT_EVENT_READ _IOR('N', 0x8d, struct event_args) + +int install_handler(int sig, void (*fn)(int, siginfo_t *, void *), void **seen); + +static int dev, fails; +#define CHECK(name, cond) do { if (!(cond)) { printf("FAIL %s line %d errno %d\n", name, __LINE__, errno); fails++; } } while (0) + +static uint64_t mono_ns(int64_t delta_ms) { + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + return (uint64_t)t.tv_sec * 1000000000ull + (uint64_t)t.tv_nsec + (uint64_t)(delta_ms * 1000000); +} + +static int wait_on(unsigned long req, const int *objs, uint32_t count, uint32_t owner, int alert, uint64_t timeout, uint32_t *index) { + struct wait_args w = {timeout, (uintptr_t)objs, count, 0xdead, 0, owner, (uint32_t)alert, 0}; + int r = ioctl(dev, req, &w); + if (index) *index = w.index; + return r < 0 ? errno : 0; +} + +static int event(int manual, int signaled) { + struct event_args a = {(uint32_t)manual, (uint32_t)signaled}; + return ioctl(dev, NT_CREATE_EVENT, &a); +} + +static int sem(uint32_t count, uint32_t max) { + struct sem_args a = {count, max}; + return ioctl(dev, NT_CREATE_SEM, &a); +} + +static int mutex(uint32_t owner, uint32_t count) { + struct mutex_args a = {owner, count}; + return ioctl(dev, NT_CREATE_MUTEX, &a); +} + +static uint32_t prev_of(int fd, unsigned long req, uint32_t in) { + uint32_t v = in; + if (ioctl(fd, req, &v) < 0) return 0xffffffff; + return v; +} + +static void semaphores(void) { + struct sem_args bad = {3, 2}, r; + CHECK("sem_create_invalid", ioctl(dev, NT_CREATE_SEM, &bad) < 0 && errno == EINVAL); + int s = sem(2, 2); + CHECK("sem_create", s >= 0); + uint32_t idx; + CHECK("sem_wait1", wait_on(NT_WAIT_ANY, &s, 1, 1, 0, 0, &idx) == 0 && idx == 0); + CHECK("sem_wait2", wait_on(NT_WAIT_ANY, &s, 1, 1, 0, 0, &idx) == 0); + CHECK("sem_empty", wait_on(NT_WAIT_ANY, &s, 1, 1, 0, 0, NULL) == ETIMEDOUT); + CHECK("sem_release_prev", prev_of(s, NT_SEM_RELEASE, 1) == 0); + CHECK("sem_overflow", prev_of(s, NT_SEM_RELEASE, 2) == 0xffffffff && errno == EOVERFLOW); + CHECK("sem_read", ioctl(s, NT_SEM_READ, &r) == 0 && r.count == 1 && r.max == 2); + close(s); +} + +static void mutexes(void) { + struct mutex_args bad = {0, 1}, r, u; + CHECK("mutex_create_invalid", ioctl(dev, NT_CREATE_MUTEX, &bad) < 0 && errno == EINVAL); + int m = mutex(0, 0); + uint32_t idx; + CHECK("mutex_owner_zero", wait_on(NT_WAIT_ANY, &m, 1, 0, 0, 0, NULL) == EINVAL); + CHECK("mutex_take", wait_on(NT_WAIT_ANY, &m, 1, 7, 0, 0, &idx) == 0 && idx == 0); + CHECK("mutex_recurse", wait_on(NT_WAIT_ANY, &m, 1, 7, 0, 0, NULL) == 0); + CHECK("mutex_other", wait_on(NT_WAIT_ANY, &m, 1, 8, 0, 0, NULL) == ETIMEDOUT); + CHECK("mutex_read", ioctl(m, NT_MUTEX_READ, &r) == 0 && r.owner == 7 && r.count == 2); + u = (struct mutex_args){8, 0}; + CHECK("mutex_unlock_eperm", ioctl(m, NT_MUTEX_UNLOCK, &u) < 0 && errno == EPERM); + u = (struct mutex_args){0, 0}; + CHECK("mutex_unlock_einval", ioctl(m, NT_MUTEX_UNLOCK, &u) < 0 && errno == EINVAL); + u = (struct mutex_args){7, 0}; + CHECK("mutex_unlock_prev", ioctl(m, NT_MUTEX_UNLOCK, &u) == 0 && u.count == 2); + uint32_t who = 8; + CHECK("mutex_kill_eperm", ioctl(m, NT_MUTEX_KILL, &who) < 0 && errno == EPERM); + who = 7; + CHECK("mutex_kill", ioctl(m, NT_MUTEX_KILL, &who) == 0); + CHECK("mutex_read_dead", ioctl(m, NT_MUTEX_READ, &r) < 0 && errno == EOWNERDEAD && r.owner == 0 && r.count == 0); + CHECK("mutex_abandoned", wait_on(NT_WAIT_ANY, &m, 1, 9, 0, 0, &idx) == EOWNERDEAD && idx == 0); + CHECK("mutex_after_abandon", ioctl(m, NT_MUTEX_READ, &r) == 0 && r.owner == 9 && r.count == 1); + close(m); +} + +static void events(void) { + int a = event(0, 1), m = event(1, 0); + struct event_args r; + CHECK("auto_take", wait_on(NT_WAIT_ANY, &a, 1, 1, 0, 0, NULL) == 0); + CHECK("auto_consumed", wait_on(NT_WAIT_ANY, &a, 1, 1, 0, 0, NULL) == ETIMEDOUT); + CHECK("set_prev0", prev_of(m, NT_EVENT_SET, 0) == 0); + CHECK("set_prev1", prev_of(m, NT_EVENT_SET, 0) == 1); + CHECK("manual_kept", wait_on(NT_WAIT_ANY, &m, 1, 1, 0, 0, NULL) == 0 && wait_on(NT_WAIT_ANY, &m, 1, 1, 0, 0, NULL) == 0); + CHECK("reset_prev", prev_of(m, NT_EVENT_RESET, 0) == 1); + CHECK("pulse_prev", prev_of(m, NT_EVENT_PULSE, 0) == 0); + CHECK("pulse_leaves_unsignaled", ioctl(m, NT_EVENT_READ, &r) == 0 && r.manual == 1 && r.signaled == 0); + close(a); + close(m); +} + +static void any_order(void) { + int o[4] = {event(1, 0), sem(1, 5), event(1, 1), sem(0, 5)}; + int alert = event(0, 1); + uint32_t idx; + CHECK("any_lowest", wait_on(NT_WAIT_ANY, o, 4, 1, alert, 0, &idx) == 0 && idx == 1); + CHECK("any_next", wait_on(NT_WAIT_ANY, o, 4, 1, alert, 0, &idx) == 0 && idx == 2); + prev_of(o[2], NT_EVENT_RESET, 0); + CHECK("any_alert", wait_on(NT_WAIT_ANY, o, 4, 1, alert, 0, &idx) == 0 && idx == 4); + CHECK("any_alert_consumed", wait_on(NT_WAIT_ANY, o, 4, 1, alert, 0, NULL) == ETIMEDOUT); + int dup[3] = {o[3], o[0], o[3]}; + prev_of(o[3], NT_SEM_RELEASE, 1); + CHECK("any_duplicate_lowest", wait_on(NT_WAIT_ANY, dup, 3, 1, 0, 0, &idx) == 0 && idx == 0); + int many[65]; + for (int i = 0; i < 65; i++) many[i] = o[0]; + CHECK("any_too_many", wait_on(NT_WAIT_ANY, many, 65, 1, 0, 0, NULL) == EINVAL); + int badfd = 0; + CHECK("any_invalid_fd", wait_on(NT_WAIT_ANY, &badfd, 1, 1, 0, 0, NULL) == EINVAL); + CHECK("any_timeout", wait_on(NT_WAIT_ANY, o, 1, 1, 0, mono_ns(30), NULL) == ETIMEDOUT); + for (int i = 0; i < 4; i++) close(o[i]); + close(alert); +} + +static void all_semantics(void) { + int s = sem(1, 5), e = event(0, 0), m = mutex(0, 0); + int o[3] = {s, e, m}; + struct sem_args sr; + uint32_t idx; + CHECK("all_not_ready", wait_on(NT_WAIT_ALL, o, 3, 4, 0, 0, NULL) == ETIMEDOUT); + CHECK("all_untouched", ioctl(s, NT_SEM_READ, &sr) == 0 && sr.count == 1); + prev_of(e, NT_EVENT_SET, 0); + CHECK("all_ready", wait_on(NT_WAIT_ALL, o, 3, 4, 0, 0, &idx) == 0 && idx == 0); + CHECK("all_took_sem", ioctl(s, NT_SEM_READ, &sr) == 0 && sr.count == 0); + int dup[2] = {s, s}; + CHECK("all_duplicate", wait_on(NT_WAIT_ALL, dup, 2, 4, 0, 0, NULL) == EINVAL); + int alert = event(1, 1); + CHECK("all_alert", wait_on(NT_WAIT_ALL, o, 3, 4, alert, 0, &idx) == 0 && idx == 3); + close(s); + close(e); + close(m); + close(alert); +} + +static int wake_obj; +static uint32_t wake_index; +static int wake_ret; +static void *waiter(void *p) { + int all = (int)(intptr_t)p; + int objs[2] = {wake_obj, wake_obj + 0}; + wake_ret = wait_on(all ? NT_WAIT_ALL : NT_WAIT_ANY, objs, 1, 3, 0, UINT64_MAX, &wake_index); + return NULL; +} + +static void cross_thread(void) { + wake_obj = event(0, 0); + pthread_t t; + pthread_create(&t, NULL, waiter, NULL); + usleep(30000); + prev_of(wake_obj, NT_EVENT_SET, 0); + pthread_join(t, NULL); + CHECK("thread_wake", wake_ret == 0 && wake_index == 0); + struct event_args r; + CHECK("thread_auto_reset", ioctl(wake_obj, NT_EVENT_READ, &r) == 0 && r.signaled == 0); + close(wake_obj); + int s = sem(0, 10); + wake_obj = s; + pthread_t ts[3]; + for (int i = 0; i < 3; i++) pthread_create(&ts[i], NULL, waiter, NULL); + usleep(30000); + CHECK("sem_release_three", prev_of(s, NT_SEM_RELEASE, 3) == 0); + for (int i = 0; i < 3; i++) pthread_join(ts[i], NULL); + struct sem_args sr; + CHECK("sem_all_taken", ioctl(s, NT_SEM_READ, &sr) == 0 && sr.count == 0); + close(s); +} + +static void cross_process(void) { + int sv[2]; + CHECK("socketpair", socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0); + int inherited = event(0, 0); + pid_t pid = fork(); + if (pid == 0) { + uint32_t idx; + int r1 = wait_on(NT_WAIT_ANY, &inherited, 1, 5, 0, mono_ns(5000), &idx); + char c; + struct iovec io = {&c, 1}; + char cbuf[CMSG_SPACE(sizeof(int))]; + struct msghdr msg = {0}; + msg.msg_iov = &io; + msg.msg_iovlen = 1; + msg.msg_control = cbuf; + msg.msg_controllen = sizeof(cbuf); + int got = -1; + if (recvmsg(sv[1], &msg, 0) == 1) memcpy(&got, CMSG_DATA(CMSG_FIRSTHDR(&msg)), sizeof(int)); + int r2 = wait_on(NT_WAIT_ANY, &got, 1, 5, 0, mono_ns(5000), NULL); + _exit(r1 == 0 && r2 == 0 ? 0 : 1); + } + usleep(30000); + prev_of(inherited, NT_EVENT_SET, 0); + int sent = sem(0, 1); + char c = 'x'; + struct iovec io = {&c, 1}; + char cbuf[CMSG_SPACE(sizeof(int))]; + struct msghdr msg = {0}; + msg.msg_iov = &io; + msg.msg_iovlen = 1; + msg.msg_control = cbuf; + msg.msg_controllen = sizeof(cbuf); + struct cmsghdr *cm = CMSG_FIRSTHDR(&msg); + cm->cmsg_level = SOL_SOCKET; + cm->cmsg_type = SCM_RIGHTS; + cm->cmsg_len = CMSG_LEN(sizeof(int)); + memcpy(CMSG_DATA(cm), &sent, sizeof(int)); + sendmsg(sv[0], &msg, 0); + usleep(30000); + prev_of(sent, NT_SEM_RELEASE, 1); + int status = 0; + waitpid(pid, &status, 0); + CHECK("process_wake", WIFEXITED(status) && WEXITSTATUS(status) == 0); + close(inherited); + close(sent); + close(sv[0]); + close(sv[1]); +} + +static int ping_obj, pong_obj, stress_sem; +static void *stress_ponger(void *p) { + long n = (long)p; + uint32_t v; + for (long i = 0; i < n; i++) { + if (wait_on(NT_WAIT_ANY, &ping_obj, 1, 21, 0, UINT64_MAX, NULL) != 0) return (void *)1; + ioctl(pong_obj, NT_EVENT_SET, &v); + } + return NULL; +} +static void *stress_hammer(void *p) { + long n = (long)p; + for (long i = 0; i < n; i++) { + if (wait_on(NT_WAIT_ANY, &stress_sem, 1, 22, 0, UINT64_MAX, NULL) != 0) return (void *)1; + uint32_t c = 1; + ioctl(stress_sem, NT_SEM_RELEASE, &c); + } + return NULL; +} + +static void stress(void) { + long rounds = 20000; + ping_obj = event(0, 0); + pong_obj = event(0, 0); + pthread_t t; + void *bad = NULL; + pthread_create(&t, NULL, stress_ponger, (void *)rounds); + uint32_t v; + int ok = 1; + for (long i = 0; i < rounds && ok; i++) { + ioctl(ping_obj, NT_EVENT_SET, &v); + ok = wait_on(NT_WAIT_ANY, &pong_obj, 1, 20, 0, UINT64_MAX, NULL) == 0; + } + pthread_join(t, &bad); + CHECK("stress_pingpong", ok && bad == NULL); + stress_sem = sem(1, 1); + pthread_t th[4]; + for (int i = 0; i < 4; i++) pthread_create(&th[i], NULL, stress_hammer, (void *)5000L); + int hammer_ok = 1; + for (int i = 0; i < 4; i++) { + pthread_join(th[i], &bad); + hammer_ok &= bad == NULL; + } + struct sem_args sr; + CHECK("stress_contended", hammer_ok && ioctl(stress_sem, NT_SEM_READ, &sr) == 0 && sr.count == 1); + close(ping_obj); + close(pong_obj); + close(stress_sem); +} + +static int busy_obj; +static volatile int handled, stop_worker; +static sem_t parked, unpark; +static void reentrant(int sig, siginfo_t *si, void *uc) { + (void)sig; (void)si; (void)uc; + uint32_t v = 0; + ioctl(busy_obj, NT_EVENT_SET, &v); + handled++; +} +static void suspending(int sig, siginfo_t *si, void *uc) { + (void)sig; (void)si; (void)uc; + sem_post(&parked); + while (sem_wait(&unpark) != 0) {} + handled++; +} +static void *worker(void *p) { + (void)p; + uint32_t v; + while (!stop_worker) { + ioctl(busy_obj, NT_EVENT_SET, &v); + wait_on(NT_WAIT_ANY, &busy_obj, 1, 11, 0, 0, NULL); + } + return NULL; +} + +static void signals(void) { + void *seen = NULL; + busy_obj = event(0, 0); + CHECK("install_reentrant", install_handler(SIGUSR1, reentrant, &seen) == 0); + CHECK("query_original", seen == (void *)reentrant); + pthread_t w; + stop_worker = 0; + handled = 0; + pthread_create(&w, NULL, worker, NULL); + for (int i = 0; i < 2000; i++) { + pthread_kill(w, SIGUSR1); + if (i % 64 == 0) usleep(100); + } + usleep(20000); + stop_worker = 1; + pthread_join(w, NULL); + CHECK("reentrant_ran", handled > 0); + sem_init(&parked, 0, 0); + sem_init(&unpark, 0, 0); + CHECK("install_suspending", install_handler(SIGUSR1, suspending, &seen) == 0); + stop_worker = 0; + handled = 0; + pthread_create(&w, NULL, worker, NULL); + uint32_t v; + for (int i = 0; i < 300; i++) { + pthread_kill(w, SIGUSR1); + while (sem_wait(&parked) != 0) {} + ioctl(busy_obj, NT_EVENT_SET, &v); + wait_on(NT_WAIT_ANY, &busy_obj, 1, 12, 0, 0, NULL); + sem_post(&unpark); + } + stop_worker = 1; + pthread_join(w, NULL); + CHECK("suspend_ran", handled == 300); + close(busy_obj); +} + +int main(void) { + alarm(60); + dev = open("/dev/ntsync", O_RDWR | O_CLOEXEC); + if (dev < 0) { + printf("no device %d\n", errno); + return 1; + } + semaphores(); + mutexes(); + events(); + any_order(); + all_semantics(); + cross_thread(); + cross_process(); + stress(); + signals(); + printf("done fails=%d\n", fails); + return fails != 0; +} +""" + + +class NtsyncPreloadTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + if not shutil.which("cc"): + raise unittest.SkipTest("no compiler") + cls.tmp = tempfile.TemporaryDirectory() + tmp = Path(cls.tmp.name) + (tmp / "ntdll.c").write_text(NTDLL) + (tmp / "prog.c").write_text(PROGRAM) + sources = sorted(str(p) for p in PRELOAD.glob("*.c")) + subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-Wall", "-pthread", "-o", str(tmp / "libblsession.so"), *sources, "-ldl"], + check=True) + subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-o", str(tmp / "ntdll.so"), str(tmp / "ntdll.c")], check=True) + subprocess.run(["cc", "-O1", "-pthread", "-o", str(tmp / "prog"), str(tmp / "prog.c"), str(tmp / "ntdll.so"), + "-Wl,-rpath," + str(tmp)], check=True) + cls.program = tmp / "prog" + cls.preload = tmp / "libblsession.so" + + @classmethod + def tearDownClass(cls): + cls.tmp.cleanup() + + def run_program(self): + env = dict(os.environ, LD_PRELOAD=str(self.preload), BL_SYNC="1") + return subprocess.run([str(self.program)], env=env, capture_output=True, text=True, timeout=90) + + def test_emulation_matches_the_ntsync_driver(self): + out = self.run_program() + self.assertEqual(out.returncode, 0, out.stdout + out.stderr) + self.assertIn("done fails=0", out.stdout) + + def test_repeated_runs_stay_consistent(self): + for _ in range(3): + out = self.run_program() + self.assertEqual(out.returncode, 0, out.stdout + out.stderr) + + +if __name__ == "__main__": + unittest.main() From 77dd04ec8c3fe7c2d3074e625dc62e5ec56de501 Mon Sep 17 00:00:00 2001 From: maxjivi05 Date: Fri, 23 Oct 2026 12:15:43 -0400 Subject: [PATCH 2/4] fix: droiddeck-ntsync keeps protection when more than four signals arrive and keeps waits intact when a handler waits again - A fifth distinct signal inside a critical section is now held pending with the thread's signal mask and released once the section ends, instead of running its handler while an object lock is held. - A wait from a signal handler during another wait's sleep uses its own queue and, for a second device, a reference for that call only, so the outer wait keeps its queue and can't return the inner wait's result. --- tools/linuxfs/preload/ntsync.c | 84 ++++++++++++++++++++++------- tools/tests/test_ntsync_preload.py | 87 ++++++++++++++++++++++++++++++ 2 files changed, 153 insertions(+), 18 deletions(-) diff --git a/tools/linuxfs/preload/ntsync.c b/tools/linuxfs/preload/ntsync.c index 2b1c790459..76e50972d4 100644 --- a/tools/linuxfs/preload/ntsync.c +++ b/tools/linuxfs/preload/ntsync.c @@ -17,6 +17,7 @@ #include #include #include +#include #include struct ns_sem_args { @@ -170,6 +171,7 @@ struct ns_tls { struct ns_dev *d; uint32_t q; int waiting; + int sleep; }; static struct ns_dev ns_devs[NS_DEVS]; @@ -262,8 +264,10 @@ static void ns_unlock(uint32_t *w) { struct ns_cs { int depth; int count; + int nheld; int sigs[NS_DEFER]; siginfo_t info[NS_DEFER]; + sigset_t held; }; static __thread struct ns_cs ns_cs; @@ -290,8 +294,26 @@ static int ns_defer(int sig, const siginfo_t *si) { return 1; } +static int ns_park(int sig, const siginfo_t *si, ucontext_t *uc) { + sigset_t one; + sigemptyset(&one); + sigaddset(&one, sig); + int saved = errno; + pthread_sigmask(SIG_BLOCK, &one, NULL); + pid_t pid = getpid(), tid = (pid_t)ns_self(); + int ok = (si && syscall(SYS_rt_tgsigqueueinfo, pid, tid, sig, si) == 0) || syscall(SYS_tgkill, pid, tid, sig) == 0; + if (!ok) pthread_sigmask(SIG_UNBLOCK, &one, NULL); + errno = saved; + if (!ok) return 0; + sigaddset(&uc->uc_sigmask, sig); + if (!ns_cs.nheld) sigemptyset(&ns_cs.held); + sigaddset(&ns_cs.held, sig); + ns_cs.nheld = 1; + return 1; +} + static void ns_trampoline(int sig, siginfo_t *si, void *uc) { - if (__atomic_load_n(&ns_cs.depth, __ATOMIC_RELAXED) > 0 && ns_defer(sig, si)) return; + if (__atomic_load_n(&ns_cs.depth, __ATOMIC_RELAXED) > 0 && (ns_defer(sig, si) || (uc && ns_park(sig, si, uc)))) return; uintptr_t h = __atomic_load_n(&ns_handlers[sig], __ATOMIC_ACQUIRE); if (!h) return; if (__atomic_load_n(&ns_siginfo[sig], __ATOMIC_RELAXED)) ((void (*)(int, siginfo_t *, void *))h)(sig, si, uc); @@ -321,7 +343,19 @@ static void ns_restore(void) { __atomic_signal_fence(__ATOMIC_SEQ_CST); if (--ns_cs.depth == 0) { __atomic_signal_fence(__ATOMIC_SEQ_CST); + int nheld = ns_cs.nheld; + sigset_t held; + if (nheld) { + held = ns_cs.held; + ns_cs.nheld = 0; + __atomic_signal_fence(__ATOMIC_SEQ_CST); + } if (ns_cs.count) ns_flush(); + if (nheld) { + int saved = errno; + pthread_sigmask(SIG_UNBLOCK, &held, NULL); + errno = saved; + } } } @@ -875,6 +909,7 @@ static void ns_key_init(void) { static int ns_hold(struct ns_dev *d) { if (ns_tq.d == d) return 1; if (!ns_dev_get(d)) return 0; + if (ns_tq.sleep) return 2; struct ns_dev *old = ns_tq.d; if (old) { ns_block(); @@ -891,6 +926,22 @@ static int ns_hold(struct ns_dev *d) { return 1; } +static struct ns_q *ns_new_q(struct ns_dev *d, uint32_t *qi) { + struct ns_head *h = d->h; + uint32_t i; + if (!ns_pop(h, &h->q_free, 0, &i) && !ns_grow(&h->q_hwm, NS_QS, &i)) { + ns_sweep_dead(h); + if (!ns_pop(h, &h->q_free, 0, &i)) return NULL; + } + struct ns_q *q = ns_q(h, i); + q->proc = (uint32_t)d->proc; + q->waiting = 0; + q->sleeping = 0; + q->inuse = 1; + *qi = i; + return q; +} + static struct ns_q *ns_thread_q(struct ns_dev *d, uint32_t *qi) { struct ns_head *h = d->h; if (ns_tq.d != d) return NULL; @@ -902,19 +953,10 @@ static struct ns_q *ns_thread_q(struct ns_dev *d, uint32_t *qi) { *qi = ns_tq.q - 1; return ns_q(h, *qi); } - uint32_t i; - if (!ns_pop(h, &h->q_free, 0, &i) && !ns_grow(&h->q_hwm, NS_QS, &i)) { - ns_sweep_dead(h); - if (!ns_pop(h, &h->q_free, 0, &i)) return NULL; - } - struct ns_q *q = ns_q(h, i); - q->proc = (uint32_t)d->proc; - q->waiting = 0; - q->sleeping = 0; - q->inuse = 1; - ns_tq.q = i + 1; + struct ns_q *q = ns_new_q(d, qi); + if (!q) return NULL; + ns_tq.q = *qi + 1; ns_tq.waiting = 0; - *qi = i; return q; } @@ -1064,8 +1106,9 @@ static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { for (uint32_t j = 0; j < i; j++) if (slots[j] == slots[i]) return EINVAL; } + int nested = ns_tq.sleep > 0; ns_block(); - if (!all && !ns_tq.waiting) { + if (!all && (nested || !ns_tq.waiting)) { int dead = 0, got = ns_try_any(h, slots, gens, total, args.owner, &dead); if (got >= 0) { ns_restore(); @@ -1078,7 +1121,7 @@ static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { } } uint32_t qi; - struct ns_q *q = ns_ready(d) ? ns_thread_q(d, &qi) : NULL; + struct ns_q *q = !ns_ready(d) ? NULL : nested ? ns_new_q(d, &qi) : ns_thread_q(d, &qi); if (!q) { ns_restore(); return ENOMEM; @@ -1100,7 +1143,7 @@ static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { } q->total = total; q->waiting = 1; - ns_tq.waiting = 1; + if (!nested) ns_tq.waiting = 1; int bad = 0; if (!all) { for (uint32_t i = 0; i < total && !bad; i++) { @@ -1152,14 +1195,17 @@ static int ns_wait(struct ns_dev *d, struct ns_wait_args *ua, int all) { } int ret = 0; if (!bad && __atomic_load_n(&q->signaled, __ATOMIC_ACQUIRE) == -1) { + ns_tq.sleep++; ns_restore(); ret = ns_sleep(q, &args); ns_block(); + ns_tq.sleep--; } ns_drop_q(h, qi); - ns_tq.waiting = 0; + if (!nested) ns_tq.waiting = 0; int32_t got = __atomic_load_n(&q->signaled, __ATOMIC_ACQUIRE); int dead = (int)q->ownerdead; + if (nested) ns_free_q(h, qi); ns_restore(); if (bad) return EINVAL; if (got != -1) { @@ -1322,8 +1368,10 @@ int bl_ntsync_ioctl(int fd, unsigned long req, void *arg, int *rc) { uint64_t e = ns_lookup(fd); if (!e) return 0; struct ns_dev *d = &ns_devs[(e >> 56) & 7]; - if (!ns_hold(d)) return 0; + int held = ns_hold(d); + if (!held) return 0; int out = 0, err = (e & NS_E_DEVICE) ? ns_dev_ioctl(d, req, arg, &out) : ns_obj_ioctl(d, e, req, arg); + if (held == 2) ns_dev_put(d); if (err) { errno = err; *rc = -1; diff --git a/tools/tests/test_ntsync_preload.py b/tools/tests/test_ntsync_preload.py index e05178c8d4..34f3eaea45 100644 --- a/tools/tests/test_ntsync_preload.py +++ b/tools/tests/test_ntsync_preload.py @@ -393,6 +393,91 @@ static void signals(void) { close(busy_obj); } +static volatile int burst_count; +static void bursting(int sig, siginfo_t *si, void *uc) { + (void)sig; (void)si; (void)uc; + uint32_t v = 0; + ioctl(busy_obj, NT_EVENT_SET, &v); + __atomic_add_fetch(&burst_count, 1, __ATOMIC_RELAXED); +} + +static void bursts(void) { + void *seen = NULL; + busy_obj = event(0, 0); + for (int s = 0; s < 8; s++) CHECK("install_burst", install_handler(SIGRTMIN + s, bursting, &seen) == 0); + pthread_t w; + stop_worker = 0; + burst_count = 0; + pthread_create(&w, NULL, worker, NULL); + union sigval val = {0}; + int sent = 0; + for (int i = 0; i < 400; i++) { + for (int s = 0; s < 8; s++) + if (pthread_sigqueue(w, SIGRTMIN + s, val) == 0) sent++; + usleep(200); + } + for (int i = 0; i < 2000 && __atomic_load_n(&burst_count, __ATOMIC_RELAXED) < sent; i++) usleep(1000); + stop_worker = 1; + pthread_join(w, NULL); + CHECK("burst_all_handled", burst_count == sent && sent > 0); + close(busy_obj); +} + +static int outer_obj, inner_obj, other_dev, other_obj; +static volatile int nested_ok, nested_done, outer_done; +static void nesting(int sig, siginfo_t *si, void *uc) { + (void)sig; (void)si; (void)uc; + uint32_t idx = 99; + int ok = wait_on(NT_WAIT_ANY, &inner_obj, 1, 21, 0, mono_ns(50), &idx) == 0 && idx == 0; + struct wait_args w = {mono_ns(2), (uintptr_t)&other_obj, 1, 0xdead, 0, 22, 0, 0}; + ok = ok && ioctl(other_dev, NT_WAIT_ANY, &w) < 0 && errno == ETIMEDOUT; + nested_ok += ok; + __atomic_store_n(&nested_done, 1, __ATOMIC_RELEASE); +} +static void *outer_waiter(void *p) { + struct wait_args w = {mono_ns(3000), (uintptr_t)&outer_obj, 1, 99, 0, 23, 0, 0}; + int r; + do { r = ioctl(dev, NT_WAIT_ANY, &w); } while (r < 0 && errno == EINTR); + *(int *)p = r == 0 && w.index == 0; + __atomic_store_n(&outer_done, 1, __ATOMIC_RELEASE); + return NULL; +} + +static void nested_waits(void) { + void *seen = NULL; + other_dev = open("/dev/ntsync", O_RDWR | O_CLOEXEC); + CHECK("second_device", other_dev >= 0); + struct event_args ea = {0, 0}; + other_obj = ioctl(other_dev, NT_CREATE_EVENT, &ea); + inner_obj = event(1, 1); + CHECK("install_nesting", install_handler(SIGUSR2, nesting, &seen) == 0); + int good = 0, early = 0; + nested_ok = 0; + for (int i = 0; i < 40; i++) { + outer_obj = event(0, 0); + int result = 0; + pthread_t t; + nested_done = outer_done = 0; + pthread_create(&t, NULL, outer_waiter, &result); + usleep(5000); + pthread_kill(t, SIGUSR2); + while (!__atomic_load_n(&nested_done, __ATOMIC_ACQUIRE)) usleep(200); + usleep(5000); + early += __atomic_load_n(&outer_done, __ATOMIC_ACQUIRE); + uint32_t v = 0; + ioctl(outer_obj, NT_EVENT_SET, &v); + pthread_join(t, NULL); + good += result; + close(outer_obj); + } + CHECK("outer_wait_not_woken_by_nested_wait", early == 0); + CHECK("outer_wait_survives_nested_waits", good == 40); + CHECK("nested_waits_complete", nested_ok == 40); + close(inner_obj); + close(other_obj); + close(other_dev); +} + int main(void) { alarm(60); dev = open("/dev/ntsync", O_RDWR | O_CLOEXEC); @@ -409,6 +494,8 @@ int main(void) { cross_process(); stress(); signals(); + bursts(); + nested_waits(); printf("done fails=%d\n", fails); return fails != 0; } From 293e84a64c038ca014a66a20d45966b78b1cd996 Mon Sep 17 00:00:00 2001 From: maxjivi05 Date: Fri, 23 Oct 2026 13:57:38 -0400 Subject: [PATCH 3/4] feat: droiddeck-ntsync is the default Wine sync - New installs start on ntsync. - Existing installs move to ntsync once on the first start of this version, whatever sync they used before. A choice made after that is kept. - The ntsync switch is no longer labelled experimental or for testing, in every language. --- .../main/java/com/droiddeck/launcher/App.kt | 1 + .../launcher/session/SessionPrefs.kt | 13 ++++++++- app/src/main/res/values-ar/strings.xml | 4 +-- app/src/main/res/values-b+es+419/strings.xml | 4 +-- app/src/main/res/values-bg/strings.xml | 4 +-- app/src/main/res/values-cs/strings.xml | 4 +-- app/src/main/res/values-da/strings.xml | 4 +-- app/src/main/res/values-de/strings.xml | 4 +-- app/src/main/res/values-el/strings.xml | 4 +-- app/src/main/res/values-es/strings.xml | 4 +-- app/src/main/res/values-fi/strings.xml | 4 +-- app/src/main/res/values-fr/strings.xml | 4 +-- app/src/main/res/values-hi/strings.xml | 4 +-- app/src/main/res/values-hu/strings.xml | 4 +-- app/src/main/res/values-in/strings.xml | 4 +-- app/src/main/res/values-it/strings.xml | 4 +-- app/src/main/res/values-ja/strings.xml | 4 +-- app/src/main/res/values-ko/strings.xml | 4 +-- app/src/main/res/values-ms/strings.xml | 4 +-- app/src/main/res/values-nb/strings.xml | 4 +-- app/src/main/res/values-nl/strings.xml | 4 +-- app/src/main/res/values-pl/strings.xml | 4 +-- app/src/main/res/values-pt-rPT/strings.xml | 4 +-- app/src/main/res/values-pt/strings.xml | 4 +-- app/src/main/res/values-ro/strings.xml | 4 +-- app/src/main/res/values-ru/strings.xml | 4 +-- app/src/main/res/values-sv/strings.xml | 4 +-- app/src/main/res/values-th/strings.xml | 4 +-- app/src/main/res/values-tr/strings.xml | 4 +-- app/src/main/res/values-uk/strings.xml | 4 +-- app/src/main/res/values-vi/strings.xml | 4 +-- app/src/main/res/values-zh-rCN/strings.xml | 4 +-- app/src/main/res/values-zh-rHK/strings.xml | 4 +-- app/src/main/res/values-zh-rTW/strings.xml | 4 +-- app/src/main/res/values/strings.xml | 4 +-- .../launcher/session/SyncBackendTest.kt | 29 +++++++++++++++++-- 36 files changed, 106 insertions(+), 69 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt index 3fc4383772..aa26d5fca9 100644 --- a/app/src/main/java/com/droiddeck/launcher/App.kt +++ b/app/src/main/java/com/droiddeck/launcher/App.kt @@ -28,6 +28,7 @@ class App : Application() { if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic") return CrashHandler.install(this) com.droiddeck.launcher.session.QuestExperimental.initialize(this) + com.droiddeck.launcher.session.SessionPrefs.applyNtsyncDefault(this) com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this) com.droiddeck.launcher.update.AppUpdates.init(this) com.droiddeck.launcher.core.DownloadSource.init(this) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index d9d2d8e1d3..4fbdd11803 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -376,7 +376,7 @@ object SessionPrefs { prefs(context).edit().putBoolean("noXalia", on).apply() } - fun fastSync(context: Context): Boolean = prefs(context).getBoolean("fastSync", false) + fun fastSync(context: Context): Boolean = prefs(context).getBoolean("fastSync", true) fun setFastSync(context: Context, on: Boolean) { prefs(context).edit().putBoolean("fastSync", on).apply() @@ -411,6 +411,17 @@ object SessionPrefs { .apply() } + fun applyNtsyncDefault(context: Context) { + val prefs = prefs(context) + if (prefs.getBoolean("ntsyncDefaultV1", false)) return + prefs.edit() + .putBoolean("fastSync", true) + .putBoolean("fsyncFirst", false) + .putBoolean("syncFallback", true) + .putBoolean("ntsyncDefaultV1", true) + .apply() + } + fun syncFallback(context: Context): Boolean = prefs(context).getBoolean("syncFallback", true) fun setSyncFallback(context: Context, on: Boolean) { diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 7001fa9167..5b0acda790 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -549,8 +549,8 @@ Turnip: التصيير عبر sysmem أسرع لعميل Steam؛ في الألعاب يختار برنامج التشغيل بين العرض المقسّم إلى مربعات والعرض في ذاكرة النظام لكل مرحلة. مطلوب على Adreno 710/720/722. تجاوز مساعد xalia في Steam - droiddeck-ntsync (تجريبي) - بديل في مساحة المستخدم لبرنامج تشغيل ntsync في Linux، للاختبار. أثناء تفعيله، يستخدمه Proton بدلًا من droiddeck-esync وdroiddeck-fsync. يعمل مع Proton Experimental ARM64 وGE-Proton وproton-cachyos. يُطبَّق في الجلسة التالية. + droiddeck-ntsync + بديل في مساحة المستخدم لبرنامج تشغيل ntsync في Linux. أثناء تفعيله، يستخدمه Proton بدلًا من droiddeck-esync وdroiddeck-fsync. يعمل مع Proton Experimental ARM64 وGE-Proton وproton-cachyos. يُطبَّق في الجلسة التالية. droiddeck-esync droiddeck-fsync أولًا يشغّل خاصية fsync المدمجة في Proton على ملفات Proton الأصلية، مع توفير futex_waitv في مساحة المستخدم، فلا يحتاج إلى حزمة ويستمر في العمل لحظة تحديث Steam لـ Proton. أثناء تفعيله، تستخدمه الألعاب قبل droiddeck-esync، باستثناء القليل الذي يبقيه Proton معطّلًا لـ fsync. يُطبَّق في الجلسة التالية. diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index 16db21a9b9..4d1c38fb2a 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -536,8 +536,8 @@ Turnip: renderizado sysmem Más rápido para el cliente de Steam; en los juegos, el controlador elige entre renderizado por mosaicos o en memoria del sistema en cada pasada. Obligatorio en Adreno 710/720/722. Omitir el asistente xalia de Steam - droiddeck-ntsync (experimental) - Un sustituto en espacio de usuario del controlador ntsync de Linux, para pruebas. Mientras está activado, Proton lo usa en lugar de droiddeck-esync y droiddeck-fsync. Funciona con Proton Experimental ARM64, GE-Proton y proton-cachyos. Se aplica en la próxima sesión. + droiddeck-ntsync + Un sustituto en espacio de usuario del controlador ntsync de Linux. Mientras está activado, Proton lo usa en lugar de droiddeck-esync y droiddeck-fsync. Funciona con Proton Experimental ARM64, GE-Proton y proton-cachyos. Se aplica en la próxima sesión. droiddeck-esync droiddeck-fsync primero Usa el fsync propio de Proton con los archivos originales de Proton, con futex_waitv proporcionado en espacio de usuario, así que no necesita paquete y sigue funcionando en cuanto Steam actualiza Proton. Mientras está activado, los juegos lo usan antes que droiddeck-esync, salvo los pocos que Proton mantiene sin fsync. Se aplica en la próxima sesión. diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index 9dcc424a11..358318565f 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -541,8 +541,8 @@ Turnip: рендиране sysmem По-бързо за клиента на Steam; в игрите драйверът избира за всеки проход между рендериране на плочки и в системната памет. Задължително на Adreno 710/720/722. Пропускане на помощника xalia на Steam - droiddeck-ntsync (експериментално) - Заместител на потребителско ниво за драйвера ntsync на Linux, за тестване. Докато е включен, Proton го използва вместо droiddeck-esync и droiddeck-fsync. Работи с Proton Experimental ARM64, GE-Proton и proton-cachyos. Прилага се от следващата сесия. + droiddeck-ntsync + Заместител на потребителско ниво за драйвера ntsync на Linux. Докато е включен, Proton го използва вместо droiddeck-esync и droiddeck-fsync. Работи с Proton Experimental ARM64, GE-Proton и proton-cachyos. Прилага се от следващата сесия. droiddeck-esync droiddeck-fsync първо Стартира собствения fsync на Proton върху оригиналните файлове на Proton, с futex_waitv, подаден от потребителско ниво, затова не изисква пакет и продължава да работи веднага след актуализация на Proton от Steam. Докато е включен, игрите го използват преди droiddeck-esync, освен малкото, които Proton държи извън fsync. Прилага се от следващата сесия. diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 97e6799605..938597a14a 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -545,8 +545,8 @@ Turnip: vykreslování sysmem Rychlejší pro klienta Steam; ve hrách ovladač pro každý průchod volí dlaždicové vykreslování, nebo vykreslování v systémové paměti. Vyžadováno na Adreno 710/720/722. Vynechat Steamova pomocníka xalia - droiddeck-ntsync (experimentální) - Uživatelská náhrada linuxového ovladače ntsync, pro testování. Když je zapnuto, Proton ho používá místo droiddeck-esync a droiddeck-fsync. Funguje s Proton Experimental ARM64, GE-Proton a proton-cachyos. Použije se od příští relace. + droiddeck-ntsync + Uživatelská náhrada linuxového ovladače ntsync. Když je zapnuto, Proton ho používá místo droiddeck-esync a droiddeck-fsync. Funguje s Proton Experimental ARM64, GE-Proton a proton-cachyos. Použije se od příští relace. droiddeck-esync droiddeck-fsync jako první Spouští vlastní fsync Protonu na původních souborech Protonu, s futex_waitv dodaným v uživatelském prostoru, takže nepotřebuje balíček a funguje i hned po aktualizaci Protonu Steamem. Když je zapnuto, hry ho používají před droiddeck-esync, kromě těch pár, které Proton u fsync nechává vypnuté. Použije se od příští relace. diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 0c2bc230b3..4d0230790d 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem-rendering Hurtigere til Steam-klienten; i spil vælger driveren flise- eller systemhukommelses-rendering for hvert pass. Påkrævet på Adreno 710/720/722. Spring Steams xalia-hjælper over - droiddeck-ntsync (eksperimentel) - En stand-in til ntsync-driveren i Linux-kernen, i brugerrum, til test. Mens den er til, bruger Proton den i stedet for droiddeck-esync og droiddeck-fsync. Fungerer med Proton Experimental ARM64, GE-Proton og proton-cachyos. Gælder fra næste session. + droiddeck-ntsync + En stand-in til ntsync-driveren i Linux-kernen, i brugerrum. Mens den er til, bruger Proton den i stedet for droiddeck-esync og droiddeck-fsync. Fungerer med Proton Experimental ARM64, GE-Proton og proton-cachyos. Gælder fra næste session. droiddeck-esync droiddeck-fsync først Kører Protons egen fsync på de uændrede Proton-filer, med futex_waitv leveret i brugerrum, så det kræver ingen pack og fortsætter med at virke, lige så snart Steam opdaterer Proton. Mens den er til, bruger spil den før droiddeck-esync, undtagen de få, Proton holder uden for fsync. Gælder fra næste session. diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index c09e49dd7e..a25032d287 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -541,8 +541,8 @@ Turnip: Sysmem-Rendering Schneller für den Steam-Client; in Spielen wählt der Treiber pro Durchgang zwischen Kachel- und Systemspeicher-Rendering. Erforderlich bei Adreno 710/720/722. Steams xalia-Helfer überspringen - droiddeck-ntsync (experimentell) - Ein Userspace-Ersatz für den Linux-Treiber ntsync, zum Testen. Solange er aktiv ist, nutzt Proton ihn statt droiddeck-esync und droiddeck-fsync. Funktioniert mit Proton Experimental ARM64, GE-Proton und proton-cachyos. Gilt ab der nächsten Sitzung. + droiddeck-ntsync + Ein Userspace-Ersatz für den Linux-Treiber ntsync. Solange er aktiv ist, nutzt Proton ihn statt droiddeck-esync und droiddeck-fsync. Funktioniert mit Proton Experimental ARM64, GE-Proton und proton-cachyos. Gilt ab der nächsten Sitzung. droiddeck-esync droiddeck-fsync bevorzugen Führt Protons eigenes fsync mit den unveränderten Proton-Dateien aus, wobei futex_waitv im Userspace bereitgestellt wird. Es braucht daher kein Pack und funktioniert weiter, sobald Steam Proton aktualisiert. Solange es aktiv ist, nutzen Spiele es vor droiddeck-esync, außer den wenigen, die Proton von fsync fernhält. Gilt ab der nächsten Sitzung. diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 181822f35e..03ab295a9f 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -541,8 +541,8 @@ Turnip: απόδοση sysmem Ταχύτερο για το πρόγραμμα-πελάτη Steam· στα παιχνίδια ο οδηγός επιλέγει σε κάθε πέρασμα απόδοση με πλακίδια ή στη μνήμη συστήματος. Απαιτείται σε Adreno 710/720/722. Παράβλεψη του βοηθού xalia του Steam - droiddeck-ntsync (πειραματικό) - Ένα υποκατάστατο σε επίπεδο χρήστη για το πρόγραμμα οδήγησης ntsync του Linux, για δοκιμές. Όσο είναι ενεργό, το Proton το χρησιμοποιεί αντί για το droiddeck-esync και το droiddeck-fsync. Λειτουργεί με Proton Experimental ARM64, GE-Proton και proton-cachyos. Εφαρμόζεται στην επόμενη συνεδρία. + droiddeck-ntsync + Ένα υποκατάστατο σε επίπεδο χρήστη για το πρόγραμμα οδήγησης ntsync του Linux. Όσο είναι ενεργό, το Proton το χρησιμοποιεί αντί για το droiddeck-esync και το droiddeck-fsync. Λειτουργεί με Proton Experimental ARM64, GE-Proton και proton-cachyos. Εφαρμόζεται στην επόμενη συνεδρία. droiddeck-esync droiddeck-fsync πρώτα Εκτελεί το δικό του fsync του Proton στα απλά αρχεία Proton, με το futex_waitv παρεχόμενο σε επίπεδο χρήστη, οπότε δεν χρειάζεται πακέτο και συνεχίζει να λειτουργεί τη στιγμή που το Steam ενημερώνει το Proton. Όσο είναι ενεργό, τα παιχνίδια το χρησιμοποιούν πριν από το droiddeck-esync, εκτός από τα λίγα που το Proton κρατά εκτός fsync. Εφαρμόζεται στην επόμενη συνεδρία. diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index ec99ab7198..c8f94321e8 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -545,8 +545,8 @@ Turnip: renderizado sysmem Más rápido para el cliente de Steam; en los juegos, el controlador elige entre renderizado por mosaicos o en memoria del sistema en cada pasada. Obligatorio en Adreno 710/720/722. Omitir el asistente xalia de Steam - droiddeck-ntsync (experimental) - Un sustituto en espacio de usuario del controlador ntsync de Linux, para pruebas. Mientras está activado, Proton lo usa en lugar de droiddeck-esync y droiddeck-fsync. Funciona con Proton Experimental ARM64, GE-Proton y proton-cachyos. Se aplica en la próxima sesión. + droiddeck-ntsync + Un sustituto en espacio de usuario del controlador ntsync de Linux. Mientras está activado, Proton lo usa en lugar de droiddeck-esync y droiddeck-fsync. Funciona con Proton Experimental ARM64, GE-Proton y proton-cachyos. Se aplica en la próxima sesión. droiddeck-esync droiddeck-fsync primero Usa el fsync propio de Proton con los archivos originales de Proton, con futex_waitv proporcionado en espacio de usuario, así que no necesita paquete y sigue funcionando en cuanto Steam actualiza Proton. Mientras está activado, los juegos lo usan antes que droiddeck-esync, salvo los pocos que Proton mantiene sin fsync. Se aplica en la próxima sesión. diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index ac12cc7e89..31695f9a15 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem-renderöinti Nopeampi Steam-asiakasohjelmalle; peleissä ajuri valitsee jokaiselle vaiheelle ruuduittaisen tai järjestelmämuistiin tehtävän renderöinnin. Pakollinen Adreno 710/720/722:lla. Ohita Steamin xalia-avustaja - droiddeck-ntsync (kokeellinen) - Käyttäjätilainen korvike Linuxin ntsync-ajurille, testausta varten. Kun se on päällä, Proton käyttää sitä droiddeck-esyncin ja droiddeck-fsyncin sijaan. Toimii Proton Experimental ARM64:n, GE-Protonin ja proton-cachyosin kanssa. Tulee voimaan seuraavassa istunnossa. + droiddeck-ntsync + Käyttäjätilainen korvike Linuxin ntsync-ajurille. Kun se on päällä, Proton käyttää sitä droiddeck-esyncin ja droiddeck-fsyncin sijaan. Toimii Proton Experimental ARM64:n, GE-Protonin ja proton-cachyosin kanssa. Tulee voimaan seuraavassa istunnossa. droiddeck-esync droiddeck-fsync etusijalle Käynnistää Protonin omaa fsynciä vakiotiedostoilla, futex_waitv tarjottuna käyttäjätilassa, niin se ei tarvitse pakettia ja toimii edelleen heti kun Steam päivittää Protonin. Kun se on päällä, pelit käyttävät sitä droiddeck-esyncin edellä, paitsi harvat, jotka Proton pitää pois fsyncistä. Tulee voimaan seuraavassa istunnossa. diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 143d11449b..8410619a68 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -545,8 +545,8 @@ Turnip : rendu sysmem Le client Steam sera plus rapide ; en jeu, le pilote choisit à chaque passe entre rendu par tuiles et rendu en mémoire système. Requis pour Adreno 710/720/722. Ignorer l\'assistant xalia de Steam - droiddeck-ntsync (expérimental) - Un substitut en espace utilisateur du pilote Linux ntsync, pour les tests. Lorsqu\'il est activé, Proton l\'utilise à la place de droiddeck-esync et de droiddeck-fsync. Fonctionne avec Proton Experimental ARM64, GE-Proton et proton-cachyos. Prendra effet à la prochaine session. + droiddeck-ntsync + Un substitut en espace utilisateur du pilote Linux ntsync. Lorsqu\'il est activé, Proton l\'utilise à la place de droiddeck-esync et de droiddeck-fsync. Fonctionne avec Proton Experimental ARM64, GE-Proton et proton-cachyos. Prendra effet à la prochaine session. droiddeck-esync droiddeck-fsync en priorité Exécute le fsync propre à Proton sur les fichiers Proton d\'origine, avec futex_waitv fourni en espace utilisateur : aucun pack n\'est nécessaire et il continue de fonctionner dès que Steam met à jour Proton. Lorsqu\'il est activé, les jeux l\'utilisent avant droiddeck-esync, sauf les quelques-uns que Proton exclut de fsync. Prendra effet à la prochaine session. diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index 1135072324..5126c1d6de 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem रेंडरिंग Steam क्लाइंट के लिए तेज़; गेम में ड्राइवर हर पास के लिए टाइल या सिस्टम मेमोरी रेंडरिंग चुनता है। Adreno 710/720/722 पर ज़रूरी। Steam के xalia हेल्पर को छोड़ें - droiddeck-ntsync (एक्सपेरिमेंटल) - जांच के लिए Linux ntsync ड्राइवर की यूज़रस्पेस जगह लेने वाली चीज़। चालू रहते हुए, Proton इसे droiddeck-esync और droiddeck-fsync के बदले इस्तेमाल करता है। यह Proton Experimental ARM64, GE-Proton और proton-cachyos के साथ काम करता है। अगले सेशन से लागू होता है। + droiddeck-ntsync + Linux ntsync ड्राइवर की यूज़रस्पेस जगह लेने वाली चीज़। चालू रहते हुए, Proton इसे droiddeck-esync और droiddeck-fsync के बदले इस्तेमाल करता है। यह Proton Experimental ARM64, GE-Proton और proton-cachyos के साथ काम करता है। अगले सेशन से लागू होता है। droiddeck-esync droiddeck-fsync पहले स्टॉक Proton फ़ाइलों पर Proton का अपना fsync चलाता है, futex_waitv यूज़रस्पेस में दिया जाता है, इसलिए इसे किसी पैक की ज़रूरत नहीं और Steam के Proton अपडेट करते ही यह काम करता रहता है। चालू रहते हुए, गेम इसे droiddeck-esync से पहले इस्तेमाल करते हैं, सिवाय उन कुछ के जिन्हें Proton fsync से दूर रखता है। अगले सेशन से लागू होता है। diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index a1638350ab..cbf3a71628 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem renderelés Gyorsabb a Steam kliensnek; játékokban a meghajtó menetenként választ a csempés és a rendszermemóriás renderelés között. Adreno 710/720/722-n szükséges. A Steam xalia segítőjének kihagyása - droiddeck-ntsync (kísérleti) - A Linux ntsync illesztőprogram felhasználói szintű helyettesítője, teszteléshez. Amíg be van kapcsolva, a Proton ezt használja a droiddeck-esync és a droiddeck-fsync helyett. A Proton Experimental ARM64-gyel, a GE-Protonnal és a proton-cachyosszal működik. A következő munkamenettől érvényes. + droiddeck-ntsync + A Linux ntsync illesztőprogram felhasználói szintű helyettesítője. Amíg be van kapcsolva, a Proton ezt használja a droiddeck-esync és a droiddeck-fsync helyett. A Proton Experimental ARM64-gyel, a GE-Protonnal és a proton-cachyosszal működik. A következő munkamenettől érvényes. droiddeck-esync droiddeck-fsync előre A Proton saját fsyncjét futtatja az eredeti Proton-fájlokon, felhasználói szinten biztosított futex_waitv-vel, így nincs szükség csomagra, és azonnal működik, amint a Steam frissíti a Protont. Amíg be van kapcsolva, a játékok ezt használják a droiddeck-esync előtt, kivéve azt a néhányat, amelyet a Proton kizár az fsyncből. A következő munkamenettől érvényes. diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 61bb207a00..444e88819e 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -539,8 +539,8 @@ Turnip: rendering sysmem Lebih cepat untuk klien Steam; di gim, driver memilih rendering ubin atau memori sistem untuk setiap pass. Diperlukan pada Adreno 710/720/722. Lewati bantuan xalia milik Steam - droiddeck-ntsync (eksperimental) - Pengganti userspace untuk driver ntsync Linux, untuk pengujian. Saat aktif, Proton menggunakannya sebagai pengganti droiddeck-esync dan droiddeck-fsync. Berfungsi dengan Proton Experimental ARM64, GE-Proton, dan proton-cachyos. Berlaku pada sesi berikutnya. + droiddeck-ntsync + Pengganti userspace untuk driver ntsync Linux. Saat aktif, Proton menggunakannya sebagai pengganti droiddeck-esync dan droiddeck-fsync. Berfungsi dengan Proton Experimental ARM64, GE-Proton, dan proton-cachyos. Berlaku pada sesi berikutnya. droiddeck-esync droiddeck-fsync lebih dulu Menjalankan fsync milik Proton sendiri pada file Proton standar, dengan futex_waitv yang disediakan di userspace, sehingga tidak memerlukan paket dan tetap berfungsi begitu Steam memperbarui Proton. Saat aktif, gim menggunakannya sebelum droiddeck-esync, kecuali beberapa gim yang oleh Proton dijaga tetap di luar fsync. Berlaku pada sesi berikutnya. diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 0d8fd58828..abfe8b6f5c 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -543,8 +543,8 @@ Turnip: rendering sysmem Più veloce per il client di Steam; nei giochi il driver sceglie per ogni passata tra rendering a tile e in memoria di sistema. Necessario su Adreno 710/720/722. Salta l\'assistente xalia di Steam - droiddeck-ntsync (sperimentale) - Un sostituto in userspace del driver ntsync di Linux, per i test. Quando è attivo, Proton lo usa al posto di droiddeck-esync e droiddeck-fsync. Funziona con Proton Experimental ARM64, GE-Proton e proton-cachyos. Si applica dalla prossima sessione. + droiddeck-ntsync + Un sostituto in userspace del driver ntsync di Linux. Quando è attivo, Proton lo usa al posto di droiddeck-esync e droiddeck-fsync. Funziona con Proton Experimental ARM64, GE-Proton e proton-cachyos. Si applica dalla prossima sessione. droiddeck-esync Prima droiddeck-fsync Esegue il fsync di Proton sui file Proton originali, con futex_waitv fornito in userspace, quindi non richiede pacchetti e continua a funzionare appena Steam aggiorna Proton. Quando è attivo, i giochi lo usano prima di droiddeck-esync, tranne i pochi che Proton esclude da fsync. Si applica dalla prossima sessione. diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 7b719791fd..4431538c7c 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -541,8 +541,8 @@ Turnip:sysmemレンダリング Steamクライアントが高速になります。ゲームではドライバーがパスごとにタイルレンダリングとシステムメモリレンダリングを選びます。Adreno 710/720/722では必須です。 Steamのxalia補助をスキップ - droiddeck-ntsync(実験的) - Linuxのntsyncドライバーをユーザー空間で代替するテスト用機能です。オンの間、Protonはdroiddeck-esyncとdroiddeck-fsyncの代わりにこれを使用します。Proton Experimental ARM64、GE-Proton、proton-cachyosで動作します。次回のセッションで有効になります。 + droiddeck-ntsync + Linuxのntsyncドライバーをユーザー空間で代替する機能です。オンの間、Protonはdroiddeck-esyncとdroiddeck-fsyncの代わりにこれを使用します。Proton Experimental ARM64、GE-Proton、proton-cachyosで動作します。次回のセッションで有効になります。 droiddeck-esync droiddeck-fsyncを優先 futex_waitvをユーザー空間で提供し、標準のProtonファイルのままProton自身のfsyncを実行します。パックが不要なため、SteamがProtonを更新してもすぐに動作し続けます。オンの間、Protonがfsyncを使わない一部のゲームを除き、ゲームはdroiddeck-esyncよりこちらを優先します。次回のセッションで有効になります。 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 0ea3c7b1be..c88fe44b3b 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem 렌더링 Steam 클라이언트가 빨라집니다. 게임에서는 드라이버가 패스마다 타일 렌더링과 시스템 메모리 렌더링 중 하나를 고릅니다. Adreno 710/720/722에 필수입니다. Steam의 xalia 도우미 건너뛰기 - droiddeck-ntsync(실험적) - 테스트용으로 Linux ntsync 드라이버를 사용자 공간에서 대신하는 기능입니다. 켜져 있으면 Proton이 droiddeck-esync와 droiddeck-fsync 대신 이 기능을 사용합니다. Proton Experimental ARM64, GE-Proton 및 proton-cachyos에서 작동합니다. 다음 세션에 적용됩니다. + droiddeck-ntsync + Linux ntsync 드라이버를 사용자 공간에서 대신하는 기능입니다. 켜져 있으면 Proton이 droiddeck-esync와 droiddeck-fsync 대신 이 기능을 사용합니다. Proton Experimental ARM64, GE-Proton 및 proton-cachyos에서 작동합니다. 다음 세션에 적용됩니다. droiddeck-esync droiddeck-fsync 우선 futex_waitv를 사용자 공간에서 제공하여 기본 Proton 파일로 Proton 자체의 fsync를 실행하므로, 팩이 필요 없고 Steam이 Proton을 업데이트해도 바로 작동합니다. 켜져 있으면 게임이 droiddeck-esync보다 이 기능을 우선 사용합니다. 단, Proton이 fsync를 끄는 일부 게임은 예외입니다. 다음 세션에 적용됩니다. diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index 2e3eb1205d..7b44da15ba 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -539,8 +539,8 @@ Turnip: rendering sysmem Lebih pantas untuk klien Steam; dalam permainan, pemacu memilih pemaparan jubin atau memori sistem bagi setiap laluan. Diperlukan pada Adreno 710/720/722. Langkau pembantu xalia Steam - droiddeck-ntsync (eksperimen) - Pengganti ruang pengguna untuk pemacu ntsync Linux, untuk pengujian. Semasa ia hidup, Proton menggunakannya sebagai ganti droiddeck-esync dan droiddeck-fsync. Berfungsi dengan Proton Experimental ARM64, GE-Proton dan proton-cachyos. Berkuat kuasa pada sesi seterusnya. + droiddeck-ntsync + Pengganti ruang pengguna untuk pemacu ntsync Linux. Semasa ia hidup, Proton menggunakannya sebagai ganti droiddeck-esync dan droiddeck-fsync. Berfungsi dengan Proton Experimental ARM64, GE-Proton dan proton-cachyos. Berkuat kuasa pada sesi seterusnya. droiddeck-esync droiddeck-fsync dahulu Menjalankan fsync Proton sendiri pada fail Proton standard, dengan futex_waitv dibekalkan dalam ruang pengguna, jadi ia tidak memerlukan pek dan terus berfungsi sebaik sahaja Steam mengemas kini Proton. Semasa ia hidup, permainan menggunakannya mendahului droiddeck-esync, kecuali beberapa Proton yang mematikan fsync. Berkuat kuasa pada sesi seterusnya. diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index e0ee85176d..c702bd959b 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem-rendering Raskere for Steam-klienten; i spill velger driveren flis- eller systemminnerendering for hvert pass. Påkrevd på Adreno 710/720/722. Hopp over Steams xalia-hjelper - droiddeck-ntsync (eksperimentell) - En erstatning i brukerrom for Linux-driveren ntsync, for testing. Mens dette er på, bruker Proton den i stedet for droiddeck-esync og droiddeck-fsync. Fungerer med Proton Experimental ARM64, GE-Proton og proton-cachyos. Gjelder fra neste sesjon. + droiddeck-ntsync + En erstatning i brukerrom for Linux-driveren ntsync. Mens dette er på, bruker Proton den i stedet for droiddeck-esync og droiddeck-fsync. Fungerer med Proton Experimental ARM64, GE-Proton og proton-cachyos. Gjelder fra neste sesjon. droiddeck-esync droiddeck-fsync først Kjører Protons egen fsync på de uendrede Proton-filene, med futex_waitv levert i brukerrom, så den trenger ingen pakke og fortsetter å fungere i det Steam oppdaterer Proton. Mens dette er på, bruker spill den foran droiddeck-esync, med unntak av de få Proton holder utenfor fsync. Gjelder fra neste sesjon. diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 93b6ab06fc..a5fda08678 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem-rendering Sneller voor de Steam-client; in games kiest het stuurprogramma per pass tussen tegel- en systeemgeheugenrendering. Vereist op Adreno 710/720/722. Sla de xalia-helper van Steam over - droiddeck-ntsync (experimenteel) - Een userspace-vervanger voor de ntsync-driver van Linux, voor tests. Terwijl dit aan staat, gebruikt Proton dit in plaats van droiddeck-esync en droiddeck-fsync. Werkt met Proton Experimental ARM64, GE-Proton en proton-cachyos. Geldt vanaf de volgende sessie. + droiddeck-ntsync + Een userspace-vervanger voor de ntsync-driver van Linux. Terwijl dit aan staat, gebruikt Proton dit in plaats van droiddeck-esync en droiddeck-fsync. Werkt met Proton Experimental ARM64, GE-Proton en proton-cachyos. Geldt vanaf de volgende sessie. droiddeck-esync droiddeck-fsync eerst Draait de eigen fsync van Proton op de standaard Proton-bestanden, met futex_waitv in userspace geleverd, zodat er geen pakket nodig is en dit blijft werken zodra Steam Proton bijwerkt. Terwijl dit aan staat, gebruiken games dit vóór droiddeck-esync, behalve de paar die Proton niet op fsync laat draaien. Geldt vanaf de volgende sessie. diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 288e644bae..d13e2f120d 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -545,8 +545,8 @@ Turnip: renderowanie sysmem Szybsze dla klienta Steam; w grach sterownik dla każdego przebiegu wybiera renderowanie kafelkowe lub w pamięci systemowej. Wymagane na Adreno 710/720/722. Pomijaj pomocnika xalia w Steam - droiddeck-ntsync (eksperymentalne) - Zastępnik sterownika Linux ntsync w przestrzeni użytkownika, do testów. Gdy jest włączony, Proton używa go zamiast droiddeck-esync i droiddeck-fsync. Zgodny z Proton Experimental ARM64, GE-Proton i proton-cachyos. Działa od następnej sesji. + droiddeck-ntsync + Zastępnik sterownika Linux ntsync w przestrzeni użytkownika. Gdy jest włączony, Proton używa go zamiast droiddeck-esync i droiddeck-fsync. Zgodny z Proton Experimental ARM64, GE-Proton i proton-cachyos. Działa od następnej sesji. droiddeck-esync Najpierw droiddeck-fsync Uruchamia własny fsync Proton na standardowych plikach Proton, z futex_waitv dostarczanym w przestrzeni użytkownika, więc nie wymaga pakietu i działa od razu po aktualizacji Proton przez Steam. Gdy jest włączony, gry używają go przed droiddeck-esync, z wyjątkiem nielicznych, którym Proton wyłącza fsync. Działa od następnej sesji. diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index 91e75d38fc..4d05644a03 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -543,8 +543,8 @@ Turnip: renderização em sysmem Mais rápido para o cliente Steam; nos jogos, o controlador escolhe em cada passagem entre renderização em mosaico ou na memória do sistema. Obrigatório no Adreno 710/720/722. Ignorar o assistente xalia do Steam - droiddeck-ntsync (experimental) - Um substituto em espaço de utilizador para o controlador ntsync do Linux, para testes. Enquanto estiver ativado, o Proton utiliza-o em vez do droiddeck-esync e do droiddeck-fsync. Funciona com o Proton Experimental ARM64, o GE-Proton e o proton-cachyos. Aplica-se na próxima sessão. + droiddeck-ntsync + Um substituto em espaço de utilizador para o controlador ntsync do Linux. Enquanto estiver ativado, o Proton utiliza-o em vez do droiddeck-esync e do droiddeck-fsync. Funciona com o Proton Experimental ARM64, o GE-Proton e o proton-cachyos. Aplica-se na próxima sessão. droiddeck-esync droiddeck-fsync primeiro Executa o fsync do próprio Proton sobre os ficheiros originais do Proton, com o futex_waitv fornecido em espaço de utilizador, por isso não precisa de pacote e continua a funcionar assim que o Steam atualiza o Proton. Enquanto estiver ativado, os jogos utilizam-no antes do droiddeck-esync, exceto os poucos que o Proton mantém fora do fsync. Aplica-se na próxima sessão. diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 45bd06550c..802fa6ad9e 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -543,8 +543,8 @@ Turnip: renderização sysmem Mais rápido para o cliente da Steam; nos jogos, o driver escolhe a cada passagem entre renderização em blocos ou na memória do sistema. Obrigatório nas Adreno 710/720/722. Pular o assistente xalia da Steam - droiddeck-ntsync (experimental) - Um substituto em espaço de usuário para o driver ntsync do Linux, para testes. Enquanto estiver ativado, o Proton o usa no lugar do droiddeck-esync e do droiddeck-fsync. Funciona com o Proton Experimental ARM64, o GE-Proton e o proton-cachyos. Vale a partir da próxima sessão. + droiddeck-ntsync + Um substituto em espaço de usuário para o driver ntsync do Linux. Enquanto estiver ativado, o Proton o usa no lugar do droiddeck-esync e do droiddeck-fsync. Funciona com o Proton Experimental ARM64, o GE-Proton e o proton-cachyos. Vale a partir da próxima sessão. droiddeck-esync droiddeck-fsync primeiro Roda o fsync do próprio Proton nos arquivos originais do Proton, com o futex_waitv fornecido em espaço de usuário, então não precisa de pacote e continua funcionando assim que a Steam atualiza o Proton. Enquanto estiver ativado, os jogos o usam antes do droiddeck-esync, exceto os poucos que o Proton mantém fora do fsync. Vale a partir da próxima sessão. diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 4b434247a5..9ed2b820b1 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -543,8 +543,8 @@ Turnip: randare sysmem Mai rapidă pentru clientul Steam; în jocuri, driverul alege la fiecare trecere între randarea pe dale și cea în memoria sistemului. Necesară pe Adreno 710/720/722. Omite asistentul xalia al Steam - droiddeck-ntsync (experimental) - Un substitut la nivel de utilizator pentru driverul Linux ntsync, pentru testare. Cât timp este activ, Proton îl folosește în locul droiddeck-esync și droiddeck-fsync. Funcționează cu Proton Experimental ARM64, GE-Proton și proton-cachyos. Se aplică la sesiunea următoare. + droiddeck-ntsync + Un substitut la nivel de utilizator pentru driverul Linux ntsync. Cât timp este activ, Proton îl folosește în locul droiddeck-esync și droiddeck-fsync. Funcționează cu Proton Experimental ARM64, GE-Proton și proton-cachyos. Se aplică la sesiunea următoare. droiddeck-esync droiddeck-fsync primul Rulează propriul fsync al Proton pe fișierele Proton standard, cu futex_waitv furnizat la nivel de utilizator, deci nu are nevoie de pachet și continuă să funcționeze imediat ce Steam actualizează Proton. Cât timp este activ, jocurile îl folosesc înaintea droiddeck-esync, cu excepția celor puține pe care Proton le ține în afara fsync. Se aplică la sesiunea următoare. diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 592685d837..ad24076cc5 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -547,8 +547,8 @@ Turnip: рендеринг sysmem Клиент Steam будет быстрее; в играх драйвер для каждого прохода выбирает тайловый рендеринг или рендеринг в системной памяти. Требуется для Adreno 710/720/722. Пропустить помощник xalia в Steam - droiddeck-ntsync (экспериментально) - Замена драйвера ntsync Linux в пространстве пользователя, для тестирования. Пока включено, Proton использует ее вместо droiddeck-esync и droiddeck-fsync. Работает с Proton Experimental ARM64, GE-Proton и proton-cachyos. Вступит в силу в следующей сессии. + droiddeck-ntsync + Замена драйвера ntsync Linux в пространстве пользователя. Пока включено, Proton использует ее вместо droiddeck-esync и droiddeck-fsync. Работает с Proton Experimental ARM64, GE-Proton и proton-cachyos. Вступит в силу в следующей сессии. droiddeck-esync droiddeck-fsync в приоритете Запускает собственный fsync Proton на стандартных файлах Proton, а futex_waitv предоставляется в пространстве пользователя: пакет не нужен, и все продолжает работать сразу после обновления Proton в Steam. Пока включено, игры используют его раньше droiddeck-esync, кроме тех немногих, для которых Proton отключает fsync. Вступит в силу в следующей сессии. diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 5f75e21777..ee40ac576c 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem-rendering Snabbare för Steam-klienten; i spel väljer drivrutinen kakel- eller systemminnesrendering för varje pass. Krävs på Adreno 710/720/722. Hoppa över Steams xalia-hjälp - droiddeck-ntsync (experimentell) - En ersättning i användarutrymmet för Linux ntsync-drivrutinen, för testning. Medan det är på använder Proton det i stället för droiddeck-esync och droiddeck-fsync. Fungerar med Proton Experimental ARM64, GE-Proton och proton-cachyos. Gäller från nästa session. + droiddeck-ntsync + En ersättning i användarutrymmet för Linux ntsync-drivrutinen. Medan det är på använder Proton det i stället för droiddeck-esync och droiddeck-fsync. Fungerar med Proton Experimental ARM64, GE-Proton och proton-cachyos. Gäller från nästa session. droiddeck-esync droiddeck-fsync först Kör Protons egen fsync på de ursprungliga Proton-filerna, med futex_waitv tillhandahållen i användarutrymmet, så det behöver inget paket och fortsätter fungera så snart Steam uppdaterar Proton. Medan det är på använder spel det före droiddeck-esync, förutom de få som Proton håller borta från fsync. Gäller från nästa session. diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index d2c04317c6..dffe5fd7ae 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -539,8 +539,8 @@ Turnip: การเรนเดอร์ sysmem เร็วขึ้นสำหรับไคลเอนต์ Steam ในเกมไดรเวอร์จะเลือกการเรนเดอร์แบบไทล์หรือในหน่วยความจำระบบในแต่ละพาส จำเป็นสำหรับ Adreno 710/720/722 ข้ามตัวช่วย xalia ของ Steam - droiddeck-ntsync (ทดลอง) - ตัวแทนในระดับยูสเซอร์สเปซของไดรเวอร์ ntsync ของ Linux สำหรับการทดสอบ เมื่อเปิดใช้ Proton จะใช้สิ่งนี้แทน droiddeck-esync และ droiddeck-fsync ใช้ได้กับ Proton Experimental ARM64, GE-Proton และ proton-cachyos จะมีผลในเซสชันถัดไป + droiddeck-ntsync + ตัวแทนในระดับยูสเซอร์สเปซของไดรเวอร์ ntsync ของ Linux เมื่อเปิดใช้ Proton จะใช้สิ่งนี้แทน droiddeck-esync และ droiddeck-fsync ใช้ได้กับ Proton Experimental ARM64, GE-Proton และ proton-cachyos จะมีผลในเซสชันถัดไป droiddeck-esync droiddeck-fsync ก่อน รัน fsync ของ Proton เองบนไฟล์ Proton มาตรฐาน โดยมี futex_waitv ที่จัดเตรียมในระดับยูสเซอร์สเปซ จึงไม่ต้องใช้แพ็กและยังคงทำงานได้ทันทีที่ Steam อัปเดต Proton เมื่อเปิดใช้ เกมจะใช้สิ่งนี้ก่อน droiddeck-esync ยกเว้นบางส่วนที่ Proton ปิด fsync ไว้ จะมีผลในเซสชันถัดไป diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 24fc12e92d..bb71dab78e 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -541,8 +541,8 @@ Turnip: sysmem işleme Steam istemcisi için daha hızlı; oyunlarda sürücü her geçişte döşeme tabanlı veya sistem belleğinde işlemeyi seçer. Adreno 710/720/722\'de gereklidir. Steam\'in xalia yardımcısını atla - droiddeck-ntsync (deneysel) - Linux ntsync sürücüsünün test amaçlı, kullanıcı alanında çalışan bir yedeği. Açıkken Proton, droiddeck-esync ve droiddeck-fsync yerine bunu kullanır. Proton Experimental ARM64, GE-Proton ve proton-cachyos ile çalışır. Sonraki oturumda uygulanır. + droiddeck-ntsync + Linux ntsync sürücüsünün kullanıcı alanında çalışan bir yedeği. Açıkken Proton, droiddeck-esync ve droiddeck-fsync yerine bunu kullanır. Proton Experimental ARM64, GE-Proton ve proton-cachyos ile çalışır. Sonraki oturumda uygulanır. droiddeck-esync Önce droiddeck-fsync Proton\'un kendi fsync\'ini standart Proton dosyalarıyla, futex_waitv kullanıcı alanında sağlanarak çalıştırır; bu yüzden paket gerektirmez ve Steam Proton\'u güncellediği anda da çalışmaya devam eder. Açıkken oyunlar, Proton\'un fsync dışında tuttuğu birkaç oyun hariç, bunu droiddeck-esync\'ten önce kullanır. Sonraki oturumda uygulanır. diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 0fe47636a7..a67b973c6a 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -545,8 +545,8 @@ Turnip: рендеринг через sysmem Швидше для клієнта Steam; в іграх драйвер для кожного проходу вибирає тайловий рендеринг або рендеринг у системній пам’яті. Потрібно для Adreno 710/720/722. Пропускати помічник Steam xalia - droiddeck-ntsync (експериментально) - Програмна заміна драйвера ntsync ядра Linux у просторі користувача, для тестування. Поки це увімкнено, Proton використовує її замість droiddeck-esync і droiddeck-fsync. Працює з Proton Experimental ARM64, GE-Proton і proton-cachyos. Застосовується в наступному сеансі. + droiddeck-ntsync + Програмна заміна драйвера ntsync ядра Linux у просторі користувача. Поки це увімкнено, Proton використовує її замість droiddeck-esync і droiddeck-fsync. Працює з Proton Experimental ARM64, GE-Proton і proton-cachyos. Застосовується в наступному сеансі. droiddeck-esync droiddeck-fsync першим Запускає власний fsync Proton на стандартних файлах Proton, а futex_waitv надається в просторі користувача, тому не потрібен пакет і все працює відразу після оновлення Proton у Steam. Поки це увімкнено, ігри використовують його раніше за droiddeck-esync, окрім кількох, де Proton тримає fsync вимкненим. Застосовується в наступному сеансі. diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index c7e88e0653..73a93bf2f5 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -539,8 +539,8 @@ Turnip: render sysmem Nhanh hơn cho ứng dụng Steam; trong game, trình điều khiển chọn kết xuất theo ô hoặc trong bộ nhớ hệ thống cho từng lượt. Bắt buộc trên Adreno 710/720/722. Bỏ qua trình trợ giúp xalia của Steam - droiddeck-ntsync (thử nghiệm) - Một bản thay thế ở không gian người dùng cho driver ntsync của Linux, dùng để thử nghiệm. Khi đang bật, Proton dùng nó thay cho droiddeck-esync và droiddeck-fsync. Hoạt động với Proton Experimental ARM64, GE-Proton và proton-cachyos. Áp dụng từ phiên sau. + droiddeck-ntsync + Một bản thay thế ở không gian người dùng cho driver ntsync của Linux. Khi đang bật, Proton dùng nó thay cho droiddeck-esync và droiddeck-fsync. Hoạt động với Proton Experimental ARM64, GE-Proton và proton-cachyos. Áp dụng từ phiên sau. droiddeck-esync droiddeck-fsync trước Chạy fsync riêng của Proton trên các tệp Proton gốc, với futex_waitv được cung cấp ở không gian người dùng, nên không cần pack và vẫn hoạt động ngay khi Steam cập nhật Proton. Khi đang bật, game dùng nó trước droiddeck-esync, trừ một số ít Proton giữ fsync tắt. Áp dụng từ phiên sau. diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 68d927ebb2..6d09ed2aed 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -541,8 +541,8 @@ Turnip:sysmem 渲染 Steam 客户端更快;游戏中驱动会为每个渲染通道选择分块渲染或系统内存渲染。Adreno 710/720/722 必需。 跳过 Steam 的 xalia 助手 - droiddeck-ntsync(实验性) - Linux ntsync 驱动的用户态替代品,供测试使用。开启时,Proton 使用它代替 droiddeck-esync 和 droiddeck-fsync。适用于 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。将在下次会话生效。 + droiddeck-ntsync + Linux ntsync 驱动的用户态替代品。开启时,Proton 使用它代替 droiddeck-esync 和 droiddeck-fsync。适用于 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。将在下次会话生效。 droiddeck-esync droiddeck-fsync 优先 在原始 Proton 文件上运行 Proton 自带的 fsync,由用户态提供 futex_waitv,因此无需任何包,且 Steam 更新 Proton 后立即继续可用。开启时,除 Proton 自身禁用 fsync 的少数游戏外,各游戏优先使用它而非 droiddeck-esync。将在下次会话生效。 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index a39c7b101d..ce0f2693ca 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -541,8 +541,8 @@ Turnip:sysmem 渲染 Steam 用戶端會更快;遊戲中驅動程式會為每個渲染通道選擇分塊渲染或系統記憶體渲染。Adreno 710/720/722 必須開啟。 略過 Steam 的 xalia 輔助程式 - droiddeck-ntsync(實驗性) - 在用戶空間代替 Linux ntsync 驅動程式,供測試使用。開啟時,Proton 會使用它而非 droiddeck-esync 和 droiddeck-fsync。適用於 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。下次會話生效。 + droiddeck-ntsync + 在用戶空間代替 Linux ntsync 驅動程式。開啟時,Proton 會使用它而非 droiddeck-esync 和 droiddeck-fsync。適用於 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。下次會話生效。 droiddeck-esync 優先使用 droiddeck-fsync 在原裝 Proton 檔案上執行 Proton 本身的 fsync,並在用戶空間提供 futex_waitv,因此無需套件,Steam 更新 Proton 後亦能立即繼續運作。開啟時,遊戲會優先使用它而非 droiddeck-esync,Proton 刻意不用 fsync 的少數遊戲除外。下次會話生效。 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index d29f3cef46..a7d315ec18 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -541,8 +541,8 @@ Turnip:sysmem 渲染 Steam 用戶端會更快;遊戲中驅動程式會為每個算繪通道選擇分塊算繪或系統記憶體算繪。Adreno 710/720/722 必需。 跳過 Steam 的 xalia 輔助程式 - droiddeck-ntsync(實驗性) - 以使用者空間替代 Linux ntsync 驅動程式,供測試使用。開啟時,Proton 會使用它來取代 droiddeck-esync 和 droiddeck-fsync。適用於 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。下次工作階段生效。 + droiddeck-ntsync + 以使用者空間替代 Linux ntsync 驅動程式。開啟時,Proton 會使用它來取代 droiddeck-esync 和 droiddeck-fsync。適用於 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。下次工作階段生效。 droiddeck-esync 優先使用 droiddeck-fsync 在原版 Proton 檔案上執行 Proton 自己的 fsync,並在使用者空間提供 futex_waitv,因此不需要套件,Steam 更新 Proton 後也能立即繼續運作。開啟時,遊戲會優先使用它而非 droiddeck-esync,Proton 本身停用 fsync 的少數遊戲除外。下次工作階段生效。 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index c449a05be5..25c5c820b3 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -554,8 +554,8 @@ Turnip: sysmem rendering Faster for the Steam client; in games the driver picks tile or system-memory rendering per pass. Required on Adreno 710/720/722. Skip Steam\'s xalia helper - droiddeck-ntsync (experimental) - A userspace stand-in for the Linux ntsync driver, for testing. While it is on, Proton uses it instead of droiddeck-esync and droiddeck-fsync. Works with Proton Experimental ARM64, GE-Proton and proton-cachyos. Applies next session. + droiddeck-ntsync + A userspace stand-in for the Linux ntsync driver. While it is on, Proton uses it instead of droiddeck-esync and droiddeck-fsync. Works with Proton Experimental ARM64, GE-Proton and proton-cachyos. Applies next session. droiddeck-esync droiddeck-fsync first Runs Proton\'s own fsync on the stock Proton files, with futex_waitv supplied in userspace, so it needs no pack and keeps working the moment Steam updates Proton. While it is on, games use it ahead of droiddeck-esync, except the few Proton keeps off fsync. Applies next session. diff --git a/app/src/test/java/com/droiddeck/launcher/session/SyncBackendTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SyncBackendTest.kt index 844931bbbb..85cf481e90 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SyncBackendTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SyncBackendTest.kt @@ -13,9 +13,33 @@ class SyncBackendTest { private val context: Context = RuntimeEnvironment.getApplication() @Test - fun aFreshInstallStartsOnEsync() { - assertEquals(SessionPrefs.SYNC_ESYNC, SessionPrefs.syncBackend(context)) + fun aFreshInstallStartsOnNtsync() { + assertEquals(SessionPrefs.SYNC_NTSYNC, SessionPrefs.syncBackend(context)) assertEquals(false, SessionPrefs.fsyncFirst(context)) + SessionPrefs.applyNtsyncDefault(context) + assertEquals(SessionPrefs.SYNC_NTSYNC, SessionPrefs.syncBackend(context)) + } + + @Test + fun anEarlierChoiceMovesToNtsyncOnce() { + for (earlier in listOf(SessionPrefs.SYNC_ESYNC, SessionPrefs.SYNC_FSYNC, SessionPrefs.SYNC_WINESERVER)) { + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit().clear().commit() + SessionPrefs.setSyncBackend(context, earlier) + SessionPrefs.applyNtsyncDefault(context) + assertEquals(SessionPrefs.SYNC_NTSYNC, SessionPrefs.syncBackend(context)) + } + } + + @Test + fun aChoiceMadeAfterTheMoveIsKept() { + SessionPrefs.setSyncBackend(context, SessionPrefs.SYNC_ESYNC) + SessionPrefs.applyNtsyncDefault(context) + SessionPrefs.setSyncBackend(context, SessionPrefs.SYNC_ESYNC) + SessionPrefs.applyNtsyncDefault(context) + assertEquals(SessionPrefs.SYNC_ESYNC, SessionPrefs.syncBackend(context)) + SessionPrefs.setSyncBackend(context, SessionPrefs.SYNC_WINESERVER) + SessionPrefs.applyNtsyncDefault(context) + assertEquals(SessionPrefs.SYNC_WINESERVER, SessionPrefs.syncBackend(context)) } @Test @@ -34,6 +58,7 @@ class SyncBackendTest { @Test fun pickingATabTurnsSyncBackOn() { + SessionPrefs.setFastSync(context, false) SessionPrefs.setSyncFallback(context, false) SessionPrefs.setFsyncFirst(context, false) assertEquals(SessionPrefs.SYNC_WINESERVER, SessionPrefs.syncBackend(context)) From 9438aac0db992cf9699e5b7b4b32bbaa7b4b83ee Mon Sep 17 00:00:00 2001 From: maxjivi05 Date: Fri, 23 Oct 2026 14:55:33 -0400 Subject: [PATCH 4/4] fix: droiddeck-ntsync leaves one-shot handlers alone and replays deferred signals exactly once - Handlers installed with SA_RESETHAND are no longer wrapped, so a deferred one-shot signal can't fall through to the default action. - Deferred signals are replayed with every signal blocked, so a signal landing mid-replay can't send an entry twice. - Taking a deferral slot and holding a signal are safe when one signal interrupts another, and a held signal is released only at the nesting level that held it, so a handler's return can't block it again. --- tools/linuxfs/preload/ntsync.c | 76 +++++++++++++++++------------- tools/tests/test_ntsync_preload.py | 37 +++++++++++++++ 2 files changed, 81 insertions(+), 32 deletions(-) diff --git a/tools/linuxfs/preload/ntsync.c b/tools/linuxfs/preload/ntsync.c index 76e50972d4..d49bb42b74 100644 --- a/tools/linuxfs/preload/ntsync.c +++ b/tools/linuxfs/preload/ntsync.c @@ -260,14 +260,16 @@ static void ns_unlock(uint32_t *w) { } #define NS_DEFER 4 +#define NS_LEVELS 8 struct ns_cs { int depth; int count; - int nheld; + int level; + unsigned held_levels; int sigs[NS_DEFER]; siginfo_t info[NS_DEFER]; - sigset_t held; + sigset_t held[NS_LEVELS]; }; static __thread struct ns_cs ns_cs; @@ -284,17 +286,23 @@ static int ns_deferrable(int sig) { static int ns_defer(int sig, const siginfo_t *si) { struct ns_cs *cs = &ns_cs; if (sig < SIGRTMIN) - for (int i = 0; i < cs->count; i++) - if (cs->sigs[i] == sig) return 1; - if (cs->count >= NS_DEFER) return 0; - cs->sigs[cs->count] = sig; - if (si) memcpy(&cs->info[cs->count], si, sizeof(*si)); - else memset(&cs->info[cs->count], 0, sizeof(*si)); - cs->count++; + for (int i = 0; i < NS_DEFER; i++) + if (__atomic_load_n(&cs->sigs[i], __ATOMIC_RELAXED) == sig) return 1; + int i = __atomic_fetch_add(&cs->count, 1, __ATOMIC_RELAXED); + if (i >= NS_DEFER) { + __atomic_fetch_sub(&cs->count, 1, __ATOMIC_RELAXED); + return 0; + } + if (si) memcpy(&cs->info[i], si, sizeof(*si)); + else memset(&cs->info[i], 0, sizeof(*si)); + __atomic_signal_fence(__ATOMIC_SEQ_CST); + __atomic_store_n(&cs->sigs[i], sig, __ATOMIC_RELAXED); return 1; } static int ns_park(int sig, const siginfo_t *si, ucontext_t *uc) { + int level = ns_cs.level; + if (level < 0 || level >= NS_LEVELS) return 0; sigset_t one; sigemptyset(&one); sigaddset(&one, sig); @@ -306,9 +314,10 @@ static int ns_park(int sig, const siginfo_t *si, ucontext_t *uc) { errno = saved; if (!ok) return 0; sigaddset(&uc->uc_sigmask, sig); - if (!ns_cs.nheld) sigemptyset(&ns_cs.held); - sigaddset(&ns_cs.held, sig); - ns_cs.nheld = 1; + unsigned long *words = (unsigned long *)&ns_cs.held[level]; + unsigned bits = 8 * sizeof(unsigned long); + __atomic_fetch_or(&words[(unsigned)(sig - 1) / bits], 1ul << ((unsigned)(sig - 1) % bits), __ATOMIC_RELAXED); + __atomic_fetch_or(&ns_cs.held_levels, 1u << level, __ATOMIC_RELAXED); return 1; } @@ -316,21 +325,34 @@ static void ns_trampoline(int sig, siginfo_t *si, void *uc) { if (__atomic_load_n(&ns_cs.depth, __ATOMIC_RELAXED) > 0 && (ns_defer(sig, si) || (uc && ns_park(sig, si, uc)))) return; uintptr_t h = __atomic_load_n(&ns_handlers[sig], __ATOMIC_ACQUIRE); if (!h) return; + ns_cs.level++; + __atomic_signal_fence(__ATOMIC_SEQ_CST); if (__atomic_load_n(&ns_siginfo[sig], __ATOMIC_RELAXED)) ((void (*)(int, siginfo_t *, void *))h)(sig, si, uc); else ((void (*)(int))h)(sig); + __atomic_signal_fence(__ATOMIC_SEQ_CST); + ns_cs.level--; } static void ns_flush(void) { struct ns_cs *cs = &ns_cs; - int n = cs->count, sigs[NS_DEFER]; - siginfo_t info[NS_DEFER]; - memcpy(sigs, cs->sigs, sizeof(sigs)); - memcpy(info, cs->info, sizeof(info)); - cs->count = 0; + sigset_t all, mask; + sigfillset(&all); int saved = errno; + pthread_sigmask(SIG_BLOCK, &all, &mask); + int n = cs->count < NS_DEFER ? cs->count : NS_DEFER; pid_t pid = getpid(), tid = (pid_t)ns_self(); for (int i = 0; i < n; i++) - if (syscall(SYS_rt_tgsigqueueinfo, pid, tid, sigs[i], &info[i]) != 0) syscall(SYS_tgkill, pid, tid, sigs[i]); + if (cs->sigs[i] > 0 && syscall(SYS_rt_tgsigqueueinfo, pid, tid, cs->sigs[i], &cs->info[i]) != 0) syscall(SYS_tgkill, pid, tid, cs->sigs[i]); + memset(cs->sigs, 0, sizeof(cs->sigs)); + cs->count = 0; + int level = cs->level; + if (level >= 0 && level < NS_LEVELS && (cs->held_levels & (1u << level))) { + for (int sig = 1; sig < _NSIG; sig++) + if (sigismember(&cs->held[level], sig) == 1) sigdelset(&mask, sig); + sigemptyset(&cs->held[level]); + cs->held_levels &= ~(1u << level); + } + pthread_sigmask(SIG_SETMASK, &mask, NULL); errno = saved; } @@ -343,19 +365,8 @@ static void ns_restore(void) { __atomic_signal_fence(__ATOMIC_SEQ_CST); if (--ns_cs.depth == 0) { __atomic_signal_fence(__ATOMIC_SEQ_CST); - int nheld = ns_cs.nheld; - sigset_t held; - if (nheld) { - held = ns_cs.held; - ns_cs.nheld = 0; - __atomic_signal_fence(__ATOMIC_SEQ_CST); - } - if (ns_cs.count) ns_flush(); - if (nheld) { - int saved = errno; - pthread_sigmask(SIG_UNBLOCK, &held, NULL); - errno = saved; - } + if (ns_cs.count || (ns_cs.held_levels && ns_cs.level >= 0 && ns_cs.level < NS_LEVELS && (ns_cs.held_levels & (1u << ns_cs.level)))) + ns_flush(); } } @@ -371,7 +382,8 @@ int sigaction(int sig, const struct sigaction *act, struct sigaction *old) { uint8_t prev_info = __atomic_load_n(&ns_siginfo[sig], __ATOMIC_RELAXED); struct sigaction mine; const struct sigaction *use = act; - if (act && act->sa_handler != SIG_DFL && act->sa_handler != SIG_IGN && bl_from_ntdll(__builtin_return_address(0))) { + if (act && act->sa_handler != SIG_DFL && act->sa_handler != SIG_IGN && !(act->sa_flags & SA_RESETHAND) && + bl_from_ntdll(__builtin_return_address(0))) { mine = *act; mine.sa_sigaction = ns_trampoline; mine.sa_flags |= SA_SIGINFO; diff --git a/tools/tests/test_ntsync_preload.py b/tools/tests/test_ntsync_preload.py index 34f3eaea45..a2c50a7d68 100644 --- a/tools/tests/test_ntsync_preload.py +++ b/tools/tests/test_ntsync_preload.py @@ -23,6 +23,15 @@ int install_handler(int sig, void (*fn)(int, siginfo_t *, void *), void **seen) *seen = (void *)old.sa_sigaction; return 0; } + +int install_oneshot(int sig, void (*fn)(int, siginfo_t *, void *)) { + struct sigaction sa; + memset(&sa, 0, sizeof(sa)); + sa.sa_sigaction = fn; + sa.sa_flags = SA_SIGINFO | SA_RESTART | SA_RESETHAND; + sigemptyset(&sa.sa_mask); + return sigaction(sig, &sa, NULL); +} """ PROGRAM = r""" @@ -63,6 +72,7 @@ struct wait_args { uint64_t timeout, objs; uint32_t count, index, flags, owner, #define NT_EVENT_READ _IOR('N', 0x8d, struct event_args) int install_handler(int sig, void (*fn)(int, siginfo_t *, void *), void **seen); +int install_oneshot(int sig, void (*fn)(int, siginfo_t *, void *)); static int dev, fails; #define CHECK(name, cond) do { if (!(cond)) { printf("FAIL %s line %d errno %d\n", name, __LINE__, errno); fails++; } } while (0) @@ -423,6 +433,32 @@ static void bursts(void) { close(busy_obj); } +static volatile int oneshot_count; +static void oneshot(int sig, siginfo_t *si, void *uc) { + (void)sig; (void)si; (void)uc; + __atomic_add_fetch(&oneshot_count, 1, __ATOMIC_RELAXED); +} + +static void oneshots(void) { + busy_obj = event(0, 0); + pthread_t w; + stop_worker = 0; + oneshot_count = 0; + pthread_create(&w, NULL, worker, NULL); + int fired = 0; + for (int i = 0; i < 300; i++) { + if (install_oneshot(SIGWINCH, oneshot) != 0) break; + int before = __atomic_load_n(&oneshot_count, __ATOMIC_RELAXED); + pthread_kill(w, SIGWINCH); + fired++; + for (int j = 0; j < 2000 && __atomic_load_n(&oneshot_count, __ATOMIC_RELAXED) == before; j++) usleep(50); + } + stop_worker = 1; + pthread_join(w, NULL); + CHECK("oneshot_handlers_run", oneshot_count == fired && fired == 300); + close(busy_obj); +} + static int outer_obj, inner_obj, other_dev, other_obj; static volatile int nested_ok, nested_done, outer_done; static void nesting(int sig, siginfo_t *si, void *uc) { @@ -495,6 +531,7 @@ int main(void) { stress(); signals(); bursts(); + oneshots(); nested_waits(); printf("done fails=%d\n", fails); return fails != 0;