node_device_udev.c 54.6 KB
Newer Older
1 2 3
/*
 * node_device_udev.c: node device enumeration - libudev implementation
 *
4
 * Copyright (C) 2009-2015 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16
 *
 * 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
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
19 20 21 22
 */

#include <config.h>
#include <libudev.h>
23
#include <pciaccess.h>
24 25
#include <scsi/scsi.h>

26
#include "dirname.h"
27
#include "node_device_conf.h"
28
#include "node_device_event.h"
29
#include "node_device_driver.h"
30 31
#include "node_device_udev.h"
#include "virerror.h"
32 33
#include "driver.h"
#include "datatypes.h"
34
#include "virlog.h"
35
#include "viralloc.h"
36
#include "viruuid.h"
37
#include "virbuffer.h"
38
#include "virfile.h"
39
#include "virpci.h"
40
#include "virpidfile.h"
41
#include "virstring.h"
42
#include "virnetdev.h"
43
#include "virmdev.h"
44

45 46
#include "configmake.h"

47 48
#define VIR_FROM_THIS VIR_FROM_NODEDEV

49 50
VIR_LOG_INIT("node_device.node_device_udev");

51 52 53 54
#ifndef TYPE_RAID
# define TYPE_RAID 12
#endif

55 56 57 58 59 60
typedef struct _udevEventData udevEventData;
typedef udevEventData *udevEventDataPtr;

struct _udevEventData {
    virObjectLockable parent;

61 62
    struct udev_monitor *udev_monitor;
    int watch;
63 64 65 66 67 68

    /* Thread data */
    virThread th;
    virCond threadCond;
    bool threadQuit;
    bool dataReady;
69 70
};

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
static virClassPtr udevEventDataClass;

static void
udevEventDataDispose(void *obj)
{
    struct udev *udev = NULL;
    udevEventDataPtr priv = obj;

    if (priv->watch != -1)
        virEventRemoveHandle(priv->watch);

    if (!priv->udev_monitor)
        return;

    udev = udev_monitor_get_udev(priv->udev_monitor);
    udev_monitor_unref(priv->udev_monitor);
    udev_unref(udev);
88 89

    virCondDestroy(&priv->threadCond);
90 91 92 93 94 95
}


static int
udevEventDataOnceInit(void)
{
96
    if (!VIR_CLASS_NEW(udevEventData, virClassForObjectLockable()))
97 98 99 100 101
        return -1;

    return 0;
}

102
VIR_ONCE_GLOBAL_INIT(udevEventData);
103 104 105 106 107 108 109 110 111 112 113 114

static udevEventDataPtr
udevEventDataNew(void)
{
    udevEventDataPtr ret = NULL;

    if (udevEventDataInitialize() < 0)
        return NULL;

    if (!(ret = virObjectLockableNew(udevEventDataClass)))
        return NULL;

115 116 117 118 119
    if (virCondInit(&ret->threadCond) < 0) {
        virObjectUnref(ret);
        return NULL;
    }

120 121 122 123
    ret->watch = -1;
    return ret;
}

124

J
Ján Tomko 已提交
125 126 127 128 129 130 131 132 133 134 135
static bool
udevHasDeviceProperty(struct udev_device *dev,
                      const char *key)
{
    if (udev_device_get_property_value(dev, key))
        return true;

    return false;
}


136 137 138
static const char *
udevGetDeviceProperty(struct udev_device *udev_device,
                      const char *property_key)
139
{
140
    const char *ret = NULL;
141

142
    ret = udev_device_get_property_value(udev_device, property_key);
143

144 145
    VIR_DEBUG("Found property key '%s' value '%s' for device with sysname '%s'",
              property_key, NULLSTR(ret), udev_device_get_sysname(udev_device));
146 147 148 149 150

    return ret;
}


151 152 153 154
static int
udevGetStringProperty(struct udev_device *udev_device,
                      const char *property_key,
                      char **value)
155
{
156
    *value = g_strdup(udevGetDeviceProperty(udev_device, property_key));
157

158
    return 0;
159 160 161
}


162 163 164 165 166
static int
udevGetIntProperty(struct udev_device *udev_device,
                   const char *property_key,
                   int *value,
                   int base)
167
{
168
    const char *str = NULL;
169

170
    str = udevGetDeviceProperty(udev_device, property_key);
171

172
    if (str && virStrToLong_i(str, NULL, base, value) < 0) {
173 174
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to convert '%s' to int"), str);
175
        return -1;
176
    }
177
    return 0;
178 179 180
}


181 182 183 184 185
static int
udevGetUintProperty(struct udev_device *udev_device,
                    const char *property_key,
                    unsigned int *value,
                    int base)
186
{
187
    const char *str = NULL;
188

189
    str = udevGetDeviceProperty(udev_device, property_key);
190

191
    if (str && virStrToLong_ui(str, NULL, base, value) < 0) {
192 193
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to convert '%s' to int"), str);
194
        return -1;
195
    }
196
    return 0;
197 198 199
}


200 201 202
static const char *
udevGetDeviceSysfsAttr(struct udev_device *udev_device,
                       const char *attr_name)
203
{
204
    const char *ret = NULL;
205

206
    ret = udev_device_get_sysattr_value(udev_device, attr_name);
207 208

    VIR_DEBUG("Found sysfs attribute '%s' value '%s' "
209
              "for device with sysname '%s'",
210
              attr_name, NULLSTR(ret),
211 212 213 214 215
              udev_device_get_sysname(udev_device));
    return ret;
}


216 217 218 219
static int
udevGetStringSysfsAttr(struct udev_device *udev_device,
                       const char *attr_name,
                       char **value)
220
{
221
    *value = g_strdup(udevGetDeviceSysfsAttr(udev_device, attr_name));
222

223
    virStringStripControlChars(*value);
224

225 226
    if (*value != NULL && (STREQ(*value, "")))
        VIR_FREE(*value);
227

228
    return 0;
229 230 231
}


232 233 234 235 236
static int
udevGetIntSysfsAttr(struct udev_device *udev_device,
                    const char *attr_name,
                    int *value,
                    int base)
237
{
238
    const char *str = NULL;
239

240
    str = udevGetDeviceSysfsAttr(udev_device, attr_name);
241

242
    if (str && virStrToLong_i(str, NULL, base, value) < 0) {
243 244
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to convert '%s' to int"), str);
245
        return -1;
246 247
    }

248
    return 0;
249 250 251
}


252 253 254 255 256
static int
udevGetUintSysfsAttr(struct udev_device *udev_device,
                     const char *attr_name,
                     unsigned int *value,
                     int base)
257
{
258
    const char *str = NULL;
259

260
    str = udevGetDeviceSysfsAttr(udev_device, attr_name);
261

262
    if (str && virStrToLong_ui(str, NULL, base, value) < 0) {
263 264
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to convert '%s' to unsigned int"), str);
265
        return -1;
266 267
    }

268
    return 0;
269 270 271
}


272 273 274 275
static int
udevGetUint64SysfsAttr(struct udev_device *udev_device,
                       const char *attr_name,
                       unsigned long long *value)
276
{
277
    const char *str = NULL;
278

279
    str = udevGetDeviceSysfsAttr(udev_device, attr_name);
280

281
    if (str && virStrToLong_ull(str, NULL, 0, value) < 0) {
282 283
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to convert '%s' to unsigned long long"), str);
J
Ján Tomko 已提交
284
        return -1;
285 286
    }

J
Ján Tomko 已提交
287
    return 0;
288 289 290
}


291 292 293 294
static int
udevGenerateDeviceName(struct udev_device *device,
                       virNodeDeviceDefPtr def,
                       const char *s)
295
{
296
    size_t i;
297 298
    virBuffer buf = VIR_BUFFER_INITIALIZER;

299
    virBufferAsprintf(&buf, "%s_%s",
300 301 302
                      udev_device_get_subsystem(device),
                      udev_device_get_sysname(device));

303
    if (s != NULL)
304
        virBufferAsprintf(&buf, "_%s", s);
305 306 307

    def->name = virBufferContentAndReset(&buf);

308
    for (i = 0; i < strlen(def->name); i++) {
309
        if (!(g_ascii_isalnum(*(def->name + i))))
310 311 312
            *(def->name + i) = '_';
    }

313
    return 0;
314 315
}

316 317 318 319 320 321

static int
udevTranslatePCIIds(unsigned int vendor,
                    unsigned int product,
                    char **vendor_string,
                    char **product_string)
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
{
    struct pci_id_match m;
    const char *vendor_name = NULL, *device_name = NULL;

    m.vendor_id = vendor;
    m.device_id = product;
    m.subvendor_id = PCI_MATCH_ANY;
    m.subdevice_id = PCI_MATCH_ANY;
    m.device_class = 0;
    m.device_class_mask = 0;
    m.match_data = 0;

    /* pci_get_strings returns void */
    pci_get_strings(&m,
                    &device_name,
337
                    &vendor_name,
338 339 340
                    NULL,
                    NULL);

341 342
    *vendor_string = g_strdup(vendor_name);
    *product_string = g_strdup(device_name);
343

344
    return 0;
345 346 347
}


