d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- Split code shared by almost any boot loader into separate files and

Browse Source 
clean up most layering violations:

	sys/boot/i386/common/rbx.h:

		RBX_* defines
		OPT_SET()
		OPT_CHECK()

	sys/boot/common/util.[ch]:

		memcpy()
		memset()
		memcmp()
		bcpy()
		bzero()
		bcmp()
		strcmp()
		strncmp() [new]
		strcpy()
		strcat()
		strchr()
		strlen()
		printf()

	sys/boot/i386/common/cons.[ch]:

		ioctrl
		putc()
		xputc()
		putchar()
		getc()
		xgetc()
		keyhit() [now takes number of seconds as an argument]
		getstr()

	sys/boot/i386/common/drv.[ch]:

		struct dsk
		drvread()
		drvwrite() [new]
		drvsize() [new]

	sys/boot/common/crc32.[ch] [new]

	sys/boot/common/gpt.[ch] [new]

- Teach gptboot and gptzfsboot about new files. I haven't touched the
  rest, but there is still a lot of code duplication to be removed.

- Implement full GPT support. Currently we just read primary header and
  partition table and don't care about checksums, etc. After this change we
  verify checksums of primary header and primary partition table and if
  there is a problem we fall back to backup header and backup partition
  table.

- Clean up most messages to use prefix of boot program, so in case of an
  error we know where the error comes from, eg.:

	gptboot: unable to read primary GPT header

- If we can't boot, print boot prompt only once and not every five
  seconds.

- Honour newly added GPT attributes:

	bootme - this is bootable partition
	bootonce - try to boot from this partition only once
	bootfailed - we failed to boot from this partition

- Change boot order of gptboot to the following:

	1. Try to boot from all the partitions that have both 'bootme'
	   and 'bootonce' attributes one by one.
	2. Try to boot from all the partitions that have only 'bootme'
	   attribute one by one.
	3. If there are no partitions with 'bootme' attribute, boot from
	   the first UFS partition.

- The 'bootonce' functionality is implemented in the following way:

	1. Walk through all the partitions and when 'bootonce'
	   attribute is found without 'bootme' attribute, remove
	   'bootonce' attribute and set 'bootfailed' attribute.
	   'bootonce' attribute alone means that we tried to boot from
	   this partition, but boot failed after leaving gptboot and
	   machine was restarted.
	2. Find partition with both 'bootme' and 'bootonce' attributes.
	3. Remove 'bootme' attribute.
	4. Try to execute /boot/loader or /boot/kernel/kernel from that
	   partition. If succeeded we stop here.
	5. If execution failed, remove 'bootonce' and set 'bootfailed'.
	6. Go to 2.

   If whole boot succeeded there is new /etc/rc.d/gptboot script coming
   that will log all partitions that we failed to boot from (the ones with
   'bootfailed' attribute) and will remove this attribute. It will also
   find partition with 'bootonce' attribute - this is the partition we
   booted from successfully. The script will log success and remove the
   attribute.

   All the GPT updates we do here goes to both primary and backup GPT if
   they are valid. We don't touch headers or partition tables when
   checksum doesn't match.

Reviewed by:	arch (Message-ID: <20100917234542.GE1902@garage.freebsd.pl>)
Obtained from:	Wheel Systems Sp. z o.o. http://www.wheelsystems.com
MFC after:	2 weeks
This commit is contained in:
Pawel Jakub Dawidek 2010-09-24 19:49:12 +00:00
parent cec283baf4
commit a0e2fdedd1
18 changed files with 1376 additions and 857 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
sys/boot/common/crc32.c Normal file
View File

@ -0,0 +1,108 @@
/*-
* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
* code or tables extracted from it, as desired without restriction.
*/
/*
* First, the polynomial itself and its table of feedback terms. The
* polynomial is
* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
*
* Note that we take it "backwards" and put the highest-order term in
* the lowest-order bit. The X^32 term is "implied"; the LSB is the
* X^31 term, etc. The X^0 term (usually shown as "+1") results in
* the MSB being 1
*
* Note that the usual hardware shift register implementation, which
* is what we're using (we're merely optimizing it by doing eight-bit
* chunks at a time) shifts bits into the lowest-order term. In our
* implementation, that means shifting towards the right. Why do we
* do it this way? Because the calculated CRC must be transmitted in
* order from highest-order term to lowest-order term. UARTs transmit
* characters in order from LSB to MSB. By storing the CRC this way
* we hand it to the UART in the order low-byte to high-byte; the UART
* sends each low-bit to hight-bit; and the result is transmission bit
* by bit from highest- to lowest-order term without requiring any bit
* shuffling on our part. Reception works similarly
*
* The feedback terms table consists of 256, 32-bit entries. Notes
*
* The table can be generated at runtime if desired; code to do so
* is shown later. It might not be obvious, but the feedback
* terms simply represent the results of eight shift/xor opera
* tions for all combinations of data and CRC register values
*
* The values must be right-shifted by eight bits by the "updcrc
* logic; the shift must be unsigned (bring in zeroes). On some
* hardware you could probably optimize the shift in assembler by
* using byte-swap instructions
* polynomial $edb88320
*
*
* CRC32 code derived from work by Gary S. Brown.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/types.h>
#include "crc32.h"
static uint32_t crc32_tab[] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
uint32_t
crc32(const void *buf, size_t size)
{
const uint8_t *p = buf;
uint32_t crc;
crc = ~0U;
while (size--)
crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
return (crc ^ ~0U);
}

13
sys/boot/common/crc32.h Normal file
View File

@ -0,0 +1,13 @@
/*-
* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
* code or tables extracted from it, as desired without restriction.
*
* $FreeBSD$
*/
#ifndef _CRC32_H_
#define _CRC32_H_
uint32_t crc32(const void *buf, size_t size);
#endif /* !_CRC32_H_ */

381
sys/boot/common/gpt.c Normal file
View File

