src/mkbrncmdline.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * mkbrncmdline.c - partially based on OpenWrt's wndr3700.c
   4  *
   5  * Copyright (C) 2011 Tobias Diedrich <ranma+openwrt@tdiedrich.de>
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stddef.h>
  11 #include <unistd.h>
  12 #include <errno.h>
  13 #include <fcntl.h>
  14 #include <sys/mman.h>
  15 #include <string.h>
  16 #include <netinet/in.h>
  17 #include <inttypes.h>
  18
  19 static void usage(const char *) __attribute__ (( __noreturn__ ));
  20
  21 static void usage(const char *mess)
  22 {
  23         fprintf(stderr, "Error: %s\n", mess);
  24         fprintf(stderr, "Usage: mkbrncmdline -i input_file -o output_file [-a loadaddress] arg1 [argx ...]\n");
  25         fprintf(stderr, "\n");
  26         exit(1);
  27 }
  28
  29 static char *input_file = NULL;
  30 static char *output_file = NULL;
  31 static unsigned loadaddr = 0x80002000;
  32
  33 static void parseopts(int *argc, char ***argv)
  34 {
  35         char *endptr;
  36         int res;
  37
  38         while ((res = getopt(*argc, *argv, "a:i:o:")) != -1) {
  39                 switch (res) {
  40                 default:
  41                         usage("Unknown option");
  42                         break;
  43                 case 'a':
  44                         loadaddr = strtoul(optarg, &endptr, 0);
  45                         if (endptr == optarg || *endptr != 0)
  46                                 usage("loadaddress must be a decimal or hexadecimal 32-bit value");
  47                         break;
  48                 case 'i':
  49                         input_file = optarg;
  50                         break;
  51                 case 'o':
  52                         output_file = optarg;
  53                         break;
  54                 }
  55         }
  56         *argc -= optind;
  57         *argv += optind;
  58 }
  59
  60 static void emitload(int outfd, int reg, unsigned value)
  61 {
  62         char buf[8] = {
  63                 0x3c, 0x04 + reg,
  64                 value >> 24, value >> 16,
  65                 0x34, 0x84 + reg + (reg << 5),
  66                 value >> 8, value,
  67         };
  68         if (write(outfd, buf, sizeof(buf)) != sizeof(buf)) {
  69                 fprintf(stderr, "write: %s\n", strerror(errno));
  70                 exit(1);
  71         }
  72 }
  73
  74 int main(int argc, char **argv)
  75 {
  76         int outfd;
  77         int i;
  78         int fd;
  79         size_t len, skip, buf_len;
  80         unsigned cmdline_addr;
  81         unsigned s_ofs;
  82         char *buf;
  83
  84         parseopts(&argc, &argv);
  85
  86         if (argc < 1)
  87                 usage("must specify at least one kernel cmdline argument");
  88
  89         if (input_file == NULL || output_file == NULL)
  90                 usage("must specify input and output file");
  91
  92         if ((outfd = open(output_file, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
  93         {
  94                 fprintf(stderr, "Error opening '%s' for writing: %s\n", output_file, strerror(errno));
  95                 exit(1);
  96         }
  97
  98         // mmap input_file
  99         if ((fd = open(input_file, O_RDONLY))  < 0
 100         || (len = lseek(fd, 0, SEEK_END)) < 0
 101         || (input_file = mmap(0, len, PROT_READ, MAP_SHARED, fd, 0)) == (void *) (-1)
 102         || close(fd) < 0)
 103         {
 104                 fprintf(stderr, "Error mapping file '%s': %s\n", input_file, strerror(errno));
 105                 exit(1);
 106         }
 107
 108         cmdline_addr = loadaddr + len;
 109
 110         // Kernel args are passed in registers a0,a1,a2 and a3
 111         emitload(outfd, 0, 0);              /* a0 = 0 */
 112         emitload(outfd, 1, 0);              /* a1 = 0 */
 113         emitload(outfd, 2, cmdline_addr);   /* a2 = &cmdline */
 114         emitload(outfd, 3, 0);              /* a3 = 0 */
 115         skip = lseek(outfd, 0, SEEK_END);
 116
 117         // write the kernel
 118         if (write(outfd, input_file + skip, len - skip) != len -skip) {
 119                 fprintf(stderr, "write: %s\n", strerror(errno));
 120                 exit(1);
 121         }
 122
 123         // write cmdline structure
 124         buf_len = (argc + 1) * 4;
 125         for (i=0; i<argc; i++) {
 126                 buf_len += strlen(argv[i]) + 1;
 127         }
 128         buf = malloc(buf_len + 16);
 129         if (!buf) {
 130                 fprintf(stderr, "Could not allocate memory for cmdline buffer\n");
 131                 exit(1);
 132         }
 133         memset(buf, 0, buf_len);
 134
 135         s_ofs = 4 * (argc + 1);
 136         for (i=0; i<argc; i++) {
 137                 unsigned s_ptr = cmdline_addr + s_ofs;
 138                 buf[i * 4 + 0] = s_ptr >> 24;
 139                 buf[i * 4 + 1] = s_ptr >> 16;
 140                 buf[i * 4 + 2] = s_ptr >>  8;
 141                 buf[i * 4 + 3] = s_ptr >>  0;
 142                 memcpy(&buf[s_ofs], argv[i], strlen(argv[i]));
 143                 s_ofs += strlen(argv[i]) + 1;
 144         }
 145         if (write(outfd, buf, buf_len) != buf_len) {
 146                 fprintf(stderr, "write: %s\n", strerror(errno));
 147                 exit(1);
 148         }
 149
 150
 151         munmap(input_file, len);
 152         close(outfd);
 153         free(buf);
 154
 155         return 0;
 156 }