348 349 350
static int
udevProcessPCI(struct udev_device *device,
               virNodeDeviceDefPtr def)
351
{
352
    virNodeDevCapPCIDevPtr pci_dev = &def->caps->data.pci_dev;
353 354
    virPCIEDeviceInfoPtr pci_express = NULL;
    virPCIDevicePtr pciDev = NULL;
355
    int ret = -1;
356
    char *p;
357 358 359 360 361
    bool privileged;

    nodeDeviceLock();
    privileged = driver->privileged;
    nodeDeviceUnlock();
362

363 364
    pci_dev->klass = -1;
    if (udevGetIntProperty(device, "PCI_CLASS", &pci_dev->klass, 16) < 0)
365
        goto cleanup;
366

367
    if ((p = strrchr(def->sysfs_path, '/')) == NULL ||
368 369 370 371
        virStrToLong_ui(p + 1, &p, 16, &pci_dev->domain) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 16, &pci_dev->bus) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 16, &pci_dev->slot) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 16, &pci_dev->function) < 0) {
372 373
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("failed to parse the PCI address from sysfs path: '%s'"),
374
                       def->sysfs_path);
375
        goto cleanup;
376 377
    }

378
    if (udevGetUintSysfsAttr(device, "vendor", &pci_dev->vendor, 16) < 0)
379
        goto cleanup;
380

381
    if (udevGetUintSysfsAttr(device, "device", &pci_dev->product, 16) < 0)
382
        goto cleanup;
383

384 385 386 387
    if (udevTranslatePCIIds(pci_dev->vendor,
                            pci_dev->product,
                            &pci_dev->vendor_name,
                            &pci_dev->product_name) != 0) {
388
        goto cleanup;
389
    }
390

391
    if (udevGenerateDeviceName(device, def, NULL) != 0)
392
        goto cleanup;
393

394 395
    /* The default value is -1, because it can't be 0
     * as zero is valid node number. */
396
    pci_dev->numa_node = -1;
397
    if (udevGetIntSysfsAttr(device, "numa_node",
398
                            &pci_dev->numa_node, 10) < 0)
399
        goto cleanup;
400

401
    if (virNodeDeviceGetPCIDynamicCaps(def->sysfs_path, pci_dev) < 0)
402
        goto cleanup;
403

404 405 406 407
    if (!(pciDev = virPCIDeviceNew(pci_dev->domain,
                                   pci_dev->bus,
                                   pci_dev->slot,
                                   pci_dev->function)))
408
        goto cleanup;
409

410
    /* We need to be root to read PCI device configs */
411
    if (privileged) {
412
        if (virPCIGetHeaderType(pciDev, &pci_dev->hdrType) < 0)
413
            goto cleanup;
414

415 416
        if (virPCIDeviceIsPCIExpress(pciDev) > 0) {
            if (VIR_ALLOC(pci_express) < 0)
417
                goto cleanup;
418

419 420 421
            if (virPCIDeviceHasPCIExpressLink(pciDev) > 0) {
                if (VIR_ALLOC(pci_express->link_cap) < 0 ||
                    VIR_ALLOC(pci_express->link_sta) < 0)
422
                    goto cleanup;
423 424 425 426 427 428 429

                if (virPCIDeviceGetLinkCapSta(pciDev,
                                              &pci_express->link_cap->port,
                                              &pci_express->link_cap->speed,
                                              &pci_express->link_cap->width,
                                              &pci_express->link_sta->speed,
                                              &pci_express->link_sta->width) < 0)
430
                    goto cleanup;
431 432 433

                pci_express->link_sta->port = -1; /* PCIe can't negotiate port. Yet :) */
            }
434 435
            pci_dev->flags |= VIR_NODE_DEV_CAP_FLAG_PCIE;
            pci_dev->pci_express = pci_express;
436
            pci_express = NULL;
437 438 439
        }
    }

440 441
    ret = 0;

442
 cleanup:
443
    virPCIDeviceFree(pciDev);
444
    virPCIEDeviceInfoFree(pci_express);
445 446 447
    return ret;
}

448 449 450

static int
drmGetMinorType(int minor)
M
Marc-André Lureau 已提交
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
{
    int type = minor >> 6;

    if (minor < 0)
        return -1;

    switch (type) {
    case VIR_NODE_DEV_DRM_PRIMARY:
    case VIR_NODE_DEV_DRM_CONTROL:
    case VIR_NODE_DEV_DRM_RENDER:
        return type;
    default:
        return -1;
    }
}

467 468 469 470

static int
udevProcessDRMDevice(struct udev_device *device,
                     virNodeDeviceDefPtr def)
M
Marc-André Lureau 已提交
471
{
472
    virNodeDevCapDRMPtr drm = &def->caps->data.drm;
M
Marc-André Lureau 已提交
473 474 475 476 477 478 479 480 481 482 483
    int minor;

    if (udevGenerateDeviceName(device, def, NULL) != 0)
        return -1;

    if (udevGetIntProperty(device, "MINOR", &minor, 10) < 0)
        return -1;

    if ((minor = drmGetMinorType(minor)) == -1)
        return -1;

484
    drm->type = minor;
M
Marc-André Lureau 已提交
485 486 487

    return 0;
}
488

489 490 491 492

static int
udevProcessUSBDevice(struct udev_device *device,
                     virNodeDeviceDefPtr def)
493
{
494
    virNodeDevCapUSBDevPtr usb_dev = &def->caps->data.usb_dev;
495

496
    if (udevGetUintProperty(device, "BUSNUM", &usb_dev->bus, 10) < 0)
497
        return -1;
498
    if (udevGetUintProperty(device, "DEVNUM", &usb_dev->device, 10) < 0)
499
        return -1;
500
    if (udevGetUintProperty(device, "ID_VENDOR_ID", &usb_dev->vendor, 16) < 0)
501
        return -1;
502

503 504
    if (udevGetStringProperty(device,
                              "ID_VENDOR_FROM_DATABASE",
505
                              &usb_dev->vendor_name) < 0)
506
        return -1;
507

508
    if (!usb_dev->vendor_name &&
509
        udevGetStringSysfsAttr(device, "manufacturer",
510
                               &usb_dev->vendor_name) < 0)
511
        return -1;
512

513
    if (udevGetUintProperty(device, "ID_MODEL_ID", &usb_dev->product, 16) < 0)
514
        return -1;
515

516 517
    if (udevGetStringProperty(device,
                              "ID_MODEL_FROM_DATABASE",
518
                              &usb_dev->product_name) < 0)
519
        return -1;
520

521
    if (!usb_dev->product_name &&
522
        udevGetStringSysfsAttr(device, "product",
523
                               &usb_dev->product_name) < 0)
524
        return -1;
525

526
    if (udevGenerateDeviceName(device, def, NULL) != 0)
527
        return -1;
528

529
    return 0;
530 531 532
}


533 534 535
static int
udevProcessUSBInterface(struct udev_device *device,
                        virNodeDeviceDefPtr def)
536
{
537
    virNodeDevCapUSBIfPtr usb_if = &def->caps->data.usb_if;
538

539
    if (udevGetUintSysfsAttr(device, "bInterfaceNumber",
540
                             &usb_if->number, 16) < 0)
541
        return -1;
542

543
    if (udevGetUintSysfsAttr(device, "bInterfaceClass",
544
                             &usb_if->klass, 16) < 0)
545
        return -1;
546

547
    if (udevGetUintSysfsAttr(device, "bInterfaceSubClass",
548
                             &usb_if->subclass, 16) < 0)
549
        return -1;
550

551
    if (udevGetUintSysfsAttr(device, "bInterfaceProtocol",
552
                             &usb_if->protocol, 16) < 0)
553
        return -1;
554

555
    if (udevGenerateDeviceName(device, def, NULL) != 0)
556
        return -1;
557

558
    return 0;
559 560 561
}


562 563 564
static int
udevProcessNetworkInterface(struct udev_device *device,
                            virNodeDeviceDefPtr def)
