efi_veto.c File Reference

EFI driver vetoes. More...

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/settings.h>
#include <ipxe/pci.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/Protocol/DriverBinding.h>
#include <ipxe/efi/Protocol/LoadedImage.h>
#include <ipxe/efi/Protocol/ComponentName.h>
#include <ipxe/efi/efi_veto.h>

Go to the source code of this file.

Data Structures
struct	efi_veto_candidate
	A driver veto candidate. More...
struct	efi_veto
	A driver veto. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	efi_veto_unload (struct efi_veto *veto)
	Unload an EFI driver. More...
static int	efi_veto_disconnect (struct efi_veto *veto)
	Disconnect an EFI driver from all handles. More...
static int	efi_veto_uninstall (struct efi_veto *veto)
	Uninstall an EFI driver binding protocol. More...
static int	efi_veto_close_protocol (struct efi_veto *veto, EFI_HANDLE handle, EFI_GUID *protocol)
	Close protocol on handle potentially opened by an EFI driver. More...
static int	efi_veto_close_handle (struct efi_veto *veto, EFI_HANDLE handle)
	Close handle potentially opened by an EFI driver. More...
static int	efi_veto_close (struct efi_veto *veto)
	Close all remaining handles opened by an EFI driver. More...
static int	efi_veto_destroy (struct efi_veto *veto)
	Terminate an EFI driver with extreme prejudice. More...
static int	efi_veto_driver (struct efi_veto *veto)
	Veto an EFI driver. More...
static int	efi_veto_ip4config (EFI_DRIVER_BINDING_PROTOCOL *binding __unused, EFI_LOADED_IMAGE_PROTOCOL *loaded __unused, EFI_COMPONENT_NAME_PROTOCOL *wtf __unused, const char *manufacturer, const CHAR16 *name)
	Veto Ip4ConfigDxe driver on some platforms. More...
static int	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)
	Veto HP XhciDxe driver. More...
static int	efi_veto_vmware_uefipxebc (EFI_DRIVER_BINDING_PROTOCOL *binding __unused, EFI_LOADED_IMAGE_PROTOCOL *loaded __unused, EFI_COMPONENT_NAME_PROTOCOL *wtf __unused, const char *manufacturer, const CHAR16 *name)
	Veto VMware UefiPxeBcDxe driver. More...
static int	efi_veto_dhcp6 (EFI_DRIVER_BINDING_PROTOCOL *binding __unused, EFI_LOADED_IMAGE_PROTOCOL *loaded __unused, EFI_COMPONENT_NAME_PROTOCOL *wtf __unused, const char *manufacturer __unused, const CHAR16 *name)
	Veto Dhcp6Dxe driver. More...
static int	efi_veto_find (EFI_HANDLE driver, const char *manufacturer, struct efi_veto *veto)
	Find driver veto, if any. More...
void	efi_veto (void)
	Remove any vetoed drivers. More...

Variables
static struct efi_veto_candidate	efi_vetoes []
	Driver vetoes. More...

Detailed Description

EFI driver vetoes.

Definition in file efi_veto.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

efi_veto_unload()

static int efi_veto_unload ( struct efi_veto *  veto )

static

Unload an EFI driver.

Parameters

veto	Driver veto

Return values

rc	Return status code

