9 Commits
Author SHA1 Message Date
Michael Brown 22916e6284 WIP 2023-06-27 18:15:17 +01:00
Michael Brown 570134c7ba [efi] Rename "driver" to "target" in preparation for two-phase veto mechanism
Forcible uninstallation of handles installed by a vetoed driver can be
done only on the basis of an image handle, since there is no way
within the UEFI driver model to identify the driver that installed a
protocol on a handle.  A single image may provide multiple drivers.

This will require a two-phase mechanism in which we first perform the
DisconnectController() calls, uninstall the driver binding protocols,
and close any stray handles associated with the driver handle.  Once
all driver binding handles have been processed in this way, a second
pass can close and uninstall any stray handles associated with the
image handle.

Prepare for a two-phase veto mechanism by renaming the "driver" handle
to a "target" handle (which may be either the driver handle or the
image handle).

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-27 14:49:41 +01:00
Michael Brown a029f4e13b [efi] Veto the VirtualBox E1kNetDxe driver
The VirtualBox E1kNetDxe driver has a Stop() method that relies on
being passed its own child device handle.  Unfortunately, the same
driver's Start() method never opens the parent device handle with
BY_CHILD_CONTROLLER attributes on behalf of the newly installed child
device handle, with the result that the UEFI device model is
completely unaware of the nominal parent-child relationship.  This
omission can be observed via the UEFI shell "devtree" command, which
will show the child SNP device handle as a standalone top-level device
handle, with no relationship to its underlying parent PCI device
handle.

The upshot of this omission is that the VirtualBox E1kNetDxe driver's
Stop() method is a pure no-op.  Calling DisconnectController() on the
PCI device handle will return successfully, but will not have actually
disconnected anything.  A subsequent attempt to open the handle on
behalf of iPXE's native Intel driver will get stuck in an infinite
loop inside OpenProtocol(), as the firmware repeatedly calls
DisconnectController() in an attempt to disconnect the E1kNetDxe
driver from the PCI device handle.

Work around this problem by adding the buggy VirtualBox E1kNetDxe
driver to the veto list.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-23 16:51:10 +01:00
Michael Brown ae435cb4cc [efi] Process veto objects in reverse order of enumeration
While not guaranteed by the UEFI specification, the enumeration of
handles, protocols, and openers will generally return results in order
of creation.  Processing these objects in reverse order (as is already
done when calling DisconnectController() on the list of all handles)
will generally therefore perform the forcible uninstallation
operations in reverse order of object creation, which minimises the
number of implicit operations performed (e.g. when disconnecting a
controller that itself still has existent child controllers).

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-23 16:51:10 +01:00
Michael Brown f8a0d1c0b8 [efi] Check for protocols opened by vetoed driver and image handles
The UEFI specification states that the AgentHandle may be either the
driving binding protocol handle or the image handle.

Check for both handles when searching for stale handles to be forcibly
closed on behalf of a vetoed driver.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-23 16:51:10 +01:00
Michael Brown f0b1025503 [efi] Unload vetoed drivers by image handle rather than driver handle
In most cases, the driver handle will be the image handle itself.
However, this is not required by the UEFI specification, and some
images will install multiple driver binding handles.