565
{
D
David Allan 已提交
566
    const char *devtype = udev_device_get_devtype(device);
567
    virNodeDevCapNetPtr net = &def->caps->data.net;
568

D
David Allan 已提交
569
    if (devtype && STREQ(devtype, "wlan")) {
570
        net->subtype = VIR_NODE_DEV_CAP_NET_80211;
D
David Allan 已提交
571
    } else {
572
        net->subtype = VIR_NODE_DEV_CAP_NET_80203;
D
David Allan 已提交
573 574
    }

575 576
    if (udevGetStringProperty(device,
                              "INTERFACE",
577
                              &net->ifname) < 0)
578
        return -1;
579

580
    if (udevGetStringSysfsAttr(device, "address",
581
                               &net->address) < 0)
582
        return -1;
583

584
    if (udevGetUintSysfsAttr(device, "addr_len", &net->address_len, 0) < 0)
585
        return -1;
586

587
    if (udevGenerateDeviceName(device, def, net->address) != 0)
588
        return -1;
589

590
    if (virNetDevGetLinkInfo(net->ifname, &net->lnk) < 0)
591
        return -1;
592

593
    if (virNetDevGetFeatures(net->ifname, &net->features) < 0)
594
        return -1;
595

596
    return 0;
597 598 599
}


600
static int
J
Ján Tomko 已提交
601
udevProcessSCSIHost(struct udev_device *device G_GNUC_UNUSED,
602
                    virNodeDeviceDefPtr def)
603
{
604
    virNodeDevCapSCSIHostPtr scsi_host = &def->caps->data.scsi_host;
605
    char *filename = NULL;
J
Ján Tomko 已提交
606
    char *str;
607

608
    filename = last_component(def->sysfs_path);
609

610
    if (!(str = STRSKIP(filename, "host")) ||
611
        virStrToLong_ui(str, NULL, 0, &scsi_host->host) < 0) {
612 613 614
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("failed to parse SCSI host '%s'"),
                       filename);
615
        return -1;
616 617
    }

618
    virNodeDeviceGetSCSIHostCaps(&def->caps->data.scsi_host);
619

620
    if (udevGenerateDeviceName(device, def, NULL) != 0)
621
        return -1;
622

623
    return 0;
624 625 626
}


627 628 629
static int
udevProcessSCSITarget(struct udev_device *device,
                      virNodeDeviceDefPtr def)
D
David Allan 已提交
630 631
{
    const char *sysname = NULL;
632
    virNodeDevCapSCSITargetPtr scsi_target = &def->caps->data.scsi_target;
D
David Allan 已提交
633 634 635

    sysname = udev_device_get_sysname(device);

636
    scsi_target->name = g_strdup(sysname);
D
David Allan 已提交
637

638
    virNodeDeviceGetSCSITargetCaps(def->sysfs_path, &def->caps->data.scsi_target);
639

640
    if (udevGenerateDeviceName(device, def, NULL) != 0)
641
        return -1;
D
David Allan 已提交
642

643
    return 0;
D
David Allan 已提交
644 645 646
}


647
static int
J
Ján Tomko 已提交
648
udevGetSCSIType(virNodeDeviceDefPtr def G_GNUC_UNUSED,
649 650
                unsigned int type,
                char **typestring)
651 652 653 654 655 656 657 658
{
    int ret = 0;
    int foundtype = 1;

    *typestring = NULL;

    switch (type) {
    case TYPE_DISK:
659
        *typestring = g_strdup("disk");
660 661
        break;
    case TYPE_TAPE:
662
        *typestring = g_strdup("tape");
663 664
        break;
    case TYPE_PROCESSOR:
665
        *typestring = g_strdup("processor");
666 667
        break;
    case TYPE_WORM:
668
        *typestring = g_strdup("worm");
669 670
        break;
    case TYPE_ROM:
671
        *typestring = g_strdup("cdrom");
672 673
        break;
    case TYPE_SCANNER:
674
        *typestring = g_strdup("scanner");
675 676
        break;
    case TYPE_MOD:
677
        *typestring = g_strdup("mod");
678 679
        break;
    case TYPE_MEDIUM_CHANGER:
680
        *typestring = g_strdup("changer");
681 682
        break;
    case TYPE_ENCLOSURE:
683
        *typestring = g_strdup("enclosure");
684
        break;
685
    case TYPE_RAID:
686
        *typestring = g_strdup("raid");
687
        break;
688 689 690 691 692 693 694 695 696 697
    case TYPE_NO_LUN:
    default:
        foundtype = 0;
        break;
    }

    if (*typestring == NULL) {
        if (foundtype == 1) {
            ret = -1;
        } else {
698 699
            VIR_DEBUG("Failed to find SCSI device type %d for %s",
                      type, def->sysfs_path);
700 701 702 703 704 705 706
        }
    }

    return ret;
}


707
static int
J
Ján Tomko 已提交
708
udevProcessSCSIDevice(struct udev_device *device G_GNUC_UNUSED,
709
                      virNodeDeviceDefPtr def)
710 711 712
{
    int ret = -1;
    unsigned int tmp = 0;
713
    virNodeDevCapSCSIPtr scsi = &def->caps->data.scsi;
714 715
    char *filename = NULL, *p = NULL;

716
    filename = last_component(def->sysfs_path);
717

718 719 720 721
    if (virStrToLong_ui(filename, &p, 10, &scsi->host) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 10, &scsi->bus) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 10, &scsi->target) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 10, &scsi->lun) < 0) {
722 723 724 725
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("failed to parse the SCSI address from filename: '%s'"),
                       filename);
        return -1;
726 727
    }

728 729
    if (udev_device_get_sysattr_value(device, "type")) {
        if (udevGetUintSysfsAttr(device, "type", &tmp, 0) < 0)
730
            goto cleanup;
731

732
        if (udevGetSCSIType(def, tmp, &scsi->type) < 0)
733
            goto cleanup;
734 735
    }

736
    if (udevGenerateDeviceName(device, def, NULL) != 0)
737
        goto cleanup;
738 739 740

    ret = 0;

741
 cleanup:
742
    if (ret != 0) {
743 744 745
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to process SCSI device with sysfs path '%s'"),
                       def->sysfs_path);
746 747 748 749 750
    }
    return ret;
}


751 752 753
static int
udevProcessDisk(struct udev_device *device,
                virNodeDeviceDefPtr def)
754
{
755
    virNodeDevCapStoragePtr storage = &def->caps->data.storage;
756

757
    if (udevGetUint64SysfsAttr(device, "size", &storage->num_blocks) < 0)
758
        return -1;
759

J
Ján Tomko 已提交
760
    if (udevGetUint64SysfsAttr(device, "queue/logical_block_size",
761
                               &storage->logical_block_size) < 0)
762
        return -1;
763

764
    storage->size = storage->num_blocks * storage->logical_block_size;
765

766
    return 0;
767 768 769
}


770 771 772 773
static int
udevProcessRemoveableMedia(struct udev_device *device,
                           virNodeDeviceDefPtr def,
                           int has_media)
774
{
775
    virNodeDevCapStoragePtr storage = &def->caps->data.storage;
J
Ján Tomko 已提交
776
    int is_removable = 0;
777

778 779 780
    if (udevGetIntSysfsAttr(device, "removable", &is_removable, 0) < 0)
        return -1;
    if (is_removable == 1)
781 782
        def->caps->data.storage.flags |= VIR_NODE_DEV_CAP_STORAGE_REMOVABLE;

J
Ján Tomko 已提交
783 784
    if (!has_media)
        return 0;
785

J
Ján Tomko 已提交
786 787
    def->caps->data.storage.flags |=
        VIR_NODE_DEV_CAP_STORAGE_REMOVABLE_MEDIA_AVAILABLE;
788

J
Ján Tomko 已提交
789
    if (udevGetStringProperty(device, "ID_FS_LABEL",
790
                              &storage->media_label) < 0)
J
Ján Tomko 已提交
791
        return -1;
792

J
Ján Tomko 已提交
793
    if (udevGetUint64SysfsAttr(device, "size",
794
                               &storage->num_blocks) < 0)
J
Ján Tomko 已提交
795
        return -1;
796

J
Ján Tomko 已提交
797
    if (udevGetUint64SysfsAttr(device, "queue/logical_block_size",
798
                               &storage->logical_block_size) < 0)
J
Ján Tomko 已提交
799
        return -1;
800

J
Ján Tomko 已提交
801 802 803 804 805 806 807
    /* XXX This calculation is wrong for the qemu virtual cdrom
     * which reports the size in 512 byte blocks, but the logical
     * block size as 2048.  I don't have a physical cdrom on a
     * devel system to see how they behave. */
    def->caps->data.storage.removable_media_size =
        def->caps->data.storage.num_blocks *
        def->caps->data.storage.logical_block_size;
808

J
Ján Tomko 已提交
809
    return 0;
810 811
}

812 813 814 815

static int
udevProcessCDROM(struct udev_device *device,
                 virNodeDeviceDefPtr def)
