system/utest/core/process/process.cpp - zircon - Git at Google

 // Copyright 2016 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <assert.h>

 #include <zircon/process.h>
 #include <zircon/syscalls.h>
 #include <zircon/syscalls/object.h>
 #include <zircon/types.h>

 #include <mini-process/mini-process.h>

 #include <unittest/unittest.h>

 namespace {

 const zx_time_t kTimeoutNs = ZX_MSEC(250);

 bool mini_process_sanity() {
     BEGIN_TEST;

     zx_handle_t proc;
     zx_handle_t thread;
     zx_handle_t vmar;

     ASSERT_EQ(zx_process_create(zx_job_default(), "mini-p", 3u, 0, &proc, &vmar), ZX_OK);
     ASSERT_EQ(zx_thread_create(proc, "mini-p", 2u, 0u, &thread), ZX_OK);

     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

     zx_handle_t cmd_channel;
     EXPECT_EQ(start_mini_process_etc(proc, thread, vmar, event, &cmd_channel), ZX_OK);

     EXPECT_EQ(mini_process_cmd(cmd_channel, MINIP_CMD_ECHO_MSG, nullptr), ZX_OK);

     zx_handle_t oev;
     EXPECT_EQ(mini_process_cmd(cmd_channel, MINIP_CMD_CREATE_EVENT, &oev), ZX_OK);

     EXPECT_EQ(mini_process_cmd(cmd_channel, MINIP_CMD_EXIT_NORMAL, nullptr), ZX_ERR_PEER_CLOSED);

     zx_handle_close(thread);
     zx_handle_close(proc);
     zx_handle_close(vmar);
     END_TEST;
 }

 bool process_start_fail() {
     BEGIN_TEST;

     zx_handle_t event1, event2;
     zx_handle_t process;
     zx_handle_t thread;

     ASSERT_EQ(zx_event_create(0u, &event1), ZX_OK);
     ASSERT_EQ(zx_event_create(0u, &event2), ZX_OK);

     ASSERT_EQ(start_mini_process(zx_job_default(), event1, &process, &thread), ZX_OK);

     zx_handle_t other_thread;
     ASSERT_EQ(zx_thread_create(process, "test", 4u, 0, &other_thread), ZX_OK);

     // Test that calling process_start() again for an existing process fails in a
     // reasonable way. Also test that the transfered object is back into this process.
     EXPECT_EQ(zx_process_start(process, other_thread, 0, 0, event2, 0), ZX_ERR_BAD_STATE);
     EXPECT_EQ(zx_object_signal(event2, 0u, ZX_EVENT_SIGNALED), ZX_OK);

     zx_handle_close(event2);
     zx_handle_close(process);
     zx_handle_close(thread);
     zx_handle_close(other_thread);
     END_TEST;
 }

 bool kill_process_via_thread_close() {
     BEGIN_TEST;

     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

     zx_handle_t process;
     zx_handle_t thread;
     ASSERT_EQ(start_mini_process(zx_job_default(), event, &process, &thread), ZX_OK);

     // closing the only thread handle should cause the process to terminate.
     EXPECT_EQ(zx_handle_close(thread), ZX_OK);

     zx_signals_t signals;
     EXPECT_EQ(zx_object_wait_one(
         process, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     EXPECT_EQ(signals, ZX_TASK_TERMINATED | ZX_SIGNAL_LAST_HANDLE);

     EXPECT_EQ(zx_handle_close(process), ZX_OK);
     END_TEST;
 }

 bool kill_process_via_process_close() {
     BEGIN_TEST;

     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

     zx_handle_t process;
     zx_handle_t thread;
     ASSERT_EQ(start_mini_process(zx_job_default(), event, &process, &thread), ZX_OK);

     // closing the only process handle should cause the process to terminate.
     EXPECT_EQ(zx_handle_close(process), ZX_OK);

     zx_signals_t signals;
     EXPECT_EQ(zx_object_wait_one(
         thread, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     EXPECT_EQ(signals, ZX_TASK_TERMINATED | ZX_SIGNAL_LAST_HANDLE);

     EXPECT_EQ(zx_handle_close(thread), ZX_OK);
     END_TEST;
 }

 bool kill_process_via_thread_kill() {
     BEGIN_TEST;

     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

     zx_handle_t process;
     zx_handle_t thread;
     ASSERT_EQ(start_mini_process(zx_job_default(), event, &process, &thread), ZX_OK);

     // Killing the only thread should cause the process to terminate.
     EXPECT_EQ(zx_task_kill(thread), ZX_OK);

     zx_signals_t signals;
     EXPECT_EQ(zx_object_wait_one(
         process, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     EXPECT_EQ(signals, ZX_TASK_TERMINATED | ZX_SIGNAL_LAST_HANDLE);

     EXPECT_EQ(zx_handle_close(process), ZX_OK);
     EXPECT_EQ(zx_handle_close(thread), ZX_OK);
     END_TEST;
 }

 bool kill_process_via_vmar_destroy() {
     BEGIN_TEST;

     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

     zx_handle_t proc;
     zx_handle_t vmar;
     ASSERT_EQ(zx_process_create(zx_job_default(), "ttp", 3u, 0, &proc, &vmar), ZX_OK);

     zx_handle_t thread;
     ASSERT_EQ(zx_thread_create(proc, "th", 2u, 0u, &thread), ZX_OK);

     // Make the process busy-wait rather than using a vDSO call because
     // if it maps in the vDSO then zx_vmar_destroy is prohibited.
     EXPECT_EQ(start_mini_process_etc(proc, thread, vmar, event, nullptr),
               ZX_OK);

     // Destroying the root VMAR should cause the process to terminate.
     REGISTER_CRASH(proc);
     EXPECT_EQ(zx_vmar_destroy(vmar), ZX_OK);

     zx_signals_t signals;
     EXPECT_EQ(zx_object_wait_one(
         proc, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     signals &= ZX_TASK_TERMINATED;
     EXPECT_EQ(signals, ZX_TASK_TERMINATED);

     EXPECT_EQ(zx_handle_close(proc), ZX_OK);
     EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
     EXPECT_EQ(zx_handle_close(thread), ZX_OK);
     END_TEST;
 }

 bool kill_process_handle_cycle() {
     BEGIN_TEST;

     zx_handle_t proc1, proc2;
     zx_handle_t vmar1, vmar2;

     ASSERT_EQ(zx_process_create(zx_job_default(), "ttp1", 4u, 0u, &proc1, &vmar1), ZX_OK);
     ASSERT_EQ(zx_process_create(zx_job_default(), "ttp2", 4u, 0u, &proc2, &vmar2), ZX_OK);

     zx_handle_t thread1, thread2;

     ASSERT_EQ(zx_thread_create(proc1, "th1", 3u, 0u, &thread1), ZX_OK);
     ASSERT_EQ(zx_thread_create(proc2, "th2", 3u, 0u, &thread2), ZX_OK);

     zx_handle_t dup1, dup2;

     EXPECT_EQ(zx_handle_duplicate(proc1, ZX_RIGHT_SAME_RIGHTS, &dup1), ZX_OK);
     EXPECT_EQ(zx_handle_duplicate(proc2, ZX_RIGHT_SAME_RIGHTS, &dup2), ZX_OK);

     zx_handle_t minip_chn[2];

     EXPECT_EQ(start_mini_process_etc(proc1, thread1, vmar1, dup2, &minip_chn[0]),
               ZX_OK);
     EXPECT_EQ(start_mini_process_etc(proc2, thread2, vmar2, dup1, &minip_chn[1]),
               ZX_OK);

     EXPECT_EQ(zx_handle_close(vmar2), ZX_OK);
     EXPECT_EQ(zx_handle_close(vmar1), ZX_OK);

     EXPECT_EQ(zx_handle_close(proc1), ZX_OK);
     EXPECT_EQ(zx_handle_close(proc2), ZX_OK);

     // At this point each processes have each other last process handle.  Make sure
     // they are running.

     zx_signals_t signals;
     EXPECT_EQ(zx_object_wait_one(
         thread1, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

     EXPECT_EQ(zx_object_wait_one(
         thread2, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

     EXPECT_EQ(zx_handle_close(thread1), ZX_OK);

     // Closing thread1 should cause process 1 to exit which should cause process 2 to
     // exit which we test by waiting on the second process thread handle.

     EXPECT_EQ(zx_object_wait_one(
         thread2, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     EXPECT_EQ(signals, ZX_TASK_TERMINATED | ZX_SIGNAL_LAST_HANDLE);

     EXPECT_EQ(zx_handle_close(thread2), ZX_OK);

     END_TEST;
 }

 static zx_status_t dup_send_handle(zx_handle_t channel, zx_handle_t handle) {
     zx_handle_t dup;
     zx_status_t st = zx_handle_duplicate(handle, ZX_RIGHT_SAME_RIGHTS, &dup);
     if (st < 0)
         return st;
     return zx_channel_write(channel, 0u, nullptr, 0u, &dup, 1u);
 }

 bool kill_channel_handle_cycle() {
     BEGIN_TEST;

     zx_handle_t chan[2] = {ZX_HANDLE_INVALID, ZX_HANDLE_INVALID};
     ASSERT_EQ(zx_channel_create(0u, &chan[0], &chan[1]), ZX_OK);

     zx_handle_t proc1, proc2;
     zx_handle_t vmar1, vmar2;

     zx_handle_t job_child;
     ASSERT_EQ(zx_job_create(zx_job_default(), 0u, &job_child), ZX_OK);

     ASSERT_EQ(zx_process_create(job_child, "ttp1", 4u, 0u, &proc1, &vmar1), ZX_OK);
     ASSERT_EQ(zx_process_create(job_child, "ttp2", 4u, 0u, &proc2, &vmar2), ZX_OK);

     zx_handle_t thread1, thread2;

     ASSERT_EQ(zx_thread_create(proc1, "th1", 3u, 0u, &thread1), ZX_OK);
     ASSERT_EQ(zx_thread_create(proc2, "th2", 3u, 0u, &thread2), ZX_OK);

     // Now we stuff duplicated process and thread handles into each side of the channel.

     EXPECT_EQ(dup_send_handle(chan[0], proc2), ZX_OK);
     EXPECT_EQ(dup_send_handle(chan[0], thread2), ZX_OK);

     EXPECT_EQ(dup_send_handle(chan[1], proc1), ZX_OK);
     EXPECT_EQ(dup_send_handle(chan[1], thread1), ZX_OK);

     // The process start with each one side of the channel. We don't have access to the
     // channel anymore.

     zx_handle_t minip_chn[2];

     EXPECT_EQ(start_mini_process_etc(proc1, thread1, vmar1, chan[0], &minip_chn[0]),
               ZX_OK);
     EXPECT_EQ(start_mini_process_etc(proc2, thread2, vmar2, chan[1], &minip_chn[1]),
               ZX_OK);

     EXPECT_EQ(zx_handle_close(vmar2), ZX_OK);
     EXPECT_EQ(zx_handle_close(vmar1), ZX_OK);

     EXPECT_EQ(zx_handle_close(proc1), ZX_OK);
     EXPECT_EQ(zx_handle_close(proc2), ZX_OK);

     // Make (relatively) certain the processes are alive.

     zx_signals_t signals;
     EXPECT_EQ(zx_object_wait_one(
         thread1, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

     EXPECT_EQ(zx_object_wait_one(
         thread2, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

     // At this point the two processes have each other thread/process handles. For example
     // if we close the thread handles, unlike the previous test, the processes will
     // still be alive.

     EXPECT_EQ(zx_handle_close(thread1), ZX_OK);

     EXPECT_EQ(zx_object_wait_one(
         thread2, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

     // The only way out of this situation is to use the job handle.

     EXPECT_EQ(zx_task_kill(job_child), ZX_OK);

     EXPECT_EQ(zx_object_wait_one(
         thread2, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     signals &= ZX_TASK_TERMINATED;
     EXPECT_EQ(signals, ZX_TASK_TERMINATED);

     EXPECT_EQ(zx_handle_close(thread2), ZX_OK);
     EXPECT_EQ(zx_handle_close(job_child), ZX_OK);

     END_TEST;
 }

 // Tests that |zx_info_process_t| fields reflect the current state of a process.
 bool info_reflects_process_state() {
     BEGIN_TEST;

     // Create a process with one thread.
     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

     zx_handle_t job_child;
     ASSERT_EQ(zx_job_create(zx_job_default(), 0u, &job_child), ZX_OK);

     zx_handle_t proc;
     zx_handle_t vmar;
     ASSERT_EQ(zx_process_create(job_child, "ttp", 4u, 0u, &proc, &vmar), ZX_OK);

     zx_handle_t thread;
     ASSERT_EQ(zx_thread_create(proc, "th", 3u, 0u, &thread), ZX_OK);

     zx_info_process_t info;
     ASSERT_EQ(zx_object_get_info(
             proc, ZX_INFO_PROCESS, &info, sizeof(info), NULL, NULL), ZX_OK);
     EXPECT_FALSE(info.started, "process should not appear as started");
     EXPECT_FALSE(info.exited, "process should not appear as exited");

     zx_handle_t minip_chn;
     // Start the process and make (relatively) certain it's alive.
     ASSERT_EQ(start_mini_process_etc(proc, thread, vmar, event, &minip_chn),
               ZX_OK);
     zx_signals_t signals;
     ASSERT_EQ(zx_object_wait_one(
         proc, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

     ASSERT_EQ(zx_object_get_info(
             proc, ZX_INFO_PROCESS, &info, sizeof(info), NULL, NULL), ZX_OK);
     EXPECT_TRUE(info.started, "process should appear as started");
     EXPECT_FALSE(info.exited, "process should not appear as exited");

     // Kill the process and wait for it to terminate.
     ASSERT_EQ(zx_task_kill(proc), ZX_OK);
     ASSERT_EQ(zx_object_wait_one(
         proc, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
     ASSERT_EQ(signals, ZX_TASK_TERMINATED | ZX_SIGNAL_LAST_HANDLE);

     ASSERT_EQ(zx_object_get_info(
             proc, ZX_INFO_PROCESS, &info, sizeof(info), NULL, NULL), ZX_OK);
     EXPECT_TRUE(info.started, "process should appear as started");
     EXPECT_TRUE(info.exited, "process should appear as exited");
     EXPECT_NE(info.return_code, 0, "killed process should have non-zero return code");

     END_TEST;
 }

 } // namespace

 BEGIN_TEST_CASE(process_tests)
 RUN_TEST(mini_process_sanity);
 RUN_TEST(process_start_fail);
 RUN_TEST(kill_process_via_thread_close);
 RUN_TEST(kill_process_via_process_close);
 RUN_TEST(kill_process_via_thread_kill);
 RUN_TEST_ENABLE_CRASH_HANDLER(kill_process_via_vmar_destroy);
 RUN_TEST(kill_process_handle_cycle);
 RUN_TEST(kill_channel_handle_cycle);
 RUN_TEST(info_reflects_process_state);
 END_TEST_CASE(process_tests)

 #ifndef BUILD_COMBINED_TESTS
 int main(int argc, char** argv) {
     bool success = unittest_run_all_tests(argc, argv);
     return success ? 0 : -1;
 }
 #endif
	// Copyright 2016 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <assert.h>

	#include <zircon/process.h>
	#include <zircon/syscalls.h>
	#include <zircon/syscalls/object.h>
	#include <zircon/types.h>

	#include <mini-process/mini-process.h>

	#include <unittest/unittest.h>

	namespace {

	const zx_time_t kTimeoutNs = ZX_MSEC(250);

	bool mini_process_sanity() {
	BEGIN_TEST;

	zx_handle_t proc;
	zx_handle_t thread;
	zx_handle_t vmar;

	ASSERT_EQ(zx_process_create(zx_job_default(), "mini-p", 3u, 0, &proc, &vmar), ZX_OK);
	ASSERT_EQ(zx_thread_create(proc, "mini-p", 2u, 0u, &thread), ZX_OK);

	zx_handle_t event;
	ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

	zx_handle_t cmd_channel;
	EXPECT_EQ(start_mini_process_etc(proc, thread, vmar, event, &cmd_channel), ZX_OK);

	EXPECT_EQ(mini_process_cmd(cmd_channel, MINIP_CMD_ECHO_MSG, nullptr), ZX_OK);

	zx_handle_t oev;
	EXPECT_EQ(mini_process_cmd(cmd_channel, MINIP_CMD_CREATE_EVENT, &oev), ZX_OK);

	EXPECT_EQ(mini_process_cmd(cmd_channel, MINIP_CMD_EXIT_NORMAL, nullptr), ZX_ERR_PEER_CLOSED);

	zx_handle_close(thread);
	zx_handle_close(proc);
	zx_handle_close(vmar);
	END_TEST;
	}

	bool process_start_fail() {
	BEGIN_TEST;

	zx_handle_t event1, event2;
	zx_handle_t process;
	zx_handle_t thread;

	ASSERT_EQ(zx_event_create(0u, &event1), ZX_OK);
	ASSERT_EQ(zx_event_create(0u, &event2), ZX_OK);

	ASSERT_EQ(start_mini_process(zx_job_default(), event1, &process, &thread), ZX_OK);

	zx_handle_t other_thread;
	ASSERT_EQ(zx_thread_create(process, "test", 4u, 0, &other_thread), ZX_OK);

	// Test that calling process_start() again for an existing process fails in a
	// reasonable way. Also test that the transfered object is back into this process.
	EXPECT_EQ(zx_process_start(process, other_thread, 0, 0, event2, 0), ZX_ERR_BAD_STATE);
	EXPECT_EQ(zx_object_signal(event2, 0u, ZX_EVENT_SIGNALED), ZX_OK);

	zx_handle_close(event2);
	zx_handle_close(process);
	zx_handle_close(thread);
	zx_handle_close(other_thread);
	END_TEST;
	}

	bool kill_process_via_thread_close() {
	BEGIN_TEST;

	zx_handle_t event;
	ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

	zx_handle_t process;
	zx_handle_t thread;
	ASSERT_EQ(start_mini_process(zx_job_default(), event, &process, &thread), ZX_OK);

	// closing the only thread handle should cause the process to terminate.
	EXPECT_EQ(zx_handle_close(thread), ZX_OK);

	zx_signals_t signals;
	EXPECT_EQ(zx_object_wait_one(
	process, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	EXPECT_EQ(signals, ZX_TASK_TERMINATED \| ZX_SIGNAL_LAST_HANDLE);

	EXPECT_EQ(zx_handle_close(process), ZX_OK);
	END_TEST;
	}

	bool kill_process_via_process_close() {
	BEGIN_TEST;

	zx_handle_t event;
	ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

	zx_handle_t process;
	zx_handle_t thread;
	ASSERT_EQ(start_mini_process(zx_job_default(), event, &process, &thread), ZX_OK);

	// closing the only process handle should cause the process to terminate.
	EXPECT_EQ(zx_handle_close(process), ZX_OK);

	zx_signals_t signals;
	EXPECT_EQ(zx_object_wait_one(
	thread, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	EXPECT_EQ(signals, ZX_TASK_TERMINATED \| ZX_SIGNAL_LAST_HANDLE);

	EXPECT_EQ(zx_handle_close(thread), ZX_OK);
	END_TEST;
	}

	bool kill_process_via_thread_kill() {
	BEGIN_TEST;

	zx_handle_t event;
	ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

	zx_handle_t process;
	zx_handle_t thread;
	ASSERT_EQ(start_mini_process(zx_job_default(), event, &process, &thread), ZX_OK);

	// Killing the only thread should cause the process to terminate.
	EXPECT_EQ(zx_task_kill(thread), ZX_OK);

	zx_signals_t signals;
	EXPECT_EQ(zx_object_wait_one(
	process, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	EXPECT_EQ(signals, ZX_TASK_TERMINATED \| ZX_SIGNAL_LAST_HANDLE);

	EXPECT_EQ(zx_handle_close(process), ZX_OK);
	EXPECT_EQ(zx_handle_close(thread), ZX_OK);
	END_TEST;
	}

	bool kill_process_via_vmar_destroy() {
	BEGIN_TEST;

	zx_handle_t event;
	ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

	zx_handle_t proc;
	zx_handle_t vmar;
	ASSERT_EQ(zx_process_create(zx_job_default(), "ttp", 3u, 0, &proc, &vmar), ZX_OK);

	zx_handle_t thread;
	ASSERT_EQ(zx_thread_create(proc, "th", 2u, 0u, &thread), ZX_OK);

	// Make the process busy-wait rather than using a vDSO call because
	// if it maps in the vDSO then zx_vmar_destroy is prohibited.
	EXPECT_EQ(start_mini_process_etc(proc, thread, vmar, event, nullptr),
	ZX_OK);

	// Destroying the root VMAR should cause the process to terminate.
	REGISTER_CRASH(proc);
	EXPECT_EQ(zx_vmar_destroy(vmar), ZX_OK);

	zx_signals_t signals;
	EXPECT_EQ(zx_object_wait_one(
	proc, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	signals &= ZX_TASK_TERMINATED;
	EXPECT_EQ(signals, ZX_TASK_TERMINATED);

	EXPECT_EQ(zx_handle_close(proc), ZX_OK);
	EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
	EXPECT_EQ(zx_handle_close(thread), ZX_OK);
	END_TEST;
	}

	bool kill_process_handle_cycle() {
	BEGIN_TEST;

	zx_handle_t proc1, proc2;
	zx_handle_t vmar1, vmar2;

	ASSERT_EQ(zx_process_create(zx_job_default(), "ttp1", 4u, 0u, &proc1, &vmar1), ZX_OK);
	ASSERT_EQ(zx_process_create(zx_job_default(), "ttp2", 4u, 0u, &proc2, &vmar2), ZX_OK);

	zx_handle_t thread1, thread2;

	ASSERT_EQ(zx_thread_create(proc1, "th1", 3u, 0u, &thread1), ZX_OK);
	ASSERT_EQ(zx_thread_create(proc2, "th2", 3u, 0u, &thread2), ZX_OK);

	zx_handle_t dup1, dup2;

	EXPECT_EQ(zx_handle_duplicate(proc1, ZX_RIGHT_SAME_RIGHTS, &dup1), ZX_OK);
	EXPECT_EQ(zx_handle_duplicate(proc2, ZX_RIGHT_SAME_RIGHTS, &dup2), ZX_OK);

	zx_handle_t minip_chn[2];

	EXPECT_EQ(start_mini_process_etc(proc1, thread1, vmar1, dup2, &minip_chn[0]),
	ZX_OK);
	EXPECT_EQ(start_mini_process_etc(proc2, thread2, vmar2, dup1, &minip_chn[1]),
	ZX_OK);

	EXPECT_EQ(zx_handle_close(vmar2), ZX_OK);
	EXPECT_EQ(zx_handle_close(vmar1), ZX_OK);

	EXPECT_EQ(zx_handle_close(proc1), ZX_OK);
	EXPECT_EQ(zx_handle_close(proc2), ZX_OK);

	// At this point each processes have each other last process handle. Make sure
	// they are running.

	zx_signals_t signals;
	EXPECT_EQ(zx_object_wait_one(
	thread1, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

	EXPECT_EQ(zx_object_wait_one(
	thread2, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

	EXPECT_EQ(zx_handle_close(thread1), ZX_OK);

	// Closing thread1 should cause process 1 to exit which should cause process 2 to
	// exit which we test by waiting on the second process thread handle.

	EXPECT_EQ(zx_object_wait_one(
	thread2, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	EXPECT_EQ(signals, ZX_TASK_TERMINATED \| ZX_SIGNAL_LAST_HANDLE);

	EXPECT_EQ(zx_handle_close(thread2), ZX_OK);

	END_TEST;
	}

	static zx_status_t dup_send_handle(zx_handle_t channel, zx_handle_t handle) {
	zx_handle_t dup;
	zx_status_t st = zx_handle_duplicate(handle, ZX_RIGHT_SAME_RIGHTS, &dup);
	if (st < 0)
	return st;
	return zx_channel_write(channel, 0u, nullptr, 0u, &dup, 1u);
	}

	bool kill_channel_handle_cycle() {
	BEGIN_TEST;

	zx_handle_t chan[2] = {ZX_HANDLE_INVALID, ZX_HANDLE_INVALID};
	ASSERT_EQ(zx_channel_create(0u, &chan[0], &chan[1]), ZX_OK);

	zx_handle_t proc1, proc2;
	zx_handle_t vmar1, vmar2;

	zx_handle_t job_child;
	ASSERT_EQ(zx_job_create(zx_job_default(), 0u, &job_child), ZX_OK);

	ASSERT_EQ(zx_process_create(job_child, "ttp1", 4u, 0u, &proc1, &vmar1), ZX_OK);
	ASSERT_EQ(zx_process_create(job_child, "ttp2", 4u, 0u, &proc2, &vmar2), ZX_OK);

	zx_handle_t thread1, thread2;

	ASSERT_EQ(zx_thread_create(proc1, "th1", 3u, 0u, &thread1), ZX_OK);
	ASSERT_EQ(zx_thread_create(proc2, "th2", 3u, 0u, &thread2), ZX_OK);

	// Now we stuff duplicated process and thread handles into each side of the channel.

	EXPECT_EQ(dup_send_handle(chan[0], proc2), ZX_OK);
	EXPECT_EQ(dup_send_handle(chan[0], thread2), ZX_OK);

	EXPECT_EQ(dup_send_handle(chan[1], proc1), ZX_OK);
	EXPECT_EQ(dup_send_handle(chan[1], thread1), ZX_OK);

	// The process start with each one side of the channel. We don't have access to the
	// channel anymore.

	zx_handle_t minip_chn[2];

	EXPECT_EQ(start_mini_process_etc(proc1, thread1, vmar1, chan[0], &minip_chn[0]),
	ZX_OK);
	EXPECT_EQ(start_mini_process_etc(proc2, thread2, vmar2, chan[1], &minip_chn[1]),
	ZX_OK);

	EXPECT_EQ(zx_handle_close(vmar2), ZX_OK);
	EXPECT_EQ(zx_handle_close(vmar1), ZX_OK);

	EXPECT_EQ(zx_handle_close(proc1), ZX_OK);
	EXPECT_EQ(zx_handle_close(proc2), ZX_OK);

	// Make (relatively) certain the processes are alive.

	zx_signals_t signals;
	EXPECT_EQ(zx_object_wait_one(
	thread1, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

	EXPECT_EQ(zx_object_wait_one(
	thread2, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

	// At this point the two processes have each other thread/process handles. For example
	// if we close the thread handles, unlike the previous test, the processes will
	// still be alive.

	EXPECT_EQ(zx_handle_close(thread1), ZX_OK);

	EXPECT_EQ(zx_object_wait_one(
	thread2, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

	// The only way out of this situation is to use the job handle.

	EXPECT_EQ(zx_task_kill(job_child), ZX_OK);

	EXPECT_EQ(zx_object_wait_one(
	thread2, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	signals &= ZX_TASK_TERMINATED;
	EXPECT_EQ(signals, ZX_TASK_TERMINATED);

	EXPECT_EQ(zx_handle_close(thread2), ZX_OK);
	EXPECT_EQ(zx_handle_close(job_child), ZX_OK);

	END_TEST;
	}

	// Tests that \|zx_info_process_t\| fields reflect the current state of a process.
	bool info_reflects_process_state() {
	BEGIN_TEST;

	// Create a process with one thread.
	zx_handle_t event;
	ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);

	zx_handle_t job_child;
	ASSERT_EQ(zx_job_create(zx_job_default(), 0u, &job_child), ZX_OK);

	zx_handle_t proc;
	zx_handle_t vmar;
	ASSERT_EQ(zx_process_create(job_child, "ttp", 4u, 0u, &proc, &vmar), ZX_OK);

	zx_handle_t thread;
	ASSERT_EQ(zx_thread_create(proc, "th", 3u, 0u, &thread), ZX_OK);

	zx_info_process_t info;
	ASSERT_EQ(zx_object_get_info(
	proc, ZX_INFO_PROCESS, &info, sizeof(info), NULL, NULL), ZX_OK);
	EXPECT_FALSE(info.started, "process should not appear as started");
	EXPECT_FALSE(info.exited, "process should not appear as exited");

	zx_handle_t minip_chn;
	// Start the process and make (relatively) certain it's alive.
	ASSERT_EQ(start_mini_process_etc(proc, thread, vmar, event, &minip_chn),
	ZX_OK);
	zx_signals_t signals;
	ASSERT_EQ(zx_object_wait_one(
	proc, ZX_TASK_TERMINATED, zx_deadline_after(kTimeoutNs), &signals), ZX_ERR_TIMED_OUT);

	ASSERT_EQ(zx_object_get_info(
	proc, ZX_INFO_PROCESS, &info, sizeof(info), NULL, NULL), ZX_OK);
	EXPECT_TRUE(info.started, "process should appear as started");
	EXPECT_FALSE(info.exited, "process should not appear as exited");

	// Kill the process and wait for it to terminate.
	ASSERT_EQ(zx_task_kill(proc), ZX_OK);
	ASSERT_EQ(zx_object_wait_one(
	proc, ZX_TASK_TERMINATED, ZX_TIME_INFINITE, &signals), ZX_OK);
	ASSERT_EQ(signals, ZX_TASK_TERMINATED \| ZX_SIGNAL_LAST_HANDLE);

	ASSERT_EQ(zx_object_get_info(
	proc, ZX_INFO_PROCESS, &info, sizeof(info), NULL, NULL), ZX_OK);
	EXPECT_TRUE(info.started, "process should appear as started");
	EXPECT_TRUE(info.exited, "process should appear as exited");
	EXPECT_NE(info.return_code, 0, "killed process should have non-zero return code");

	END_TEST;
	}

	} // namespace

	BEGIN_TEST_CASE(process_tests)
	RUN_TEST(mini_process_sanity);
	RUN_TEST(process_start_fail);
	RUN_TEST(kill_process_via_thread_close);
	RUN_TEST(kill_process_via_process_close);
	RUN_TEST(kill_process_via_thread_kill);
	RUN_TEST_ENABLE_CRASH_HANDLER(kill_process_via_vmar_destroy);
	RUN_TEST(kill_process_handle_cycle);
	RUN_TEST(kill_channel_handle_cycle);
	RUN_TEST(info_reflects_process_state);
	END_TEST_CASE(process_tests)

	#ifndef BUILD_COMBINED_TESTS
	int main(int argc, char** argv) {
	bool success = unittest_run_all_tests(argc, argv);
	return success ? 0 : -1;
	}
	#endif