Use the image handle (extracted from the driver binding protocol
instance) when attempting to unload the driver's image.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-23 16:51:10 +01:00
Michael Brown c832580f19 [efi] Pass more detailed driver information to veto methods
Pass the driver binding handle, the driver binding protocol instance,
the image handle, and the loaded image protocol instance to all veto
methods.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-23 16:22:27 +01:00
Michael Brown 9a118322a0 [efi] Show manufacturer in veto debug output
Simplify the process of adding new entries to the veto list by
including the manufacturer name within the standard debug output.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-22 23:20:37 +01:00
Michael Brown 2689a6e776 [efi] Always poll for TX completions
Polling for TX completions is arguably redundant when there are no
transmissions currently in progress.  Commit c6c7e78 ("[efi] Poll for
TX completions only when there is an outstanding TX buffer") switched
to setting the PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS flag only when
there is an in-progress transmission awaiting completion, in order to
reduce reported TX errors and debug message noise from buggy NII
implementations that report spurious TX completions whenever the
transmit queue is empty.

Some other NII implementations (observed with the Realtek driver in a
Dell Latitude 3440) seem to have a bug in the transmit datapath
handling which results in the transmit ring freezing after sending a
few hundred packets under heavy load.  The symptoms are that the
TPPoll register's NPQ bit remains set and the 256-entry transmit ring
contains a large number of uncompleted descriptors (with the OWN bit
set), the first two of which have identical data buffer addresses.

Though iPXE will submit at most one in-progress transmission via NII,
the Dell/Realtek driver seems to make a page-aligned copy of each
transmit data buffer and to report TX completions immediately without
waiting for the packet to actually be transmitted.  These synthetic TX
completions continue even after the hardware transmit ring freezes.

Setting PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS on every poll reduces the
probability of this Dell/Realtek driver bug being triggered by a
factor of around 500, which brings the failure rate down to the point
that it can sensibly be managed by external logic such as the
"--timeout" option for image downloads.  Closing and reopening the
interface (via "ifclose"/"ifopen") will clear the error condition and
allow transmissions to resume.

Revert to setting PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS on every poll,
and silently ignore situations in which the hardware reports a
completion when no transmission is in progress.  This approximately
matches the behaviour of the SnpDxe driver, which will also generally
set PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS on every poll.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
2023-06-21 11:49:53 +01:00
2 changed files with 274 additions and 173 deletions
+5 -5
View File
@@ -1032,8 +1032,9 @@ static void nii_poll_tx ( struct net_device *netdev, unsigned int stat ) {
if ( stat & PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN ) if ( stat & PXE_STATFLAGS_GET_STATUS_NO_TXBUFS_WRITTEN )
return; return;
/* Sanity check */ /* Ignore spurious completions reported by some devices */
assert ( nii->txbuf != NULL ); if ( ! nii->txbuf )
return;
/* Complete transmission */ /* Complete transmission */
iobuf = nii->txbuf; iobuf = nii->txbuf;
@@ -1131,7 +1132,7 @@ static void nii_poll ( struct net_device *netdev ) {
/* Get status */ /* Get status */
op = NII_OP ( PXE_OPCODE_GET_STATUS, op = NII_OP ( PXE_OPCODE_GET_STATUS,
( PXE_OPFLAGS_GET_INTERRUPT_STATUS | ( PXE_OPFLAGS_GET_INTERRUPT_STATUS |
( nii->txbuf ? PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS : 0)| PXE_OPFLAGS_GET_TRANSMITTED_BUFFERS |
( nii->media ? PXE_OPFLAGS_GET_MEDIA_STATUS : 0 ) ) ); ( nii->media ? PXE_OPFLAGS_GET_MEDIA_STATUS : 0 ) ) );
if ( ( stat = nii_issue_db ( nii, op, &db, sizeof ( db ) ) ) < 0 ) { if ( ( stat = nii_issue_db ( nii, op, &db, sizeof ( db ) ) ) < 0 ) {
rc = -EIO_STAT ( stat ); rc = -EIO_STAT ( stat );
@@ -1141,8 +1142,7 @@ static void nii_poll ( struct net_device *netdev ) {
} }
/* Process any TX completions */ /* Process any TX completions */
if ( nii->txbuf ) nii_poll_tx ( netdev, stat );
nii_poll_tx ( netdev, stat );
/* Process any RX completions */ /* Process any RX completions */
nii_poll_rx ( netdev ); nii_poll_rx ( netdev );
+269 -168
View File
@@ -44,39 +44,65 @@ struct efi_veto {
/** /**
* Check if driver is vetoed * Check if driver is vetoed
* *
* @v binding Driver binding protocol
* @v loaded Loaded image protocol
* @v wtf Component name protocol, if present
* @v manufacturer Manufacturer name, if present * @v manufacturer Manufacturer name, if present
* @v name Driver name (in "eng" language), if present * @v name Driver name (in "eng" language), if present
* @ret vetoed Driver is to be vetoed * @ret vetoed Driver is to be vetoed
*/ */
int ( * veto ) ( EFI_DRIVER_BINDING_PROTOCOL *binding, int ( * veto ) ( const char *manufacturer, const CHAR16 *name );
EFI_LOADED_IMAGE_PROTOCOL *loaded,
EFI_COMPONENT_NAME_PROTOCOL *wtf,
const char *manufacturer, const CHAR16 *name );
}; };
/** /**
* Unload an EFI driver * Unload an EFI driver
* *
* @v driver Driver binding handle * @v driver Driver binding handle
* @v image Image handle to fill in on failure
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_unload ( EFI_HANDLE driver ) { static int efi_veto_unload ( EFI_HANDLE driver, EFI_HANDLE *image ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
union {
EFI_DRIVER_BINDING_PROTOCOL *binding;
void *interface;
} binding;
EFI_STATUS efirc; EFI_STATUS efirc;
int rc; int rc;
/* Unload the driver */ /* Clear image handle */
if ( ( efirc = bs->UnloadImage ( driver ) ) != 0 ) { *image = NULL;
/* Open driver binding protocol */
if ( ( efirc = bs->OpenProtocol (
driver, &efi_driver_binding_protocol_guid,
&binding.interface, efi_image_handle, driver,
EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not unload: %s\n", DBGC ( driver, "EFIVETO %s could not open driver binding "
efi_handle_name ( driver ), strerror ( rc ) ); "protocol: %s\n", efi_handle_name ( driver ),
return rc; strerror ( rc ) );
goto err_binding;
} }
return 0; /* Identify image handle */
*image = binding.binding->ImageHandle;
/* Unload the driver */
if ( ( efirc = bs->UnloadImage ( *image ) ) != 0 ) {
rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not unload",
efi_handle_name ( driver ) );
DBGC ( driver, " %s: %s\n",
efi_handle_name ( *image ), strerror ( rc ) );
goto err_unload;
}
/* Invalidate now-unloaded image handle */
*image = NULL;
err_unload:
bs->CloseProtocol ( driver, &efi_driver_binding_protocol_guid,
efi_image_handle, driver );
err_binding:
return rc;
} }
/** /**
@@ -129,62 +155,78 @@ static int efi_veto_disconnect ( EFI_HANDLE driver ) {
} }
/** /**
* Uninstall an EFI driver binding protocol * Uninstall an EFI protocol
* *
* @v driver Driver binding handle * @v agent Agent handle
* @v loaded Loaded image protocol filter, or NULL
* @v handle Potentially opened handle
* @v protocol Installed protocol
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_uninstall ( EFI_HANDLE driver ) { static int efi_veto_uninstall ( EFI_HANDLE agent,
EFI_LOADED_IMAGE_PROTOCOL *loaded,
EFI_HANDLE handle, EFI_GUID *protocol ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
union { void *interface;
EFI_DRIVER_BINDING_PROTOCOL *binding; void *method;
void *interface; size_t offset;
} binding;
EFI_STATUS efirc; EFI_STATUS efirc;
int rc; int rc;
/* Open driver binding protocol */ /* Open protocol */
if ( ( efirc = bs->OpenProtocol ( if ( ( efirc = bs->OpenProtocol (
driver, &efi_driver_binding_protocol_guid, handle, protocol, &interface, efi_image_handle, agent,
&binding.interface, efi_image_handle, driver,
EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) { EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not open driver binding " DBGC ( agent, "EFIVETO %s could not open %s",
"protocol: %s\n", efi_handle_name ( driver ), efi_handle_name ( agent ), efi_guid_ntoa ( protocol ) );
strerror ( rc ) ); DBGC ( agent, " on %s: %s\n",
efi_handle_name ( handle ), strerror ( rc ) );
return rc; return rc;
} }
/* Close driver binding protocol */ /* Get representative method pointer, if known */
bs->CloseProtocol ( driver, &efi_driver_binding_protocol_guid, method = efi_veto_method ( protocol, interface );
efi_image_handle, driver );
/* Uninstall driver binding protocol */ /* Close protocol */
bs->CloseProtocol ( handle, protocol, efi_image_handle, agent );
/* Do nothing if method does not match filter */
if ( loaded ) {
offset = ( method - loaded->ImageBase );
if ( offset > loaded->ImageSize )
return 0;
}
/* Print debug message before potential invalidation of handle */
DBGC2 ( agent, "EFIVETO %s uninstalling %s",
efi_handle_name ( agent ), efi_guid_ntoa ( protocol ) );
DBGC2 ( agent, " from %s\n", efi_handle_name ( handle ) );
/* Uninstall protocol */
if ( ( efirc = bs->UninstallMultipleProtocolInterfaces ( if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
driver, &efi_driver_binding_protocol_guid, handle, protocol, interface, NULL ) ) != 0 ) {
binding.binding, NULL ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not uninstall driver " DBGC ( agent, "EFIVETO %s could not uninstall %s",
"binding protocol: %s\n", efi_handle_name ( agent ), efi_guid_ntoa ( protocol ) );
efi_handle_name ( driver ), strerror ( rc ) ); DBGC ( agent, " from %s: %s\n",
efi_handle_name ( handle ), strerror ( rc ) );
return rc; return rc;
} }
DBGC2 ( driver, "EFIVETO %s uninstalled driver binding protocol\n",
efi_handle_name ( driver ) );
return 0; return 0;
} }
/** /**
* Close protocol on handle potentially opened by an EFI driver * Close protocol on handle potentially opened by an EFI driver
* *
* @v driver Driver binding handle * @v agent Agent handle
* @v handle Potentially opened handle * @v handle Potentially opened handle
* @v protocol Opened protocol * @v protocol Opened protocol
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_close_protocol ( EFI_HANDLE driver, EFI_HANDLE handle, static int efi_veto_close ( EFI_HANDLE agent, EFI_HANDLE handle,
EFI_GUID *protocol ) { EFI_GUID *protocol ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *openers; EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *openers;
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *opener; EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *opener;
@@ -198,27 +240,28 @@ static int efi_veto_close_protocol ( EFI_HANDLE driver, EFI_HANDLE handle,
if ( ( efirc = bs->OpenProtocolInformation ( handle, protocol, &openers, if ( ( efirc = bs->OpenProtocolInformation ( handle, protocol, &openers,
&count ) ) != 0 ) { &count ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not retrieve openers", DBGC ( agent, "EFIVETO %s could not retrieve openers",
efi_handle_name ( driver ) ); efi_handle_name ( agent ) );
DBGC ( driver, " of %s %s: %s", efi_handle_name ( handle ), DBGC ( agent, " of %s %s: %s", efi_handle_name ( handle ),
efi_guid_ntoa ( protocol ), strerror ( rc ) ); efi_guid_ntoa ( protocol ), strerror ( rc ) );
goto err_list; goto err_list;
} }
/* Close anything opened by this driver */ /* Close anything opened by this driver */
for ( i = 0 ; i < count ; i++ ) { for ( i = 0 ; i < count ; i++ ) {
opener = &openers[i]; opener = &openers[ count - i - 1 ];
if ( opener->AgentHandle != driver ) if ( opener->AgentHandle != agent )
continue; continue;
controller = opener->ControllerHandle; controller = opener->ControllerHandle;
DBGC_EFI_OPENER ( driver, handle, protocol, opener ); DBGC_EFI_OPENER ( agent, handle, protocol, opener );
if ( ( efirc = bs->CloseProtocol ( handle, protocol, driver, if ( ( efirc = bs->CloseProtocol ( handle, protocol, agent,
controller ) ) != 0 ) { controller ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not close stray open", DBGC ( agent, "EFIVETO %s could not close stray open",
efi_handle_name ( driver ) ); efi_handle_name ( agent ) );
DBGC ( driver, " of %s: %s\n", DBGC ( agent, " of %s %s: %s\n",
efi_handle_name ( handle ), strerror ( rc ) ); efi_handle_name ( handle ),
efi_guid_ntoa ( protocol ), strerror ( rc ) );
goto err_close; goto err_close;
} }
} }
@@ -233,15 +276,19 @@ static int efi_veto_close_protocol ( EFI_HANDLE driver, EFI_HANDLE handle,
} }
/** /**
* Close handle potentially opened by an EFI driver * Close/uninstall handle potentially used by an EFI driver
* *
* @v driver Driver binding handle * @v agent Agent handle
* @v loaded Loaded image protocol for uninstallation, or NULL
* @v handle Potentially opened handle * @v handle Potentially opened handle
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_close_handle ( EFI_HANDLE driver, EFI_HANDLE handle ) { static int efi_veto_handle ( EFI_HANDLE agent,
EFI_LOADED_IMAGE_PROTOCOL *loaded,
EFI_HANDLE handle ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
EFI_GUID **protocols; EFI_GUID **protocols;
EFI_GUID *protocol;
UINTN count; UINTN count;
unsigned int i; unsigned int i;
EFI_STATUS efirc; EFI_STATUS efirc;
@@ -251,23 +298,34 @@ static int efi_veto_close_handle ( EFI_HANDLE driver, EFI_HANDLE handle ) {
if ( ( efirc = bs->ProtocolsPerHandle ( handle, &protocols, if ( ( efirc = bs->ProtocolsPerHandle ( handle, &protocols,
&count ) ) != 0 ) { &count ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not retrieve protocols", DBGC ( agent, "EFIVETO %s could not retrieve protocols",
efi_handle_name ( driver ) ); efi_handle_name ( agent ) );
DBGC ( driver, " for %s: %s\n", DBGC ( agent, " for %s: %s\n",
efi_handle_name ( handle ), strerror ( rc ) ); efi_handle_name ( handle ), strerror ( rc ) );
goto err_list; goto err_list;
} }
/* Close each protocol */ /* Close each protocol */
for ( i = 0 ; i < count ; i++ ) { for ( i = 0 ; i < count ; i++ ) {
if ( ( rc = efi_veto_close_protocol ( driver, handle, protocol = protocols[ count - i - 1];
protocols[i] ) ) != 0 ) if ( ( rc = efi_veto_close ( agent, handle, protocol ) ) != 0 )
goto err_close; goto err_close;
} }
/* Uninstall each protocol, if applicable */
if ( loaded ) {
for ( i = 0 ; i < count ; i++ ) {
protocol = protocols[ count - i - 1];
if ( ( rc = efi_veto_uninstall ( agent, loaded, handle,
protocol ) ) != 0 )
goto err_uninstall;
}
}
/* Success */ /* Success */
rc = 0; rc = 0;
err_uninstall:
err_close: err_close:
bs->FreePool ( protocols ); bs->FreePool ( protocols );
err_list: err_list:
@@ -275,14 +333,17 @@ static int efi_veto_close_handle ( EFI_HANDLE driver, EFI_HANDLE handle ) {
} }
/** /**
* Close all remaining handles opened by an EFI driver * Close/uninstall all remaining handles used by an EFI driver
* *
* @v driver Driver binding handle * @v agent Agent handle
* @v loaded Loaded image protocol for uninstallation, or NULL
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_close ( EFI_HANDLE driver ) { static int efi_veto_handles ( EFI_HANDLE agent,
EFI_LOADED_IMAGE_PROTOCOL *loaded ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
EFI_HANDLE *handles; EFI_HANDLE *handles;
EFI_HANDLE handle;
UINTN count; UINTN count;
unsigned int i; unsigned int i;
EFI_STATUS efirc; EFI_STATUS efirc;
@@ -292,24 +353,25 @@ static int efi_veto_close ( EFI_HANDLE driver ) {
if ( ( efirc = bs->LocateHandleBuffer ( AllHandles, NULL, NULL, if ( ( efirc = bs->LocateHandleBuffer ( AllHandles, NULL, NULL,
&count, &handles ) ) != 0 ) { &count, &handles ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not enumerate handles: %s\n", DBGC ( agent, "EFIVETO %s could not enumerate handles: %s\n",
efi_handle_name ( driver ), strerror ( rc ) ); efi_handle_name ( agent ), strerror ( rc ) );
goto err_list; goto err_list;
} }
/* Close each handle */ /* Close and/or uninstall each handle */
for ( i = 0 ; i < count ; i++ ) { for ( i = 0 ; i < count ; i++ ) {
if ( ( rc = efi_veto_close_handle ( driver, handle = handles[ count - i - 1 ];
handles[i] ) ) != 0 ) if ( ( rc = efi_veto_handle ( agent, loaded, handle ) ) != 0 )
goto err_close; goto err_handle;
} }
/* Success */ /* Success */
rc = 0; rc = 0;
DBGC2 ( driver, "EFIVETO %s closed all remaining handles\n", DBGC2 ( agent, "EFIVETO %s closed%s all remaining handles\n",
efi_handle_name ( driver ) ); efi_handle_name ( agent ),
( loaded ? " and uninstalled" : "" ) );
err_close: err_handle:
bs->FreePool ( handles ); bs->FreePool ( handles );
err_list: err_list:
return rc; return rc;
@@ -318,10 +380,11 @@ static int efi_veto_close ( EFI_HANDLE driver ) {
/** /**
* Terminate an EFI driver with extreme prejudice * Terminate an EFI driver with extreme prejudice
* *
* @v driver Driver binding handle * @v driver Driver handle
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_destroy ( EFI_HANDLE driver ) { static int efi_veto_destroy ( EFI_HANDLE driver ) {
EFI_GUID *binding = &efi_driver_binding_protocol_guid;
int rc; int rc;
/* Disconnect driver from all handles */ /* Disconnect driver from all handles */
@@ -329,53 +392,91 @@ static int efi_veto_destroy ( EFI_HANDLE driver ) {
return rc; return rc;
/* Uninstall driver binding protocol */ /* Uninstall driver binding protocol */
if ( ( rc = efi_veto_uninstall ( driver ) ) != 0 ) if ( ( rc = efi_veto_uninstall ( driver, NULL, driver,
binding ) ) != 0 )
return rc; return rc;
/* Close any remaining opened handles */ /* Close any remaining opened handles */
if ( ( rc = efi_veto_close ( driver ) ) != 0 ) if ( ( rc = efi_veto_handles ( driver, NULL ) ) != 0 )
return rc; return rc;
DBGC ( driver, "EFIVETO %s forcibly removed\n", DBGC ( driver, "EFIVETO %s forcibly removed driver\n",
efi_handle_name ( driver ) ); efi_handle_name ( driver ) );
return 0; return 0;
} }
/** /**
* Veto an EFI driver * Veto an EFI driver handle
* *
* @v driver Driver binding handle * @v driver Driver handle
* @ret image Image handle, if still present after veto attempt
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_driver ( EFI_HANDLE driver ) { static int efi_veto_driver ( EFI_HANDLE driver, EFI_HANDLE *image ) {
int rc; int rc;
/* Try gracefully unloading the driver */ /* Try gracefully unloading the underlying image */
if ( ( rc = efi_veto_unload ( driver ) ) == 0 ) if ( ( rc = efi_veto_unload ( driver, image ) ) == 0 )
return 0; return 0;
/* If that fails, use a hammer */ /* If that fails, use a hammer */
if ( ( rc = efi_veto_destroy ( driver ) ) == 0 ) if ( ( rc = efi_veto_destroy ( driver ) ) == 0 )
return 0; return 0;
DBGC ( driver, "EFIVETO %s could not veto driver: %s\n",
efi_handle_name ( driver ), strerror ( rc ) );
return rc;
}
/**
* Veto an EFI image handle
*
* @v image Image handle
* @ret rc Return status code
*/
static int efi_veto_image ( EFI_HANDLE image ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
union {
EFI_LOADED_IMAGE_PROTOCOL *loaded;
void *interface;
} loaded;
EFI_STATUS efirc;
int rc;
/* Open loaded image protocol */
if ( ( efirc = bs->OpenProtocol (
image, &efi_loaded_image_protocol_guid,
&loaded.interface, efi_image_handle, image,
EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
rc = -EEFI ( efirc );
DBGC ( image, "EFIVETO %s could not open loaded image "
"protocol: %s\n", efi_handle_name ( image ),
strerror ( rc ) );
goto err_loaded;
}
/* Close and uninstall any remaining handles */
if ( ( rc = efi_veto_handles ( image, loaded.loaded ) ) != 0 )
return rc;
DBGC ( image, "EFIVETO %s forcibly removed image\n",
efi_handle_name ( image ) );
bs->CloseProtocol ( image, &efi_loaded_image_protocol_guid,
efi_image_handle, image );
err_loaded:
return rc; return rc;
} }
/** /**
* Veto Ip4ConfigDxe driver on some platforms * Veto Ip4ConfigDxe driver on some platforms
* *
* @v binding Driver binding protocol
* @v loaded Loaded image protocol
* @v wtf Component name protocol, if present
* @v manufacturer Manufacturer name, if present * @v manufacturer Manufacturer name, if present
* @v name Driver name, if present * @v name Driver name, if present
* @ret vetoed Driver is to be vetoed * @ret vetoed Driver is to be vetoed
*/ */
static int static int efi_veto_ip4config ( const char *manufacturer,
efi_veto_ip4config ( EFI_DRIVER_BINDING_PROTOCOL *binding __unused, const CHAR16 *name ) {
EFI_LOADED_IMAGE_PROTOCOL *loaded __unused,
EFI_COMPONENT_NAME_PROTOCOL *wtf __unused,
const char *manufacturer, const CHAR16 *name ) {
static const CHAR16 ip4cfg[] = L"IP4 CONFIG Network Service Driver"; static const CHAR16 ip4cfg[] = L"IP4 CONFIG Network Service Driver";
static const char *dell = "Dell Inc."; static const char *dell = "Dell Inc.";
static const char *itautec = "Itautec S.A."; static const char *itautec = "Itautec S.A.";
@@ -397,18 +498,11 @@ efi_veto_ip4config ( EFI_DRIVER_BINDING_PROTOCOL *binding __unused,
/** /**
* Veto HP XhciDxe driver * Veto HP XhciDxe driver
* *
* @v binding Driver binding protocol
* @v loaded Loaded image protocol
* @v wtf Component name protocol, if present
* @v manufacturer Manufacturer name, if present * @v manufacturer Manufacturer name, if present
* @v name Driver name, if present * @v name Driver name, if present
* @ret vetoed Driver is to be vetoed * @ret vetoed Driver is to be vetoed
*/ */
static int static int efi_veto_hp_xhci ( const char *manufacturer, const CHAR16 *name ) {
efi_veto_hp_xhci ( EFI_DRIVER_BINDING_PROTOCOL *binding __unused,
EFI_LOADED_IMAGE_PROTOCOL *loaded __unused,
EFI_COMPONENT_NAME_PROTOCOL *wtf __unused,
const char *manufacturer, const CHAR16 *name ) {
static const CHAR16 xhci[] = L"Usb Xhci Driver"; static const CHAR16 xhci[] = L"Usb Xhci Driver";
static const char *hp = "HP"; static const char *hp = "HP";
struct pci_driver *driver; struct pci_driver *driver;
@@ -439,17 +533,13 @@ efi_veto_hp_xhci ( EFI_DRIVER_BINDING_PROTOCOL *binding __unused,
* Veto VMware UefiPxeBcDxe driver * Veto VMware UefiPxeBcDxe driver
* *
* @v binding Driver binding protocol * @v binding Driver binding protocol
* @v loaded Loaded image protocol
* @v wtf Component name protocol, if present * @v wtf Component name protocol, if present
* @v manufacturer Manufacturer name, if present * @v manufacturer Manufacturer name, if present
* @v name Driver name, if present * @v name Driver name, if present
* @ret vetoed Driver is to be vetoed * @ret vetoed Driver is to be vetoed
*/ */
static int static int efi_veto_vmware_uefipxebc ( const char *manufacturer,
efi_veto_vmware_uefipxebc ( EFI_DRIVER_BINDING_PROTOCOL *binding __unused, const CHAR16 *name ) {
EFI_LOADED_IMAGE_PROTOCOL *loaded __unused,
EFI_COMPONENT_NAME_PROTOCOL *wtf __unused,
const char *manufacturer, const CHAR16 *name ) {
static const CHAR16 uefipxebc[] = L"UEFI PXE Base Code Driver"; static const CHAR16 uefipxebc[] = L"UEFI PXE Base Code Driver";
static const char *vmware = "VMware, Inc."; static const char *vmware = "VMware, Inc.";
@@ -466,6 +556,31 @@ efi_veto_vmware_uefipxebc ( EFI_DRIVER_BINDING_PROTOCOL *binding __unused,
return 1; return 1;
} }
/**
* Veto VirtualBox E1kNetDxe driver
*
* @v manufacturer Manufacturer name, if present
* @v name Driver name, if present
* @ret vetoed Driver is to be vetoed
*/
static int efi_veto_vbox_e1knet ( const char *manufacturer,
const CHAR16 *name ) {
static const CHAR16 e1knet[] = L"E1000 network interface card Driver";
static const char *vbox = "innotek GmbH";
/* Check manufacturer and driver name */
if ( ! manufacturer )
return 0;
if ( ! name )
return 0;
if ( strcmp ( manufacturer, vbox ) != 0 )
return 0;
if ( memcmp ( name, e1knet, sizeof ( e1knet ) ) != 0 )
return 0;
return 1;
}
/** Driver vetoes */ /** Driver vetoes */
static struct efi_veto efi_vetoes[] = { static struct efi_veto efi_vetoes[] = {
{ {
@@ -480,6 +595,10 @@ static struct efi_veto efi_vetoes[] = {
.name = "VMware UefiPxeBc", .name = "VMware UefiPxeBc",
.veto = efi_veto_vmware_uefipxebc, .veto = efi_veto_vmware_uefipxebc,
}, },
{
.name = "VirtualBox E1kNetDxe",
.veto = efi_veto_vbox_e1knet,
},
}; };
/** /**
@@ -487,29 +606,19 @@ static struct efi_veto efi_vetoes[] = {
* *
* @v driver Driver binding handle * @v driver Driver binding handle
* @v manufacturer Manufacturer name, if present * @v manufacturer Manufacturer name, if present
* @ret veto Driver veto, or NULL * @ret veto Driver veto to fill in
* @ret rc Return status code * @ret rc Return status code
*/ */
static int efi_veto_find ( EFI_HANDLE driver, const char *manufacturer, static int efi_veto_find ( EFI_HANDLE driver, const char *manufacturer,
struct efi_veto **veto ) { struct efi_veto **veto ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
union {
EFI_DRIVER_BINDING_PROTOCOL *binding;
void *interface;
} binding;
union {
EFI_LOADED_IMAGE_PROTOCOL *loaded;
void *interface;
} loaded;
union { union {
EFI_COMPONENT_NAME_PROTOCOL *wtf; EFI_COMPONENT_NAME_PROTOCOL *wtf;
void *interface; void *interface;
} wtf; } wtf;
CHAR16 *name; CHAR16 *name;
unsigned int i; unsigned int i;
EFI_HANDLE image;
EFI_STATUS efirc; EFI_STATUS efirc;
int rc;
DBGC2 ( &efi_vetoes, "EFIVETO checking %s\n", DBGC2 ( &efi_vetoes, "EFIVETO checking %s\n",
efi_handle_name ( driver ) ); efi_handle_name ( driver ) );
@@ -517,32 +626,6 @@ static int efi_veto_find ( EFI_HANDLE driver, const char *manufacturer,
/* Mark as not vetoed */ /* Mark as not vetoed */
*veto = NULL; *veto = NULL;
/* Open driver binding protocol */
if ( ( efirc = bs->OpenProtocol (
driver, &efi_driver_binding_protocol_guid,
&binding.interface, efi_image_handle, driver,
EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not open driver binding "
"protocol: %s\n", efi_handle_name ( driver ),
strerror ( rc ) );
goto err_binding;
}
image = binding.binding->ImageHandle;
/* Open loaded image protocol */
if ( ( efirc = bs->OpenProtocol (
image, &efi_loaded_image_protocol_guid,
&loaded.interface, efi_image_handle, image,
EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
rc = -EEFI ( efirc );
DBGC ( driver, "EFIVETO %s could not open",
efi_handle_name ( driver ) );
DBGC ( driver, " %s loaded image protocol: %s\n",
efi_handle_name ( image ), strerror ( rc ) );
goto err_loaded;
}
/* Open component name protocol, if present*/ /* Open component name protocol, if present*/
if ( ( efirc = bs->OpenProtocol ( if ( ( efirc = bs->OpenProtocol (
driver, &efi_component_name_protocol_guid, driver, &efi_component_name_protocol_guid,
@@ -565,28 +648,25 @@ static int efi_veto_find ( EFI_HANDLE driver, const char *manufacturer,
/* Check vetoes */ /* Check vetoes */
for ( i = 0 ; i < ( sizeof ( efi_vetoes ) / for ( i = 0 ; i < ( sizeof ( efi_vetoes ) /
sizeof ( efi_vetoes[0] ) ) ; i++ ) { sizeof ( efi_vetoes[0] ) ) ; i++ ) {
if ( efi_vetoes[i].veto ( binding.binding, loaded.loaded,
wtf.wtf, manufacturer, name ) ) {
*veto = &efi_vetoes[i];
break;
}
}
/* Success */ /* Check if this veto applies */
rc = 0; if ( ! efi_vetoes[i].veto ( manufacturer, name ) )
continue;
DBGC ( driver, "EFIVETO %s is vetoed (%s)\n",
efi_handle_name ( driver ), efi_vetoes[i].name );
*veto = &efi_vetoes[i];
break;
}
/* Close protocols */ /* Close protocols */
if ( wtf.wtf ) { if ( wtf.wtf ) {
bs->CloseProtocol ( driver, &efi_component_name_protocol_guid, bs->CloseProtocol ( driver, &efi_component_name_protocol_guid,
efi_image_handle, driver ); efi_image_handle, driver );
} }
bs->CloseProtocol ( image, &efi_loaded_image_protocol_guid,
efi_image_handle, image ); return 0;
err_loaded:
bs->CloseProtocol ( driver, &efi_driver_binding_protocol_guid,
efi_image_handle, driver );
err_binding:
return rc;
} }
/** /**
@@ -596,9 +676,10 @@ static int efi_veto_find ( EFI_HANDLE driver, const char *manufacturer,
void efi_veto ( void ) { void efi_veto ( void ) {
EFI_BOOT_SERVICES *bs = efi_systab->BootServices; EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
struct efi_veto *veto; struct efi_veto *veto;
EFI_HANDLE *drivers; EFI_HANDLE *targets;
EFI_HANDLE driver; EFI_HANDLE driver;
UINTN num_drivers; EFI_HANDLE image;
UINTN count;
unsigned int i; unsigned int i;
char *manufacturer; char *manufacturer;
EFI_STATUS efirc; EFI_STATUS efirc;
@@ -607,7 +688,7 @@ void efi_veto ( void ) {
/* Locate all driver binding protocol handles */ /* Locate all driver binding protocol handles */
if ( ( efirc = bs->LocateHandleBuffer ( if ( ( efirc = bs->LocateHandleBuffer (
ByProtocol, &efi_driver_binding_protocol_guid, ByProtocol, &efi_driver_binding_protocol_guid,
NULL, &num_drivers, &drivers ) ) != 0 ) { NULL, &count, &targets ) ) != 0 ) {
rc = -EEFI ( efirc ); rc = -EEFI ( efirc );
DBGC ( &efi_vetoes, "EFIVETO could not list all drivers: " DBGC ( &efi_vetoes, "EFIVETO could not list all drivers: "
"%s\n", strerror ( rc ) ); "%s\n", strerror ( rc ) );
@@ -617,10 +698,16 @@ void efi_veto ( void ) {
/* Get manufacturer name */ /* Get manufacturer name */
fetch_string_setting_copy ( NULL, &manufacturer_setting, fetch_string_setting_copy ( NULL, &manufacturer_setting,
&manufacturer ); &manufacturer );
DBGC ( &efi_vetoes, "EFIVETO manufacturer is \"%s\"\n", manufacturer );
/* Unload any vetoed drivers */ /* Identify any vetoed drivers and veto the driver handles */
for ( i = 0 ; i < num_drivers ; i++ ) { for ( i = 0 ; i < count ; i++ ) {
driver = drivers[i];
/* Consume driver handle from target list */
driver = targets[ count - i - 1 ];
targets[ count - i - 1 ] = NULL;
/* Check if this driver is vetoed */
if ( ( rc = efi_veto_find ( driver, manufacturer, if ( ( rc = efi_veto_find ( driver, manufacturer,
&veto ) ) != 0 ) { &veto ) ) != 0 ) {
DBGC ( driver, "EFIVETO %s could not determine " DBGC ( driver, "EFIVETO %s could not determine "
@@ -630,17 +717,31 @@ void efi_veto ( void ) {
} }
if ( ! veto ) if ( ! veto )
continue; continue;
DBGC ( driver, "EFIVETO %s is vetoed (%s)\n",
efi_handle_name ( driver ), veto->name ); /* Veto driver handle */
if ( ( rc = efi_veto_driver ( driver ) ) != 0 ) { if ( ( rc = efi_veto_driver ( driver, &image ) ) != 0 )
DBGC ( driver, "EFIVETO %s could not veto: %s\n", continue;
efi_handle_name ( driver ), strerror ( rc ) );
} /* Record image handle (if still present) as a target */
targets[ count - i - 1 ] = image;
}
/* Veto any remaining image handles */
for ( i = 0 ; i < count ; i++ ) {
/* Consume image handle from target list */
image = targets[ count - i - 1 ];
if ( ! image )
continue;
/* Veto image handle */
if ( ( rc = efi_veto_image ( image ) ) != 0 )
continue;
} }
/* Free manufacturer name */ /* Free manufacturer name */
free ( manufacturer ); free ( manufacturer );
/* Free handle list */ /* Free handle list */
bs->FreePool ( drivers ); bs->FreePool ( targets );
} }