Skip to content

About

Prebuilt LKM modules that bring Droidspaces container support to stock Android GKI kernels — no kernel reflash. Multi-KMI arm64 builds.

Topics

Resources

Stars

14 stars

Watchers

0 watching

Forks

Latest commit

 

History

287 Commits

Folders and files

Repository files navigation

Droidspaces LKM

Container capabilities for stock GKI kernels — no kernel rebuild, no boot image flashing.

Build

English | 简体中文 · Releases · KMI coverage


Droidspaces needs PID/IPC namespaces, devtmpfs, macvlan, IPv6 NAT and a few cgroup controllers. Most vendor kernels ship with those compiled out to satisfy GKI ABI checks.

The other way to get them back is to unlock the bootloader, rebuild the kernel and flash it. That works, but it costs you: one kernel per device model, the stability of the result is your problem, and every system update means starting over. The modules avoid all of that. One set covers seven KMIs, matched against uname -r, so the device model stops mattering.

Project status

No stable release yet. Every tag published from this repository is a GitHub pre-release (preview). Treat them as builds to try and report on, not as a version to depend on. The first stable release will be tagged once the loadable-hook backend has full hardware regression across all seven KMIs.

What CI does Compiles every KMI, fails the build on error, keeps the .ko files as Actions artifacts. Never publishes.
What Release does Runs only on a tag push (vX.Y.Z), builds, and publishes a pre-release with the modules, per-KMI zips and a source snapshot.
Where to report New issue — the form asks for exactly the data needed to tell a build problem from an environment mismatch.

update.json is only bumped when a release is meant to reach users through the KernelSU updater, so it currently points at the forthcoming v0.1.0.

What it fixes

droidspaces check on an unpatched vendor kernel:

[MUST HAVE]
  [✗] PID namespace
  [✗] IPC namespace
[RECOMMENDED]
  [✗] devtmpfs support
[OPTIONAL]
  [✗] Macvlan support
  [✗] IPv6 NAT support

After loading these modules, every line is a tick:

[MUST HAVE]
  [✓] Root privileges          [✓] PID namespace
  [✓] Linux version            [✓] Mount namespace
  [✓] UTS namespace            [✓] IPC namespace
  [✓] pivot_root syscall       [✓] /proc filesystem
  [✓] /sys filesystem          [✓] Seccomp support

[RECOMMENDED]
  [✓] epoll / signalfd / PTY / devpts      [✓] Loop device
  [✓] ext4 filesystem                      [✓] Cgroup v2 support
  [✓] Cgroup namespace                     [✓] New mount API
  [✓] devtmpfs support

[OPTIONAL]
  [✓] FUSE support             [✓] TUN/TAP support
  [✓] OverlayFS support        [✓] Network namespace
  [✓] Bridge device support    [✓] Veth pair support
  [✓] Macvlan support          [✓] IPv6 NAT support
  [✓] Memory limit support     [✓] Swap limit support
  [✓] CPU limit support        [✓] CPU usage accounting
  [✓] Process limit support    [✓] Sandboxing (user namespaces)

[✓] All required features found!

That is the real output from a 6.1.157 vendor kernel, not a projection. The OPTIONAL block is the interesting one: CPU limit, Process limit and Sandboxing are the three a module was supposed to be unable to provide, and they are the reason this project exists at v1.0.0 rather than v0.x.

Modules

Module Purpose CONFIG it stands in for Autoload
lkm4ctr.ko Namespace core PID_NS / UTS_NS / IPC_NS / SYSVIPC / POSIX_MQUEUE ✅
devtmpfs_lkm.ko Registers a devtmpfs filesystem DEVTMPFS ✅
macvlan.ko Per-container LAN IP MACVLAN ✅
ip6table_nat.ko IPv6 NAT IP6_NF_NAT / IP6_NF_TARGET_MASQUERADE ✅
vkms.ko Virtual DRM device, provides a render node DRM_VKMS (with DRIVER_RENDER patch) ⭕
droid_lkm_pids.ko Emulated pids controller CGROUP_PIDS ✅
droid_lkm_cpu.ko Time-slice CPU quota CFS_BANDWIDTH ✅
uart_guard.ko tty attribute read protection (kprobe) none (guards a vendor uart_get_info lock bug) ✅
mali_nsfix.ko Redirects mali_kbase's pid lookup so GPU contexts can be created in a PID namespace none (fixes a driver assumption; see its README) 🔵

