mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-10-31 10:23:09 +00:00
4583a73470
In order to allow libvirt to create and start new mediated devices, we need to be able to verify that the device has been started. In order to do this, we'll need to save the UUID of newly-discovered devices within the virNodeDevCapMdev structure. This allows us to search the device list by UUID and verify whether the expected device has been started. Signed-off-by: Jonathon Jongsma <jjongsma@redhat.com> Reviewed-by: Erik Skultety <eskultet@redhat.com> Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
389 lines
12 KiB
C
389 lines
12 KiB
C
/*
|
|
* node_device_conf.h: config handling for node devices
|
|
*
|
|
* Copyright (C) 2009-2015 Red Hat, Inc.
|
|
* Copyright (C) 2008 Virtual Iron Software, Inc.
|
|
* Copyright (C) 2008 David F. Lively
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "internal.h"
|
|
#include "virbitmap.h"
|
|
#include "virscsihost.h"
|
|
#include "virpci.h"
|
|
#include "virvhba.h"
|
|
#include "device_conf.h"
|
|
#include "storage_adapter_conf.h"
|
|
#include "virenum.h"
|
|
|
|
#include <libxml/tree.h>
|
|
|
|
#define CREATE_DEVICE 1
|
|
#define EXISTING_DEVICE 0
|
|
|
|
typedef enum {
|
|
/* Keep in sync with VIR_ENUM_IMPL in node_device_conf.c */
|
|
VIR_NODE_DEV_DEVNODE_DEV,
|
|
VIR_NODE_DEV_DEVNODE_LINK,
|
|
|
|
VIR_NODE_DEV_DEVNODE_LAST
|
|
} virNodeDevDevnodeType;
|
|
|
|
VIR_ENUM_DECL(virNodeDevDevnode);
|
|
|
|
typedef enum {
|
|
/* Keep in sync with VIR_ENUM_IMPL in node_device_conf.c */
|
|
VIR_NODE_DEV_CAP_SYSTEM, /* System capability */
|
|
VIR_NODE_DEV_CAP_PCI_DEV, /* PCI device */
|
|
VIR_NODE_DEV_CAP_USB_DEV, /* USB device */
|
|
VIR_NODE_DEV_CAP_USB_INTERFACE, /* USB interface */
|
|
VIR_NODE_DEV_CAP_NET, /* Network device */
|
|
VIR_NODE_DEV_CAP_SCSI_HOST, /* SCSI Host Bus Adapter */
|
|
VIR_NODE_DEV_CAP_SCSI_TARGET, /* SCSI Target */
|
|
VIR_NODE_DEV_CAP_SCSI, /* SCSI device */
|
|
VIR_NODE_DEV_CAP_STORAGE, /* Storage device */
|
|
VIR_NODE_DEV_CAP_FC_HOST, /* FC Host Bus Adapter */
|
|
VIR_NODE_DEV_CAP_VPORTS, /* HBA which is capable of vports */
|
|
VIR_NODE_DEV_CAP_SCSI_GENERIC, /* SCSI generic device */
|
|
VIR_NODE_DEV_CAP_DRM, /* DRM device */
|
|
VIR_NODE_DEV_CAP_MDEV_TYPES, /* Device capable of mediated devices */
|
|
VIR_NODE_DEV_CAP_MDEV, /* Mediated device */
|
|
VIR_NODE_DEV_CAP_CCW_DEV, /* s390 CCW device */
|
|
|
|
VIR_NODE_DEV_CAP_LAST
|
|
} virNodeDevCapType;
|
|
|
|
typedef enum {
|
|
/* Keep in sync with VIR_ENUM_IMPL in node_device_conf.c */
|
|
VIR_NODE_DEV_CAP_NET_80203, /* 802.03 network device */
|
|
VIR_NODE_DEV_CAP_NET_80211, /* 802.11 network device */
|
|
VIR_NODE_DEV_CAP_NET_LAST
|
|
} virNodeDevNetCapType;
|
|
|
|
VIR_ENUM_DECL(virNodeDevCap);
|
|
VIR_ENUM_DECL(virNodeDevNetCap);
|
|
|
|
typedef enum {
|
|
VIR_NODE_DEV_CAP_STORAGE_REMOVABLE = (1 << 0),
|
|
VIR_NODE_DEV_CAP_STORAGE_REMOVABLE_MEDIA_AVAILABLE = (1 << 1),
|
|
VIR_NODE_DEV_CAP_STORAGE_HOTPLUGGABLE = (1 << 2),
|
|
} virNodeDevStorageCapFlags;
|
|
|
|
typedef enum {
|
|
VIR_NODE_DEV_CAP_FLAG_HBA_FC_HOST = (1 << 0),
|
|
VIR_NODE_DEV_CAP_FLAG_HBA_VPORT_OPS = (1 << 1),
|
|
} virNodeDevSCSIHostCapFlags;
|
|
|
|
typedef enum {
|
|
VIR_NODE_DEV_CAP_FLAG_FC_RPORT = (1 << 0),
|
|
} virNodeDevSCSITargetCapsFlags;
|
|
|
|
typedef enum {
|
|
VIR_NODE_DEV_CAP_FLAG_PCI_PHYSICAL_FUNCTION = (1 << 0),
|
|
VIR_NODE_DEV_CAP_FLAG_PCI_VIRTUAL_FUNCTION = (1 << 1),
|
|
VIR_NODE_DEV_CAP_FLAG_PCIE = (1 << 2),
|
|
VIR_NODE_DEV_CAP_FLAG_PCI_MDEV = (1 << 3),
|
|
} virNodeDevPCICapFlags;
|
|
|
|
typedef enum {
|
|
/* Keep in sync with VIR_ENUM_IMPL in node_device_conf.c */
|
|
VIR_NODE_DEV_DRM_PRIMARY,
|
|
VIR_NODE_DEV_DRM_CONTROL,
|
|
VIR_NODE_DEV_DRM_RENDER,
|
|
|
|
VIR_NODE_DEV_DRM_LAST
|
|
} virNodeDevDRMType;
|
|
|
|
VIR_ENUM_DECL(virNodeDevDRM);
|
|
|
|
typedef struct _virNodeDevCapSystemHardware virNodeDevCapSystemHardware;
|
|
typedef virNodeDevCapSystemHardware *virNodeDevCapSystemHardwarePtr;
|
|
struct _virNodeDevCapSystemHardware {
|
|
char *vendor_name;
|
|
char *version;
|
|
char *serial;
|
|
unsigned char uuid[VIR_UUID_BUFLEN];
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSystemFirmware virNodeDevCapSystemFirmware;
|
|
typedef virNodeDevCapSystemFirmware *virNodeDevCapSystemFirmwarePtr;
|
|
struct _virNodeDevCapSystemFirmware {
|
|
char *vendor_name;
|
|
char *version;
|
|
char *release_date;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSystem virNodeDevCapSystem;
|
|
typedef virNodeDevCapSystem *virNodeDevCapSystemPtr;
|
|
struct _virNodeDevCapSystem {
|
|
char *product_name;
|
|
virNodeDevCapSystemHardware hardware;
|
|
virNodeDevCapSystemFirmware firmware;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapMdev virNodeDevCapMdev;
|
|
typedef virNodeDevCapMdev *virNodeDevCapMdevPtr;
|
|
struct _virNodeDevCapMdev {
|
|
char *type;
|
|
unsigned int iommuGroupNumber;
|
|
char *uuid;
|
|
virMediatedDeviceAttrPtr *attributes;
|
|
size_t nattributes;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapPCIDev virNodeDevCapPCIDev;
|
|
typedef virNodeDevCapPCIDev *virNodeDevCapPCIDevPtr;
|
|
struct _virNodeDevCapPCIDev {
|
|
unsigned int domain;
|
|
unsigned int bus;
|
|
unsigned int slot;
|
|
unsigned int function;
|
|
unsigned int product;
|
|
unsigned int vendor;
|
|
int klass;
|
|
char *product_name;
|
|
char *vendor_name;
|
|
virPCIDeviceAddressPtr physical_function;
|
|
virPCIDeviceAddressPtr *virtual_functions;
|
|
size_t num_virtual_functions;
|
|
unsigned int max_virtual_functions;
|
|
unsigned int flags;
|
|
virPCIDeviceAddressPtr *iommuGroupDevices;
|
|
size_t nIommuGroupDevices;
|
|
unsigned int iommuGroupNumber;
|
|
int numa_node;
|
|
virPCIEDeviceInfoPtr pci_express;
|
|
int hdrType; /* enum virPCIHeaderType or -1 */
|
|
virMediatedDeviceTypePtr *mdev_types;
|
|
size_t nmdev_types;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapUSBDev virNodeDevCapUSBDev;
|
|
typedef virNodeDevCapUSBDev *virNodeDevCapUSBDevPtr;
|
|
struct _virNodeDevCapUSBDev {
|
|
unsigned int bus;
|
|
unsigned int device;
|
|
unsigned int product;
|
|
unsigned int vendor;
|
|
char *product_name;
|
|
char *vendor_name;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapUSBIf virNodeDevCapUSBIf;
|
|
typedef virNodeDevCapUSBIf *virNodeDevCapUSBIfPtr;
|
|
struct _virNodeDevCapUSBIf {
|
|
unsigned int number;
|
|
unsigned int klass;
|
|
unsigned int subclass;
|
|
unsigned int protocol;
|
|
char *description;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapNet virNodeDevCapNet;
|
|
typedef virNodeDevCapNet *virNodeDevCapNetPtr;
|
|
struct _virNodeDevCapNet {
|
|
char *address;
|
|
unsigned int address_len;
|
|
char *ifname;
|
|
virNetDevIfLink lnk;
|
|
virNodeDevNetCapType subtype; /* LAST -> no subtype */
|
|
virBitmapPtr features; /* enum virNetDevFeature */
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSCSIHost virNodeDevCapSCSIHost;
|
|
typedef virNodeDevCapSCSIHost *virNodeDevCapSCSIHostPtr;
|
|
struct _virNodeDevCapSCSIHost {
|
|
unsigned int host;
|
|
int unique_id;
|
|
char *wwnn;
|
|
char *wwpn;
|
|
char *fabric_wwn;
|
|
unsigned int flags;
|
|
int max_vports;
|
|
int vports;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSCSITarget virNodeDevCapSCSITarget;
|
|
typedef virNodeDevCapSCSITarget *virNodeDevCapSCSITargetPtr;
|
|
struct _virNodeDevCapSCSITarget {
|
|
char *name;
|
|
unsigned int flags; /* enum virNodeDevSCSITargetCapsFlags */
|
|
char *rport;
|
|
char *wwpn;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSCSI virNodeDevCapSCSI;
|
|
typedef virNodeDevCapSCSI *virNodeDevCapSCSIPtr;
|
|
struct _virNodeDevCapSCSI {
|
|
unsigned int host;
|
|
unsigned int bus;
|
|
unsigned int target;
|
|
unsigned int lun;
|
|
char *type;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapStorage virNodeDevCapStorage;
|
|
typedef virNodeDevCapStorage *virNodeDevCapStoragePtr;
|
|
struct _virNodeDevCapStorage {
|
|
unsigned long long size;
|
|
unsigned long long num_blocks;
|
|
unsigned long long logical_block_size;
|
|
unsigned long long removable_media_size;
|
|
char *block;
|
|
char *bus;
|
|
char *drive_type;
|
|
char *model;
|
|
char *vendor;
|
|
char *serial;
|
|
char *media_label;
|
|
unsigned int flags; /* virNodeDevStorageCapFlags bits */
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSCSIGeneric virNodeDevCapSCSIGeneric;
|
|
typedef virNodeDevCapSCSIGeneric *virNodeDevCapSCSIGenericPtr;
|
|
struct _virNodeDevCapSCSIGeneric {
|
|
char *path;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapDRM virNodeDevCapDRM;
|
|
typedef virNodeDevCapDRM *virNodeDevCapDRMPtr;
|
|
struct _virNodeDevCapDRM {
|
|
virNodeDevDRMType type;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapCCW virNodeDevCapCCW;
|
|
typedef virNodeDevCapCCW *virNodeDevCapCCWPtr;
|
|
struct _virNodeDevCapCCW {
|
|
unsigned int cssid;
|
|
unsigned int ssid;
|
|
unsigned int devno;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapData virNodeDevCapData;
|
|
typedef virNodeDevCapData *virNodeDevCapDataPtr;
|
|
struct _virNodeDevCapData {
|
|
virNodeDevCapType type;
|
|
union {
|
|
virNodeDevCapSystem system;
|
|
virNodeDevCapPCIDev pci_dev;
|
|
virNodeDevCapUSBDev usb_dev;
|
|
virNodeDevCapUSBIf usb_if;
|
|
virNodeDevCapNet net;
|
|
virNodeDevCapSCSIHost scsi_host;
|
|
virNodeDevCapSCSITarget scsi_target;
|
|
virNodeDevCapSCSI scsi;
|
|
virNodeDevCapStorage storage;
|
|
virNodeDevCapSCSIGeneric sg;
|
|
virNodeDevCapDRM drm;
|
|
virNodeDevCapMdev mdev;
|
|
virNodeDevCapCCW ccw_dev;
|
|
};
|
|
};
|
|
|
|
typedef struct _virNodeDevCapsDef virNodeDevCapsDef;
|
|
typedef virNodeDevCapsDef *virNodeDevCapsDefPtr;
|
|
struct _virNodeDevCapsDef {
|
|
virNodeDevCapData data;
|
|
virNodeDevCapsDefPtr next; /* next capability */
|
|
};
|
|
|
|
|
|
typedef struct _virNodeDeviceDef virNodeDeviceDef;
|
|
typedef virNodeDeviceDef *virNodeDeviceDefPtr;
|
|
struct _virNodeDeviceDef {
|
|
char *name; /* device name (unique on node) */
|
|
char *sysfs_path; /* udev name/sysfs path */
|
|
char *parent; /* optional parent device name */
|
|
char *parent_sysfs_path; /* udev parent name/sysfs path */
|
|
char *parent_wwnn; /* optional parent wwnn */
|
|
char *parent_wwpn; /* optional parent wwpn */
|
|
char *parent_fabric_wwn; /* optional parent fabric_wwn */
|
|
char *driver; /* optional driver name */
|
|
char *devnode; /* /dev path */
|
|
char **devlinks; /* /dev links */
|
|
virNodeDevCapsDefPtr caps; /* optional device capabilities */
|
|
};
|
|
|
|
char *
|
|
virNodeDeviceDefFormat(const virNodeDeviceDef *def);
|
|
|
|
virNodeDeviceDefPtr
|
|
virNodeDeviceDefParseString(const char *str,
|
|
int create,
|
|
const char *virt_type);
|
|
|
|
virNodeDeviceDefPtr
|
|
virNodeDeviceDefParseFile(const char *filename,
|
|
int create,
|
|
const char *virt_type);
|
|
|
|
virNodeDeviceDefPtr
|
|
virNodeDeviceDefParseNode(xmlDocPtr xml,
|
|
xmlNodePtr root,
|
|
int create,
|
|
const char *virt_type);
|
|
|
|
int
|
|
virNodeDeviceGetWWNs(virNodeDeviceDefPtr def,
|
|
char **wwnn,
|
|
char **wwpn);
|
|
|
|
void
|
|
virNodeDeviceDefFree(virNodeDeviceDefPtr def);
|
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNodeDeviceDef, virNodeDeviceDefFree);
|
|
|
|
void
|
|
virNodeDevCapsDefFree(virNodeDevCapsDefPtr caps);
|
|
|
|
#define VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP \
|
|
(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_DRM | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV_TYPES | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_MDEV | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_CCW_DEV)
|
|
|
|
int
|
|
virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHostPtr scsi_host);
|
|
|
|
int
|
|
virNodeDeviceGetSCSITargetCaps(const char *sysfsPath,
|
|
virNodeDevCapSCSITargetPtr scsi_target);
|
|
|
|
int
|
|
virNodeDeviceGetPCIDynamicCaps(const char *sysfsPath,
|
|
virNodeDevCapPCIDevPtr pci_dev);
|
|
|
|
int
|
|
virNodeDeviceUpdateCaps(virNodeDeviceDefPtr def);
|
|
|
|
int
|
|
virNodeDeviceCapsListExport(virNodeDeviceDefPtr def,
|
|
virNodeDevCapType **list);
|