816 817 818 819 820 821 822 823
{
    int has_media = 0;

    /* NB: the drive_type string provided by udev is different from
     * that provided by HAL; now it's "cd" instead of "cdrom" We
     * change it to cdrom to preserve compatibility with earlier
     * versions of libvirt.  */
    VIR_FREE(def->caps->data.storage.drive_type);
824
    def->caps->data.storage.drive_type = g_strdup("cdrom");
825

826 827
    if (udevHasDeviceProperty(device, "ID_CDROM_MEDIA") &&
        udevGetIntProperty(device, "ID_CDROM_MEDIA", &has_media, 0) < 0)
828
        return -1;
829

830
    return udevProcessRemoveableMedia(device, def, has_media);
831 832
}

833 834 835 836

static int
udevProcessFloppy(struct udev_device *device,
                  virNodeDeviceDefPtr def)
837 838 839
{
    int has_media = 0;

840
    if (udevHasDeviceProperty(device, "ID_CDROM_MEDIA")) {
841
        /* USB floppy */
842 843
        if (udevGetIntProperty(device, "DKD_MEDIA_AVAILABLE", &has_media, 0) < 0)
            return -1;
844
    } else if (udevHasDeviceProperty(device, "ID_FS_LABEL")) {
845 846 847 848 849 850
        /* Legacy floppy */
        has_media = 1;
    }

    return udevProcessRemoveableMedia(device, def, has_media);
}
851

852

853 854 855
static int
udevProcessSD(struct udev_device *device,
              virNodeDeviceDefPtr def)
856
{
857
    virNodeDevCapStoragePtr storage = &def->caps->data.storage;
858

J
Ján Tomko 已提交
859
    if (udevGetUint64SysfsAttr(device, "size",
860
                               &storage->num_blocks) < 0)
861
        return -1;
862

J
Ján Tomko 已提交
863
    if (udevGetUint64SysfsAttr(device, "queue/logical_block_size",
864
                               &storage->logical_block_size) < 0)
865
        return -1;
866

867
    storage->size = storage->num_blocks * storage->logical_block_size;
868

869
    return 0;
870 871 872
}


873 874 875 876
/* This function exists to deal with the case in which a driver does
 * not provide a device type in the usual place, but udev told us it's
 * a storage device, and we can make a good guess at what kind of
 * storage device it is from other information that is provided. */
877 878
static int
udevKludgeStorageType(virNodeDeviceDefPtr def)
879
{
880 881 882
    VIR_DEBUG("Could not find definitive storage type for device "
              "with sysfs path '%s', trying to guess it",
              def->sysfs_path);
883

884
    /* virtio disk */
885 886
    if (STRPREFIX(def->caps->data.storage.block, "/dev/vd")) {
        def->caps->data.storage.drive_type = g_strdup("disk");
887
        VIR_DEBUG("Found storage type '%s' for device "
888
                  "with sysfs path '%s'",
889 890
                  def->caps->data.storage.drive_type,
                  def->sysfs_path);
891
        return 0;
892
    }
893 894 895
    VIR_DEBUG("Could not determine storage type "
              "for device with sysfs path '%s'", def->sysfs_path);
    return -1;
896 897 898
}


899 900 901
static int
udevProcessStorage(struct udev_device *device,
                   virNodeDeviceDefPtr def)
902
{
903
    virNodeDevCapStoragePtr storage = &def->caps->data.storage;
904
    int ret = -1;
905
    const char* devnode;
906

907
    devnode = udev_device_get_devnode(device);
908
    if (!devnode) {
909
        VIR_DEBUG("No devnode for '%s'", udev_device_get_devpath(device));
910
        goto cleanup;
911
    }
912

913
    storage->block = g_strdup(devnode);
914

915
    if (udevGetStringProperty(device, "ID_BUS", &storage->bus) < 0)
916
        goto cleanup;
917
    if (udevGetStringProperty(device, "ID_SERIAL", &storage->serial) < 0)
918
        goto cleanup;
919

920
    if (udevGetStringSysfsAttr(device, "device/vendor", &storage->vendor) < 0)
921
        goto cleanup;
922 923 924
    if (def->caps->data.storage.vendor)
        virTrimSpaces(def->caps->data.storage.vendor, NULL);

925
    if (udevGetStringSysfsAttr(device, "device/model", &storage->model) < 0)
926
        goto cleanup;
927 928
    if (def->caps->data.storage.model)
        virTrimSpaces(def->caps->data.storage.model, NULL);
929 930 931 932 933
    /* There is no equivalent of the hotpluggable property in libudev,
     * but storage is going toward a world in which hotpluggable is
     * expected, so I don't see a problem with not having a property
     * for it. */

934
    if (udevGetStringProperty(device, "ID_TYPE", &storage->drive_type) < 0)
935
        goto cleanup;
936

937
    if (!storage->drive_type ||
938
        STREQ(def->caps->data.storage.drive_type, "generic")) {
939 940
        int val = 0;
        const char *str = NULL;
941 942 943

        /* All floppy drives have the ID_DRIVE_FLOPPY prop. This is
         * needed since legacy floppies don't have a drive_type */
944
        if (udevGetIntProperty(device, "ID_DRIVE_FLOPPY", &val, 0) < 0)
945
            goto cleanup;
946 947
        else if (val == 1)
            str = "floppy";
948

949
        if (!str) {
950
            if (udevGetIntProperty(device, "ID_CDROM", &val, 0) < 0)
951
                goto cleanup;
952 953 954
            else if (val == 1)
                str = "cd";
        }
955

956
        if (!str) {
957
            if (udevGetIntProperty(device, "ID_DRIVE_FLASH_SD", &val, 0) < 0)
958
                goto cleanup;
959 960 961
            if (val == 1)
                str = "sd";
        }
962

963
        if (str) {
964
            storage->drive_type = g_strdup(str);
965 966
        } else {
            /* If udev doesn't have it, perhaps we can guess it. */
967
            if (udevKludgeStorageType(def) != 0)
968
                goto cleanup;
969 970 971 972 973 974 975
        }
    }

    if (STREQ(def->caps->data.storage.drive_type, "cd")) {
        ret = udevProcessCDROM(device, def);
    } else if (STREQ(def->caps->data.storage.drive_type, "disk")) {
        ret = udevProcessDisk(device, def);
976 977
    } else if (STREQ(def->caps->data.storage.drive_type, "floppy")) {
        ret = udevProcessFloppy(device, def);
978 979
    } else if (STREQ(def->caps->data.storage.drive_type, "sd")) {
        ret = udevProcessSD(device, def);
980
    } else {
981 982
        VIR_DEBUG("Unsupported storage type '%s'",
                  def->caps->data.storage.drive_type);
983
        goto cleanup;
984 985
    }

986
    if (udevGenerateDeviceName(device, def, storage->serial) != 0)
987
        goto cleanup;
988

989
 cleanup:
990
    VIR_DEBUG("Storage ret=%d", ret);
991 992 993
    return ret;
}

994

995
static int
996
udevProcessSCSIGeneric(struct udev_device *dev,
997 998
                       virNodeDeviceDefPtr def)
{
999 1000
    if (udevGetStringProperty(dev, "DEVNAME", &def->caps->data.sg.path) < 0 ||
        !def->caps->data.sg.path)
1001 1002 1003 1004 1005 1006 1007 1008
        return -1;

    if (udevGenerateDeviceName(dev, def, NULL) != 0)
        return -1;

    return 0;
}

1009

1010 1011 1012 1013 1014 1015 1016 1017
static int
udevProcessMediatedDevice(struct udev_device *dev,
                          virNodeDeviceDefPtr def)
{
    int ret = -1;
    const char *uuidstr = NULL;
    int iommugrp = -1;
    char *linkpath = NULL;
1018
    char *canonicalpath = NULL;
1019 1020
    virNodeDevCapMdevPtr data = &def->caps->data.mdev;

1021 1022 1023 1024 1025 1026
    /* Because of a kernel uevent race, we might get the 'add' event prior to
     * the sysfs tree being ready, so any attempt to access any sysfs attribute
     * would result in ENOENT and us dropping the device, so let's work around
     * it by waiting for the attributes to become available.
     */

1027
    linkpath = g_strdup_printf("%s/mdev_type", udev_device_get_syspath(dev));
1028

1029 1030 1031 1032 1033 1034 1035
    if (virFileWaitForExists(linkpath, 1, 100) < 0) {
        virReportSystemError(errno,
                             _("failed to wait for file '%s' to appear"),
                             linkpath);
        goto cleanup;
    }

1036 1037
    if (virFileResolveLink(linkpath, &canonicalpath) < 0) {
        virReportSystemError(errno, _("failed to resolve '%s'"), linkpath);
1038
        goto cleanup;
1039
    }
1040

1041
    data->type = g_strdup(last_component(canonicalpath));
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054

    uuidstr = udev_device_get_sysname(dev);
    if ((iommugrp = virMediatedDeviceGetIOMMUGroupNum(uuidstr)) < 0)
        goto cleanup;

    if (udevGenerateDeviceName(dev, def, NULL) != 0)
        goto cleanup;

    data->iommuGroupNumber = iommugrp;

    ret = 0;
 cleanup:
    VIR_FREE(linkpath);
1055
    VIR_FREE(canonicalpath);
1056 1057 1058
    return ret;
}

