/* $NetBSD: alpha.c,v 1.15 2003/10/27 00:12:44 lukem Exp $ */ /*- * Copyright (c) 2002 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Luke Mewburn of Wasabi Systems. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the NetBSD * Foundation, Inc. and its contributors. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * Copyright (c) 1999 Ross Harvey. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Ross Harvey * for the NetBSD Project. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * Copyright (c) 1999 Christopher G. Demetriou. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Christopher G. Demetriou * for the NetBSD Project. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #if HAVE_NBTOOL_CONFIG_H #include "nbtool_config.h" #endif #include #if !defined(__lint) __RCSID("$NetBSD: alpha.c,v 1.15 2003/10/27 00:12:44 lukem Exp $"); #endif /* !__lint */ #include #include #include #include #include #include #include #include #include "installboot.h" #define SUN_DKMAGIC 55998 /* XXX: from */ static void resum(ib_params *, struct alpha_boot_block * const bb, uint16_t *bb16); static void sun_bootstrap(ib_params *, struct alpha_boot_block * const); static void check_sparc(const struct alpha_boot_block * const, const char *); int alpha_clearboot(ib_params *params) { struct alpha_boot_block bb; uint64_t cksum; ssize_t rv; assert(params != NULL); assert(params->fsfd != -1); assert(params->filesystem != NULL); assert(sizeof(struct alpha_boot_block) == ALPHA_BOOT_BLOCK_BLOCKSIZE); if (params->flags & (IB_STAGE1START | IB_APPEND)) { warnx("Can't use `-b bno' or `-o append' with `-c'"); return (0); } rv = pread(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET); if (rv == -1) { warn("Reading `%s'", params->filesystem); return (0); } else if (rv != sizeof(bb)) { warnx("Reading `%s': short read", params->filesystem); return (0); } ALPHA_BOOT_BLOCK_CKSUM(&bb, &cksum); if (cksum != bb.bb_cksum) { // XXX check bb_cksum endian? warnx( "Old boot block checksum invalid (was %#llx, calculated %#llx)", (unsigned long long)bb.bb_cksum, (unsigned long long)cksum); warnx("Boot block invalid"); return (0); } if (params->flags & IB_VERBOSE) { printf("Old bootstrap start sector: %llu\n", (unsigned long long)le64toh(bb.bb_secstart)); printf("Old bootstrap size: %llu\n", (unsigned long long)le64toh(bb.bb_secsize)); printf("Old bootstrap checksum: %#llx\n", (unsigned long long)bb.bb_cksum); } bb.bb_secstart = bb.bb_secsize = bb.bb_flags = 0; ALPHA_BOOT_BLOCK_CKSUM(&bb, &bb.bb_cksum); if (params->flags & IB_SUNSUM) sun_bootstrap(params, &bb); printf("New bootstrap start sector: %llu\n", (unsigned long long)le64toh(bb.bb_secstart)); printf("New bootstrap size: %llu\n", (unsigned long long)le64toh(bb.bb_secsize)); printf("New bootstrap checksum: %#llx\n", (unsigned long long)bb.bb_cksum); if (params->flags & IB_VERBOSE) printf("%slearing boot block\n", (params->flags & IB_NOWRITE) ? "Not c" : "C"); if (params->flags & IB_NOWRITE) return (1); rv = pwrite(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET); if (rv == -1) { warn("Writing `%s'", params->filesystem); return (0); } else if (rv != sizeof(bb)) { warnx("Writing `%s': short write", params->filesystem); return (0); } return (1); } int alpha_setboot(ib_params *params) { struct alpha_boot_block bb; uint64_t startblock; int retval; char *bootstrapbuf; size_t bootstrapsize; ssize_t rv; assert(params != NULL); assert(params->fsfd != -1); assert(params->filesystem != NULL); assert(params->s1fd != -1); assert(params->stage1 != NULL); assert(sizeof(struct alpha_boot_block) == ALPHA_BOOT_BLOCK_BLOCKSIZE); retval = 0; bootstrapbuf = NULL; /* * Allocate a buffer, with space to round up the input file * to the next block size boundary, and with space for the boot * block. */ bootstrapsize = roundup(params->s1stat.st_size, ALPHA_BOOT_BLOCK_BLOCKSIZE); bootstrapbuf = malloc(bootstrapsize); if (bootstrapbuf == NULL) { warn("Allocating %lu bytes", (unsigned long) bootstrapsize); goto done; } memset(bootstrapbuf, 0, bootstrapsize); /* read the file into the buffer */ rv = pread(params->s1fd, bootstrapbuf, params->s1stat.st_size, 0); if (rv == -1) { warn("Reading `%s'", params->stage1); return (0); } else if (rv != params->s1stat.st_size) { warnx("Reading `%s': short read", params->stage1); return (0); } rv = pread(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET); if (rv == -1) { warn("Reading `%s'", params->filesystem); goto done; } else if (rv != sizeof(bb)) { warnx("Reading `%s': short read", params->filesystem); goto done; } if (params->flags & IB_SUNSUM) check_sparc(&bb, "Initial"); /* fill in the updated bootstrap fields */ if (params->flags & IB_APPEND) { struct stat filesyssb; if (fstat(params->fsfd, &filesyssb) == -1) { warn("Examining `%s'", params->filesystem); goto done; } if (!S_ISREG(filesyssb.st_mode)) { warnx( "`%s' must be a regular file to append a bootstrap", params->filesystem); goto done; } startblock = howmany(filesyssb.st_size, ALPHA_BOOT_BLOCK_BLOCKSIZE); } else if (params->flags & IB_STAGE1START) { startblock = params->s1start; } else { startblock = ALPHA_BOOT_BLOCK_OFFSET / ALPHA_BOOT_BLOCK_BLOCKSIZE + 1; } bb.bb_secsize = htole64(howmany(params->s1stat.st_size, ALPHA_BOOT_BLOCK_BLOCKSIZE)); bb.bb_secstart = htole64(startblock); bb.bb_flags = 0; ALPHA_BOOT_BLOCK_CKSUM(&bb, &bb.bb_cksum); if (params->flags & IB_SUNSUM) sun_bootstrap(params, &bb); if (params->flags & IB_VERBOSE) { printf("Bootstrap start sector: %llu\n", (unsigned long long)startblock); printf("Bootstrap sector count: %llu\n", (unsigned long long)le64toh(bb.bb_secsize)); printf("New boot block checksum: %#llx\n", (unsigned long long)bb.bb_cksum); printf("%sriting bootstrap\n", (params->flags & IB_NOWRITE) ? "Not w" : "W"); } if (params->flags & IB_NOWRITE) { retval = 1; goto done; } rv = pwrite(params->fsfd, bootstrapbuf, bootstrapsize, startblock * ALPHA_BOOT_BLOCK_BLOCKSIZE); if (rv == -1) { warn("Writing `%s'", params->filesystem); goto done; } else if (rv != bootstrapsize) { warnx("Writing `%s': short write", params->filesystem); goto done; } if (params->flags & IB_VERBOSE) printf("Writing boot block\n"); rv = pwrite(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET); if (rv == -1) { warn("Writing `%s'", params->filesystem); goto done; } else if (rv != sizeof(bb)) { warnx("Writing `%s': short write", params->filesystem); goto done; } else { retval = 1; } done: if (bootstrapbuf) free(bootstrapbuf); return (retval); } /* * The Sun and alpha checksums overlay, and the Sun magic number also * overlays the alpha checksum. If you think you are smart: stop here * and do exercise one: figure out how to salt unimportant uint16_t * words in mid-sector so that the alpha and sparc checksums match, * and so the Sun magic number is embedded in the alpha checksum. * * The last uint64_t in the sector is the alpha arithmetic checksum. * The last uint16_t in the sector is the sun xor checksum. * The penultimate uint16_t in the sector is the sun magic number. * * A: 511 510 509 508 507 506 505 504 * S: 510 511 508 509 506 507 504 505 * 63 : : : 32:31 : : : 0 * | : : : \:| : : : | * 7654321076543210765432107654321076543210765432107654321076543210 * |-- sparc --||-- sparc --| * |-- checksum --||-- magic --| * |----------------------- alpha checksum -----------------------| * 1011111011011010 * b e d a */ static void resum(ib_params *params, struct alpha_boot_block * const bb, uint16_t *bb16) { static uint64_t lastsum; if (bb16 != NULL) memcpy(bb, bb16, sizeof(*bb)); ALPHA_BOOT_BLOCK_CKSUM(bb, &bb->bb_cksum); if (bb16 != NULL) memcpy(bb16, bb, sizeof(*bb)); if ((params->flags & IB_VERBOSE) && lastsum != bb->bb_cksum) printf("alpha checksum now %016llx\n", (long long)bb->bb_cksum); lastsum = bb->bb_cksum; } static void sun_bootstrap(ib_params *params, struct alpha_boot_block * const bb) { # define BB_ADJUST_OFFSET 64 static char our_int16s[] = "\2\3\6\7\12"; uint16_t i, j, chkdelta, sunsum, bb16[256]; /* * Theory: the alpha checksum is adjusted so bits 47:32 add up * to the Sun magic number. Then, another adjustment is computed * so bits 63:48 add up to the Sun checksum, and applied in pieces * so it changes the alpha checksum but not the Sun value. * * Note: using memcpy(3) instead of a union as a strict c89/c9x * conformance experiment and to avoid a public interface delta. */ assert(sizeof(bb16) == sizeof(*bb)); memcpy(bb16, bb, sizeof(bb16)); for (i = 0; our_int16s[i]; ++i) { j = BB_ADJUST_OFFSET + our_int16s[i]; if (bb16[j]) { warnx("Non-zero bits %04x in bytes %d..%d", bb16[j], j * 2, j * 2 + 1); bb16[j] = 0; resum(params, bb, bb16); } } /* * Make alpha checksum <47:32> come out to the sun magic. */ bb16[BB_ADJUST_OFFSET + 2] = htobe16(SUN_DKMAGIC) - bb16[254]; resum(params, bb, bb16); sunsum = compute_sunsum(bb16); /* might be the final value */ if (params->flags & IB_VERBOSE) printf("target sun checksum is %04x\n", sunsum); /* * Arrange to have alpha 63:48 add up to the sparc checksum. */ chkdelta = sunsum - bb16[255]; bb16[BB_ADJUST_OFFSET + 3] = chkdelta >> 1; bb16[BB_ADJUST_OFFSET + 7] = chkdelta >> 1; /* * By placing half the correction in two different uint64_t words at * positions 63:48, the sparc sum will not change but the alpha sum * will have the full correction, but only if the target adjustment * was even. If it was odd, reverse propagate the carry one place. */ if (chkdelta & 1) { if (params->flags & IB_VERBOSE) printf("target adjustment %04x was odd, correcting\n", chkdelta); assert(bb16[BB_ADJUST_OFFSET + 6] == 0); assert(bb16[BB_ADJUST_OFFSET + 012] == 0); bb16[BB_ADJUST_OFFSET + 6] += 0x8000; bb16[BB_ADJUST_OFFSET + 012] += 0x8000; } resum(params, bb, bb16); if (params->flags & IB_VERBOSE) printf("final harmonized checksum: %016llx\n", (long long)bb->bb_cksum); check_sparc(bb, "Final"); } static void check_sparc(const struct alpha_boot_block * const bb, const char *when) { uint16_t bb16[256]; const char * const wmsg = "%s sparc %s 0x%04x invalid, expected 0x%04x"; memcpy(bb16, bb, sizeof(bb16)); if (compute_sunsum(bb16) != bb16[255]) warnx(wmsg, when, "checksum", bb16[255], compute_sunsum(bb16)); if (bb16[254] != htobe16(SUN_DKMAGIC)) warnx(wmsg, when, "magic number", bb16[254], htobe16(SUN_DKMAGIC)); }