mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-10-30 18:03:32 +00:00
0268270b0f
Allow callers to request XML validation against the schema. All callers for now pass 'false'. Signed-off-by: Peter Krempa <pkrempa@redhat.com> Reviewed-by: Jonathon Jongsma <jjongsma@redhat.com>
469 lines
15 KiB
C
469 lines
15 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 "virccw.h"
|
|
#include "virpcivpd.h"
|
|
#include "virscsihost.h"
|
|
#include "virpci.h"
|
|
#include "virvhba.h"
|
|
#include "device_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_CSS_DEV, /* s390 channel subsystem device */
|
|
VIR_NODE_DEV_CAP_VDPA, /* vDPA device */
|
|
VIR_NODE_DEV_CAP_AP_CARD, /* s390 AP Card device */
|
|
VIR_NODE_DEV_CAP_AP_QUEUE, /* s390 AP Queue */
|
|
VIR_NODE_DEV_CAP_AP_MATRIX, /* s390 AP Matrix device */
|
|
VIR_NODE_DEV_CAP_VPD, /* Device provides VPD */
|
|
|
|
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),
|
|
VIR_NODE_DEV_CAP_FLAG_PCI_VPD = (1 << 4),
|
|
} virNodeDevPCICapFlags;
|
|
|
|
typedef enum {
|
|
VIR_NODE_DEV_CAP_FLAG_CSS_MDEV = (1 << 0),
|
|
} virNodeDevCCWCapFlags;
|
|
|
|
typedef enum {
|
|
VIR_NODE_DEV_CAP_FLAG_AP_MATRIX_MDEV = (1 << 0),
|
|
} virNodeDevAPMatrixCapFlags;
|
|
|
|
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;
|
|
struct _virNodeDevCapSystemHardware {
|
|
char *vendor_name;
|
|
char *version;
|
|
char *serial;
|
|
unsigned char uuid[VIR_UUID_BUFLEN];
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSystemFirmware virNodeDevCapSystemFirmware;
|
|
struct _virNodeDevCapSystemFirmware {
|
|
char *vendor_name;
|
|
char *version;
|
|
char *release_date;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSystem virNodeDevCapSystem;
|
|
struct _virNodeDevCapSystem {
|
|
char *product_name;
|
|
virNodeDevCapSystemHardware hardware;
|
|
virNodeDevCapSystemFirmware firmware;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapMdev virNodeDevCapMdev;
|
|
struct _virNodeDevCapMdev {
|
|
char *type;
|
|
unsigned int iommuGroupNumber;
|
|
char *uuid;
|
|
virMediatedDeviceAttr **attributes;
|
|
size_t nattributes;
|
|
char *parent_addr;
|
|
bool autostart;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapPCIDev virNodeDevCapPCIDev;
|
|
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;
|
|
virPCIDeviceAddress *physical_function;
|
|
virPCIDeviceAddress **virtual_functions;
|
|
size_t num_virtual_functions;
|
|
unsigned int max_virtual_functions;
|
|
unsigned int flags;
|
|
virPCIDeviceAddress **iommuGroupDevices;
|
|
size_t nIommuGroupDevices;
|
|
unsigned int iommuGroupNumber;
|
|
int numa_node;
|
|
virPCIEDeviceInfo *pci_express;
|
|
int hdrType; /* enum virPCIHeaderType or -1 */
|
|
virMediatedDeviceType **mdev_types;
|
|
size_t nmdev_types;
|
|
virPCIVPDResource *vpd;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapUSBDev virNodeDevCapUSBDev;
|
|
struct _virNodeDevCapUSBDev {
|
|
unsigned int bus;
|
|
unsigned int device;
|
|
unsigned int product;
|
|
unsigned int vendor;
|
|
char *product_name;
|
|
char *vendor_name;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapUSBIf virNodeDevCapUSBIf;
|
|
struct _virNodeDevCapUSBIf {
|
|
unsigned int number;
|
|
unsigned int klass;
|
|
unsigned int subclass;
|
|
unsigned int protocol;
|
|
char *description;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapNet virNodeDevCapNet;
|
|
struct _virNodeDevCapNet {
|
|
char *address;
|
|
unsigned int address_len;
|
|
char *ifname;
|
|
virNetDevIfLink lnk;
|
|
virNodeDevNetCapType subtype; /* LAST -> no subtype */
|
|
virBitmap *features; /* enum virNetDevFeature */
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSCSIHost virNodeDevCapSCSIHost;
|
|
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;
|
|
struct _virNodeDevCapSCSITarget {
|
|
char *name;
|
|
unsigned int flags; /* enum virNodeDevSCSITargetCapsFlags */
|
|
char *rport;
|
|
char *wwpn;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapSCSI virNodeDevCapSCSI;
|
|
struct _virNodeDevCapSCSI {
|
|
unsigned int host;
|
|
unsigned int bus;
|
|
unsigned int target;
|
|
unsigned int lun;
|
|
char *type;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapStorage virNodeDevCapStorage;
|
|
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;
|
|
struct _virNodeDevCapSCSIGeneric {
|
|
char *path;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapDRM virNodeDevCapDRM;
|
|
struct _virNodeDevCapDRM {
|
|
virNodeDevDRMType type;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapCCW virNodeDevCapCCW;
|
|
struct _virNodeDevCapCCW {
|
|
unsigned int cssid;
|
|
unsigned int ssid;
|
|
unsigned int devno;
|
|
unsigned int flags; /* enum virNodeDevCCWCapFlags */
|
|
virMediatedDeviceType **mdev_types;
|
|
size_t nmdev_types;
|
|
virCCWDeviceAddress *channel_dev_addr;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapVDPA virNodeDevCapVDPA;
|
|
struct _virNodeDevCapVDPA {
|
|
char *chardev;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapAPCard virNodeDevCapAPCard;
|
|
struct _virNodeDevCapAPCard {
|
|
unsigned int ap_adapter;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapAPQueue virNodeDevCapAPQueue;
|
|
struct _virNodeDevCapAPQueue {
|
|
unsigned int ap_adapter;
|
|
unsigned int ap_domain;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapAPMatrix virNodeDevCapAPMatrix;
|
|
struct _virNodeDevCapAPMatrix {
|
|
char *addr;
|
|
unsigned int flags; /* enum virNodeDevAPMatrixCapFlags */
|
|
virMediatedDeviceType **mdev_types;
|
|
size_t nmdev_types;
|
|
};
|
|
|
|
|
|
typedef struct _virNodeDevCapMdevParent virNodeDevCapMdevParent;
|
|
struct _virNodeDevCapMdevParent {
|
|
virMediatedDeviceType **mdev_types;
|
|
size_t nmdev_types;
|
|
char *address;
|
|
};
|
|
|
|
typedef struct _virNodeDevCapData virNodeDevCapData;
|
|
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;
|
|
virNodeDevCapVDPA vdpa;
|
|
virNodeDevCapAPCard ap_card;
|
|
virNodeDevCapAPQueue ap_queue;
|
|
virNodeDevCapAPMatrix ap_matrix;
|
|
virNodeDevCapMdevParent mdev_parent;
|
|
};
|
|
};
|
|
|
|
typedef struct _virNodeDevCapsDef virNodeDevCapsDef;
|
|
struct _virNodeDevCapsDef {
|
|
virNodeDevCapData data;
|
|
virNodeDevCapsDef *next; /* next capability */
|
|
};
|
|
|
|
|
|
typedef struct _virNodeDeviceDef virNodeDeviceDef;
|
|
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 */
|
|
virNodeDevCapsDef *caps; /* optional device capabilities */
|
|
};
|
|
|
|
char *
|
|
virNodeDeviceDefFormat(const virNodeDeviceDef *def);
|
|
|
|
|
|
typedef int (*virNodeDeviceDefPostParseCallback)(virNodeDeviceDef *dev,
|
|
void *opaque);
|
|
|
|
typedef int (*virNodeDeviceDefValidateCallback)(virNodeDeviceDef *dev,
|
|
void *opaque);
|
|
|
|
typedef struct _virNodeDeviceDefParserCallbacks {
|
|
virNodeDeviceDefPostParseCallback postParse;
|
|
virNodeDeviceDefValidateCallback validate;
|
|
} virNodeDeviceDefParserCallbacks;
|
|
|
|
virNodeDeviceDef *
|
|
virNodeDeviceDefParse(const char *str,
|
|
const char *filename,
|
|
int create,
|
|
const char *virt_type,
|
|
virNodeDeviceDefParserCallbacks *parserCallbacks,
|
|
void *opaque,
|
|
bool validate);
|
|
|
|
virNodeDeviceDef *
|
|
virNodeDeviceDefParseXML(xmlXPathContextPtr ctxt,
|
|
int create,
|
|
const char *virt_type);
|
|
|
|
int
|
|
virNodeDeviceGetWWNs(virNodeDeviceDef *def,
|
|
char **wwnn,
|
|
char **wwpn);
|
|
|
|
void
|
|
virNodeDeviceDefFree(virNodeDeviceDef *def);
|
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNodeDeviceDef, virNodeDeviceDefFree);
|
|
|
|
void
|
|
virNodeDevCapsDefFree(virNodeDevCapsDef *caps);
|
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(virNodeDevCapsDef, virNodeDevCapsDefFree);
|
|
|
|
#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 | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_CSS_DEV | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_VDPA | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_AP_CARD | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_AP_QUEUE | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_AP_MATRIX | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPD)
|
|
|
|
#define VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_ACTIVE \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_ACTIVE | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_INACTIVE
|
|
|
|
#define VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_ALL \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_CAP | \
|
|
VIR_CONNECT_LIST_NODE_DEVICES_FILTERS_ACTIVE
|
|
|
|
int
|
|
virNodeDeviceGetSCSIHostCaps(virNodeDevCapSCSIHost *scsi_host);
|
|
|
|
int
|
|
virNodeDeviceGetSCSITargetCaps(const char *sysfsPath,
|
|
virNodeDevCapSCSITarget *scsi_target);
|
|
|
|
int
|
|
virNodeDeviceGetPCIDynamicCaps(const char *sysfsPath,
|
|
virNodeDevCapPCIDev *pci_dev);
|
|
|
|
int
|
|
virNodeDeviceGetCSSDynamicCaps(const char *sysfsPath,
|
|
virNodeDevCapCCW *ccw_dev);
|
|
|
|
int
|
|
virNodeDeviceGetAPMatrixDynamicCaps(const char *sysfsPath,
|
|
virNodeDevCapAPMatrix *ap_matrix);
|
|
|
|
int
|
|
virNodeDeviceGetMdevParentDynamicCaps(const char *sysfsPath,
|
|
virNodeDevCapMdevParent *mdev_parent);
|
|
|
|
int
|
|
virNodeDeviceUpdateCaps(virNodeDeviceDef *def);
|
|
|
|
int
|
|
virNodeDeviceCapsListExport(virNodeDeviceDef *def,
|
|
virNodeDevCapType **list);
|