ci: Attempting once more to build the LKM using the DDK

kernel/.vscode/c_cpp_properties.json

@@ -0,0 +1,11 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "cStandard": "c11",
+            "intelliSenseMode": "gcc-arm64",
+            "compileCommands": "${workspaceFolder}/compile_commands.json"
+        }
+    ],
+    "version": 4
+}

kernel/.vscode/generate_compdb.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+from __future__ import print_function, division
+
+import argparse
+import fnmatch
+import functools
+import json
+import math
+import multiprocessing
+import os
+import re
+import sys
+
+
+CMD_VAR_RE = re.compile(r'^\s*(?:saved)?cmd_(\S+)\s*:=\s*(.+)\s*$', re.MULTILINE)
+SOURCE_VAR_RE = re.compile(r'^\s*source_(\S+)\s*:=\s*(.+)\s*$', re.MULTILINE)
+
+
+def print_progress_bar(progress):
+    progress_bar = '[' + '|' * int(50 * progress) + '-' * int(50 * (1.0 - progress)) + ']'
+    print('\r', progress_bar, "{0:.1%}".format(progress), end='\r', file=sys.stderr)
+
+
+def parse_cmd_file(out_dir, cmdfile_path):
+    with open(cmdfile_path, 'r') as cmdfile:
+        cmdfile_content = cmdfile.read()
+
+    commands = { match.group(1): match.group(2) for match in CMD_VAR_RE.finditer(cmdfile_content) }
+    sources = { match.group(1): match.group(2) for match in SOURCE_VAR_RE.finditer(cmdfile_content) }
+
+    return [{
+            'directory': out_dir,
+            'command': commands[o_file_name],
+            'file': source,
+            'output': o_file_name
+        } for o_file_name, source in sources.items()]
+
+
+def gen_compile_commands(cmd_file_search_path, out_dir):
+    print("Building *.o.cmd file list...", file=sys.stderr)
+
+    out_dir = os.path.abspath(out_dir)
+
+    if not cmd_file_search_path:
+        cmd_file_search_path = [out_dir]
+
+    cmd_files = []
+    for search_path in cmd_file_search_path:
+        if (os.path.isdir(search_path)):
+            for cur_dir, subdir, files in os.walk(search_path):
+                cmd_files.extend(os.path.join(cur_dir, cmdfile_name) for cmdfile_name in fnmatch.filter(files, '*.o.cmd'))
+        else:
+            cmd_files.extend(search_path)
+
+    if not cmd_files:
+        print("No *.o.cmd files found in", ", ".join(cmd_file_search_path), file=sys.stderr)
+        return
+
+    print("Parsing *.o.cmd files...", file=sys.stderr)
+
+    n_processed = 0
+    print_progress_bar(0)
+
+    compdb = []
+    pool = multiprocessing.Pool()
+    try:
+        for compdb_chunk in pool.imap_unordered(functools.partial(parse_cmd_file, out_dir), cmd_files, chunksize=int(math.sqrt(len(cmd_files)))):
+            compdb.extend(compdb_chunk)
+            n_processed += 1
+            print_progress_bar(n_processed / len(cmd_files))
+
+    finally:
+        pool.terminate()
+        pool.join()
+
+    print(file=sys.stderr)
+    print("Writing compile_commands.json...", file=sys.stderr)
+
+    with open('compile_commands.json', 'w') as compdb_file:
+        json.dump(compdb, compdb_file, indent=1)
+
+
+def main():
+    cmd_parser = argparse.ArgumentParser()
+    cmd_parser.add_argument('-O', '--out-dir', type=str, default=os.getcwd(), help="Build output directory")
+    cmd_parser.add_argument('cmd_file_search_path', nargs='*', help="*.cmd file search path")
+    gen_compile_commands(**vars(cmd_parser.parse_args()))
+
+
+if __name__ == '__main__':
+    main()

kernel/.vscode/settings.json