Autoload marks: ✅ loads at boot · 🔵 loads at boot on Mali platforms only · ⭕ not loaded by default — create enable_vkms in the module directory to load it.

Eight of the nine load at boot, subject to the platform conditions below; vkms is the exception and needs an explicit opt-in. The three supplementary modules (droid_lkm_pids, droid_lkm_cpu, uart_guard) go last and cannot block the five above them: a failure there leaves a device that still boots and runs containers, just without the corresponding limit or tty guard. To install but not load one, drop a disable_pids / disable_cpu / disable_uart_guard / disable_mali file in the module directory. A mali_nsfix_dryrun file loads mali_nsfix unarmed (nshf_activate=0) for preflight diagnostics.

Platform-dependent modules

mali_nsfix loads automatically on Mali platforms and is skipped elsewhere. The decision is made from what the device reports, not from a list of vendor names.

本表的 Android 版本是内核模块(KMI)一侧的,与 anland6 用户态无关: anland6 的 waylandbridge 需要 Android 14(API 34)+(ANativeWindow_readFromParcel 是 API 34 才引入的符号,Android 13 上 daemon 加载失败)。 详见 https://github.com/misaka5202/Droidspaces-anland6-rootfs#support-matrix。

vkms is not loaded by default at all. It provides /dev/dri/renderD128 backed by no GPU — Mesa can only fall back to llvmpipe, i.e. CPU software rendering. It exists for desktop images that ship their own standard Wayland compositor (the Anland 5.x route: KDE Plasma / KDE Plasma Mobile / GNOME / Hyprland / Niri / Mango / Denial, whose environment carries ANLAND_DRM_DEVICE=/dev/dri/renderD128). The Mali vendor driver only exposes /dev/mali0, not a DRM render node, so on those images the compositor refuses to start without vkms (e.g. kwin_backend_anland: no usable DRM render device; cannot bring up OpenGL compositing).

The Anland 6.x waylandbridge session is exempt: measured on this device (OPPO PHZ110 / MT6989 / 6.1.157), with vkms removed the GL client still rendered and the frame still reached the screen; the compositor mapped libGLES_mali.so, opened /dev/mali0, and the /dev/dri/renderD128 fd count was zero. That path only needs mali_nsfix. Rule of thumb: 6.x uses mali_nsfix; 5.x / self-composited desktops use vkms. Enable it explicitly if something else does:

touch /data/adb/modules/droidspaces_lkm/enable_vkms
Module Loaded when Skipped when
mali_nsfix.ko /dev/mali0 exists or mali_kbase is loaded no Mali GPU present
vkms.ko enable_vkms exists in the module directory always, otherwise

mali_nsfix is not MTK-specific: it patches a mali_kbase assumption, so any Mali device benefits. Without it, a containerised process that tries to create a GPU context gets eglInitialize() returning 0x3001, and dmesg shows mali 13000000.mali: Failed to get pid pointer for <comm>/<pid>. The driver calls find_get_pid(current->tgid), where tgid is an initial-namespace value while find_get_pid() resolves through the caller's active namespace; for a container process the two disagree and the lookup fails. See extra/mali_nsfix/README.md for the mechanism and measurements.

It is what makes the Mali RootFS image usable at all: that image renders through libhybris against the vendor libGLES_mali.so, which needs a GPU context inside the container. Measured overhead on PHZ110 / MT6989 / 6.1.157 is 0.000008% - 0.000025% CPU (about five intercepted find_get_pid() calls per minute system-wide), and the counters can be read without unloading: nshf_seen / nshf_hits under /sys/module/mali_nsfix/parameters/. For an unverified device, load it unarmed first (mali_nsfix_dryrun, i.e. nshf_activate=0) and read nshf_active / nshf_probe_ok / nshf_layout_valid / nshf_driver; the KernelSU Action button (action.sh doctor) prints the same state plus a machine-readable nshf_status line. Prior art and the full failure chain are listed in the module README.

What else a Mali container needs — the Android-side compositor settings and the dma-buf handling — is in the RootFS repository's desktop and Anland guide.

Install

Option A — KernelSU / APatch module (recommended)

Download droidspaces-lkm-arm64-<version>.zip from Releases, flash it in the manager, reboot.

The module picks the .ko matching /proc/sys/kernel/osrelease at boot.