@ -0,0 +1,381 @@
/*-
* Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/gpt.h>
#ifndef LITTLE_ENDIAN
#error gpt.c works only for little endian architectures
#endif
#include "crc32.h"
#include "drv.h"
#include "util.h"
#include "gpt.h"
#define MAXTBLENTS 128
static struct gpt_hdr hdr_primary, hdr_backup, *gpthdr;
static uint64_t hdr_primary_lba, hdr_backup_lba;
static struct gpt_ent table_primary[MAXTBLENTS], table_backup[MAXTBLENTS];
static struct gpt_ent *gpttable;
static int curent, bootonce;
/*
* Buffer below 64kB passed on gptread(), which can hold at least
* one sector od data (512 bytes).
*/
static char *secbuf;
static void
gptupdate(const char *which, struct dsk *dskp, struct gpt_hdr *hdr,
struct gpt_ent *table)
{
int entries_per_sec, firstent;
daddr_t slba;
/*
* We need to update the following for both primary and backup GPT:
* 1. Sector on disk that contains curent partition.
* 2. Partition table checksum.
* 3. Header checksum.
* 4. Header on disk.
*/
entries_per_sec = DEV_BSIZE / hdr->hdr_entsz;
slba = curent / entries_per_sec;
firstent = slba * entries_per_sec;
bcpy(&table[firstent], secbuf, DEV_BSIZE);
slba += hdr->hdr_lba_table;
if (drvwrite(dskp, secbuf, slba, 1)) {
printf("%s: unable to update %s GPT partition table\n",
BOOTPROG, which);
return;
}
hdr->hdr_crc_table = crc32(table, hdr->hdr_entries * hdr->hdr_entsz);
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = crc32(hdr, hdr->hdr_size);
bzero(secbuf, DEV_BSIZE);
bcpy(hdr, secbuf, hdr->hdr_size);
if (drvwrite(dskp, secbuf, hdr->hdr_lba_self, 1)) {
printf("%s: unable to update %s GPT header\n", BOOTPROG, which);
return;
}
}
int
gptfind(const uuid_t *uuid, struct dsk *dskp, int part)
{
struct gpt_ent *ent;
int firsttry;
if (part >= 0) {
if (part == 0 || part > gpthdr->hdr_entries) {
printf("%s: invalid partition index\n", BOOTPROG);
return (-1);
}
ent = &gpttable[part - 1];
if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0) {
printf("%s: specified partition is not UFS\n",
BOOTPROG);
return (-1);
}
curent = part - 1;
goto found;
}
firsttry = (curent == -1);
curent++;
if (curent >= gpthdr->hdr_entries) {
curent = gpthdr->hdr_entries;
return (-1);
}
if (bootonce) {
/*
* First look for partition with both GPT_ENT_ATTR_BOOTME and
* GPT_ENT_ATTR_BOOTONCE flags.
*/
for (; curent < gpthdr->hdr_entries; curent++) {
ent = &gpttable[curent];
if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0)
continue;
if (!(ent->ent_attr & GPT_ENT_ATTR_BOOTME))
continue;
if (!(ent->ent_attr & GPT_ENT_ATTR_BOOTONCE))
continue;
/* Ok, found one. */
goto found;
}
bootonce = 0;
curent = 0;
}
for (; curent < gpthdr->hdr_entries; curent++) {
ent = &gpttable[curent];
if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0)
continue;
if (!(ent->ent_attr & GPT_ENT_ATTR_BOOTME))
continue;
if (ent->ent_attr & GPT_ENT_ATTR_BOOTONCE)
continue;
/* Ok, found one. */
goto found;
}
if (firsttry) {
/*
* No partition with BOOTME flag was found, try to boot from
* first UFS partition.
*/
for (curent = 0; curent < gpthdr->hdr_entries; curent++) {
ent = &gpttable[curent];
if (bcmp(&ent->ent_type, uuid, sizeof(uuid_t)) != 0)
continue;
/* Ok, found one. */
goto found;
}
}
return (-1);
found:
dskp->part = curent + 1;
ent = &gpttable[curent];
dskp->start = ent->ent_lba_start;
if (ent->ent_attr & GPT_ENT_ATTR_BOOTONCE) {
/*
* Clear BOOTME, but leave BOOTONCE set before trying to
* boot from this partition.
*/
if (hdr_primary_lba > 0) {
table_primary[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTME;
gptupdate("primary", dskp, &hdr_primary, table_primary);
}
if (hdr_backup_lba > 0) {
table_backup[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTME;
gptupdate("backup", dskp, &hdr_backup, table_backup);
}
}
return (0);
}
static int
gptread_hdr(const char *which, struct dsk *dskp, struct gpt_hdr *hdr,
uint64_t hdrlba)
{
uint32_t crc;
if (drvread(dskp, secbuf, hdrlba, 1)) {
printf("%s: unable to read %s GPT header\n", BOOTPROG, which);
return (-1);
}
bcpy(secbuf, hdr, sizeof(*hdr));
if (bcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig)) != 0 ||
hdr->hdr_lba_self != hdrlba || hdr->hdr_revision < 0x00010000 ||
hdr->hdr_entsz < sizeof(struct gpt_ent) ||
hdr->hdr_entries > MAXTBLENTS || DEV_BSIZE % hdr->hdr_entsz != 0) {
printf("%s: invalid %s GPT header\n", BOOTPROG, which);
return (-1);
}
crc = hdr->hdr_crc_self;
hdr->hdr_crc_self = 0;
if (crc32(hdr, hdr->hdr_size) != crc) {
printf("%s: %s GPT header checksum mismatch\n", BOOTPROG,
which);
return (-1);
}
hdr->hdr_crc_self = crc;
return (0);
}
void
gptbootfailed(struct dsk *dskp)
{
if (!(gpttable[curent].ent_attr & GPT_ENT_ATTR_BOOTONCE))
return;
if (hdr_primary_lba > 0) {
table_primary[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTONCE;
table_primary[curent].ent_attr |= GPT_ENT_ATTR_BOOTFAILED;
gptupdate("primary", dskp, &hdr_primary, table_primary);
}
if (hdr_backup_lba > 0) {
table_backup[curent].ent_attr &= ~GPT_ENT_ATTR_BOOTONCE;
table_backup[curent].ent_attr |= GPT_ENT_ATTR_BOOTFAILED;
gptupdate("backup", dskp, &hdr_backup, table_backup);
}
}
static void
gptbootconv(const char *which, struct dsk *dskp, struct gpt_hdr *hdr,
struct gpt_ent *table)
{
struct gpt_ent *ent;
daddr_t slba;
int table_updated, sector_updated;
int entries_per_sec, nent, part;
table_updated = 0;
entries_per_sec = DEV_BSIZE / hdr->hdr_entsz;
for (nent = 0, slba = hdr->hdr_lba_table;
slba < hdr->hdr_lba_table + hdr->hdr_entries / entries_per_sec;
slba++, nent += entries_per_sec) {
sector_updated = 0;
for (part = 0; part < entries_per_sec; part++) {
ent = &table[nent + part];
if ((ent->ent_attr & (GPT_ENT_ATTR_BOOTME |
GPT_ENT_ATTR_BOOTONCE |
GPT_ENT_ATTR_BOOTFAILED)) !=
GPT_ENT_ATTR_BOOTONCE) {
continue;
}
ent->ent_attr &= ~GPT_ENT_ATTR_BOOTONCE;
ent->ent_attr |= GPT_ENT_ATTR_BOOTFAILED;
table_updated = 1;
sector_updated = 1;
}
if (!sector_updated)
continue;
bcpy(&table[nent], secbuf, DEV_BSIZE);
if (drvwrite(dskp, secbuf, slba, 1)) {
printf("%s: unable to update %s GPT partition table\n",
BOOTPROG, which);
}
}
if (!table_updated)
return;
hdr->hdr_crc_table = crc32(table, hdr->hdr_entries * hdr->hdr_entsz);
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = crc32(hdr, hdr->hdr_size);
bzero(secbuf, DEV_BSIZE);
bcpy(hdr, secbuf, hdr->hdr_size);
if (drvwrite(dskp, secbuf, hdr->hdr_lba_self, 1))
printf("%s: unable to update %s GPT header\n", BOOTPROG, which);
}
static int
gptread_table(const char *which, const uuid_t *uuid, struct dsk *dskp,
struct gpt_hdr *hdr, struct gpt_ent *table)
{
struct gpt_ent *ent;
int entries_per_sec;
int part, nent;
daddr_t slba;
if (hdr->hdr_entries == 0)
return (0);
entries_per_sec = DEV_BSIZE / hdr->hdr_entsz;
slba = hdr->hdr_lba_table;
nent = 0;
for (;;) {
if (drvread(dskp, secbuf, slba, 1)) {
printf("%s: unable to read %s GPT partition table\n",
BOOTPROG, which);
return (-1);
}
ent = (struct gpt_ent *)secbuf;
for (part = 0; part < entries_per_sec; part++, ent++) {
bcpy(ent, &table[nent], sizeof(table[nent]));
if (++nent >= hdr->hdr_entries)
break;
}
if (nent >= hdr->hdr_entries)
break;
slba++;
}
if (crc32(table, nent * hdr->hdr_entsz) != hdr->hdr_crc_table) {
printf("%s: %s GPT table checksum mismatch\n", BOOTPROG, which);
return (-1);
}
return (0);
}
int
gptread(const uuid_t *uuid, struct dsk *dskp, char *buf)
{
uint64_t altlba;
/*
* Read and verify both GPT headers: primary and backup.
*/
secbuf = buf;
hdr_primary_lba = hdr_backup_lba = 0;
curent = -1;
bootonce = 1;
dskp->start = 0;
if (gptread_hdr("primary", dskp, &hdr_primary, 1) == 0 &&
gptread_table("primary", uuid, dskp, &hdr_primary,
table_primary) == 0) {
hdr_primary_lba = hdr_primary.hdr_lba_self;
gpthdr = &hdr_primary;
gpttable = table_primary;
}
altlba = drvsize(dskp);
if (altlba > 0)
altlba--;
else if (hdr_primary_lba > 0) {
/*
* If we cannot obtain disk size, but primary header
* is valid, we can get backup header location from
* there.
*/
altlba = hdr_primary.hdr_lba_alt;
}
if (altlba == 0)
printf("%s: unable to locate backup GPT header\n", BOOTPROG);
else if (gptread_hdr("backup", dskp, &hdr_backup, altlba) == 0 &&
gptread_table("backup", uuid, dskp, &hdr_backup,
table_backup) == 0) {
hdr_backup_lba = hdr_backup.hdr_lba_self;
if (hdr_primary_lba == 0) {
gpthdr = &hdr_backup;
gpttable = table_backup;
printf("%s: using backup GPT\n", BOOTPROG);
}
}
/*
* Convert all BOOTONCE without BOOTME flags into BOOTFAILED.
* BOOTONCE without BOOTME means that we tried to boot from it,
* but failed after leaving gptboot and machine was rebooted.
* We don't want to leave partitions marked as BOOTONCE only,
* because when we boot successfully start-up scripts should
* find at most one partition with only BOOTONCE flag and this
* will mean that we booted from that partition.
*/
if (hdr_primary_lba != 0)
gptbootconv("primary", dskp, &hdr_primary, table_primary);
if (hdr_backup_lba != 0)
gptbootconv("backup", dskp, &hdr_backup, table_backup);
if (hdr_primary_lba == 0 && hdr_backup_lba == 0)
return (-1);
return (0);
}

39
sys/boot/common/gpt.h Normal file
View File

@ -0,0 +1,39 @@
/*-
* Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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.
*
* $FreeBSD$
*/
#ifndef _GPT_H_
#define _GPT_H_
#include <uuid.h>
#include <drv.h>
int gptread(const uuid_t *uuid, struct dsk *dskp, char *buf);
int gptfind(const uuid_t *uuid, struct dsk *dskp, int part);
void gptbootfailed(struct dsk *dskp);
#endif /* !_GPT_H_ */

176
sys/boot/common/util.c Normal file
View File

@ -0,0 +1,176 @@
/*-
* Copyright (c) 1998 Robert Nordier
* Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms are freely
* permitted provided that the above copyright notice and this
* paragraph and the following disclaimer are duplicated in all
* such forms.
*
* This software is provided "AS IS" and without any express or
* implied warranties, including, without limitation, the implied
* warranties of merchantability and fitness for a particular
* purpose.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <stdarg.h>
#include "cons.h"
#include "util.h"
void
memcpy(void *dst, const void *src, int len)
{
const char *s = src;
char *d = dst;
while (len--)
*d++ = *s++;
}
void
memset(void *b, int c, size_t len)
{
char *bp = b;
while (len--)
*bp++ = (unsigned char)c;
}
int
memcmp(const void *b1, const void *b2, size_t len)
{
const unsigned char *p1, *p2;
for (p1 = b1, p2 = b2; len > 0; len--, p1++, p2++) {
if (*p1 != *p2)
return ((*p1) - (*p2));
}
return (0);
}
int
strcmp(const char *s1, const char *s2)
{
for (; *s1 == *s2 && *s1 != '\0'; s1++, s2++)
;
return ((unsigned char)*s1 - (unsigned char)*s2);
}
int
strncmp(const char *s1, const char *s2, size_t len)
{
for (; *s1 == *s2 && *s1 != '\0' && len > 0; len--, s1++, s2++)
;
return ((unsigned char)*s1 - (unsigned char)*s2);
}
void
strcpy(char *dst, const char *src)
{
while (*src != '\0')
*dst++ = *src++;
*dst = '\0';
}
void
strcat(char *dst, const char *src)
{
while (*dst != '\0')
dst++;
while (*src != '\0')
*dst++ = *src++;
*dst = '\0';
}
char *
strchr(const char *s, char ch)
{
for (; *s != '\0'; s++) {
if (*s == ch)
return ((char *)(uintptr_t)(const void *)s);
}
return (NULL);
}
size_t
strlen(const char *s)
{
size_t len = 0;
while (*s++ != '\0')
len++;
return (len);
}
void
printf(const char *fmt, ...)
{
va_list ap;
const char *hex = "0123456789abcdef";
char buf[10], *s;
unsigned long long u;
int c, l;
va_start(ap, fmt);
while ((c = *fmt++) != '\0') {
if (c != '%') {
putchar(c);
continue;
}
l = 0;
nextfmt:
c = *fmt++;
switch (c) {
case 'l':
l++;
goto nextfmt;
case 'c':
putchar(va_arg(ap, int));
break;
case 's':
for (s = va_arg(ap, char *); *s != '\0'; s++)
putchar(*s);
break;
case 'd': /* A lie, always prints unsigned */
case 'u':
case 'x':
switch (l) {
case 2:
u = va_arg(ap, unsigned long long);
break;
case 1:
u = va_arg(ap, unsigned long);
break;
default:
u = va_arg(ap, unsigned int);
break;
}
s = buf;
if (c == 'd' || c == 'u') {
do
*s++ = '0' + (u % 10U);
while (u /= 10);
} else {
do
*s++ = hex[u & 0xfu];
while (u >>= 4);
}
while (--s >= buf)
putchar(*s);
break;
}
}
va_end(ap);
}