B
Bjoern Walk 已提交
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088

static int
udevProcessCCW(struct udev_device *device,
               virNodeDeviceDefPtr def)
{
    int online;
    char *p;
    virNodeDevCapDataPtr data = &def->caps->data;

    /* process only online devices to keep the list sane */
    if (udevGetIntSysfsAttr(device, "online", &online, 0) < 0 || online != 1)
        return -1;

    if ((p = strrchr(def->sysfs_path, '/')) == NULL ||
        virStrToLong_ui(p + 1, &p, 16, &data->ccw_dev.cssid) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 16, &data->ccw_dev.ssid) < 0 || p == NULL ||
        virStrToLong_ui(p + 1, &p, 16, &data->ccw_dev.devno) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("failed to parse the CCW address from sysfs path: '%s'"),
                       def->sysfs_path);
        return -1;
    }

    if (udevGenerateDeviceName(device, def, NULL) != 0)
        return -1;

    return 0;
}


1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
static int
udevGetDeviceNodes(struct udev_device *device,
                   virNodeDeviceDefPtr def)
{
    const char *devnode = NULL;
    struct udev_list_entry *list_entry = NULL;
    int n = 0;

    devnode = udev_device_get_devnode(device);

1099
    def->devnode = g_strdup(devnode);
1100 1101 1102 1103 1104 1105 1106 1107 1108

    udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device))
        n++;

    if (VIR_ALLOC_N(def->devlinks, n + 1) < 0)
        return -1;

    n = 0;
    udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device)) {
1109
        def->devlinks[n++] = g_strdup(udev_list_entry_get_name(list_entry));
1110 1111 1112 1113 1114
    }

    return 0;
}

1115

1116 1117
static int
udevGetDeviceType(struct udev_device *device,
1118
                  virNodeDevCapType *type)
1119 1120
{
    const char *devtype = NULL;
1121
    char *subsystem = NULL;
1122
    int ret = -1;
D
David Allan 已提交
1123

1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
    devtype = udev_device_get_devtype(device);
    *type = 0;

    if (devtype) {
        if (STREQ(devtype, "usb_device"))
            *type = VIR_NODE_DEV_CAP_USB_DEV;
        else if (STREQ(devtype, "usb_interface"))
            *type = VIR_NODE_DEV_CAP_USB_INTERFACE;
        else if (STREQ(devtype, "scsi_host"))
            *type = VIR_NODE_DEV_CAP_SCSI_HOST;
        else if (STREQ(devtype, "scsi_target"))
            *type = VIR_NODE_DEV_CAP_SCSI_TARGET;
        else if (STREQ(devtype, "scsi_device"))
            *type = VIR_NODE_DEV_CAP_SCSI;
        else if (STREQ(devtype, "disk"))
            *type = VIR_NODE_DEV_CAP_STORAGE;
        else if (STREQ(devtype, "wlan"))
            *type = VIR_NODE_DEV_CAP_NET;
M
Marc-André Lureau 已提交
1142 1143
        else if (STREQ(devtype, "drm_minor"))
            *type = VIR_NODE_DEV_CAP_DRM;
1144 1145
    } else {
        /* PCI devices don't set the DEVTYPE property. */
1146
        if (udevHasDeviceProperty(device, "PCI_CLASS"))
1147
            *type = VIR_NODE_DEV_CAP_PCI_DEV;
1148

1149 1150 1151 1152
        /* Wired network interfaces don't set the DEVTYPE property,
         * USB devices also have an INTERFACE property, but they do
         * set DEVTYPE, so if devtype is NULL and the INTERFACE
         * property exists, we have a network device. */
1153
        if (udevHasDeviceProperty(device, "INTERFACE"))
1154
            *type = VIR_NODE_DEV_CAP_NET;
1155

B
Bjoern Walk 已提交
1156 1157
        /* The following devices do not set the DEVTYPE property, therefore
         * we need to rely on the SUBSYSTEM property */
1158 1159 1160 1161
        if (udevGetStringProperty(device, "SUBSYSTEM", &subsystem) < 0)
            return -1;

        if (STREQ_NULLABLE(subsystem, "scsi_generic"))
1162
            *type = VIR_NODE_DEV_CAP_SCSI_GENERIC;
1163 1164
        else if (STREQ_NULLABLE(subsystem, "mdev"))
            *type = VIR_NODE_DEV_CAP_MDEV;
B
Bjoern Walk 已提交
1165 1166
        else if (STREQ_NULLABLE(subsystem, "ccw"))
            *type = VIR_NODE_DEV_CAP_CCW_DEV;
1167

1168
        VIR_FREE(subsystem);
1169 1170
    }

1171 1172 1173 1174 1175 1176
    if (!*type)
        VIR_DEBUG("Could not determine device type for device "
                  "with sysfs name '%s'",
                  udev_device_get_sysname(device));
    else
        ret = 0;
1177 1178 1179 1180 1181

    return ret;
}


1182 1183 1184
static int
udevGetDeviceDetails(struct udev_device *device,
                     virNodeDeviceDefPtr def)
1185
{
1186
    switch (def->caps->data.type) {
1187
    case VIR_NODE_DEV_CAP_PCI_DEV:
1188
        return udevProcessPCI(device, def);
1189
    case VIR_NODE_DEV_CAP_USB_DEV:
1190
        return udevProcessUSBDevice(device, def);
1191
    case VIR_NODE_DEV_CAP_USB_INTERFACE:
1192
        return udevProcessUSBInterface(device, def);
1193
    case VIR_NODE_DEV_CAP_NET:
1194
        return udevProcessNetworkInterface(device, def);
1195
    case VIR_NODE_DEV_CAP_SCSI_HOST:
1196
        return udevProcessSCSIHost(device, def);
D
David Allan 已提交
1197
    case VIR_NODE_DEV_CAP_SCSI_TARGET:
1198
        return udevProcessSCSITarget(device, def);
1199
    case VIR_NODE_DEV_CAP_SCSI:
1200
        return udevProcessSCSIDevice(device, def);
1201
    case VIR_NODE_DEV_CAP_STORAGE:
1202
        return udevProcessStorage(device, def);
1203
    case VIR_NODE_DEV_CAP_SCSI_GENERIC:
1204
        return udevProcessSCSIGeneric(device, def);
M
Marc-André Lureau 已提交
1205
    case VIR_NODE_DEV_CAP_DRM:
1206
        return udevProcessDRMDevice(device, def);
1207
    case VIR_NODE_DEV_CAP_MDEV:
1208
        return udevProcessMediatedDevice(device, def);
B
Bjoern Walk 已提交
1209 1210
    case VIR_NODE_DEV_CAP_CCW_DEV:
        return udevProcessCCW(device, def);
1211
    case VIR_NODE_DEV_CAP_MDEV_TYPES:
1212 1213 1214 1215
    case VIR_NODE_DEV_CAP_SYSTEM:
    case VIR_NODE_DEV_CAP_FC_HOST:
    case VIR_NODE_DEV_CAP_VPORTS:
    case VIR_NODE_DEV_CAP_LAST:
1216 1217 1218
        break;
    }

1219
    return 0;
1220 1221 1222
}


1223 1224
static int
udevRemoveOneDevice(struct udev_device *device)
1225
{
1226
    virNodeDeviceObjPtr obj = NULL;
1227
    virNodeDeviceDefPtr def;
1228
    virObjectEventPtr event = NULL;
1229 1230 1231
    const char *name = NULL;

    name = udev_device_get_syspath(device);
1232
    if (!(obj = virNodeDeviceObjListFindBySysfsPath(driver->devs, name))) {
1233 1234
        VIR_DEBUG("Failed to find device to remove that has udev name '%s'",
                  name);
1235
        return -1;
1236
    }
1237
    def = virNodeDeviceObjGetDef(obj);
1238

1239
    event = virNodeDeviceEventLifecycleNew(def->name,
1240 1241 1242 1243
                                           VIR_NODE_DEVICE_EVENT_DELETED,
                                           0);

    VIR_DEBUG("Removing device '%s' with sysfs path '%s'",
1244
              def->name, name);
1245
    virNodeDeviceObjListRemove(driver->devs, obj);
1246
    virObjectUnref(obj);
1247

1248
    virObjectEventStateQueue(driver->nodeDeviceEventState, event);
1249
    return 0;
1250 1251 1252
}


