#ifndef GPT_NO_INCLUDES

#include "util.h"

#endif

#ifndef GPT_DYNAMIC_ALLOC

#else

static struct gpt_ent *table_primary, *table_backup;

#endif

#ifdef GPT_DYNAMIC_ALLOC

void

gptinit(void)

{

	table_primary = gpt_mem_alloc(sizeof(*table_primary) * MAXTBLENTS);

	table_backup = gpt_mem_alloc(sizeof(*table_backup) * MAXTBLENTS);

}

#endif

#ifdef GPT_DYNAMIC_ALLOC

void gptinit(void);

#endif

CFLAGS+=	-DBOOTPROG=\"boot1.uefi\"

CFLAGS+=	-DGPT_NO_INCLUDES=1 -DGPT_DYNAMIC_ALLOC=1

 * Copyright (c) 2015 Holger Hans Peter Freyther

 * All rights reserved.

#include <sys/gpt.h>

#include <efipart.h>

#include "gpt.h"

memset(void *b, int c, size_t len)

{

	char *bp = b;

	while (len--)

		*bp++ = (unsigned char)c;

}

static void

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);

}

#define	bcmp(b1, b2, len)	(memcmp((b1), (b2), (len)) != 0)

static int

static const uuid_t freebsd_ufs_uuid = GPT_ENT_TYPE_FREEBSD_UFS;

static void attempt_gtpboot(EFI_BOOT_SERVICES *BS, EFI_HANDLE *handles, UINTN nparts);

	attempt_gtpboot(BS, handles, nparts);

static uint32_t crc32(void *buf, size_t size)

{

	EFI_STATUS status;

	UINT32 crc;

	status = systab->BootServices->CalculateCrc32(buf, size, &crc);

	if (EFI_ERROR(status))

		return 0;

	return crc;

}

/*

 * We need to handle GPT ourselves. This means we find a

 * disk and check for the GPT partition and then we need

 * to find the handle to this device + partition. I didn't

 * want to rely on the order devices are listed.

 */

static void attempt_gtpboot(EFI_BOOT_SERVICES *BS, EFI_HANDLE *handles, UINTN nparts)