@@ -0,0 +1,35 @@
+{
+    "files.exclude": {
+        "**/*.o.cmd": true,
+        "**/*.ko.cmd": true,
+        "**/*.mod.cmd": true,
+        "**/*.cmd": true,
+        "**/*.order": true,
+        "**/*.symvers": true,
+        "**/*.o": true,
+        "**/*.mod": true,
+        "**/android-wuwa.mod.c": true,
+        "**/android-wuwa.lds": true,
+        "**/.*.*.cmd": true,
+        "**/.*.d": true,
+        "**/.*.S": true
+    },
+    "[c]": {
+        "editor.detectIndentation": false,
+        "editor.tabSize": 4,
+        "editor.insertSpaces": true,
+        "editor.rulers": [80,100]
+    },
+    "files.associations": {
+        "*.h": "c",
+        "ratio": "c",
+        "array": "c",
+        "string_view": "c",
+        "initializer_list": "c",
+        "random": "cpp"
+    },
+    "editor.indentSize": 4,
+    "editor.insertSpaces": true,
+    "editor.detectIndentation": false,
+    "clangd.path": "/opt/ddk/clang/clang-r450784e/bin/clangd"
+}

kernel/.vscode/tasks.json

@@ -0,0 +1,16 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Generate compile_commands.json",
+            "type": "process",
+            "command": "python",
+            "args": [
+                "${workspaceRoot}/.vscode/generate_compdb.py"
+            ],
+            "problemMatcher": []
+        }
+    ]
+}

kernel/Kconfig

@@ -2,7 +2,6 @@ menu "KernelSU"
 
 config KSU
     tristate "KernelSU function support"
-    depends on OVERLAY_FS
     default y
     help
       Enable kernel-level root privileges on Android System.
@@ -38,8 +37,6 @@ choice
     prompt "KernelSU hook type"
     depends on KSU
     default KSU_KPROBES_HOOK
-    help
-      Hook type for KernelSU
 
 config KSU_KPROBES_HOOK
     bool "Hook KernelSU with Kprobes"

kernel/Makefile

@@ -45,6 +45,12 @@ KSU_VERSION_API := 3.2.0
 GIT_BIN := /usr/bin/env PATH="$$PATH":/usr/bin:/usr/local/bin git
 CURL_BIN := /usr/bin/env PATH="$$PATH":/usr/bin:/usr/local/bin curl
 
+KDIR := $(KDIR)
+MDIR := $(realpath $(dir $(abspath $(lastword $(MAKEFILE_LIST)))))
+
+$(info -- KDIR: $(KDIR))
+$(info -- MDIR: $(MDIR))
+
 KSU_GITHUB_VERSION := $(shell $(CURL_BIN) -s "https://api.github.com/repos/$(REPO_OWNER)/$(REPO_NAME)/releases/latest" | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/\1/')
 KSU_GITHUB_VERSION_COMMIT := $(shell $(CURL_BIN) -sI "https://api.github.com/repos/$(REPO_OWNER)/$(REPO_NAME)/commits?sha=$(REPO_BRANCH)&per_page=1" | grep -i "link:" | sed -n 's/.*page=\([0-9]*\)>; rel="last".*/\1/p')
 
@@ -54,6 +60,10 @@ else
   KSU_SRC := $(srctree)/$(src)
 endif
 
+ifneq ($(shell test -e $(KSU_SRC)/../.git && echo "in-tree"),in-tree)
+  KSU_SRC := $(MDIR)
+endif
+
 LOCAL_GIT_EXISTS := $(shell test -e $(KSU_SRC)/../.git && echo 1 || echo 0)
 
 define get_ksu_version_full
@@ -110,8 +120,6 @@ ccflags-y += -DKSU_MANAGER_PACKAGE=\"$(KSU_MANAGER_PACKAGE)\"
 $(info -- SukiSU Manager package name: $(KSU_MANAGER_PACKAGE))
 endif
 
-$(info -- Supported Unofficial Manager: 5ec1cff (GKI) ShirkNeko udochina (GKI and KPM))
-
 ifeq ($(CONFIG_KSU_KPROBES_HOOK), y)
 $(info -- SukiSU: CONFIG_KSU_KPROBES_HOOK)
 else ifeq ($(CONFIG_KSU_TRACEPOINT_HOOK), y)
@@ -154,4 +162,11 @@ endif
 ccflags-y += -Wno-implicit-function-declaration -Wno-strict-prototypes -Wno-int-conversion -Wno-gcc-compat
 ccflags-y += -Wno-declaration-after-statement -Wno-unused-function
 
+all:
+	make -C $(KDIR) M=$(MDIR) modules
+compdb:
+	python3 $(MDIR)/.vscode/generate_compdb.py -O $(KDIR) $(MDIR)
+clean:
+	make -C $(KDIR) M=$(MDIR) clean
+
 # Keep a new line here!! Because someone may append config

kernel/core_hook.c

@@ -887,4 +887,4 @@ void ksu_core_exit(void)
         flush_workqueue(ksu_workqueue);
         destroy_workqueue(ksu_workqueue);
     }