The zip carries an updateJson, so the manager offers later releases directly; no need to come back here for a new version. If raw.githubusercontent.com is unreachable on your network, point updateJson at the jsDelivr mirror instead:

updateJson=https://cdn.jsdelivr.net/gh/misaka5202/droidspaces-lkm@master/update.json

Option B — manual insmod

insmod lkm4ctr-<kmi>.ko
insmod devtmpfs_lkm-<kmi>.ko devtmpfs_probe=2
insmod ip6table_nat-<kmi>.ko
insmod macvlan-<kmi>.ko
insmod vkms-<kmi>.ko
insmod droid_lkm_pids-<kmi>.ko
insmod droid_lkm_cpu-<kmi>.ko

vkms is only worth loading if you want a render node for a Wayland compositor; nothing else depends on it.

devtmpfs_probe=2 matters. It registers the filesystem and starts no kthread or device hooks. Droidspaces only looks for devtmpfs in /proc/filesystems; the default path (probe=0) installs inline hooks, which is riskier on a kernel it was not built against.

Verify

cat /proc/filesystems | grep devtmpfs      # devtmpfs should appear
unshare -pf true && echo "PID ns OK"
droidspaces check                          # "All required features found!"

Supported kernels

File Android / kernel
droidspaces-lkm-android12-5.10-arm64-<version>.zip Android 12 / 5.10
droidspaces-lkm-android13-5.10-arm64-<version>.zip Android 13 / 5.10
droidspaces-lkm-android13-5.15-arm64-<version>.zip Android 13 / 5.15
droidspaces-lkm-android14-5.15-arm64-<version>.zip Android 14 / 5.15
droidspaces-lkm-android14-6.1-arm64-<version>.zip Android 14 / 6.1
droidspaces-lkm-android15-6.6-arm64-<version>.zip Android 15 / 6.6
droidspaces-lkm-android16-6.12-arm64-<version>.zip Android 16 / 6.12

droidspaces-lkm-arm64-<version>.zip is the combined package: it carries the build for all 7 KMIs and picks the right one at boot from the kernel release plus ro.board.first_api_level. Pick a per-KMI zip instead if you want a smaller download.

arm64 only. Non-GKI kernels and non-ARM64 devices are not supported.

Every module is built for every KMI from that KMI's own kernel source tree in the DDK image; see docs/KMI-COVERAGE.md for the exact matrix and the per-KMI build traps.

A vendor kernel with the same KMI tag can still differ in ABI. Check the KMI tag in uname -r first, and read /data/adb/droidspaces_lkm.log after installing.

Display route

module/route picks the rendering path on Mali, three values:

route Meaning Mali behaviour
auto (default) Current behaviour Loads mali_nsfix; loads vkms only when enable_vkms exists
anland6 Anland 6.x / waylandbridge Loads mali_nsfix; never loads vkms
desktop5 Self-composited desktops (Anland 5.x route) Loads vkms; does not load mali_nsfix

On non-MTK devices the Route tab is hidden from the bottom bar (the route only matters on Mali).

How to change it:

  • At install/update: on MediaTek devices without an existing config, the installer asks for a volume-key choice - VolUp = Anland 6.x, VolDown = standard desktop 5.x. If no key is read, it falls back to auto. Existing installs keep their previous choice.
  • Any time: open this module's WebUI from the KernelSU module page, pick a value and press Apply; takes effect after reboot.
  • CLI: action.sh route auto|anland6|desktop5.

The WebUI (webroot/, Material You style with a four-tab bottom bar: Home / Route / Diagnostics / About, English + Chinese) lets you change the route any time. Home shows loaded modules, Diagnostics prints route, /dev/mali0, mali_kbase, nshf_*, the render node and recent logs, and About carries the repository plus both one-click pack links:

Running a Linux desktop (Anland 6.x)

This project only makes containers work. To actually see Linux windows on the phone you need Anland 6.x. On Mali that chain goes through libhybris + /dev/mali0, and the host-side mali_nsfix is its prerequisite; vkms is not needed (vkms exists for the 5.x / self-composited desktop images, see the previous section).

droidspaces-lkm (this project)
  └─ mali_nsfix.ko → GPU contexts can be created in-container via /dev/mali0
        │
        ▼
Droidspaces-anland6-rootfs (image)
  └─ anlandx session inside the container (wayland link + rootless Xwayland + mini-wm)
        │
        ▼
