Added disk log dump in DEBUG builds via liludump=N boot-arg (requires plugin rebuild)

N is the amount of seconds to wait before saving the log to /var/log/Lilu_%ver_%kernver.txt

Author: vit9696

Changelog.md

@@ -4,6 +4,7 @@ Lilu Changelog
 #### v1.2.7
 - Added support for detecting optimus switch-off
 - Added Sanitize target with ubsan support (thx to NetBSD)
+- Added disk log dump in DEBUG builds via `liludump=N` boot-arg (requires plugin rebuild)
 - Fixed multiple Mach-O parsing issues
 - Fixed support of PCI devices without compatible property
 

Lilu/Headers/kern_util.hpp

@@ -74,10 +74,8 @@ extern proc_t kernproc;
  */
 #define SYSLOG_COND(cond, module, str, ...)                                                          \
 	do {                                                                                             \
-	    if (cond) {                                                                                  \
-	        IOLog( "%s%10s" str "\n", xStringify(PRODUCT_NAME) ": ", module " @ ", ## __VA_ARGS__);  \
-	        if (ADDPR(debugPrintDelay) > 0) IOSleep(ADDPR(debugPrintDelay));                         \
-	    }                                                                                            \
+	    if (cond)                                                                                    \
+	        LLLog( "%s%10s" str "\n", xStringify(PRODUCT_NAME) ": ", module " @ ", ## __VA_ARGS__);  \
 	} while (0)
 
 /**
@@ -236,6 +234,14 @@ extern proc_t kernproc;
  */
 #define PACKED __attribute__((packed))
 
+/**
+ *  This function is supposed to workaround missing entries in the system log.
+ *  By providing its own buffer for logging data.
+ *
+ *  @param format  formatted string
+ */
+EXPORT void LLLog(const char *format, ...);
+
 /**
  *  Two-way substring search
  *

Lilu/PrivateHeaders/kern_config.hpp

@@ -12,23 +12,32 @@
 #include <Headers/kern_user.hpp>
 #include <Headers/kern_policy.hpp>
 #include <Headers/kern_util.hpp>
+#include <kern/thread_call.h>
 
 class Configuration {
 	/**
 	 *  Possible boot arguments
 	 */
-	static constexpr const char *bootargOff {"-liluoff"};			// Disable the kext
-	static constexpr const char *bootargUserOff {"-liluuseroff"};	// Disable kext user patcher
-	static constexpr const char *bootargBeta {"-lilubeta"};			// Force enable the kext on unsupported os
-	static constexpr const char *bootargBetaAll {"-lilubetaall"};	// Force enable the kext and all plugins on unsupported os
-	static constexpr const char *bootargForce {"-liluforce"};		// Force enable the kext (including single user mode)
-	static constexpr const char *bootargDebug {"-liludbg"};			// Enable debug logging
-	static constexpr const char *bootargDebugAll {"-liludbgall"};	// Enable debug logging (for Lilu and all the plugins)
-	static constexpr const char *bootargSlow {"-liluslow"};			// Prefer less destructive userspace measures
-	static constexpr const char *bootargFast {"-lilufast"};			// Prefer faster userspace measures
-	static constexpr const char *bootargLowMem {"-lilulowmem"};		// Disable decompression
-	static constexpr const char *bootargDelay {"liludelay"};		// Extra delay timeout after each printed message
-	
+	static constexpr const char *bootargOff {"-liluoff"};           // Disable the kext
+	static constexpr const char *bootargUserOff {"-liluuseroff"};   // Disable kext user patcher
+	static constexpr const char *bootargBeta {"-lilubeta"};         // Force enable the kext on unsupported os
+	static constexpr const char *bootargBetaAll {"-lilubetaall"};   // Force enable the kext and all plugins on unsupported os
+	static constexpr const char *bootargForce {"-liluforce"};       // Force enable the kext (including single user mode)
+	static constexpr const char *bootargDebug {"-liludbg"};         // Enable debug logging
+	static constexpr const char *bootargDebugAll {"-liludbgall"};   // Enable debug logging (for Lilu and all the plugins)
+	static constexpr const char *bootargSlow {"-liluslow"};         // Prefer less destructive userspace measures
+	static constexpr const char *bootargFast {"-lilufast"};         // Prefer faster userspace measures
+	static constexpr const char *bootargLowMem {"-lilulowmem"};     // Disable decompression
+	static constexpr const char *bootargDelay {"liludelay"};        // Extra delay timeout after each printed message
+	static constexpr const char *bootargDump {"liludump"};          // Dump lilu log to /Lilu...txt after N seconds
+
+public:
+	/**
+	 *  Externally handled boot arguments
+	 */
+	static constexpr const char *bootargCpu {"lilucpu"};            // Simulate this CPU generation, handled in kern_cpu.cpp
+
+private:
 	/**
 	 * Minimal required kernel version
 	 */
@@ -38,19 +47,19 @@ class Configuration {
 	 * Maxmimum supported kernel version
 	 */
 	static constexpr KernelVersion maxKernel {KernelVersion::Mojave};
-	
+
 	/**
 	 *  Set once the arguments are parsed
 	 */
 	bool readArguments {false};
-	
+
 	/**
 	 *  Initialise kernel and user patchers if necessary
 	 *
 	 *  @return true on success
 	 */
 	bool performInit();
-	
+
 	/**
 	 *  TrustedBSD policy called at exec
 	 *
@@ -60,8 +69,7 @@ class Configuration {
 	 *  @return 0 on success
 	 */
 	static int policyCredCheckLabelUpdateExecve(kauth_cred_t old, vnode_t vp, ...);
-	
-	
+
 	/**
 	 *  TrustedBSD policy called before remounting
 	 *
@@ -70,22 +78,48 @@ class Configuration {
 	 *  @param mlabel    mount point label
 	 */
 	static int policyCheckRemount(kauth_cred_t cred, mount *mp, label *mlabel);
-	
+
 	/**
 	 *  TrustedBSD policy options
 	 */
 	mac_policy_ops policyOps {
 		.mpo_policy_initbsd					= Policy::dummyPolicyInitBSD
 	};
-	
+
+#ifdef DEBUG
+	/**
+	 *  Debug buffer dump timeout in seconds
+	 */
+	uint32_t debugDumpTimeout {0};
+
+	/**
+	 *  Debug buffer dump thread call
+	 */
+	thread_call_t debugDumpCall {nullptr};
+
+	/**
+	 *  Initialise log to custom buffer support
+	 *  You may call it from a debugger if you need to save the log once again.
+	 */
+	void initCustomDebugSupport();
+
+	/**
+	 *  Stores debug log on disk
+	 *
+	 *  @param param0 unused
+	 *  @param param1 unused
+	 */
+	static void saveCustomDebugOnDisk(thread_call_param_t param0, thread_call_param_t param1);
+#endif
+
 public:
 	/**
 	 *  Retrieve boot arguments
 	 *
 	 *  @return true if allowed to continue
 	 */
 	bool getBootArguments();
-	
+
 	/**
 	 *  Disable the extension by default
 	 */
@@ -95,17 +129,17 @@ class Configuration {
 	 *  User patcher is disabled on request
 	 */
 	bool isUserDisabled {false};
-	
+
 	/**
 	 *  Do not patch dyld shared cache unless asked
 	 */
 	bool preferSlowMode {false};
-	
+
 	/**
 	 *  Allow decompression
 	 */
 	bool allowDecompress {true};
-	
+
 	/**
 	 *  Install or recovery
 	 */
@@ -115,7 +149,7 @@ class Configuration {
 	 *  Safe mode
 	 */
 	bool safeMode {false};
-	
+
 	/**
 	 *  Beta for all plugins and Lilu itself
 	 */
@@ -140,23 +174,52 @@ class Configuration {
 	 *  User patcher
 	 */
 	UserPatcher userPatcher;
-	
+
 	/**
 	 *  Kernel patcher
 	 */
 	KernelPatcher kernelPatcher;
-	
+
 	/**
 	 *  Policy controller
 	 */
 	Policy policy;
-	
+
 #ifdef DEBUG
+	/**
+	 *  Full policy name
+	 */
 	static constexpr const char *fullName {xStringify(PRODUCT_NAME) " Kernel Extension " xStringify(MODULE_VERSION) " DEBUG build"};
+
+	/**
+	 *  Maximum amount of data we can via the internal buffer (8 MB)
+	 */
+	static constexpr size_t MaxDebugBufferSize {1024*1024*8};
+
+	/**
+	 *  Custom logging lock
+	 */
+	IOSimpleLock *debugLock {nullptr};
+
+	/**
+	 *  Debug buffer with logged data, intentionally disabled in RELEASE mode
+	 *  to avoid sensitive information leak.
+	 *  Contains debugBufferLength symbols, not null-terminated.
+	 */
+	uint8_t *debugBuffer {nullptr};
+
+	/**
+	 *  Debug buffer current length
+	 */
+	size_t debugBufferLength {0};
 #else
+
+	/**
+	 *  Full policy name
+	 */
 	static constexpr const char *fullName {xStringify(PRODUCT_NAME) " Kernel Extension " xStringify(MODULE_VERSION)};
 #endif
-	
+
 	Configuration() : policy(xStringify(PRODUCT_NAME), fullName, &policyOps) {}
 };
 

Lilu/Sources/kern_cpu.cpp

@@ -7,6 +7,7 @@
 
 #include <Headers/kern_cpu.hpp>
 #include <Headers/kern_devinfo.hpp>
+#include <PrivateHeaders/kern_config.hpp>
 #include <i386/proc_reg.h>
 
 extern "C" {
@@ -53,7 +54,7 @@ void CPUInfo::loadCpuInformation() {
 
 	// Last but not least detect CPU generation
 	uint32_t generation = 0;
-	if (PE_parse_boot_argn("lilucpu", &generation, sizeof(generation))) {
+	if (PE_parse_boot_argn(Configuration::bootargCpu, &generation, sizeof(generation))) {
 		DBGLOG("cpu", "found CPU generation override %u", generation);
 		if (generation < static_cast<uint32_t>(CPUInfo::CpuGeneration::MaxGeneration)) {
 			currentGeneration = static_cast<CPUInfo::CpuGeneration>(generation);

Lilu/Sources/kern_start.cpp

@@ -13,6 +13,8 @@
 #include <Headers/kern_api.hpp>
 #include <Headers/kern_efi.hpp>
 #include <Headers/kern_cpu.hpp>
+#include <Headers/kern_file.hpp>
+#include <Headers/kern_time.hpp>
 
 #include <IOKit/IOLib.h>
 #include <IOKit/IORegistryEntry.h>
@@ -98,6 +100,73 @@ int Configuration::policyCredCheckLabelUpdateExecve(kauth_cred_t auth, vnode_t v
 	return 0;
 }
 
+#ifdef DEBUG
+
+void Configuration::initCustomDebugSupport() {
+	if (debugDumpTimeout == 0)
+		return;
+
+	if (!debugBuffer)
+		debugBuffer = Buffer::create<uint8_t>(MaxDebugBufferSize);
+
+	if (!debugLock)
+		debugLock = IOSimpleLockAlloc();
+
+	if (debugBuffer && debugLock) {
+		if (debugDumpCall) {
+			while (!thread_call_free(debugDumpCall))
+				thread_call_cancel(debugDumpCall);
+			debugDumpCall = nullptr;
+		}
+
+		debugDumpCall = thread_call_allocate(saveCustomDebugOnDisk, nullptr);
+		if (debugDumpCall) {
+			uint64_t deadlineNs = convertScToNs(debugDumpTimeout);
+			uint64_t deadlineAbs = 0;
+			nanoseconds_to_absolutetime(deadlineNs, &deadlineAbs);
+			thread_call_enter_delayed(debugDumpCall, mach_absolute_time() + deadlineAbs);
+			return;
+		}
+	}
+
+	if (debugBuffer) {
+		Buffer::deleter(debugBuffer);
+		debugBuffer = nullptr;
+	}
+
+	if (debugLock) {
+		IOSimpleLockFree(debugLock);
+		debugLock = nullptr;
+	}
+}
+
+void Configuration::saveCustomDebugOnDisk(thread_call_param_t, thread_call_param_t) {
+	if (ADDPR(config).debugLock && ADDPR(config).debugBuffer) {
+		auto logBuf = Buffer::create<uint8_t>(MaxDebugBufferSize);
+		if (logBuf) {
+			size_t logBufSize = 0;
+			IOSimpleLockLock(ADDPR(config).debugLock);
+			logBufSize = ADDPR(config).debugBufferLength;
+			if (logBufSize > 0)
+				lilu_os_memcpy(logBuf, ADDPR(config).debugBuffer, logBufSize);
+			IOSimpleLockUnlock(ADDPR(config).debugLock);
+
+			if (logBufSize > 0) {
+				char name[64];
+				snprintf(name, sizeof(name), "/var/log/Lilu_" xStringify(MODULE_VERSION) "_%d.%d.txt", getKernelVersion(), getKernelMinorVersion());
+				FileIO::writeBufferToFile(name, logBuf, logBufSize);
+			}
+
+			Buffer::deleter(logBuf);
+		}
+	}
+
+	thread_call_free(ADDPR(config).debugDumpCall);
+	ADDPR(config).debugDumpCall = nullptr;
+}
+
+#endif
+
 bool Configuration::getBootArguments() {
 	if (readArguments) return !isDisabled;
 
@@ -109,6 +178,12 @@ bool Configuration::getBootArguments() {
 
 	PE_parse_boot_argn(bootargDelay, &ADDPR(debugPrintDelay), sizeof(ADDPR(debugPrintDelay)));
 
+#ifdef DEBUG
+	PE_parse_boot_argn(bootargDump, &debugDumpTimeout, sizeof(debugDumpTimeout));
+	// Slightly out of place, but we need to do that as early as possible.
+	initCustomDebugSupport();
+#endif
+
 	isDisabled |= checkKernelArgument(bootargOff);
 	if (!checkKernelArgument(bootargForce)) {
 		isDisabled |= checkKernelArgument("-s");