zircon/system/host/mkkdtb/mkkdtb.c

// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/* mkkdtb - packages kernel file and dtb in kdtb format, required by some
            bootloaders instead of just appending dtb to end of kernel.
*/

#include <assert.h>
#include <ctype.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    char magic[4];
    uint32_t kern_size;
    uint32_t dtb_size;
} kdtb_header_t;

int print_usage(void) {
    printf("mkkdtb kernfile dtbfile outfile\n");
    return 0;
}

int main(int argc, char** argv) {

    int retval = 0;

    uint8_t* kern_buffer = NULL;
    uint8_t* dtb_buffer = NULL;

    FILE* dtb_fd = NULL;
    FILE* out_fd = NULL;

    kdtb_header_t kheader = {"KDTB", 0, 0};

    if (argc < 4) {
        print_usage();
        return -1;
    }

    FILE* kernel_fd = fopen(argv[1], "r");
    if (!kernel_fd) {
        fprintf(stderr, "Kernel file not found\n");
        retval = -1;
        goto fail;
    }

    dtb_fd = fopen(argv[2], "r");
    if (!dtb_fd) {
        fprintf(stderr, "DTB file not found\n");
        retval = -1;
        goto fail;
    }

    out_fd = fopen(argv[3], "w");
    if (!out_fd) {
        fprintf(stderr, "Can't open output file\n");
        retval = -1;
        goto fail;
    }

    fseek(kernel_fd, 0, SEEK_END);
    kheader.kern_size = ftell(kernel_fd);
    fseek(kernel_fd, 0, SEEK_SET);

    fseek(dtb_fd, 0, SEEK_END);
    kheader.dtb_size = ftell(dtb_fd);
    fseek(dtb_fd, 0, SEEK_SET);

    kern_buffer = malloc(kheader.kern_size);
    if (!kern_buffer) {
        retval = -1;
        goto fail;
    }
    if (fread(kern_buffer, kheader.kern_size, 1, kernel_fd) != 1) {
        fprintf(stderr, "kernel read error\n");
        retval = -1;
        goto fail;
    }

    dtb_buffer = malloc(kheader.dtb_size);
    if (!dtb_buffer) {
        retval = -1;
        goto fail;
    }
    if (fread(dtb_buffer, kheader.dtb_size, 1, dtb_fd) != 1) {
        fprintf(stderr, "dtb read error\n");
        retval = -1;
        goto fail;
    }

    fwrite(&kheader, sizeof(kheader), 1, out_fd);
    fwrite(kern_buffer, sizeof(uint8_t), kheader.kern_size, out_fd);
    fwrite(dtb_buffer, sizeof(uint8_t), kheader.dtb_size, out_fd);

fail:
    if (kernel_fd)
        fclose(kernel_fd);
    if (dtb_fd)
        fclose(dtb_fd);
    if (out_fd)
        fclose(out_fd);
    if (kern_buffer)
        free(kern_buffer);
    if (dtb_buffer)
        free(dtb_buffer);
    return retval;
}