Anland 6.x host trio
  ├─ anland-awl module (waylandbridge daemon, the Wayland server)
  ├─ com.anlandnext (display side, one Android Activity per window)
  └─ com.anland.shell (launcher; it only starts apps)

Use the setup script from Droidspaces-anland6-rootfs to wire the whole host side in one go (module, APKs, bind mount, daemon config):

adb push scripts/setup-anland6-host.sh /data/local/tmp/
adb shell su -c 'sh /data/local/tmp/setup-anland6-host.sh'

Then verify the chain:

adb shell su -c 'sh /data/local/tmp/verify-anland6-host.sh'

It checks the host, container and app layers in turn (module / daemon / socket / binder / container / app). On Mali there is one more check that script does not cover but matters just as much: whether mali_nsfix is loaded and armed — without it, eglInitialize() inside the container returns 0x3001 and dmesg shows Failed to get pid pointer. Use this module's Action button (action.sh doctor) or dry-run mode to confirm.

Full host-side steps, failure table and troubleshooting: Desktop and Anland.

Do not install the Anland 5.x set (virtual-drm-daemon.zip / app-debug.apk / the /run/display.sock bind mount). 5.x exchanges frames over a private display protocol with its own compositors (KWin/GNOME and friends); on Mali that route needs vkms for a render node. 6.x makes Wayland itself the protocol. Both routes at once break each other.

cgroup limits

--cpus and --pids-limit are the two knobs that cannot be fixed by toggling a config: with CONFIG_CFS_BANDWIDTH=n and CONFIG_CGROUP_PIDS=n the code paths are deleted at compile time, so there is nothing to enable. These two modules emulate the semantics instead:

insmod droid_lkm_pids-<kmi>.ko
insmod droid_lkm_cpu-<kmi>.ko

Then start the container with the limits you want:

droidspaces --name=box --rootfs=<rootfs> \
    --memory=512M --cpus=0.5 --pids-limit=64 start

--memory is required for the other two to land: the emulated pids.max and cpu.max hang off the memory controller, and Droidspaces only enables memory when a memory limit is configured.

Verify inside the container cgroup:

CG=/sys/fs/cgroup/droidspaces/<name>
cat $CG/pids.max          # 64
cat $CG/cpu.max           # 50000
cat $CG/pids.stats        # refused=N, layout=1

Details, guarantees and limitations: extra/cgrouplimits/README.md.

Load them manually. They hook cgroup_can_fork / cgroup_post_fork / cgroup_exit on the inline route first and fall back to kprobe when inline cannot be installed (route=0, the default). route=1 forces inline and route=2 forces kprobe, so a device can be compared and rolled back without recompiling. Keeping them out of boot autostart means a bad interaction can never stop the device from booting.

Full coverage

Every check Droidspaces performs now passes, including the three that look impossible from a module:

Check How
CPU limit support droid_lkm_cpu emulates cpu.max, and registers the sched_cfs_bandwidth_slice_us sysctl the check also wants
Process limit support droid_lkm_pids emulates the pids controller, hooking cgroup_can_fork/cgroup_post_fork/cgroup_exit inline-first with a kprobe fallback
Sandboxing (user namespaces) lkm4ctr exposes /proc/<pid>/ns/user via patches/0001-expose-ns-user.patch

The CPU one has a second precondition that is easy to miss: Droidspaces also requires /proc/sys/kernel/sched_cfs_bandwidth_slice_us to exist, and that sysctl is registered from kernel/sched/fair.c inside #ifdef CONFIG_CFS_BANDWIDTH, so a kernel with the config off never creates the file. The module registers a real table with register_sysctl() in the same shape fair.c uses (0644, proc_dointvec_minmax, default 5000), so the path is readable and writable rather than faked.

The userns one needs three separate fixes, and each one alone produces a partially-working namespace that still passes droidspaces check:

  1. Publish /proc/<pid>/ns/user (patches/0001). Publishing the symlink is only half the job: nsfs_evict() dereferences ns->ns.ops unconditionally, and the kernel's static init_user_ns has no ops initializer when CONFIG_USER_NS=n. A patch that only adds the procfs entry crashes the kernel the first time that namespace is torn down. The patch installs vns_userns_operations on the init namespace first, exactly the way kernel/pid_namespace.c already handles init_pid_ns.

  2. Fix mount namespace ownership (patches/0002). Under CONFIG_USER_NS=n, get_user_ns() compiles to return &init_user_ns, ignoring its argument. copy_mnt_ns() uses it to pin the new mount namespace's owner, so a namespace created from a child userns still belonged to init -- and may_mount() then rejected every mount with EPERM.

  3. Fix mount_capable() (also patches/0002). The same get_user_ns() bug makes alloc_fs_context() set fc->user_ns = init. tmpfs, proc and ramfs all carry FS_USERNS_MOUNT, so they take the ns_capable(fc->user_ns, ...) branch and fail. Bind mounts skip that check, which is why they started working after fix 2 while tmpfs still did not.