1253 1254 1255
static int
udevSetParent(struct udev_device *device,
              virNodeDeviceDefPtr def)
1256 1257 1258
{
    struct udev_device *parent_device = NULL;
    const char *parent_sysfs_path = NULL;
1259
    virNodeDeviceObjPtr obj = NULL;
1260
    virNodeDeviceDefPtr objdef;
1261

1262 1263
    parent_device = device;
    do {
1264

1265
        parent_device = udev_device_get_parent(parent_device);
1266
        if (parent_device == NULL)
1267
            break;
1268

1269 1270
        parent_sysfs_path = udev_device_get_syspath(parent_device);
        if (parent_sysfs_path == NULL) {
1271 1272 1273
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Could not get syspath for parent of '%s'"),
                           udev_device_get_syspath(parent_device));
1274
            return -1;
1275 1276
        }

1277 1278
        if ((obj = virNodeDeviceObjListFindBySysfsPath(driver->devs,
                                                       parent_sysfs_path))) {
1279
            objdef = virNodeDeviceObjGetDef(obj);
1280
            def->parent = g_strdup(objdef->name);
1281
            virNodeDeviceObjEndAPI(&obj);
1282

1283
            def->parent_sysfs_path = g_strdup(parent_sysfs_path);
1284 1285 1286 1287
        }

    } while (def->parent == NULL && parent_device != NULL);

1288 1289
    if (!def->parent)
        def->parent = g_strdup("computer");
1290

1291
    return 0;
1292 1293 1294
}


1295 1296
static int
udevAddOneDevice(struct udev_device *device)
1297 1298
{
    virNodeDeviceDefPtr def = NULL;
1299
    virNodeDeviceObjPtr obj = NULL;
1300
    virNodeDeviceDefPtr objdef;
1301 1302
    virObjectEventPtr event = NULL;
    bool new_device = true;
1303 1304
    int ret = -1;

1305
    if (VIR_ALLOC(def) != 0)
1306
        goto cleanup;
1307

1308
    def->sysfs_path = g_strdup(udev_device_get_syspath(device));
1309

1310
    if (udevGetStringProperty(device, "DRIVER", &def->driver) < 0)
1311
        goto cleanup;
1312

1313
    if (VIR_ALLOC(def->caps) != 0)
1314
        goto cleanup;
1315

1316
    if (udevGetDeviceType(device, &def->caps->data.type) != 0)
1317
        goto cleanup;
1318

1319 1320 1321
    if (udevGetDeviceNodes(device, def) != 0)
        goto cleanup;

1322
    if (udevGetDeviceDetails(device, def) != 0)
1323
        goto cleanup;
1324

1325
    if (udevSetParent(device, def) != 0)
1326
        goto cleanup;
1327

1328
    if ((obj = virNodeDeviceObjListFindByName(driver->devs, def->name))) {
1329
        virNodeDeviceObjEndAPI(&obj);
1330 1331 1332
        new_device = false;
    }

1333 1334
    /* If this is a device change, the old definition will be freed
     * and the current definition will take its place. */
1335
    if (!(obj = virNodeDeviceObjListAssignDef(driver->devs, def)))
1336
        goto cleanup;
1337
    objdef = virNodeDeviceObjGetDef(obj);
1338

1339
    if (new_device)
1340
        event = virNodeDeviceEventLifecycleNew(objdef->name,
1341 1342
                                               VIR_NODE_DEVICE_EVENT_CREATED,
                                               0);
1343
    else
1344
        event = virNodeDeviceEventUpdateNew(objdef->name);
1345

1346
    virNodeDeviceObjEndAPI(&obj);
1347 1348 1349

    ret = 0;

1350
 cleanup:
1351
    virObjectEventStateQueue(driver->nodeDeviceEventState, event);
1352

1353
    if (ret != 0) {
1354
        VIR_DEBUG("Discarding device %d %p %s", ret, def,
1355
                  def ? NULLSTR(def->sysfs_path) : "");
1356 1357 1358
        virNodeDeviceDefFree(def);
    }

1359 1360 1361 1362
    return ret;
}


1363 1364 1365
static int
udevProcessDeviceListEntry(struct udev *udev,
                           struct udev_list_entry *list_entry)
1366 1367 1368 1369 1370 1371 1372 1373
{
    struct udev_device *device;
    const char *name = NULL;
    int ret = -1;

    name = udev_list_entry_get_name(list_entry);

    device = udev_device_new_from_syspath(udev, name);
1374

1375 1376
    if (device != NULL) {
        if (udevAddOneDevice(device) != 0) {
1377 1378
            VIR_DEBUG("Failed to create node device for udev device '%s'",
                      name);
1379 1380 1381 1382
        }
        ret = 0;
    }

1383 1384
    udev_device_unref(device);

1385 1386 1387 1388
    return ret;
}


1389 1390 1391 1392 1393 1394 1395 1396
/* We do not care about every device (see udevGetDeviceType).
 * Do not bother enumerating over subsystems that do not
 * contain interesting devices.
 */
const char *subsystem_blacklist[] = {
    "acpi", "tty", "vc", "i2c",
};

1397 1398
static int
udevEnumerateAddMatches(struct udev_enumerate *udev_enumerate)
1399 1400 1401
{
    size_t i;

1402
    for (i = 0; i < G_N_ELEMENTS(subsystem_blacklist); i++) {
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
        const char *s = subsystem_blacklist[i];
        if (udev_enumerate_add_nomatch_subsystem(udev_enumerate, s) < 0) {
            virReportSystemError(errno, "%s", _("failed to add susbsystem filter"));
            return -1;
        }
    }
    return 0;
}


1413 1414
static int
udevEnumerateDevices(struct udev *udev)
1415 1416 1417
{
    struct udev_enumerate *udev_enumerate = NULL;
    struct udev_list_entry *list_entry = NULL;
1418
    int ret = -1;
1419 1420

    udev_enumerate = udev_enumerate_new(udev);
1421 1422
    if (udevEnumerateAddMatches(udev_enumerate) < 0)
        goto cleanup;
1423

1424 1425
    if (udev_enumerate_scan_devices(udev_enumerate) < 0)
        VIR_WARN("udev scan devices failed");
1426 1427 1428 1429 1430 1431 1432

    udev_list_entry_foreach(list_entry,
                            udev_enumerate_get_list_entry(udev_enumerate)) {

        udevProcessDeviceListEntry(udev, list_entry);
    }

1433
    ret = 0;
1434
 cleanup:
1435 1436 1437 1438 1439
    udev_enumerate_unref(udev_enumerate);
    return ret;
}


1440 1441
static void
udevPCITranslateDeinit(void)
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
{
#if defined __s390__ || defined __s390x_
    /* Nothing was initialized, nothing needs to be cleaned up */
#else
    /* pci_system_cleanup returns void */
    pci_system_cleanup();
#endif
    return;
}


1453 1454
static int
nodeStateCleanup(void)
1455
{
1456 1457
    udevEventDataPtr priv = NULL;

J
Ján Tomko 已提交
1458 1459
    if (!driver)
        return -1;
1460

1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
    priv = driver->privateData;
    if (priv) {
        virObjectLock(priv);
        priv->threadQuit = true;
        virCondSignal(&priv->threadCond);
        virObjectUnlock(priv);
        virThreadJoin(&priv->th);
    }

    virObjectUnref(priv);
1471
    virObjectUnref(driver->nodeDeviceEventState);
1472

1473
    virNodeDeviceObjListFree(driver->devs);
1474 1475 1476 1477 1478

    if (driver->lockFD != -1)
        virPidFileRelease(driver->stateDir, "driver", driver->lockFD);

    VIR_FREE(driver->stateDir);
J
Ján Tomko 已提交
1479 1480
    virMutexDestroy(&driver->lock);
    VIR_FREE(driver);
1481

J
Ján Tomko 已提交
1482 1483
    udevPCITranslateDeinit();
    return 0;
1484 1485 1486
}


1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
static int
udevHandleOneDevice(struct udev_device *device)
{
    const char *action = udev_device_get_action(device);

    VIR_DEBUG("udev action: '%s'", action);

    if (STREQ(action, "add") || STREQ(action, "change"))
        return udevAddOneDevice(device);

    if (STREQ(action, "remove"))
        return udevRemoveOneDevice(device);

    return 0;
}


1504 1505 1506
/* the caller must be holding the udevEventData object lock prior to calling
 * this function
 */
1507
static bool
1508
udevEventMonitorSanityCheck(udevEventDataPtr priv,
1509
                            int fd)