{

	EFI_DEVICE_PATH *devpath;

	EFI_BLOCK_IO *blkio;

	EFI_STATUS status;

	UINTN i, j;

	char *path = _PATH_LOADER;

	gptinit();

	for (i = 0; i < nparts; i++) {

		MASTER_BOOT_RECORD *mbr;

		struct dsk dsk;

		status = BS->HandleProtocol(handles[i],

		    &DevicePathGUID, (void **)&devpath);

		if (EFI_ERROR(status))

			continue;

		while (!IsDevicePathEnd(NextDevicePathNode(devpath)))

			devpath = NextDevicePathNode(devpath);

		/* We want devices like ATAPI.. etc and no disks */

		if (DevicePathType(devpath) != MESSAGING_DEVICE_PATH)

			continue;

		status = BS->HandleProtocol(handles[i],

		    &BlockIoProtocolGUID, (void **)&blkio);

		if (EFI_ERROR(status))

			continue;

		/* check if this is a GTP device */

		status = blkio->ReadBlocks(blkio, blkio->Media->MediaId, 0,

				blkio->Media->BlockSize, __dmadat.secbuf);

		if (EFI_ERROR(status))

			continue;

		mbr = (MASTER_BOOT_RECORD *) __dmadat.secbuf;

		for (j = 0; j < MAX_MBR_PARTITIONS; ++j) {

			if (mbr->Partition[j].BootIndicator != 0x00)

				continue;

			if (mbr->Partition[j].OSIndicator != 0xEE)

				continue;

			if (EXTRACT_UINT32(mbr->Partition[j].StartingLBA) != 1)

				continue;

			break;

		}

		if (j == MAX_MBR_PARTITIONS)

			continue;

		/* Load GPT table and identify partition to boot */

		dsk.bio = blkio;

		dsk.part = -1;

		dsk.start = 0;

		if (gptread(&freebsd_ufs_uuid, &dsk, __dmadat.secbuf) == -1) {

			printf("%s: unable to load GPT\n", BOOTPROG);

			continue;

		}

		if (gptfind(&freebsd_ufs_uuid, &dsk, dsk.part) == -1) {

			printf("%s: no UFS partition was found\n", BOOTPROG);

			continue;

		}

		/*

		 * Now find the matching partition or mark it as failure.

		 * The standard UEFI protocol can't list us the partition

		 * that was created for this device so we need to find a

		 * partition with the right partition number and then we

		 * can compare the device node before with the devicepath.

		 * This way we do not depend on the order the partitions

		 * and devices are listed.

		 */

		for (j = 0; j < nparts; ++j) {

			EFI_DEVICE_PATH *logpart, *prev;

			EFI_BLOCK_IO *partio;

			HARDDRIVE_DEVICE_PATH *hdpath;

			status = BS->HandleProtocol(handles[j],

		    			&DevicePathGUID, (void **)&logpart);

			if (EFI_ERROR(status))

				continue;

			prev = logpart;

			while (!IsDevicePathEnd(NextDevicePathNode(logpart))) {

				prev = logpart;

				logpart = NextDevicePathNode(logpart);

			}

			if (DevicePathType(logpart) != MEDIA_DEVICE_PATH)

				continue;

			if (DevicePathSubType(logpart) != HARDWARE_DEVICE_PATH)

				continue;

			hdpath = (HARDDRIVE_DEVICE_PATH *) logpart;

			if (hdpath->PartitionNumber != dsk.part)

				continue;

			status = BS->HandleProtocol(handles[j],

		    		&BlockIoProtocolGUID, (void **)&partio);

			if (EFI_ERROR(status))

				continue;

			if (!partio->Media->LogicalPartition)

				continue;

			/* check if the underlying device is the same? */

			if (DevicePathType(prev) != DevicePathType(devpath))

				continue;

			if (DevicePathNodeLength(prev) != DevicePathNodeLength(devpath))

				continue;

			if (memcmp(prev, devpath, DevicePathNodeLength(devpath)) != 0)

				continue;

			if (domount(logpart, partio, 1) >= 0) {

				bootdevhandle = handles[j];

				load(path);

			}

		}

		/* boot failed for this GPT partition */

		gptbootfailed(&dsk);

	}

	printf("Failed with gptboot\n");

}

int drvread(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk)

{

	EFI_STATUS status;

	int size;

	lba = lba / (dskp->bio->Media->BlockSize / DEV_BSIZE);

	size = nblk * DEV_BSIZE;

	status = dskp->bio->ReadBlocks(dskp->bio, dskp->bio->Media->MediaId, lba,

			size, buf);

	if (EFI_ERROR(status))

		return (-1);

	return (0);

}

int drvwrite(struct dsk *dskp, void *buf, daddr_t lba, unsigned nblk)

{

	EFI_STATUS status;

	int size;

	lba = lba / (dskp->bio->Media->BlockSize / DEV_BSIZE);

	size = nblk * DEV_BSIZE;

	status = dskp->bio->WriteBlocks(dskp->bio, dskp->bio->Media->MediaId, lba,

			size, buf);

	if (EFI_ERROR(status))

		return (-1);

	status = dskp->bio->FlushBlocks(dskp->bio);

	if (EFI_ERROR(status))

		return (-1);

	return 0;

}

uint64_t drvsize(struct dsk *dskp)

{

	return dskp->bio->Media->LastBlock;

}

void *gpt_mem_alloc(size_t size)

{

	void *mem;

	EFI_STATUS status;

	status = systab->BootServices->AllocatePool(EfiLoaderData,

		size, &mem);

	if (EFI_ERROR(status))

		return NULL;

	return mem;

}

#include "gpt.c"

#ifndef _DRV_H_

#define _DRV_H_

struct dsk {

	EFI_BLOCK_IO *bio;

	unsigned int part;

	daddr_t start;

};

#endif