With all three, on a 6.1.157 vendor kernel: unshare -Ur maps root, uid_map/gid_map accept ranges up to 65536, and tmpfs, proc and bind mounts all succeed inside the namespace -- on the host and inside a Droidspaces container.

Two more namespaces had the opposite problem: the kernel supports them natively and lkm4ctr was stubbing them out.

Namespace Before After
NET_NS unshare -n silently kept the caller's namespace; --net=macvlan failed with "could not create eth0" real netns, --net=macvlan works
CGROUP_NS unshare -C kept the caller's namespace real cgroup namespace

copy_net_ns was called with flags & ~CLONE_NEWNET, and vns_copy_cgroup_ns ignored its flags entirely. Both were deliberate: the real copy_net_ns path once corrupted the percpu_counters list. Both functions start with inc_ucount(user_ns), which walks ns->ucounts and edits a global hashtable -- accounting a vendored user_namespace does not take part in, which is also what the dec_rlimit_ucounts underflow warnings in dmesg were. Passing the real init_user_ns (what a CONFIG_USER_NS=n kernel substitutes at these call sites) removes the vendored namespace from that code entirely, and the native implementation then does the right thing.

Note that /proc/<pid>/ns/user answers a name lookup, not a directory listing: ls /proc/self/ns/ will not show it, but stat/access succeed. That is what Droidspaces actually probes.

Security notes

These modules add kernel capability, so the ways they can go wrong are worth stating.

  • mount_capable is corrected only for filesystems carrying FS_USERNS_MOUNT. Filesystems the kernel deliberately keeps out of user namespaces still require global CAP_SYS_ADMIN, so a container root cannot mount them.
  • The cgroup limit modules hold a reference on every cgroup they track, so a cgroup cannot be freed underneath them. Their cgroup_rmdir kprobe only marks an entry for reaping; the teardown runs on a workqueue where synchronize_rcu() is legal.
  • lkm4ctr redirects kernel functions by rewriting their entry with an inline jump, not a kprobe trap. The displaced instructions run from a trampoline placed next to the target so a 4-byte b reaches it; the kprobe path remains only as a fallback when that allocation fails.
  • devtmpfs_lkm rewrites device_add/device_del in kernel text. Its inline hook engine refuses a window that crosses a function boundary, refuses an instruction it cannot relocate, and clears the BTI guarded attribute only on the pages holding resumption points, restoring it on unload. Device nodes it creates default to 0600 owned by root when the driver sets no mode.
  • Module parameters are all 0444; nothing is runtime-writable.

See docs/CHANGELOG.md for what each release fixed. The changelog is maintained in Chinese (this project is Chinese-first); every entry starts with a one-line summary of the change.

Troubleshooting

insmod: unknown symbol in module, or unknown parameter

This message is the kernel's catch-all for two unrelated problems, and it hides which one you hit. The module log now separates them.

1. Wrong KMI. The .ko was built for a different kernel version. service.sh checks vermagic before every insmod and refuses with a message naming both versions, instead of letting the kernel report an unknown symbol.

[FAIL] lkm4ctr: lkm4ctr-android14-6.1.ko 的 vermagic (6.1.166-dirty) 与内核 5.10.269-... 不匹配,跳过

If you see that, the installed package does not match the device. Reinstall the build for your kernel (see the table above), and make sure the manager is not holding an old copy.

2. A symbol the kernel does not export. KMI matching cannot fix this: a vendor kernel of the same version can trim exports that the generic one has. The log now quotes the kernel's own line, so you get the symbol name rather than a generic failure:

[FAIL] lkm4ctr: insmod: failed to load ...: unknown symbol in module
             [  12.345] lkm4ctr: Unknown symbol some_helper (err -2)

Report that symbol name in an issue — it says exactly what to look at.