1510
{
1511
    int rc = -1;
1512

1513
    rc = udev_monitor_get_fd(priv->udev_monitor);
1514
    if (fd != rc) {
1515 1516 1517
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("File descriptor returned by udev %d does not "
                         "match node device file descriptor %d"),
1518
                       fd, rc);
1519 1520 1521 1522 1523 1524 1525 1526

        /* this is a non-recoverable error, let's remove the handle, so that we
         * don't get in here again because of some spurious behaviour and report
         * the same error multiple times
         */
        virEventRemoveHandle(priv->watch);
        priv->watch = -1;

1527
        return false;
1528 1529
    }

1530 1531 1532 1533
    return true;
}


1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
/**
 * udevEventHandleThread
 * @opaque: unused
 *
 * Thread to handle the udevEventHandleCallback processing when udev
 * tells us there's a device change for us (add, modify, delete, etc).
 *
 * Once notified there is data to be processed, the actual @device
 * data retrieval by libudev may be delayed due to how threads are
 * scheduled. In fact, the event loop could be scheduled earlier than
 * the handler thread, thus potentially emitting the very same event
 * the handler thread is currently trying to process, simply because
 * the data hadn't been retrieved from the socket.
 *
 * NB: Some older distros, such as CentOS 6, libudev opens sockets
 * without the NONBLOCK flag which might cause issues with event
 * based algorithm. Although the issue can be mitigated by resetting
 * priv->dataReady for each event found; however, the scheduler issues
 * would still come into play.
 */
1554
static void
J
Ján Tomko 已提交
1555
udevEventHandleThread(void *opaque G_GNUC_UNUSED)
1556
{
1557
    udevEventDataPtr priv = driver->privateData;
1558 1559
    struct udev_device *device = NULL;

1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
    /* continue rather than break from the loop on non-fatal errors */
    while (1) {
        virObjectLock(priv);
        while (!priv->dataReady && !priv->threadQuit) {
            if (virCondWait(&priv->threadCond, &priv->parent.lock)) {
                virReportSystemError(errno, "%s",
                                     _("handler failed to wait on condition"));
                virObjectUnlock(priv);
                return;
            }
        }

        if (priv->threadQuit) {
            virObjectUnlock(priv);
            return;
        }
1576

1577 1578
        errno = 0;
        device = udev_monitor_receive_device(priv->udev_monitor);
1579 1580
        virObjectUnlock(priv);

1581 1582 1583 1584 1585 1586
        if (!device) {
            if (errno == 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("failed to receive device from udev monitor"));
                return;
            }
1587

1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
            /* POSIX allows both EAGAIN and EWOULDBLOCK to be used
             * interchangeably when the read would block or timeout was fired
             */
            VIR_WARNINGS_NO_WLOGICALOP_EQUAL_EXPR
            if (errno != EAGAIN && errno != EWOULDBLOCK) {
            VIR_WARNINGS_RESET
                virReportSystemError(errno, "%s",
                                     _("failed to receive device from udev "
                                       "monitor"));
                return;
            }
1599

1600 1601 1602
            /* Trying to move the reset of the @priv->dataReady flag to
             * after the udev_monitor_receive_device wouldn't help much
             * due to event mgmt and scheduler timing. */
1603 1604 1605 1606 1607 1608 1609 1610 1611
            virObjectLock(priv);
            priv->dataReady = false;
            virObjectUnlock(priv);

            continue;
        }

        udevHandleOneDevice(device);
        udev_device_unref(device);
1612 1613 1614 1615 1616

        /* Instead of waiting for the next event after processing @device
         * data, let's keep reading from the udev monitor and only wait
         * for the next event once either a EAGAIN or a EWOULDBLOCK error
         * is encountered. */
1617
    }
1618 1619 1620
}


1621
static void
J
Ján Tomko 已提交
1622
udevEventHandleCallback(int watch G_GNUC_UNUSED,
1623
                        int fd,
J
Ján Tomko 已提交
1624 1625
                        int events G_GNUC_UNUSED,
                        void *data G_GNUC_UNUSED)
1626 1627 1628 1629 1630
{
    udevEventDataPtr priv = driver->privateData;

    virObjectLock(priv);

1631 1632 1633 1634 1635 1636 1637
    if (!udevEventMonitorSanityCheck(priv, fd))
        priv->threadQuit = true;
    else
        priv->dataReady = true;

    virCondSignal(&priv->threadCond);
    virObjectUnlock(priv);
1638 1639 1640
}


1641 1642
/* DMI is intel-compatible specific */
#if defined(__x86_64__) || defined(__i386__) || defined(__amd64__)
1643
static void
1644
udevGetDMIData(virNodeDevCapSystemPtr syscap)
1645
{
1646
    udevEventDataPtr priv = driver->privateData;
1647 1648
    struct udev *udev = NULL;
    struct udev_device *device = NULL;
1649 1650
    virNodeDevCapSystemHardwarePtr hardware = &syscap->hardware;
    virNodeDevCapSystemFirmwarePtr firmware = &syscap->firmware;
1651

1652
    virObjectLock(priv);
1653
    udev = udev_monitor_get_udev(priv->udev_monitor);
1654

1655 1656
    device = udev_device_new_from_syspath(udev, DMI_DEVPATH);
    if (device == NULL) {
1657 1658
        device = udev_device_new_from_syspath(udev, DMI_DEVPATH_FALLBACK);
        if (device == NULL) {
1659 1660 1661
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Failed to get udev device for syspath '%s' or '%s'"),
                           DMI_DEVPATH, DMI_DEVPATH_FALLBACK);
1662
            virObjectUnlock(priv);
1663
            return;
1664
        }
1665
    }
1666
    virObjectUnlock(priv);
1667

1668
    if (udevGetStringSysfsAttr(device, "product_name",
1669
                               &syscap->product_name) < 0)
1670
        goto cleanup;
1671
    if (udevGetStringSysfsAttr(device, "sys_vendor",
1672
                               &hardware->vendor_name) < 0)
1673
        goto cleanup;
1674
    if (udevGetStringSysfsAttr(device, "product_version",
1675
                               &hardware->version) < 0)
1676
        goto cleanup;
1677
    if (udevGetStringSysfsAttr(device, "product_serial",
1678
                               &hardware->serial) < 0)
1679
        goto cleanup;
1680

1681
    if (virGetHostUUID(hardware->uuid))
1682
        goto cleanup;
1683

1684
    if (udevGetStringSysfsAttr(device, "bios_vendor",
1685
                               &firmware->vendor_name) < 0)
1686
        goto cleanup;
1687
    if (udevGetStringSysfsAttr(device, "bios_version",
1688
                               &firmware->version) < 0)
1689
        goto cleanup;
1690
    if (udevGetStringSysfsAttr(device, "bios_date",
1691
                               &firmware->release_date) < 0)
1692
        goto cleanup;
1693

1694
 cleanup:
1695
    if (device != NULL)
1696 1697 1698
        udev_device_unref(device);
    return;
}
1699
#endif
1700 1701


1702 1703
static int
udevSetupSystemDev(void)
1704 1705
{
    virNodeDeviceDefPtr def = NULL;
1706
    virNodeDeviceObjPtr obj = NULL;
1707 1708
    int ret = -1;

1709 1710
    if (VIR_ALLOC(def) < 0)
        return -1;
1711

1712
    def->name = g_strdup("computer");
1713

1714
    if (VIR_ALLOC(def->caps) != 0)
1715
        goto cleanup;
1716

1717
#if defined(__x86_64__) || defined(__i386__) || defined(__amd64__)
1718
    udevGetDMIData(&def->caps->data.system);
1719
#endif
1720

1721
    if (!(obj = virNodeDeviceObjListAssignDef(driver->devs, def)))
1722
        goto cleanup;
1723

1724
    virNodeDeviceObjEndAPI(&obj);
1725 1726 1727

    ret = 0;

1728
 cleanup:
1729
    if (ret == -1)
1730 1731
        virNodeDeviceDefFree(def);

1732 1733 1734
    return ret;
}

1735

1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
static void
nodeStateInitializeEnumerate(void *opaque)
{
    struct udev *udev = opaque;
    udevEventDataPtr priv = driver->privateData;

    /* Populate with known devices */
    if (udevEnumerateDevices(udev) != 0)
        goto error;

    return;

 error:
    virObjectLock(priv);
1750 1751
    ignore_value(virEventRemoveHandle(priv->watch));
    priv->watch = -1;
1752
    priv->threadQuit = true;
1753
    virCondSignal(&priv->threadCond);
1754 1755 1756 1757
    virObjectUnlock(priv);
}


