1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * efi_selftest_manageprotocols
4 *
5 * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
6 *
7 * This unit test checks the following protocol services:
8 * InstallProtocolInterface, UninstallProtocolInterface,
9 * InstallMultipleProtocolsInterfaces, UninstallMultipleProtocolsInterfaces,
10 * HandleProtocol, ProtocolsPerHandle,
11 * LocateHandle, LocateHandleBuffer.
12 */
13
14 #include <efi_selftest.h>
15
16 /*
17 * The test currently does not actually call the interface function.
18 * So this is just a dummy structure.
19 */
20 struct interface {
21 void (EFIAPI * inc)(void);
22 };
23
24 static struct efi_boot_services *boottime;
25 static efi_guid_t guid1 =
26 EFI_GUID(0x2e7ca819, 0x21d3, 0x0a3a,
27 0xf7, 0x91, 0x82, 0x1f, 0x7a, 0x83, 0x67, 0xaf);
28 static efi_guid_t guid2 =
29 EFI_GUID(0xf909f2bb, 0x90a8, 0x0d77,
30 0x94, 0x0c, 0x3e, 0xa8, 0xea, 0x38, 0xd6, 0x6f);
31 static efi_guid_t guid3 =
32 EFI_GUID(0x06d641a3, 0xf4e7, 0xe0c9,
33 0xe7, 0x8d, 0x41, 0x2d, 0x72, 0xa6, 0xb1, 0x24);
34 static efi_handle_t handle1;
35 static efi_handle_t handle2;
36 static struct interface interface1;
37 static struct interface interface2;
38 static struct interface interface3;
39 static struct interface interface4;
40
41 /*
42 * Find a handle in an array.
43 *
44 * @handle: handle to find
45 * @count: number of entries in the array
46 * @buffer: array to search
47 */
find_in_buffer(efi_handle_t handle,size_t count,efi_handle_t * buffer)48 efi_status_t find_in_buffer(efi_handle_t handle, size_t count,
49 efi_handle_t *buffer)
50 {
51 size_t i;
52
53 for (i = 0; i < count; ++i) {
54 if (buffer[i] == handle)
55 return EFI_SUCCESS;
56 }
57 return EFI_NOT_FOUND;
58 }
59
60 /*
61 * Setup unit test.
62 *
63 * Create two handles and install two out of three protocol interfaces on each
64 * of them:
65 *
66 * handle1
67 * guid1 interface1
68 * guid3 interface3
69 * handle2
70 * guid1 interface4
71 * guid2 interface2
72 *
73 * @handle: handle of the loaded image
74 * @systable: system table
75 */
setup(const efi_handle_t img_handle,const struct efi_system_table * systable)76 static int setup(const efi_handle_t img_handle,
77 const struct efi_system_table *systable)
78 {
79 efi_status_t ret;
80 efi_handle_t handle;
81
82 boottime = systable->boottime;
83
84 ret = boottime->install_protocol_interface(&handle1, &guid3,
85 EFI_NATIVE_INTERFACE,
86 &interface3);
87 if (ret != EFI_SUCCESS) {
88 efi_st_error("InstallProtocolInterface failed\n");
89 return EFI_ST_FAILURE;
90 }
91 if (!handle1) {
92 efi_st_error("InstallProtocolInterface failed to create handle\n");
93 return EFI_ST_FAILURE;
94 }
95 handle = handle1;
96 ret = boottime->install_protocol_interface(&handle1, &guid1,
97 EFI_NATIVE_INTERFACE,
98 &interface1);
99 if (ret != EFI_SUCCESS) {
100 efi_st_error("InstallProtocolInterface failed\n");
101 return EFI_ST_FAILURE;
102 }
103 if (handle != handle1) {
104 efi_st_error("InstallProtocolInterface failed to use handle\n");
105 return EFI_ST_FAILURE;
106 }
107 ret = boottime->install_multiple_protocol_interfaces(&handle2,
108 &guid1, &interface4, &guid2, &interface2, NULL);
109 if (ret != EFI_SUCCESS) {
110 efi_st_error("InstallMultipleProtocolInterfaces failed\n");
111 return EFI_ST_FAILURE;
112 }
113 if (!handle2 || handle1 == handle2) {
114 efi_st_error("InstallMultipleProtocolInterfaces failed to create handle\n");
115 return EFI_ST_FAILURE;
116 }
117
118 return EFI_ST_SUCCESS;
119 }
120
121 /*
122 * Tear down unit test.
123 *
124 */
teardown(void)125 static int teardown(void)
126 {
127 return EFI_ST_SUCCESS;
128 }
129
130 /*
131 * Execute unit test.
132 *
133 */
execute(void)134 static int execute(void)
135 {
136 struct interface *interface;
137 efi_status_t ret;
138 efi_handle_t *buffer;
139 size_t buffer_size;
140 efi_uintn_t count = 0;
141 efi_guid_t **prot_buffer;
142 efi_uintn_t prot_count;
143
144 /*
145 * Test HandleProtocol
146 */
147 ret = boottime->handle_protocol(handle1, &guid3, (void **)&interface);
148 if (ret != EFI_SUCCESS) {
149 efi_st_error("HandleProtocol failed to retrieve interface\n");
150 return EFI_ST_FAILURE;
151 }
152 if (interface != &interface3) {
153 efi_st_error("HandleProtocol returned wrong interface\n");
154 return EFI_ST_FAILURE;
155 }
156 ret = boottime->handle_protocol(handle1, &guid2, (void **)&interface);
157 if (ret == EFI_SUCCESS) {
158 efi_st_error("HandleProtocol returned not installed interface\n");
159 return EFI_ST_FAILURE;
160 }
161
162 /*
163 * Test LocateHandleBuffer with AllHandles
164 */
165 ret = boottime->locate_handle_buffer(ALL_HANDLES, NULL, NULL,
166 &count, &buffer);
167 if (ret != EFI_SUCCESS) {
168 efi_st_error("LocateHandleBuffer with AllHandles failed\n");
169 return EFI_ST_FAILURE;
170 }
171 buffer_size = count;
172 ret = find_in_buffer(handle1, count, buffer);
173 if (ret != EFI_SUCCESS) {
174 efi_st_error("LocateHandleBuffer failed to locate new handle\n");
175 return EFI_ST_FAILURE;
176 }
177 ret = find_in_buffer(handle2, count, buffer);
178 if (ret != EFI_SUCCESS) {
179 efi_st_error("LocateHandleBuffer failed to locate new handle\n");
180 return EFI_ST_FAILURE;
181 }
182 /* Release buffer */
183 ret = boottime->free_pool(buffer);
184 if (ret != EFI_SUCCESS) {
185 efi_st_error("FreePool failed\n");
186 return EFI_ST_FAILURE;
187 }
188
189 /*
190 * Test error handling in UninstallMultipleProtocols
191 *
192 * These are the installed protocol interfaces on handle 2:
193 *
194 * guid1 interface4
195 * guid2 interface2
196 *
197 * Try to uninstall more protocols than there are installed. This
198 * should return an error EFI_INVALID_PARAMETER. All deleted protocols
199 * should be reinstalled.
200 */
201 ret = boottime->uninstall_multiple_protocol_interfaces(
202 handle2,
203 &guid1, &interface4,
204 &guid2, &interface2,
205 &guid3, &interface3,
206 NULL);
207 if (ret != EFI_INVALID_PARAMETER) {
208 printf("%lx", ret);
209 efi_st_error("UninstallMultipleProtocolInterfaces did not catch error\n");
210 return EFI_ST_FAILURE;
211 }
212
213 /*
214 * Test LocateHandleBuffer with ByProtocol
215 *
216 * These are the handles with a guid1 protocol interface installed:
217 *
218 * handle1, handle2
219 */
220 count = buffer_size;
221 ret = boottime->locate_handle_buffer(BY_PROTOCOL, &guid1, NULL,
222 &count, &buffer);
223 if (ret != EFI_SUCCESS) {
224 efi_st_error("LocateHandleBuffer failed to locate new handles\n");
225 return EFI_ST_FAILURE;
226 }
227 if (count != 2) {
228 efi_st_error("UninstallMultipleProtocolInterfaces deleted handle\n");
229 return EFI_ST_FAILURE;
230 }
231 ret = find_in_buffer(handle1, count, buffer);
232 if (ret != EFI_SUCCESS) {
233 efi_st_error("LocateHandleBuffer failed to locate new handle\n");
234 return EFI_ST_FAILURE;
235 }
236 ret = find_in_buffer(handle2, count, buffer);
237 if (ret != EFI_SUCCESS) {
238 efi_st_error("LocateHandleBuffer failed to locate new handle\n");
239 return EFI_ST_FAILURE;
240 }
241 /* Clear the buffer, we are reusing it it the next step. */
242 boottime->set_mem(buffer, sizeof(efi_handle_t) * buffer_size, 0);
243
244 /*
245 * Test LocateHandle with ByProtocol
246 */
247 count = buffer_size * sizeof(efi_handle_t);
248 ret = boottime->locate_handle(BY_PROTOCOL, &guid1, NULL,
249 &count, buffer);
250 if (ret != EFI_SUCCESS) {
251 efi_st_error("LocateHandle with ByProtocol failed\n");
252 return EFI_ST_FAILURE;
253 }
254 if (count / sizeof(efi_handle_t) != 2) {
255 efi_st_error("LocateHandle failed to locate new handles\n");
256 return EFI_ST_FAILURE;
257 }
258 buffer_size = count;
259 ret = find_in_buffer(handle1, count, buffer);
260 if (ret != EFI_SUCCESS) {
261 efi_st_error("LocateHandle failed to locate new handles\n");
262 return EFI_ST_FAILURE;
263 }
264 ret = find_in_buffer(handle2, count, buffer);
265 if (ret != EFI_SUCCESS) {
266 efi_st_error("LocateHandle failed to locate new handles\n");
267 return EFI_ST_FAILURE;
268 }
269 /* Release buffer */
270 ret = boottime->free_pool(buffer);
271 if (ret != EFI_SUCCESS) {
272 efi_st_error("FreePool failed\n");
273 return EFI_ST_FAILURE;
274 }
275
276 /*
277 * Test LocateProtocol
278 */
279 ret = boottime->locate_protocol(&guid1, NULL, (void **)&interface);
280 if (ret != EFI_SUCCESS) {
281 efi_st_error("LocateProtocol failed\n");
282 return EFI_ST_FAILURE;
283 }
284 if (interface != &interface1 && interface != &interface4) {
285 efi_st_error("LocateProtocol failed to locate protocol\n");
286 return EFI_ST_FAILURE;
287 }
288
289 /*
290 * Test UninstallMultipleProtocols
291 */
292 ret = boottime->uninstall_multiple_protocol_interfaces(
293 handle2,
294 &guid1, &interface4,
295 &guid2, &interface2,
296 NULL);
297 if (ret != EFI_SUCCESS) {
298 efi_st_error("UninstallMultipleProtocolInterfaces failed\n");
299 return EFI_ST_FAILURE;
300 }
301 /*
302 * Check that the protocols are really uninstalled.
303 */
304 count = buffer_size;
305 ret = boottime->locate_handle_buffer(BY_PROTOCOL, &guid1, NULL,
306 &count, &buffer);
307 if (ret != EFI_SUCCESS) {
308 efi_st_error("LocateHandleBuffer failed\n");
309 return EFI_ST_FAILURE;
310 }
311 if (count != 1) {
312 efi_st_error("UninstallMultipleProtocolInterfaces failed to uninstall protocols\n");
313 return EFI_ST_FAILURE;
314 }
315 ret = find_in_buffer(handle1, count, buffer);
316 if (ret != EFI_SUCCESS) {
317 efi_st_error("Failed to locate new handle\n");
318 return EFI_ST_FAILURE;
319 }
320 boottime->set_mem(buffer, sizeof(efi_handle_t) * buffer_size, 0);
321
322 /*
323 * Test ProtocolsPerHandle
324 */
325 ret = boottime->protocols_per_handle(handle1,
326 &prot_buffer, &prot_count);
327 if (ret != EFI_SUCCESS) {
328 efi_st_error("Failed to get protocols per handle\n");
329 return EFI_ST_FAILURE;
330 }
331 if (prot_count != 2) {
332 efi_st_error("Failed to get protocols per handle\n");
333 return EFI_ST_FAILURE;
334 }
335 if (efi_st_memcmp(prot_buffer[0], &guid1, 16) &&
336 efi_st_memcmp(prot_buffer[1], &guid1, 16)) {
337 efi_st_error("Failed to get protocols per handle\n");
338 return EFI_ST_FAILURE;
339 }
340 if (efi_st_memcmp(prot_buffer[0], &guid3, 16) &&
341 efi_st_memcmp(prot_buffer[1], &guid3, 16)) {
342 efi_st_error("Failed to get protocols per handle\n");
343 return EFI_ST_FAILURE;
344 }
345 /* Release buffer */
346 ret = boottime->free_pool(prot_buffer);
347 if (ret != EFI_SUCCESS) {
348 efi_st_error("FreePool failed\n");
349 return EFI_ST_FAILURE;
350 }
351
352 /*
353 * Uninstall remaining protocols
354 */
355 ret = boottime->uninstall_protocol_interface(handle1, &guid1,
356 &interface1);
357 if (ret != EFI_SUCCESS) {
358 efi_st_error("UninstallProtocolInterface failed\n");
359 return EFI_ST_FAILURE;
360 }
361 ret = boottime->handle_protocol(handle1, &guid1, (void **)&interface);
362 if (ret == EFI_SUCCESS) {
363 efi_st_error("UninstallProtocolInterface failed\n");
364 return EFI_ST_FAILURE;
365 }
366 ret = boottime->uninstall_protocol_interface(handle1, &guid3,
367 &interface3);
368 if (ret != EFI_SUCCESS) {
369 efi_st_error("UninstallProtocolInterface failed\n");
370 return EFI_ST_FAILURE;
371 }
372
373 return EFI_ST_SUCCESS;
374 }
375
376 EFI_UNIT_TEST(protserv) = {
377 .name = "manage protocols",
378 .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
379 .setup = setup,
380 .execute = execute,
381 .teardown = teardown,
382 };
383