53
sys/boot/common/util.h Normal file
View File

@ -0,0 +1,53 @@
/*-
* Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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.
*
* $FreeBSD$
*/
#ifndef _UTIL_H_
#define _UTIL_H_
#include <sys/types.h>
#include <stdarg.h>
void memcpy(void *dst, const void *src, int len);
void memset(void *b, int c, size_t len);
int memcmp(const void *b1, const void *b2, size_t len);
#define bcpy(src, dst, len) memcpy((dst), (src), (len))
#define bzero(buf, size) memset((buf), 0, (size))
#define bcmp(b1, b2, len) (memcmp((b1), (b2), (len)) != 0)
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t len);
void strcpy(char *dst, const char *src);
void strcat(char *dst, const char *src);
char *strchr(const char *s, char ch);
size_t strlen(const char *s);
void printf(const char *fmt, ...);
#endif /* !_UTIL_H_ */

152
sys/boot/i386/common/cons.c Normal file
View File

@ -0,0 +1,152 @@
/*-
* Copyright (c) 1998 Robert Nordier
* All rights reserved.
*
* Redistribution and use in source and binary forms are freely
* permitted provided that the above copyright notice and this
* paragraph and the following disclaimer are duplicated in all
* such forms.
*
* This software is provided "AS IS" and without any express or
* implied warranties, including, without limitation, the implied
* warranties of merchantability and fitness for a particular
* purpose.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <machine/psl.h>
#include <btxv86.h>
#include "lib.h"
#include "rbx.h"
#include "util.h"
#include "cons.h"
#define V86_ZR(x) ((x) & PSL_Z)
#define SECOND 18 /* Circa that many ticks in a second. */
uint8_t ioctrl = IO_KEYBOARD;
void
putc(int c)
{
v86.addr = 0x10;
v86.eax = 0xe00 | (c & 0xff);
v86.ebx = 0x7;
v86int();
}
void
xputc(int c)
{
if (ioctrl & IO_KEYBOARD)
putc(c);
if (ioctrl & IO_SERIAL)
sio_putc(c);
}
void
putchar(int c)
{
if (c == '\n')
xputc('\r');
xputc(c);
}
int
getc(int fn)
{
/*
* The extra comparison against zero is an attempt to work around
* what appears to be a bug in QEMU and Bochs. Both emulators
* sometimes report a key-press with scancode one and ascii zero
* when no such key is pressed in reality. As far as I can tell,
* this only happens shortly after a reboot.
*/
v86.ctl = V86_FLAGS;
v86.addr = 0x16;
v86.eax = fn << 8;
v86int();
return fn == 0 ? v86.eax & 0xff : (!V86_ZR(v86.efl) && (v86.eax & 0xff));
}
int
xgetc(int fn)
{
if (OPT_CHECK(RBX_NOINTR))
return (0);
for (;;) {
if (ioctrl & IO_KEYBOARD && getc(1))
return (fn ? 1 : getc(0));
if (ioctrl & IO_SERIAL && sio_ischar())
return (fn ? 1 : sio_getc());
if (fn)
return (0);
}
/* NOTREACHED */
}
int
keyhit(unsigned int secs)
{
uint32_t t0, t1;
if (OPT_CHECK(RBX_NOINTR))
return (0);
secs *= SECOND;
t0 = 0;
for (;;) {
if (xgetc(1))
return (1);
if (secs > 0) {
t1 = *(uint32_t *)PTOV(0x46c);
if (!t0)
t0 = t1;
if (t1 < t0 || t1 >= t0 + secs)
return (0);
}
}
/* NOTREACHED */
}
void
getstr(char *cmdstr, size_t cmdstrsize)
{
char *s;
int c;
s = cmdstr;
for (;;) {
switch (c = xgetc(0)) {
case 0:
break;
case '\177':
case '\b':
if (s > cmdstr) {
s--;
printf("\b \b");
}
break;
case '\n':
case '\r':
*s = 0;
return;
default:
if (s - cmdstr < cmdstrsize - 1)
*s++ = c;
putchar(c);
break;
}
}
}

34
sys/boot/i386/common/cons.h Normal file
View File

@ -0,0 +1,34 @@
/*-
* Copyright (c) 1998 Robert Nordier
* All rights reserved.
*
* Redistribution and use in source and binary forms are freely
* permitted provided that the above copyright notice and this
* paragraph and the following disclaimer are duplicated in all
* such forms.
*
* This software is provided "AS IS" and without any express or
* implied warranties, including, without limitation, the implied
* warranties of merchantability and fitness for a particular
* purpose.
*
* $FreeBSD$
*/
#ifndef _CONS_H_
#define _CONS_H_
#define IO_KEYBOARD 1
#define IO_SERIAL 2
extern uint8_t ioctrl;
void putc(int c);
void xputc(int c);
void putchar(int c);
int getc(int fn);
int xgetc(int fn);
int keyhit(unsigned int secs);
void getstr(char *cmdstr, size_t cmdstrsize);
#endif /* !_CONS_H_ */

131
sys/boot/i386/common/drv.c Normal file
View File

@ -0,0 +1,131 @@
/*-
* Copyright (c) 1998 Robert Nordier
* Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms are freely
* permitted provided that the above copyright notice and this
* paragraph and the following disclaimer are duplicated in all
* such forms.
*
* This software is provided "AS IS" and without any express or
* implied warranties, including, without limitation, the implied
* warranties of merchantability and fitness for a particular
* purpose.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <machine/psl.h>
#include <btxv86.h>
#include "rbx.h"
#include "util.h"
#include "drv.h"
#ifndef GPT
#include "xreadorg.h"
#endif
#define V86_CY(x) ((x) & PSL_C)
#define V86_ZR(x) ((x) & PSL_Z)
#ifdef GPT
uint64_t
drvsize(struct dsk *dskp)
{
unsigned char params[0x42];
uint64_t sectors;
*(uint32_t *)params = sizeof(params);
v86.ctl = V86_FLAGS;
v86.addr = 0x13;
v86.eax = 0x4800;
v86.edx = dskp->drive;
v86.ds = VTOPSEG(params);
v86.esi = VTOPOFF(params);
v86int();
if (V86_CY(v86.efl)) {
printf("error %u\n", v86.eax >> 8 & 0xff);
return (0);
}
memcpy(&sectors, params + 0x10, sizeof(sectors));
return (sectors);
}
#endif /* GPT */
#ifdef GPT
static struct {
uint16_t len;
uint16_t count;
uint16_t off;
uint16_t seg;
uint64_t lba;
} packet;
#endif /* GPT */
int
drvread(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk)
{
static unsigned c = 0x2d5c7c2f;
if (!OPT_CHECK(RBX_QUIET))
printf("%c\b", c = c << 8 | c >> 24);
#ifdef GPT
packet.len = 0x10;
packet.count = nblk;
packet.off = VTOPOFF(buf);
packet.seg = VTOPSEG(buf);
packet.lba = lba;
v86.ctl = V86_FLAGS;
v86.addr = 0x13;
v86.eax = 0x4200;
v86.edx = dskp->drive;
v86.ds = VTOPSEG(&packet);
v86.esi = VTOPOFF(&packet);
#else /* !GPT */
v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
v86.addr = XREADORG; /* call to xread in boot1 */
v86.es = VTOPSEG(buf);
v86.eax = lba;
v86.ebx = VTOPOFF(buf);
v86.ecx = lba >> 32;
v86.edx = nblk << 8 | dskp->drive;
#endif /* !GPT */
v86int();
if (V86_CY(v86.efl)) {
printf("%s: error %u lba %u\n",
BOOTPROG, v86.eax >> 8 & 0xff, lba);
return (-1);
}
return (0);
}
#ifdef GPT
int
drvwrite(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk)
{
packet.len = 0x10;
packet.count = nblk;
packet.off = VTOPOFF(buf);
packet.seg = VTOPSEG(buf);
packet.lba = lba;
v86.ctl = V86_FLAGS;
v86.addr = 0x13;
v86.eax = 0x4300;
v86.edx = dskp->drive;
v86.ds = VTOPSEG(&packet);
v86.esi = VTOPOFF(&packet);
v86int();
if (V86_CY(v86.efl)) {
printf("error %u lba %u\n", v86.eax >> 8 & 0xff, lba);
return (-1);
}
return (0);
}
#endif /* GPT */

48
sys/boot/i386/common/drv.h Normal file
View File

@ -0,0 +1,48 @@
/*-
* Copyright (c) 2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS 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 AUTHORS 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.
*
* $FreeBSD$
*/
#ifndef _DRV_H_
#define _DRV_H_
struct dsk {
unsigned int drive;
unsigned int type;
unsigned int unit;
unsigned int slice;
int part;
daddr_t start;
int init;
};
int drvread(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk);
#ifdef GPT
int drvwrite(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk);
uint64_t drvsize(struct dsk *dskp);
#endif /* GPT */
#endif /* !_DRV_H_ */

61
sys/boot/i386/common/rbx.h Normal file
View File

@ -0,0 +1,61 @@
/*-
* Copyright (c) 1998 Robert Nordier
* All rights reserved.
*
* Redistribution and use in source and binary forms are freely
* permitted provided that the above copyright notice and this
* paragraph and the following disclaimer are duplicated in all
* such forms.
*
* This software is provided "AS IS" and without any express or
* implied warranties, including, without limitation, the implied
* warranties of merchantability and fitness for a particular
* purpose.
*
* $FreeBSD$
*/
#ifndef _RBX_H_
#define _RBX_H_
#define RBX_ASKNAME 0x0 /* -a */
#define RBX_SINGLE 0x1 /* -s */
/* 0x2 is reserved for log2(RB_NOSYNC). */
/* 0x3 is reserved for log2(RB_HALT). */
/* 0x4 is reserved for log2(RB_INITNAME). */
#define RBX_DFLTROOT 0x5 /* -r */
#define RBX_KDB 0x6 /* -d */
/* 0x7 is reserved for log2(RB_RDONLY). */
/* 0x8 is reserved for log2(RB_DUMP). */
/* 0x9 is reserved for log2(RB_MINIROOT). */
#define RBX_CONFIG 0xa /* -c */
#define RBX_VERBOSE 0xb /* -v */
#define RBX_SERIAL 0xc /* -h */
#define RBX_CDROM 0xd /* -C */
/* 0xe is reserved for log2(RB_POWEROFF). */
#define RBX_GDB 0xf /* -g */
#define RBX_MUTE 0x10 /* -m */
/* 0x11 is reserved for log2(RB_SELFTEST). */
/* 0x12 is reserved for boot programs. */
/* 0x13 is reserved for boot programs. */
#define RBX_PAUSE 0x14 /* -p */
#define RBX_QUIET 0x15 /* -q */
#define RBX_NOINTR 0x1c /* -n */
/* 0x1d is reserved for log2(RB_MULTIPLE) and is just misnamed here. */
#define RBX_DUAL 0x1d /* -D */
/* 0x1f is reserved for log2(RB_BOOTINFO). */
/* pass: -a, -s, -r, -d, -c, -v, -h, -C, -g, -m, -p, -D */
#define RBX_MASK (OPT_SET(RBX_ASKNAME) | OPT_SET(RBX_SINGLE) | \
OPT_SET(RBX_DFLTROOT) | OPT_SET(RBX_KDB ) | \
OPT_SET(RBX_CONFIG) | OPT_SET(RBX_VERBOSE) | \
OPT_SET(RBX_SERIAL) | OPT_SET(RBX_CDROM) | \
OPT_SET(RBX_GDB ) | OPT_SET(RBX_MUTE) | \
OPT_SET(RBX_PAUSE) | OPT_SET(RBX_DUAL))
#define OPT_SET(opt) (1 << (opt))
#define OPT_CHECK(opt) ((opts) & OPT_SET(opt))
extern uint32_t opts;
#endif /* !_RBX_H_ */

13
sys/boot/i386/gptboot/Makefile
View File

@ -1,6 +1,6 @@
# $FreeBSD$
.PATH: ${.CURDIR}/../boot2
.PATH: ${.CURDIR}/../boot2 ${.CURDIR}/../common ${.CURDIR}/../../common
FILES= gptboot
@ -19,18 +19,21 @@ GPTBOOT_UFS?= UFS1_AND_UFS2
#GPTBOOT_UFS?= UFS2_ONLY
#GPTBOOT_UFS?= UFS1_ONLY
CFLAGS= -Os \
CFLAGS= -DBOOTPROG=\"gptboot\" \
-Os \
-fno-guess-branch-probability \
-fomit-frame-pointer \
-fno-unit-at-a-time \
-mno-align-long-strings \
-mrtd \
-mno-mmx -mno-3dnow -mno-sse -mno-sse2 -mno-sse3 \
-DGPT \
-D${GPTBOOT_UFS} \
-DSIOPRT=${BOOT_COMCONSOLE_PORT} \
-DSIOFMT=${B2SIOFMT} \
-DSIOSPD=${BOOT_COMCONSOLE_SPEED} \
-I${.CURDIR}/../../common \
-I${.CURDIR}/../common \
-I${.CURDIR}/../btx/lib -I. \
-I${.CURDIR}/../boot2 \
-Wall -Waggregate-return -Wbad-function-cast -Wcast-align \
@ -57,13 +60,13 @@ gptldr.bin: gptldr.out
gptldr.out: gptldr.o
${LD} ${LDFLAGS} -e start -Ttext ${ORG1} -o ${.TARGET} gptldr.o
CLEANFILES+= gptboot.bin gptboot.out gptboot.o sio.o
CLEANFILES+= gptboot.bin gptboot.out gptboot.o sio.o ufsread.o
gptboot.bin: gptboot.out
objcopy -S -O binary gptboot.out ${.TARGET}
gptboot.out: ${BTXCRT} gptboot.o sio.o
${LD} ${LDFLAGS} -Ttext ${ORG2} -o ${.TARGET} ${.ALLSRC}
gptboot.out: ${BTXCRT} gptboot.o sio.o gpt.o crc32.o drv.o cons.o util.o
${LD} ${LDFLAGS} -Ttext ${ORG2} -o ${.TARGET} ${.ALLSRC} ${LIBSTAND}
gptboot.o: ${.CURDIR}/../../common/ufsread.c

566
sys/boot/i386/gptboot/gptboot.c
View File

