compress symfile

Author: braindigitalis

cmake/custom_targets.cmake

@@ -177,7 +177,7 @@ function(symbols TARGETFILE SOURCEFILE)
     set(FILENAME "${CMAKE_BINARY_DIR}/iso/kernel.bin")
     set(OUTNAME "${CMAKE_BINARY_DIR}/iso/${TARGETFILE}")
     add_custom_command(OUTPUT ${OUTNAME}
-        COMMAND /bin/nm -a "${CMAKE_BINARY_DIR}/iso/kernel.bin" | sort -d > "${CMAKE_BINARY_DIR}/iso/kernel.sym"
+        COMMAND /bin/nm -a "${CMAKE_BINARY_DIR}/iso/kernel.bin" | sort -d | gzip -c > "${CMAKE_BINARY_DIR}/iso/kernel.sym"
         DEPENDS ${FILENAME})
     add_custom_target(SYMBOLS ALL DEPENDS ${OUTNAME})
     add_dependencies(SYMBOLS "kernel.bin")

include/ramdisk.h

@@ -56,6 +56,25 @@ const char* init_ramdisk_from_storage(const char* storage);
  */
 const char* init_ramdisk_from_memory(uint8_t* memory, size_t blocks, size_t blocksize);
 
+/**
+ * @brief Decompress a gzip-compressed memory buffer.
+ *
+ * Reads a gzip stream from @p compressed_image of length @p compressed_size
+ * and produces a newly allocated buffer containing the uncompressed data.
+ * On success, @p out and @p out_size are set to the buffer pointer and its
+ * length in bytes.
+ *
+ * @param compressed_image  Pointer to gzip-compressed input data.
+ * @param compressed_size   Size of the compressed input in bytes.
+ * @param out               Address of a pointer updated to the decompressed buffer.
+ * @param out_size          Address of a variable updated with the decompressed size.
+ *
+ * @return true if decompression succeeds, false on error.
+ *
+ * @note The caller is responsible for freeing the buffer assigned to @p out.
+ */
+bool decompress_gzip(uint8_t *compressed_image, size_t compressed_size, uint8_t** out, uint32_t* out_size);
+
 /**
  * @brief Inflate and mount the initial ramdisk supplied by the bootloader
  *

src/block/ramdisk.c

@@ -219,33 +219,29 @@ static void zlib_free(voidpf opaque, voidpf addr) {
 	}
 }
 
-bool mount_initial_ramdisk(uint8_t *compressed_image, size_t compressed_size) {
+bool decompress_gzip(uint8_t *compressed_image, size_t compressed_size, uint8_t** out, uint32_t* out_size) {
 	if (compressed_image == NULL) {
-		preboot_fail("Invalid ramdisk argument");
+		return false;
 	}
 
 	if (compressed_size < 18) {
-		preboot_fail("Compressed ramdisk is too small");
+		return false;
 	}
 
 	if (!(compressed_image[0] == 0x1F && compressed_image[1] == 0x8B && compressed_image[2] == 0x08)) {
-		preboot_fail("Compressed ramdisk is not a gzip stream");
+		return false;
 	}
 
 	const uint8_t *tail = compressed_image + compressed_size - 4;
-	const uint32_t isize =
-		(uint32_t) tail[0] |
-		((uint32_t) tail[1] << 8) |
-		((uint32_t) tail[2] << 16) |
-		((uint32_t) tail[3] << 24);
+	*out_size = (uint32_t) tail[0] | ((uint32_t) tail[1] << 8) | ((uint32_t) tail[2] << 16) | ((uint32_t) tail[3] << 24);
 
-	if (isize == 0) {
-		preboot_fail("Compressed ramdisk uncompressed size is zero (corrupt gzip?)");
+	if (*out_size == 0) {
+		return false;
 	}
 
-	void *out = kmalloc((size_t) isize);
-	if (out == NULL) {
-		preboot_fail("Out of memory allocating ramdisk buffer");
+	*out = kmalloc(*out_size);
+	if (*out == NULL) {
+		return false;
 	}
 
 	z_stream zs;
@@ -255,34 +251,43 @@ bool mount_initial_ramdisk(uint8_t *compressed_image, size_t compressed_size) {
 	zs.opaque = Z_NULL;
 	zs.next_in = (Bytef *) compressed_image;
 	zs.avail_in = (uInt) compressed_size;
-	zs.next_out = (Bytef *) out;
-	zs.avail_out = (uInt) isize;
+	zs.next_out = (Bytef *) *out;
+	zs.avail_out = (uInt) *out_size;
 
 	int rc = inflateInit2(&zs, 16 + MAX_WBITS);
 	if (rc != Z_OK) {
-		preboot_fail("inflateInit2 failed when extracting initial ramdisk");
+		kfree(*out);
+		return false;
 	}
-
 	rc = inflate(&zs, Z_FINISH);
 	if (rc != Z_STREAM_END) {
 		inflateEnd(&zs);
-		preboot_fail("inflate failed when extracting initial ramdisk");
+		kfree(*out);
+		return false;
 	}
-
 	const size_t out_len = (size_t) zs.total_out;
 	inflateEnd(&zs);
-
 	if (out_len == 0) {
-		preboot_fail("Decompressed ramdisk length is zero");
+		kfree(*out);
+		return false;
+	}
+	return true;
+}
+
+bool mount_initial_ramdisk(uint8_t *compressed_image, size_t compressed_size) {
+
+	uint32_t isize;
+	uint8_t* out;
+	if (!decompress_gzip(compressed_image, compressed_size, &out, &isize)) {
+		preboot_fail("Failed to decompress initial ramdisk");
 	}
 
 	const size_t block_size = 2048;
-	if ((out_len % block_size) != 0) {
+	if ((isize % block_size) != 0) {
 		preboot_fail("Ramdisk is not an integer multiple of 2048 bytes");
 	}
 
-	const size_t blocks = out_len / block_size;
-
+	const size_t blocks = isize / block_size;
 	const char *rd_name = init_ramdisk_from_memory((uint8_t *) out, blocks, block_size);
 	if (rd_name == NULL) {
 		preboot_fail("Failed to register initial ramdisk device");

src/debugger.c

@@ -93,12 +93,19 @@ bool find_limine_module(const char* name, uint8_t** content, size_t* size) {
 
 void init_debug()
 {
+	unsigned char* c_ptr = NULL;
+	size_t c_filesize = 0;
 	unsigned char* ptr = NULL;
-	size_t filesize = 0;
-	if (!find_limine_module("/kernel.sym", &ptr, &filesize)) {
+	uint32_t filesize = 0;
+	if (!find_limine_module("/kernel.sym", &c_ptr, &c_filesize)) {
 		symbol_fail();
 		return;
 	}
+	if (!decompress_gzip(c_ptr, c_filesize, &ptr, &filesize)) {
+		symbol_fail();
+		return;
+	}
+
 	char symbol_address[32];
 	char type[2];
 	char symbol[1024];
@@ -169,7 +176,7 @@ void init_debug()
 	setforeground(COLOUR_LIGHTYELLOW);
 	kprintf("/kernel.sym ");
 	setforeground(COLOUR_WHITE);
-	kprintf("(%ld bytes)\n", filesize);
+	kprintf("(%d bytes)\n", filesize);
 }
 
 const char* findsymbol(uint64_t address, uint64_t* offset) {