Page MenuHomeFreeBSD
Differential D24618

ARM SMMU v3.2 support
ClosedPublic
Actions

Authored by br on Apr 29 2020, 4:05 PM.
Tags
None
Referenced Files
F115249408: D24618.id79122.diff
Mon, Apr 21, 9:01 PM
F115190352: D24618.id75498.diff
Mon, Apr 21, 7:11 AM
Unknown Object (File)
Thu, Apr 17, 10:50 AM
Unknown Object (File)
Thu, Apr 17, 3:37 AM
Unknown Object (File)
Thu, Apr 17, 12:55 AM
Unknown Object (File)
Wed, Apr 16, 8:12 PM
Unknown Object (File)
Tue, Apr 15, 8:54 PM
Unknown Object (File)
Tue, Apr 15, 4:02 PM
View All Files
Subscribers
dsl
emaste
imp
jhb
mhorne
mmel

Details

Reviewers
kib
markj
andrew
manu
mmel
Group Reviewers
ARM
Commits
rS367736: Introduce IOMMU support for arm64 platform.
Summary

ARM System MMU v3.2 support.

Hardware overview is provided in the header of smmu.c.

Documentation is available here:
https://static.docs.arm.com/ihi0070/ca/IHI_0070_C_a_System_Memory_Management_Unit_Arm_Architecture_Specification.pdf

Test Plan

Tested on ARM Neoverse N1 SDP board.

Diff Detail

Lint
Lint Skipped
Unit
Tests Skipped

Event Timeline

There are a very large number of changes, so older changes are hidden. Show Older Changes
br updated this revision to Diff 74577.Jul 17 2020, 3:19 PM
br marked an inline comment as done.

Regenerate with acpi code committed

br updated this revision to Diff 75303.Aug 3 2020, 2:07 PM
br edited the summary of this revision. (Show Details)
br edited the test plan for this revision. (Show Details)

Regenerate with latest changes to dev/iommu

br updated this revision to Diff 75304.Aug 3 2020, 2:07 PM
br edited the summary of this revision. (Show Details)

remove empty line

br added a reviewer: ARM.Aug 3 2020, 2:10 PM
andrew added inline comments.Aug 3 2020, 4:15 PM
sys/arm64/iommu/iommu.c
344–345

You appear to be mapping a fixed address. This won't work on non-N1SDP hardware as the GIC will be at a different physical address.

You'll need to update the pci driver to ask the interrupt controller to map the memory when creating the iommu context, and free it later.

sys/conf/files.arm64
214

I think we want an iommu option to enable this. The iommu should be independent of both acpi and pci, e.g. we could use it in a system with FDT on a memory mapped bus.

sys/dev/iommu/busdma_iommu.c
881

Why not #if !defined(__i386__)

