• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/firmware-utils/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 }
157 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt