X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fudev%2Fudev-builtin-net_id.c;h=4f2b2c1f73b35ee1c8603f16627cf65ee876c263;hb=d6f116a7b18f8bd3c6507c803217991235c7f1bb;hp=d8d45081776a9b0770d659fd1c3fe44c4a3f7fd7;hpb=decd634e801bee2c554edb35383cc9d43417a850;p=elogind.git

diff --git a/src/udev/udev-builtin-net_id.c b/src/udev/udev-builtin-net_id.c
index d8d450817..4f2b2c1f7 100644
--- a/src/udev/udev-builtin-net_id.c
+++ b/src/udev/udev-builtin-net_id.c
@@ -24,22 +24,28 @@
  *  - physical/geographical location of the hardware
  *  - the interface's MAC address
  *
+ * http://www.freedesktop.org/wiki/Software/systemd/PredictableNetworkInterfaceNames
+ *
  * Two character prefixes based on the type of interface:
  *   en -- ethernet
+ *   sl -- serial line IP (slip)
  *   wl -- wlan
  *   ww -- wwan
  *
  * Type of names:
- *   o<index>                   -- on-board device index number
- *   s<slot>[f<function>]       -- hotplug slot index number
- *   x<MAC>                     -- MAC address
- *   p<bus>s<slot>[f<function>] -- PCI geographical location
- *   p<bus>s<slot>[f<function>][u<port>][...][c<config>][i<interface>]
- *                              -- USB port number chain
+ *   o<index>                              -- on-board device index number
+ *   s<slot>[f<function>][d<dev_id>]       -- hotplug slot index number
+ *   x<MAC>                                -- MAC address
+ *   [P<domain>]p<bus>s<slot>[f<function>][d<dev_id>]
+ *                                         -- PCI geographical location
+ *   [P<domain>]p<bus>s<slot>[f<function>][u<port>][..][c<config>][i<interface>]
+ *                                         -- USB port number chain
  *
  * All multi-function PCI devices will carry the [f<function>] number in the
  * device name, including the function 0 device.
  *
+ * When using PCI geography, The PCI domain is only prepended when it is not 0.
+ *
  * For USB devices the full chain of port numbers of hubs is composed. If the
  * name gets longer than the maximum number of 15 characters, the name is not
  * exported.
@@ -89,11 +95,15 @@
 #include <linux/pci_regs.h>
 
 #include "udev.h"
