efi_loader: adjust file system info
[platform/kernel/u-boot.git] / lib / efi_loader / efi_file.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * EFI_FILE_PROTOCOL
4  *
5  * Copyright (c) 2017 Rob Clark
6  */
7
8 #include <common.h>
9 #include <charset.h>
10 #include <efi_loader.h>
11 #include <malloc.h>
12 #include <mapmem.h>
13 #include <fs.h>
14
15 /* GUID for file system information */
16 const efi_guid_t efi_file_system_info_guid = EFI_FILE_SYSTEM_INFO_GUID;
17
18 /* GUID to obtain the volume label */
19 const efi_guid_t efi_system_volume_label_id = EFI_FILE_SYSTEM_VOLUME_LABEL_ID;
20
21 struct file_system {
22         struct efi_simple_file_system_protocol base;
23         struct efi_device_path *dp;
24         struct blk_desc *desc;
25         int part;
26 };
27 #define to_fs(x) container_of(x, struct file_system, base)
28
29 struct file_handle {
30         struct efi_file_handle base;
31         struct file_system *fs;
32         loff_t offset;       /* current file position/cursor */
33         int isdir;
34         u64 open_mode;
35
36         /* for reading a directory: */
37         struct fs_dir_stream *dirs;
38         struct fs_dirent *dent;
39
40         char path[0];
41 };
42 #define to_fh(x) container_of(x, struct file_handle, base)
43
44 static const struct efi_file_handle efi_file_handle_protocol;
45
46 static char *basename(struct file_handle *fh)
47 {
48         char *s = strrchr(fh->path, '/');
49         if (s)
50                 return s + 1;
51         return fh->path;
52 }
53
54 static int set_blk_dev(struct file_handle *fh)
55 {
56         return fs_set_blk_dev_with_part(fh->fs->desc, fh->fs->part);
57 }
58
59 /**
60  * is_dir() - check if file handle points to directory
61  *
62  * We assume that set_blk_dev(fh) has been called already.
63  *
64  * @fh:         file handle
65  * Return:      true if file handle points to a directory
66  */
67 static int is_dir(struct file_handle *fh)
68 {
69         struct fs_dir_stream *dirs;
70
71         dirs = fs_opendir(fh->path);
72         if (!dirs)
73                 return 0;
74
75         fs_closedir(dirs);
76
77         return 1;
78 }
79
80 /*
81  * Normalize a path which may include either back or fwd slashes,
82  * double slashes, . or .. entries in the path, etc.
83  */
84 static int sanitize_path(char *path)
85 {
86         char *p;
87
88         /* backslash to slash: */
89         p = path;
90         while ((p = strchr(p, '\\')))
91                 *p++ = '/';
92
93         /* handle double-slashes: */
94         p = path;
95         while ((p = strstr(p, "//"))) {
96                 char *src = p + 1;
97                 memmove(p, src, strlen(src) + 1);
98         }
99
100         /* handle extra /.'s */
101         p = path;
102         while ((p = strstr(p, "/."))) {
103                 /*
104                  * You'd be tempted to do this *after* handling ".."s
105                  * below to avoid having to check if "/." is start of
106                  * a "/..", but that won't have the correct results..
107                  * for example, "/foo/./../bar" would get resolved to
108                  * "/foo/bar" if you did these two passes in the other
109                  * order
110                  */
111                 if (p[2] == '.') {
112                         p += 2;
113                         continue;
114                 }
115                 char *src = p + 2;
116                 memmove(p, src, strlen(src) + 1);
117         }
118
119         /* handle extra /..'s: */
120         p = path;
121         while ((p = strstr(p, "/.."))) {
122                 char *src = p + 3;
123
124                 p--;
125
126                 /* find beginning of previous path entry: */
127                 while (true) {
128                         if (p < path)
129                                 return -1;
130                         if (*p == '/')
131                                 break;
132                         p--;
133                 }
134
135                 memmove(p, src, strlen(src) + 1);
136         }
137
138         return 0;
139 }
140
141 /**
142  * efi_create_file() - create file or directory
143  *
144  * @fh:                 file handle
145  * @attributes:         attributes for newly created file
146  * Returns:             0 for success
147  */
148 static int efi_create_file(struct file_handle *fh, u64 attributes)
149 {
150         loff_t actwrite;
151         void *buffer = &actwrite;
152
153         if (attributes & EFI_FILE_DIRECTORY)
154                 return fs_mkdir(fh->path);
155         else
156                 return fs_write(fh->path, map_to_sysmem(buffer), 0, 0,
157                                 &actwrite);
158 }
159
160 /**
161  * file_open() - open a file handle
162  *
163  * @fs:                 file system
164  * @parent:             directory relative to which the file is to be opened
165  * @file_name:          path of the file to be opened. '\', '.', or '..' may
166  *                      be used as modifiers. A leading backslash indicates an
167  *                      absolute path.
168  * @open_mode:          bit mask indicating the access mode (read, write,
169  *                      create)
170  * @attributes:         attributes for newly created file
171  * Returns:             handle to the opened file or NULL
172  */
173 static struct efi_file_handle *file_open(struct file_system *fs,
174                 struct file_handle *parent, u16 *file_name, u64 open_mode,
175                 u64 attributes)
176 {
177         struct file_handle *fh;
178         char f0[MAX_UTF8_PER_UTF16] = {0};
179         int plen = 0;
180         int flen = 0;
181
182         if (file_name) {
183                 utf16_to_utf8((u8 *)f0, file_name, 1);
184                 flen = u16_strlen(file_name);
185         }
186
187         /* we could have a parent, but also an absolute path: */
188         if (f0[0] == '\\') {
189                 plen = 0;
190         } else if (parent) {
191                 plen = strlen(parent->path) + 1;
192         }
193
194         /* +2 is for null and '/' */
195         fh = calloc(1, sizeof(*fh) + plen + (flen * MAX_UTF8_PER_UTF16) + 2);
196
197         fh->open_mode = open_mode;
198         fh->base = efi_file_handle_protocol;
199         fh->fs = fs;
200
201         if (parent) {
202                 char *p = fh->path;
203                 int exists;
204
205                 if (plen > 0) {
206                         strcpy(p, parent->path);
207                         p += plen - 1;
208                         *p++ = '/';
209                 }
210
211                 utf16_to_utf8((u8 *)p, file_name, flen);
212
213                 if (sanitize_path(fh->path))
214                         goto error;
215
216                 /* check if file exists: */
217                 if (set_blk_dev(fh))
218                         goto error;
219
220                 exists = fs_exists(fh->path);
221                 /* fs_exists() calls fs_close(), so open file system again */
222                 if (set_blk_dev(fh))
223                         goto error;
224
225                 if (!exists) {
226                         if (!(open_mode & EFI_FILE_MODE_CREATE) ||
227                             efi_create_file(fh, attributes))
228                                 goto error;
229                         if (set_blk_dev(fh))
230                                 goto error;
231                 }
232
233                 /* figure out if file is a directory: */
234                 fh->isdir = is_dir(fh);
235         } else {
236                 fh->isdir = 1;
237                 strcpy(fh->path, "");
238         }
239
240         return &fh->base;
241
242 error:
243         free(fh);
244         return NULL;
245 }
246
247 static efi_status_t EFIAPI efi_file_open(struct efi_file_handle *file,
248                 struct efi_file_handle **new_handle,
249                 u16 *file_name, u64 open_mode, u64 attributes)
250 {
251         struct file_handle *fh = to_fh(file);
252         efi_status_t ret;
253
254         EFI_ENTRY("%p, %p, \"%ls\", %llx, %llu", file, new_handle,
255                   file_name, open_mode, attributes);
256
257         /* Check parameters */
258         if (!file || !new_handle || !file_name) {
259                 ret = EFI_INVALID_PARAMETER;
260                 goto out;
261         }
262         if (open_mode != EFI_FILE_MODE_READ &&
263             open_mode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE) &&
264             open_mode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE |
265                          EFI_FILE_MODE_CREATE)) {
266                 ret = EFI_INVALID_PARAMETER;
267                 goto out;
268         }
269         /*
270          * The UEFI spec requires that attributes are only set in create mode.
271          * The SCT does not care about this and sets EFI_FILE_DIRECTORY in
272          * read mode. EDK2 does not check that attributes are zero if not in
273          * create mode.
274          *
275          * So here we only check attributes in create mode and do not check
276          * that they are zero otherwise.
277          */
278         if ((open_mode & EFI_FILE_MODE_CREATE) &&
279             (attributes & (EFI_FILE_READ_ONLY | ~EFI_FILE_VALID_ATTR))) {
280                 ret = EFI_INVALID_PARAMETER;
281                 goto out;
282         }
283
284         /* Open file */
285         *new_handle = file_open(fh->fs, fh, file_name, open_mode, attributes);
286         if (*new_handle) {
287                 EFI_PRINT("file handle %p\n", *new_handle);
288                 ret = EFI_SUCCESS;
289         } else {
290                 ret = EFI_NOT_FOUND;
291         }
292 out:
293         return EFI_EXIT(ret);
294 }
295
296 static efi_status_t file_close(struct file_handle *fh)
297 {
298         fs_closedir(fh->dirs);
299         free(fh);
300         return EFI_SUCCESS;
301 }
302
303 static efi_status_t EFIAPI efi_file_close(struct efi_file_handle *file)
304 {
305         struct file_handle *fh = to_fh(file);
306         EFI_ENTRY("%p", file);
307         return EFI_EXIT(file_close(fh));
308 }
309
310 static efi_status_t EFIAPI efi_file_delete(struct efi_file_handle *file)
311 {
312         struct file_handle *fh = to_fh(file);
313         efi_status_t ret = EFI_SUCCESS;
314
315         EFI_ENTRY("%p", file);
316
317         if (set_blk_dev(fh) || fs_unlink(fh->path))
318                 ret = EFI_WARN_DELETE_FAILURE;
319
320         file_close(fh);
321         return EFI_EXIT(ret);
322 }
323
324 /**
325  * efi_get_file_size() - determine the size of a file
326  *
327  * @fh:         file handle
328  * @file_size:  pointer to receive file size
329  * Return:      status code
330  */
331 static efi_status_t efi_get_file_size(struct file_handle *fh,
332                                       loff_t *file_size)
333 {
334         if (set_blk_dev(fh))
335                 return EFI_DEVICE_ERROR;
336
337         if (fs_size(fh->path, file_size))
338                 return EFI_DEVICE_ERROR;
339
340         return EFI_SUCCESS;
341 }
342
343 static efi_status_t file_read(struct file_handle *fh, u64 *buffer_size,
344                 void *buffer)
345 {
346         loff_t actread;
347         efi_status_t ret;
348         loff_t file_size;
349
350         ret = efi_get_file_size(fh, &file_size);
351         if (ret != EFI_SUCCESS)
352                 return ret;
353         if (file_size < fh->offset) {
354                 ret = EFI_DEVICE_ERROR;
355                 return ret;
356         }
357
358         if (set_blk_dev(fh))
359                 return EFI_DEVICE_ERROR;
360         if (fs_read(fh->path, map_to_sysmem(buffer), fh->offset,
361                     *buffer_size, &actread))
362                 return EFI_DEVICE_ERROR;
363
364         *buffer_size = actread;
365         fh->offset += actread;
366
367         return EFI_SUCCESS;
368 }
369
370 static efi_status_t dir_read(struct file_handle *fh, u64 *buffer_size,
371                 void *buffer)
372 {
373         struct efi_file_info *info = buffer;
374         struct fs_dirent *dent;
375         u64 required_size;
376         u16 *dst;
377
378         if (set_blk_dev(fh))
379                 return EFI_DEVICE_ERROR;
380
381         if (!fh->dirs) {
382                 assert(fh->offset == 0);
383                 fh->dirs = fs_opendir(fh->path);
384                 if (!fh->dirs)
385                         return EFI_DEVICE_ERROR;
386                 fh->dent = NULL;
387         }
388
389         /*
390          * So this is a bit awkward.  Since fs layer is stateful and we
391          * can't rewind an entry, in the EFI_BUFFER_TOO_SMALL case below
392          * we might have to return without consuming the dent.. so we
393          * have to stash it for next call.
394          */
395         if (fh->dent) {
396                 dent = fh->dent;
397         } else {
398                 dent = fs_readdir(fh->dirs);
399         }
400
401         if (!dent) {
402                 /* no more files in directory */
403                 *buffer_size = 0;
404                 return EFI_SUCCESS;
405         }
406
407         /* check buffer size: */
408         required_size = sizeof(*info) +
409                         2 * (utf8_utf16_strlen(dent->name) + 1);
410         if (*buffer_size < required_size) {
411                 *buffer_size = required_size;
412                 fh->dent = dent;
413                 return EFI_BUFFER_TOO_SMALL;
414         }
415         fh->dent = NULL;
416
417         *buffer_size = required_size;
418         memset(info, 0, required_size);
419
420         info->size = required_size;
421         info->file_size = dent->size;
422         info->physical_size = dent->size;
423
424         if (dent->type == FS_DT_DIR)
425                 info->attribute |= EFI_FILE_DIRECTORY;
426
427         dst = info->file_name;
428         utf8_utf16_strcpy(&dst, dent->name);
429
430         fh->offset++;
431
432         return EFI_SUCCESS;
433 }
434
435 static efi_status_t EFIAPI efi_file_read(struct efi_file_handle *file,
436                                          efi_uintn_t *buffer_size, void *buffer)
437 {
438         struct file_handle *fh = to_fh(file);
439         efi_status_t ret = EFI_SUCCESS;
440         u64 bs;
441
442         EFI_ENTRY("%p, %p, %p", file, buffer_size, buffer);
443
444         if (!buffer_size || !buffer) {
445                 ret = EFI_INVALID_PARAMETER;
446                 goto error;
447         }
448
449         bs = *buffer_size;
450         if (fh->isdir)
451                 ret = dir_read(fh, &bs, buffer);
452         else
453                 ret = file_read(fh, &bs, buffer);
454         if (bs <= SIZE_MAX)
455                 *buffer_size = bs;
456         else
457                 *buffer_size = SIZE_MAX;
458
459 error:
460         return EFI_EXIT(ret);
461 }
462
463 /**
464  * efi_file_write() - write to file
465  *
466  * This function implements the Write() service of the EFI_FILE_PROTOCOL.
467  *
468  * See the Unified Extensible Firmware Interface (UEFI) specification for
469  * details.
470  *
471  * @file:               file handle
472  * @buffer_size:        number of bytes to write
473  * @buffer:             buffer with the bytes to write
474  * Return:              status code
475  */
476 static efi_status_t EFIAPI efi_file_write(struct efi_file_handle *file,
477                                           efi_uintn_t *buffer_size,
478                                           void *buffer)
479 {
480         struct file_handle *fh = to_fh(file);
481         efi_status_t ret = EFI_SUCCESS;
482         loff_t actwrite;
483
484         EFI_ENTRY("%p, %p, %p", file, buffer_size, buffer);
485
486         if (!file || !buffer_size || !buffer) {
487                 ret = EFI_INVALID_PARAMETER;
488                 goto out;
489         }
490         if (fh->isdir) {
491                 ret = EFI_UNSUPPORTED;
492                 goto out;
493         }
494         if (!(fh->open_mode & EFI_FILE_MODE_WRITE)) {
495                 ret = EFI_ACCESS_DENIED;
496                 goto out;
497         }
498
499         if (!*buffer_size)
500                 goto out;
501
502         if (set_blk_dev(fh)) {
503                 ret = EFI_DEVICE_ERROR;
504                 goto out;
505         }
506         if (fs_write(fh->path, map_to_sysmem(buffer), fh->offset, *buffer_size,
507                      &actwrite)) {
508                 ret = EFI_DEVICE_ERROR;
509                 goto out;
510         }
511         *buffer_size = actwrite;
512         fh->offset += actwrite;
513
514 out:
515         return EFI_EXIT(ret);
516 }
517
518 /**
519  * efi_file_getpos() - get current position in file
520  *
521  * This function implements the GetPosition service of the EFI file protocol.
522  * See the UEFI spec for details.
523  *
524  * @file:       file handle
525  * @pos:        pointer to file position
526  * Return:      status code
527  */
528 static efi_status_t EFIAPI efi_file_getpos(struct efi_file_handle *file,
529                                            u64 *pos)
530 {
531         efi_status_t ret = EFI_SUCCESS;
532         struct file_handle *fh = to_fh(file);
533
534         EFI_ENTRY("%p, %p", file, pos);
535
536         if (fh->isdir) {
537                 ret = EFI_UNSUPPORTED;
538                 goto out;
539         }
540
541         *pos = fh->offset;
542 out:
543         return EFI_EXIT(ret);
544 }
545
546 /**
547  * efi_file_setpos() - set current position in file
548  *
549  * This function implements the SetPosition service of the EFI file protocol.
550  * See the UEFI spec for details.
551  *
552  * @file:       file handle
553  * @pos:        new file position
554  * Return:      status code
555  */
556 static efi_status_t EFIAPI efi_file_setpos(struct efi_file_handle *file,
557                                            u64 pos)
558 {
559         struct file_handle *fh = to_fh(file);
560         efi_status_t ret = EFI_SUCCESS;
561
562         EFI_ENTRY("%p, %llu", file, pos);
563
564         if (fh->isdir) {
565                 if (pos != 0) {
566                         ret = EFI_UNSUPPORTED;
567                         goto error;
568                 }
569                 fs_closedir(fh->dirs);
570                 fh->dirs = NULL;
571         }
572
573         if (pos == ~0ULL) {
574                 loff_t file_size;
575
576                 ret = efi_get_file_size(fh, &file_size);
577                 if (ret != EFI_SUCCESS)
578                         goto error;
579                 pos = file_size;
580         }
581
582         fh->offset = pos;
583
584 error:
585         return EFI_EXIT(ret);
586 }
587
588 static efi_status_t EFIAPI efi_file_getinfo(struct efi_file_handle *file,
589                                             const efi_guid_t *info_type,
590                                             efi_uintn_t *buffer_size,
591                                             void *buffer)
592 {
593         struct file_handle *fh = to_fh(file);
594         efi_status_t ret = EFI_SUCCESS;
595         u16 *dst;
596
597         EFI_ENTRY("%p, %pUl, %p, %p", file, info_type, buffer_size, buffer);
598
599         if (!file || !info_type || !buffer_size ||
600             (*buffer_size && !buffer)) {
601                 ret = EFI_INVALID_PARAMETER;
602                 goto error;
603         }
604
605         if (!guidcmp(info_type, &efi_file_info_guid)) {
606                 struct efi_file_info *info = buffer;
607                 char *filename = basename(fh);
608                 unsigned int required_size;
609                 loff_t file_size;
610
611                 /* check buffer size: */
612                 required_size = sizeof(*info) +
613                                 2 * (utf8_utf16_strlen(filename) + 1);
614                 if (*buffer_size < required_size) {
615                         *buffer_size = required_size;
616                         ret = EFI_BUFFER_TOO_SMALL;
617                         goto error;
618                 }
619
620                 ret = efi_get_file_size(fh, &file_size);
621                 if (ret != EFI_SUCCESS)
622                         goto error;
623
624                 memset(info, 0, required_size);
625
626                 info->size = required_size;
627                 info->file_size = file_size;
628                 info->physical_size = file_size;
629
630                 if (fh->isdir)
631                         info->attribute |= EFI_FILE_DIRECTORY;
632
633                 dst = info->file_name;
634                 utf8_utf16_strcpy(&dst, filename);
635         } else if (!guidcmp(info_type, &efi_file_system_info_guid)) {
636                 struct efi_file_system_info *info = buffer;
637                 disk_partition_t part;
638                 efi_uintn_t required_size;
639                 int r;
640
641                 if (fh->fs->part >= 1)
642                         r = part_get_info(fh->fs->desc, fh->fs->part, &part);
643                 else
644                         r = part_get_info_whole_disk(fh->fs->desc, &part);
645                 if (r < 0) {
646                         ret = EFI_DEVICE_ERROR;
647                         goto error;
648                 }
649                 required_size = sizeof(*info) + 2;
650                 if (*buffer_size < required_size) {
651                         *buffer_size = required_size;
652                         ret = EFI_BUFFER_TOO_SMALL;
653                         goto error;
654                 }
655
656                 memset(info, 0, required_size);
657
658                 info->size = required_size;
659                 /*
660                  * TODO: We cannot determine if the volume can be written to.
661                  */
662                 info->read_only = false;
663                 info->volume_size = part.size * part.blksz;
664                 /*
665                  * TODO: We currently have no function to determine the free
666                  * space. The volume size is the best upper bound we have.
667                  */
668                 info->free_space = info->volume_size;
669                 info->block_size = part.blksz;
670                 /*
671                  * TODO: The volume label is not available in U-Boot.
672                  */
673                 info->volume_label[0] = 0;
674         } else if (!guidcmp(info_type, &efi_system_volume_label_id)) {
675                 if (*buffer_size < 2) {
676                         *buffer_size = 2;
677                         ret = EFI_BUFFER_TOO_SMALL;
678                         goto error;
679                 }
680                 *(u16 *)buffer = 0;
681         } else {
682                 ret = EFI_UNSUPPORTED;
683         }
684
685 error:
686         return EFI_EXIT(ret);
687 }
688
689 static efi_status_t EFIAPI efi_file_setinfo(struct efi_file_handle *file,
690                                             const efi_guid_t *info_type,
691                                             efi_uintn_t buffer_size,
692                                             void *buffer)
693 {
694         struct file_handle *fh = to_fh(file);
695         efi_status_t ret = EFI_UNSUPPORTED;
696
697         EFI_ENTRY("%p, %pUl, %zu, %p", file, info_type, buffer_size, buffer);
698
699         if (!guidcmp(info_type, &efi_file_info_guid)) {
700                 struct efi_file_info *info = (struct efi_file_info *)buffer;
701                 char *filename = basename(fh);
702                 char *new_file_name, *pos;
703                 loff_t file_size;
704
705                 /* The buffer will always contain a file name. */
706                 if (buffer_size < sizeof(struct efi_file_info) + 2 ||
707                     buffer_size < info->size) {
708                         ret = EFI_BAD_BUFFER_SIZE;
709                         goto out;
710                 }
711                 /* We cannot change the directory attribute */
712                 if (!fh->isdir != !(info->attribute & EFI_FILE_DIRECTORY)) {
713                         ret = EFI_ACCESS_DENIED;
714                         goto out;
715                 }
716                 /* Check for renaming */
717                 new_file_name = malloc(utf16_utf8_strlen(info->file_name));
718                 if (!new_file_name) {
719                         ret = EFI_OUT_OF_RESOURCES;
720                         goto out;
721                 }
722                 pos = new_file_name;
723                 utf16_utf8_strcpy(&pos, info->file_name);
724                 if (strcmp(new_file_name, filename)) {
725                         /* TODO: we do not support renaming */
726                         EFI_PRINT("Renaming not supported\n");
727                         free(new_file_name);
728                         ret = EFI_ACCESS_DENIED;
729                         goto out;
730                 }
731                 free(new_file_name);
732                 /* Check for truncation */
733                 ret = efi_get_file_size(fh, &file_size);
734                 if (ret != EFI_SUCCESS)
735                         goto out;
736                 if (file_size != info->file_size) {
737                         /* TODO: we do not support truncation */
738                         EFI_PRINT("Truncation not supported\n");
739                         ret = EFI_ACCESS_DENIED;
740                         goto out;
741                 }
742                 /*
743                  * We do not care for the other attributes
744                  * TODO: Support read only
745                  */
746                 ret = EFI_SUCCESS;
747         } else {
748                 /* TODO: We do not support changing the volume label */
749                 ret = EFI_UNSUPPORTED;
750         }
751 out:
752         return EFI_EXIT(ret);
753 }
754
755 static efi_status_t EFIAPI efi_file_flush(struct efi_file_handle *file)
756 {
757         EFI_ENTRY("%p", file);
758         return EFI_EXIT(EFI_SUCCESS);
759 }
760
761 static efi_status_t EFIAPI efi_file_open_ex(struct efi_file_handle *file,
762                         struct efi_file_handle **new_handle,
763                         u16 *file_name, u64 open_mode, u64 attributes,
764                         struct efi_file_io_token *token)
765 {
766         return EFI_UNSUPPORTED;
767 }
768
769 static efi_status_t EFIAPI efi_file_read_ex(struct efi_file_handle *file,
770                         struct efi_file_io_token *token)
771 {
772         return EFI_UNSUPPORTED;
773 }
774
775 static efi_status_t EFIAPI efi_file_write_ex(struct efi_file_handle *file,
776                         struct efi_file_io_token *token)
777 {
778         return EFI_UNSUPPORTED;
779 }
780
781 static efi_status_t EFIAPI efi_file_flush_ex(struct efi_file_handle *file,
782                         struct efi_file_io_token *token)
783 {
784         return EFI_UNSUPPORTED;
785 }
786
787 static const struct efi_file_handle efi_file_handle_protocol = {
788         .rev = EFI_FILE_PROTOCOL_REVISION2,
789         .open = efi_file_open,
790         .close = efi_file_close,
791         .delete = efi_file_delete,
792         .read = efi_file_read,
793         .write = efi_file_write,
794         .getpos = efi_file_getpos,
795         .setpos = efi_file_setpos,
796         .getinfo = efi_file_getinfo,
797         .setinfo = efi_file_setinfo,
798         .flush = efi_file_flush,
799         .open_ex = efi_file_open_ex,
800         .read_ex = efi_file_read_ex,
801         .write_ex = efi_file_write_ex,
802         .flush_ex = efi_file_flush_ex,
803 };
804
805 /**
806  * efi_file_from_path() - open file via device path
807  *
808  * @fp:         device path
809  * @return:     EFI_FILE_PROTOCOL for the file or NULL
810  */
811 struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp)
812 {
813         struct efi_simple_file_system_protocol *v;
814         struct efi_file_handle *f;
815         efi_status_t ret;
816
817         v = efi_fs_from_path(fp);
818         if (!v)
819                 return NULL;
820
821         EFI_CALL(ret = v->open_volume(v, &f));
822         if (ret != EFI_SUCCESS)
823                 return NULL;
824
825         /* Skip over device-path nodes before the file path. */
826         while (fp && !EFI_DP_TYPE(fp, MEDIA_DEVICE, FILE_PATH))
827                 fp = efi_dp_next(fp);
828
829         /*
830          * Step through the nodes of the directory path until the actual file
831          * node is reached which is the final node in the device path.
832          */
833         while (fp) {
834                 struct efi_device_path_file_path *fdp =
835                         container_of(fp, struct efi_device_path_file_path, dp);
836                 struct efi_file_handle *f2;
837                 u16 *filename;
838
839                 if (!EFI_DP_TYPE(fp, MEDIA_DEVICE, FILE_PATH)) {
840                         printf("bad file path!\n");
841                         f->close(f);
842                         return NULL;
843                 }
844
845                 filename = u16_strdup(fdp->str);
846                 if (!filename)
847                         return NULL;
848                 EFI_CALL(ret = f->open(f, &f2, filename,
849                                        EFI_FILE_MODE_READ, 0));
850                 free(filename);
851                 if (ret != EFI_SUCCESS)
852                         return NULL;
853
854                 fp = efi_dp_next(fp);
855
856                 EFI_CALL(f->close(f));
857                 f = f2;
858         }
859
860         return f;
861 }
862
863 static efi_status_t EFIAPI
864 efi_open_volume(struct efi_simple_file_system_protocol *this,
865                 struct efi_file_handle **root)
866 {
867         struct file_system *fs = to_fs(this);
868
869         EFI_ENTRY("%p, %p", this, root);
870
871         *root = file_open(fs, NULL, NULL, 0, 0);
872
873         return EFI_EXIT(EFI_SUCCESS);
874 }
875
876 struct efi_simple_file_system_protocol *
877 efi_simple_file_system(struct blk_desc *desc, int part,
878                        struct efi_device_path *dp)
879 {
880         struct file_system *fs;
881
882         fs = calloc(1, sizeof(*fs));
883         fs->base.rev = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
884         fs->base.open_volume = efi_open_volume;
885         fs->desc = desc;
886         fs->part = part;
887         fs->dp = dp;
888
889         return &fs->base;
890 }