logo

live-bootstrap

Mirror of <https://github.com/fosslinux/live-bootstrap>

kexec-fiwix.c (9716B)

    

  1. /* SPDX-FileCopyrightText: 2023 Richard Masters <grick23@gmail.com> */
  2. /* SPDX-License-Identifier: MIT */
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include "multiboot1.h"
  8. #define MULTIBOOT_MAGIC 0x2BADB002
  10. multiboot_uint32_t get_memmap(char *filename, void *memmap_addr) {
  12. 	if (!filename) {
  13. 		return 0;
  14. 	}
  16. 	multiboot_uint32_t memmap_length = 0;
  18. 	FILE *memmap_file = fopen(filename, "r");
  19. 	if (!memmap_file) {
  20. 		return 0;
  21. 	}
  23. 	fseek(memmap_file, 0, SEEK_END);
  24. 	memmap_length = ftell(memmap_file);
  25. 	if (!memmap_length) {
  26. 		fclose(memmap_file);
  27. 		return 0;
  28. 	}
  29. 	printf("kexec-fiwix: Memory map file length: %d\n", memmap_length);
  31. 	puts("kexec-fiwix: Reading memory map file...");
  32. 	fseek(memmap_file, 0, SEEK_SET);
  33. 	int memmap_read_len = fread(memmap_addr, memmap_length, 1, memmap_file);
  34. 	fclose(memmap_file);
  36. 	if (memmap_read_len < 1) {
  37. 		printf("kexec-fiwix: memory map fread error: %d\n", memmap_read_len);
  38. 		return 0;
  39. 	}
  41. 	return memmap_length;
  42. }
  44. int main(int argc, char **argv) {
  46. 	char *fiwix_filename = "/boot/fiwix";
  47. 	char *initrd_filename = "/boot/fiwix.ext2";
  48. 	char *cmdline = NULL;
  49. 	char *memmap = NULL;
  50. 	int i;
  52. 	for (i = 1; i < argc; i++) {
  53. 		if (!strcmp(argv[i], "-c")) {
  54. 			i++;
  55. 			cmdline = argv[i];
  56. 		} else if (!strcmp(argv[i], "-i")) {
  57. 			i++;
  58. 			initrd_filename = argv[i];
  59. 		} else if (!strcmp(argv[i], "-m")) {
  60. 			i++;
  61. 			memmap = argv[i];
  62. 		} else {
  63. 			fiwix_filename = argv[i];
  64. 		}
  65. 	}
  67. 	/* Read the kernel */
  69. 	printf("kexec-fiwix: starting kernel %s...\n\n", fiwix_filename);
  70. 	FILE *fiwix_file = fopen(fiwix_filename, "r");
  71. 	fseek(fiwix_file, 0, SEEK_END);
  72. 	int fiwix_len = ftell(fiwix_file);
  73. 	printf("kexec-fiwix: Fiwix kernel file length: %d\n", fiwix_len);
  75. 	puts("kexec-fiwix: Reading kernel...");
  76. 	fseek(fiwix_file, 0, SEEK_SET);
  77. 	char * fiwix_mem = malloc(fiwix_len);
  78. 	int read_len = fread(fiwix_mem, fiwix_len, 1, fiwix_file);
  79. 	fclose(fiwix_file);
  81. 	if (read_len < 1) {
  82. 		printf("kexec-fiwix: kernel fread error: %d\n", read_len);
  83. 		return EXIT_FAILURE;
  84. 	}
  87. 	/* Display info from ELF header */
  89. 	unsigned int e_entry = *((unsigned int *) (&fiwix_mem[0x18]));
  90. 	printf("ELF virtual entry point       : 0x%x\n", e_entry);
  92. 	unsigned int e_phoff = *((unsigned int *) (&fiwix_mem[0x1C]));
  93. 	printf("ELF program header offset     : 0x%x\n", e_phoff);
  95. 	unsigned int e_phnum = *((unsigned int *) (&fiwix_mem[0x2C]));
  96. 	e_phnum &= 0xFFFF;
  97. 	printf("ELF number of program  headers: %d\n", e_phnum);
  99. 	unsigned int e_phentsize = *((unsigned int *) (&fiwix_mem[0x2A]));
  100. 	e_phentsize &= 0xFFFF;
  101. 	printf("ELF size of program  headers  : %d\n", e_phentsize);
  104. 	/* Load the kernel */
  105. 	puts("kexec-fiwix: Placing kernel in memory...");
  107. 	int header_num;
  108. 	for (header_num = 0; header_num < e_phnum; header_num++) {
  109. 		char * fiwix_prog_header = &fiwix_mem[e_phoff + header_num * e_phentsize];
  111. 		unsigned int p_offset = *((unsigned int *) (&fiwix_prog_header[0x04]));
  112. 		unsigned int p_vaddr = *((unsigned int *) (&fiwix_prog_header[0x08]));
  113. 		unsigned int p_paddr = *((unsigned int *) (&fiwix_prog_header[0x0C]));
  114. 		unsigned int p_filesz = *((unsigned int *) (&fiwix_prog_header[0x10]));
  115. 		unsigned int p_memsz = *((unsigned int *) (&fiwix_prog_header[0x14]));
  117. 		if (header_num == 0) {
  118.         		e_entry -= (p_vaddr - p_paddr);
  119. 			printf("ELF physical entry point      : 0x%x\n", e_entry);
  120. 		}
  122. 		printf("header %d:\n", header_num);
  123. 		printf("    p_offset: 0x%08x\n", p_offset);
  124. 		printf("    p_paddr : 0x%08x\n", p_paddr);
  125. 		printf("    p_filesz: 0x%08x\n", p_filesz);
  126. 		printf("    p_memsz : 0x%08x\n", p_memsz);
  128. 		memset((void *)p_paddr, 0, p_memsz + 0x10000);
  129. 		memcpy((void *)p_paddr, &fiwix_mem[p_offset], p_filesz);
  130. 	}
  132. 	puts("Preparing multiboot info for kernel...");
  134. 	char * boot_loader_name = "kexec-fiwix";
  136. 	unsigned int next_avail_mem = 0x9800;
  137. 	multiboot_info_t * pmultiboot_info = (multiboot_info_t *) next_avail_mem;
  138. 	memset(pmultiboot_info, 0, sizeof(multiboot_info_t));
  140. 	pmultiboot_info->flags = MULTIBOOT_INFO_BOOT_LOADER_NAME
  141. 		| MULTIBOOT_INFO_MEMORY
  142. 		| MULTIBOOT_INFO_MODS
  143. 		| MULTIBOOT_INFO_MEM_MAP;
  145. 	next_avail_mem += sizeof(multiboot_info_t);
  147. 	pmultiboot_info->mem_lower = 0x0000027F;
  148. 	pmultiboot_info->mem_upper = 0x002FFB80;
  150. 	/* Set command line */
  151. 	if (cmdline != NULL) {
  152. 		pmultiboot_info->flags = pmultiboot_info->flags | MULTIBOOT_INFO_CMDLINE;
  153. 		pmultiboot_info->cmdline = next_avail_mem;
  154. 		strcpy((char *) next_avail_mem, cmdline);
  155. 		next_avail_mem += (strlen(cmdline) + 1);
  156. 	}
  158. 	int filenum;
  159. 	unsigned int filename_addr;
  160. 	for (filenum = 4, filename_addr = 0x201000; filenum <= 14335; filenum++, filename_addr += 1024) {
  161. 		if (!strcmp((char *) filename_addr, initrd_filename)) {
  162. 			printf("Found image at filenum %d\n", filenum);
  163. 			break;
  164. 		}
  165. 	}
  167. 	unsigned int initrd_src = *((unsigned int *) (0x01000000 + (16 * filenum) + 4));
  168. 	unsigned int initrd_len = *((unsigned int *) (0x01000000 + (16 * filenum) + 8));
  169. 	printf("initrd_src: 0x%08x\n", initrd_src);
  170. 	printf("initrd_len: 0x%08x\n", initrd_len);
  172. 	/* Set ramdrive info */
  173. 	pmultiboot_info->mods_count = 1;
  174. 	pmultiboot_info->mods_addr = next_avail_mem;
  175. 	multiboot_module_t *pmultiboot_module = (multiboot_module_t *) next_avail_mem;
  176. 	pmultiboot_module->mod_start = 0x1C6000;
  177. 	pmultiboot_module->mod_end = 0x1C6000 + initrd_len;
  178. 	next_avail_mem += sizeof(multiboot_module_t);
  179. 	pmultiboot_module->cmdline = next_avail_mem;
  180. 	strcpy((char *) next_avail_mem, "fiwix.ext2");
  181. 	next_avail_mem += (strlen("fiwix.ext2") + 1);
  183. 	/* Set memory map info */
  184. 	pmultiboot_info->mmap_addr = next_avail_mem;
  185. 	pmultiboot_info->mmap_length = get_memmap(memmap, (void *) pmultiboot_info->mmap_addr);
  187. 	/* if we have no memory map, fall back to a safe default */
  188. 	if (pmultiboot_info->mmap_length == 0) {
  189. 		pmultiboot_info->mmap_length = 7 * sizeof(multiboot_memory_map_t);
  190. 		multiboot_memory_map_t *pmultiboot_memory_map = (multiboot_memory_map_t *) next_avail_mem;
  192. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  193. 		pmultiboot_memory_map->addr = 0x00000000;
  194. 		pmultiboot_memory_map->len  = 0x00080000;
  195. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_AVAILABLE;
  196. 		pmultiboot_memory_map++;
  198. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  199. 		pmultiboot_memory_map->addr = 0x00080000;
  200. 		pmultiboot_memory_map->len  = 0x00020000;
  201. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_RESERVED;
  202. 		pmultiboot_memory_map++;
  204. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  205. 		pmultiboot_memory_map->addr = 0x000F0000;
  206. 		pmultiboot_memory_map->len =  0x00010000;
  207. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_RESERVED;
  208. 		pmultiboot_memory_map++;
  210. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  211. 		pmultiboot_memory_map->addr = 0x00100000;
  212. 		pmultiboot_memory_map->len  = 0xBBF00000;
  213. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_AVAILABLE;
  214. 		pmultiboot_memory_map++;
  216. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  217. 		pmultiboot_memory_map->addr = 0XBC000000;
  218. 		pmultiboot_memory_map->len  = 0x04000000;
  219. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_RESERVED;
  220. 		pmultiboot_memory_map++;
  222. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  223. 		pmultiboot_memory_map->addr = 0XFEFFC000;
  224. 		pmultiboot_memory_map->len  = 0x00004000;
  225. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_RESERVED;
  226. 		pmultiboot_memory_map++;
  228. 		pmultiboot_memory_map->size = sizeof(multiboot_memory_map_t) - sizeof(multiboot_uint32_t);
  229. 		pmultiboot_memory_map->addr = 0XFFFC0000;
  230. 		pmultiboot_memory_map->len  = 0x00040000;
  231. 		pmultiboot_memory_map->type = MULTIBOOT_MEMORY_RESERVED;
  232. 		pmultiboot_memory_map++;
  233. 	}
  235. 	next_avail_mem += pmultiboot_info->mmap_length;
  237. 	/* Set boot loader name */
  238. 	pmultiboot_info->boot_loader_name = next_avail_mem;
  239. 	strcpy((char *) next_avail_mem, boot_loader_name);
  240. 	/* next_avail_mem += (strlen(boot_loader_name) + 1); */
  242. 	/* Jump to kernel entry point */
  243. 	unsigned int magic = MULTIBOOT_BOOTLOADER_MAGIC;
  244. 	unsigned int dummy = 0;
  245. 	unsigned int multiboot_info_num = (unsigned int) pmultiboot_info;
  247. 	printf("Preparing trampoline...\n");
  249. 	/* The ramdrive needs to be written to a location that would overwrite this program.
  250. 	 * Therfore, the code that copies the ram drive and jumps to the kernel needs to be
  251. 	 * run from a safe location. So, we put that code into an array variable and
  252. 	 * copy the code (called a "trampoline") to a safe location and then jump to it.
  253. 	 * The 0x00000000 values below are place holders which are set below
  254. 	 */
  255. 	char trampoline[] = {
  256. 		0xBE, 0x00, 0x00, 0x00, 0x00,   /* mov esi, 0x00000000 */
  257. 		0xBF, 0x00, 0x00, 0x00, 0x00,   /* mov edi, 0x00000000 */
  258. 		0xB9, 0x00, 0x00, 0x00, 0x00,   /* mov ecx, 0x00000000 */
  259. 		0xFC,                           /* cld                 */
  260. 		0xF3, 0xA4,                     /* rep movsb           */
  261. 		0xB8, 0x00, 0x00, 0x00, 0x00,   /* mov eax, 0x00000000 */
  262. 		0xBB, 0x00, 0x00, 0x00, 0x00,   /* mov ebx, 0x00000000 */
  263. 		0xFB,                           /* sti                 */
  264. 		0xEA, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00  /* jmp far 0x0008:0x00000000 */
  265. 	};
  267. 	/* Set place holder values */
  268. 	*((unsigned int *) &trampoline[1])  = initrd_src;
  269. 	*((unsigned int *) &trampoline[6])  = 0x001C6000;
  270. 	*((unsigned int *) &trampoline[11]) = initrd_len;
  271. 	*((unsigned int *) &trampoline[19])  = magic;
  272. 	*((unsigned int *) &trampoline[24])  = multiboot_info_num;
  273. 	*((unsigned int *) &trampoline[30])  = e_entry;
  275. 	memcpy((void *)0x4000, trampoline, sizeof(trampoline));
  277. 	printf("kexec-fiwix: jumping to trampoline...\n");
  278. 	__asm__ __volatile__ (
  279. 		"ljmp $0x8, $0x00004000\n\t"
  280. 	);
  281. }