/// <summary>
/// Initializes the sandbox kernel extension connection manager, setting up the kernel extension connection and workers that drain the
/// kernel event queue and report file accesses
/// </summary>
public KextConnection(Config config = null, bool skipDisposingForTests = false)
{
m_reportQueueLastEnqueueTime = 0;
m_kextConnectionInfo = new Sandbox.KextConnectionInfo()
{
Error = Sandbox.KextSuccess
};
m_sharedMemoryInfo = new Sandbox.KextSharedMemoryInfo()
{
Error = Sandbox.KextSuccess
};
MeasureCpuTimes = config.MeasureCpuTimes;
IsInTestMode = skipDisposingForTests;
// initialize kext connection
Sandbox.InitializeKextConnection(ref m_kextConnectionInfo);
if (m_kextConnectionInfo.Error != Sandbox.KextSuccess)
{
throw new BuildXLException($@"Unable to connect to sandbox kernel extension (Code: {m_kextConnectionInfo.Error}) - make sure it is loaded and retry! {KextInstallHelper}");
}
// check and set if the sandbox is running in debug configuration
bool isDebug = false;
Sandbox.CheckForDebugMode(ref isDebug, m_kextConnectionInfo);
ProcessUtilities.SetNativeConfiguration(isDebug);
#if DEBUG
if (!ProcessUtilities.IsNativeInDebugConfiguration())
#else
if (ProcessUtilities.IsNativeInDebugConfiguration())
#endif
{
throw new BuildXLException($"Sandbox kernel extension build flavor missmatch - the extension must match the engine build flavor, Debug != Release. {KextInstallHelper}");
}
// check if the sandbox version matches
var stringBufferLength = MaxVersionNumberLength + 1;
var version = new StringBuilder(stringBufferLength);
Sandbox.KextVersionString(version, stringBufferLength);
if (!RequiredKextVersionNumber.Equals(version.ToString().TrimEnd('\0')))
{
throw new BuildXLException($"Sandbox kernel extension version mismatch, the loaded kernel extension version '{version}' does not match the required version '{RequiredKextVersionNumber}'. {KextInstallHelper}");
}
if (config?.KextConfig != null)
{
if (!Sandbox.Configure(config.KextConfig.Value, m_kextConnectionInfo))
{
throw new BuildXLException($"Unable to configure sandbox kernel extension");
}
}
m_failureCallback = config?.FailureCallback;
// Initialize the shared memory region
Sandbox.InitializeKextSharedMemory(m_kextConnectionInfo, ref m_sharedMemoryInfo);
if (m_sharedMemoryInfo.Error != Sandbox.KextSuccess)
{
throw new BuildXLException($"Unable to allocate shared memory region for worker (Code:{m_sharedMemoryInfo.Error})");
}
if (!SetFailureNotificationHandler())
{
throw new BuildXLException($"Unable to set sandbox kernel extension failure notification callback handler");
}
m_workerThread = new Thread(() => StartReceivingAccessReports(m_sharedMemoryInfo.Address, m_sharedMemoryInfo.Port));
m_workerThread.IsBackground = true;
m_workerThread.Priority = ThreadPriority.Highest;
m_workerThread.Start();
unsafe bool SetFailureNotificationHandler()
{
return(Sandbox.SetFailureNotificationHandler(KextFailureCallback, m_kextConnectionInfo));
void KextFailureCallback(void *refCon, int status)
{
m_failureCallback?.Invoke(status, $"Unrecoverable kernel extension failure happened - try reloading the kernel extension or restart your system. {KextInstallHelper}");
}
}
}
/// <summary>
/// Initializes the sandbox kernel extension connection manager, setting up the kernel extension connection and workers that drain the
/// kernel event queue and report file accesses
/// </summary>
public SandboxedKextConnection(int numberOfKextConnections, ulong reportQueueSizeMB = 0, Sandbox.FailureNotificationCallback failureCallback = null, bool skipDisposingForTests = false)
{
Contract.Requires(numberOfKextConnections > 0, "The number of connections to establish to the kernel extension must at least be 1.");
NumberOfKextConnections = numberOfKextConnections;
m_skipDisposingForTests = skipDisposingForTests;
m_callback = () =>
{
return(m_kextConnectionInfo);
};
Sandbox.InitializeKextConnectionInfoCallback(m_callback);
unsafe
{
var connectionInfo = new Sandbox.KextConnectionInfo()
{
Error = Sandbox.KextSuccess
};
Sandbox.InitializeKextConnection(&connectionInfo);
if (connectionInfo.Error != Sandbox.KextSuccess)
{
throw new BuildXLException($"Unable to connect to sandbox kernel extension (Code: {connectionInfo.Error}) - make sure it is loaded!");
}
m_kextConnectionInfo = connectionInfo;
var stringBufferLength = m_maxVersionNumberLength + 1;
var version = new StringBuilder(stringBufferLength);
Sandbox.KextVersionString(version, stringBufferLength);
if (!RequiredKextVersionNumber.Equals(version.ToString().TrimEnd('\0')))
{
throw new BuildXLException($"Sandbox kernel extension version mismatch, the loaded kernel extension version '{version}' does not match the required version '{RequiredKextVersionNumber}'.");
}
if (reportQueueSizeMB > 0 && !Sandbox.SetReportQueueSize(reportQueueSizeMB))
{
throw new BuildXLException($"Unable to set sandbox kernel extension report queue size.");
}
m_failureCallback = failureCallback;
for (int count = 0; count < NumberOfKextConnections; count++)
{
// Initialize the shared memory region
var memoryInfo = new Sandbox.KextSharedMemoryInfo()
{
Error = Sandbox.KextSuccess
};
Sandbox.InitializeKextSharedMemory(&memoryInfo);
if (memoryInfo.Error != Sandbox.KextSuccess)
{
throw new BuildXLException($"Unable to allocate shared memory region for worker (Code:{memoryInfo.Error})");
}
if (m_failureCallback != null && !Sandbox.SetFailureNotificationHandler(m_failureCallback))
{
throw new BuildXLException($"Unable to set sandbox kernel extension failure notification callback handler.");
}
m_sharedMemoryInfos.Add(memoryInfo);
}
m_sharedMemoryInfos.ForEach(memoryInfo => {
Thread worker = new Thread(() => StartReceivingAccessReports(memoryInfo.Address, memoryInfo.Port));
m_workerThreads.Add(worker);
worker.IsBackground = true;
worker.Priority = ThreadPriority.Highest;
worker.Start();
});
}
}
