2
* node_device_hal.c: node device enumeration - HAL-based implementation
4
* Copyright (C) 2008 Virtual Iron Software, Inc.
5
* Copyright (C) 2008 David F. Lively
7
* This library is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU Lesser General Public
9
* License as published by the Free Software Foundation; either
10
* version 2.1 of the License, or (at your option) any later version.
12
* This library is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* Lesser General Public License for more details.
17
* You should have received a copy of the GNU Lesser General Public
18
* License along with this library; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
* Author: David F. Lively <dlively@virtualiron.com>
30
#include "node_device_conf.h"
31
#include "node_device_hal.h"
32
#include "virterror_internal.h"
34
#include "datatypes.h"
39
#include "node_device.h"
41
#define VIR_FROM_THIS VIR_FROM_NODEDEV
44
* Host device enumeration (HAL implementation)
47
static virDeviceMonitorStatePtr driverState;
49
#define CONN_DRV_STATE(conn) \
50
((virDeviceMonitorStatePtr)((conn)->devMonPrivateData))
51
#define DRV_STATE_HAL_CTX(ds) ((LibHalContext *)((ds)->privateData))
52
#define CONN_HAL_CTX(conn) DRV_STATE_HAL_CTX(CONN_DRV_STATE(conn))
54
#define NODE_DEV_UDI(obj) ((const char *)((obj)->privateData)
57
static const char *hal_name(const char *udi)
59
const char *name = strrchr(udi, '/');
66
static int get_str_prop(LibHalContext *ctxt, const char *udi,
67
const char *prop, char **val_p)
69
char *val = libhal_device_get_property_string(ctxt, udi, prop, NULL);
76
/* Treat empty strings as NULL values */
84
static int get_int_prop(LibHalContext *ctxt, const char *udi,
85
const char *prop, int *val_p)
91
dbus_error_init(&err);
92
val = libhal_device_get_property_int(ctxt, udi, prop, &err);
93
rv = dbus_error_is_set(&err);
94
dbus_error_free(&err);
101
static int get_bool_prop(LibHalContext *ctxt, const char *udi,
102
const char *prop, int *val_p)
108
dbus_error_init(&err);
109
val = libhal_device_get_property_bool(ctxt, udi, prop, &err);
110
rv = dbus_error_is_set(&err);
111
dbus_error_free(&err);
118
static int get_uint64_prop(LibHalContext *ctxt, const char *udi,
119
const char *prop, unsigned long long *val_p)
122
unsigned long long val;
125
dbus_error_init(&err);
126
val = libhal_device_get_property_uint64(ctxt, udi, prop, &err);
127
rv = dbus_error_is_set(&err);
128
dbus_error_free(&err);
135
static int gather_pci_cap(LibHalContext *ctx, const char *udi,
136
union _virNodeDevCapData *d)
140
if (get_str_prop(ctx, udi, "pci.linux.sysfs_path", &sysfs_path) == 0) {
141
char *p = strrchr(sysfs_path, '/');
143
(void)virStrToLong_ui(p+1, &p, 16, &d->pci_dev.domain);
144
(void)virStrToLong_ui(p+1, &p, 16, &d->pci_dev.bus);
145
(void)virStrToLong_ui(p+1, &p, 16, &d->pci_dev.slot);
146
(void)virStrToLong_ui(p+1, &p, 16, &d->pci_dev.function);
148
VIR_FREE(sysfs_path);
150
(void)get_int_prop(ctx, udi, "pci.vendor_id", (int *)&d->pci_dev.vendor);
151
if (get_str_prop(ctx, udi, "pci.vendor", &d->pci_dev.vendor_name) != 0)
152
(void)get_str_prop(ctx, udi, "info.vendor", &d->pci_dev.vendor_name);
153
(void)get_int_prop(ctx, udi, "pci.product_id", (int *)&d->pci_dev.product);
154
if (get_str_prop(ctx, udi, "pci.product", &d->pci_dev.product_name) != 0)
155
(void)get_str_prop(ctx, udi, "info.product", &d->pci_dev.product_name);
160
static int gather_usb_cap(LibHalContext *ctx, const char *udi,
161
union _virNodeDevCapData *d)
163
(void)get_int_prop(ctx, udi, "usb.interface.number",
164
(int *)&d->usb_if.number);
165
(void)get_int_prop(ctx, udi, "usb.interface.class",
166
(int *)&d->usb_if._class);
167
(void)get_int_prop(ctx, udi, "usb.interface.subclass",
168
(int *)&d->usb_if.subclass);
169
(void)get_int_prop(ctx, udi, "usb.interface.protocol",
170
(int *)&d->usb_if.protocol);
171
(void)get_str_prop(ctx, udi, "usb.interface.description",
172
&d->usb_if.description);
177
static int gather_usb_device_cap(LibHalContext *ctx, const char *udi,
178
union _virNodeDevCapData *d)
180
(void)get_int_prop(ctx, udi, "usb_device.bus_number",
181
(int *)&d->usb_dev.bus);
182
(void)get_int_prop(ctx, udi, "usb_device.linux.device_number",
183
(int *)&d->usb_dev.device);
184
(void)get_int_prop(ctx, udi, "usb_device.vendor_id",
185
(int *)&d->usb_dev.vendor);
186
if (get_str_prop(ctx, udi, "usb_device.vendor",
187
&d->usb_dev.vendor_name) != 0)
188
(void)get_str_prop(ctx, udi, "info.vendor", &d->usb_dev.vendor_name);
189
(void)get_int_prop(ctx, udi, "usb_device.product_id",
190
(int *)&d->usb_dev.product);
191
if (get_str_prop(ctx, udi, "usb_device.product",
192
&d->usb_dev.product_name) != 0)
193
(void)get_str_prop(ctx, udi, "info.product", &d->usb_dev.product_name);
198
static int gather_net_cap(LibHalContext *ctx, const char *udi,
199
union _virNodeDevCapData *d)
201
unsigned long long dummy;
202
(void)get_str_prop(ctx, udi, "net.interface", &d->net.ifname);
203
(void)get_str_prop(ctx, udi, "net.address", &d->net.address);
204
if (get_uint64_prop(ctx, udi, "net.80203.mac_address",
206
d->net.subtype = VIR_NODE_DEV_CAP_NET_80203;
207
else if (get_uint64_prop(ctx, udi, "net.80211.mac_address",
209
d->net.subtype = VIR_NODE_DEV_CAP_NET_80211;
211
d->net.subtype = VIR_NODE_DEV_CAP_NET_LAST;
217
static int gather_scsi_host_cap(LibHalContext *ctx, const char *udi,
218
union _virNodeDevCapData *d)
222
(void)get_int_prop(ctx, udi, "scsi_host.host", (int *)&d->scsi_host.host);
224
retval = check_fc_host(d);
230
retval = check_vport_capable(d);
237
static int gather_scsi_cap(LibHalContext *ctx, const char *udi,
238
union _virNodeDevCapData *d)
240
(void)get_int_prop(ctx, udi, "scsi.host", (int *)&d->scsi.host);
241
(void)get_int_prop(ctx, udi, "scsi.bus", (int *)&d->scsi.bus);
242
(void)get_int_prop(ctx, udi, "scsi.target", (int *)&d->scsi.target);
243
(void)get_int_prop(ctx, udi, "scsi.lun", (int *)&d->scsi.lun);
244
(void)get_str_prop(ctx, udi, "scsi.type", &d->scsi.type);
249
static int gather_storage_cap(LibHalContext *ctx, const char *udi,
250
union _virNodeDevCapData *d)
253
(void)get_str_prop(ctx, udi, "block.device", &d->storage.block);
254
(void)get_str_prop(ctx, udi, "storage.bus", &d->storage.bus);
255
(void)get_str_prop(ctx, udi, "storage.drive_type", &d->storage.drive_type);
256
(void)get_str_prop(ctx, udi, "storage.model", &d->storage.model);
257
(void)get_str_prop(ctx, udi, "storage.vendor", &d->storage.vendor);
258
(void)get_str_prop(ctx, udi, "storage.serial", &d->storage.serial);
259
if (get_bool_prop(ctx, udi, "storage.removable", &val) == 0 && val) {
260
d->storage.flags |= VIR_NODE_DEV_CAP_STORAGE_REMOVABLE;
261
if (get_bool_prop(ctx, udi, "storage.removable.media_available",
264
VIR_NODE_DEV_CAP_STORAGE_REMOVABLE_MEDIA_AVAILABLE;
265
(void)get_uint64_prop(ctx, udi, "storage.removable.media_size",
266
&d->storage.removable_media_size);
269
(void)get_uint64_prop(ctx, udi, "storage.size", &d->storage.size);
271
if (get_bool_prop(ctx, udi, "storage.hotpluggable", &val) == 0 && val)
272
d->storage.flags |= VIR_NODE_DEV_CAP_STORAGE_HOTPLUGGABLE;
277
static int gather_system_cap(LibHalContext *ctx, const char *udi,
278
union _virNodeDevCapData *d)
282
(void)get_str_prop(ctx, udi, "system.product", &d->system.product_name);
283
(void)get_str_prop(ctx, udi, "system.hardware.vendor",
284
&d->system.hardware.vendor_name);
285
(void)get_str_prop(ctx, udi, "system.hardware.version",
286
&d->system.hardware.version);
287
(void)get_str_prop(ctx, udi, "system.hardware.serial",
288
&d->system.hardware.serial);
289
if (get_str_prop(ctx, udi, "system.hardware.uuid", &uuidstr) == 0) {
290
(void)virUUIDParse(uuidstr, d->system.hardware.uuid);
293
(void)get_str_prop(ctx, udi, "system.firmware.vendor",
294
&d->system.firmware.vendor_name);
295
(void)get_str_prop(ctx, udi, "system.firmware.version",
296
&d->system.firmware.version);
297
(void)get_str_prop(ctx, udi, "system.firmware.release_date",
298
&d->system.firmware.release_date);
303
struct _caps_tbl_entry {
304
const char *cap_name;
305
enum virNodeDevCapType type;
306
int (*gather_fn)(LibHalContext *ctx,
308
union _virNodeDevCapData *data);
311
typedef struct _caps_tbl_entry caps_tbl_entry;
313
static caps_tbl_entry caps_tbl[] = {
314
{ "system", VIR_NODE_DEV_CAP_SYSTEM, gather_system_cap },
315
{ "pci", VIR_NODE_DEV_CAP_PCI_DEV, gather_pci_cap },
316
{ "usb", VIR_NODE_DEV_CAP_USB_INTERFACE, gather_usb_cap },
317
{ "usb_device", VIR_NODE_DEV_CAP_USB_DEV, gather_usb_device_cap },
318
{ "net", VIR_NODE_DEV_CAP_NET, gather_net_cap },
319
{ "scsi_host", VIR_NODE_DEV_CAP_SCSI_HOST, gather_scsi_host_cap },
320
{ "scsi", VIR_NODE_DEV_CAP_SCSI, gather_scsi_cap },
321
{ "storage", VIR_NODE_DEV_CAP_STORAGE, gather_storage_cap },
325
/* qsort/bsearch string comparator */
326
static int cmpstringp(const void *p1, const void *p2)
328
/* from man 3 qsort */
329
return strcmp(* (char * const *) p1, * (char * const *) p2);
333
static int gather_capability(LibHalContext *ctx, const char *udi,
334
const char *cap_name,
335
virNodeDevCapsDefPtr *caps_p)
337
caps_tbl_entry *entry;
339
entry = bsearch(&cap_name, caps_tbl, ARRAY_CARDINALITY(caps_tbl),
340
sizeof(caps_tbl[0]), cmpstringp);
343
virNodeDevCapsDefPtr caps;
344
if (VIR_ALLOC(caps) < 0)
346
caps->type = entry->type;
347
if (entry->gather_fn) {
348
int rv = (*entry->gather_fn)(ctx, udi, &caps->data);
350
virNodeDevCapsDefFree(caps);
354
caps->next = *caps_p;
362
static int gather_capabilities(LibHalContext *ctx, const char *udi,
363
virNodeDevCapsDefPtr *caps_p)
365
char *bus_name = NULL;
366
virNodeDevCapsDefPtr caps = NULL;
367
char **hal_cap_names;
370
if (STREQ(udi, "/org/freedesktop/Hal/devices/computer")) {
371
rv = gather_capability(ctx, udi, "system", &caps);
376
if (get_str_prop(ctx, udi, "info.subsystem", &bus_name) == 0 ||
377
get_str_prop(ctx, udi, "linux.subsystem", &bus_name) == 0) {
378
rv = gather_capability(ctx, udi, bus_name, &caps);
383
hal_cap_names = libhal_device_get_property_strlist(ctx, udi,
387
for (i = 0; hal_cap_names[i]; i++) {
388
if (! (bus_name && STREQ(hal_cap_names[i], bus_name))) {
389
rv = gather_capability(ctx, udi, hal_cap_names[i], &caps);
394
for (i = 0; hal_cap_names[i]; i++)
395
VIR_FREE(hal_cap_names[i]);
396
VIR_FREE(hal_cap_names);
406
for (i = 0; hal_cap_names[i]; i++)
407
VIR_FREE(hal_cap_names[i]);
408
VIR_FREE(hal_cap_names);
411
virNodeDevCapsDefPtr next = caps->next;
412
virNodeDevCapsDefFree(caps);
418
static void free_udi(void *udi)
423
static void dev_create(const char *udi)
426
char *parent_key = NULL;
427
virNodeDeviceObjPtr dev = NULL;
428
virNodeDeviceDefPtr def = NULL;
429
const char *name = hal_name(udi);
431
char *privData = strdup(udi);
432
char *devicePath = NULL;
437
nodeDeviceLock(driverState);
438
ctx = DRV_STATE_HAL_CTX(driverState);
440
if (VIR_ALLOC(def) < 0)
443
if ((def->name = strdup(name)) == NULL)
446
if (get_str_prop(ctx, udi, "info.parent", &parent_key) == 0) {
447
def->parent = strdup(hal_name(parent_key));
448
VIR_FREE(parent_key);
449
if (def->parent == NULL)
453
rv = gather_capabilities(ctx, udi, &def->caps);
454
if (rv != 0) goto failure;
456
if (def->caps == NULL)
459
/* Some devices don't have a path in sysfs, so ignore failure */
460
get_str_prop(ctx, udi, "linux.sysfs_path", &devicePath);
462
dev = virNodeDeviceAssignDef(NULL,
467
VIR_FREE(devicePath);
471
dev->privateData = privData;
472
dev->privateFree = free_udi;
473
dev->devicePath = devicePath;
475
virNodeDeviceObjUnlock(dev);
477
nodeDeviceUnlock(driverState);
481
DEBUG("FAILED TO ADD dev %s", name);
485
virNodeDeviceDefFree(def);
486
nodeDeviceUnlock(driverState);
489
static void dev_refresh(const char *udi)
491
const char *name = hal_name(udi);
492
virNodeDeviceObjPtr dev;
494
nodeDeviceLock(driverState);
495
dev = virNodeDeviceFindByName(&driverState->devs, name);
497
/* Simply "rediscover" device -- incrementally handling changes
498
* to sub-capabilities (like net.80203) is nasty ... so avoid it.
500
virNodeDeviceObjRemove(&driverState->devs, dev);
502
DEBUG("no device named %s", name);
503
nodeDeviceUnlock(driverState);
510
static void device_added(LibHalContext *ctx ATTRIBUTE_UNUSED,
513
DEBUG0(hal_name(udi));
518
static void device_removed(LibHalContext *ctx ATTRIBUTE_UNUSED,
521
const char *name = hal_name(udi);
522
virNodeDeviceObjPtr dev;
524
nodeDeviceLock(driverState);
525
dev = virNodeDeviceFindByName(&driverState->devs,name);
528
virNodeDeviceObjRemove(&driverState->devs, dev);
530
DEBUG("no device named %s", name);
531
nodeDeviceUnlock(driverState);
535
static void device_cap_added(LibHalContext *ctx,
536
const char *udi, const char *cap)
538
const char *name = hal_name(udi);
539
virNodeDeviceObjPtr dev;
541
nodeDeviceLock(driverState);
542
dev = virNodeDeviceFindByName(&driverState->devs,name);
543
nodeDeviceUnlock(driverState);
544
DEBUG("%s %s", cap, name);
546
(void)gather_capability(ctx, udi, cap, &dev->def->caps);
547
virNodeDeviceObjUnlock(dev);
549
DEBUG("no device named %s", name);
554
static void device_cap_lost(LibHalContext *ctx ATTRIBUTE_UNUSED,
558
const char *name = hal_name(udi);
559
DEBUG("%s %s", cap, name);
565
static void device_prop_modified(LibHalContext *ctx ATTRIBUTE_UNUSED,
568
dbus_bool_t is_removed ATTRIBUTE_UNUSED,
569
dbus_bool_t is_added ATTRIBUTE_UNUSED)
571
const char *name = hal_name(udi);
572
DEBUG("%s %s", name, key);
578
static void dbus_watch_callback(int fdatch ATTRIBUTE_UNUSED,
579
int fd ATTRIBUTE_UNUSED,
580
int events, void *opaque)
582
DBusWatch *watch = opaque;
583
LibHalContext *hal_ctx;
584
DBusConnection *dbus_conn;
587
if (events & VIR_EVENT_HANDLE_READABLE)
588
dbus_flags |= DBUS_WATCH_READABLE;
589
if (events & VIR_EVENT_HANDLE_WRITABLE)
590
dbus_flags |= DBUS_WATCH_WRITABLE;
591
if (events & VIR_EVENT_HANDLE_ERROR)
592
dbus_flags |= DBUS_WATCH_ERROR;
593
if (events & VIR_EVENT_HANDLE_HANGUP)
594
dbus_flags |= DBUS_WATCH_HANGUP;
596
(void)dbus_watch_handle(watch, dbus_flags);
598
nodeDeviceLock(driverState);
599
hal_ctx = DRV_STATE_HAL_CTX(driverState);
600
dbus_conn = libhal_ctx_get_dbus_connection(hal_ctx);
601
nodeDeviceUnlock(driverState);
602
while (dbus_connection_dispatch(dbus_conn) == DBUS_DISPATCH_DATA_REMAINS)
603
/* keep dispatching while data remains */;
607
static int xlate_dbus_watch_flags(int dbus_flags)
609
unsigned int flags = 0;
610
if (dbus_flags & DBUS_WATCH_READABLE)
611
flags |= VIR_EVENT_HANDLE_READABLE;
612
if (dbus_flags & DBUS_WATCH_WRITABLE)
613
flags |= VIR_EVENT_HANDLE_WRITABLE;
614
if (dbus_flags & DBUS_WATCH_ERROR)
615
flags |= VIR_EVENT_HANDLE_ERROR;
616
if (dbus_flags & DBUS_WATCH_HANGUP)
617
flags |= VIR_EVENT_HANDLE_HANGUP;
622
struct nodeDeviceWatchInfo
627
static void nodeDeviceWatchFree(void *data) {
628
struct nodeDeviceWatchInfo *info = data;
632
static dbus_bool_t add_dbus_watch(DBusWatch *watch,
633
void *data ATTRIBUTE_UNUSED)
637
struct nodeDeviceWatchInfo *info;
639
if (VIR_ALLOC(info) < 0)
642
if (dbus_watch_get_enabled(watch))
643
flags = xlate_dbus_watch_flags(dbus_watch_get_flags(watch));
645
#if HAVE_DBUS_WATCH_GET_UNIX_FD
646
fd = dbus_watch_get_unix_fd(watch);
648
fd = dbus_watch_get_fd(watch);
650
info->watch = virEventAddHandle(fd, flags, dbus_watch_callback,
652
if (info->watch < 0) {
656
dbus_watch_set_data(watch, info, nodeDeviceWatchFree);
662
static void remove_dbus_watch(DBusWatch *watch,
663
void *data ATTRIBUTE_UNUSED)
665
struct nodeDeviceWatchInfo *info;
667
info = dbus_watch_get_data(watch);
669
(void)virEventRemoveHandle(info->watch);
673
static void toggle_dbus_watch(DBusWatch *watch,
674
void *data ATTRIBUTE_UNUSED)
677
struct nodeDeviceWatchInfo *info;
679
if (dbus_watch_get_enabled(watch))
680
flags = xlate_dbus_watch_flags(dbus_watch_get_flags(watch));
682
info = dbus_watch_get_data(watch);
684
(void)virEventUpdateHandle(info->watch, flags);
688
static int halDeviceMonitorStartup(int privileged ATTRIBUTE_UNUSED)
690
LibHalContext *hal_ctx = NULL;
691
DBusConnection *dbus_conn = NULL;
696
/* Ensure caps_tbl is sorted by capability name */
697
qsort(caps_tbl, ARRAY_CARDINALITY(caps_tbl), sizeof(caps_tbl[0]),
700
if (VIR_ALLOC(driverState) < 0)
703
if (virMutexInit(&driverState->lock) < 0) {
704
VIR_FREE(driverState);
707
nodeDeviceLock(driverState);
709
/* Allocate and initialize a new HAL context */
710
dbus_connection_set_change_sigpipe(FALSE);
711
dbus_threads_init_default();
713
dbus_error_init(&err);
714
hal_ctx = libhal_ctx_new();
715
if (hal_ctx == NULL) {
716
VIR_ERROR0("libhal_ctx_new returned NULL\n");
719
dbus_conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
720
if (dbus_conn == NULL) {
721
VIR_ERROR0("dbus_bus_get failed\n");
724
dbus_connection_set_exit_on_disconnect(dbus_conn, FALSE);
726
if (!libhal_ctx_set_dbus_connection(hal_ctx, dbus_conn)) {
727
VIR_ERROR0("libhal_ctx_set_dbus_connection failed\n");
730
if (!libhal_ctx_init(hal_ctx, &err)) {
731
VIR_ERROR0("libhal_ctx_init failed\n");
735
/* Register dbus watch callbacks */
736
if (!dbus_connection_set_watch_functions(dbus_conn,
741
VIR_ERROR0("dbus_connection_set_watch_functions failed\n");
745
/* Register HAL event callbacks */
746
if (!libhal_ctx_set_device_added(hal_ctx, device_added) ||
747
!libhal_ctx_set_device_removed(hal_ctx, device_removed) ||
748
!libhal_ctx_set_device_new_capability(hal_ctx, device_cap_added) ||
749
!libhal_ctx_set_device_lost_capability(hal_ctx, device_cap_lost) ||
750
!libhal_ctx_set_device_property_modified(hal_ctx, device_prop_modified) ||
751
!libhal_device_property_watch_all(hal_ctx, &err)) {
752
VIR_ERROR0("setting up HAL callbacks failed\n");
756
/* Populate with known devices */
757
driverState->privateData = hal_ctx;
759
nodeDeviceUnlock(driverState);
760
udi = libhal_get_all_devices(hal_ctx, &num_devs, &err);
762
VIR_ERROR0("libhal_get_all_devices failed\n");
765
for (i = 0; i < num_devs; i++) {
774
if (dbus_error_is_set(&err)) {
775
VIR_ERROR("%s: %s\n", err.name, err.message);
776
dbus_error_free(&err);
778
virNodeDeviceObjListFree(&driverState->devs);
780
(void)libhal_ctx_free(hal_ctx);
782
for (i = 0; i < num_devs; i++)
786
nodeDeviceUnlock(driverState);
787
VIR_FREE(driverState);
793
static int halDeviceMonitorShutdown(void)
796
nodeDeviceLock(driverState);
797
LibHalContext *hal_ctx = DRV_STATE_HAL_CTX(driverState);
798
virNodeDeviceObjListFree(&driverState->devs);
799
(void)libhal_ctx_shutdown(hal_ctx, NULL);
800
(void)libhal_ctx_free(hal_ctx);
801
nodeDeviceUnlock(driverState);
802
virMutexDestroy(&driverState->lock);
803
VIR_FREE(driverState);
810
static int halDeviceMonitorReload(void)
815
LibHalContext *hal_ctx;
817
VIR_INFO0("Reloading HAL device state");
818
nodeDeviceLock(driverState);
819
VIR_INFO0("Removing existing objects");
820
virNodeDeviceObjListFree(&driverState->devs);
821
nodeDeviceUnlock(driverState);
823
hal_ctx = DRV_STATE_HAL_CTX(driverState);
824
VIR_INFO0("Creating new objects");
825
dbus_error_init(&err);
826
udi = libhal_get_all_devices(hal_ctx, &num_devs, &err);
828
fprintf(stderr, "%s: libhal_get_all_devices failed\n", __FUNCTION__);
831
for (i = 0; i < num_devs; i++) {
836
VIR_INFO0("HAL device reload complete");
842
static int halDeviceMonitorActive(void)
844
/* Always ready to deal with a shutdown */
849
static virDrvOpenStatus halNodeDrvOpen(virConnectPtr conn,
850
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
851
int flags ATTRIBUTE_UNUSED)
853
if (driverState == NULL)
854
return VIR_DRV_OPEN_DECLINED;
856
conn->devMonPrivateData = driverState;
858
return VIR_DRV_OPEN_SUCCESS;
861
static int halNodeDrvClose(virConnectPtr conn ATTRIBUTE_UNUSED)
863
conn->devMonPrivateData = NULL;
868
static virDeviceMonitor halDeviceMonitor = {
869
.name = "halDeviceMonitor",
870
.open = halNodeDrvOpen,
871
.close = halNodeDrvClose,
875
static virStateDriver halStateDriver = {
876
.initialize = halDeviceMonitorStartup,
877
.cleanup = halDeviceMonitorShutdown,
878
.reload = halDeviceMonitorReload,
879
.active = halDeviceMonitorActive,
882
int halNodeRegister(void)
884
registerCommonNodeFuncs(&halDeviceMonitor);
885
if (virRegisterDeviceMonitor(&halDeviceMonitor) < 0)
887
return virRegisterStateDriver(&halStateDriver);
added
removed
src/node_device_hal.c
