[PATCH] powerpc: replace page_to_virt() with lowmem_page_address() for Book-E
[linux-3.10.git] / arch / powerpc / boot / addRamDisk.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <netinet/in.h>
4 #include <unistd.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <string.h>
8 #include <elf.h>
9
10 #define ElfHeaderSize  (64 * 1024)
11 #define ElfPages  (ElfHeaderSize / 4096)
12 #define KERNELBASE (0xc000000000000000)
13 #define _ALIGN_UP(addr,size)    (((addr)+((size)-1))&(~((size)-1)))
14
15 struct addr_range {
16         unsigned long long addr;
17         unsigned long memsize;
18         unsigned long offset;
19 };
20
21 static int check_elf64(void *p, int size, struct addr_range *r)
22 {
23         Elf64_Ehdr *elf64 = p;
24         Elf64_Phdr *elf64ph;
25
26         if (elf64->e_ident[EI_MAG0] != ELFMAG0 ||
27             elf64->e_ident[EI_MAG1] != ELFMAG1 ||
28             elf64->e_ident[EI_MAG2] != ELFMAG2 ||
29             elf64->e_ident[EI_MAG3] != ELFMAG3 ||
30             elf64->e_ident[EI_CLASS] != ELFCLASS64 ||
31             elf64->e_ident[EI_DATA] != ELFDATA2MSB ||
32             elf64->e_type != ET_EXEC || elf64->e_machine != EM_PPC64)
33                 return 0;
34
35         if ((elf64->e_phoff + sizeof(Elf64_Phdr)) > size)
36                 return 0;
37
38         elf64ph = (Elf64_Phdr *) ((unsigned long)elf64 +
39                                   (unsigned long)elf64->e_phoff);
40
41         r->memsize = (unsigned long)elf64ph->p_memsz;
42         r->offset = (unsigned long)elf64ph->p_offset;
43         r->addr = (unsigned long long)elf64ph->p_vaddr;
44
45 #ifdef DEBUG
46         printf("PPC64 ELF file, ph:\n");
47         printf("p_type   0x%08x\n", elf64ph->p_type);
48         printf("p_flags  0x%08x\n", elf64ph->p_flags);
49         printf("p_offset 0x%016llx\n", elf64ph->p_offset);
50         printf("p_vaddr  0x%016llx\n", elf64ph->p_vaddr);
51         printf("p_paddr  0x%016llx\n", elf64ph->p_paddr);
52         printf("p_filesz 0x%016llx\n", elf64ph->p_filesz);
53         printf("p_memsz  0x%016llx\n", elf64ph->p_memsz);
54         printf("p_align  0x%016llx\n", elf64ph->p_align);
55         printf("... skipping 0x%08lx bytes of ELF header\n",
56                (unsigned long)elf64ph->p_offset);
57 #endif
58
59         return 64;
60 }
61 void get4k(FILE *file, char *buf )
62 {
63         unsigned j;
64         unsigned num = fread(buf, 1, 4096, file);
65         for ( j=num; j<4096; ++j )
66                 buf[j] = 0;
67 }
68
69 void put4k(FILE *file, char *buf )
70 {
71         fwrite(buf, 1, 4096, file);
72 }
73
74 void death(const char *msg, FILE *fdesc, const char *fname) 
75 {
76         fprintf(stderr, msg);
77         fclose(fdesc);
78         unlink(fname);
79         exit(1);
80 }
81
82 int main(int argc, char **argv)
83 {
84         char inbuf[4096];
85         struct addr_range vmlinux;
86         FILE *ramDisk;
87         FILE *inputVmlinux;
88         FILE *outputVmlinux;
89
90         char *rd_name, *lx_name, *out_name;
91
92         size_t i;
93         unsigned long ramFileLen;
94         unsigned long ramLen;
95         unsigned long roundR;
96         unsigned long offset_end;
97
98         unsigned long kernelLen;
99         unsigned long actualKernelLen;
100         unsigned long round;
101         unsigned long roundedKernelLen;
102         unsigned long ramStartOffs;
103         unsigned long ramPages;
104         unsigned long roundedKernelPages;
105         unsigned long hvReleaseData;
106         u_int32_t eyeCatcher = 0xc8a5d9c4;
107         unsigned long naca;
108         unsigned long xRamDisk;
109         unsigned long xRamDiskSize;
110         long padPages;
111   
112   
113         if (argc < 2) {
114                 fprintf(stderr, "Name of RAM disk file missing.\n");
115                 exit(1);
116         }
117         rd_name = argv[1];
118
119         if (argc < 3) {
120                 fprintf(stderr, "Name of vmlinux file missing.\n");
121                 exit(1);
122         }
123         lx_name = argv[2];
124
125         if (argc < 4) {
126                 fprintf(stderr, "Name of vmlinux output file missing.\n");
127                 exit(1);
128         }
129         out_name = argv[3];
130
131
132         ramDisk = fopen(rd_name, "r");
133         if ( ! ramDisk ) {
134                 fprintf(stderr, "RAM disk file \"%s\" failed to open.\n", rd_name);
135                 exit(1);
136         }
137
138         inputVmlinux = fopen(lx_name, "r");
139         if ( ! inputVmlinux ) {
140                 fprintf(stderr, "vmlinux file \"%s\" failed to open.\n", lx_name);
141                 exit(1);
142         }
143   
144         outputVmlinux = fopen(out_name, "w+");
145         if ( ! outputVmlinux ) {
146                 fprintf(stderr, "output vmlinux file \"%s\" failed to open.\n", out_name);
147                 exit(1);
148         }
149
150         i = fread(inbuf, 1, sizeof(inbuf), inputVmlinux);
151         if (i != sizeof(inbuf)) {
152                 fprintf(stderr, "can not read vmlinux file %s: %u\n", lx_name, i);
153                 exit(1);
154         }
155
156         i = check_elf64(inbuf, sizeof(inbuf), &vmlinux);
157         if (i == 0) {
158                 fprintf(stderr, "You must have a linux kernel specified as argv[2]\n");
159                 exit(1);
160         }
161
162         /* Input Vmlinux file */
163         fseek(inputVmlinux, 0, SEEK_END);
164         kernelLen = ftell(inputVmlinux);
165         fseek(inputVmlinux, 0, SEEK_SET);
166         printf("kernel file size = %lu\n", kernelLen);
167
168         actualKernelLen = kernelLen - ElfHeaderSize;
169
170         printf("actual kernel length (minus ELF header) = %lu\n", actualKernelLen);
171
172         round = actualKernelLen % 4096;
173         roundedKernelLen = actualKernelLen;
174         if ( round )
175                 roundedKernelLen += (4096 - round);
176         printf("Vmlinux length rounded up to a 4k multiple = %ld/0x%lx \n", roundedKernelLen, roundedKernelLen);
177         roundedKernelPages = roundedKernelLen / 4096;
178         printf("Vmlinux pages to copy = %ld/0x%lx \n", roundedKernelPages, roundedKernelPages);
179
180         offset_end = _ALIGN_UP(vmlinux.memsize, 4096);
181         /* calc how many pages we need to insert between the vmlinux and the start of the ram disk */
182         padPages = offset_end/4096 - roundedKernelPages;
183
184         /* Check and see if the vmlinux is already larger than _end in System.map */
185         if (padPages < 0) {
186                 /* vmlinux is larger than _end - adjust the offset to the start of the embedded ram disk */ 
187                 offset_end = roundedKernelLen;
188                 printf("vmlinux is larger than _end indicates it needs to be - offset_end = %lx \n", offset_end);
189                 padPages = 0;
190                 printf("will insert %lx pages between the vmlinux and the start of the ram disk \n", padPages);
191         }
192         else {
193                 /* _end is larger than vmlinux - use the offset to _end that we calculated from the system map */
194                 printf("vmlinux is smaller than _end indicates is needed - offset_end = %lx \n", offset_end);
195                 printf("will insert %lx pages between the vmlinux and the start of the ram disk \n", padPages);
196         }
197
198
199
200         /* Input Ram Disk file */
201         // Set the offset that the ram disk will be started at.
202         ramStartOffs = offset_end;  /* determined from the input vmlinux file and the system map */
203         printf("Ram Disk will start at offset = 0x%lx \n", ramStartOffs);
204   
205         fseek(ramDisk, 0, SEEK_END);
206         ramFileLen = ftell(ramDisk);
207         fseek(ramDisk, 0, SEEK_SET);
208         printf("%s file size = %ld/0x%lx \n", rd_name, ramFileLen, ramFileLen);
209
210         ramLen = ramFileLen;
211
212         roundR = 4096 - (ramLen % 4096);
213         if ( roundR ) {
214                 printf("Rounding RAM disk file up to a multiple of 4096, adding %ld/0x%lx \n", roundR, roundR);
215                 ramLen += roundR;
216         }
217
218         printf("Rounded RAM disk size is %ld/0x%lx \n", ramLen, ramLen);
219         ramPages = ramLen / 4096;
220         printf("RAM disk pages to copy = %ld/0x%lx\n", ramPages, ramPages);
221
222
223
224   // Copy 64K ELF header
225         for (i=0; i<(ElfPages); ++i) {
226                 get4k( inputVmlinux, inbuf );
227                 put4k( outputVmlinux, inbuf );
228         }
229
230         /* Copy the vmlinux (as full pages). */
231         fseek(inputVmlinux, ElfHeaderSize, SEEK_SET);
232         for ( i=0; i<roundedKernelPages; ++i ) {
233                 get4k( inputVmlinux, inbuf );
234                 put4k( outputVmlinux, inbuf );
235         }
236   
237         /* Insert pad pages (if appropriate) that are needed between */
238         /* | the end of the vmlinux and the ram disk. */
239         for (i=0; i<padPages; ++i) {
240                 memset(inbuf, 0, 4096);
241                 put4k(outputVmlinux, inbuf);
242         }
243
244         /* Copy the ram disk (as full pages). */
245         for ( i=0; i<ramPages; ++i ) {
246                 get4k( ramDisk, inbuf );
247                 put4k( outputVmlinux, inbuf );
248         }
249
250         /* Close the input files */
251         fclose(ramDisk);
252         fclose(inputVmlinux);
253         /* And flush the written output file */
254         fflush(outputVmlinux);
255
256
257
258         /* Fixup the new vmlinux to contain the ram disk starting offset (xRamDisk) and the ram disk size (xRamDiskSize) */
259         /* fseek to the hvReleaseData pointer */
260         fseek(outputVmlinux, ElfHeaderSize + 0x24, SEEK_SET);
261         if (fread(&hvReleaseData, 4, 1, outputVmlinux) != 1) {
262                 death("Could not read hvReleaseData pointer\n", outputVmlinux, out_name);
263         }
264         hvReleaseData = ntohl(hvReleaseData); /* Convert to native int */
265         printf("hvReleaseData is at %08lx\n", hvReleaseData);
266
267         /* fseek to the hvReleaseData */
268         fseek(outputVmlinux, ElfHeaderSize + hvReleaseData, SEEK_SET);
269         if (fread(inbuf, 0x40, 1, outputVmlinux) != 1) {
270                 death("Could not read hvReleaseData\n", outputVmlinux, out_name);
271         }
272         /* Check hvReleaseData sanity */
273         if (memcmp(inbuf, &eyeCatcher, 4) != 0) {
274                 death("hvReleaseData is invalid\n", outputVmlinux, out_name);
275         }
276         /* Get the naca pointer */
277         naca = ntohl(*((u_int32_t*) &inbuf[0x0C])) - KERNELBASE;
278         printf("Naca is at offset 0x%lx \n", naca);
279
280         /* fseek to the naca */
281         fseek(outputVmlinux, ElfHeaderSize + naca, SEEK_SET);
282         if (fread(inbuf, 0x18, 1, outputVmlinux) != 1) {
283                 death("Could not read naca\n", outputVmlinux, out_name);
284         }
285         xRamDisk = ntohl(*((u_int32_t *) &inbuf[0x0c]));
286         xRamDiskSize = ntohl(*((u_int32_t *) &inbuf[0x14]));
287         /* Make sure a RAM disk isn't already present */
288         if ((xRamDisk != 0) || (xRamDiskSize != 0)) {
289                 death("RAM disk is already attached to this kernel\n", outputVmlinux, out_name);
290         }
291         /* Fill in the values */
292         *((u_int32_t *) &inbuf[0x0c]) = htonl(ramStartOffs);
293         *((u_int32_t *) &inbuf[0x14]) = htonl(ramPages);
294
295         /* Write out the new naca */
296         fflush(outputVmlinux);
297         fseek(outputVmlinux, ElfHeaderSize + naca, SEEK_SET);
298         if (fwrite(inbuf, 0x18, 1, outputVmlinux) != 1) {
299                 death("Could not write naca\n", outputVmlinux, out_name);
300         }
301         printf("Ram Disk of 0x%lx pages is attached to the kernel at offset 0x%08lx\n",
302                ramPages, ramStartOffs);
303
304         /* Done */
305         fclose(outputVmlinux);
306         /* Set permission to executable */
307         chmod(out_name, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
308
309         return 0;
310 }
311