| // Copyright 2019 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 <gtest/gtest.h> |
| |
| #include "tools/fidlcat/interception_tests/interception_workflow_test.h" |
| |
| namespace fidlcat { |
| |
| // zx_channel_create tests. |
| |
| std::unique_ptr<SystemCallTest> ZxChannelCreate(int64_t result, std::string_view result_name, |
| uint32_t options, zx_handle_t* out0, |
| zx_handle_t* out1) { |
| auto value = std::make_unique<SystemCallTest>("zx_channel_create", result, result_name); |
| value->AddInput(options); |
| value->AddInput(reinterpret_cast<uint64_t>(out0)); |
| value->AddInput(reinterpret_cast<uint64_t>(out1)); |
| return value; |
| } |
| |
| // Checks that we can decode a zx_channel_create syscall. |
| // Also checks that we create the right semantic for the channels. |
| #define CREATE_DISPLAY_TEST_CONTENT(errno, expected) \ |
| zx_handle_t out0 = 0x12345678; \ |
| zx_handle_t out1 = 0x87654321; \ |
| ProcessController controller(this, session(), loop()); \ |
| PerformDisplayTest(&controller, "$plt(zx_channel_create)", \ |
| ZxChannelCreate(errno, #errno, 0, &out0, &out1), expected); \ |
| SyscallDecoderDispatcher* dispatcher = controller.workflow().syscall_decoder_dispatcher(); \ |
| const fidl_codec::semantic::InferredHandleInfo* info0 = \ |
| dispatcher->inference().GetInferredHandleInfo(kFirstPid, out0); \ |
| ASSERT_NE(info0, nullptr); \ |
| ASSERT_EQ(info0->type(), "channel"); \ |
| ASSERT_EQ(info0->fd(), 0); \ |
| const fidl_codec::semantic::InferredHandleInfo* info1 = \ |
| dispatcher->inference().GetInferredHandleInfo(kFirstPid, out1); \ |
| ASSERT_NE(info1, nullptr); \ |
| ASSERT_EQ(info1->type(), "channel"); \ |
| ASSERT_EQ(info1->fd(), 1); \ |
| const fidl_codec::semantic::InferredHandleInfo* info2 = \ |
| dispatcher->inference().GetInferredHandleInfo(kSecondPid, out0); \ |
| ASSERT_NE(info2, nullptr); \ |
| ASSERT_EQ(info2->type(), "channel"); \ |
| ASSERT_EQ(info2->fd(), 2); \ |
| const fidl_codec::semantic::InferredHandleInfo* info3 = \ |
| dispatcher->inference().GetInferredHandleInfo(kSecondPid, out1); \ |
| ASSERT_NE(info3, nullptr); \ |
| ASSERT_EQ(info3->type(), "channel"); \ |
| ASSERT_EQ(info3->fd(), 3); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kFirstPid, out0), out1); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kFirstPid, out1), out0); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kSecondPid, out0), out1); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kSecondPid, out1), out0); |
| |
| #define CREATE_DISPLAY_TEST(name, errno, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { CREATE_DISPLAY_TEST_CONTENT(errno, expected); } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { CREATE_DISPLAY_TEST_CONTENT(errno, expected); } |
| |
| CREATE_DISPLAY_TEST( |
| ZxChannelCreate, ZX_OK, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_create(" |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m (out0: \x1B[32mhandle\x1B[0m = \x1B[31m12345678\x1B[0m, " |
| "out1: \x1B[32mhandle\x1B[0m = \x1B[31m87654321\x1B[0m)\n"); |
| |
| // Checks that we can decode a zx_channel_create syscall with interleaved responses. |
| // Also checks that we create the right semantic for the channels. |
| #define CREATE_INTERLEAVED_DISPLAY_TEST_CONTENT(errno, expected) \ |
| zx_handle_t out0 = 0x12345678; \ |
| zx_handle_t out1 = 0x87654321; \ |
| ProcessController controller(this, session(), loop()); \ |
| PerformInterleavedDisplayTest(&controller, "$plt(zx_channel_create)", \ |
| ZxChannelCreate(errno, #errno, 0, &out0, &out1), expected); \ |
| SyscallDecoderDispatcher* dispatcher = controller.workflow().syscall_decoder_dispatcher(); \ |
| const fidl_codec::semantic::InferredHandleInfo* info0 = \ |
| dispatcher->inference().GetInferredHandleInfo(kFirstPid, out0); \ |
| ASSERT_NE(info0, nullptr); \ |
| ASSERT_EQ(info0->type(), "channel"); \ |
| ASSERT_EQ(info0->fd(), 0); \ |
| const fidl_codec::semantic::InferredHandleInfo* info1 = \ |
| dispatcher->inference().GetInferredHandleInfo(kFirstPid, out1); \ |
| ASSERT_NE(info1, nullptr); \ |
| ASSERT_EQ(info1->type(), "channel"); \ |
| ASSERT_EQ(info1->fd(), 1); \ |
| const fidl_codec::semantic::InferredHandleInfo* info2 = \ |
| dispatcher->inference().GetInferredHandleInfo(kSecondPid, out0); \ |
| ASSERT_NE(info2, nullptr); \ |
| ASSERT_EQ(info2->type(), "channel"); \ |
| ASSERT_EQ(info2->fd(), 2); \ |
| const fidl_codec::semantic::InferredHandleInfo* info3 = \ |
| dispatcher->inference().GetInferredHandleInfo(kSecondPid, out1); \ |
| ASSERT_NE(info3, nullptr); \ |
| ASSERT_EQ(info3->type(), "channel"); \ |
| ASSERT_EQ(info3->fd(), 3); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kFirstPid, out0), out1); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kFirstPid, out1), out0); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kSecondPid, out0), out1); \ |
| ASSERT_EQ(dispatcher->inference().GetLinkedHandle(kSecondPid, out1), out0); |
| |
| #define CREATE_INTERLEAVED_DISPLAY_TEST(name, errno, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { \ |
| CREATE_INTERLEAVED_DISPLAY_TEST_CONTENT(errno, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { \ |
| CREATE_INTERLEAVED_DISPLAY_TEST_CONTENT(errno, expected); \ |
| } |
| |
| CREATE_INTERLEAVED_DISPLAY_TEST( |
| ZxChannelCreateInterleaved, ZX_OK, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_create(" |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m)\n" |
| "\n" |
| "test_2718 \x1B[31m2718\x1B[0m:\x1B[31m8765\x1B[0m zx_channel_create(" |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m)\n" |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m -> \x1B[32mZX_OK\x1B[0m (" |
| "out0: \x1B[32mhandle\x1B[0m = \x1B[31m12345678\x1B[0m, " |
| "out1: \x1B[32mhandle\x1B[0m = \x1B[31m87654321\x1B[0m)\n" |
| "\n" |
| "test_2718 \x1B[31m2718\x1B[0m:\x1B[31m8765\x1B[0m -> \x1B[32mZX_OK\x1B[0m (" |
| "out0: \x1B[32mhandle\x1B[0m = \x1B[31m12345678\x1B[0m, " |
| "out1: \x1B[32mhandle\x1B[0m = \x1B[31m87654321\x1B[0m)\n"); |
| |
| // zx_channel_write_tests. |
| |
| std::unique_ptr<SystemCallTest> ZxChannelWrite(int64_t result, std::string_view result_name, |
| zx_handle_t handle, uint32_t options, |
| const uint8_t* bytes, uint32_t num_bytes, |
| const zx_handle_t* handles, uint32_t num_handles) { |
| auto value = std::make_unique<SystemCallTest>("zx_channel_write", result, result_name); |
| value->AddInput(handle); |
| value->AddInput(options); |
| value->AddInput(reinterpret_cast<uint64_t>(bytes)); |
| value->AddInput(num_bytes); |
| value->AddInput(reinterpret_cast<uint64_t>(handles)); |
| value->AddInput(num_handles); |
| return value; |
| } |
| |
| #define WRITE_CHECK_TEST_CONTENT(errno) \ |
| data().set_check_bytes(); \ |
| data().set_check_handles(); \ |
| PerformCheckTest("$plt(zx_channel_write)", \ |
| ZxChannelWrite(errno, #errno, kHandle, 0, data().bytes(), data().num_bytes(), \ |
| data().handles(), data().num_handles()), \ |
| nullptr) |
| |
| #define WRITE_CHECK_TEST(name, errno) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { WRITE_CHECK_TEST_CONTENT(errno); } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { WRITE_CHECK_TEST_CONTENT(errno); } |
| |
| WRITE_CHECK_TEST(ZxChannelWriteCheck, ZX_OK); |
| |
| #define WRITE_DISPLAY_TEST_CONTENT(errno, expected) \ |
| data().set_check_bytes(); \ |
| data().set_check_handles(); \ |
| PerformDisplayTest("$plt(zx_channel_write)", \ |
| ZxChannelWrite(errno, #errno, kHandle, 0, data().bytes(), data().num_bytes(), \ |
| data().handles(), data().num_handles()), \ |
| expected) |
| |
| #define WRITE_DISPLAY_TEST(name, errno, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { WRITE_DISPLAY_TEST_CONTENT(errno, expected); } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { WRITE_DISPLAY_TEST_CONTENT(errno, expected); } |
| |
| WRITE_DISPLAY_TEST(ZxChannelWrite, ZX_OK, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_write(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m)\n" |
| "" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n"); |
| |
| WRITE_DISPLAY_TEST(ZxChannelWritePeerClosed, ZX_ERR_PEER_CLOSED, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_write(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m)\n" |
| "" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n" |
| " -> \x1B[31mZX_ERR_PEER_CLOSED\x1B[0m\n"); |
| |
| #define LARGE_WRITE_DISPLAY_TEST_CONTENT(errno, expected) \ |
| PerformDisplayTest( \ |
| "$plt(zx_channel_write)", \ |
| ZxChannelWrite(errno, #errno, kHandle, 0, data().large_bytes(), data().num_large_bytes(), \ |
| data().handles(), data().num_handles()), \ |
| expected) |
| |
| #define LARGE_WRITE_DISPLAY_TEST(name, errno, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { LARGE_WRITE_DISPLAY_TEST_CONTENT(errno, expected); } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { LARGE_WRITE_DISPLAY_TEST_CONTENT(errno, expected); } |
| |
| LARGE_WRITE_DISPLAY_TEST(ZxChannelWriteLarge, ZX_OK, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_write(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m)\n" |
| "" |
| " \x1B[31mCan't decode message: num_bytes=100 num_handles=2 txid=9040100 " |
| "ordinal=e1c4a99079645140\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31m00, 01, 04, 09\x1B[0m, 10, 19, 24, 31\x1B[31m, " |
| "40, 51, 64, 79\x1B[0m, 90, a9, c4, e1, \n" |
| " 0010: \x1B[31m00, 21, 44, 69\x1B[0m, 90, b9, e4, 11\x1B[31m, " |
| "40, 71, a4, d9\x1B[0m, 10, 49, 84, c1, \n" |
| " 0020: \x1B[31m00, 41, 84, c9\x1B[0m, 10, 59, a4, f1\x1B[31m, " |
| "40, 91, e4, 39\x1B[0m, 90, e9, 44, a1, \n" |
| " 0030: \x1B[31m00, 61, c4, 29\x1B[0m, 90, f9, 64, d1\x1B[31m, " |
| "40, b1, 24, 99\x1B[0m, 10, 89, 04, 81, \n" |
| " 0040: \x1B[31m00, 81, 04, 89\x1B[0m, 10, 99, 24, b1\x1B[31m, " |
| "40, d1, 64, f9\x1B[0m, 90, 29, c4, 61, \n" |
| " 0050: \x1B[31m00, a1, 44, e9\x1B[0m, 90, 39, e4, 91\x1B[31m, " |
| "40, f1, a4, 59\x1B[0m, 10, c9, 84, 41, \n" |
| " 0060: \x1B[31m00, c1, 84, 49\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n"); |
| |
| #define WRITE_ABORTED_TEST_CONTENT(errno, expected) \ |
| PerformAbortedTest("$plt(zx_channel_write)", \ |
| ZxChannelWrite(errno, #errno, kHandle, 0, data().bytes(), data().num_bytes(), \ |
| data().handles(), data().num_handles()), \ |
| expected) |
| |
| #define WRITE_ABORTED_TEST(name, errno, expected) \ |
| TEST_F(InterceptionWorkflowTestX64Aborted, name) { \ |
| WRITE_ABORTED_TEST_CONTENT(errno, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArmAborted, name) { WRITE_ABORTED_TEST_CONTENT(errno, expected); } |
| |
| WRITE_ABORTED_TEST(ZxChannelWriteAborted, ZX_OK, |
| "\x1B[32m\nStop monitoring \x1B[34mtest_3141\x1B[0m koid=\x1B[31m3141\x1B[0m\n"); |
| |
| // zx_channel_read tests. |
| |
| std::unique_ptr<SystemCallTest> ZxChannelRead(int64_t result, std::string_view result_name, |
| zx_handle_t handle, uint32_t options, |
| const uint8_t* bytes, const zx_handle_t* handles, |
| uint32_t num_bytes, uint32_t num_handles, |
| uint32_t* actual_bytes, uint32_t* actual_handles) { |
| auto value = std::make_unique<SystemCallTest>("zx_channel_read", result, result_name); |
| value->AddInput(handle); |
| value->AddInput(options); |
| value->AddInput(reinterpret_cast<uint64_t>(bytes)); |
| value->AddInput(reinterpret_cast<uint64_t>(handles)); |
| value->AddInput(num_bytes); |
| value->AddInput(num_handles); |
| value->AddInput(reinterpret_cast<uint64_t>(actual_bytes)); |
| value->AddInput(reinterpret_cast<uint64_t>(actual_handles)); |
| return value; |
| } |
| |
| #define READ_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected) \ |
| if (check_bytes) { \ |
| data().set_check_bytes(); \ |
| } \ |
| if (check_handles) { \ |
| data().set_check_handles(); \ |
| } \ |
| uint32_t actual_bytes = data().num_bytes(); \ |
| uint32_t actual_handles = data().num_handles(); \ |
| PerformDisplayTest("$plt(zx_channel_read)", \ |
| ZxChannelRead(errno, #errno, kHandle, 0, data().bytes(), data().handles(), \ |
| 100, 64, (check_bytes) ? &actual_bytes : nullptr, \ |
| (check_handles) ? &actual_handles : nullptr), \ |
| expected); |
| |
| #define READ_DISPLAY_TEST(name, errno, check_bytes, check_handles, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { \ |
| READ_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { \ |
| READ_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } |
| |
| READ_DISPLAY_TEST(ZxChannelRead, ZX_OK, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n"); |
| |
| READ_DISPLAY_TEST(ZxChannelReadShouldWait, ZX_ERR_SHOULD_WAIT, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[31mZX_ERR_SHOULD_WAIT\x1B[0m\n"); |
| |
| READ_DISPLAY_TEST(ZxChannelReadTooSmall, ZX_ERR_BUFFER_TOO_SMALL, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[31mZX_ERR_BUFFER_TOO_SMALL\x1B[0m (" |
| "actual_bytes: \x1B[32muint32\x1B[0m = \x1B[34m16\x1B[0m, " |
| "actual_handles: \x1B[32muint32\x1B[0m = \x1B[34m2\x1B[0m)\n"); |
| |
| READ_DISPLAY_TEST(ZxChannelReadNoBytes, ZX_OK, false, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " not enough data for message\n" |
| " \x1B[31mCan't decode message: num_bytes=0 num_handles=2\x1B[0m\n" |
| " data=\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n"); |
| |
| READ_DISPLAY_TEST(ZxChannelReadNoHandles, ZX_OK, true, false, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=0 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n"); |
| |
| // zx_channel_read_etc tests. |
| std::unique_ptr<SystemCallTest> ZxChannelReadEtc(int64_t result, std::string_view result_name, |
| zx_handle_t handle, uint32_t options, |
| const uint8_t* bytes, |
| const zx_handle_info_t* handles, |
| uint32_t num_bytes, uint32_t num_handles, |
| uint32_t* actual_bytes, uint32_t* actual_handles) { |
| auto value = std::make_unique<SystemCallTest>("zx_channel_read_etc", result, result_name); |
| value->AddInput(handle); |
| value->AddInput(options); |
| value->AddInput(reinterpret_cast<uint64_t>(bytes)); |
| value->AddInput(reinterpret_cast<uint64_t>(handles)); |
| value->AddInput(num_bytes); |
| value->AddInput(num_handles); |
| value->AddInput(reinterpret_cast<uint64_t>(actual_bytes)); |
| value->AddInput(reinterpret_cast<uint64_t>(actual_handles)); |
| return value; |
| } |
| |
| #define READ_ETC_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected) \ |
| if (check_bytes) { \ |
| data().set_check_bytes(); \ |
| } \ |
| if (check_handles) { \ |
| data().set_check_handles(); \ |
| } \ |
| uint32_t actual_bytes = data().num_bytes(); \ |
| uint32_t actual_handles = data().num_handle_infos(); \ |
| PerformDisplayTest( \ |
| "$plt(zx_channel_read_etc)", \ |
| ZxChannelReadEtc(errno, #errno, kHandle, 0, data().bytes(), data().handle_infos(), 100, 64, \ |
| (check_bytes) ? &actual_bytes : nullptr, \ |
| (check_handles) ? &actual_handles : nullptr), \ |
| expected); |
| |
| #define READ_ETC_DISPLAY_TEST(name, errno, check_bytes, check_handles, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { \ |
| READ_ETC_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { \ |
| READ_ETC_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } |
| |
| READ_ETC_DISPLAY_TEST(ZxChannelReadEtc, ZX_OK, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read_etc(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n"); |
| |
| READ_ETC_DISPLAY_TEST(ZxChannelReadEtcShouldWait, ZX_ERR_SHOULD_WAIT, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read_etc(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[31mZX_ERR_SHOULD_WAIT\x1B[0m\n"); |
| |
| READ_ETC_DISPLAY_TEST(ZxChannelReadEtcTooSmall, ZX_ERR_BUFFER_TOO_SMALL, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read_etc(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| "" |
| " -> \x1B[31mZX_ERR_BUFFER_TOO_SMALL\x1B[0m (" |
| "actual_bytes: \x1B[32muint32\x1B[0m = \x1B[34m16\x1B[0m, " |
| "actual_handles: \x1B[32muint32\x1B[0m = \x1B[34m2\x1B[0m)\n"); |
| |
| READ_ETC_DISPLAY_TEST(ZxChannelReadEtcNoBytes, ZX_OK, false, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read_etc(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " not enough data for message\n" |
| " \x1B[31mCan't decode message: num_bytes=0 num_handles=2\x1B[0m\n" |
| " data=\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n"); |
| |
| READ_ETC_DISPLAY_TEST(ZxChannelReadEtcNoHandles, ZX_OK, true, false, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_read_etc(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=0 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n"); |
| |
| // zx_channel_call tests. |
| |
| std::unique_ptr<SystemCallTest> ZxChannelCall(int64_t result, std::string_view result_name, |
| zx_handle_t handle, uint32_t options, |
| zx_time_t deadline, |
| const zx_channel_call_args_t* args, |
| uint32_t* actual_bytes, uint32_t* actual_handles) { |
| auto value = std::make_unique<SystemCallTest>("zx_channel_call", result, result_name); |
| value->AddInput(handle); |
| value->AddInput(options); |
| value->AddInput(deadline); |
| value->AddInput(reinterpret_cast<uint64_t>(args)); |
| value->AddInput(reinterpret_cast<uint64_t>(actual_bytes)); |
| value->AddInput(reinterpret_cast<uint64_t>(actual_handles)); |
| return value; |
| } |
| |
| #define CALL_CHECK_TEST_CONTENT(errno) \ |
| data().set_check_bytes(); \ |
| data().set_check_handles(); \ |
| zx_channel_call_args_t args; \ |
| args.wr_bytes = data().bytes(); \ |
| args.wr_handles = data().handles(); \ |
| args.rd_bytes = data().bytes(); \ |
| args.rd_handles = data().handles(); \ |
| args.wr_num_bytes = data().num_bytes(); \ |
| args.wr_num_handles = data().num_handles(); \ |
| args.rd_num_bytes = 100; \ |
| args.rd_num_handles = 64; \ |
| uint32_t actual_bytes = data().num_bytes(); \ |
| uint32_t actual_handles = data().num_handles(); \ |
| zx_channel_call_args_t args2; \ |
| args2.wr_bytes = data().bytes2(); \ |
| args2.wr_handles = data().handles2(); \ |
| args2.rd_bytes = data().bytes2(); \ |
| args2.rd_handles = data().handles2(); \ |
| args2.wr_num_bytes = data().num_bytes2(); \ |
| args2.wr_num_handles = data().num_handles2(); \ |
| args2.rd_num_bytes = 100; \ |
| args2.rd_num_handles = 64; \ |
| uint32_t actual_bytes2 = data().num_bytes2(); \ |
| uint32_t actual_handles2 = data().num_handles2(); \ |
| PerformCheckTest("$plt(zx_channel_call)", \ |
| ZxChannelCall(errno, #errno, kHandle, 0, ZX_TIME_INFINITE, &args, \ |
| &actual_bytes, &actual_handles), \ |
| ZxChannelCall(errno, #errno, kHandle, 0, ZX_TIME_INFINITE, &args2, \ |
| &actual_bytes2, &actual_handles2)); |
| |
| #define CALL_CHECK_TEST(name, errno) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { CALL_CHECK_TEST_CONTENT(errno); } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { CALL_CHECK_TEST_CONTENT(errno); } |
| |
| CALL_CHECK_TEST(ZxChannelCallCheck, ZX_OK); |
| |
| #define CALL_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected) \ |
| if (check_bytes) { \ |
| data().set_check_bytes(); \ |
| } \ |
| if (check_handles) { \ |
| data().set_check_handles(); \ |
| } \ |
| zx_channel_call_args_t args; \ |
| args.wr_bytes = data().bytes(); \ |
| args.wr_handles = data().handles(); \ |
| args.rd_bytes = data().bytes(); \ |
| args.rd_handles = data().handles(); \ |
| args.wr_num_bytes = data().num_bytes(); \ |
| args.wr_num_handles = data().num_handles(); \ |
| args.rd_num_bytes = 100; \ |
| args.rd_num_handles = 64; \ |
| uint32_t actual_bytes = data().num_bytes(); \ |
| uint32_t actual_handles = data().num_handles(); \ |
| PerformDisplayTest("$plt(zx_channel_call)", \ |
| ZxChannelCall(errno, #errno, kHandle, 0, ZX_TIME_INFINITE, &args, \ |
| (check_bytes) ? &actual_bytes : nullptr, \ |
| (check_handles) ? &actual_handles : nullptr), \ |
| expected); |
| |
| #define CALL_DISPLAY_TEST(name, errno, check_bytes, check_handles, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { \ |
| CALL_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { \ |
| CALL_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } |
| |
| CALL_DISPLAY_TEST(ZxChannelCall, ZX_OK, true, true, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_call(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "deadline: \x1B[32mzx.time\x1B[0m = \x1B[34mZX_TIME_INFINITE\x1B[0m, " |
| "rd_num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "rd_num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| " data=\n" |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| " handles=\n" |
| " 0000: 01234567, 89abcdef\n"); |
| |
| #define CALL_DISPLAY_TEST_WITH_PROCESS_INFO(name, errno, check_bytes, check_handles, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { \ |
| set_with_process_info(); \ |
| CALL_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { \ |
| set_with_process_info(); \ |
| CALL_DISPLAY_TEST_CONTENT(errno, check_bytes, check_handles, expected); \ |
| } |
| |
| CALL_DISPLAY_TEST_WITH_PROCESS_INFO( |
| ZxChannelCallWithProcessInfo, ZX_OK, true, true, |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m \n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_call(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "deadline: \x1B[32mzx.time\x1B[0m = \x1B[34mZX_TIME_INFINITE\x1B[0m, " |
| "rd_num_bytes: \x1B[32muint32\x1B[0m = \x1B[34m100\x1B[0m, " |
| "rd_num_handles: \x1B[32muint32\x1B[0m = \x1B[34m64\x1B[0m)\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " data=\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " handles=\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " 0000: 01234567, 89abcdef\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " \x1B[31mCan't decode message: num_bytes=16 num_handles=2 " |
| "txid=aaaaaaaa ordinal=77e4cceb00000000\x1B[0m\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " data=\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " 0000: \x1B[31maa, aa, aa, aa\x1B[0m, 00, 00, 00, 01\x1B[31m" |
| ", 00, 00, 00, 00\x1B[0m, eb, cc, e4, 77\x1B[0m\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " handles=\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m " |
| " 0000: 01234567, 89abcdef\n"); |
| |
| #define CALL_DISPLAY_TEST_CONTENT_NULL_ARGS(errno, expected) \ |
| PerformDisplayTest( \ |
| "$plt(zx_channel_call)", \ |
| ZxChannelCall(errno, #errno, kHandle, 0, ZX_TIME_INFINITE, nullptr, nullptr, nullptr), \ |
| expected); |
| |
| #define CALL_DISPLAY_TEST_NULL_ARGS(name, errno, expected) \ |
| TEST_F(InterceptionWorkflowTestX64, name) { \ |
| CALL_DISPLAY_TEST_CONTENT_NULL_ARGS(errno, expected); \ |
| } \ |
| TEST_F(InterceptionWorkflowTestArm, name) { \ |
| CALL_DISPLAY_TEST_CONTENT_NULL_ARGS(errno, expected); \ |
| } |
| |
| CALL_DISPLAY_TEST_NULL_ARGS(ZxChannelCallNullArgs, ZX_OK, |
| "\n" |
| "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m zx_channel_call(" |
| "handle: \x1B[32mhandle\x1B[0m = \x1B[31mcefa1db0\x1B[0m, " |
| "options: \x1B[32muint32\x1B[0m = \x1B[34m0\x1B[0m, " |
| "deadline: \x1B[32mzx.time\x1B[0m = \x1B[34mZX_TIME_INFINITE\x1B[0m, " |
| "rd_num_bytes: \x1B[32muint32\x1B[0m = \x1B[31mnull\x1B[0m, " |
| "rd_num_handles: \x1B[32muint32\x1B[0m = \x1B[31mnull\x1B[0m)\n" |
| " not enough data for message\n" |
| " \x1B[31mCan't decode message: num_bytes=0 num_handles=0\x1B[0m\n" |
| " data=\x1B[0m\n" |
| " -> \x1B[32mZX_OK\x1B[0m\n" |
| " not enough data for message\n" |
| " \x1B[31mCan't decode message: num_bytes=0 num_handles=0\x1B[0m\n" |
| " data=\x1B[0m\n"); |
| |
| } // namespace fidlcat |
