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_error("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_error("UninstallMultipleProtocolInterfaces failed\n");
 277                 return EFI_ST_FAILURE;
 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_error("UninstallMultipleProtocolInterfaces failed to uninstall protocols\n");
 291                 return EFI_ST_FAILURE;
 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_error("UninstallProtocolInterface failed\n");
 331                 return EFI_ST_FAILURE;
 332         }
 333         ret = boottime->handle_protocol(handle1, &guid1, (void **)&interface);
 334         if (ret == EFI_SUCCESS) {
 335                 efi_st_error("UninstallProtocolInterface failed\n");
 336                 return EFI_ST_FAILURE;
 337         }
 338         ret = boottime->uninstall_protocol_interface(handle1, &guid3,
 339                                                      &interface1);
 340         if (ret != EFI_SUCCESS) {
 341                 efi_st_error("UninstallProtocolInterface failed\n");
 342                 return EFI_ST_FAILURE;
 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 };