Annotation of sys/arch/mvme68k/stand/installboot/installboot.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: installboot.c,v 1.11 2007/06/17 00:28:56 deraadt Exp $ */
! 2: /* $NetBSD: installboot.c,v 1.5 1995/11/17 23:23:50 gwr Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1994 Paul Kranenburg
! 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. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed by Paul Kranenburg.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <sys/param.h>
! 35: #include <sys/mount.h>
! 36: #include <sys/time.h>
! 37: #include <sys/stat.h>
! 38: #include <sys/disklabel.h>
! 39: #include <ufs/ufs/dinode.h>
! 40: #include <ufs/ufs/dir.h>
! 41: #include <ufs/ffs/fs.h>
! 42: #include <err.h>
! 43: #include <a.out.h>
! 44: #include <fcntl.h>
! 45: #include <nlist.h>
! 46: #include <stdlib.h>
! 47: #include <stdio.h>
! 48: #include <string.h>
! 49: #include <unistd.h>
! 50: #include <util.h>
! 51:
! 52: int verbose, nowrite, hflag;
! 53: char *boot, *proto, *dev;
! 54: char cdev[80];
! 55:
! 56: struct nlist nl[] = {
! 57: #define X_BLOCK_SIZE 0
! 58: {"_block_size"},
! 59: #define X_BLOCK_COUNT 1
! 60: {"_block_count"},
! 61: #define X_BLOCK_TABLE 2
! 62: {"_block_table"},
! 63: {NULL}
! 64: };
! 65:
! 66: int *block_size_p; /* block size var. in prototype image */
! 67: int *block_count_p; /* block count var. in prototype image */
! 68: daddr_t *block_table; /* block number array in prototype image */
! 69: int maxblocknum; /* size of this array */
! 70:
! 71:
! 72: char *loadprotoblocks(char *, long *);
! 73: int loadblocknums(char *, int);
! 74: static void devread(int, void *, daddr_t, size_t, char *);
! 75: static void usage(void);
! 76: int main(int, char *[]);
! 77: static void vid_to_disklabel(char *, char *);
! 78:
! 79: static void
! 80: usage(void)
! 81: {
! 82: fprintf(stderr,
! 83: "usage: installboot [-n] [-v] [-h] <boot> <proto> <device>\n");
! 84: exit(1);
! 85: }
! 86:
! 87: int
! 88: main(argc, argv)
! 89: int argc;
! 90: char *argv[];
! 91: {
! 92: int c, devfd;
! 93: char *protostore;
! 94: long protosize;
! 95:
! 96: while ((c = getopt(argc, argv, "vnh")) != -1) {
! 97: switch (c) {
! 98: case 'h':
! 99: /* Don't strip a.out header */
! 100: hflag = 1;
! 101: break;
! 102: case 'n':
! 103: /* Do not actually write the bootblock to disk */
! 104: nowrite = 1;
! 105: break;
! 106: case 'v':
! 107: /* Chat */
! 108: verbose = 1;
! 109: break;
! 110: default:
! 111: usage();
! 112: }
! 113: }
! 114:
! 115: if (argc - optind < 3) {
! 116: usage();
! 117: }
! 118:
! 119: boot = argv[optind];
! 120: proto = argv[optind + 1];
! 121: dev = argv[optind + 2];
! 122: strlcpy(cdev, dev, sizeof cdev);
! 123: cdev[strlen(cdev)-1] = 'c';
! 124:
! 125: if (verbose) {
! 126: printf("boot: %s\n", boot);
! 127: printf("proto: %s\n", proto);
! 128: printf("device: %s\n", dev);
! 129: printf("cdevice: %s\n", cdev);
! 130: }
! 131:
! 132: /* Insert VID into disklabel */
! 133: vid_to_disklabel(cdev, proto);
! 134:
! 135: /* Load proto blocks into core */
! 136: if ((protostore = loadprotoblocks(proto, &protosize)) == NULL)
! 137: exit(1);
! 138:
! 139: /* XXX - Paranoia: Make sure size is aligned! */
! 140: if (protosize & (DEV_BSIZE - 1))
! 141: err(1, "proto bootblock bad size=%d", protosize);
! 142:
! 143: /* Open and check raw disk device */
! 144: if ((devfd = open(dev, O_RDONLY, 0)) < 0)
! 145: err(1, "open: %s", dev);
! 146:
! 147: /* Extract and load block numbers */
! 148: if (loadblocknums(boot, devfd) != 0)
! 149: exit(1);
! 150:
! 151: (void)close(devfd);
! 152:
! 153: if (nowrite)
! 154: return 0;
! 155:
! 156: /* Write patched proto bootblocks into the superblock */
! 157: if (protosize > SBSIZE - DEV_BSIZE)
! 158: errx(1, "proto bootblocks too big");
! 159:
! 160: if ((devfd = open(cdev, O_RDWR, 0)) < 0)
! 161: err(1, "open: %s", dev);
! 162:
! 163: if (lseek(devfd, DEV_BSIZE, SEEK_SET) != DEV_BSIZE)
! 164: err(1, "lseek bootstrap");
! 165:
! 166: /* Sync filesystems (to clean in-memory superblock?) */
! 167: sync();
! 168:
! 169: if (write(devfd, protostore, protosize) != protosize)
! 170: err(1, "write bootstrap");
! 171: (void)close(devfd);
! 172: return 0;
! 173: }
! 174:
! 175: char *
! 176: loadprotoblocks(fname, size)
! 177: char *fname;
! 178: long *size;
! 179: {
! 180: int fd;
! 181: size_t tdsize; /* text+data size */
! 182: size_t bbsize; /* boot block size (block aligned) */
! 183: char *bp;
! 184: struct nlist *nlp;
! 185: struct exec eh;
! 186: long off;
! 187:
! 188: fd = -1;
! 189: bp = NULL;
! 190:
! 191: /* Locate block number array in proto file */
! 192: if (nlist(fname, nl) != 0) {
! 193: warnx("nlist: %s: symbols not found", fname);
! 194: return NULL;
! 195: }
! 196: /* Validate symbol types (global data). */
! 197: for (nlp = nl; nlp->n_un.n_name; nlp++) {
! 198: if (nlp->n_type != (N_DATA | N_EXT)) {
! 199: warnx("nlist: %s: wrong type", nlp->n_un.n_name);
! 200: return NULL;
! 201: }
! 202: }
! 203:
! 204: if ((fd = open(fname, O_RDONLY)) < 0) {
! 205: warn("open: %s", fname);
! 206: return NULL;
! 207: }
! 208: if (read(fd, &eh, sizeof(eh)) != sizeof(eh)) {
! 209: warn("read: %s", fname);
! 210: goto bad;
! 211: }
! 212: if (N_GETMAGIC(eh) != OMAGIC) {
! 213: warn("bad magic: 0x%x", eh.a_midmag);
! 214: goto bad;
! 215: }
! 216: /*
! 217: * We have to include the exec header in the beginning of
! 218: * the buffer, and leave extra space at the end in case
! 219: * the actual write to disk wants to skip the header.
! 220: */
! 221: tdsize = eh.a_text + eh.a_data;
! 222: bbsize = tdsize + sizeof(eh);
! 223: bbsize = roundup(bbsize, DEV_BSIZE);
! 224:
! 225: /*
! 226: * Allocate extra space here because the caller may copy
! 227: * the boot block starting at the end of the exec header.
! 228: * This prevents reading beyond the end of the buffer.
! 229: */
! 230: if ((bp = calloc(bbsize + sizeof(eh), 1)) == NULL) {
! 231: warnx("malloc: %s: no memory", fname);
! 232: goto bad;
! 233: }
! 234: /* Copy the exec header and read the rest of the file. */
! 235: memcpy(bp, &eh, sizeof(eh));
! 236: if (read(fd, bp+sizeof(eh), tdsize) != tdsize) {
! 237: warn("read: %s", fname);
! 238: goto bad;
! 239: }
! 240:
! 241: *size = bbsize; /* aligned to DEV_BSIZE */
! 242:
! 243: /* Calculate the symbols' locations within the proto file */
! 244: off = N_DATOFF(eh) - N_DATADDR(eh) - (eh.a_entry - N_TXTADDR(eh));
! 245: block_size_p = (int *) (bp + nl[X_BLOCK_SIZE ].n_value + off);
! 246: block_count_p = (int *) (bp + nl[X_BLOCK_COUNT].n_value + off);
! 247: block_table = (daddr_t *) (bp + nl[X_BLOCK_TABLE].n_value + off);
! 248: maxblocknum = *block_count_p;
! 249:
! 250: if (verbose) {
! 251: printf("%s: entry point %#x\n", fname, eh.a_entry);
! 252: printf("proto bootblock size %ld\n", *size);
! 253: printf("room for %d filesystem blocks at %#x\n",
! 254: maxblocknum, nl[X_BLOCK_TABLE].n_value);
! 255: }
! 256:
! 257: close(fd);
! 258: if (!hflag)
! 259: bp += sizeof(struct exec);
! 260: return bp;
! 261:
! 262: bad:
! 263: if (bp)
! 264: free(bp);
! 265: if (fd >= 0)
! 266: close(fd);
! 267: return NULL;
! 268: }
! 269:
! 270: static void
! 271: devread(int fd, void *buf, daddr_t blk, size_t size, char *msg)
! 272: {
! 273: if (lseek(fd, dbtob(blk), SEEK_SET) != dbtob(blk))
! 274: err(1, "%s: devread: lseek", msg);
! 275:
! 276: if (read(fd, buf, size) != size)
! 277: err(1, "%s: devread: read", msg);
! 278: }
! 279:
! 280: static char sblock[SBSIZE];
! 281:
! 282: int
! 283: loadblocknums(char *boot, int devfd)
! 284: {
! 285: int i, fd;
! 286: struct stat statbuf;
! 287: struct statfs statfsbuf;
! 288: struct fs *fs;
! 289: char *buf;
! 290: daddr_t blk, *ap;
! 291: struct ufs1_dinode *ip;
! 292: int ndb;
! 293:
! 294: /*
! 295: * Open 2nd-level boot program and record the block numbers
! 296: * it occupies on the filesystem represented by `devfd'.
! 297: */
! 298:
! 299: /* Make sure the (probably new) boot file is on disk. */
! 300: sync(); sleep(1);
! 301:
! 302: if ((fd = open(boot, O_RDONLY)) < 0)
! 303: err(1, "open: %s", boot);
! 304:
! 305: if (fstatfs(fd, &statfsbuf) != 0)
! 306: err(1, "statfs: %s", boot);
! 307:
! 308: if (strncmp(statfsbuf.f_fstypename, "ffs", MFSNAMELEN) &&
! 309: strncmp(statfsbuf.f_fstypename, "ufs", MFSNAMELEN) ) {
! 310: errx(1, "%s: must be on an FFS filesystem", boot);
! 311: }
! 312:
! 313: if (fsync(fd) != 0)
! 314: err(1, "fsync: %s", boot);
! 315:
! 316: if (fstat(fd, &statbuf) != 0)
! 317: err(1, "fstat: %s", boot);
! 318:
! 319: close(fd);
! 320:
! 321: /* Read superblock */
! 322: devread(devfd, sblock, SBLOCK, SBSIZE, "superblock");
! 323: fs = (struct fs *)sblock;
! 324:
! 325: /* Sanity-check super-block. */
! 326:
! 327: if (fs->fs_magic != FS_MAGIC)
! 328: errx(1, "Bad magic number in superblock");
! 329:
! 330: if (fs->fs_inopb <= 0)
! 331: err(1, "Bad inopb=%d in superblock", fs->fs_inopb);
! 332:
! 333: /* Read inode */
! 334: if ((buf = malloc(fs->fs_bsize)) == NULL)
! 335: errx(1, "No memory for filesystem block");
! 336:
! 337: blk = fsbtodb(fs, ino_to_fsba(fs, statbuf.st_ino));
! 338: devread(devfd, buf, blk, fs->fs_bsize, "inode");
! 339: ip = (struct ufs1_dinode *)(buf) + ino_to_fsbo(fs, statbuf.st_ino);
! 340:
! 341: /*
! 342: * Have the inode. Figure out how many blocks we need.
! 343: */
! 344: ndb = howmany(ip->di_size, fs->fs_bsize);
! 345: if (ndb > maxblocknum)
! 346: errx(1, "Too many blocks");
! 347: *block_count_p = ndb;
! 348: *block_size_p = fs->fs_bsize;
! 349: if (verbose)
! 350: printf("Will load %d blocks of size %d each.\n",
! 351: ndb, fs->fs_bsize);
! 352:
! 353: /*
! 354: * Get the block numbers; we don't handle fragments
! 355: */
! 356: ap = ip->di_db;
! 357: for (i = 0; i < NDADDR && *ap && ndb; i++, ap++, ndb--) {
! 358: blk = fsbtodb(fs, *ap);
! 359: if (verbose)
! 360: printf("%d: %d\n", i, blk);
! 361: block_table[i] = blk;
! 362: }
! 363: if (ndb == 0)
! 364: return 0;
! 365:
! 366: /*
! 367: * Just one level of indirections; there isn't much room
! 368: * for more in the 1st-level bootblocks anyway.
! 369: */
! 370: blk = fsbtodb(fs, ip->di_ib[0]);
! 371: devread(devfd, buf, blk, fs->fs_bsize, "indirect block");
! 372: ap = (daddr_t *)buf;
! 373: for (; i < NINDIR(fs) && *ap && ndb; i++, ap++, ndb--) {
! 374: blk = fsbtodb(fs, *ap);
! 375: if (verbose)
! 376: printf("%d: %d\n", i, blk);
! 377: block_table[i] = blk;
! 378: }
! 379:
! 380: return 0;
! 381: }
! 382:
! 383: static void
! 384: vid_to_disklabel(char *dkname, char *bootproto)
! 385: {
! 386: char *specname;
! 387: int exe_file, f;
! 388: struct mvmedisklabel *pcpul;
! 389: struct stat stat;
! 390: unsigned int exe_addr;
! 391: unsigned short exe_addr_u;
! 392: unsigned short exe_addr_l;
! 393:
! 394: pcpul = (struct mvmedisklabel *)malloc(sizeof(struct mvmedisklabel));
! 395: bzero(pcpul, sizeof(struct mvmedisklabel));
! 396:
! 397: if (verbose)
! 398: printf("modifying vid.\n");
! 399:
! 400: exe_file = open(bootproto, O_RDONLY, 0444);
! 401: if (exe_file == -1) {
! 402: perror(bootproto);
! 403: exit(2);
! 404: }
! 405:
! 406: f = opendev(dkname, O_RDWR, OPENDEV_PART, &specname);
! 407:
! 408: if (lseek(f, 0, SEEK_SET) < 0 ||
! 409: read(f, pcpul, sizeof(struct mvmedisklabel)) <
! 410: sizeof(struct mvmedisklabel))
! 411: err(4, "%s", specname);
! 412:
! 413:
! 414: pcpul->version = 1;
! 415: strncpy(pcpul->vid_id, "M68K", 4);
! 416:
! 417: fstat(exe_file, &stat);
! 418:
! 419: /* size in 256 byte blocks round up after a.out header removed */
! 420:
! 421: pcpul->vid_oss = 2;
! 422: pcpul->vid_osl = (((stat.st_size -0x20) +511) / 512) *2;
! 423:
! 424: lseek(exe_file, 0x14, SEEK_SET);
! 425: read(exe_file, &exe_addr, 4);
! 426:
! 427: /* check this, it may not work in both endian. */
! 428: /* No, it doesn't. Use a big endian machine for now. SPM */
! 429:
! 430: {
! 431: union {
! 432: struct s {
! 433: unsigned short s1;
! 434: unsigned short s2;
! 435: } s;
! 436: unsigned long l;
! 437: } a;
! 438: a.l = exe_addr;
! 439: pcpul->vid_osa_u = a.s.s1;
! 440: pcpul->vid_osa_l = a.s.s2;
! 441:
! 442: }
! 443: pcpul->vid_cas = 1;
! 444: pcpul->vid_cal = 1;
! 445:
! 446: /* do not want to write past end of structure, not null terminated */
! 447:
! 448: strncpy(pcpul->vid_mot, "MOTOROLA", 8);
! 449:
! 450: pcpul->cfg_rec = 0x100;
! 451: pcpul->cfg_psm = 0x200;
! 452:
! 453: if (!nowrite) {
! 454: if (lseek(f, 0, SEEK_SET) < 0 ||
! 455: write(f, pcpul, sizeof(struct mvmedisklabel)) <
! 456: sizeof(struct mvmedisklabel))
! 457: err(4, "%s", specname);
! 458: }
! 459: free(pcpul);
! 460:
! 461: close(exe_file);
! 462: close(f);
! 463: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to installboot.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mvme68k / stand / installboot