1 /* $NetBSD: alpha.c,v 1.22 2019/05/07 04:35:31 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 2002 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Luke Mewburn of Wasabi Systems.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1999 Ross Harvey. All rights reserved.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 * 3. All advertising materials mentioning features or use of this software
44 * must display the following acknowledgement:
45 * This product includes software developed by Ross Harvey
46 * for the NetBSD Project.
47 * 4. The name of the author may not be used to endorse or promote products
48 * derived from this software without specific prior written permission
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
51 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
52 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
53 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
54 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
55 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
56 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
57 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
58 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
59 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
60 */
61
62 /*
63 * Copyright (c) 1999 Christopher G. Demetriou. All rights reserved.
64 *
65 * Redistribution and use in source and binary forms, with or without
66 * modification, are permitted provided that the following conditions
67 * are met:
68 * 1. Redistributions of source code must retain the above copyright
69 * notice, this list of conditions and the following disclaimer.
70 * 2. Redistributions in binary form must reproduce the above copyright
71 * notice, this list of conditions and the following disclaimer in the
72 * documentation and/or other materials provided with the distribution.
73 * 3. All advertising materials mentioning features or use of this software
74 * must display the following acknowledgement:
75 * This product includes software developed by Christopher G. Demetriou
76 * for the NetBSD Project.
77 * 4. The name of the author may not be used to endorse or promote products
78 * derived from this software without specific prior written permission
79 *
80 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
81 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
82 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
83 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
84 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
85 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
86 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
87 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
88 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
89 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
90 */
91
92 #if HAVE_NBTOOL_CONFIG_H
93 #include "nbtool_config.h"
94 #endif
95
96 #include <sys/cdefs.h>
97 #if !defined(__lint)
98 __RCSID("$NetBSD: alpha.c,v 1.22 2019/05/07 04:35:31 thorpej Exp $");
99 #endif /* !__lint */
100
101 #include <sys/param.h>
102
103 #include <assert.h>
104 #include <err.h>
105 #include <stddef.h>
106 #include <stdio.h>
107 #include <stdlib.h>
108 #include <string.h>
109 #include <unistd.h>
110
111 #include "installboot.h"
112
113 #define SUN_DKMAGIC 55998 /* XXX: from <dev/sun/disklabel.h> */
114
115 static void resum(ib_params *, struct alpha_boot_block * const bb,
116 uint16_t *bb16);
117 static void sun_bootstrap(ib_params *, struct alpha_boot_block * const);
118 static void check_sparc(const struct alpha_boot_block * const,
119 const char *);
120
121 static int alpha_clearboot(ib_params *);
122 static int alpha_setboot(ib_params *);
123
124 struct ib_mach ib_mach_alpha = {
125 .name = "alpha",
126 .setboot = alpha_setboot,
127 .clearboot = alpha_clearboot,
128 .editboot = no_editboot,
129 .valid_flags = IB_STAGE1START | IB_ALPHASUM | IB_APPEND |
130 IB_SUNSUM,
131 };
132
133 static int
alpha_clearboot(ib_params * params)134 alpha_clearboot(ib_params *params)
135 {
136 struct alpha_boot_block bb;
137 uint64_t cksum;
138 ssize_t rv;
139
140 assert(params != NULL);
141 assert(params->fsfd != -1);
142 assert(params->filesystem != NULL);
143 assert(sizeof(struct alpha_boot_block) == ALPHA_BOOT_BLOCK_BLOCKSIZE);
144
145 if (params->flags & (IB_STAGE1START | IB_APPEND)) {
146 warnx("Can't use `-b bno' or `-o append' with `-c'");
147 return (0);
148 }
149
150 rv = pread(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET);
151 if (rv == -1) {
152 warn("Reading `%s'", params->filesystem);
153 return (0);
154 } else if (rv != sizeof(bb)) {
155 warnx("Reading `%s': short read", params->filesystem);
156 return (0);
157 }
158 ALPHA_BOOT_BLOCK_CKSUM(&bb, &cksum);
159 if (cksum != bb.bb_cksum) { // XXX check bb_cksum endian?
160 warnx(
161 "Old boot block checksum invalid (was %#llx, calculated %#llx)",
162 (unsigned long long)le64toh(bb.bb_cksum),
163 (unsigned long long)le64toh(cksum));
164 warnx("Boot block invalid");
165 return (0);
166 }
167
168 if (params->flags & IB_VERBOSE) {
169 printf("Old bootstrap start sector: %llu\n",
170 (unsigned long long)le64toh(bb.bb_secstart));
171 printf("Old bootstrap size: %llu\n",
172 (unsigned long long)le64toh(bb.bb_secsize));
173 printf("Old bootstrap checksum: %#llx\n",
174 (unsigned long long)le64toh(bb.bb_cksum));
175 }
176
177 bb.bb_secstart = bb.bb_secsize = bb.bb_flags = 0;
178
179 ALPHA_BOOT_BLOCK_CKSUM(&bb, &bb.bb_cksum);
180 if (params->flags & IB_SUNSUM)
181 sun_bootstrap(params, &bb);
182
183 printf("New bootstrap start sector: %llu\n",
184 (unsigned long long)le64toh(bb.bb_secstart));
185 printf("New bootstrap size: %llu\n",
186 (unsigned long long)le64toh(bb.bb_secsize));
187 printf("New bootstrap checksum: %#llx\n",
188 (unsigned long long)le64toh(bb.bb_cksum));
189
190 if (params->flags & IB_VERBOSE)
191 printf("%slearing boot block\n",
192 (params->flags & IB_NOWRITE) ? "Not c" : "C");
193 if (params->flags & IB_NOWRITE)
194 return (1);
195
196 rv = pwrite(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET);
197 if (rv == -1) {
198 warn("Writing `%s'", params->filesystem);
199 return (0);
200 } else if (rv != sizeof(bb)) {
201 warnx("Writing `%s': short write", params->filesystem);
202 return (0);
203 }
204
205 return (1);
206 }
207
208 static int
alpha_setboot(ib_params * params)209 alpha_setboot(ib_params *params)
210 {
211 struct alpha_boot_block bb;
212 uint64_t startblock;
213 int retval;
214 char *bootstrapbuf;
215 size_t bootstrapsize;
216 ssize_t rv;
217
218 assert(params != NULL);
219 assert(params->fsfd != -1);
220 assert(params->filesystem != NULL);
221 assert(params->s1fd != -1);
222 assert(params->stage1 != NULL);
223 assert(sizeof(struct alpha_boot_block) == ALPHA_BOOT_BLOCK_BLOCKSIZE);
224
225 retval = 0;
226 bootstrapbuf = NULL;
227
228 /*
229 * Allocate a buffer, with space to round up the input file
230 * to the next block size boundary, and with space for the boot
231 * block.
232 */
233 bootstrapsize = roundup(params->s1stat.st_size,
234 ALPHA_BOOT_BLOCK_BLOCKSIZE);
235
236 bootstrapbuf = malloc(bootstrapsize);
237 if (bootstrapbuf == NULL) {
238 warn("Allocating %lu bytes", (unsigned long) bootstrapsize);
239 goto done;
240 }
241 memset(bootstrapbuf, 0, bootstrapsize);
242
243 /* read the file into the buffer */
244 rv = pread(params->s1fd, bootstrapbuf, params->s1stat.st_size, 0);
245 if (rv == -1) {
246 warn("Reading `%s'", params->stage1);
247 goto done;
248 } else if (rv != params->s1stat.st_size) {
249 warnx("Reading `%s': short read", params->stage1);
250 goto done;
251 }
252
253 rv = pread(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET);
254 if (rv == -1) {
255 warn("Reading `%s'", params->filesystem);
256 goto done;
257 } else if (rv != sizeof(bb)) {
258 warnx("Reading `%s': short read", params->filesystem);
259 goto done;
260 }
261
262 if (params->flags & IB_SUNSUM)
263 check_sparc(&bb, "Initial");
264
265 /* fill in the updated bootstrap fields */
266 if (params->flags & IB_APPEND) {
267 struct stat filesyssb;
268
269 if (fstat(params->fsfd, &filesyssb) == -1) {
270 warn("Examining `%s'", params->filesystem);
271 goto done;
272 }
273 if (!S_ISREG(filesyssb.st_mode)) {
274 warnx(
275 "`%s' must be a regular file to append a bootstrap",
276 params->filesystem);
277 goto done;
278 }
279 startblock = howmany(filesyssb.st_size,
280 ALPHA_BOOT_BLOCK_BLOCKSIZE);
281 } else if (params->flags & IB_STAGE1START) {
282 startblock = params->s1start;
283 } else {
284 startblock = ALPHA_BOOT_BLOCK_OFFSET /
285 ALPHA_BOOT_BLOCK_BLOCKSIZE + 1;
286 }
287
288 bb.bb_secsize =
289 htole64(howmany(params->s1stat.st_size,
290 ALPHA_BOOT_BLOCK_BLOCKSIZE));
291 bb.bb_secstart = htole64(startblock);
292 bb.bb_flags = 0;
293
294 ALPHA_BOOT_BLOCK_CKSUM(&bb, &bb.bb_cksum);
295 if (params->flags & IB_SUNSUM)
296 sun_bootstrap(params, &bb);
297
298 if (params->flags & IB_VERBOSE) {
299 printf("Bootstrap start sector: %llu\n",
300 (unsigned long long)startblock);
301 printf("Bootstrap sector count: %llu\n",
302 (unsigned long long)le64toh(bb.bb_secsize));
303 printf("New boot block checksum: %#llx\n",
304 (unsigned long long)le64toh(bb.bb_cksum));
305 printf("%sriting bootstrap\n",
306 (params->flags & IB_NOWRITE) ? "Not w" : "W");
307 }
308 if (params->flags & IB_NOWRITE) {
309 retval = 1;
310 goto done;
311 }
312 rv = pwrite(params->fsfd, bootstrapbuf, bootstrapsize,
313 startblock * ALPHA_BOOT_BLOCK_BLOCKSIZE);
314 if (rv == -1) {
315 warn("Writing `%s'", params->filesystem);
316 goto done;
317 } else if ((size_t)rv != bootstrapsize) {
318 warnx("Writing `%s': short write", params->filesystem);
319 goto done;
320 }
321
322 if (params->flags & IB_VERBOSE)
323 printf("Writing boot block\n");
324 rv = pwrite(params->fsfd, &bb, sizeof(bb), ALPHA_BOOT_BLOCK_OFFSET);
325 if (rv == -1) {
326 warn("Writing `%s'", params->filesystem);
327 goto done;
328 } else if (rv != sizeof(bb)) {
329 warnx("Writing `%s': short write", params->filesystem);
330 goto done;
331 } else {
332 retval = 1;
333 }
334
335 done:
336 if (bootstrapbuf)
337 free(bootstrapbuf);
338 return (retval);
339 }
340
341
342 /*
343 * The Sun and alpha checksums overlay, and the Sun magic number also
344 * overlays the alpha checksum. If you think you are smart: stop here
345 * and do exercise one: figure out how to salt unimportant uint16_t
346 * words in mid-sector so that the alpha and sparc checksums match,
347 * and so the Sun magic number is embedded in the alpha checksum.
348 *
349 * The last uint64_t in the sector is the alpha arithmetic checksum.
350 * The last uint16_t in the sector is the sun xor checksum.
351 * The penultimate uint16_t in the sector is the sun magic number.
352 *
353 * A: 511 510 509 508 507 506 505 504
354 * S: 510 511 508 509 506 507 504 505
355 * 63 : : : 32:31 : : : 0
356 * | : : : \:| : : : |
357 * 7654321076543210765432107654321076543210765432107654321076543210
358 * |-- sparc --||-- sparc --|
359 * |-- checksum --||-- magic --|
360 * |----------------------- alpha checksum -----------------------|
361 * 1011111011011010
362 * b e d a
363 */
364
365 static void
resum(ib_params * params,struct alpha_boot_block * const bb,uint16_t * bb16)366 resum(ib_params *params, struct alpha_boot_block * const bb, uint16_t *bb16)
367 {
368 static uint64_t lastsum;
369
370 if (bb16 != NULL)
371 memcpy(bb, bb16, sizeof(*bb));
372 ALPHA_BOOT_BLOCK_CKSUM(bb, &bb->bb_cksum);
373 if (bb16 != NULL)
374 memcpy(bb16, bb, sizeof(*bb));
375 if ((params->flags & IB_VERBOSE) && lastsum != bb->bb_cksum)
376 printf("alpha checksum now %016llx\n",
377 (unsigned long long)le64toh(bb->bb_cksum));
378 lastsum = bb->bb_cksum;
379 }
380
381 static void
sun_bootstrap(ib_params * params,struct alpha_boot_block * const bb)382 sun_bootstrap(ib_params *params, struct alpha_boot_block * const bb)
383 {
384 # define BB_ADJUST_OFFSET 64
385 static char our_int16s[] = "\2\3\6\7\12";
386 uint16_t i, j, chkdelta, sunsum, bb16[256];
387
388 /*
389 * Theory: the alpha checksum is adjusted so bits 47:32 add up
390 * to the Sun magic number. Then, another adjustment is computed
391 * so bits 63:48 add up to the Sun checksum, and applied in pieces
392 * so it changes the alpha checksum but not the Sun value.
393 *
394 * Note: using memcpy(3) instead of a union as a strict c89/c9x
395 * conformance experiment and to avoid a public interface delta.
396 */
397 assert(sizeof(bb16) == sizeof(*bb));
398 memcpy(bb16, bb, sizeof(bb16));
399 for (i = 0; our_int16s[i]; ++i) {
400 j = BB_ADJUST_OFFSET + our_int16s[i];
401 if (bb16[j]) {
402 warnx("Non-zero bits %04x in bytes %d..%d",
403 bb16[j], j * 2, j * 2 + 1);
404 bb16[j] = 0;
405 resum(params, bb, bb16);
406 }
407 }
408 /*
409 * Make alpha checksum <47:32> come out to the sun magic.
410 */
411 bb16[BB_ADJUST_OFFSET + 2] = htobe16(SUN_DKMAGIC) - bb16[254];
412 resum(params, bb, bb16);
413 sunsum = compute_sunsum(bb16); /* might be the final value */
414 if (params->flags & IB_VERBOSE)
415 printf("target sun checksum is %04x\n", sunsum);
416 /*
417 * Arrange to have alpha 63:48 add up to the sparc checksum.
418 */
419 chkdelta = sunsum - bb16[255];
420 bb16[BB_ADJUST_OFFSET + 3] = chkdelta >> 1;
421 bb16[BB_ADJUST_OFFSET + 7] = chkdelta >> 1;
422 /*
423 * By placing half the correction in two different uint64_t words at
424 * positions 63:48, the sparc sum will not change but the alpha sum
425 * will have the full correction, but only if the target adjustment
426 * was even. If it was odd, reverse propagate the carry one place.
427 */
428 if (chkdelta & 1) {
429 if (params->flags & IB_VERBOSE)
430 printf("target adjustment %04x was odd, correcting\n",
431 chkdelta);
432 assert(bb16[BB_ADJUST_OFFSET + 6] == 0);
433 assert(bb16[BB_ADJUST_OFFSET + 012] == 0);
434 bb16[BB_ADJUST_OFFSET + 6] += 0x8000;
435 bb16[BB_ADJUST_OFFSET + 012] += 0x8000;
436 }
437 resum(params, bb, bb16);
438 if (params->flags & IB_VERBOSE)
439 printf("final harmonized checksum: %016llx\n",
440 (unsigned long long)le64toh(bb->bb_cksum));
441 check_sparc(bb, "Final");
442 }
443
444 static void
check_sparc(const struct alpha_boot_block * const bb,const char * when)445 check_sparc(const struct alpha_boot_block * const bb, const char *when)
446 {
447 uint16_t bb16[256];
448 #define wmsg "%s sparc %s 0x%04x invalid, expected 0x%04x"
449
450 memcpy(bb16, bb, sizeof(bb16));
451 if (compute_sunsum(bb16) != bb16[255])
452 warnx(wmsg, when, "checksum", bb16[255], compute_sunsum(bb16));
453 if (bb16[254] != htobe16(SUN_DKMAGIC))
454 warnx(wmsg, when, "magic number", bb16[254],
455 htobe16(SUN_DKMAGIC));
456 }
457