+#include "fileio.h"
 
 enum netname_type{
         NET_UNDEF,
         NET_PCI,
         NET_USB,
+        NET_BCMA,
+        NET_VIRTIO,
+        NET_CCWGROUP,
 };
 
 struct netnames {
@@ -108,8 +118,13 @@ struct netnames {
         char pci_onboard[IFNAMSIZ];
         const char *pci_onboard_label;
 
-        struct udev_device *usbdev;
         char usb_ports[IFNAMSIZ];
+
+        char bcma_core[IFNAMSIZ];
+
+        char virtio_core[IFNAMSIZ];
+
+        char ccw_core[IFNAMSIZ];
 };
 
 /* retrieve on-board index number and label from firmware */
@@ -134,11 +149,11 @@ static int dev_pci_onboard(struct udev_device *dev, struct netnames *names) {
 }
 
 /* read the 256 bytes PCI configuration space to check the multi-function bit */
-static bool is_pci_singlefunction(struct udev_device *dev) {
+static bool is_pci_multifunction(struct udev_device *dev) {
         char filename[256];
-        FILE *f;
+        FILE *f = NULL;
         char config[64];
-        bool single = false;
+        bool multi = false;
 
         snprintf(filename, sizeof(filename), "%s/config", udev_device_get_syspath(dev));
         f = fopen(filename, "re");
@@ -148,33 +163,46 @@ static bool is_pci_singlefunction(struct udev_device *dev) {
                 goto out;
 
         /* bit 0-6 header type, bit 7 multi/single function device */
-        if ((config[PCI_HEADER_TYPE] & 0x80) == 0)
-                single = true;
+        if ((config[PCI_HEADER_TYPE] & 0x80) != 0)
+                multi = true;
 out:
-        fclose(f);
-        return single;
+        if (f)
+                fclose(f);
+        return multi;
 }
 
 static int dev_pci_slot(struct udev_device *dev, struct netnames *names) {
         struct udev *udev = udev_device_get_udev(names->pcidev);
-        unsigned int bus;
-        unsigned int slot;
-        unsigned int func;
+        unsigned domain, bus, slot, func, dev_id = 0;
+        size_t l;
+        char *s;
+        const char *attr;
         struct udev_device *pci = NULL;
-        char slots[256];
-        DIR *dir;
+        char slots[256], str[256];
+        _cleanup_closedir_ DIR *dir = NULL;
         struct dirent *dent;
-        char str[256];
-        int hotplug_slot = 0;
-        int err = 0;
+        int hotplug_slot = 0, err = 0;
 
-        /* compose a name based on the raw kernel's PCI bus, slot numbers */
-        if (sscanf(udev_device_get_sysname(names->pcidev), "0000:%x:%x.%d", &bus, &slot, &func) != 3)
+        if (sscanf(udev_device_get_sysname(names->pcidev), "%x:%x:%x.%u", &domain, &bus, &slot, &func) != 4)
                 return -ENOENT;
-        if (func == 0 && is_pci_singlefunction(names->pcidev))
-                snprintf(names->pci_path, sizeof(names->pci_path), "p%ds%d", bus, slot);
-        else
-                snprintf(names->pci_path, sizeof(names->pci_path), "p%ds%df%d", bus, slot, func);
+
+        /* kernel provided multi-device index */
+        attr = udev_device_get_sysattr_value(dev, "dev_id");
+        if (attr)
+                dev_id = strtol(attr, NULL, 16);
+
+        /* compose a name based on the raw kernel's PCI bus, slot numbers */
+        s = names->pci_path;
+        l = sizeof(names->pci_path);
+        if (domain > 0)
+                l = strpcpyf(&s, l, "P%d", domain);
+        l = strpcpyf(&s, l, "p%ds%d", bus, slot);
+        if (func > 0 || is_pci_multifunction(names->pcidev))
+                l = strpcpyf(&s, l, "f%d", func);
+        if (dev_id > 0)
+                l = strpcpyf(&s, l, "d%d", dev_id);
+        if (l == 0)
+                names->pci_path[0] = '\0';
 
         /* ACPI _SUN  -- slot user number */
         pci = udev_device_new_from_subsystem_sysname(udev, "subsystem", "pci");
@@ -204,7 +232,7 @@ static int dev_pci_slot(struct udev_device *dev, struct netnames *names) {
                 snprintf(str, sizeof(str), "%s/%s/address", slots, dent->d_name);
                 if (read_one_line_file(str, &address) >= 0) {
                         /* match slot address with device by stripping the function */
-                        if (strncmp(address, udev_device_get_sysname(names->pcidev), strlen(address)) == 0)
+                        if (strneq(address, udev_device_get_sysname(names->pcidev), strlen(address)))
                                 hotplug_slot = i;
                         free(address);
                 }
@@ -212,13 +240,19 @@ static int dev_pci_slot(struct udev_device *dev, struct netnames *names) {
                 if (hotplug_slot > 0)
                         break;
         }
-        closedir(dir);
 
         if (hotplug_slot > 0) {
-                if (func == 0 && is_pci_singlefunction(names->pcidev))
-                        snprintf(names->pci_slot, sizeof(names->pci_slot), "s%d", hotplug_slot);
-                else
-                        snprintf(names->pci_slot, sizeof(names->pci_slot), "s%df%d", hotplug_slot, func);
+                s = names->pci_slot;
+                l = sizeof(names->pci_slot);
+                if (domain > 0)
+                        l = strpcpyf(&s, l, "P%d", domain);
+                l = strpcpyf(&s, l, "s%d", hotplug_slot);
+                if (func > 0 || is_pci_multifunction(names->pcidev))
+                        l = strpcpyf(&s, l, "f%d", func);
+                if (dev_id > 0)
+                        l = strpcpyf(&s, l, "d%d", dev_id);
+                if (l == 0)
+                        names->pci_path[0] = '\0';
         }
 out:
         udev_device_unref(pci);
@@ -232,7 +266,7 @@ static int names_pci(struct udev_device *dev, struct netnames *names) {
         if (!parent)
                 return -ENOENT;
         /* check if our direct parent is a PCI device with no other bus in-between */
-        if (streq("pci", udev_device_get_subsystem(parent))) {
+        if (streq_ptr("pci", udev_device_get_subsystem(parent))) {
                 names->type = NET_PCI;
                 names->pcidev = parent;
         } else {
@@ -246,6 +280,7 @@ static int names_pci(struct udev_device *dev, struct netnames *names) {
 }
 
 static int names_usb(struct udev_device *dev, struct netnames *names) {
+        struct udev_device *usbdev;
         char name[256];
         char *ports;
         char *config;
@@ -253,12 +288,12 @@ static int names_usb(struct udev_device *dev, struct netnames *names) {
         size_t l;
         char *s;
 
-        names->usbdev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_interface");
-        if (!names->usbdev)
+        usbdev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_interface");
+        if (!usbdev)
                 return -ENOENT;
 
         /* get USB port number chain, configuration, interface */
-        util_strscpy(name, sizeof(name), udev_device_get_sysname(names->usbdev));
+        strscpy(name, sizeof(name), udev_device_get_sysname(usbdev));
         s = strchr(name, '-');
         if (!s)
                 return -EINVAL;
@@ -281,15 +316,15 @@ static int names_usb(struct udev_device *dev, struct netnames *names) {
         while ((s = strchr(s, '.')))
                 s[0] = 'u';
         s = names->usb_ports;
-        l = util_strpcpyl(&s, sizeof(names->usb_ports), "u", ports, NULL);
+        l = strpcpyl(&s, sizeof(names->usb_ports), "u", ports, NULL);
 
         /* append USB config number, suppress the common config == 1 */
         if (!streq(config, "1"))
-                l = util_strpcpyl(&s, sizeof(names->usb_ports), "c", config, NULL);
+                l = strpcpyl(&s, sizeof(names->usb_ports), "c", config, NULL);
 
         /* append USB interface number, suppress the interface == 0 */
         if (!streq(interf, "0"))
-                l = util_strpcpyl(&s, sizeof(names->usb_ports), "i", interf, NULL);
+                l = strpcpyl(&s, sizeof(names->usb_ports), "i", interf, NULL);
         if (l == 0)
                 return -ENAMETOOLONG;
 
@@ -297,6 +332,82 @@ static int names_usb(struct udev_device *dev, struct netnames *names) {
         return 0;
 }
 
+static int names_bcma(struct udev_device *dev, struct netnames *names) {
+        struct udev_device *bcmadev;
+        unsigned int core;
+
+        bcmadev = udev_device_get_parent_with_subsystem_devtype(dev, "bcma", NULL);
+        if (!bcmadev)
+                return -ENOENT;
+
+        /* bus num:core num */
+        if (sscanf(udev_device_get_sysname(bcmadev), "bcma%*u:%u", &core) != 1)
+                return -EINVAL;
+        /* suppress the common core == 0 */
+        if (core > 0)
+                snprintf(names->bcma_core, sizeof(names->bcma_core), "b%u", core);
+
+        names->type = NET_BCMA;
+        return 0;
+}
+
+static int names_virtio(struct udev_device *dev, struct netnames *names) {
+        struct udev_device *virtdev;
+        unsigned int core;
+
+        virtdev = udev_device_get_parent_with_subsystem_devtype(dev, "virtio", NULL);
+        if (!virtdev)
+                return -ENOENT;
+
+        /* core num */
+        if (sscanf(udev_device_get_sysname(virtdev), "virtio%u", &core) != 1)
+                return -EINVAL;
+        /* suppress the common core == 0 */
+        if (core > 0)
+                snprintf(names->virtio_core, sizeof(names->virtio_core), "v%u", core);
+
+        names->type = NET_VIRTIO;
+        return 0;
+}
+
+static int names_ccw(struct  udev_device *dev, struct netnames *names) {
+        struct udev_device *cdev;
+        const char *bus_id;
+        size_t bus_id_len;
+        int rc;
+
+        /* Retrieve the associated CCW device */
+        cdev = udev_device_get_parent(dev);
+        if (!cdev)
+                return -ENOENT;
+
+        /* Network devices are always grouped CCW devices */
+        if (!streq_ptr("ccwgroup", udev_device_get_subsystem(cdev)))
+                return -ENOENT;
+
+        /* Retrieve bus-ID of the grouped CCW device.  The bus-ID uniquely
+         * identifies the network device on the Linux on System z channel
+         * subsystem.  Note that the bus-ID contains lowercase characters.
+         */
+        bus_id = udev_device_get_sysname(cdev);
+        if (!bus_id)
+                return -ENOENT;
+
+        /* Check the length of the bus-ID.  Rely on that the kernel provides
+         * a correct bus-ID; alternatively, improve this check and parse and
+         * verify each bus-ID part...
+         */
+        bus_id_len = strlen(bus_id);
+        if (!bus_id_len || bus_id_len < 8 || bus_id_len > 9)
+                return -EINVAL;
+
+        /* Store the CCW bus-ID for use as network device name */
+        rc = snprintf(names->ccw_core, sizeof(names->ccw_core), "ccw%s", bus_id);
+        if (rc >= 0 && rc < (int)sizeof(names->ccw_core))
+                names->type = NET_CCWGROUP;
+        return 0;
+}
+
 static int names_mac(struct udev_device *dev, struct netnames *names) {
         const char *s;
         unsigned int i;
@@ -342,24 +453,43 @@ static int ieee_oui(struct udev_device *dev, struct netnames *names, bool test)
         snprintf(str, sizeof(str), "OUI:%02X%02X%02X%02X%02X%02X",
                  names->mac[0], names->mac[1], names->mac[2],
                  names->mac[3], names->mac[4], names->mac[5]);
-        udev_builtin_hwdb_lookup(dev, str, test);
+        udev_builtin_hwdb_lookup(dev, NULL, str, NULL, test);
         return 0;
 }
 
 static int builtin_net_id(struct udev_device *dev, int argc, char *argv[], bool test) {
         const char *s;
+        const char *p;
         unsigned int i;
         const char *devtype;
         const char *prefix = "en";
-        struct netnames names;
+        struct netnames names = {};
         int err;
 
-        /* handle only ARPHRD_ETHER devices */
+        /* handle only ARPHRD_ETHER and ARPHRD_SLIP devices */
         s = udev_device_get_sysattr_value(dev, "type");
         if (!s)
                 return EXIT_FAILURE;
         i = strtoul(s, NULL, 0);
-        if (i != 1)
+        switch (i) {
+        case 1: /* ARPHRD_ETHER */
+                prefix = "en";
+                break;
+        case 256: /* ARPHRD_SLIP */
+                prefix = "sl";
+                break;
+        default:
+                return 0;
+        }
+
+        /* skip stacked devices, like VLANs, ... */
+        s = udev_device_get_sysattr_value(dev, "ifindex");
+        if (!s)
+                return EXIT_FAILURE;
+        p = udev_device_get_sysattr_value(dev, "iflink");
+        if (!p)
+                return EXIT_FAILURE;
+        if (!streq(s, p))
                 return 0;
 
         devtype = udev_device_get_devtype(dev);
@@ -370,7 +500,6 @@ static int builtin_net_id(struct udev_device *dev, int argc, char *argv[], bool
                         prefix = "ww";
         }
 
-        zero(names);
         err = names_mac(dev, &names);
         if (err >= 0 && names.mac_valid) {
                 char str[IFNAMSIZ];
@@ -383,6 +512,16 @@ static int builtin_net_id(struct udev_device *dev, int argc, char *argv[], bool
                 ieee_oui(dev, &names, test);
         }
 
+        /* get path names for Linux on System z network devices */
+        err = names_ccw(dev, &names);
+        if (err >= 0 && names.type == NET_CCWGROUP) {
+                char str[IFNAMSIZ];
+
+                if (snprintf(str, sizeof(str), "%s%s", prefix, names.ccw_core) < (int)sizeof(str))
+                        udev_builtin_add_property(dev, test, "ID_NET_NAME_PATH", str);
+                goto out;
+        }
+
         /* get PCI based path names, we compose only PCI based paths */
         err = names_pci(dev, &names);
         if (err < 0)
@@ -422,7 +561,39 @@ static int builtin_net_id(struct udev_device *dev, int argc, char *argv[], bool
                 if (names.pci_slot[0])
                         if (snprintf(str, sizeof(str), "%s%s%s", prefix, names.pci_slot, names.usb_ports) < (int)sizeof(str))
                                 udev_builtin_add_property(dev, test, "ID_NET_NAME_SLOT", str);
+                goto out;
         }
+
+        /* Broadcom bus */
+        err = names_bcma(dev, &names);
+        if (err >= 0 && names.type == NET_BCMA) {
+                char str[IFNAMSIZ];
+
+                if (names.pci_path[0])
+                        if (snprintf(str, sizeof(str), "%s%s%s", prefix, names.pci_path, names.bcma_core) < (int)sizeof(str))
+                                udev_builtin_add_property(dev, test, "ID_NET_NAME_PATH", str);
+
+                if (names.pci_slot[0])
+                        if (snprintf(str, sizeof(str), "%s%s%s", prefix, names.pci_slot, names.bcma_core) < (int)sizeof(str))
+                                udev_builtin_add_property(dev, test, "ID_NET_NAME_SLOT", str);
+                goto out;
+        }
+
+        /* virtio bus */
+        err = names_virtio(dev, &names);
+        if (err >= 0 && names.type == NET_VIRTIO) {
+                char str[IFNAMSIZ];
+
+                if (names.pci_path[0])
+                        if (snprintf(str, sizeof(str), "%s%s%s", prefix, names.pci_path, names.virtio_core) < (int)sizeof(str))
+                                udev_builtin_add_property(dev, test, "ID_NET_NAME_PATH", str);
+
+                if (names.pci_slot[0])
+                        if (snprintf(str, sizeof(str), "%s%s%s", prefix, names.pci_slot, names.virtio_core) < (int)sizeof(str))
+                                udev_builtin_add_property(dev, test, "ID_NET_NAME_SLOT", str);
+                goto out;
+        }
+
 out:
         return EXIT_SUCCESS;
 }