sys/dev/iommu/iommu_gas.c
72 ↗(On Diff #75303)

It looks like you need these for IOMMU_PAGE_SIZE and IOMMU_PAGE_MASK. Could you create machine/iommu.h for these so we don't need #if defined(...) whenever we need these.

br updated this revision to Diff 75375.Aug 4 2020, 4:13 PM

Query the GIC page from the ITS driver using MSI_MAP, instead of hardcoding

br added inline comments.Aug 4 2020, 4:17 PM
sys/arm64/iommu/iommu.c
344–345

Thanks, indeed.
We create an iommu context not in the PCI driver, but later a bit, when a PCI peripheral requests bus_dma tag, so I have slightly different solution using intr_map_msi().
please check

br updated this revision to Diff 75489.Aug 6 2020, 1:06 PM

Rebase

br updated this revision to Diff 75490.Aug 6 2020, 1:14 PM
br marked an inline comment as done.

allow irq == 0 in map_msi()

br mentioned this in D25974: map_msi for IOMMU.Aug 6 2020, 1:22 PM
br updated this revision to Diff 75493.Aug 6 2020, 1:38 PM
br marked an inline comment as done.

device iommu added

br marked an inline comment as done.Aug 6 2020, 1:38 PM
br added inline comments.
sys/conf/files.arm64
214

Ok

sys/dev/iommu/busdma_iommu.c
881

Thanks. Fixed.

sys/dev/iommu/iommu_gas.c
72 ↗(On Diff #75303)

Done.

br updated this revision to Diff 75498.Aug 6 2020, 2:13 PM
br marked an inline comment as done.

smmu_map_msi() added

br updated this revision to Diff 75501.Aug 6 2020, 2:25 PM

Regen

br updated this revision to Diff 75670.Aug 11 2020, 12:48 PM

Regenerate

mmel added a subscriber: mmel.Sep 1 2020, 12:19 PM

I’m slightly confused by code partitioning.
With that in mind that we have multiple types of IOMMUs (rockchip, tegra, smmu v2, allwinner …, and one SoC can have multiple different IOMMUs, I’m not sure how this patch fit in this situation.
Is iommu.c intended as base for future IOMMU independent part of framework? If yes, why it contain functions prefixed by smmu_? If not, why it’s named by generic name?
Do you have any roadmap, ideas how final (supporting multiple kinds of IOMMUs in one generic kernel) should be structured?

sys/arm64/arm64/pmap.c
3493

Why? Do you expect that SMMU pmap can be used on PE?

sys/arm64/iommu/iommu.c
283

Is GICv3 necessary precondition for SMMU v3?

sys/dev/pci/pci_host_generic_acpi.c
412

this should be called by using common IOMMU interface - you may have different IOMMUs in one system.

br updated this revision to Diff 77482.Sep 24 2020, 1:53 PM

Add quirk: iommu set to buswide for Marvell AHCI

br updated this revision to Diff 77483.Sep 24 2020, 2:00 PM

Regenerate

br mentioned this in D26360: PCI function address aliasing support.Sep 24 2020, 2:01 PM
br updated this revision to Diff 77680.Sep 30 2020, 2:01 PM

Regenerate

br added a comment.Sep 30 2020, 2:13 PM
In D24618#583893, @mmel wrote:

I’m slightly confused by code partitioning.
With that in mind that we have multiple types of IOMMUs (rockchip, tegra, smmu v2, allwinner …, and one SoC can have multiple different IOMMUs, I’m not sure how this patch fit in this situation.
Is iommu.c intended as base for future IOMMU independent part of framework? If yes, why it contain functions prefixed by smmu_? If not, why it’s named by generic name?
Do you have any roadmap, ideas how final (supporting multiple kinds of IOMMUs in one generic kernel) should be structured?

iommu.c is a glue between generic iommu framework (dev/iommu) and smmu driver (we have multiple instances of SMMU in the system).
I agree it is confusing, so I renamed it to iommu_smmu.c.

We could probably reuse the glue for other arm64 IOMMU systems (at least smmuv2), but not sure about others.

(sorry for long reply I missed your comments)

sys/arm64/arm64/pmap.c
3493

No, but we are doing SMMU TLB invalidation shortly after pmap_senter().

sys/arm64/iommu/iommu.c
283

No, I just have renamed variables

sys/dev/pci/pci_host_generic_acpi.c
412

yes we are currently reworking this part

br updated this revision to Diff 77976.Oct 7 2020, 3:31 PM

a change by andrew@:

Manage MSI IOMMU pages when allocating their irq

This allows the interrupt controller driver only need a small change to
create a map for the page the device will write to to raise an interrupt.
br mentioned this in D26705: Manage MSI iommu pages.Oct 7 2020, 7:34 PM
br updated this revision to Diff 78824.Oct 27 2020, 4:42 PM

The final patch to review

br updated this revision to Diff 78827.Oct 27 2020, 5:26 PM

Rename iommu_smmu.c to smmu_iommu.c

br updated this revision to Diff 78908.Oct 29 2020, 3:22 PM

Set domain.end address (max guest addr + 1) to the VM_MAXUSER_ADDR

br added a child revision: D26877: SMMU pmap routines added.Oct 30 2020, 12:20 PM
br updated this revision to Diff 79122.Nov 3 2020, 11:29 AM

update copyright for smmu_quircks.c

mmel added a comment.Nov 3 2020, 1:21 PM

I’m looking at this from perspective of presence of multiple different implementations of IOMMUs in ARM(64) world. From this point of view, I still have some problems with code partitioning, mainly in meaning of smmu_if.m.
I think that smmu_if.m should be taken as interface between system and individual IOMMU implementation. That’s mean that it should be decontaminated from using smmu (in names and/or as argument) and renamed to iommu_if.m.
The system wide function in smmu_iommu.c (like iommu_get_ctx(), iommu_find(),iommu_registe() or so) should be moved to own independent file (say iommu.c) and all HW dependent functionality should be passed by using iommu_if.m to given implementation.

I think that this not that hard change, 95% of code is already done. I, of course, don’t want to block you, I only think that some system interface should be prepared in forward.

br updated this revision to Diff 79434.Nov 11 2020, 4:47 PM

Rework the arm64 iommu interface so it could be used on other IOMMU engines in arm64 world, not only SMMU.
(Requested by mmel)

mmel accepted this revision.Nov 15 2020, 10:22 AM

In any case, with these minor issues fixed, LGTM

sys/arm64/iommu/iommu.c
209

iommu can be used also for not-pci based devices. This should be reimplemented as new newbus method with pci_get_rid() as default for pci device class.
However, this can be done as a subsequent step, so please only add a comment to document this fact.

356

should be locked by IOMMU_LIST_LOCK

377

should be locked by IOMMU_LIST_LOCK

sys/arm64/iommu/iommu.h
42

These constants are already defined in sys/dev/iommu/iommu_gas.h.
You should include it in this header.

sys/arm64/iommu/smmu.c
742

ste[1] is reinitialized few lines bellow.

752

style, why '|=' ?

770

imho, this should be documented in comment (or removed).

866

this is not macro so why "\" at end of line ?

1231

Style

This revision is now accepted and ready to land.Nov 15 2020, 10:22 AM
br mentioned this in D27229: Add dev member to struct iommu.Nov 15 2020, 11:00 PM
br updated this revision to Diff 79573.Nov 16 2020, 12:03 AM

Address mmel's comments.

This revision now requires review to proceed.Nov 16 2020, 12:03 AM
mmel added a comment.Nov 16 2020, 1:47 PM

Perfect. Many thanks for cooperation.

br updated this revision to Diff 79604.Nov 16 2020, 3:09 PM

More style fixes:
o Rename header protection variables
o Make variables consistent:

struct smmu_unit is unit
struct smmu_domain is domain
struct smmu_ctx is ctx
struct iommu_unit is iommu
struct iommu_domain is iodom
struct iommu_ctx is ioctx

o Add locking around smmu_ctx_lookup() method
o ctx_free and domain_free methods return void
o Call to iommu_gas_fini_domain() and iommu_domain_fini() on domain deinitialization (iommu_domain_free())

br updated this revision to Diff 79609.Nov 16 2020, 4:20 PM

Remove unused headers

This revision was not accepted when it landed; it landed in state Needs Review.Nov 16 2020, 9:56 PM
Closed by commit rS367736: Introduce IOMMU support for arm64 platform. (authored by br). · Explain Why
This revision was automatically updated to reflect the committed changes.
br added a commit: rS367736: Introduce IOMMU support for arm64 platform..
Herald added a subscriber: imp. · View Herald TranscriptNov 16 2020, 9:56 PM
dsl added a subscriber: dsl.Jun 15 2021, 3:41 PM

Revision Contents
Changeset List

PathSize
sys/
arm64/
arm64/
224 lines
include/
2 lines
7 lines
iommu/
85 lines
583 lines
105 lines
1784 lines
252 lines
478 lines
155 lines
conf/
6 lines
1 line
dev/
acpica/
2 lines
iommu/
4 lines
pci/
2 lines
19 lines

Diff 75498

View Options

sys/arm64/arm64/pmap.c

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/include/bus_dma_impl.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/include/pmap.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/iommu/iommu.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/iommu/iommu.c

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/iommu/iommu_if.m

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/iommu/smmu.c

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/iommu/smmu_acpi.c

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesstruct devsw efipart_hddev = {
.dv_strategy = efipart_strategy, .dv_strategy = efipart_strategy,
.dv_open = efipart_open, .dv_open = efipart_open,
.dv_close = efipart_close, .dv_close = efipart_close,
.dv_ioctl = efipart_ioctl, .dv_ioctl = efipart_ioctl,
.dv_print = efipart_printhd, .dv_print = efipart_printhd,
.dv_cleanup = NULL .dv_cleanup = NULL
}; };
static pdinfo_list_t fdinfo; static pdinfo_list_t fdinfo = STAILQ_HEAD_INITIALIZER(fdinfo);
static pdinfo_list_t cdinfo; static pdinfo_list_t cdinfo = STAILQ_HEAD_INITIALIZER(cdinfo);
static pdinfo_list_t hdinfo; static pdinfo_list_t hdinfo = STAILQ_HEAD_INITIALIZER(hdinfo);
static pdinfo_list_t pdinfo = STAILQ_HEAD_INITIALIZER(pdinfo);
static EFI_HANDLE *efipart_handles = NULL;
static UINTN efipart_nhandles = 0;
pdinfo_list_t * pdinfo_list_t *
efiblk_get_pdinfo_list(struct devsw *dev) efiblk_get_pdinfo_list(struct devsw *dev)
{ {
if (dev->dv_type == DEVT_DISK) if (dev->dv_type == DEVT_DISK)
return (&hdinfo); return (&hdinfo);
if (dev->dv_type == DEVT_CD) if (dev->dv_type == DEVT_CD)
return (&cdinfo); return (&cdinfo);
if (dev->dv_type == DEVT_FD) if (dev->dv_type == DEVT_FD)
Show All 18 Linesefiblk_get_pdinfo(struct devdesc *dev)
} }
return (pd); return (pd);
} }
pdinfo_t * pdinfo_t *
efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path) efiblk_get_pdinfo_by_device_path(EFI_DEVICE_PATH *path)
{ {
EFI_HANDLE h; EFI_HANDLE h;
EFI_STATUS status;
EFI_DEVICE_PATH *devp = path;
h = efi_devpath_to_handle(path, efipart_handles, efipart_nhandles); status = BS->LocateDevicePath(&blkio_guid, &devp, &h);
if (h == NULL) if (EFI_ERROR(status))
return (NULL); return (NULL);
return (efiblk_get_pdinfo_by_handle(h)); return (efiblk_get_pdinfo_by_handle(h));
} }
static bool static bool
same_handle(pdinfo_t *pd, EFI_HANDLE h) same_handle(pdinfo_t *pd, EFI_HANDLE h)
{ {
Show All 14 Lines STAILQ_FOREACH(dp, &hdinfo, pd_link) {
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) { STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h)) if (same_handle(pp, h))
return (pp); return (pp);
} }
} }
STAILQ_FOREACH(dp, &cdinfo, pd_link) { STAILQ_FOREACH(dp, &cdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
STAILQ_FOREACH(pp, &dp->pd_part, pd_link) {
if (same_handle(pp, h))
return (pp);
} }
}
STAILQ_FOREACH(dp, &fdinfo, pd_link) { STAILQ_FOREACH(dp, &fdinfo, pd_link) {
if (same_handle(dp, h)) if (same_handle(dp, h))
return (dp); return (dp);
} }
return (NULL); return (NULL);
} }
static int static int
efiblk_pdinfo_count(pdinfo_list_t *pdi) efiblk_pdinfo_count(pdinfo_list_t *pdi)
{ {
pdinfo_t *pd; pdinfo_t *pd;
int i = 0; int i = 0;
STAILQ_FOREACH(pd, pdi, pd_link) { STAILQ_FOREACH(pd, pdi, pd_link) {
i++; i++;
} }
return (i); return (i);
} }
int int
efipart_inithandles(void) efipart_inithandles(void)
{ {
unsigned i, nin;
UINTN sz; UINTN sz;
EFI_HANDLE *hin; EFI_HANDLE *hin;
EFI_DEVICE_PATH *devpath;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *pd;
if (efipart_nhandles != 0) { if (!STAILQ_EMPTY(&pdinfo))
free(efipart_handles); return (0);
efipart_handles = NULL;
efipart_nhandles = 0;
}
sz = 0; sz = 0;
hin = NULL; hin = NULL;
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin); status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, hin);
if (status == EFI_BUFFER_TOO_SMALL) { if (status == EFI_BUFFER_TOO_SMALL) {
hin = malloc(sz); hin = malloc(sz);
status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz, status = BS->LocateHandle(ByProtocol, &blkio_guid, 0, &sz,
hin); hin);
if (EFI_ERROR(status)) if (EFI_ERROR(status))
free(hin); free(hin);
} }
if (EFI_ERROR(status)) if (EFI_ERROR(status))
return (efi_status_to_errno(status)); return (efi_status_to_errno(status));
efipart_handles = hin; nin = sz / sizeof(*hin);
efipart_nhandles = sz / sizeof(*hin);
#ifdef EFIPART_DEBUG #ifdef EFIPART_DEBUG
printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, printf("%s: Got %d BLOCK IO MEDIA handle(s)\n", __func__, nin);
efipart_nhandles);
#endif #endif
return (0);
}
static ACPI_HID_DEVICE_PATH * for (i = 0; i < nin; i++) {
efipart_floppy(EFI_DEVICE_PATH *node)
{
ACPI_HID_DEVICE_PATH *acpi;
if (DevicePathType(node) == ACPI_DEVICE_PATH &&
DevicePathSubType(node) == ACPI_DP) {
acpi = (ACPI_HID_DEVICE_PATH *) node;
if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
acpi->HID == EISA_PNP_ID(PNP0701)) {
return (acpi);
}
}
return (NULL);
}
/* /*
* Determine if the provided device path is hdd. * Get devpath and open protocol.
* * We should not get errors here
* There really is no simple fool proof way to classify the devices.
* Since we do build three lists of devices - floppy, cd and hdd, we
* will try to see if the device is floppy or cd, and list anything else
* as hdd.
*/ */
static bool if ((devpath = efi_lookup_devpath(hin[i])) == NULL)
efipart_hdd(EFI_DEVICE_PATH *dp)
{
unsigned i;
EFI_DEVICE_PATH *devpath, *node;
EFI_BLOCK_IO *blkio;
EFI_STATUS status;
if (dp == NULL)
return (false);
if ((node = efi_devpath_last_node(dp)) == NULL)
return (false);
if (efipart_floppy(node) != NULL)
return (false);
/*
* Test every EFI BLOCK IO handle to make sure dp is not device path
* for CD/DVD.
*/
for (i = 0; i < efipart_nhandles; i++) {
devpath = efi_lookup_devpath(efipart_handles[i]);
if (devpath == NULL)
return (false);
/* Only continue testing when dp is prefix in devpath. */
if (!efi_devpath_is_prefix(dp, devpath))
continue; continue;
/* status = OpenProtocolByHandle(hin[i], &blkio_guid,
* The device path has to have last node describing the
* device, or we can not test the type.
*/
if ((node = efi_devpath_last_node(devpath)) == NULL)
return (false);
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) {
return (false);
}
/* Make sure we do have the media. */
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid,
(void **)&blkio); (void **)&blkio);
if (EFI_ERROR(status)) if (EFI_ERROR(status)) {
return (false); printf("error %lu\n", EFI_ERROR_CODE(status));
continue;
/* USB or SATA cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent) {
return (false);
} }
/* /*
* We assume the block size 512 or greater power of 2. * We assume the block size 512 or greater power of 2.
* iPXE is known to insert stub BLOCK IO device with * iPXE is known to insert stub BLOCK IO device with
* BlockSize 1. * BlockSize 1.
*/ */
if (blkio->Media->BlockSize < 512 || if (blkio->Media->BlockSize < 512 ||
!powerof2(blkio->Media->BlockSize)) { !powerof2(blkio->Media->BlockSize))
return (false); continue;
}
}
return (true);
}
/* /* This is bad. */
* Add or update entries with new handle data. if ((pd = calloc(1, sizeof(*pd))) == NULL) {
*/ printf("efipart_inithandles: Out of memory.\n");
static int free(hin);
efipart_fdinfo_add(EFI_HANDLE handle, uint32_t uid, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *fd;
fd = calloc(1, sizeof(pdinfo_t));
if (fd == NULL) {
printf("Failed to register floppy %d, out of memory\n", uid);
return (ENOMEM); return (ENOMEM);
} }
STAILQ_INIT(&fd->pd_part); STAILQ_INIT(&pd->pd_part);
fd->pd_unit = uid; pd->pd_handle = hin[i];
fd->pd_handle = handle; pd->pd_devpath = devpath;
fd->pd_devpath = devpath; pd->pd_blkio = blkio;
fd->pd_parent = NULL; STAILQ_INSERT_TAIL(&pdinfo, pd, pd_link);
fd->pd_devsw = &efipart_fddev; }
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
free(hin);
return (0); return (0);
} }
static void static ACPI_HID_DEVICE_PATH *
efipart_updatefd(void) efipart_floppy(EFI_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath, *node;
ACPI_HID_DEVICE_PATH *acpi; ACPI_HID_DEVICE_PATH *acpi;
int i;
for (i = 0; i < efipart_nhandles; i++) { if (DevicePathType(node) == ACPI_DEVICE_PATH &&
devpath = efi_lookup_devpath(efipart_handles[i]); DevicePathSubType(node) == ACPI_DP) {
if (devpath == NULL) acpi = (ACPI_HID_DEVICE_PATH *) node;
continue; if (acpi->HID == EISA_PNP_ID(PNP0604) ||
acpi->HID == EISA_PNP_ID(PNP0700) ||
if ((node = efi_devpath_last_node(devpath)) == NULL) acpi->HID == EISA_PNP_ID(PNP0701)) {
continue; return (acpi);
if ((acpi = efipart_floppy(node)) != NULL) {
efipart_fdinfo_add(efipart_handles[i], acpi->UID,
devpath);
} }
} }
return (NULL);
} }
static pdinfo_t *
efipart_find_parent(pdinfo_list_t *pdi, EFI_DEVICE_PATH *devpath)
{
pdinfo_t *pd;
STAILQ_FOREACH(pd, pdi, pd_link)
if (efi_devpath_is_prefix(pd->pd_devpath, devpath))
return (pd);
return (NULL);
}
static int static int
efipart_initfd(void) efipart_initfd(void)
{ {
EFI_DEVICE_PATH *node;
ACPI_HID_DEVICE_PATH *acpi;
pdinfo_t *parent, *fd;
STAILQ_INIT(&fdinfo); restart:
STAILQ_FOREACH(fd, &pdinfo, pd_link) {
if ((node = efi_devpath_last_node(fd->pd_devpath)) == NULL)
continue;
efipart_updatefd(); if ((acpi = efipart_floppy(node)) == NULL)
continue;
STAILQ_REMOVE(&pdinfo, fd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, fd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
parent->pd_alias = fd->pd_handle;
parent->pd_unit = acpi->UID;
free(fd);
fd = parent;
} else {
fd->pd_unit = acpi->UID;
}
fd->pd_devsw = &efipart_fddev;
STAILQ_INSERT_TAIL(&fdinfo, fd, pd_link);
goto restart;
}
bcache_add_dev(efiblk_pdinfo_count(&fdinfo)); bcache_add_dev(efiblk_pdinfo_count(&fdinfo));
return (0); return (0);
} }
/* /*
* Add or update entries with new handle data. * Add or update entries with new handle data.
*/ */
static int static void
efipart_cdinfo_add(EFI_HANDLE handle, EFI_HANDLE alias, efipart_cdinfo_add(pdinfo_t *cd)
EFI_DEVICE_PATH *devpath)
{ {
int unit; pdinfo_t *pd, *last;
pdinfo_t *cd;
pdinfo_t *pd;
unit = 0;
STAILQ_FOREACH(pd, &cdinfo, pd_link) { STAILQ_FOREACH(pd, &cdinfo, pd_link) {
if (efi_devpath_match(pd->pd_devpath, devpath) == true) { if (efi_devpath_is_prefix(pd->pd_devpath, cd->pd_devpath)) {
pd->pd_handle = handle; last = STAILQ_LAST(&pd->pd_part, pdinfo, pd_link);
pd->pd_alias = alias; if (last != NULL)
return (0); cd->pd_unit = last->pd_unit + 1;
else
cd->pd_unit = 0;
cd->pd_parent = pd;
cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&pd->pd_part, cd, pd_link);
return;
} }
unit++;
} }
cd = calloc(1, sizeof(pdinfo_t)); last = STAILQ_LAST(&cdinfo, pdinfo, pd_link);
if (cd == NULL) { if (last != NULL)
printf("Failed to add cd %d, out of memory\n", unit); cd->pd_unit = last->pd_unit + 1;
return (ENOMEM); else
} cd->pd_unit = 0;
STAILQ_INIT(&cd->pd_part);
cd->pd_handle = handle;
cd->pd_unit = unit;
cd->pd_alias = alias;
cd->pd_devpath = devpath;
cd->pd_parent = NULL; cd->pd_parent = NULL;
cd->pd_devsw = &efipart_cddev; cd->pd_devsw = &efipart_cddev;
STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link); STAILQ_INSERT_TAIL(&cdinfo, cd, pd_link);
return (0);
} }
static bool
efipart_testcd(EFI_DEVICE_PATH *node, EFI_BLOCK_IO *blkio)
{
if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP)
return (true);
/* cd without the media. */
if (blkio->Media->RemovableMedia &&
!blkio->Media->MediaPresent)
return (true);
return (false);
}
static void static void
efipart_updatecd(void) efipart_updatecd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *cd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(cd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(cd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL)
continue;
if (efipart_floppy(node) != NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (efipart_hdd(devpath)) /* Is parent of this device already registered? */
continue; parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
efipart_cdinfo_add(cd);
goto restart;
}
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (!efipart_testcd(node, cd->pd_blkio))
(void **)&blkio);
if (EFI_ERROR(status))
continue; continue;
/* Find parent and unlink both parent and cd from pdinfo */
STAILQ_REMOVE(&pdinfo, cd, pdinfo, pd_link);
parent = efipart_find_parent(&pdinfo, cd->pd_devpath);
if (parent != NULL) {
STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
efipart_cdinfo_add(parent);
}
if (parent == NULL)
parent = efipart_find_parent(&cdinfo, cd->pd_devpath);
/* /*
* If we come across a logical partition of subtype CDROM * If we come across a logical partition of subtype CDROM
* it doesn't refer to the CD filesystem itself, but rather * it doesn't refer to the CD filesystem itself, but rather
* to any usable El Torito boot image on it. In this case * to any usable El Torito boot image on it. In this case
* we try to find the parent device and add that instead as * we try to find the parent device and add that instead as
* that will be the CD filesystem. * that will be the CD filesystem.
*/ */
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_CDROM_DP) { DevicePathSubType(node) == MEDIA_CDROM_DP &&
devpathcpy = efi_devpath_trim(devpath); parent == NULL) {
if (devpathcpy == NULL) parent = calloc(1, sizeof(*parent));
continue; if (parent == NULL) {
tmpdevpath = devpathcpy; printf("efipart_updatecd: out of memory\n");
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, /* this device is lost but try again. */
&handle); free(cd);
free(devpathcpy); goto restart;
if (EFI_ERROR(status))
continue;
devpath = efi_lookup_devpath(handle);
efipart_cdinfo_add(handle, efipart_handles[i],
devpath);
continue;
} }
if (DevicePathType(node) == MESSAGING_DEVICE_PATH && devpath = efi_devpath_trim(cd->pd_devpath);
DevicePathSubType(node) == MSG_ATAPI_DP) { if (devpath == NULL) {
efipart_cdinfo_add(efipart_handles[i], NULL, printf("efipart_updatecd: out of memory\n");
devpath); /* this device is lost but try again. */
continue; free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath = devpath;
/* USB or SATA cd without the media. */ status = BS->LocateDevicePath(&blkio_guid,
if (blkio->Media->RemovableMedia && &parent->pd_devpath, &parent->pd_handle);
!blkio->Media->MediaPresent) { free(devpath);
efipart_cdinfo_add(efipart_handles[i], NULL, if (EFI_ERROR(status)) {
devpath); printf("efipart_updatecd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(cd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(parent->pd_handle);
efipart_cdinfo_add(parent);
} }
efipart_cdinfo_add(cd);
goto restart;
} }
}
static int static int
efipart_initcd(void) efipart_initcd(void)
{ {
STAILQ_INIT(&cdinfo);
efipart_updatecd(); efipart_updatecd();
bcache_add_dev(efiblk_pdinfo_count(&cdinfo)); bcache_add_dev(efiblk_pdinfo_count(&cdinfo));
return (0); return (0);
} }
static int static void
efipart_hdinfo_add(EFI_HANDLE disk_handle, EFI_HANDLE part_handle) efipart_hdinfo_add(pdinfo_t *hd, HARDDRIVE_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *disk_devpath, *part_devpath; pdinfo_t *pd, *last;
HARDDRIVE_DEVICE_PATH *node;
int unit;
pdinfo_t *hd, *pd, *last;
disk_devpath = efi_lookup_devpath(disk_handle); STAILQ_FOREACH(pd, &hdinfo, pd_link) {
if (disk_devpath == NULL) if (efi_devpath_is_prefix(pd->pd_devpath, hd->pd_devpath)) {
return (ENOENT);
if (part_handle != NULL) {
part_devpath = efi_lookup_devpath(part_handle);
if (part_devpath == NULL)
return (ENOENT);
node = (HARDDRIVE_DEVICE_PATH *)
efi_devpath_last_node(part_devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
} else {
part_devpath = NULL;
node = NULL;
}
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
STAILQ_FOREACH(hd, &hdinfo, pd_link) {
if (efi_devpath_match(hd->pd_devpath, disk_devpath) == true) {
if (part_devpath == NULL)
return (0);
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = part_handle; hd->pd_unit = node->PartitionNumber;
pd->pd_unit = node->PartitionNumber; hd->pd_parent = pd;
pd->pd_devpath = part_devpath; hd->pd_devsw = &efipart_hddev;
pd->pd_parent = hd; STAILQ_INSERT_TAIL(&pd->pd_part, hd, pd_link);
pd->pd_devsw = &efipart_hddev; return;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
} }
} }
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* Add the disk. */ /* Add the disk. */
hd = pd;
hd->pd_handle = disk_handle;
hd->pd_unit = unit;
hd->pd_devpath = disk_devpath;
hd->pd_parent = NULL;
hd->pd_devsw = &efipart_hddev; hd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link); STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
if (part_devpath == NULL)
return (0);
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add partition, out of memory\n");
return (ENOMEM);
} }
STAILQ_INIT(&pd->pd_part);
/* Add the partition. */
pd->pd_handle = part_handle;
pd->pd_unit = node->PartitionNumber;
pd->pd_devpath = part_devpath;
pd->pd_parent = hd;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hd->pd_part, pd, pd_link);
return (0);
}
/* /*
* The MEDIA_FILEPATH_DP has device name. * The MEDIA_FILEPATH_DP has device name.
* From U-Boot sources it looks like names are in the form * From U-Boot sources it looks like names are in the form
* of typeN:M, where type is interface type, N is disk id * of typeN:M, where type is interface type, N is disk id
* and M is partition id. * and M is partition id.
*/ */
static int static void
efipart_hdinfo_add_filepath(EFI_HANDLE disk_handle) efipart_hdinfo_add_filepath(pdinfo_t *hd, FILEPATH_DEVICE_PATH *node)
{ {
EFI_DEVICE_PATH *devpath;
FILEPATH_DEVICE_PATH *node;
char *pathname, *p; char *pathname, *p;
int unit, len; int len;
pdinfo_t *pd, *last; pdinfo_t *last;
/* First collect and verify all the data */
if ((devpath = efi_lookup_devpath(disk_handle)) == NULL)
return (ENOENT);
node = (FILEPATH_DEVICE_PATH *)efi_devpath_last_node(devpath);
if (node == NULL)
return (ENOENT); /* This should not happen. */
pd = calloc(1, sizeof(pdinfo_t));
if (pd == NULL) {
printf("Failed to add disk, out of memory\n");
return (ENOMEM);
}
STAILQ_INIT(&pd->pd_part);
last = STAILQ_LAST(&hdinfo, pdinfo, pd_link); last = STAILQ_LAST(&hdinfo, pdinfo, pd_link);
if (last != NULL) if (last != NULL)
unit = last->pd_unit + 1; hd->pd_unit = last->pd_unit + 1;
else else
unit = 0; hd->pd_unit = 0;
/* FILEPATH_DEVICE_PATH has 0 terminated string */ /* FILEPATH_DEVICE_PATH has 0 terminated string */
len = ucs2len(node->PathName); len = ucs2len(node->PathName);
if ((pathname = malloc(len + 1)) == NULL) { if ((pathname = malloc(len + 1)) == NULL) {
printf("Failed to add disk, out of memory\n"); printf("Failed to add disk, out of memory\n");
free(pd); free(hd);
return (ENOMEM); return;
} }
cpy16to8(node->PathName, pathname, len + 1); cpy16to8(node->PathName, pathname, len + 1);
p = strchr(pathname, ':'); p = strchr(pathname, ':');
/* /*
* Assume we are receiving handles in order, first disk handle, * Assume we are receiving handles in order, first disk handle,
* then partitions for this disk. If this assumption proves * then partitions for this disk. If this assumption proves
* false, this code would need update. * false, this code would need update.
*/ */
if (p == NULL) { /* no colon, add the disk */ if (p == NULL) { /* no colon, add the disk */
pd->pd_handle = disk_handle; hd->pd_devsw = &efipart_hddev;
pd->pd_unit = unit; STAILQ_INSERT_TAIL(&hdinfo, hd, pd_link);
pd->pd_devpath = devpath;
pd->pd_parent = NULL;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&hdinfo, pd, pd_link);
free(pathname); free(pathname);
return (0); return;
} }
p++; /* skip the colon */ p++; /* skip the colon */
errno = 0; errno = 0;
unit = (int)strtol(p, NULL, 0); hd->pd_unit = (int)strtol(p, NULL, 0);
if (errno != 0) { if (errno != 0) {
printf("Bad unit number for partition \"%s\"\n", pathname); printf("Bad unit number for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EUNIT); return;
} }
/* /*
* We should have disk registered, if not, we are receiving * We should have disk registered, if not, we are receiving
* handles out of order, and this code should be reworked * handles out of order, and this code should be reworked
* to create "blank" disk for partition, and to find the * to create "blank" disk for partition, and to find the
* disk based on PathName compares. * disk based on PathName compares.
*/ */
if (last == NULL) { if (last == NULL) {
printf("BUG: No disk for partition \"%s\"\n", pathname); printf("BUG: No disk for partition \"%s\"\n", pathname);
free(pathname); free(pathname);
free(pd); free(hd);
return (EINVAL); return;
} }
/* Add the partition. */ /* Add the partition. */
pd->pd_handle = disk_handle; hd->pd_parent = last;
pd->pd_unit = unit; hd->pd_devsw = &efipart_hddev;
pd->pd_devpath = devpath; STAILQ_INSERT_TAIL(&last->pd_part, hd, pd_link);
pd->pd_parent = last;
pd->pd_devsw = &efipart_hddev;
STAILQ_INSERT_TAIL(&last->pd_part, pd, pd_link);
free(pathname); free(pathname);
return (0);
} }
static void static void
efipart_updatehd(void) efipart_updatehd(void)
{ {
int i; EFI_DEVICE_PATH *devpath, *node;
EFI_DEVICE_PATH *devpath, *devpathcpy, *tmpdevpath, *node;
EFI_HANDLE handle;
EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
pdinfo_t *parent, *hd;
for (i = 0; i < efipart_nhandles; i++) { restart:
devpath = efi_lookup_devpath(efipart_handles[i]); STAILQ_FOREACH(hd, &pdinfo, pd_link) {
if (devpath == NULL) if ((node = efi_devpath_last_node(hd->pd_devpath)) == NULL)
continue; continue;
if ((node = efi_devpath_last_node(devpath)) == NULL) if (efipart_floppy(node) != NULL)
continue; continue;
if (!efipart_hdd(devpath)) if (efipart_testcd(node, hd->pd_blkio))
continue; continue;
status = OpenProtocolByHandle(efipart_handles[i], &blkio_guid, if (DevicePathType(node) == HARDWARE_DEVICE_PATH &&
(void **)&blkio); DevicePathSubType(node) == HW_PCI_DP) {
if (EFI_ERROR(status)) STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add(hd, NULL);
goto restart;
}
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_FILEPATH_DP) { DevicePathSubType(node) == MEDIA_FILEPATH_DP) {
efipart_hdinfo_add_filepath(efipart_handles[i]); STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
continue; efipart_hdinfo_add_filepath(hd,
(FILEPATH_DEVICE_PATH *)node);
goto restart;
} }
if (DevicePathType(node) == MEDIA_DEVICE_PATH && STAILQ_REMOVE(&pdinfo, hd, pdinfo, pd_link);
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) { parent = efipart_find_parent(&pdinfo, hd->pd_devpath);
devpathcpy = efi_devpath_trim(devpath); if (parent != NULL) {
if (devpathcpy == NULL) STAILQ_REMOVE(&pdinfo, parent, pdinfo, pd_link);
continue; efipart_hdinfo_add(parent, NULL);
tmpdevpath = devpathcpy; } else {
status = BS->LocateDevicePath(&blkio_guid, &tmpdevpath, parent = efipart_find_parent(&hdinfo, hd->pd_devpath);
&handle); }
free(devpathcpy);
if (EFI_ERROR(status))
continue;
/*
* We do not support nested partitions.
*/
devpathcpy = efi_lookup_devpath(handle);
if (devpathcpy == NULL)
continue;
if ((node = efi_devpath_last_node(devpathcpy)) == NULL)
continue;
if (DevicePathType(node) == MEDIA_DEVICE_PATH && if (DevicePathType(node) == MEDIA_DEVICE_PATH &&
DevicePathSubType(node) == MEDIA_HARDDRIVE_DP) DevicePathSubType(node) == MEDIA_HARDDRIVE_DP &&
continue; parent == NULL) {
parent = calloc(1, sizeof(*parent));
if (parent == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(hd);
goto restart;
}
efipart_hdinfo_add(handle, efipart_handles[i]); devpath = efi_devpath_trim(hd->pd_devpath);
continue; if (devpath == NULL) {
printf("efipart_updatehd: out of memory\n");
/* this device is lost but try again. */
free(parent);
free(hd);
goto restart;
} }
efipart_hdinfo_add(efipart_handles[i], NULL); parent->pd_devpath = devpath;
status = BS->LocateDevicePath(&blkio_guid,
&parent->pd_devpath, &parent->pd_handle);
free(devpath);
if (EFI_ERROR(status)) {
printf("efipart_updatehd: error %lu\n",
EFI_ERROR_CODE(status));
free(parent);
free(hd);
goto restart;
} }
parent->pd_devpath =
efi_lookup_devpath(&parent->pd_handle);
efipart_hdinfo_add(parent, NULL);
} }
efipart_hdinfo_add(hd, (HARDDRIVE_DEVICE_PATH *)node);
goto restart;
}
}
static int static int
efipart_inithd(void) efipart_inithd(void)
{ {
STAILQ_INIT(&hdinfo);
efipart_updatehd(); efipart_updatehd();
bcache_add_dev(efiblk_pdinfo_count(&hdinfo)); bcache_add_dev(efiblk_pdinfo_count(&hdinfo));
return (0); return (0);
} }
static int static int
efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose) efipart_print_common(struct devsw *dev, pdinfo_list_t *pdlist, int verbose)
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
{ {
va_list args; va_list args;
struct disk_devdesc *dev; struct disk_devdesc *dev;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
EFI_STATUS status; EFI_STATUS status;
va_start(args, f); va_start(args, f);
dev = va_arg(args, struct disk_devdesc*); dev = va_arg(args, struct disk_devdesc *);
va_end(args); va_end(args);
if (dev == NULL) if (dev == NULL)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EIO); return (EIO);
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
{ {
struct disk_devdesc *dev = (struct disk_devdesc *)devdata; struct disk_devdesc *dev = (struct disk_devdesc *)devdata;
pdinfo_t *pd; pdinfo_t *pd;
EFI_BLOCK_IO *blkio; EFI_BLOCK_IO *blkio;
uint64_t off, disk_blocks, d_offset = 0; uint64_t off, disk_blocks, d_offset = 0;
char *blkbuf; char *blkbuf;
size_t blkoff, blksz; size_t blkoff, blksz;
int error; int error;
size_t diskend, readstart; uint64_t diskend, readstart;
if (dev == NULL || blk < 0) if (dev == NULL || blk < 0)
return (EINVAL); return (EINVAL);
pd = efiblk_get_pdinfo((struct devdesc *)dev); pd = efiblk_get_pdinfo((struct devdesc *)dev);
if (pd == NULL) if (pd == NULL)
return (EINVAL); return (EINVAL);
Show All 40 Linesefipart_realstrategy(void *devdata, int rw, daddr_t blk, size_t size,
if ((size % blkio->Media->BlockSize == 0) && if ((size % blkio->Media->BlockSize == 0) &&
(off % blkio->Media->BlockSize == 0)) (off % blkio->Media->BlockSize == 0))
return (efipart_readwrite(blkio, rw, return (efipart_readwrite(blkio, rw,
off / blkio->Media->BlockSize, off / blkio->Media->BlockSize,
size / blkio->Media->BlockSize, buf)); size / blkio->Media->BlockSize, buf));
/* /*
* The block size of the media is not a multiple of I/O. * The buffer size is not a multiple of the media block size.
*/ */
blkbuf = malloc(blkio->Media->BlockSize); blkbuf = malloc(blkio->Media->BlockSize);
if (blkbuf == NULL) if (blkbuf == NULL)
return (ENOMEM); return (ENOMEM);
error = 0; error = 0;
blk = off / blkio->Media->BlockSize; blk = off / blkio->Media->BlockSize;
blkoff = off % blkio->Media->BlockSize; blkoff = off % blkio->Media->BlockSize;
Show All 18 Lines
View Options

sys/arm64/iommu/smmu_reg.h

Loading...
View Options

sys/arm64/iommu/smmu_var.h

Loading...
View Options

sys/conf/files.arm64

Loading...
View Options

sys/conf/options

Loading...
View Options

sys/dev/acpica/acpi_pci.c

Loading...
View Options

sys/dev/iommu/busdma_iommu.c

Loading...
View Options

sys/dev/pci/pci.c

Loading...
View Options

sys/dev/pci/pci_host_generic_acpi.c

Loading...