-}
+}

kernel/kernel_compat.h

@@ -6,6 +6,14 @@
 #include "ss/policydb.h"
 #include "linux/key.h"
 
+#if defined(CONFIG_KPROBES) && !(defined(CONFIG_KSU_TRACEPOINT_HOOK) || defined(CONFIG_KSU_MANUAL_HOOK))
+#define __KPROBES_HOOK 1
+#elif (defined(CONFIG_KSU_TRACEPOINT_HOOK) || defined(CONFIG_KSU_MANUAL_HOOK)) && !defined(CONFIG_KSU_KPROBES_HOOK)
+#define __KPROBES_HOOK 0
+#elif defined(CONFIG_KSU_KPROBES_HOOK)
+#define __KPROBES_HOOK 1
+#endif
+
 
 #if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
 // arch/arm64/include/asm/barrier.h, adding dsb probably unneeded

kernel/ksu.c

@@ -7,6 +7,7 @@
 
 #include "allowlist.h"
 #include "arch.h"
+#include "kernel_compat.h"
 #include "core_hook.h"
 #include "feature.h"
 #include "klog.h" // IWYU pragma: keep
@@ -56,7 +57,7 @@ int __init kernelsu_init(void)
     ksu_allowlist_init();
 
     ksu_throne_tracker_init();
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     ksu_sucompat_init();
     ksu_ksud_init();
 #else
@@ -85,7 +86,7 @@ void kernelsu_exit(void)
 
     destroy_workqueue(ksu_workqueue);
 
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     ksu_ksud_exit();
     ksu_sucompat_exit();
 #endif

kernel/ksud.c

@@ -49,7 +49,7 @@ static void stop_vfs_read_hook();
 static void stop_execve_hook();
 static void stop_input_hook();
 
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
 static struct work_struct stop_vfs_read_work;
 static struct work_struct stop_execve_hook_work;
 static struct work_struct stop_input_hook_work;
