--- /dev/null
+
+// 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.cpp -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_TIMEOUT: 2400
+// XFAIL: $SUDO ./dyld_process_info_notify.exe $RUN_DIR/target.exe
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <unistd.h>
+#include <signal.h>
+#include <spawn.h>
+#include <errno.h>
+#include <mach/mach.h>
+#include <mach/machine.h>
+#include <mach-o/dyld_process_info.h>
+#include <dispatch/dispatch.h>
+#include <Availability.h>
+
+#include "test_support.h"
+
+extern char** environ;
+
+void launchTest(bool launchSuspended, bool disconnectEarly)
+{
+ LOG("launchTest (%s)", launchSuspended ? "suspended" : "unsuspened");
+ dispatch_queue_t queue = dispatch_queue_create("com.apple.dyld.test.dyld_process_info", NULL);
+ // We do this instead of using a dispatch_semaphore to prevent priority inversions
+ dispatch_block_t taskDone = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS, ^{});
+ dispatch_block_t taskStarted = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS, ^{});
+ pid_t pid;
+
+ task_t task;
+ char subTestNameBuffer[256];
+ char *subTestName = &subTestNameBuffer[0];
+ __block bool sawMainExecutable = false;
+ __block bool sawlibSystem = false;
+ __block bool gotTerminationNotice = false;
+ __block bool gotEarlyNotice = 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(RUN_DIR "/target.exe");
+ const char* env[] = { "TEST_OUTPUT=None", NULL};
+ process.set_env(env);
+ process.set_launch_suspended(launchSuspended);
+ if (!launchSuspended) {
+ const char* args[] = {"suspend-in-main", NULL};
+ _process_config_set_args(process, args);
+ _process_config_set_stderr_handler(process, ^(int fd) {
+ dispatch_semaphore_signal(taskStarted);
+ });
+ _process_config_set_exit_handler(process, ^(pid_t pid) {
+ LOG("DIED (pid: %d)", pid);
+ });
+ }
+ pid = process.launch(queue);
+
+ if (!launchSuspended && dispatch_semaphore_wait(taskStarted, dispatch_time(DISPATCH_TIME_NOW, 5LL * NSEC_PER_SEC)) != 0) {
+ FAIL("Child launch timeout");
+ }
+#if 1
+ snprintf(&subTestNameBuffer[0], 256, "%s (arch: %d)", launchSuspended ? "launch suspended" : "launch suspend-in-main", currentArch);
+
+ if ( task_for_pid(mach_task_self(), pid, &task) != KERN_SUCCESS ) {
+ FAIL("task_for_pid()");
+ }
+
+ 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) {
+ 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 ) {
+ LOG("EARLY DISCONNECT");
+ gotEarlyNotice = true;
+ dispatch_semaphore_signal(taskDone);
+ }
+ }
+ },
+ ^{
+ LOG("TERMINATED (pid: %d)", pid);
+ gotTerminationNotice = true;
+ dispatch_semaphore_signal(taskDone);
+ },
+ &kr);
+ ++count;
+ if ( handle == NULL )
+ LOG("_dyld_process_info_notify() returned NULL, result=%d, count=%d", kr, count);
+ } while ( (handle == NULL) && (count < 5) );
+
+ if ( handle == NULL ) {
+ FAIL("%s: did not not get handle", subTestName);
+ }
+
+ 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");
+ } else {
+ kill(pid, SIGUSR1);
+ LOG("Sent SIGUSR1");
+ }
+
+ // block waiting for notification that target has exited
+ if (dispatch_semaphore_wait(taskDone, dispatch_time(DISPATCH_TIME_NOW, 10LL * NSEC_PER_SEC)) != 0) {
+ FAIL("%s: did not get exit signal", subTestName);
+ }
+
+// dispatch_release(taskDone);
+// dispatch_release(queue);
+// _dyld_process_info_notify_release(handle);
+
+ // Do not run any tests associated with startup unless the kernel suspended us
+ // before main()
+ if (launchSuspended) {
+ if ( !sawMainExecutable ) {
+ FAIL("%s: did not get load notification of main executable", subTestName);
+ }
+
+ if ( !gotMainNotice ) {
+ FAIL("%s: did not get notification of main()", subTestName);
+ }
+
+ if ( gotMainNoticeBeforeAllInitialDylibs ) {
+ FAIL("%s: notification of main() arrived before all initial dylibs", subTestName);
+ }
+
+ if ( gotFooNoticeBeforeMain ) {
+ FAIL("%s: notification of main() arrived after libfoo load notice", subTestName);
+ }
+
+ if ( !sawlibSystem ) {
+ FAIL("%s: did not get load notification of libSystem", subTestName);
+ }
+ }
+
+ if ( disconnectEarly ) {
+ if ( libFooLoadCount != 1 ) {
+ FAIL("%s: got %d load notifications about libFoo instead of 1", subTestName, libFooLoadCount);
+ }
+ if ( libFooUnloadCount != 0 ) {
+ FAIL("%s: got %d unload notifications about libFoo instead of 1", subTestName, libFooUnloadCount);
+ }
+ }
+ else {
+ if ( libFooLoadCount != 3 ) {
+ FAIL("%s: got %d load notifications about libFoo instead of 3", subTestName, libFooLoadCount);
+ }
+ if ( libFooUnloadCount != 3 ) {
+ FAIL("%s: got %d unload notifications about libFoo instead of 3", subTestName, libFooUnloadCount);
+ }
+ }
+#endif
+}
+
+#if 0
+static void validateMaxNotifies(struct task_and_pid tp)
+{
+ dispatch_queue_t serviceQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
+ dyld_process_info_notify handles[10];
+ // This loop goes through 10 iterations
+ // i = 0..7 Should succeed
+ // i = 8 Should fail, but trigger a release that frees up a slot
+ // i = 9 Should succeed
+ for (int i=0; i < 10; ++i) {
+ kern_return_t kr;
+ handles[i] = _dyld_process_info_notify(tp.task, serviceQueue,
+ ^(bool unload, uint64_t timestamp, uint64_t machHeader, const uuid_t uuid, const char* path) {
+ LOG("unload=%d, 0x%012llX <%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X> %s",
+ unload, machHeader, uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
+ uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14], uuid[15], path);
+ },
+ ^{
+ LOG("target exited");
+ },
+ &kr);
+ if ( handles[i] == NULL ) {
+ if ( i == 8 ) {
+ // expected failure, because only 8 simultaneous connections allowed
+ // release one and try again
+ _dyld_process_info_notify_release(handles[4]);
+ handles[4] = NULL;
+ }
+ else {
+ LOG("_dyld_process_info_notify() returned NULL and kern_result=%d, on count=%d", kr, i);
+ killTest(tp);
+ exit(0);
+ }
+ }
+ }
+ // release all
+ for (int i=0; i < 10; ++i) {
+ if ( handles[i] != NULL ) {
+ _dyld_process_info_notify_release(handles[i]);
+ }
+ }
+ dispatch_release(serviceQueue);
+}
+#endif
+
+static void testSelfAttach(void) {
+ LOG("7");
+ __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);
+ LOG("7.5");
+ 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;
+ }
+ },
+ ^{},
+ &kr);
+ LOG("8");
+ if ( handle == NULL ) {
+ LOG("_dyld_process_info_notify() returned NULL, result=%d", kr);
+ }
+ LOG("8.5");
+ void* h = dlopen(RUN_DIR "/libfoo.dylib", 0);
+ LOG("8.75");
+ dlclose(h);
+ if (!dylibLoadNotified) {
+ FAIL("testSelfAttach");
+ }
+ LOG("9");
+}
+
+int main(int argc, const char* argv[], const char* envp[], const char* apple[]) {
+
+ // test 1) launch test program suspended in same arch as this program
+ launchTest(true, false);
+
+ // test 2) launch test program in same arch as this program where it sleeps itself
+ launchTest(false, false);
+// validateMaxNotifies(child);
+
+ // test 3) launch test program where we disconnect from it after first dlopen
+ launchTest(true, true);
+// monitor("disconnect", child, true, false);
+
+ // test 4) attempt to monitor the monitoring process
+// testSelfAttach();
+ PASS("Success");
+
+}
projects / apple / dyld.git / blobdiff