e3c7c6bb31a00e12066454538bd1b83b3730e3d4
[debian/elilo] / x86_64 / bzimage.c
1 /*
2  *  Copyright (C) 2001-2003 Hewlett-Packard Co.
3  *      Contributed by Stephane Eranian <eranian@hpl.hp.com>
4  *      Contributed by Mike Johnston <johnston@intel.com>
5  *      Contributed by Chris Ahna <christopher.j.ahna@intel.com>
6  *
7  * This file is part of the ELILO, the EFI Linux boot loader.
8  *
9  *  ELILO is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2, or (at your option)
12  *  any later version.
13  *
14  *  ELILO is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with ELILO; see the file COPYING.  If not, write to the Free
21  *  Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22  *  02111-1307, USA.
23  *
24  * Please check out the elilo.txt for complete documentation on how
25  * to use this program.
26  */
27
28 #include <efi.h>
29 #include <efilib.h>
30
31 #include "elilo.h"
32 #include "loader.h"
33
34 boot_params_t *param_start = NULL;
35 UINTN param_size = 0;
36
37 UINTN kernel_size = 0x800000;   /* 8M (default x86_64 bzImage size limit) */
38
39 static INTN
40 bzImage_probe(CHAR16 *kname)
41 {
42         EFI_STATUS efi_status;
43         UINTN size;
44         fops_fd_t fd;
45         UINT8 bootsect[512];
46
47         DBG_PRT((L"probe_bzImage_boot()\n"));
48
49         if (!kname) {
50                 ERR_PRT((L"kname == %xh", kname));
51                 free_kmem();
52                 return -1;
53         }
54
55         /* 
56          * Open kernel image. 
57          */
58         DBG_PRT((L"opening %s...\n", kname));
59
60         efi_status = fops_open(kname, &fd);
61         if (EFI_ERROR(efi_status)) {
62                 ERR_PRT((L"Could not open %s.", kname));
63                 free_kmem();
64                 return -1;
65         }
66         /*
67          * Read boot sector.
68          */
69
70         DBG_PRT((L"\nreading boot sector...\n"));
71
72         size = sizeof bootsect;
73         efi_status = fops_read(fd, bootsect, &size);
74         if (EFI_ERROR(efi_status) || size != sizeof bootsect) {
75                 ERR_PRT((L"Could not read boot sector from %s.", kname));
76                 fops_close(fd);
77                 free_kmem();
78                 return -1;
79         }
80         /*
81          * Verify boot sector signature.
82          */
83
84         if (bootsect[0x1FE] != 0x55 || bootsect[0x1FF] != 0xAA) {
85                 ERR_PRT((L"%s is not a bzImage kernel image.\n", kname));
86                 fops_close(fd);
87                 free_kmem();
88                 return -1;
89         }
90         /*
91          * Check for out of range setup data size.
92          * Will almost always be 7, but we will accept 1 to 64.
93          */
94
95         DBG_PRT((L"bootsect[1F1h] == %d setup sectors\n", bootsect[0x1F1]));
96
97         if (bootsect[0x1F1] < 1 || bootsect[0x1F1] > 64) {
98                 ERR_PRT((L"%s is not a valid bzImage kernel image.",
99                         kname));
100                 fops_close(fd);
101                 free_kmem();
102                 return -1;
103         }
104         /*
105          * Allocate and read setup data.
106          */
107
108         DBG_PRT((L"reading setup data...\n"));
109
110         param_size = (bootsect[0x1F1] + 1) * 512;
111         param_start = alloc(param_size, EfiLoaderData);
112
113         DBG_PRT((L"param_size=%d param_start=%x", param_size, param_start));
114
115         if (!param_start) {
116                 ERR_PRT((L"Could not allocate %d bytes of setup data.",
117                         param_size));
118                 fops_close(fd);
119                 free_kmem();
120                 return -1;
121         }
122
123         CopyMem(param_start, bootsect, sizeof bootsect);
124
125         size = param_size - 512;
126         efi_status = fops_read(fd, ((UINT8 *)param_start) + 512, &size);
127
128         if (EFI_ERROR(efi_status) || size != param_size - 512) {
129                 ERR_PRT((L"Could not read %d bytes of setup data.",
130                         param_size - 512));
131                 free(param_start);
132                 param_start = NULL;
133                 param_size = 0;
134                 fops_close(fd);
135                 free_kmem();
136                 return -1;
137         }
138         /*
139          * Check for setup data signature.
140          */
141
142         { 
143                 UINT8 *c = ((UINT8 *)param_start)+514;
144                 DBG_PRT((L"param_start(c=%x): %c-%c-%c-%c", 
145                         c, (CHAR16)c[0],(CHAR16) c[1], (CHAR16)c[2], (CHAR16)c[3]));
146         }
147         if (CompareMem(((UINT8 *)param_start) + 514, "HdrS", 4)) {
148                 ERR_PRT((L"%s does not have a setup signature.",
149                         kname));
150                 free(param_start);
151                 param_start = NULL;
152                 param_size = 0;
153                 fops_close(fd);
154                 free_kmem();
155                 return -1;
156         }
157         /*
158          * Allocate memory for kernel.
159          */
160
161         /*
162          * Get correct address for kernel from header, if applicable & available. 
163          */
164         if ((param_start->s.hdr_major == 2) &&
165             (param_start->s.hdr_minor >= 6) &&
166             (param_start->s.kernel_start >= DEFAULT_KERNEL_START)) {
167                 kernel_start = (void *)param_start->s.kernel_start;
168                 VERB_PRT(3, Print(L"kernel header suggests kernel start at address "PTR_FMT"\n", 
169                         kernel_start));
170         }
171
172         kernel_load_address = kernel_start;
173
174         if (alloc_kmem(kernel_start, EFI_SIZE_TO_PAGES(kernel_size)) != 0) {
175                 /*
176                  * Couldn't get desired address--just load it anywhere and move it later.
177                  * (Easier than relocating kernel, and also works with non-relocatable kernels.)
178                  */
179                 if (alloc_kmem_anywhere(&kernel_load_address, EFI_SIZE_TO_PAGES(kernel_size)) != 0) {
180                         ERR_PRT((L"Could not allocate memory for kernel."));
181                         free(param_start);
182                         param_start = NULL;
183                         param_size = 0;
184                         fops_close(fd);
185                         return -1;
186                 }
187         }
188
189         VERB_PRT(3, Print(L"kernel_start: "PTR_FMT"  kernel_size: %d  loading at: "PTR_FMT"\n", 
190                 kernel_start, kernel_size, kernel_load_address));
191
192         /*
193          * Now read the rest of the kernel image into memory.
194          */
195
196         DBG_PRT((L"reading kernel image...\n"));
197
198         size = kernel_size;
199         efi_status = fops_read(fd, kernel_load_address, &size);
200         if (EFI_ERROR(efi_status) || size < 0x10000) {
201                 ERR_PRT((L"Error reading kernel image %s.", kname));
202                 free(param_start);
203                 param_start = NULL;
204                 param_size = 0;
205                 fops_close(fd);
206                 free_kmem();
207                 return -1;
208         }
209
210         DBG_PRT((L"kernel image read:  %d bytes, %d Kbytes\n", size, size / 1024));
211
212         /*
213          * Boot sector, setup data and kernel image loaded.
214          */
215
216         fops_close(fd);
217         return 0;
218 }
219
220 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
221 static INTN
222 bzImage_load(CHAR16 *kname, kdesc_t *kd)
223 {
224         DBG_PRT((L"load_bzImage_boot()\n"));
225
226         if (!kname || !kd) {
227                 ERR_PRT((L"kname="PTR_FMT"  kd="PTR_FMT"", kname, kd));
228                 free(param_start);
229                 param_start = NULL;
230                 param_size = 0;
231                 free_kmem();
232                 return -1;
233         }
234         kd->kstart = kd->kentry = kernel_start;
235         kd->kend = ((UINT8 *)kd->kstart) + kernel_size;
236
237         DBG_PRT((L"kstart="PTR_FMT"  kentry="PTR_FMT"  kend="PTR_FMT"\n", kd->kstart, kd->kentry, kd->kend));
238
239         return 0;
240 }
241
242 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
243 loader_ops_t bzimage_loader = {
244         NULL,
245         L"bzImage_loader",
246         &bzImage_probe,
247         &bzImage_load
248 };