@@ -268,7 +268,7 @@ static ssize_t read_iter_proxy(struct kiocb *iocb, struct iov_iter *to)
 int ksu_handle_vfs_read(struct file **file_ptr, char __user **buf_ptr,
             size_t *count_ptr, loff_t **pos)
 {
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
      if (!ksu_vfs_read_hook) {
          return 0;
      }
@@ -381,7 +381,7 @@ static bool is_volumedown_enough(unsigned int count)
 int ksu_handle_input_handle_event(unsigned int *type, unsigned int *code,
                   int *value)
 {
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
      if (!ksu_input_hook) {
          return 0;
      }
@@ -423,7 +423,7 @@ bool ksu_is_safe_mode()
     return false;
 }
 
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
 static int sys_execve_handler_pre(struct kprobe *p, struct pt_regs *regs)
 {
     /*
@@ -596,7 +596,7 @@ static void do_stop_input_hook(struct work_struct *work)
 
 static void stop_vfs_read_hook()
 {
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     bool ret = schedule_work(&stop_vfs_read_work);
     pr_info("unregister vfs_read kprobe: %d!\n", ret);
 #else
@@ -607,7 +607,7 @@ static void stop_vfs_read_hook()
 
 static void stop_execve_hook()
 {
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     bool ret = schedule_work(&stop_execve_hook_work);
     pr_info("unregister execve kprobe: %d!\n", ret);
 #else
@@ -623,7 +623,7 @@ static void stop_input_hook()
         return;
     }
     input_hook_stopped = true;
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     bool ret = schedule_work(&stop_input_hook_work);
     pr_info("unregister input kprobe: %d!\n", ret);
 #else
@@ -635,7 +635,7 @@ static void stop_input_hook()
 // ksud: module support
 void ksu_ksud_init()
 {
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     int ret;
 
     ret = register_kprobe(&execve_kp);
@@ -655,7 +655,7 @@ void ksu_ksud_init()
 
 void ksu_ksud_exit()
 {
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     unregister_kprobe(&execve_kp);
     // this should be done before unregister vfs_read_kp
     // unregister_kprobe(&vfs_read_kp);

kernel/sucompat.c

@@ -62,7 +62,7 @@ static const struct ksu_feature_handler su_compat_handler = {
     .set_handler = su_compat_feature_set,
 };
 
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
 static bool ksu_sucompat_hook_state __read_mostly = true;
 #endif
 
@@ -94,7 +94,7 @@ int ksu_handle_faccessat(int *dfd, const char __user **filename_user, int *mode,
 {
     const char su[] = SU_PATH;
 
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
     if (!ksu_sucompat_hook_state) {
          return 0;
      }
@@ -124,7 +124,7 @@ int ksu_handle_stat(int *dfd, const char __user **filename_user, int *flags)
     // const char sh[] = SH_PATH;
     const char su[] = SU_PATH;
 
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
     if (!ksu_sucompat_hook_state) {
          return 0;
      }
@@ -182,7 +182,7 @@ int ksu_handle_execveat_sucompat(int *fd, struct filename **filename_ptr,
     const char sh[] = KSUD_PATH;
     const char su[] = SU_PATH;
 
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
     if (!ksu_sucompat_hook_state) {
          return 0;
      }
@@ -228,7 +228,7 @@ int ksu_handle_execve_sucompat(int *fd, const char __user **filename_user,
     const char su[] = SU_PATH;
     char path[sizeof(su) + 1];
 
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
     if (!ksu_sucompat_hook_state){
          return 0;
      }
@@ -273,7 +273,7 @@ int ksu_handle_devpts(struct inode *inode)
 int __ksu_handle_devpts(struct inode *inode)
 {
 
-#ifndef CONFIG_KSU_KPROBES_HOOK
+#ifndef __KPROBES_HOOK
     if (!ksu_sucompat_hook_state)
         return 0;
 #endif
@@ -299,7 +299,7 @@ int __ksu_handle_devpts(struct inode *inode)
     return 0;
 }
 
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
 static int faccessat_handler_pre(struct kprobe *p, struct pt_regs *regs)
 {
     struct pt_regs *real_regs = PT_REAL_REGS(regs);
@@ -381,7 +381,7 @@ static void destroy_kprobe(struct kprobe **kp_ptr)
 // sucompat: permited process can execute 'su' to gain root access.
 void ksu_sucompat_enable()
 {
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     su_kps[0] = init_kprobe(SYS_EXECVE_SYMBOL, execve_handler_pre);
     su_kps[1] = init_kprobe(SYS_FACCESSAT_SYMBOL, faccessat_handler_pre);
     su_kps[2] = init_kprobe(SYS_NEWFSTATAT_SYMBOL, newfstatat_handler_pre);
@@ -394,7 +394,7 @@ void ksu_sucompat_enable()
 
 void ksu_sucompat_disable()
 {
-#ifdef CONFIG_KSU_KPROBES_HOOK
+#ifdef __KPROBES_HOOK
     int i;
     for (i = 0; i < ARRAY_SIZE(su_kps); i++) {
         destroy_kprobe(&su_kps[i]);