drivers/firmware/efi/libstub/file.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Helper functions used by the EFI stub on multiple
   4  * architectures. This should be #included by the EFI stub
   5  * implementation files.
   6  *
   7  * Copyright 2011 Intel Corporation; author Matt Fleming
   8  */
   9
  10 #include <linux/efi.h>
  11 #include <asm/efi.h>
  12
  13 #include "efistub.h"
  14
  15 #define MAX_FILENAME_SIZE       256
  16
  17 /*
  18  * Some firmware implementations have problems reading files in one go.
  19  * A read chunk size of 1MB seems to work for most platforms.
  20  *
  21  * Unfortunately, reading files in chunks triggers *other* bugs on some
  22  * platforms, so we provide a way to disable this workaround, which can
  23  * be done by passing "efi=nochunk" on the EFI boot stub command line.
  24  *
  25  * If you experience issues with initrd images being corrupt it's worth
  26  * trying efi=nochunk, but chunking is enabled by default on x86 because
  27  * there are far more machines that require the workaround than those that
  28  * break with it enabled.
  29  */
  30 #define EFI_READ_CHUNK_SIZE     SZ_1M
  31
  32 struct finfo {
  33         efi_file_info_t info;
  34         efi_char16_t    filename[MAX_FILENAME_SIZE];
  35 };
  36
  37 static efi_status_t efi_open_file(efi_file_protocol_t *volume,
  38                                   struct finfo *fi,
  39                                   efi_file_protocol_t **handle,
  40                                   unsigned long *file_size)
  41 {
  42         efi_guid_t info_guid = EFI_FILE_INFO_ID;
  43         efi_file_protocol_t *fh;
  44         unsigned long info_sz;
  45         efi_status_t status;
  46         efi_char16_t *c;
  47
  48         /* Replace UNIX dir separators with EFI standard ones */
  49         for (c = fi->filename; *c != L'\0'; c++) {
  50                 if (*c == L'/')
  51                         *c = L'\\';
  52         }
  53
  54         status = efi_call_proto(volume, open, &fh, fi->filename,
  55                                 EFI_FILE_MODE_READ, 0);
  56         if (status != EFI_SUCCESS) {
  57                 efi_err("Failed to open file: %ls\n", fi->filename);
  58                 return status;
  59         }
  60
  61         info_sz = sizeof(struct finfo);
  62         status = efi_call_proto(fh, get_info, &info_guid, &info_sz, fi);
  63         if (status != EFI_SUCCESS) {
  64                 efi_err("Failed to get file info\n");
  65                 efi_call_proto(fh, close);
  66                 return status;
  67         }
  68
  69         *handle = fh;
  70         *file_size = fi->info.file_size;
  71         return EFI_SUCCESS;
  72 }
  73
  74 static efi_status_t efi_open_volume(efi_loaded_image_t *image,
  75                                     efi_file_protocol_t **fh)
  76 {
  77         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
  78         efi_simple_file_system_protocol_t *io;
  79         efi_status_t status;
  80
  81         status = efi_bs_call(handle_protocol, efi_table_attr(image, device_handle),
  82                              &fs_proto, (void **)&io);
  83         if (status != EFI_SUCCESS) {
  84                 efi_err("Failed to handle fs_proto\n");
  85                 return status;
  86         }
  87
  88         status = efi_call_proto(io, open_volume, fh);
  89         if (status != EFI_SUCCESS)
  90                 efi_err("Failed to open volume\n");
  91
  92         return status;
  93 }
  94
  95 static int find_file_option(const efi_char16_t *cmdline, int cmdline_len,
  96                             const efi_char16_t *prefix, int prefix_size,
  97                             efi_char16_t *result, int result_len)
  98 {
  99         int prefix_len = prefix_size / 2;
 100         bool found = false;
 101         int i;
 102
 103         for (i = prefix_len; i < cmdline_len; i++) {
 104                 if (!memcmp(&cmdline[i - prefix_len], prefix, prefix_size)) {
 105                         found = true;
 106                         break;
 107                 }
 108         }
 109
 110         if (!found)
 111                 return 0;
 112
 113         /* Skip any leading slashes */
 114         while (i < cmdline_len && (cmdline[i] == L'/' || cmdline[i] == L'\\'))
 115                 i++;
 116
 117         while (--result_len > 0 && i < cmdline_len) {
 118                 efi_char16_t c = cmdline[i++];
 119
 120                 if (c == L'\0' || c == L'\n' || c == L' ')
 121                         break;
 122                 *result++ = c;
 123         }
 124         *result = L'\0';
 125         return i;
 126 }
 127
 128 static efi_status_t efi_open_device_path(efi_file_protocol_t **volume,
 129                                          struct finfo *fi)
 130 {
 131         efi_guid_t text_to_dp_guid = EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID;
 132         static efi_device_path_from_text_protocol_t *text_to_dp = NULL;
 133         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
 134         efi_device_path_protocol_t *initrd_dp;
 135         efi_simple_file_system_protocol_t *io;
 136         struct efi_file_path_dev_path *fpath;
 137         efi_handle_t handle;
 138         efi_status_t status;
 139
 140         /* See if the text to device path protocol exists */
 141         if (!text_to_dp &&
 142             efi_bs_call(locate_protocol, &text_to_dp_guid, NULL,
 143                         (void **)&text_to_dp) != EFI_SUCCESS)
 144                 return EFI_UNSUPPORTED;
 145
 146
 147         /* Convert the filename wide string into a device path */
 148         initrd_dp = efi_fn_call(text_to_dp, convert_text_to_device_path,
 149                                 fi->filename);
 150
 151         /* Check whether the device path in question implements simple FS */
 152         if ((efi_bs_call(locate_device_path, &fs_proto, &initrd_dp, &handle) ?:
 153              efi_bs_call(handle_protocol, handle, &fs_proto, (void **)&io))
 154             != EFI_SUCCESS)
 155                 return EFI_NOT_FOUND;
 156
 157         /* Check whether the remaining device path is a file device path */
 158         if (initrd_dp->type != EFI_DEV_MEDIA ||
 159             initrd_dp->sub_type != EFI_DEV_MEDIA_FILE) {
 160                 efi_warn("Unexpected device path node type: (%x, %x)\n",
 161                          initrd_dp->type, initrd_dp->sub_type);
 162                 return EFI_LOAD_ERROR;
 163         }
 164
 165         /* Copy the remaining file path into the fi structure */
 166         fpath = (struct efi_file_path_dev_path *)initrd_dp;
 167         memcpy(fi->filename, fpath->filename,
 168                min(sizeof(fi->filename),
 169                    fpath->header.length - sizeof(fpath->header)));
 170
 171         status = efi_call_proto(io, open_volume, volume);
 172         if (status != EFI_SUCCESS)
 173                 efi_err("Failed to open volume\n");
 174
 175         return status;
 176 }
 177
 178 #ifndef CONFIG_CMDLINE
 179 #define CONFIG_CMDLINE
 180 #endif
 181
 182 static const efi_char16_t builtin_cmdline[] = L"" CONFIG_CMDLINE;
 183
 184 /*
 185  * Check the cmdline for a LILO-style file= arguments.
 186  *
 187  * We only support loading a file from the same filesystem as
 188  * the kernel image.
 189  */
 190 efi_status_t handle_cmdline_files(efi_loaded_image_t *image,
 191                                   const efi_char16_t *optstr,
 192                                   int optstr_size,
 193                                   unsigned long soft_limit,
 194                                   unsigned long hard_limit,
 195                                   unsigned long *load_addr,
 196                                   unsigned long *load_size)
 197 {
 198         const bool ignore_load_options = IS_ENABLED(CONFIG_CMDLINE_OVERRIDE) ||
 199                                          IS_ENABLED(CONFIG_CMDLINE_FORCE);
 200         const efi_char16_t *cmdline = efi_table_attr(image, load_options);
 201         u32 cmdline_len = efi_table_attr(image, load_options_size);
 202         unsigned long efi_chunk_size = ULONG_MAX;
 203         efi_file_protocol_t *volume = NULL;
 204         efi_file_protocol_t *file;
 205         unsigned long alloc_addr;
 206         unsigned long alloc_size;
 207         efi_status_t status;
 208         bool twopass;
 209         int offset;
 210
 211         if (!load_addr || !load_size)
 212                 return EFI_INVALID_PARAMETER;
 213
 214         efi_apply_loadoptions_quirk((const void **)&cmdline, &cmdline_len);
 215         cmdline_len /= sizeof(*cmdline);
 216
 217         if (IS_ENABLED(CONFIG_X86) && !efi_nochunk)
 218                 efi_chunk_size = EFI_READ_CHUNK_SIZE;
 219
 220         alloc_addr = alloc_size = 0;
 221
 222         if (!ignore_load_options && cmdline_len > 0) {
 223                 twopass = IS_ENABLED(CONFIG_CMDLINE_BOOL) ||
 224                           IS_ENABLED(CONFIG_CMDLINE_EXTEND);
 225         } else {
 226 do_builtin:     cmdline     = builtin_cmdline;
 227                 cmdline_len = ARRAY_SIZE(builtin_cmdline) - 1;
 228                 twopass     = false;
 229         }
 230
 231         do {
 232                 struct finfo fi;
 233                 unsigned long size;
 234                 void *addr;
 235
 236                 offset = find_file_option(cmdline, cmdline_len,
 237                                           optstr, optstr_size,
 238                                           fi.filename, ARRAY_SIZE(fi.filename));
 239
 240                 if (!offset)
 241                         break;
 242
 243                 cmdline += offset;
 244                 cmdline_len -= offset;
 245
 246                 status = efi_open_device_path(&volume, &fi);
 247                 if (status == EFI_UNSUPPORTED || status == EFI_NOT_FOUND)
 248                         /* try the volume that holds the kernel itself */
 249                         status = efi_open_volume(image, &volume);
 250
 251                 if (status != EFI_SUCCESS)
 252                         goto err_free_alloc;
 253
 254                 status = efi_open_file(volume, &fi, &file, &size);
 255                 if (status != EFI_SUCCESS)
 256                         goto err_close_volume;
 257
 258                 /*
 259                  * Check whether the existing allocation can contain the next
 260                  * file. This condition will also trigger naturally during the
 261                  * first (and typically only) iteration of the loop, given that
 262                  * alloc_size == 0 in that case.
 263                  */
 264                 if (round_up(alloc_size + size, EFI_ALLOC_ALIGN) >
 265                     round_up(alloc_size, EFI_ALLOC_ALIGN)) {
 266                         unsigned long old_addr = alloc_addr;
 267
 268                         status = EFI_OUT_OF_RESOURCES;
 269                         if (soft_limit < hard_limit)
 270                                 status = efi_allocate_pages(alloc_size + size,
 271                                                             &alloc_addr,
 272                                                             soft_limit);
 273                         if (status == EFI_OUT_OF_RESOURCES)
 274                                 status = efi_allocate_pages(alloc_size + size,
 275                                                             &alloc_addr,
 276                                                             hard_limit);
 277                         if (status != EFI_SUCCESS) {
 278                                 efi_err("Failed to allocate memory for files\n");
 279                                 goto err_close_file;
 280                         }
 281
 282                         if (old_addr != 0) {
 283                                 /*
 284                                  * This is not the first time we've gone
 285                                  * around this loop, and so we are loading
 286                                  * multiple files that need to be concatenated
 287                                  * and returned in a single buffer.
 288                                  */
 289                                 memcpy((void *)alloc_addr, (void *)old_addr, alloc_size);
 290                                 efi_free(alloc_size, old_addr);
 291                         }
 292                 }
 293
 294                 addr = (void *)alloc_addr + alloc_size;
 295                 alloc_size += size;
 296
 297                 while (size) {
 298                         unsigned long chunksize = min(size, efi_chunk_size);
 299
 300                         status = efi_call_proto(file, read, &chunksize, addr);
 301                         if (status != EFI_SUCCESS) {
 302                                 efi_err("Failed to read file\n");
 303                                 goto err_close_file;
 304                         }
 305                         addr += chunksize;
 306                         size -= chunksize;
 307                 }
 308                 efi_call_proto(file, close);
 309                 efi_call_proto(volume, close);
 310         } while (offset > 0);
 311
 312         if (twopass)
 313                 goto do_builtin;
 314
 315         *load_addr = alloc_addr;
 316         *load_size = alloc_size;
 317
 318         if (*load_size == 0)
 319                 return EFI_NOT_READY;
 320         return EFI_SUCCESS;
 321
 322 err_close_file:
 323         efi_call_proto(file, close);
 324
 325 err_close_volume:
 326         efi_call_proto(volume, close);
 327
 328 err_free_alloc:
 329         efi_free(alloc_size, alloc_addr);
 330         return status;
 331 }