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