Definition at line 78 of file efi_veto.c.

                                                     {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE driver = veto->driver;
        EFI_HANDLE image = veto->image;
        EFI_STATUS efirc;
        int rc;

        /* 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 ) );
                return rc;
        }

        return 0;
}

References EFI_SYSTEM_TABLE::BootServices, DBGC, efi_veto::driver, EEFI, efi_handle_name(), efi_systab, efi_veto::image, rc, strerror(), and EFI_BOOT_SERVICES::UnloadImage.

Referenced by efi_veto_driver().

efi_veto_disconnect()

static int efi_veto_disconnect ( struct efi_veto *  veto )

static

Disconnect an EFI driver from all handles.

Parameters

veto	Driver veto

Return values

rc	Return status code

Definition at line 104 of file efi_veto.c.

                                                         {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE driver = veto->driver;
        EFI_HANDLE *handles;
        EFI_HANDLE handle;
        UINTN count;
        unsigned int i;
        EFI_STATUS efirc;
        int rc;

        /* Enumerate all handles */
        if ( ( efirc = bs->LocateHandleBuffer ( AllHandles, NULL, NULL,
                                                &count, &handles ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( driver, "EFIVETO %s could not enumerate handles: %s\n",
                       efi_handle_name ( driver ), strerror ( rc ) );
                goto err_list;
        }

        /* Disconnect driver from all handles, in reverse order */
        for ( i = 0 ; i < count ; i++ ) {
                handle = handles[ count - i - 1 ];
                efirc = bs->DisconnectController ( handle, driver, NULL );
                if ( ( efirc != 0 ) && ( efirc != EFI_NOT_FOUND ) ) {
                        rc = -EEFI ( efirc );
                        DBGC ( driver, "EFIVETO %s could not disconnect",
                               efi_handle_name ( driver ) );
                        DBGC ( driver, " %s: %s\n",
                               efi_handle_name ( handle ), strerror ( rc ) );
                        goto err_disconnect;
                }
        }

        /* Success */
        rc = 0;
        DBGC2 ( driver, "EFIVETO %s disconnected all handles\n",
                efi_handle_name ( driver ) );

 err_disconnect:
        bs->FreePool ( handles );
 err_list:
        return rc;
}

References AllHandles, EFI_SYSTEM_TABLE::BootServices, count, DBGC, DBGC2, EFI_BOOT_SERVICES::DisconnectController, efi_veto::driver, EEFI, efi_handle_name(), EFI_NOT_FOUND, efi_systab, EFI_BOOT_SERVICES::FreePool, handle, EFI_BOOT_SERVICES::LocateHandleBuffer, NULL, rc, and strerror().

Referenced by efi_veto_destroy().

efi_veto_uninstall()

static int efi_veto_uninstall ( struct efi_veto *  veto )

static

Uninstall an EFI driver binding protocol.

Parameters

veto	Driver veto

Return values

rc	Return status code

Definition at line 154 of file efi_veto.c.

                                                        {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE driver = veto->driver;
        union {
                EFI_DRIVER_BINDING_PROTOCOL *binding;
                void *interface;
        } binding;
        EFI_STATUS efirc;
        int rc;

        /* 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 ) );
                return rc;
        }

        /* Close driver binding protocol */
        bs->CloseProtocol ( driver, &efi_driver_binding_protocol_guid,
                            efi_image_handle, driver );

        /* Uninstall driver binding protocol */
        if ( ( efirc = bs->UninstallMultipleProtocolInterfaces (
                        driver, &efi_driver_binding_protocol_guid,
                        binding.binding, NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( driver, "EFIVETO %s could not uninstall driver "
                       "binding protocol: %s\n",
                       efi_handle_name ( driver ), strerror ( rc ) );
                return rc;
        }

        DBGC2 ( driver, "EFIVETO %s uninstalled driver binding protocol\n",
                efi_handle_name ( driver ) );
        return 0;
}

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, DBGC, DBGC2, efi_veto::driver, EEFI, efi_driver_binding_protocol_guid, efi_handle_name(), efi_image_handle, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_systab, NULL, EFI_BOOT_SERVICES::OpenProtocol, rc, strerror(), and EFI_BOOT_SERVICES::UninstallMultipleProtocolInterfaces.

Referenced by efi_veto_destroy().

efi_veto_close_protocol()

static int efi_veto_close_protocol ( struct efi_veto *  veto, EFI_HANDLE  handle, EFI_GUID *  protocol  )

static

Close protocol on handle potentially opened by an EFI driver.

Parameters

veto	Driver veto
handle	Potentially opened handle
protocol	Opened protocol

Return values

rc	Return status code

Definition at line 204 of file efi_veto.c.

                                                          {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE driver = veto->driver;
        EFI_HANDLE image = veto->image;
        EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *openers;
        EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *opener;
        EFI_HANDLE controller;
        UINTN count;
        unsigned int i;
        EFI_STATUS efirc;
        int rc;

        /* Retrieve list of openers */
        if ( ( efirc = bs->OpenProtocolInformation ( handle, protocol, &openers,
                                                     &count ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( driver, "EFIVETO %s could not retrieve openers",
                       efi_handle_name ( driver ) );
                DBGC ( driver, " of %s %s: %s", efi_handle_name ( handle ),
                       efi_guid_ntoa ( protocol ), strerror ( rc ) );
                goto err_list;
        }

        /* Close anything opened by this driver */
        for ( i = 0 ; i < count ; i++ ) {
                opener = &openers[ count - i - 1 ];
                if ( ( opener->AgentHandle != driver ) &&
                     ( opener->AgentHandle != image ) ) {
                        continue;
                }
                controller = opener->ControllerHandle;
                DBGC_EFI_OPENER ( driver, handle, protocol, opener );
                if ( ( efirc = bs->CloseProtocol ( handle, protocol, driver,
                                                   controller ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( driver, "EFIVETO %s could not close stray open",
                               efi_handle_name ( driver ) );
                        DBGC ( driver, " of %s: %s\n",
                               efi_handle_name ( handle ), strerror ( rc ) );
                        goto err_close;
                }
        }

        /* Success */
        rc = 0;

 err_close:
        bs->FreePool ( openers );
 err_list:
        return rc;
}

References EFI_OPEN_PROTOCOL_INFORMATION_ENTRY::AgentHandle, EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, controller, EFI_OPEN_PROTOCOL_INFORMATION_ENTRY::ControllerHandle, count, DBGC, DBGC_EFI_OPENER, efi_veto::driver, EEFI, efi_guid_ntoa(), efi_handle_name(), efi_systab, EFI_BOOT_SERVICES::FreePool, handle, efi_veto::image, EFI_BOOT_SERVICES::OpenProtocolInformation, protocol, rc, and strerror().

Referenced by efi_veto_close_handle().

efi_veto_close_handle()

static int efi_veto_close_handle ( struct efi_veto *  veto, EFI_HANDLE  handle  )

static

Close handle potentially opened by an EFI driver.

Parameters

veto	Driver veto
handle	Potentially opened handle

Return values

rc	Return status code

Definition at line 264 of file efi_veto.c.

                                                                              {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE driver = veto->driver;
        EFI_GUID **protocols;
        EFI_GUID *protocol;
        UINTN count;
        unsigned int i;
        EFI_STATUS efirc;
        int rc;

        /* Retrieve list of protocols */
        if ( ( efirc = bs->ProtocolsPerHandle ( handle, &protocols,
                                                &count ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( driver, "EFIVETO %s could not retrieve protocols",
                       efi_handle_name ( driver ) );
                DBGC ( driver, " for %s: %s\n",
                       efi_handle_name ( handle ), strerror ( rc ) );
                goto err_list;
        }

        /* Close each protocol */
        for ( i = 0 ; i < count ; i++ ) {
                protocol = protocols[ count - i - 1];
                if ( ( rc = efi_veto_close_protocol ( veto, handle,
                                                      protocol ) ) != 0 )
                        goto err_close;
        }

        /* Success */
        rc = 0;

 err_close:
        bs->FreePool ( protocols );
 err_list:
        return rc;
}

References EFI_SYSTEM_TABLE::BootServices, count, DBGC, efi_veto::driver, EEFI, efi_handle_name(), efi_systab, efi_veto_close_protocol(), EFI_BOOT_SERVICES::FreePool, handle, protocol, EFI_BOOT_SERVICES::ProtocolsPerHandle, rc, and strerror().

Referenced by efi_veto_close().

efi_veto_close()

static int efi_veto_close ( struct efi_veto *  veto )

static

Close all remaining handles opened by an EFI driver.

Parameters

veto	Driver veto

Return values

rc	Return status code

Definition at line 308 of file efi_veto.c.

                                                    {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE driver = veto->driver;
        EFI_HANDLE *handles;
        EFI_HANDLE handle;
        UINTN count;
        unsigned int i;
        EFI_STATUS efirc;
        int rc;

        /* Enumerate all handles */
        if ( ( efirc = bs->LocateHandleBuffer ( AllHandles, NULL, NULL,
                                                &count, &handles ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( driver, "EFIVETO %s could not enumerate handles: %s\n",
                       efi_handle_name ( driver ), strerror ( rc ) );
                goto err_list;
        }

        /* Close each handle */
        for ( i = 0 ; i < count ; i++ ) {
                handle = handles[ count - i - 1 ];
                if ( ( rc = efi_veto_close_handle ( veto, handle ) ) != 0 )
                        goto err_close;
        }

        /* Success */
        rc = 0;
        DBGC2 ( driver, "EFIVETO %s closed all remaining handles\n",
                efi_handle_name ( driver ) );

 err_close:
        bs->FreePool ( handles );
 err_list:
        return rc;
}

References AllHandles, EFI_SYSTEM_TABLE::BootServices, count, DBGC, DBGC2, efi_veto::driver, EEFI, efi_handle_name(), efi_systab, efi_veto_close_handle(), EFI_BOOT_SERVICES::FreePool, handle, EFI_BOOT_SERVICES::LocateHandleBuffer, NULL, rc, and strerror().

Referenced by efi_veto_destroy().

efi_veto_destroy()

static int efi_veto_destroy ( struct efi_veto *  veto )

static

Terminate an EFI driver with extreme prejudice.

Parameters

veto	Driver veto

Return values

rc	Return status code

Definition at line 351 of file efi_veto.c.

                                                      {
        EFI_HANDLE driver = veto->driver;
        int rc;

        /* Disconnect driver from all handles */
        if ( ( rc = efi_veto_disconnect ( veto ) ) != 0 )
                return rc;

        /* Uninstall driver binding protocol */
        if ( ( rc = efi_veto_uninstall ( veto ) ) != 0 )
                return rc;

        /* Close any remaining opened handles */
        if ( ( rc = efi_veto_close ( veto ) ) != 0 )
                return rc;

        DBGC ( driver, "EFIVETO %s forcibly removed\n",
               efi_handle_name ( driver ) );
        return 0;
}

References DBGC, efi_veto::driver, efi_handle_name(), efi_veto_close(), efi_veto_disconnect(), efi_veto_uninstall(), and rc.

Referenced by efi_veto_driver().

efi_veto_driver()

static int efi_veto_driver ( struct efi_veto *  veto )

static

Veto an EFI driver.

Parameters

veto	Driver veto

Return values

rc	Return status code

Definition at line 378 of file efi_veto.c.

                                                     {
        int rc;

        /* Try gracefully unloading the driver */
        if ( ( rc = efi_veto_unload ( veto ) ) == 0 )
                return 0;

        /* If that fails, use a hammer */
        if ( ( rc = efi_veto_destroy ( veto ) ) == 0 )
                return 0;

        return rc;
}

References efi_veto_destroy(), efi_veto_unload(), and rc.

Referenced by efi_veto().

efi_veto_ip4config()

static int efi_veto_ip4config ( 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

Veto Ip4ConfigDxe driver on some platforms.

Parameters

binding	Driver binding protocol
loaded	Loaded image protocol
wtf	Component name protocol, if present
manufacturer	Manufacturer name, if present
name	Driver name, if present

Return values

vetoed

Driver is to be vetoed

Definition at line 403 of file efi_veto.c.

                                                                    {
        static const CHAR16 ip4cfg[] = L"IP4 CONFIG Network Service Driver";
        static const char *dell = "Dell Inc.";
        static const char *itautec = "Itautec S.A.";

        /* Check manufacturer and driver name */
        if ( ! manufacturer )
                return 0;
        if ( ! name )
                return 0;
        if ( ( strcmp ( manufacturer, dell ) != 0 ) &&
             ( strcmp ( manufacturer, itautec ) != 0 ) )
                return 0;
        if ( memcmp ( name, ip4cfg, sizeof ( ip4cfg ) ) != 0 )
                return 0;

        return 1;
}

References manufacturer, memcmp(), name, and strcmp().

efi_veto_hp_xhci()

static int 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

Veto HP XhciDxe driver.

Parameters

binding	Driver binding protocol
loaded	Loaded image protocol
wtf	Component name protocol, if present
manufacturer	Manufacturer name, if present
name	Driver name, if present

Return values

vetoed

Driver is to be vetoed

Definition at line 436 of file efi_veto.c.

                                                                  {
        static const CHAR16 xhci[] = L"Usb Xhci Driver";
        static const char *hp = "HP";
        struct pci_driver *driver;

        /* Check manufacturer and driver name */
        if ( ! manufacturer )
                return 0;
        if ( ! name )
                return 0;
        if ( strcmp ( manufacturer, hp ) != 0 )
                return 0;
        if ( memcmp ( name, xhci, sizeof ( xhci ) ) != 0 )
                return 0;

        /* Veto driver only if we have our own xHCI driver */
        for_each_table_entry ( driver, PCI_DRIVERS ) {
                if ( driver->class.class ==
                     PCI_CLASS ( PCI_CLASS_SERIAL, PCI_CLASS_SERIAL_USB,
                                 PCI_CLASS_SERIAL_USB_XHCI ) ) {
                        return 1;
                }
        }

        return 0;
}

References pci_class_id::class, pci_driver::class, for_each_table_entry, manufacturer, memcmp(), name, PCI_CLASS, PCI_CLASS_SERIAL, PCI_CLASS_SERIAL_USB, PCI_CLASS_SERIAL_USB_XHCI, PCI_DRIVERS, and strcmp().

efi_veto_vmware_uefipxebc()

static int efi_veto_vmware_uefipxebc ( 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

Veto VMware UefiPxeBcDxe driver.

Parameters

binding	Driver binding protocol
loaded	Loaded image protocol
wtf	Component name protocol, if present
manufacturer	Manufacturer name, if present
name	Driver name, if present

Return values

vetoed

Driver is to be vetoed

Definition at line 477 of file efi_veto.c.

                                                                           {
        static const CHAR16 uefipxebc[] = L"UEFI PXE Base Code Driver";
        static const char *vmware = "VMware, Inc.";

        /* Check manufacturer and driver name */
        if ( ! manufacturer )
                return 0;
        if ( ! name )
                return 0;
        if ( strcmp ( manufacturer, vmware ) != 0 )
                return 0;
        if ( memcmp ( name, uefipxebc, sizeof ( uefipxebc ) ) != 0 )
                return 0;

        return 1;
}

References manufacturer, memcmp(), name, and strcmp().

efi_veto_dhcp6()

static int efi_veto_dhcp6 ( EFI_DRIVER_BINDING_PROTOCOL *binding  __unused, EFI_LOADED_IMAGE_PROTOCOL *loaded  __unused, EFI_COMPONENT_NAME_PROTOCOL *wtf  __unused, const char *manufacturer  __unused, const CHAR16 *  name  )

static

Veto Dhcp6Dxe driver.

Parameters

binding	Driver binding protocol
loaded	Loaded image protocol
wtf	Component name protocol, if present
manufacturer	Manufacturer name, if present
name	Driver name, if present

Return values

vetoed

Driver is to be vetoed

Definition at line 507 of file efi_veto.c.

                                                 {
        static const CHAR16 dhcp6[] = L"DHCP6 Protocol Driver";

        /* Check driver name */
        if ( ! name )
                return 0;
        if ( memcmp ( name, dhcp6, sizeof ( dhcp6 ) ) != 0 )
                return 0;

        return 1;
}

References memcmp(), and name.

efi_veto_find()

static int efi_veto_find ( EFI_HANDLE  driver, const char *  manufacturer, struct efi_veto *  veto  )

static

Find driver veto, if any.

Parameters

driver	Driver binding handle
manufacturer	Manufacturer name, if present

Return values

veto	Driver veto to fill in
rc	Return status code

Definition at line 551 of file efi_veto.c.

                                                   {
        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 {
                EFI_COMPONENT_NAME_PROTOCOL *wtf;
                void *interface;
        } wtf;
        CHAR16 *name;
        unsigned int i;
        EFI_HANDLE image;
        EFI_STATUS efirc;
        int rc;

        DBGC2 ( &efi_vetoes, "EFIVETO checking %s\n",
                efi_handle_name ( driver ) );

        /* Mark as not vetoed */
        memset ( veto, 0, sizeof ( *veto ) );

        /* 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*/
        if ( ( efirc = bs->OpenProtocol (
                        driver, &efi_component_name_protocol_guid,
                        &wtf.interface, efi_image_handle, driver,
                        EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
                /* Ignore failure; is not required to be present */
                wtf.interface = NULL;
        }

        /* Get driver name, if available */
        if ( wtf.wtf &&
             ( ( efirc = wtf.wtf->GetDriverName ( wtf.wtf, "eng",
                                                  &name ) == 0 ) ) ) {
                /* Driver has a name */
        } else {
                /* Ignore failure; name is not required to be present */
                name = NULL;
        }

        /* Check vetoes */
        for ( i = 0 ; i < ( sizeof ( efi_vetoes ) /
                            sizeof ( efi_vetoes[0] ) ) ; i++ ) {
                if ( efi_vetoes[i].veto ( binding.binding, loaded.loaded,
                                          wtf.wtf, manufacturer, name ) ) {
                        DBGC ( driver, "EFIVETO %s is vetoed (%s)\n",
                               efi_handle_name ( driver ),
                               efi_vetoes[i].name );
                        veto->driver = driver;
                        veto->binding = binding.binding;
                        veto->image = image;
                        veto->loaded = loaded.loaded;
                        break;
                }
        }

        /* Success */
        rc = 0;

        /* Close protocols */
        if ( wtf.wtf ) {
                bs->CloseProtocol ( driver, &efi_component_name_protocol_guid,
                                    efi_image_handle, driver );
        }
        bs->CloseProtocol ( image, &efi_loaded_image_protocol_guid,
                            efi_image_handle, image );
 err_loaded:
        bs->CloseProtocol ( driver, &efi_driver_binding_protocol_guid,
                            efi_image_handle, driver );
 err_binding:
        return rc;
}

References efi_veto::binding, EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, DBGC, DBGC2, efi_veto::driver, EEFI, efi_component_name_protocol_guid, efi_driver_binding_protocol_guid, efi_handle_name(), efi_image_handle, efi_loaded_image_protocol_guid, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_systab, efi_vetoes, efi_veto::image, efi_veto::loaded, manufacturer, memset(), name, NULL, EFI_BOOT_SERVICES::OpenProtocol, rc, strerror(), and wtf.

Referenced by efi_veto().

efi_veto()

void efi_veto

(

void

)

Remove any vetoed drivers.

Definition at line 660 of file efi_veto.c.

                       {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        struct efi_veto veto;
        EFI_HANDLE *drivers;
        EFI_HANDLE driver;
        UINTN count;
        unsigned int i;
        char *manufacturer;
        EFI_STATUS efirc;
        int rc;

        /* Locate all driver binding protocol handles */
        if ( ( efirc = bs->LocateHandleBuffer (
                        ByProtocol, &efi_driver_binding_protocol_guid,
                        NULL, &count, &drivers ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( &efi_vetoes, "EFIVETO could not list all drivers: "
                       "%s\n", strerror ( rc ) );
                return;
        }

        /* Get manufacturer name */
        fetch_string_setting_copy ( NULL, &manufacturer_setting,
                                    &manufacturer );
        DBGC ( &efi_vetoes, "EFIVETO manufacturer is \"%s\"\n", manufacturer );

        /* Unload any vetoed drivers */
        for ( i = 0 ; i < count ; i++ ) {
                driver = drivers[ count - i - 1 ];
                if ( ( rc = efi_veto_find ( driver, manufacturer,
                                            &veto ) ) != 0 ) {
                        DBGC ( driver, "EFIVETO %s could not determine "
                               "vetoing: %s\n",
                               efi_handle_name ( driver ), strerror ( rc ) );
                        continue;
                }
                if ( ! veto.driver )
                        continue;
                if ( ( rc = efi_veto_driver ( &veto ) ) != 0 ) {
                        DBGC ( driver, "EFIVETO %s could not veto: %s\n",
                               efi_handle_name ( driver ), strerror ( rc ) );
                }
        }

        /* Free manufacturer name */
        free ( manufacturer );

        /* Free handle list */
        bs->FreePool ( drivers );
}

References EFI_SYSTEM_TABLE::BootServices, ByProtocol, count, DBGC, efi_veto::driver, EEFI, efi_driver_binding_protocol_guid, efi_handle_name(), efi_systab, efi_veto_driver(), efi_veto_find(), efi_vetoes, fetch_string_setting_copy(), free, EFI_BOOT_SERVICES::FreePool, EFI_BOOT_SERVICES::LocateHandleBuffer, manufacturer, NULL, rc, and strerror().

Referenced by efi_probe().

Variable Documentation

efi_vetoes

struct efi_veto_candidate efi_vetoes[]

static

Initial value:

= {
        {
                .name = "Ip4Config",
                .veto = efi_veto_ip4config,
        },
        {
                .name = "HP Xhci",
                .veto = efi_veto_hp_xhci,
        },
        {
                .name = "VMware UefiPxeBc",
                .veto = efi_veto_vmware_uefipxebc,
        },
        {
                .name = "Dhcp6",
                .veto = efi_veto_dhcp6,
        },
}

Driver vetoes.

Definition at line 524 of file efi_veto.c.

Referenced by efi_veto(), and efi_veto_find().