Page MenuHomeFreeBSD
Differential D11699

www/nginx: fix makesum target
ClosedPublic
Actions

Authored by joneum on Jul 23 2017, 11:33 AM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Apr 18, 1:35 PM
Unknown Object (File)
Wed, Apr 16, 3:13 AM
Unknown Object (File)
Mar 10 2025, 7:00 PM
Unknown Object (File)
Jan 30 2025, 7:54 AM
Unknown Object (File)
Jan 23 2025, 6:06 AM
Unknown Object (File)
Jan 20 2025, 9:57 AM
Unknown Object (File)
Jan 13 2025, 9:17 AM
Unknown Object (File)
Nov 29 2024, 3:22 PM
View All 85 Files
Subscribers
mat

Details

Reviewers
tz
rene
miwi
Commits
rP446626: - Fix the makesum target, so that all distfiles are considered
Summary
  • Fix the makesum target, so that all distfiles are considered

Approved by: xxxx (mentor)
#Differential Revision: https://reviews.freebsd.org/Dxxxxx

Diff Detail

Repository
rP FreeBSD ports repository
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

joneum created this revision.Jul 23 2017, 11:33 AM
Herald added a subscriber: mat. · View Herald TranscriptJul 23 2017, 11:33 AM
Harbormaster completed remote builds in B10628: Diff 31093.Jul 23 2017, 11:33 AM
rene accepted this revision.Jul 25 2017, 6:00 PM

It still looks a bit fishy to me (as in the Ports Framework needs to be more intelligent) but it works.

This revision is now accepted and ready to land.Jul 25 2017, 6:00 PM
Closed by commit rP446626: - Fix the makesum target, so that all distfiles are considered (authored by joneum). · Explain WhyJul 25 2017, 8:51 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
head/
www/
nginx/
5 lines

Diff 31201

View Options

head/www/nginx/Makefile

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