3. unknown parameter means an param=value was passed that the module does not declare. service.sh now filters parameters against the .ko before use and logs what it dropped:

[WARN] devtmpfs_lkm 不支持参数 foo,已忽略

Nothing loads at all

Run the Action button in the module page. It prints the kernel, the resolved KMI, the module list and a capability check, which is enough to tell an environment mismatch from a real failure.

Also check the boot guard: if three consecutive boots never reach boot-completed.sh, the module disables itself and writes the reason to /data/adb/droidspaces_lkm.log and /data/adb/droidspaces_lkm.d/.

Important notes

A mismatched vermagic can still load

The kernel validates the layout of struct module (the size of .gnu.linkonce.this_module), not only the vermagic string. Every module here is built to the same 1088-byte this_module as the vendor modules, which is why a ko built by the DDK loads on a device whose kernel release differs.

Never autoload devtmpfs_lkm with default parameters

devtmpfs_probe=0 (the default) during early boot can hang the device: the module rewrites kernel text and the early-boot environment is not stable. Always pass devtmpfs_probe=2.

Hardware access boundaries

--hw-access maps nodes such as /dev/mali0, /dev/dma_heap, /dev/binder and they can be open()ed inside the container. Whether a Linux desktop can actually use the GPU depends on the driver stack:

  • Qualcomm Adreno: /dev/kgsl-3d0 plus Turnip in userspace works — a Wayland desktop over anland is viable, and needs no vkms.
  • ARM Mali: /dev/mali0 is a private ioctl interface; standard Wayland compositors (KDE/GNOME/Hyprland/Niri/Mango/Denial, i.e. the 5.x route) work over DRM and need vkms to supply the render node. Anland 6.x (waylandbridge) is the exception: it drives /dev/mali0 through libhybris and only needs mali_nsfix, not vkms.

Deployment notes for a Wayland desktop over anland: docs/ANLAND-DEPLOY.md.

Build

Two workflows, deliberately separate:

Workflow Trigger Publishes?
ci.yml push to master, pull request, manual No — artifacts only. Builds one KMI by default (android14-6.1); pass full_matrix: true for all seven
release.yml tag vX.Y.Z, manual with a tag Yes — pre-release only

Both call the reusable build.yml, which only compiles and packages. Keeping publishing out of CI means a green check can never put a broken artifact in front of users, and a release always corresponds to a tag somebody chose.

To cut a preview:

git tag v0.1.0
git push origin v0.1.0

To try a CI build without tagging, download the ko-* artifacts from the run.

Module layout

The installable module follows the KernelSU module guide — no META-INF, no system/ overlay (nothing here modifies /system):

module/
├── module.prop      metadata; version is what the updater compares
├── customize.sh     install-time: arch check, KMI hint, ui_print
├── service.sh       late_start: insmod the per-KMI .ko files
├── uninstall.sh     cleans up; deliberately does not rmmod (see below)
└── action.sh        the Action button: one screen of state + capability checks

Scripts take their own directory with MODDIR=${0%/*} rather than hardcoding /data/adb/modules/<id>, so the module survives being installed elsewhere.

Sources and licensing

This project does not reimplement kernel functionality; everything is ported or adapted:

Component Origin License
lkm4ctr (vendor/ + glue/) cyanmint/lkm4ctr see its copying.txt; vendor/kernel/ comes from Linux, GPL-2.0-only
devtmpfs_lkm / macvlan / ip6table_nat ai-luo2006/droidspaces-6.12-pmb110 GPL-2.0
droid_lkm_pids port of the same project's pids Plan B GPL-2.0
droid_lkm_cpu original GPL-2.0

GPL-2.0 requires source for binaries. Every release carries source-<tag>.tar.gz, the exact tree the .ko files were built from.

vendor/kernel/user_namespace.c, vendor/kernel/nsproxy.c, vendor/kernel/pid_namespace.c, vendor/ipc/* come from Linux (6.1.124 / android14-6.1) with symbol renames so they can be built out of tree.

References

Disclaimer: loading a kernel module runs kernel code with full privilege. Use this only if you can accept the risk of an unbootable device, and have a recovery path (fastboot / recovery).

About

Prebuilt LKM modules that bring Droidspaces container support to stock Android GKI kernels — no kernel reflash. Multi-KMI arm64 builds.

Topics

Resources

Stars

14 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages