external/gpl3/binutils/usr.sbin/mdsetimage/mdsetimage.c

   1 /* $NetBSD: mdsetimage.c,v 1.2 2010/11/06 16:03:23 uebayasi Exp $ */
   2 /* from: NetBSD: mdsetimage.c,v 1.15 2001/03/21 23:46:48 cgd Exp $ */
   3
   4 /*
   5  * Copyright (c) 1996, 2002 Christopher G. Demetriou
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * <<Id: LICENSE_GC,v 1.1 2001/10/01 23:24:05 cgd Exp>>
  31  */
  32
  33 #if HAVE_NBTOOL_CONFIG_H
  34 #include "nbtool_config.h"
  35 #endif
  36
  37 #include <sys/cdefs.h>
  38 #if !defined(lint)
  39 __COPYRIGHT("@(#) Copyright (c) 1996\
  40  Christopher G. Demetriou.  All rights reserved.");
  41 __RCSID("$NetBSD: mdsetimage.c,v 1.2 2010/11/06 16:03:23 uebayasi Exp $");
  42 #endif /* not lint */
  43
  44 #include <sys/types.h>
  45 #include <sys/mman.h>
  46 #include <sys/stat.h>
  47
  48 #include <err.h>
  49 #include <fcntl.h>
  50 #include <limits.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <unistd.h>
  54 #include <string.h>
  55
  56 #include <bfd.h>
  57
  58 struct symbols {
  59         char *name;
  60         size_t offset;
  61 };
  62 #define X_MD_ROOT_IMAGE 0
  63 #define X_MD_ROOT_SIZE  1
  64
  65 #define CHUNKSIZE       (64 * 1024)
  66
  67 int             main(int, char *[]);
  68 static void     usage(void) __attribute__((noreturn));
  69 static int      find_md_root(bfd *, struct symbols symbols[]);
  70
  71 int     verbose;
  72 int     extract;
  73 int     setsize;
  74
  75 static const char *progname;
  76 #undef setprogname
  77 #define setprogname(x)  (void)(progname = (x))
  78 #undef getprogname
  79 #define getprogname()   (progname)
  80
  81 int
  82 main(int argc, char *argv[])
  83 {
  84         int ch, kfd, fsfd, rv;
  85         struct stat ksb, fssb;
  86         size_t md_root_offset, md_root_size_offset;
  87         u_int32_t md_root_size;
  88         const char *kfile, *fsfile;
  89         char *mappedkfile;
  90         char *bfdname = NULL;
  91         bfd *abfd;
  92         ssize_t left_to_copy;
  93         struct symbols md_root_symbols[3] = { { 0 } };
  94
  95         md_root_symbols[X_MD_ROOT_IMAGE].name = "_md_root_image";
  96         md_root_symbols[X_MD_ROOT_SIZE].name = "_md_root_size";
  97
  98         setprogname(argv[0]);
  99
 100         while ((ch = getopt(argc, argv, "I:S:b:svx")) != -1)
 101                 switch (ch) {
 102                 case 'I':
 103                         md_root_symbols[X_MD_ROOT_IMAGE].name = optarg;
 104                         break;
 105                 case 'S':
 106                         md_root_symbols[X_MD_ROOT_SIZE].name = optarg;
 107                         break;
 108                 case 'b':
 109                         bfdname = optarg;
 110                         break;
 111                 case 's':
 112                         setsize = 1;
 113                         break;
 114                 case 'v':
 115                         verbose = 1;
 116                         break;
 117                 case 'x':
 118                         extract = 1;
 119                         break;
 120                 case '?':
 121                 default:
 122                         usage();
 123         }
 124         argc -= optind;
 125         argv += optind;
 126
 127         if (argc != 2)
 128                 usage();
 129         kfile = argv[0];
 130         fsfile = argv[1];
 131
 132         if (extract) {
 133                 if ((kfd = open(kfile, O_RDONLY, 0))  == -1)
 134                         err(1, "open %s", kfile);
 135         } else {
 136                 if ((kfd = open(kfile, O_RDWR, 0))  == -1)
 137                         err(1, "open %s", kfile);
 138         }
 139
 140         bfd_init();
 141         if ((abfd = bfd_fdopenr(kfile, bfdname, kfd)) == NULL) {
 142                 bfd_perror("open");
 143                 exit(1);
 144         }
 145         if (!bfd_check_format(abfd, bfd_object)) {
 146                 bfd_perror("check format");
 147                 exit(1);
 148         }
 149
 150         if (find_md_root(abfd, md_root_symbols) != 0)
 151                 errx(1, "could not find symbols in %s", kfile);
 152         if (verbose)
 153                 fprintf(stderr, "got symbols from %s\n", kfile);
 154
 155         if (fstat(kfd, &ksb) == -1)
 156                 err(1, "fstat %s", kfile);
 157         if (ksb.st_size != (size_t)ksb.st_size)
 158                 errx(1, "%s too big to map", kfile);
 159
 160         if ((mappedkfile = mmap(NULL, ksb.st_size, PROT_READ,
 161             MAP_FILE | MAP_PRIVATE, kfd, 0)) == (caddr_t)-1)
 162                 err(1, "mmap %s", kfile);
 163         if (verbose)
 164                 fprintf(stderr, "mapped %s\n", kfile);
 165
 166         md_root_offset = md_root_symbols[X_MD_ROOT_IMAGE].offset;
 167         md_root_size_offset = md_root_symbols[X_MD_ROOT_SIZE].offset;
 168         md_root_size = bfd_get_32(abfd, &mappedkfile[md_root_size_offset]);
 169
 170         munmap(mappedkfile, ksb.st_size);
 171
 172         if (extract) {
 173                 if ((fsfd = open(fsfile, O_WRONLY|O_CREAT, 0777)) == -1)
 174                         err(1, "open %s", fsfile);
 175                 left_to_copy = md_root_size;
 176         } else {
 177                 if ((fsfd = open(fsfile, O_RDONLY, 0)) == -1)
 178                         err(1, "open %s", fsfile);
 179                 if (fstat(fsfd, &fssb) == -1)
 180                         err(1, "fstat %s", fsfile);
 181                 if (fssb.st_size != (size_t)fssb.st_size)
 182                         errx(1, "fs image is too big");
 183                 if (fssb.st_size > md_root_size)
 184                         errx(1, "fs image (%lld bytes) too big for buffer (%lu bytes)",
 185                             (long long)fssb.st_size, (unsigned long)md_root_size);
 186                 left_to_copy = fssb.st_size;
 187         }
 188
 189         if (verbose)
 190                 fprintf(stderr, "copying image %s %s %s\n", fsfile,
 191                     (extract ? "from" : "into"), kfile);
 192
 193         if (lseek(kfd, md_root_offset, SEEK_SET) != md_root_offset)
 194                 err(1, "seek %s", kfile);
 195         while (left_to_copy > 0) {
 196                 char buf[CHUNKSIZE];
 197                 ssize_t todo;
 198                 int rfd;
 199                 int wfd;
 200                 const char *rfile;
 201                 const char *wfile;
 202                 if (extract) {
 203                         rfd = kfd;
 204                         rfile = kfile;
 205                         wfd = fsfd;
 206                         wfile = fsfile;
 207                 } else {
 208                         rfd = fsfd;
 209                         rfile = fsfile;
 210                         wfd = kfd;
 211                         wfile = kfile;
 212                 }
 213
 214                 todo = (left_to_copy > CHUNKSIZE) ? CHUNKSIZE : left_to_copy;
 215                 if ((rv = read(rfd, buf, todo)) != todo) {
 216                         if (rv == -1)
 217                                 err(1, "read %s", rfile);
 218                         else
 219                                 errx(1, "unexpected EOF reading %s", rfile);
 220                 }
 221                 if ((rv = write(wfd, buf, todo)) != todo) {
 222                         if (rv == -1)
 223                                 err(1, "write %s", wfile);
 224                         else
 225                                 errx(1, "short write writing %s", wfile);
 226                 }
 227                 left_to_copy -= todo;
 228         }
 229         if (verbose)
 230                 fprintf(stderr, "done copying image\n");
 231         if (setsize && !extract) {
 232                 char buf[sizeof(uint32_t)];
 233
 234                 if (verbose)
 235                         fprintf(stderr, "setting md_root_size to %llu\n",
 236                             (unsigned long long) fssb.st_size);
 237                 if (lseek(kfd, md_root_size_offset, SEEK_SET) !=
 238                     md_root_size_offset)
 239                         err(1, "seek %s", kfile);
 240                 bfd_put_32(abfd, fssb.st_size, buf);
 241                 if (write(kfd, buf, sizeof(buf)) != sizeof(buf))
 242                         err(1, "write %s", kfile);
 243         }
 244
 245         close(fsfd);
 246         close(kfd);
 247
 248         if (verbose)
 249                 fprintf(stderr, "exiting\n");
 250
 251         bfd_close_all_done(abfd);
 252         exit(0);
 253 }
 254
 255 static void
 256 usage(void)
 257 {
 258         const char **list;
 259
 260         fprintf(stderr,
 261             "usage: %s [-svx] [-b bfdname] kernel image\n",
 262             getprogname());
 263         fprintf(stderr, "supported targets:");
 264         for (list = bfd_target_list(); *list != NULL; list++)
 265                 fprintf(stderr, " %s", *list);
 266         fprintf(stderr, "\n");
 267         exit(1);
 268 }
 269
 270 static int
 271 find_md_root(bfd *abfd, struct symbols symbols[])
 272 {
 273         long i;
 274         long storage_needed;
 275         long number_of_symbols;
 276         asymbol **symbol_table = NULL;
 277         struct symbols *s;
 278
 279         storage_needed = bfd_get_symtab_upper_bound(abfd);
 280         if (storage_needed <= 0)
 281                 return (1);
 282
 283         symbol_table = (asymbol **)malloc(storage_needed);
 284         if (symbol_table == NULL)
 285                 return (1);
 286
 287         number_of_symbols = bfd_canonicalize_symtab(abfd, symbol_table);
 288         if (number_of_symbols <= 0) {
 289                 free(symbol_table);
 290                 return (1);
 291         }
 292
 293         for (i = 0; i < number_of_symbols; i++) {
 294                 for (s = symbols; s->name != NULL; s++) {
 295                         const char *sym = symbol_table[i]->name;
 296
 297                         /*
 298                          * match symbol prefix '_' or ''.
 299                          */
 300                         if (!strcmp(s->name, sym) ||
 301                             !strcmp(s->name + 1, sym)) {
 302                                 s->offset =
 303                                     (size_t)(symbol_table[i]->section->filepos
 304                                     + symbol_table[i]->value);
 305                         }
 306                 }
 307         }
 308
 309         free(symbol_table);
 310
 311         for (s = symbols; s->name != NULL; s++) {
 312                 if (s->offset == 0)
 313                         return (1);
 314         }
 315
 316         return (0);
 317 }