mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-11 02:51:10 +00:00
The412Banner
4022351e22
Lifts Bannerlator's Linux/gamescope runtime out into an app of its own: the Wayland compositor, the proot session, the runtime installer, the fake-evdev controller path and the PulseAudio server, with none of the Wine, container or store machinery around them. One activity installs the runtime from the same winlator-contents catalog and a second one runs the session: compositor on a SurfaceView, gamescope and Valve's native arm64 client under proot, a physical pad republished into the fake-input rings, and the session's milestones on screen until the first frame arrives.
110 lines
3.5 KiB
C
110 lines
3.5 KiB
C
/*
|
|
* Ported from WinNative (maxjivi05, feature/wayland-gamescope, 2026-09-18/19), GPL-3.0, with names
|
|
* changed to this project's. The reasoning below is the original author's.
|
|
*
|
|
* File locking for the game library on external storage.
|
|
*
|
|
* The user's games are bound in from /storage/emulated, which Android serves over FUSE, and that
|
|
* filesystem implements no locking at all: flock() and fcntl()'s lock commands answer ENOSYS for
|
|
* every file under it. The Steam client takes a shared lock on each content file as it validates
|
|
* or updates a title and treats the refusal as a failure, so a download walks its progress back
|
|
* and forth instead of finishing; a game reading its own data hits the same wall.
|
|
*
|
|
* Where the kernel can lock, it does: the real call runs first and its answer stands, so files on
|
|
* the app's own f2fs storage keep genuine cross-process exclusion. Only the filesystem that cannot
|
|
* lock at all is answered here, and granting is the honest reading of it - a filesystem with no
|
|
* lock state has nothing to contend over, and the one other party that could contend is inside
|
|
* this same session. Reporting failure instead buys no safety and costs the download.
|
|
*
|
|
* F_GETLK is the exception: it asks who holds a lock, and on a filesystem holding none the true
|
|
* answer is "nobody", so it is reported unlocked rather than granted.
|
|
*/
|
|
#define _GNU_SOURCE
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdarg.h>
|
|
#include <stddef.h>
|
|
#include <sys/file.h>
|
|
#include <unistd.h>
|
|
|
|
/* The filesystem refuses the whole operation, rather than declining this particular lock. */
|
|
static int unsupported(int error) {
|
|
return error == ENOSYS || error == ENOTSUP || error == EOPNOTSUPP;
|
|
}
|
|
|
|
int flock(int fd, int operation) {
|
|
static int (*real_flock)(int, int);
|
|
int result;
|
|
|
|
if (real_flock == NULL) real_flock = dlsym(RTLD_NEXT, "flock");
|
|
if (real_flock == NULL) return 0;
|
|
result = real_flock(fd, operation);
|
|
if (result < 0 && unsupported(errno)) return 0;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* fcntl()'s third argument is an int, a pointer, or absent depending on the command; only the
|
|
* lock commands are of interest here and all of those take a struct flock *. Anything else is
|
|
* passed straight through as a void * - wide enough for both an int and a pointer on every ABI
|
|
* the runtime is built for.
|
|
*/
|
|
static int is_lock_command(int cmd) {
|
|
switch (cmd) {
|
|
case F_SETLK:
|
|
case F_SETLKW:
|
|
#ifdef F_OFD_SETLK
|
|
case F_OFD_SETLK:
|
|
#endif
|
|
#ifdef F_OFD_SETLKW
|
|
case F_OFD_SETLKW:
|
|
#endif
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int is_lock_query(int cmd) {
|
|
switch (cmd) {
|
|
case F_GETLK:
|
|
#ifdef F_OFD_GETLK
|
|
case F_OFD_GETLK:
|
|
#endif
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int fcntl(int fd, int cmd, ...) {
|
|
static int (*real_fcntl)(int, int, ...);
|
|
va_list ap;
|
|
void *arg;
|
|
int result;
|
|
|
|
va_start(ap, cmd);
|
|
arg = va_arg(ap, void *);
|
|
va_end(ap);
|
|
|
|
if (real_fcntl == NULL) real_fcntl = dlsym(RTLD_NEXT, "fcntl");
|
|
if (real_fcntl == NULL) {
|
|
errno = ENOSYS;
|
|
return -1;
|
|
}
|
|
result = real_fcntl(fd, cmd, arg);
|
|
if (result >= 0 || !unsupported(errno)) return result;
|
|
if (is_lock_command(cmd)) return 0;
|
|
if (is_lock_query(cmd) && arg != NULL) {
|
|
((struct flock *)arg)->l_type = F_UNLCK;
|
|
return 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#if defined(__GLIBC__) && defined(F_SETLK64)
|
|
/* glibc's large-file build redirects both names; the runtime is 64-bit, so they are the same call. */
|
|
int fcntl64(int fd, int cmd, ...) __attribute__((alias("fcntl")));
|
|
#endif
|