+
+// BUILD: $CC target.c -o $BUILD_DIR/target.exe -DRUN_DIR="$RUN_DIR"
+// BUILD: $CC foo.c -o $BUILD_DIR/libfoo.dylib -dynamiclib
+// BUILD: $CXX main.mm -o $BUILD_DIR/dyld_process_info_notify.exe -DRUN_DIR="$RUN_DIR"
+// BUILD: $TASK_FOR_PID_ENABLE $BUILD_DIR/dyld_process_info_notify.exe
+
+// RUN: $SUDO ./dyld_process_info_notify.exe
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <unistd.h>
+#include <signal.h>
+#include <spawn.h>
+#include <errno.h>
+#include <libgen.h>
+#include <sys/proc.h>
+#include <mach/mach.h>
+#include <sys/param.h>
+#include <mach/machine.h>
+#include <mach-o/dyld_images.h>
+#include <mach-o/dyld_process_info.h>
+#include <dispatch/dispatch.h>
+#include <Availability.h>
+
+#include "test_support.h"
+
+//FIXME: We need to add some concurrent access tests
+//FIXME: Add cross architecture tests back now that arm64e macOS exists
+
+extern char** environ;
+
+// This is a one shot semaphore implementation that is QoS aware with integreated logging
+struct OneShotSemaphore {
+ OneShotSemaphore(const char* N) :_name(strdup(N)), _block(dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS, ^{})) {}
+ bool wait() {
+ LOG("Waiting for semaphore %s", _name);
+ dispatch_time_t tenSecondFromNow = dispatch_time(DISPATCH_WALLTIME_NOW, 10 * NSEC_PER_SEC);
+ if (dispatch_block_wait(_block, tenSecondFromNow) != 0) {
+ LOG("Timeout for semaphore %s", _name);
+ return false;
+ }
+ return true;
+ }
+ void signal() {
+ LOG("Signalling semaphore %s", _name);
+ _block();
+ }
+private:
+ const char* _name;
+ dispatch_block_t _block;
+};
+
+void launchTest(bool launchSuspended, bool disconnectEarly)
+{
+
+ LOG("launchTest (%s)", launchSuspended ? "suspended" : "unsuspened");
+ LOG("launchTest (%s)", disconnectEarly ? "disconnect early" : "normal disconnnect");
+ dispatch_queue_t queue = dispatch_queue_create("com.apple.dyld.test.dyld_process_info", NULL);
+ dispatch_queue_t signalQueue = dispatch_queue_create("com.apple.dyld.test.dyld_process_info.signals", NULL);
+
+ // We use these blocks as semaphores. We do it this way so have ownership for QOS and so we get logging
+ __block OneShotSemaphore childReady("childReady");
+ __block OneShotSemaphore childExit("childExit");
+ __block OneShotSemaphore childDone("childDone");
+ __block OneShotSemaphore childExitNotification("childExitNotification");
+
+ // We control our interactions with the sub ordinate process via signals, but if we send signals before its signal handlers
+ // are installed it will terminate. We wait for it to SIGUSR1 us to indicate it is ready, so we need to setup a signal handler for
+ // that.
+ signal(SIGUSR1, SIG_IGN);
+ dispatch_source_t usr1SignalSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGUSR1, 0, signalQueue);
+ dispatch_source_set_event_handler(usr1SignalSource, ^{
+ LOG("Got SIGUSR1");
+ childReady.signal();
+ });
+ dispatch_resume(usr1SignalSource);
+
+ signal(SIGUSR2, SIG_IGN);
+ dispatch_source_t usr2SignalSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGUSR2, 0, signalQueue);
+ dispatch_source_set_event_handler(usr2SignalSource, ^{
+ LOG("Got SIGUSR2");
+ childDone.signal();
+ });
+ dispatch_resume(usr2SignalSource);
+
+ pid_t pid;
+ task_t task;
+ __block bool sawMainExecutable = false;
+ __block bool sawlibSystem = false;
+ __block bool gotMainNotice = false;
+ __block bool gotMainNoticeBeforeAllInitialDylibs = false;
+ __block bool gotFooNoticeBeforeMain = false;
+ __block int libFooLoadCount = 0;
+ __block int libFooUnloadCount = 0;
+ __block dyld_process_info_notify handle;
+
+ _process process;
+ process.set_executable_path(RUN_DIR "/target.exe");
+ const char* env[] = { "TEST_OUTPUT=None", NULL};
+ process.set_env(env);
+ process.set_launch_suspended(launchSuspended);
+ process.set_exit_handler(^(pid_t pid) {
+ // This is almost all logging code, the only functional element of it
+ // is calling the childExit() semaphore
+ int status = 0;
+ int dispStatus = 0;
+ (void)waitpid(pid, &status, 0);
+ const char* exitType = "UNKNOWN";
+ if (WIFEXITED(status)) {
+ exitType = "exit()";
+ dispStatus = WEXITSTATUS(status);
+ }
+ if (WIFSIGNALED(status)) {
+ exitType = "signal";
+ dispStatus = WTERMSIG(status);
+ }
+ LOG("DIED via %s (pid: %d, status: %d)", exitType, pid, dispStatus);
+ childExit.signal();
+ });
+
+ // Launch process
+ pid = process.launch();
+ LOG("launchTest pid (%u)", pid);
+ if ( task_read_for_pid(mach_task_self(), pid, &task) != KERN_SUCCESS ) {
+ FAIL("task_read_for_pid()");
+ }
+
+ // Attach notifier
+ kern_return_t kr;
+ unsigned count = 0;
+ do {
+ handle = _dyld_process_info_notify( task, queue,
+ ^(bool unload, uint64_t timestamp, uint64_t machHeader, const uuid_t uuid, const char* path) {
+ LOG("Handler called");
+ if ( strstr(path, "/target.exe") != NULL )
+ sawMainExecutable = true;
+ if ( strstr(path, "/libSystem") != NULL )
+ sawlibSystem = true;
+ if ( strstr(path, "/libfoo.dylib") != NULL ) {
+ if ( !gotMainNotice ) {
+ gotFooNoticeBeforeMain = true;
+ }
+ if ( unload ) {
+ ++libFooUnloadCount;
+ } else {
+ ++libFooLoadCount;
+ if (disconnectEarly) {
+ _dyld_process_info_notify_release(handle);
+ }
+ }
+ }
+ },
+ ^{
+ LOG("TERMINATED (pid: %d)", pid);
+ childExitNotification.signal();
+ },
+ &kr);
+ ++count;
+ if ( handle == NULL )
+ LOG("_dyld_process_info_notify() returned NULL, result=%d, count=%d", kr, count);
+ } while ( (handle == NULL) && (count < 5) );
+ LOG("launchTest handler registered");
+
+ if ( handle == NULL ) {
+ FAIL("Did not not get handle");
+ }
+
+ // if suspended attach main notifier and unsuspend
+ if (launchSuspended) {
+ // If the process starts suspended register for main(),
+ // otherwise skip since this test is a race between
+ // process setup and notification registration
+ _dyld_process_info_notify_main(handle, ^{
+ LOG("target entering main()");
+ gotMainNotice = true;
+ if ( !sawMainExecutable || !sawlibSystem )
+ gotMainNoticeBeforeAllInitialDylibs = true;
+ });
+ kill(pid, SIGCONT);
+ LOG("Sent SIGCONT");
+ }
+
+ if (!childReady.wait()) {
+ FAIL("Timed out waiting for child to signal it is ready");
+ }
+ kill(pid, SIGUSR1);
+ LOG("Sent SIGUSR1");
+ if (!childDone.wait()) {
+ FAIL("Timed out waiting for child to finish dlopen()/dlclose() operations");
+ }
+ if (launchSuspended) {
+ if ( !sawMainExecutable ) {
+ FAIL("Did not get load notification of main executable");
+ }
+ if ( !gotMainNotice ) {
+ FAIL("Did not get notification of main()");
+ }
+ if ( gotMainNoticeBeforeAllInitialDylibs ) {
+ FAIL("Notification of main() arrived before all initial dylibs");
+ }
+ if ( gotFooNoticeBeforeMain ) {
+ FAIL("Notification of main() arrived after libfoo load notice");
+ }
+ if ( !sawlibSystem ) {
+ FAIL("Did not get load notification of libSystem");
+ }
+ }
+ kill(pid, SIGTERM);
+ LOG("Sent SIGTERM");
+ if (!childExitNotification.wait()) {
+ FAIL("Timed out waiting for child exit notification via _dyld_process_info_notify");
+ }
+ if ( disconnectEarly ) {
+ if ( libFooLoadCount != 1 ) {
+ FAIL("Got %d load notifications about libFoo instead of 1", libFooLoadCount);
+ }
+ if ( libFooUnloadCount != 0 ) {
+ FAIL("Got %d unload notifications about libFoo instead of 1", libFooUnloadCount);
+ }
+ } else {
+ if ( libFooLoadCount != 3 ) {
+ FAIL("Got %d load notifications about libFoo instead of 3", libFooLoadCount);
+ }
+ if ( libFooUnloadCount != 3 ) {
+ FAIL("Got %d unload notifications about libFoo instead of 3", libFooUnloadCount);
+ }
+ }
+ if (!childExit.wait()) {
+ FAIL("Timed out waiting for child cleanup");
+ }
+
+ // Tear down
+ dispatch_source_cancel(usr1SignalSource);
+ dispatch_source_cancel(usr2SignalSource);
+ if (!disconnectEarly) {
+ _dyld_process_info_notify_release(handle);
+ }
+}
+
+static void testSelfAttach(void) {
+ __block OneShotSemaphore teardownSempahore("self test teardownSempahore");
+ __block bool dylibLoadNotified = false;
+ kern_return_t kr = KERN_SUCCESS;
+ dispatch_queue_t queue = dispatch_queue_create("com.apple.dyld.test.dyld_process_info.self-attach", NULL);
+ dyld_process_info_notify handle = _dyld_process_info_notify(mach_task_self(), queue,
+ ^(bool unload, uint64_t timestamp, uint64_t machHeader, const uuid_t uuid, const char* path) {
+ if ( strstr(path, "/libfoo.dylib") != NULL ) {
+ dylibLoadNotified = true;
+ }
+ },
+ ^{ teardownSempahore.signal(); },
+ &kr);
+ if ( handle == NULL ) {
+ LOG("_dyld_process_info_notify() returned NULL, result=%d", kr);
+ }
+ void* h = dlopen(RUN_DIR "/libfoo.dylib", 0);
+ dlclose(h);
+ if (!dylibLoadNotified) {
+ FAIL("testSelfAttach");
+ }
+ _dyld_process_info_notify_release(handle);
+ teardownSempahore.wait();
+
+ // Get the all image info
+ task_dyld_info_data_t taskDyldInfo;
+ mach_msg_type_number_t taskDyldInfoCount = TASK_DYLD_INFO_COUNT;
+ if (task_info(mach_task_self(), TASK_DYLD_INFO, (task_info_t)&taskDyldInfo, &taskDyldInfoCount) != KERN_SUCCESS) {
+ FAIL("Could not find all image info");
+ }
+ dyld_all_image_infos* infos = (dyld_all_image_infos*)taskDyldInfo.all_image_info_addr;
+
+ // Find a slot for the right
+ uint8_t notifySlot;
+ for (uint8_t notifySlot = 0; notifySlot < DYLD_MAX_PROCESS_INFO_NOTIFY_COUNT; ++notifySlot) {
+ if (infos->notifyPorts[notifySlot] != 0) {
+ FAIL("Port array entry %u not cleaned up, expected 0, got %u", notifySlot, infos->notifyPorts[notifySlot]);
+ }
+ }
+}
+
+int main(int argc, const char* argv[], const char* envp[], const char* apple[]) {
+ // test 1) attempt to monitor the monitoring process
+ testSelfAttach();
+ // test 2) launch test program suspended and wait for it to run to completion
+ launchTest(true, false);
+ // test 3) launch test program in unsuspended and wait for it to run to completion
+ launchTest(false, false);
+ // test 4) launch test program suspended and disconnect from it after the first dlopen() in target.exe
+ launchTest(true, true);
+ // test 5) launch test program unsuspended and disconnect from it after the first dlopen() in target.exe
+ launchTest(false, true);
+
+ PASS("Success");
+}
projects / apple / dyld.git / commitdiff
