1 /* $NetBSD: efifs.c,v 1.6 2014/03/25 18:35:33 christos Exp $ */
2
3 /*-
4 * Copyright (c) 2001 Doug Rabson
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sys/boot/efi/libefi/efifs.c,v 1.8 2003/08/02 08:22:03 marcel Exp $
29 */
30
31 #include <sys/time.h>
32 #include <sys/dirent.h>
33 #include <lib/libsa/stand.h>
34 #include <lib/libsa/loadfile.h>
35 #include <lib/libkern/libkern.h>
36
37 #include <efi.h>
38 #include <efilib.h>
39
40 #include <bootstrap.h>
41
42 #include "efiboot.h"
43
44 /* Perform I/O in blocks of size EFI_BLOCK_SIZE. */
45 #define EFI_BLOCK_SIZE (1024 * 1024)
46
47
48 int
efifs_open(const char * upath,struct open_file * f)49 efifs_open(const char *upath, struct open_file *f)
50 {
51 struct efi_devdesc *dev = f->f_devdata;
52 static EFI_GUID sfsid = SIMPLE_FILE_SYSTEM_PROTOCOL;
53 EFI_FILE_IO_INTERFACE *sfs;
54 EFI_FILE *root;
55 EFI_FILE *file;
56 EFI_STATUS status;
57 CHAR16 *cp;
58 CHAR16 *path;
59
60 /*
61 * We cannot blindly assume that f->f_devdata points to a
62 * efi_devdesc structure. Before we dereference 'dev', make
63 * sure that the underlying device is ours.
64 */
65 if (f->f_dev != &devsw[0] || dev->d_handle == NULL)
66 return ENOENT;
67
68 status = BS->HandleProtocol(dev->d_handle, &sfsid, (VOID **)&sfs);
69 if (EFI_ERROR(status))
70 return ENOENT;
71
72 /*
73 * Find the root directory.
74 */
75 status = sfs->OpenVolume(sfs, &root);
76
77 /*
78 * Convert path to CHAR16, skipping leading separators.
79 */
80 while (*upath == '/')
81 upath++;
82 if (!*upath) {
83 /* Opening the root directory, */
84 f->f_fsdata = root;
85 return 0;
86 }
87 cp = path = alloc((strlen(upath) + 1) * sizeof(CHAR16));
88 if (path == NULL)
89 return ENOMEM;
90 while (*upath) {
91 if (*upath == '/')
92 *cp = '\\';
93 else
94 *cp = *upath;
95 upath++;
96 cp++;
97 }
98 *cp++ = 0;
99
100 /*
101 * Try to open it.
102 */
103 status = root->Open(root, &file, path, EFI_FILE_MODE_READ, 0);
104 free(path);
105 if (EFI_ERROR(status)) {
106 root->Close(root);
107 return ENOENT;
108 }
109
110 root->Close(root);
111 f->f_fsdata = file;
112 return 0;
113 }
114
115 int
efifs_close(struct open_file * f)116 efifs_close(struct open_file *f)
117 {
118 EFI_FILE *file = f->f_fsdata;
119
120 file->Close(file);
121 return 0;
122 }
123
124 int
efifs_read(struct open_file * f,void * buf,size_t size,size_t * resid)125 efifs_read(struct open_file *f, void *buf, size_t size, size_t *resid)
126 {
127 EFI_FILE *file = f->f_fsdata;
128 EFI_STATUS status;
129 UINTN sz = size;
130 char *bufp;
131
132 bufp = buf;
133 while (size > 0) {
134 sz = size;
135 if (sz > EFI_BLOCK_SIZE)
136 sz = EFI_BLOCK_SIZE;
137 status = file->Read(file, &sz, bufp);
138
139 #if !defined(LIBSA_NO_TWIDDLE)
140 twiddle();
141 #endif
142
143 if (EFI_ERROR(status))
144 return EIO;
145 if (sz == 0)
146 break;
147 size -= sz;
148 bufp += sz;
149 }
150 if (resid)
151 *resid = size;
152 return 0;
153 }
154
155 int
efifs_write(struct open_file * f,void * buf,size_t size,size_t * resid)156 efifs_write(struct open_file *f, void *buf, size_t size, size_t *resid)
157 {
158 EFI_FILE *file = f->f_fsdata;
159 EFI_STATUS status;
160 UINTN sz = size;
161 char *bufp;
162
163 bufp = buf;
164 while (size > 0) {
165 sz = size;
166 if (sz > EFI_BLOCK_SIZE)
167 sz = EFI_BLOCK_SIZE;
168 status = file->Write(file, &sz, bufp);
169
170 #if !defined(LIBSA_NO_TWIDDLE)
171 twiddle();
172 #endif
173
174 if (EFI_ERROR(status))
175 return EIO;
176 if (sz == 0)
177 break;
178 size -= sz;
179 bufp += sz;
180 }
181 if (resid)
182 *resid = size;
183 return 0;
184 }
185
186 off_t
efifs_seek(struct open_file * f,off_t offset,int where)187 efifs_seek(struct open_file *f, off_t offset, int where)
188 {
189 EFI_FILE *file = f->f_fsdata;
190 EFI_STATUS status;
191 UINT64 base;
192 UINTN sz;
193 static EFI_GUID infoid = EFI_FILE_INFO_ID;
194 EFI_FILE_INFO info;
195
196 switch (where) {
197 case SEEK_SET:
198 base = 0;
199 break;
200
201 case SEEK_CUR:
202 status = file->GetPosition(file, &base);
203 if (EFI_ERROR(status))
204 return -1;
205 break;
206
207 case SEEK_END:
208 sz = sizeof(info);
209 status = file->GetInfo(file, &infoid, &sz, &info);
210 if (EFI_ERROR(status))
211 return -1;
212 base = info.FileSize;
213 break;
214 }
215
216 status = file->SetPosition(file, base + offset);
217 if (EFI_ERROR(status))
218 return -1;
219 file->GetPosition(file, &base);
220
221 return base;
222 }
223
224 int
efifs_stat(struct open_file * f,struct stat * sb)225 efifs_stat(struct open_file *f, struct stat *sb)
226 {
227 EFI_FILE *file = f->f_fsdata;
228 EFI_STATUS status;
229 char *buf;
230 UINTN sz;
231 static EFI_GUID infoid = EFI_FILE_INFO_ID;
232 EFI_FILE_INFO *info;
233
234 memset(sb, 0, sizeof(*sb));
235
236 buf = alloc(1024);
237 sz = 1024;
238
239 status = file->GetInfo(file, &infoid, &sz, buf);
240 if (EFI_ERROR(status)) {
241 free(buf);
242 return -1;
243 }
244
245 info = (EFI_FILE_INFO *) buf;
246
247 if (info->Attribute & EFI_FILE_READ_ONLY)
248 sb->st_mode = S_IRUSR;
249 else
250 sb->st_mode = S_IRUSR | S_IWUSR;
251 if (info->Attribute & EFI_FILE_DIRECTORY)
252 sb->st_mode |= S_IFDIR;
253 else
254 sb->st_mode |= S_IFREG;
255 sb->st_size = info->FileSize;
256
257 free(buf);
258 return 0;
259 }
260
261 int
efifs_readdir(struct open_file * f,struct dirent * d)262 efifs_readdir(struct open_file *f, struct dirent *d)
263 {
264 EFI_FILE *file = f->f_fsdata;
265 EFI_STATUS status;
266 char *buf;
267 UINTN sz;
268 EFI_FILE_INFO *info;
269 int i;
270
271 buf = alloc(1024);
272 sz = 1024;
273
274 status = file->Read(file, &sz, buf);
275 if (EFI_ERROR(status) || sz < offsetof(EFI_FILE_INFO, FileName))
276 return ENOENT;
277
278 info = (EFI_FILE_INFO *) buf;
279
280 d->d_fileno = 0;
281 d->d_reclen = sizeof(*d);
282 if (info->Attribute & EFI_FILE_DIRECTORY)
283 d->d_type = DT_DIR;
284 else
285 d->d_type = DT_REG;
286 d->d_namlen = ((info->Size - offsetof(EFI_FILE_INFO, FileName))
287 / sizeof(CHAR16));
288 for (i = 0; i < d->d_namlen; i++)
289 d->d_name[i] = info->FileName[i];
290 d->d_name[i] = 0;
291
292 free(buf);
293 return 0;
294 }
295
296 static EFI_HANDLE *fs_handles;
297 UINTN fs_handle_count;
298
299 int
efifs_get_unit(EFI_HANDLE h)300 efifs_get_unit(EFI_HANDLE h)
301 {
302 UINTN u;
303
304 u = 0;
305 while (u < fs_handle_count && fs_handles[u] != h)
306 u++;
307 return ((u < fs_handle_count) ? u : -1);
308 }
309
310 int
efifs_dev_init(void)311 efifs_dev_init(void)
312 {
313 EFI_STATUS status;
314 UINTN sz;
315 static EFI_GUID sfsid = SIMPLE_FILE_SYSTEM_PROTOCOL;
316
317 sz = 0;
318 status = BS->LocateHandle(ByProtocol, &sfsid, 0, &sz, 0);
319 if (status != EFI_BUFFER_TOO_SMALL)
320 return ENOENT;
321 fs_handles = (EFI_HANDLE *) alloc(sz);
322 status = BS->LocateHandle(ByProtocol, &sfsid, 0,
323 &sz, fs_handles);
324 if (EFI_ERROR(status)) {
325 free(fs_handles);
326 return ENOENT;
327 }
328 fs_handle_count = sz / sizeof(EFI_HANDLE);
329
330 return 0;
331 }
332
333 /*
334 * Print information about disks
335 */
336 void
efifs_dev_print(int verbose)337 efifs_dev_print(int verbose)
338 {
339 int i;
340 char line[80];
341
342 for (i = 0; i < fs_handle_count; i++) {
343 snprintf(line, sizeof(line), " fs%d: EFI filesystem", i);
344 pager_output(line);
345 /* XXX more detail? */
346 pager_output("\n");
347 }
348 }
349
350 /*
351 * Attempt to open the disk described by (dev) for use by (f).
352 *
353 * Note that the philosophy here is "give them exactly what
354 * they ask for". This is necessary because being too "smart"
355 * about what the user might want leads to complications.
356 * (eg. given no slice or partition value, with a disk that is
357 * sliced - are they after the first BSD slice, or the DOS
358 * slice before it?)
359 */
360 int
efifs_dev_open(struct open_file * f,...)361 efifs_dev_open(struct open_file *f, ...)
362 {
363 va_list args;
364 struct efi_devdesc *dev;
365 int unit;
366
367 va_start(args, f);
368 dev = va_arg(args, struct efi_devdesc*);
369 va_end(args);
370
371 unit = dev->d_kind.efidisk.unit;
372 if (unit < 0 || unit >= fs_handle_count) {
373 printf("attempt to open nonexistent EFI filesystem\n");
374 return(ENXIO);
375 }
376
377 dev->d_handle = fs_handles[unit];
378
379 return 0;
380 }
381
382 int
efifs_dev_close(struct open_file * f)383 efifs_dev_close(struct open_file *f)
384 {
385
386 return 0;
387 }
388
389 int
efifs_dev_strategy(void * devdata,int rw,daddr_t dblk,size_t size,void * buf,size_t * rsize)390 efifs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, void *buf, size_t *rsize)
391 {
392 return 0;
393 }
394
395