mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-11-01 10:51:12 +00:00
88446e07b2
The driver URI scheme:
"$drivername:///embed?root=/some/path"
enables a new way to use the drivers by embedding them directly in the
calling process. To use this the process must have a thread running the
libvirt event loop. This URI will then cause libvirt to dynamically load
the driver module and call its global initialization function. This
syntax is applicable to any driver, but only those will have been
modified to support a custom root directory and embed URI path will
successfully open.
The application can now make normal libvirt API calls which are all
serviced in-process with no RPC layer involved.
It is required to specify an explicit root directory, and locks will be
acquired on this directory to avoid conflicting with another app that
might accidentally pick the same directory.
Use of '/' is not explicitly forbidden, but note that the file layout
used underneath the embedded driver root does not match the file
layout used by system/session mode drivers. So this cannot be used as
a backdoor to interact with, or fake, the system/session mode drivers.
Libvirt will create arbitrary files underneath this root directory. The
root directory can be kept untouched across connection open attempts if
the application needs persistence. The application is responsible for
purging everything underneath this root directory when finally no longer
required.
Even when a virt driver is used in embedded mode, it is still possible
for it to in turn use functionality that calls out to other secondary
drivers in libvirtd. For example an embedded instance of QEMU can open
the network, secret or storage drivers in the system libvirtd.
That said, the application would typically want to at least open an
embedded secret driver ("secret:///embed?root=/some/path"). Note that
multiple different embedded drivers can use the same root prefix and
co-operate just as they would inside a normal libvirtd daemon.
A key thing to note is that for this to work, the application that links
to libvirt *MUST* be built with -Wl,--export-dynamic to ensure that
symbols from libvirt.so are exported & thus available to the dynamically
loaded driver module. If libvirt.so itself was dynamically loaded then
RTLD_GLOBAL must be passed to dlopen().
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
139 lines
4.7 KiB
C
139 lines
4.7 KiB
C
/*
|
|
* driver.h: description of the set of interfaces provided by a
|
|
* entry point to the virtualization engine
|
|
*
|
|
* Copyright (C) 2006-2014 Red Hat, Inc.
|
|
*
|
|
* 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 <unistd.h>
|
|
|
|
#include "internal.h"
|
|
#include "libvirt_internal.h"
|
|
#include "viruri.h"
|
|
|
|
|
|
/* Status codes returned from driver open call. */
|
|
typedef enum {
|
|
/* Opened successfully. */
|
|
VIR_DRV_OPEN_SUCCESS = 0,
|
|
|
|
/* 'name' is not for us. */
|
|
VIR_DRV_OPEN_DECLINED = -1,
|
|
|
|
/* 'name' is for us, but there was some error. virConnectOpen will
|
|
* return an error rather than continue probing the other drivers.
|
|
*/
|
|
VIR_DRV_OPEN_ERROR = -2,
|
|
} virDrvOpenStatus;
|
|
|
|
|
|
/* Internal feature-detection macro. Don't call drv->supports_feature
|
|
* directly if you don't have to, because it may be NULL, use this macro
|
|
* instead.
|
|
*
|
|
* Note that this treats a possible error returned by drv->supports_feature
|
|
* the same as not supported. If you care about the error, call
|
|
* drv->supports_feature directly.
|
|
*
|
|
* Returns:
|
|
* != 0 Feature is supported.
|
|
* 0 Feature is not supported.
|
|
*/
|
|
#define VIR_DRV_SUPPORTS_FEATURE(drv, conn, feature) \
|
|
((drv)->connectSupportsFeature ? \
|
|
(drv)->connectSupportsFeature((conn), (feature)) > 0 : 0)
|
|
|
|
|
|
#define __VIR_DRIVER_H_INCLUDES___
|
|
|
|
#include "driver-hypervisor.h"
|
|
#include "driver-interface.h"
|
|
#include "driver-network.h"
|
|
#include "driver-nodedev.h"
|
|
#include "driver-nwfilter.h"
|
|
#include "driver-secret.h"
|
|
#include "driver-state.h"
|
|
#include "driver-stream.h"
|
|
#include "driver-storage.h"
|
|
|
|
#undef __VIR_DRIVER_H_INCLUDES___
|
|
|
|
typedef struct _virConnectDriver virConnectDriver;
|
|
typedef virConnectDriver *virConnectDriverPtr;
|
|
|
|
struct _virConnectDriver {
|
|
/* Whether driver permits a server in the URI */
|
|
bool localOnly;
|
|
/* Whether driver needs a server in the URI */
|
|
bool remoteOnly;
|
|
/* Whether driver can be used in embedded mode */
|
|
bool embeddable;
|
|
/*
|
|
* NULL terminated list of supported URI schemes.
|
|
* - Single element { NULL } list indicates no supported schemes
|
|
* - NULL list indicates wildcard supporting all schemes
|
|
*/
|
|
const char **uriSchemes;
|
|
virHypervisorDriverPtr hypervisorDriver;
|
|
virInterfaceDriverPtr interfaceDriver;
|
|
virNetworkDriverPtr networkDriver;
|
|
virNodeDeviceDriverPtr nodeDeviceDriver;
|
|
virNWFilterDriverPtr nwfilterDriver;
|
|
virSecretDriverPtr secretDriver;
|
|
virStorageDriverPtr storageDriver;
|
|
};
|
|
|
|
int virRegisterConnectDriver(virConnectDriverPtr driver,
|
|
bool setSharedDrivers) G_GNUC_WARN_UNUSED_RESULT;
|
|
int virRegisterStateDriver(virStateDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
|
|
int virSetSharedInterfaceDriver(virInterfaceDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
int virSetSharedNetworkDriver(virNetworkDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
int virSetSharedNodeDeviceDriver(virNodeDeviceDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
int virSetSharedNWFilterDriver(virNWFilterDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
int virSetSharedSecretDriver(virSecretDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
int virSetSharedStorageDriver(virStorageDriverPtr driver) G_GNUC_WARN_UNUSED_RESULT;
|
|
|
|
bool virHasDriverForURIScheme(const char *scheme);
|
|
|
|
int virDriverLoadModule(const char *name,
|
|
const char *regfunc,
|
|
bool required);
|
|
|
|
int virDriverShouldAutostart(const char *name,
|
|
bool *autostart);
|
|
|
|
virConnectPtr virGetConnectInterface(void);
|
|
virConnectPtr virGetConnectNetwork(void);
|
|
virConnectPtr virGetConnectNWFilter(void);
|
|
virConnectPtr virGetConnectNodeDev(void);
|
|
virConnectPtr virGetConnectSecret(void);
|
|
virConnectPtr virGetConnectStorage(void);
|
|
|
|
int virSetConnectInterface(virConnectPtr conn);
|
|
int virSetConnectNetwork(virConnectPtr conn);
|
|
int virSetConnectNWFilter(virConnectPtr conn);
|
|
int virSetConnectNodeDev(virConnectPtr conn);
|
|
int virSetConnectSecret(virConnectPtr conn);
|
|
int virSetConnectStorage(virConnectPtr conn);
|
|
|
|
bool virConnectValidateURIPath(const char *uriPath,
|
|
const char *entityName,
|
|
bool privileged);
|