1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * A test for GUEST_PRINTF
4 *
5 * Copyright 2022, Google, Inc. and/or its affiliates.
6 */
7 #include <fcntl.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <sys/ioctl.h>
12
13 #include "test_util.h"
14 #include "kvm_util.h"
15 #include "processor.h"
16 #include "ucall_common.h"
17
18 struct guest_vals {
19 uint64_t a;
20 uint64_t b;
21 uint64_t type;
22 };
23
24 static struct guest_vals vals;
25
26 /* GUEST_PRINTF()/GUEST_ASSERT_FMT() does not support float or double. */
27 #define TYPE_LIST \
28 TYPE(test_type_i64, I64, "%ld", int64_t) \
29 TYPE(test_type_u64, U64u, "%lu", uint64_t) \
30 TYPE(test_type_x64, U64x, "0x%lx", uint64_t) \
31 TYPE(test_type_X64, U64X, "0x%lX", uint64_t) \
32 TYPE(test_type_u32, U32u, "%u", uint32_t) \
33 TYPE(test_type_x32, U32x, "0x%x", uint32_t) \
34 TYPE(test_type_X32, U32X, "0x%X", uint32_t) \
35 TYPE(test_type_int, INT, "%d", int) \
36 TYPE(test_type_char, CHAR, "%c", char) \
37 TYPE(test_type_str, STR, "'%s'", const char *) \
38 TYPE(test_type_ptr, PTR, "%p", uintptr_t)
39
40 enum args_type {
41 #define TYPE(fn, ext, fmt_t, T) TYPE_##ext,
42 TYPE_LIST
43 #undef TYPE
44 };
45
46 static void run_test(struct kvm_vcpu *vcpu, const char *expected_printf,
47 const char *expected_assert);
48
49 #define BUILD_TYPE_STRINGS_AND_HELPER(fn, ext, fmt_t, T) \
50 const char *PRINTF_FMT_##ext = "Got params a = " fmt_t " and b = " fmt_t; \
51 const char *ASSERT_FMT_##ext = "Expected " fmt_t ", got " fmt_t " instead"; \
52 static void fn(struct kvm_vcpu *vcpu, T a, T b) \
53 { \
54 char expected_printf[UCALL_BUFFER_LEN]; \
55 char expected_assert[UCALL_BUFFER_LEN]; \
56 \
57 snprintf(expected_printf, UCALL_BUFFER_LEN, PRINTF_FMT_##ext, a, b); \
58 snprintf(expected_assert, UCALL_BUFFER_LEN, ASSERT_FMT_##ext, a, b); \
59 vals = (struct guest_vals){ (uint64_t)a, (uint64_t)b, TYPE_##ext }; \
60 sync_global_to_guest(vcpu->vm, vals); \
61 run_test(vcpu, expected_printf, expected_assert); \
62 }
63
64 #define TYPE(fn, ext, fmt_t, T) \
65 BUILD_TYPE_STRINGS_AND_HELPER(fn, ext, fmt_t, T)
66 TYPE_LIST
67 #undef TYPE
68
69 static void guest_code(void)
70 {
71 while (1) {
72 switch (vals.type) {
73 #define TYPE(fn, ext, fmt_t, T) \
74 case TYPE_##ext: \
75 GUEST_PRINTF(PRINTF_FMT_##ext, vals.a, vals.b); \
76 __GUEST_ASSERT(vals.a == vals.b, \
77 ASSERT_FMT_##ext, vals.a, vals.b); \
78 break;
79 TYPE_LIST
80 #undef TYPE
81 default:
82 GUEST_SYNC(vals.type);
83 }
84
85 GUEST_DONE();
86 }
87 }
88
89 /*
90 * Unfortunately this gets a little messy because 'assert_msg' doesn't
91 * just contains the matching string, it also contains additional assert
92 * info. Fortunately the part that matches should be at the very end of
93 * 'assert_msg'.
94 */
95 static void ucall_abort(const char *assert_msg, const char *expected_assert_msg)
96 {
97 int len_str = strlen(assert_msg);
98 int len_substr = strlen(expected_assert_msg);
99 int offset = len_str - len_substr;
100
101 TEST_ASSERT(len_substr <= len_str,
102 "Expected '%s' to be a substring of '%s'",
103 assert_msg, expected_assert_msg);
104
105 TEST_ASSERT(strcmp(&assert_msg[offset], expected_assert_msg) == 0,
106 "Unexpected mismatch. Expected: '%s', got: '%s'",
107 expected_assert_msg, &assert_msg[offset]);
108 }
109
110 static void run_test(struct kvm_vcpu *vcpu, const char *expected_printf,
111 const char *expected_assert)
112 {
113 struct kvm_run *run = vcpu->run;
114 struct ucall uc;
115
116 while (1) {
117 vcpu_run(vcpu);
118
119 TEST_ASSERT(run->exit_reason == UCALL_EXIT_REASON,
120 "Unexpected exit reason: %u (%s),",
121 run->exit_reason, exit_reason_str(run->exit_reason));
122
123 switch (get_ucall(vcpu, &uc)) {
124 case UCALL_SYNC:
125 TEST_FAIL("Unknown 'args_type' = %lu", uc.args[1]);
126 break;
127 case UCALL_PRINTF:
128 TEST_ASSERT(strcmp(uc.buffer, expected_printf) == 0,
129 "Unexpected mismatch. Expected: '%s', got: '%s'",
130 expected_printf, uc.buffer);
131 break;
132 case UCALL_ABORT:
133 ucall_abort(uc.buffer, expected_assert);
134 break;
135 case UCALL_DONE:
136 return;
137 default:
138 TEST_FAIL("Unknown ucall %lu", uc.cmd);
139 }
140 }
141 }
142
143 static void guest_code_limits(void)
144 {
145 char test_str[UCALL_BUFFER_LEN + 10];
146
147 memset(test_str, 'a', sizeof(test_str));
148 test_str[sizeof(test_str) - 1] = 0;
149
150 GUEST_PRINTF("%s", test_str);
151 }
152
153 static void test_limits(void)
154 {
155 struct kvm_vcpu *vcpu;
156 struct kvm_run *run;
157 struct kvm_vm *vm;
158 struct ucall uc;
159
160 vm = vm_create_with_one_vcpu(&vcpu, guest_code_limits);
161 run = vcpu->run;
162 vcpu_run(vcpu);
163
164 TEST_ASSERT(run->exit_reason == UCALL_EXIT_REASON,
165 "Unexpected exit reason: %u (%s),",
166 run->exit_reason, exit_reason_str(run->exit_reason));
167
168 TEST_ASSERT(get_ucall(vcpu, &uc) == UCALL_ABORT,
169 "Unexpected ucall command: %lu, Expected: %u (UCALL_ABORT)",
170 uc.cmd, UCALL_ABORT);
171
172 kvm_vm_free(vm);
173 }
174
175 int main(int argc, char *argv[])
176 {
177 struct kvm_vcpu *vcpu;
178 struct kvm_vm *vm;
179
180 vm = vm_create_with_one_vcpu(&vcpu, guest_code);
181
182 test_type_i64(vcpu, -1, -1);
183 test_type_i64(vcpu, -1, 1);
184 test_type_i64(vcpu, 0x1234567890abcdef, 0x1234567890abcdef);
185 test_type_i64(vcpu, 0x1234567890abcdef, 0x1234567890abcdee);
186
187 test_type_u64(vcpu, 0x1234567890abcdef, 0x1234567890abcdef);
188 test_type_u64(vcpu, 0x1234567890abcdef, 0x1234567890abcdee);
189 test_type_x64(vcpu, 0x1234567890abcdef, 0x1234567890abcdef);
190 test_type_x64(vcpu, 0x1234567890abcdef, 0x1234567890abcdee);
191 test_type_X64(vcpu, 0x1234567890abcdef, 0x1234567890abcdef);
192 test_type_X64(vcpu, 0x1234567890abcdef, 0x1234567890abcdee);
193
194 test_type_u32(vcpu, 0x90abcdef, 0x90abcdef);
195 test_type_u32(vcpu, 0x90abcdef, 0x90abcdee);
196 test_type_x32(vcpu, 0x90abcdef, 0x90abcdef);
197 test_type_x32(vcpu, 0x90abcdef, 0x90abcdee);
198 test_type_X32(vcpu, 0x90abcdef, 0x90abcdef);
199 test_type_X32(vcpu, 0x90abcdef, 0x90abcdee);
200
201 test_type_int(vcpu, -1, -1);
202 test_type_int(vcpu, -1, 1);
203 test_type_int(vcpu, 1, 1);
204
205 test_type_char(vcpu, 'a', 'a');
206 test_type_char(vcpu, 'a', 'A');
207 test_type_char(vcpu, 'a', 'b');
208
209 test_type_str(vcpu, "foo", "foo");
210 test_type_str(vcpu, "foo", "bar");
211
212 test_type_ptr(vcpu, 0x1234567890abcdef, 0x1234567890abcdef);
213 test_type_ptr(vcpu, 0x1234567890abcdef, 0x1234567890abcdee);
214
215 kvm_vm_free(vm);
216
217 test_limits();
218
219 return 0;
220 }
221
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.