@ -32,46 +32,11 @@ __FBSDID("$FreeBSD$");
#include <btxv86.h>
#include "lib.h"
#define IO_KEYBOARD 1
#define IO_SERIAL 2
#define SECOND 18 /* Circa that many ticks in a second. */
#define RBX_ASKNAME 0x0 /* -a */
#define RBX_SINGLE 0x1 /* -s */
/* 0x2 is reserved for log2(RB_NOSYNC). */
/* 0x3 is reserved for log2(RB_HALT). */
/* 0x4 is reserved for log2(RB_INITNAME). */
#define RBX_DFLTROOT 0x5 /* -r */
#define RBX_KDB 0x6 /* -d */
/* 0x7 is reserved for log2(RB_RDONLY). */
/* 0x8 is reserved for log2(RB_DUMP). */
/* 0x9 is reserved for log2(RB_MINIROOT). */
#define RBX_CONFIG 0xa /* -c */
#define RBX_VERBOSE 0xb /* -v */
#define RBX_SERIAL 0xc /* -h */
#define RBX_CDROM 0xd /* -C */
/* 0xe is reserved for log2(RB_POWEROFF). */
#define RBX_GDB 0xf /* -g */
#define RBX_MUTE 0x10 /* -m */
/* 0x11 is reserved for log2(RB_SELFTEST). */
/* 0x12 is reserved for boot programs. */
/* 0x13 is reserved for boot programs. */
#define RBX_PAUSE 0x14 /* -p */
#define RBX_QUIET 0x15 /* -q */
#define RBX_NOINTR 0x1c /* -n */
/* 0x1d is reserved for log2(RB_MULTIPLE) and is just misnamed here. */
#define RBX_DUAL 0x1d /* -D */
/* 0x1f is reserved for log2(RB_BOOTINFO). */
/* pass: -a, -s, -r, -d, -c, -v, -h, -C, -g, -m, -p, -D */
#define RBX_MASK (OPT_SET(RBX_ASKNAME) | OPT_SET(RBX_SINGLE) | \
OPT_SET(RBX_DFLTROOT) | OPT_SET(RBX_KDB ) | \
OPT_SET(RBX_CONFIG) | OPT_SET(RBX_VERBOSE) | \
OPT_SET(RBX_SERIAL) | OPT_SET(RBX_CDROM) | \
OPT_SET(RBX_GDB ) | OPT_SET(RBX_MUTE) | \
OPT_SET(RBX_PAUSE) | OPT_SET(RBX_DUAL))
#include "rbx.h"
#include "drv.h"
#include "util.h"
#include "cons.h"
#include "gpt.h"
#define PATH_CONFIG "/boot.config"
#define PATH_BOOT3 "/boot/loader"
@ -82,8 +47,6 @@ __FBSDID("$FreeBSD$");
#define NDEV 3
#define MEM_BASE 0x12
#define MEM_EXT 0x15
#define V86_CY(x) ((x) & PSL_C)
#define V86_ZR(x) ((x) & PSL_Z)
#define DRV_HARD 0x80
#define DRV_MASK 0x7f
@ -93,211 +56,178 @@ __FBSDID("$FreeBSD$");
#define TYPE_MAXHARD TYPE_DA
#define TYPE_FD 2
#define OPT_SET(opt) (1 << (opt))
#define OPT_CHECK(opt) ((opts) & OPT_SET(opt))
extern uint32_t _end;
static const uuid_t freebsd_ufs_uuid = GPT_ENT_TYPE_FREEBSD_UFS;
static const char optstr[NOPT] = "DhaCcdgmnpqrsv"; /* Also 'P', 'S' */
static const unsigned char flags[NOPT] = {
RBX_DUAL,
RBX_SERIAL,
RBX_ASKNAME,
RBX_CDROM,
RBX_CONFIG,
RBX_KDB,
RBX_GDB,
RBX_MUTE,
RBX_NOINTR,
RBX_PAUSE,
RBX_QUIET,
RBX_DFLTROOT,
RBX_SINGLE,
RBX_VERBOSE
RBX_DUAL,
RBX_SERIAL,
RBX_ASKNAME,
RBX_CDROM,
RBX_CONFIG,
RBX_KDB,
RBX_GDB,
RBX_MUTE,
RBX_NOINTR,
RBX_PAUSE,
RBX_QUIET,
RBX_DFLTROOT,
RBX_SINGLE,
RBX_VERBOSE
};
uint32_t opts;
static const char *const dev_nm[NDEV] = {"ad", "da", "fd"};
static const unsigned char dev_maj[NDEV] = {30, 4, 2};
static struct dsk {
unsigned drive;
unsigned type;
unsigned unit;
int part;
daddr_t start;
int init;
} dsk;
static char cmd[512], cmddup[512];
static struct dsk dsk;
static char kname[1024];
static uint32_t opts;
static int comspeed = SIOSPD;
static struct bootinfo bootinfo;
static uint8_t ioctrl = IO_KEYBOARD;
void exit(int);
static int bcmp(const void *, const void *, size_t);
static void load(void);
static int parse(void);
static int parse(char *, int *);
static int xfsread(ino_t, void *, size_t);
static int dskread(void *, daddr_t, unsigned);
static void printf(const char *,...);
static void putchar(int);
static void memcpy(void *, const void *, int);
static uint32_t memsize(void);
static int drvread(void *, daddr_t, unsigned);
static int keyhit(unsigned);
static int xputc(int);
static int xgetc(int);
static int getc(int);
static void
memcpy(void *dst, const void *src, int len)
{
const char *s = src;
char *d = dst;
while (len--)
*d++ = *s++;
}
static inline int
strcmp(const char *s1, const char *s2)
{
for (; *s1 == *s2 && *s1; s1++, s2++);
return (unsigned char)*s1 - (unsigned char)*s2;
}
#include "ufsread.c"
static inline int
xfsread(ino_t inode, void *buf, size_t nbyte)
{
if ((size_t)fsread(inode, buf, nbyte) != nbyte) {
printf("Invalid %s\n", "format");
return -1;
}
return 0;
if ((size_t)fsread(inode, buf, nbyte) != nbyte) {
printf("Invalid %s\n", "format");
return (-1);
}
return (0);
}
static inline uint32_t
memsize(void)
{
v86.addr = MEM_EXT;
v86.eax = 0x8800;
v86int();
return v86.eax;
v86.addr = MEM_EXT;
v86.eax = 0x8800;
v86int();
return (v86.eax);
}
static inline void
getstr(void)
static int
gptinit(void)
{
char *s;
int c;
s = cmd;
for (;;) {
switch (c = xgetc(0)) {
case 0:
break;
case '\177':
case '\b':
if (s > cmd) {
s--;
printf("\b \b");
}
break;
case '\n':
case '\r':
*s = 0;
return;
default:
if (s - cmd < sizeof(cmd) - 1)
*s++ = c;
putchar(c);
if (gptread(&freebsd_ufs_uuid, &dsk, dmadat->secbuf) == -1) {
printf("%s: unable to load GPT\n", BOOTPROG);
return (-1);
}
}
}
static inline void
putc(int c)
{
v86.addr = 0x10;
v86.eax = 0xe00 | (c & 0xff);
v86.ebx = 0x7;
v86int();
if (gptfind(&freebsd_ufs_uuid, &dsk, dsk.part) == -1) {
printf("%s: no UFS partition was found\n", BOOTPROG);
return (-1);
}
dsk_meta = 0;
return (0);
}
int
main(void)
{
int autoboot;
ino_t ino;
char cmd[512], cmdtmp[512];
int autoboot, dskupdated;
ino_t ino;
dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
v86.ctl = V86_FLAGS;
v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
dsk.drive = *(uint8_t *)PTOV(ARGS);
dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
dsk.unit = dsk.drive & DRV_MASK;
dsk.part = -1;
bootinfo.bi_version = BOOTINFO_VERSION;
bootinfo.bi_size = sizeof(bootinfo);
bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */
bootinfo.bi_extmem = memsize();
bootinfo.bi_memsizes_valid++;
dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
v86.ctl = V86_FLAGS;
v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
dsk.drive = *(uint8_t *)PTOV(ARGS);
dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
dsk.unit = dsk.drive & DRV_MASK;
dsk.part = -1;
dsk.start = 0;
bootinfo.bi_version = BOOTINFO_VERSION;
bootinfo.bi_size = sizeof(bootinfo);
bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */
bootinfo.bi_extmem = memsize();
bootinfo.bi_memsizes_valid++;
/* Process configuration file */
/* Process configuration file */
autoboot = 1;
if (gptinit() != 0)
return (-1);
if ((ino = lookup(PATH_CONFIG)))
fsread(ino, cmd, sizeof(cmd));
autoboot = 1;
*cmd = '\0';
if (*cmd) {
memcpy(cmddup, cmd, sizeof(cmd));
if (parse())
autoboot = 0;
if (!OPT_CHECK(RBX_QUIET))
printf("%s: %s", PATH_CONFIG, cmddup);
/* Do not process this command twice */
*cmd = 0;
}
for (;;) {
*kname = '\0';
ino = lookup(PATH_CONFIG);
if (ino > 0)
fsread(ino, cmd, sizeof(cmd));
/*
* Try to exec stage 3 boot loader. If interrupted by a keypress,
* or in case of failure, try to load a kernel directly instead.
*/
if (*cmd != '\0') {
memcpy(cmdtmp, cmd, sizeof(cmdtmp));
if (parse(cmdtmp, &dskupdated))
break;
if (dskupdated && gptinit() != 0)
break;
if (!OPT_CHECK(RBX_QUIET))
printf("%s: %s", PATH_CONFIG, cmd);
*cmd = '\0';
}
if (autoboot && !*kname) {
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
if (!keyhit(3*SECOND)) {
load();
memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL));
if (autoboot && keyhit(3)) {
if (*kname == '\0')
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
break;
}
autoboot = 0;
/*
* Try to exec stage 3 boot loader. If interrupted by a
* keypress, or in case of failure, try to load a kernel
* directly instead.
*/
if (*kname != '\0')
load();
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
load();
memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL));
load();
gptbootfailed(&dsk);
if (gptfind(&freebsd_ufs_uuid, &dsk, -1) == -1)
break;
dsk_meta = 0;
}
}
/* Present the user with the boot2 prompt. */
/* Present the user with the boot2 prompt. */
for (;;) {
if (!autoboot || !OPT_CHECK(RBX_QUIET))
printf("\nFreeBSD/x86 boot\n"
"Default: %u:%s(%up%u)%s\n"
"boot: ",
dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
dsk.part, kname);
if (ioctrl & IO_SERIAL)
sio_flush();
if (!autoboot || keyhit(5*SECOND))
getstr();
else if (!autoboot || !OPT_CHECK(RBX_QUIET))
putchar('\n');
autoboot = 0;
if (parse())
putchar('\a');
else
load();
}
for (;;) {
if (!OPT_CHECK(RBX_QUIET)) {
printf("\nFreeBSD/x86 boot\n"
"Default: %u:%s(%up%u)%s\n"
"boot: ",
dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
dsk.part, kname);
}
if (ioctrl & IO_SERIAL)
sio_flush();
*cmd = '\0';
if (keyhit(0))
getstr(cmd, sizeof(cmd));
else if (!OPT_CHECK(RBX_QUIET))
putchar('\n');
if (parse(cmd, &dskupdated)) {
putchar('\a');
continue;
}
if (dskupdated && gptinit() != 0)
continue;
load();
}
/* NOTREACHED */
}
/* XXX - Needed for btxld to link the boot2 binary; do not remove. */
@ -321,8 +251,11 @@ load(void)
int fmt, i, j;
if (!(ino = lookup(kname))) {
if (!ls)
printf("No %s\n", kname);
if (!ls) {
printf("%s: No %s on %u:%s(%up%u)\n", BOOTPROG,
kname, dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
dsk.part);
}
return;
}
if (xfsread(ino, &hdr, sizeof(hdr)))
@ -402,14 +335,15 @@ load(void)
}
static int
parse(void)
parse(char *cmdstr, int *dskupdated)
{
char *arg = cmd;
char *arg = cmdstr;
char *ep, *p, *q;
const char *cp;
unsigned int drv;
int c, i, j;
*dskupdated = 0;
while ((c = *arg++)) {
if (c == ' ' || c == '\t' || c == '\n')
continue;
@ -480,7 +414,7 @@ parse(void)
drv = dsk.unit;
dsk.drive = (dsk.type <= TYPE_MAXHARD
? DRV_HARD : 0) + drv;
dsk_meta = 0;
*dskupdated = 1;
}
if ((i = ep - arg)) {
if ((size_t)i >= sizeof(kname))
@ -496,232 +430,6 @@ parse(void)
static int
dskread(void *buf, daddr_t lba, unsigned nblk)
{
struct gpt_hdr hdr;
struct gpt_ent *ent;
char *sec;
daddr_t slba, elba;
int part, entries_per_sec;
if (!dsk_meta) {
/* Read and verify GPT. */
sec = dmadat->secbuf;
dsk.start = 0;
if (drvread(sec, 1, 1))
return -1;
memcpy(&hdr, sec, sizeof(hdr));
if (bcmp(hdr.hdr_sig, GPT_HDR_SIG, sizeof(hdr.hdr_sig)) != 0 ||
hdr.hdr_lba_self != 1 || hdr.hdr_revision < 0x00010000 ||
hdr.hdr_entsz < sizeof(*ent) || DEV_BSIZE % hdr.hdr_entsz != 0) {
printf("Invalid GPT header\n");
return -1;
}
/* XXX: CRC check? */
/*
* If the partition isn't specified, then search for the first UFS
* partition and hope it is /. Perhaps we should be using an OS
* flag in the GPT entry to mark / partitions.
*
* If the partition is specified, then figure out the LBA for the
* sector containing that partition index and load it.
*/
entries_per_sec = DEV_BSIZE / hdr.hdr_entsz;
if (dsk.part == -1) {
slba = hdr.hdr_lba_table;
elba = slba + hdr.hdr_entries / entries_per_sec;
while (slba < elba && dsk.part == -1) {
if (drvread(sec, slba, 1))
return -1;
for (part = 0; part < entries_per_sec; part++) {
ent = (struct gpt_ent *)(sec + part * hdr.hdr_entsz);
if (bcmp(&ent->ent_type, &freebsd_ufs_uuid,
sizeof(uuid_t)) == 0) {
dsk.part = (slba - hdr.hdr_lba_table) *
entries_per_sec + part + 1;
dsk.start = ent->ent_lba_start;
break;
}
}
slba++;
}
if (dsk.part == -1) {
printf("No UFS partition was found\n");
return -1;
}
} else {
if (dsk.part > hdr.hdr_entries) {
printf("Invalid partition index\n");
return -1;
}
slba = hdr.hdr_lba_table + (dsk.part - 1) / entries_per_sec;
if (drvread(sec, slba, 1))
return -1;
part = (dsk.part - 1) % entries_per_sec;
ent = (struct gpt_ent *)(sec + part * hdr.hdr_entsz);
if (bcmp(&ent->ent_type, &freebsd_ufs_uuid, sizeof(uuid_t)) != 0) {
printf("Specified partition is not UFS\n");
return -1;
}
dsk.start = ent->ent_lba_start;
}
/*
* XXX: No way to detect SCSI vs. ATA currently.
*/
#if 0
if (!dsk.init) {
if (d->d_type == DTYPE_SCSI)
dsk.type = TYPE_DA;
dsk.init++;
}
#endif
}
return drvread(buf, dsk.start + lba, nblk);
}
static void
printf(const char *fmt,...)
{
va_list ap;
char buf[10];
char *s;
unsigned u;
int c;
va_start(ap, fmt);
while ((c = *fmt++)) {
if (c == '%') {
c = *fmt++;
switch (c) {
case 'c':
putchar(va_arg(ap, int));
continue;
case 's':
for (s = va_arg(ap, char *); *s; s++)
putchar(*s);
continue;
case 'u':
u = va_arg(ap, unsigned);
s = buf;
do
*s++ = '0' + u % 10U;
while (u /= 10U);
while (--s >= buf)
putchar(*s);
continue;
}
}
putchar(c);
}
va_end(ap);
return;
}
static void
putchar(int c)
{
if (c == '\n')
xputc('\r');
xputc(c);
}
static int
bcmp(const void *b1, const void *b2, size_t length)
{
const char *p1 = b1, *p2 = b2;
if (length == 0)
return (0);
do {
if (*p1++ != *p2++)
break;
} while (--length);
return (length);
}
static struct {
uint16_t len;
uint16_t count;
uint16_t off;
uint16_t seg;
uint64_t lba;
} packet;
static int
drvread(void *buf, daddr_t lba, unsigned nblk)
{
static unsigned c = 0x2d5c7c2f;
if (!OPT_CHECK(RBX_QUIET))
printf("%c\b", c = c << 8 | c >> 24);
packet.len = 0x10;
packet.count = nblk;
packet.off = VTOPOFF(buf);
packet.seg = VTOPSEG(buf);
packet.lba = lba;
v86.ctl = V86_FLAGS;
v86.addr = 0x13;
v86.eax = 0x4200;
v86.edx = dsk.drive;
v86.ds = VTOPSEG(&packet);
v86.esi = VTOPOFF(&packet);
v86int();
if (V86_CY(v86.efl)) {
printf("error %u lba %u\n", v86.eax >> 8 & 0xff, lba);
return -1;
}
return 0;
}
static int
keyhit(unsigned ticks)
{
uint32_t t0, t1;
if (OPT_CHECK(RBX_NOINTR))
return 0;
t0 = 0;
for (;;) {
if (xgetc(1))
return 1;
t1 = *(uint32_t *)PTOV(0x46c);
if (!t0)
t0 = t1;
if (t1 < t0 || t1 >= t0 + ticks)
return 0;
}
}
static int
xputc(int c)
{
if (ioctrl & IO_KEYBOARD)
putc(c);
if (ioctrl & IO_SERIAL)
sio_putc(c);
return c;
}
static int
xgetc(int fn)
{
if (OPT_CHECK(RBX_NOINTR))
return 0;
for (;;) {
if (ioctrl & IO_KEYBOARD && getc(1))
return fn ? 1 : getc(0);
if (ioctrl & IO_SERIAL && sio_ischar())
return fn ? 1 : sio_getc();
if (fn)
return 0;
}
}
static int
getc(int fn)
{
v86.addr = 0x16;
v86.eax = fn << 8;
v86int();
return fn == 0 ? v86.eax & 0xff : !V86_ZR(v86.efl);
return drvread(&dsk, buf, lba + dsk.start, nblk);
}

10
sys/boot/i386/gptzfsboot/Makefile
View File

@ -1,6 +1,8 @@
# $FreeBSD$
.PATH: ${.CURDIR}/../boot2 ${.CURDIR}/../gptboot ${.CURDIR}/../zfsboot
.PATH: ${.CURDIR}/../boot2 ${.CURDIR}/../gptboot \
${.CURDIR}/../zfsboot ${.CURDIR}/../common \
${.CURDIR}/../../common
FILES= gptzfsboot
@ -14,7 +16,8 @@ REL1= 0x700
ORG1= 0x7c00
ORG2= 0x0
CFLAGS= -Os \
CFLAGS= -DBOOTPROG=\"gptzfsboot\" \
-Os \
-fno-guess-branch-probability \
-fomit-frame-pointer \
-fno-unit-at-a-time \
@ -26,6 +29,7 @@ CFLAGS= -Os \
-DSIOFMT=${B2SIOFMT} \
-DSIOSPD=${BOOT_COMCONSOLE_SPEED} \
-I${.CURDIR}/../../common \
-I${.CURDIR}/../common \
-I${.CURDIR}/../../zfs \
-I${.CURDIR}/../../../cddl/boot/zfs \
-I${.CURDIR}/../btx/lib -I. \
@ -59,7 +63,7 @@ CLEANFILES+= gptzfsboot.bin gptzfsboot.out zfsboot.o sio.o
gptzfsboot.bin: gptzfsboot.out
objcopy -S -O binary gptzfsboot.out ${.TARGET}
gptzfsboot.out: ${BTXCRT} zfsboot.o sio.o
gptzfsboot.out: ${BTXCRT} zfsboot.o sio.o gpt.o drv.o cons.o util.o
${LD} ${LDFLAGS} -Ttext ${ORG2} -o ${.TARGET} ${.ALLSRC} ${LIBSTAND}
zfsboot.o: ${.CURDIR}/../../zfs/zfsimpl.c

17
sys/boot/i386/zfsboot/Makefile
View File

@ -1,6 +1,6 @@
# $FreeBSD$
.PATH: ${.CURDIR}/../boot2
.PATH: ${.CURDIR}/../boot2 ${.CURDIR}/../common ${.CURDIR}/../../common
FILES= zfsboot
@ -17,7 +17,8 @@ REL1= 0x700
ORG1= 0x7c00
ORG2= 0x2000
CFLAGS= -Os -g \
CFLAGS= -DBOOTPROG=\"zfsboot\" \
-Os -g \
-fno-guess-branch-probability \
-fomit-frame-pointer \
-fno-unit-at-a-time \
@ -29,6 +30,8 @@ CFLAGS= -Os -g \
-DSIOPRT=${BOOT_COMCONSOLE_PORT} \
-DSIOFMT=${B2SIOFMT} \
-DSIOSPD=${BOOT_COMCONSOLE_SPEED} \
-I${.CURDIR}/../../common \
-I${.CURDIR}/../common \
-I${.CURDIR}/../../zfs \
-I${.CURDIR}/../../../cddl/boot/zfs \
-I${.CURDIR}/../btx/lib -I. \
@ -57,7 +60,7 @@ zfsldr.out: zfsldr.o
${LD} ${LDFLAGS} -e start -Ttext ${ORG1} -o ${.TARGET} zfsldr.o
CLEANFILES+= zfsboot2 zfsboot.ld zfsboot.ldr zfsboot.bin zfsboot.out \
zfsboot.o zfsboot.s zfsboot.s.tmp zfsboot.h sio.o
zfsboot.o zfsboot.s zfsboot.s.tmp xreadorg.h sio.o
# We currently allow 32768 bytes for zfsboot - in practice it could be
# any size up to 3.5Mb but keeping it fixed size simplifies zfsldr.
@ -79,19 +82,19 @@ zfsboot.ldr:
zfsboot.bin: zfsboot.out
objcopy -S -O binary zfsboot.out ${.TARGET}
zfsboot.out: ${BTXCRT} zfsboot.o sio.o
zfsboot.out: ${BTXCRT} zfsboot.o sio.o drv.o cons.o util.o
${LD} ${LDFLAGS} -Ttext ${ORG2} -o ${.TARGET} ${.ALLSRC} ${LIBSTAND}
zfsboot.o: zfsboot.s
SRCS= zfsboot.c zfsboot.h
SRCS= zfsboot.c xreadorg.h
zfsboot.s: zfsboot.c zfsboot.h ${.CURDIR}/../../zfs/zfsimpl.c
zfsboot.s: zfsboot.c xreadorg.h ${.CURDIR}/../../zfs/zfsimpl.c
${CC} ${CFLAGS} -S -o zfsboot.s.tmp ${.CURDIR}/zfsboot.c
sed -e '/align/d' -e '/nop/d' < zfsboot.s.tmp > zfsboot.s
rm -f zfsboot.s.tmp
zfsboot.h: zfsldr.out
xreadorg.h: zfsldr.out
${NM} -t d ${.ALLSRC} | awk '/([0-9])+ T xread/ \
{ x = $$1 - ORG1; \
printf("#define XREADORG %#x\n", REL1 + x) }' \

419
sys/boot/i386/zfsboot/zfsboot.c
View File

@ -36,50 +36,11 @@ __FBSDID("$FreeBSD$");
#include <btxv86.h>
#ifndef GPT
#include "zfsboot.h"
#endif
#include "lib.h"
#define IO_KEYBOARD 1
#define IO_SERIAL 2
#define SECOND 18 /* Circa that many ticks in a second. */
#define RBX_ASKNAME 0x0 /* -a */
#define RBX_SINGLE 0x1 /* -s */
/* 0x2 is reserved for log2(RB_NOSYNC). */
/* 0x3 is reserved for log2(RB_HALT). */
/* 0x4 is reserved for log2(RB_INITNAME). */
#define RBX_DFLTROOT 0x5 /* -r */
#define RBX_KDB 0x6 /* -d */
/* 0x7 is reserved for log2(RB_RDONLY). */
/* 0x8 is reserved for log2(RB_DUMP). */
/* 0x9 is reserved for log2(RB_MINIROOT). */
#define RBX_CONFIG 0xa /* -c */
#define RBX_VERBOSE 0xb /* -v */
#define RBX_SERIAL 0xc /* -h */
#define RBX_CDROM 0xd /* -C */
/* 0xe is reserved for log2(RB_POWEROFF). */
#define RBX_GDB 0xf /* -g */
#define RBX_MUTE 0x10 /* -m */
/* 0x11 is reserved for log2(RB_SELFTEST). */
/* 0x12 is reserved for boot programs. */
/* 0x13 is reserved for boot programs. */
#define RBX_PAUSE 0x14 /* -p */
#define RBX_QUIET 0x15 /* -q */
#define RBX_NOINTR 0x1c /* -n */
/* 0x1d is reserved for log2(RB_MULTIPLE) and is just misnamed here. */
#define RBX_DUAL 0x1d /* -D */
/* 0x1f is reserved for log2(RB_BOOTINFO). */
/* pass: -a, -s, -r, -d, -c, -v, -h, -C, -g, -m, -p, -D */
#define RBX_MASK (OPT_SET(RBX_ASKNAME) | OPT_SET(RBX_SINGLE) | \
OPT_SET(RBX_DFLTROOT) | OPT_SET(RBX_KDB ) | \
OPT_SET(RBX_CONFIG) | OPT_SET(RBX_VERBOSE) | \
OPT_SET(RBX_SERIAL) | OPT_SET(RBX_CDROM) | \
OPT_SET(RBX_GDB ) | OPT_SET(RBX_MUTE) | \
OPT_SET(RBX_PAUSE) | OPT_SET(RBX_DUAL))
#include "rbx.h"
#include "drv.h"
#include "util.h"
#include "cons.h"
/* Hint to loader that we came from ZFS */
#define KARGS_FLAGS_ZFS 0x4
@ -91,8 +52,6 @@ __FBSDID("$FreeBSD$");
#define ARGS 0x900
#define NOPT 14
#define NDEV 3
#define V86_CY(x) ((x) & 1)
#define V86_ZR(x) ((x) & 0x40)
#define BIOS_NUMDRIVES 0x475
#define DRV_HARD 0x80
@ -103,8 +62,7 @@ __FBSDID("$FreeBSD$");
#define TYPE_MAXHARD TYPE_DA
#define TYPE_FD 2
#define OPT_SET(opt) (1 << (opt))
#define OPT_CHECK(opt) ((opts) & OPT_SET(opt))
#define MAXBDDEV 31
extern uint32_t _end;
@ -128,26 +86,16 @@ static const unsigned char flags[NOPT] = {
RBX_SINGLE,
RBX_VERBOSE
};
uint32_t opts;
static const char *const dev_nm[NDEV] = {"ad", "da", "fd"};
static const unsigned char dev_maj[NDEV] = {30, 4, 2};
struct dsk {
unsigned drive;
unsigned type;
unsigned unit;
unsigned slice;
unsigned part;
int init;
daddr_t start;
};
static char cmd[512];
static char kname[1024];
static uint32_t opts;
static int comspeed = SIOSPD;
static struct bootinfo bootinfo;
static uint32_t bootdev;
static uint8_t ioctrl = IO_KEYBOARD;
vm_offset_t high_heap_base;
uint32_t bios_basemem, bios_extmem, high_heap_size;
@ -173,79 +121,7 @@ static struct dmadat *dmadat;
void exit(int);
static void load(void);
static int parse(void);
static void printf(const char *,...);
static void putchar(int);
static void bios_getmem(void);
static int drvread(struct dsk *, void *, daddr_t, unsigned);
static int keyhit(unsigned);
static int xputc(int);
static int xgetc(int);
static int getc(int);
static void memcpy(void *, const void *, int);
static void
memcpy(void *dst, const void *src, int len)
{
const char *s = src;
char *d = dst;
while (len--)
*d++ = *s++;
}
static void
strcpy(char *dst, const char *src)
{
while (*src)
*dst++ = *src++;
*dst++ = 0;
}
static void
strcat(char *dst, const char *src)
{
while (*dst)
dst++;
while (*src)
*dst++ = *src++;
*dst++ = 0;
}
static int
strcmp(const char *s1, const char *s2)
{
for (; *s1 == *s2 && *s1; s1++, s2++);
return (unsigned char)*s1 - (unsigned char)*s2;
}
static const char *
strchr(const char *s, char ch)
{
for (; *s; s++)
if (*s == ch)
return s;
return 0;
}
static int
memcmp(const void *p1, const void *p2, size_t n)
{
const char *s1 = (const char *) p1;
const char *s2 = (const char *) p2;
for (; n > 0 && *s1 == *s2; s1++, s2++, n--);
if (n)
return (unsigned char)*s1 - (unsigned char)*s2;
else
return 0;
}
static void
memset(void *p, char val, size_t n)
{
char *s = (char *) p;
while (n--)
*s++ = val;
}
static void *
malloc(size_t n)
@ -261,15 +137,6 @@ malloc(size_t n)
return p;
}
static size_t
strlen(const char *s)
{
size_t len = 0;
while (*s++)
len++;
return len;
}
static char *
strdup(const char *s)
{
@ -324,6 +191,7 @@ vdev_read(vdev_t *vdev, void *priv, off_t off, void *buf, size_t bytes)
p = buf;
lba = off / DEV_BSIZE;
lba += dsk->start;
while (bytes > 0) {
nb = bytes / DEV_BSIZE;
if (nb > READ_BUF_SIZE / DEV_BSIZE)
@ -435,46 +303,6 @@ bios_getmem(void)
}
}
static inline void
getstr(void)
{
char *s;
int c;
s = cmd;
for (;;) {
switch (c = xgetc(0)) {
case 0:
break;
case '\177':
case '\b':
if (s > cmd) {
s--;
printf("\b \b");
}
break;
case '\n':
case '\r':
*s = 0;
return;
default:
if (s - cmd < sizeof(cmd) - 1)
*s++ = c;
putchar(c);
}
}
}
static inline void
putc(int c)
{
v86.ctl = 0;
v86.addr = 0x10;
v86.eax = 0xe00 | (c & 0xff);
v86.ebx = 0x7;
v86int();
}
/*
* Try to detect a device supported by the legacy int13 BIOS
*/
@ -571,7 +399,7 @@ probe_drive(struct dsk *dsk, spa_t **spap)
* We record the first pool we find (we will try
* to boot from that one).
*/
spap = 0;
spap = NULL;
/*
* This slice had a vdev. We need a new dsk
@ -687,7 +515,7 @@ main(void)
dsk->part = 0;
dsk->start = 0;
dsk->init = 0;
probe_drive(dsk, 0);
probe_drive(dsk, NULL);
}
/*
@ -697,7 +525,7 @@ main(void)
if (!spa) {
spa = STAILQ_FIRST(&zfs_pools);
if (!spa) {
printf("No ZFS pools located, can't boot\n");
printf("%s: No ZFS pools located, can't boot\n", BOOTPROG);
for (;;)
;
}
@ -726,7 +554,7 @@ main(void)
if (autoboot && !*kname) {
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
if (!keyhit(3*SECOND)) {
if (!keyhit(3)) {
load();
memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL));
}
@ -742,8 +570,8 @@ main(void)
spa->spa_name, kname);
if (ioctrl & IO_SERIAL)
sio_flush();
if (!autoboot || keyhit(5*SECOND))
getstr();
if (!autoboot || keyhit(5))
getstr(cmd, sizeof(cmd));
else if (!autoboot || !OPT_CHECK(RBX_QUIET))
putchar('\n');
autoboot = 0;
@ -858,7 +686,7 @@ load(void)
}
static int
parse()
parse(void)
{
char *arg = cmd;
char *ep, *p, *q;
@ -950,222 +778,3 @@ parse()
}
return 0;
}
static void
printf(const char *fmt,...)
{
va_list ap;
char buf[20];
char *s;
unsigned long long u;
int c;
int minus;
int prec;
int l;
int len;
int pad;
va_start(ap, fmt);
while ((c = *fmt++)) {
if (c == '%') {
minus = 0;
prec = 0;
l = 0;
nextfmt:
c = *fmt++;
switch (c) {
case '-':
minus = 1;
goto nextfmt;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
prec = 10 * prec + (c - '0');
goto nextfmt;
case 'c':
putchar(va_arg(ap, int));
continue;
case 'l':
l++;
goto nextfmt;
case 's':
s = va_arg(ap, char *);
if (prec) {
len = strlen(s);
if (len < prec)
pad = prec - len;
else
pad = 0;
if (minus)
while (pad--)
putchar(' ');
for (; *s; s++)
putchar(*s);
if (!minus)
while (pad--)
putchar(' ');
} else {
for (; *s; s++)
putchar(*s);
}
continue;
case 'u':
switch (l) {
case 2:
u = va_arg(ap, unsigned long long);
break;
case 1:
u = va_arg(ap, unsigned long);
break;
default:
u = va_arg(ap, unsigned);
break;
}
s = buf;
do
*s++ = '0' + u % 10U;
while (u /= 10U);
while (--s >= buf)
putchar(*s);
continue;
}
}
putchar(c);
}
va_end(ap);
return;
}
static void
putchar(int c)
{
if (c == '\n')
xputc('\r');
xputc(c);
}
#ifdef GPT
static struct {
uint16_t len;
uint16_t count;
uint16_t off;
uint16_t seg;
uint64_t lba;
} packet;
#endif
static int
drvread(struct dsk *dsk, void *buf, daddr_t lba, unsigned nblk)
{
#ifdef GPT
static unsigned c = 0x2d5c7c2f;
if (!OPT_CHECK(RBX_QUIET))
printf("%c\b", c = c << 8 | c >> 24);
packet.len = 0x10;
packet.count = nblk;
packet.off = VTOPOFF(buf);
packet.seg = VTOPSEG(buf);
packet.lba = lba + dsk->start;
v86.ctl = V86_FLAGS;
v86.addr = 0x13;
v86.eax = 0x4200;
v86.edx = dsk->drive;
v86.ds = VTOPSEG(&packet);
v86.esi = VTOPOFF(&packet);
v86int();
if (V86_CY(v86.efl)) {
printf("error %u lba %u\n", v86.eax >> 8 & 0xff, lba);
return -1;
}
return 0;
#else
static unsigned c = 0x2d5c7c2f;
lba += dsk->start;
if (!OPT_CHECK(RBX_QUIET))
printf("%c\b", c = c << 8 | c >> 24);
v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
v86.addr = XREADORG; /* call to xread in boot1 */
v86.es = VTOPSEG(buf);
v86.eax = lba;
v86.ebx = VTOPOFF(buf);
v86.ecx = lba >> 32;
v86.edx = nblk << 8 | dsk->drive;
v86int();
v86.ctl = V86_FLAGS;
if (V86_CY(v86.efl)) {
printf("error %u lba %u\n", v86.eax >> 8 & 0xff, lba);
return -1;
}
return 0;
#endif
}
static int
keyhit(unsigned ticks)
{
uint32_t t0, t1;
if (OPT_CHECK(RBX_NOINTR))
return 0;
t0 = 0;
for (;;) {
if (xgetc(1))
return 1;
t1 = *(uint32_t *)PTOV(0x46c);
if (!t0)
t0 = t1;
if (t1 < t0 || t1 >= t0 + ticks)
return 0;
}
}
static int
xputc(int c)
{
if (ioctrl & IO_KEYBOARD)
putc(c);
if (ioctrl & IO_SERIAL)
sio_putc(c);
return c;
}
static int
xgetc(int fn)
{
if (OPT_CHECK(RBX_NOINTR))
return 0;
for (;;) {
if (ioctrl & IO_KEYBOARD && getc(1))
return fn ? 1 : getc(0);
if (ioctrl & IO_SERIAL && sio_ischar())
return fn ? 1 : sio_getc();
if (fn)
return 0;
}
}
static int
getc(int fn)
{
/*
* The extra comparison against zero is an attempt to work around
* what appears to be a bug in QEMU and Bochs. Both emulators
* sometimes report a key-press with scancode one and ascii zero
* when no such key is pressed in reality. As far as I can tell,
* this only happens shortly after a reboot.
*/
v86.ctl = V86_FLAGS;
v86.addr = 0x16;
v86.eax = fn << 8;
v86int();
return fn == 0 ? v86.eax & 0xff : (!V86_ZR(v86.efl) && (v86.eax & 0xff));
}

1
sys/boot/zfs/Makefile
View File

@ -5,6 +5,7 @@ INTERNALLIB=
SRCS+= zfs.c
CFLAGS+= -DBOOTPROG=\"zfsloader\"
CFLAGS+= -I${.CURDIR}/../common -I${.CURDIR}/../.. -I.
CFLAGS+= -I${.CURDIR}/../../../lib/libstand
CFLAGS+= -I${.CURDIR}/../../cddl/boot/zfs

11
sys/boot/zfs/zfsimpl.c
View File

@ -496,12 +496,7 @@ vdev_init_from_nvlist(const unsigned char *nvlist, vdev_t **vdevp, int is_newer)
vdev->v_nparity = 0;
if (nvlist_find(nvlist, ZPOOL_CONFIG_PATH,
DATA_TYPE_STRING, 0, &path) == 0) {
if (strlen(path) > 5
&& path[0] == '/'
&& path[1] == 'd'
&& path[2] == 'e'
&& path[3] == 'v'
&& path[4] == '/')
if (strncmp(path, "/dev/", 5) == 0)
path += 5;
vdev->v_name = strdup(path);
} else {
@ -682,7 +677,7 @@ pager_printf(const char *fmt, ...)
#endif
#define STATUS_FORMAT " %-16s %-10s\n"
#define STATUS_FORMAT " %s %s\n"
static void
print_state(int indent, const char *name, vdev_state_t state)
@ -1393,7 +1388,7 @@ fzap_list(spa_t *spa, const dnode_phys_t *dnode)
*/
value = fzap_leaf_value(&zl, zc);
printf("%-32s 0x%llx\n", name, value);
printf("%s 0x%llx\n", name, value);
}
}