1758
static int
J
Ján Tomko 已提交
1759
udevPCITranslateInit(bool privileged G_GNUC_UNUSED)
1760
{
1761 1762 1763 1764
#if defined __s390__ || defined __s390x_
    /* On s390(x) system there is no PCI bus.
     * Therefore there is nothing to initialize here. */
#else
1765
    int rc;
1766

1767
    if ((rc = pci_system_init()) != 0) {
1768 1769 1770
        /* Ignore failure as non-root; udev is not as helpful in that
         * situation, but a non-privileged user won't benefit much
         * from udev in the first place.  */
1771
        if (errno != ENOENT && (privileged  || errno != EACCES)) {
1772 1773
            virReportSystemError(rc, "%s",
                                 _("Failed to initialize libpciaccess"));
1774
            return -1;
1775
        }
1776
    }
1777
#endif
1778 1779 1780
    return 0;
}

1781 1782 1783

static int
nodeStateInitialize(bool privileged,
J
Ján Tomko 已提交
1784 1785
                    virStateInhibitCallback callback G_GNUC_UNUSED,
                    void *opaque G_GNUC_UNUSED)
1786
{
1787
    udevEventDataPtr priv = NULL;
1788
    struct udev *udev = NULL;
1789
    virThread enumThread;
1790

1791
    if (VIR_ALLOC(driver) < 0)
1792
        return VIR_DRV_STATE_INIT_ERROR;
1793

1794
    driver->lockFD = -1;
1795
    if (virMutexInit(&driver->lock) < 0) {
1796 1797
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Unable to initialize mutex"));
1798
        VIR_FREE(driver);
1799
        return VIR_DRV_STATE_INIT_ERROR;
1800 1801
    }

1802 1803
    driver->privileged = privileged;

1804
    if (privileged) {
1805
        driver->stateDir = g_strdup_printf("%s/libvirt/nodedev", RUNSTATEDIR);
1806
    } else {
1807
        g_autofree char *rundir = NULL;
1808 1809 1810

        if (!(rundir = virGetUserRuntimeDirectory()))
            goto cleanup;
1811
        driver->stateDir = g_strdup_printf("%s/nodedev/run", rundir);
1812 1813 1814 1815 1816 1817 1818 1819 1820
    }

    if (virFileMakePathWithMode(driver->stateDir, S_IRWXU) < 0) {
        virReportSystemError(errno, _("cannot create state directory '%s'"),
                             driver->stateDir);
        goto cleanup;
    }

    if ((driver->lockFD =
1821
         virPidFileAcquire(driver->stateDir, "driver", false, getpid())) < 0)
1822 1823
        goto cleanup;

1824 1825
    if (!(driver->devs = virNodeDeviceObjListNew()) ||
        !(priv = udevEventDataNew()))
1826
        goto cleanup;
1827

1828
    driver->privateData = priv;
1829
    driver->nodeDeviceEventState = virObjectEventStateNew();
1830

1831
    if (udevPCITranslateInit(privileged) < 0)
1832
        goto cleanup;
1833

1834
    udev = udev_new();
1835 1836 1837
    if (!udev) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to create udev context"));
1838
        goto cleanup;
1839
    }
1840

1841 1842
    virObjectLock(priv);

1843
    priv->udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
1844
    if (!priv->udev_monitor) {
1845 1846
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("udev_monitor_new_from_netlink returned NULL"));
1847
        goto unlock;
1848 1849
    }

1850
    udev_monitor_enable_receiving(priv->udev_monitor);
1851

1852 1853 1854 1855 1856 1857 1858
    /* mimic udevd's behaviour and override the systems rmem_max limit in case
     * there's a significant number of device 'add' events
     */
    if (geteuid() == 0)
        udev_monitor_set_receive_buffer_size(priv->udev_monitor,
                                             128 * 1024 * 1024);

1859 1860 1861 1862 1863 1864
    if (virThreadCreate(&priv->th, true, udevEventHandleThread, NULL) < 0) {
        virReportSystemError(errno, "%s",
                             _("failed to create udev handler thread"));
        goto unlock;
    }

1865 1866 1867 1868 1869 1870 1871 1872
    /* We register the monitor with the event callback so we are
     * notified by udev of device changes before we enumerate existing
     * devices because libvirt will simply recreate the device if we
     * try to register it twice, i.e., if the device appears between
     * the time we register the callback and the time we begin
     * enumeration.  The alternative is to register the callback after
     * we enumerate, in which case we will fail to create any devices
     * that appear while the enumeration is taking place.  */
1873 1874 1875
    priv->watch = virEventAddHandle(udev_monitor_get_fd(priv->udev_monitor),
                                    VIR_EVENT_HANDLE_READABLE,
                                    udevEventHandleCallback, NULL, NULL);
1876
    if (priv->watch == -1)
1877
        goto unlock;
1878

1879 1880
    virObjectUnlock(priv);

1881
    /* Create a fictional 'computer' device to root the device tree. */
1882
    if (udevSetupSystemDev() != 0)
1883
        goto cleanup;
1884

1885 1886 1887 1888
    if (virThreadCreate(&enumThread, false, nodeStateInitializeEnumerate,
                        udev) < 0) {
        virReportSystemError(errno, "%s",
                             _("failed to create udev enumerate thread"));
1889
        goto cleanup;
1890
    }
1891

1892
    return VIR_DRV_STATE_INIT_COMPLETE;
1893

1894
 cleanup:
1895
    nodeStateCleanup();
1896
    return VIR_DRV_STATE_INIT_ERROR;
1897 1898

 unlock:
1899
    virObjectUnlock(priv);
1900
    goto cleanup;
1901 1902 1903
}


1904 1905
static int
nodeStateReload(void)
1906 1907 1908 1909 1910
{
    return 0;
}


1911
static virNodeDeviceDriver udevNodeDeviceDriver = {
1912
    .name = "udev",
1913 1914
    .nodeNumOfDevices = nodeNumOfDevices, /* 0.7.3 */
    .nodeListDevices = nodeListDevices, /* 0.7.3 */
1915
    .connectListAllNodeDevices = nodeConnectListAllNodeDevices, /* 0.10.2 */
1916 1917
    .connectNodeDeviceEventRegisterAny = nodeConnectNodeDeviceEventRegisterAny, /* 2.2.0 */
    .connectNodeDeviceEventDeregisterAny = nodeConnectNodeDeviceEventDeregisterAny, /* 2.2.0 */
1918 1919 1920 1921 1922 1923 1924 1925
    .nodeDeviceLookupByName = nodeDeviceLookupByName, /* 0.7.3 */
    .nodeDeviceLookupSCSIHostByWWN = nodeDeviceLookupSCSIHostByWWN, /* 1.0.2 */
    .nodeDeviceGetXMLDesc = nodeDeviceGetXMLDesc, /* 0.7.3 */
    .nodeDeviceGetParent = nodeDeviceGetParent, /* 0.7.3 */
    .nodeDeviceNumOfCaps = nodeDeviceNumOfCaps, /* 0.7.3 */
    .nodeDeviceListCaps = nodeDeviceListCaps, /* 0.7.3 */
    .nodeDeviceCreateXML = nodeDeviceCreateXML, /* 0.7.3 */
    .nodeDeviceDestroy = nodeDeviceDestroy, /* 0.7.3 */
1926 1927
};

1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939

static virHypervisorDriver udevHypervisorDriver = {
    .name = "nodedev",
    .connectOpen = nodeConnectOpen, /* 4.1.0 */
    .connectClose = nodeConnectClose, /* 4.1.0 */
    .connectIsEncrypted = nodeConnectIsEncrypted, /* 4.1.0 */
    .connectIsSecure = nodeConnectIsSecure, /* 4.1.0 */
    .connectIsAlive = nodeConnectIsAlive, /* 4.1.0 */
};


static virConnectDriver udevConnectDriver = {
1940
    .localOnly = true,
1941
    .uriSchemes = (const char *[]){ "nodedev", NULL },
1942 1943 1944 1945 1946
    .hypervisorDriver = &udevHypervisorDriver,
    .nodeDeviceDriver = &udevNodeDeviceDriver,
};


1947
static virStateDriver udevStateDriver = {
M
Matthias Bolte 已提交
1948
    .name = "udev",
1949 1950 1951
    .stateInitialize = nodeStateInitialize, /* 0.7.3 */
    .stateCleanup = nodeStateCleanup, /* 0.7.3 */
    .stateReload = nodeStateReload, /* 0.7.3 */
1952 1953
};

1954 1955 1956

int
udevNodeRegister(void)
1957
{
1958
    VIR_DEBUG("Registering udev node device backend");
1959

1960 1961
    if (virRegisterConnectDriver(&udevConnectDriver, false) < 0)
        return -1;
1962
    if (virSetSharedNodeDeviceDriver(&udevNodeDeviceDriver) < 0)
1963 1964 1965 1966
        return -1;

    return virRegisterStateDriver(&udevStateDriver);
}