src/udev/udev-builtin-path_id.c

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * compose persistent device path
   4  *
   5  * Logic based on Hannes Reinecke's shell script.
   6  */
   7
   8 #include <ctype.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <getopt.h>
  12 #include <stdarg.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16
  17 #include "alloc-util.h"
  18 #include "dirent-util.h"
  19 #include "fd-util.h"
  20 #include "libudev-util.h"
  21 #include "string-util.h"
  22 #include "strv.h"
  23 #include "sysexits.h"
  24 #include "udev-builtin.h"
  25
  26 _printf_(2,3)
  27 static void path_prepend(char **path, const char *fmt, ...) {
  28         va_list va;
  29         _cleanup_free_ char *pre = NULL;
  30         int r;
  31
  32         va_start(va, fmt);
  33         r = vasprintf(&pre, fmt, va);
  34         va_end(va);
  35         if (r < 0) {
  36                 log_oom();
  37                 exit(EX_OSERR);
  38         }
  39
  40         if (*path) {
  41                 char *new;
  42
  43                 new = strjoin(pre, "-", *path);
  44                 if (!new) {
  45                         log_oom();
  46                         exit(EX_OSERR);
  47                 }
  48
  49                 free_and_replace(*path, new);
  50         } else
  51                 *path = TAKE_PTR(pre);
  52 }
  53
  54 /*
  55 ** Linux only supports 32 bit luns.
  56 ** See drivers/scsi/scsi_scan.c::scsilun_to_int() for more details.
  57 */
  58 static int format_lun_number(sd_device *dev, char **path) {
  59         const char *sysnum;
  60         unsigned long lun;
  61         int r;
  62
  63         r = sd_device_get_sysnum(dev, &sysnum);
  64         if (r < 0)
  65                 return r;
  66         if (!sysnum)
  67                 return -ENOENT;
  68
  69         lun = strtoul(sysnum, NULL, 10);
  70         if (lun < 256)
  71                 /* address method 0, peripheral device addressing with bus id of zero */
  72                 path_prepend(path, "lun-%lu", lun);
  73         else
  74                 /* handle all other lun addressing methods by using a variant of the original lun format */
  75                 path_prepend(path, "lun-0x%04lx%04lx00000000", lun & 0xffff, (lun >> 16) & 0xffff);
  76
  77         return 0;
  78 }
  79
  80 static sd_device *skip_subsystem(sd_device *dev, const char *subsys) {
  81         sd_device *parent;
  82
  83         assert(dev);
  84         assert(subsys);
  85
  86         for (parent = dev; ; ) {
  87                 const char *subsystem;
  88
  89                 if (sd_device_get_subsystem(parent, &subsystem) < 0)
  90                         break;
  91
  92                 if (!streq(subsystem, subsys))
  93                         break;
  94
  95                 dev = parent;
  96                 if (sd_device_get_parent(dev, &parent) < 0)
  97                         break;
  98         }
  99
 100         return dev;
 101 }
 102
 103 static sd_device *handle_scsi_fibre_channel(sd_device *parent, char **path) {
 104         sd_device *targetdev;
 105         _cleanup_(sd_device_unrefp) sd_device *fcdev = NULL;
 106         const char *port, *sysname;
 107         _cleanup_free_ char *lun = NULL;
 108
 109         assert(parent);
 110         assert(path);
 111
 112         if (sd_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_target", &targetdev) < 0)
 113                 return NULL;
 114         if (sd_device_get_sysname(targetdev, &sysname) < 0)
 115                 return NULL;
 116         if (sd_device_new_from_subsystem_sysname(&fcdev, "fc_transport", sysname) < 0)
 117                 return NULL;
 118         if (sd_device_get_sysattr_value(fcdev, "port_name", &port) < 0)
 119                 return NULL;
 120
 121         format_lun_number(parent, &lun);
 122         path_prepend(path, "fc-%s-%s", port, lun);
 123         return parent;
 124 }
 125
 126 static sd_device *handle_scsi_sas_wide_port(sd_device *parent, char **path) {
 127         sd_device *targetdev, *target_parent;
 128         _cleanup_(sd_device_unrefp) sd_device *sasdev = NULL;
 129         const char *sas_address, *sysname;
 130         _cleanup_free_ char *lun = NULL;
 131
 132         assert(parent);
 133         assert(path);
 134
 135         if (sd_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_target", &targetdev) < 0)
 136                 return NULL;
 137         if (sd_device_get_parent(targetdev, &target_parent) < 0)
 138                 return NULL;
 139         if (sd_device_get_sysname(target_parent, &sysname) < 0)
 140                 return NULL;
 141         if (sd_device_new_from_subsystem_sysname(&sasdev, "sas_device", sysname) < 0)
 142                 return NULL;
 143         if (sd_device_get_sysattr_value(sasdev, "sas_address", &sas_address) < 0)
 144                 return NULL;
 145
 146         format_lun_number(parent, &lun);
 147         path_prepend(path, "sas-%s-%s", sas_address, lun);
 148         return parent;
 149 }
 150
 151 static sd_device *handle_scsi_sas(sd_device *parent, char **path) {
 152         sd_device *targetdev, *target_parent, *port, *expander;
 153         _cleanup_(sd_device_unrefp) sd_device *target_sasdev = NULL, *expander_sasdev = NULL, *port_sasdev = NULL;
 154         const char *sas_address = NULL;
 155         const char *phy_id;
 156         const char *phy_count, *sysname;
 157         _cleanup_free_ char *lun = NULL;
 158
 159         assert(parent);
 160         assert(path);
 161
 162         if (sd_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_target", &targetdev) < 0)
 163                 return NULL;
 164         if (sd_device_get_parent(targetdev, &target_parent) < 0)
 165                 return NULL;
 166         if (sd_device_get_sysname(target_parent, &sysname) < 0)
 167                 return NULL;
 168         /* Get sas device */
 169         if (sd_device_new_from_subsystem_sysname(&target_sasdev, "sas_device", sysname) < 0)
 170                 return NULL;
 171         /* The next parent is sas port */
 172         if (sd_device_get_parent(target_parent, &port) < 0)
 173                 return NULL;
 174         if (sd_device_get_sysname(port, &sysname) < 0)
 175                 return NULL;
 176         /* Get port device */
 177         if (sd_device_new_from_subsystem_sysname(&port_sasdev, "sas_port", sysname) < 0)
 178                 return NULL;
 179         if (sd_device_get_sysattr_value(port_sasdev, "num_phys", &phy_count) < 0)
 180                 return NULL;
 181
 182         /* Check if we are simple disk */
 183         if (strncmp(phy_count, "1", 2) != 0)
 184                 return handle_scsi_sas_wide_port(parent, path);
 185
 186         /* Get connected phy */
 187         if (sd_device_get_sysattr_value(target_sasdev, "phy_identifier", &phy_id) < 0)
 188                 return NULL;
 189
 190         /* The port's parent is either hba or expander */
 191         if (sd_device_get_parent(port, &expander) < 0)
 192                 return NULL;
 193
 194         if (sd_device_get_sysname(expander, &sysname) < 0)
 195                 return NULL;
 196         /* Get expander device */
 197         if (sd_device_new_from_subsystem_sysname(&expander_sasdev, "sas_device", sysname) >= 0) {
 198                 /* Get expander's address */
 199                 if (sd_device_get_sysattr_value(expander_sasdev, "sas_address", &sas_address) < 0)
 200                         return NULL;
 201         }
 202
 203         format_lun_number(parent, &lun);
 204         if (sas_address)
 205                  path_prepend(path, "sas-exp%s-phy%s-%s", sas_address, phy_id, lun);
 206         else
 207                  path_prepend(path, "sas-phy%s-%s", phy_id, lun);
 208
 209         return parent;
 210 }
 211
 212 static sd_device *handle_scsi_iscsi(sd_device *parent, char **path) {
 213         sd_device *transportdev;
 214         _cleanup_(sd_device_unrefp) sd_device *sessiondev = NULL, *conndev = NULL;
 215         const char *target, *connname, *addr, *port;
 216         _cleanup_free_ char *lun = NULL;
 217         const char *sysname, *sysnum;
 218
 219         assert(parent);
 220         assert(path);
 221
 222         /* find iscsi session */
 223         for (transportdev = parent; ; ) {
 224
 225                 if (sd_device_get_parent(transportdev, &transportdev) < 0)
 226                         return NULL;
 227                 if (sd_device_get_sysname(transportdev, &sysname) < 0)
 228                         return NULL;
 229                 if (startswith(sysname, "session"))
 230                         break;
 231         }
 232
 233         /* find iscsi session device */
 234         if (sd_device_new_from_subsystem_sysname(&sessiondev, "iscsi_session", sysname) < 0)
 235                 return NULL;
 236
 237         if (sd_device_get_sysattr_value(sessiondev, "targetname", &target) < 0)
 238                 return NULL;
 239
 240         if (sd_device_get_sysnum(transportdev, &sysnum) < 0 || !sysnum)
 241                 return NULL;
 242         connname = strjoina("connection", sysnum, ":0");
 243         if (sd_device_new_from_subsystem_sysname(&conndev, "iscsi_connection", connname) < 0)
 244                 return NULL;
 245
 246         if (sd_device_get_sysattr_value(conndev, "persistent_address", &addr) < 0)
 247                 return NULL;
 248         if (sd_device_get_sysattr_value(conndev, "persistent_port", &port) < 0)
 249                 return NULL;
 250
 251         format_lun_number(parent, &lun);
 252         path_prepend(path, "ip-%s:%s-iscsi-%s-%s", addr, port, target, lun);
 253         return parent;
 254 }
 255
 256 static sd_device *handle_scsi_ata(sd_device *parent, char **path, char **compat_path) {
 257         sd_device *targetdev, *target_parent;
 258         _cleanup_(sd_device_unrefp) sd_device *atadev = NULL;
 259         const char *port_no, *sysname, *name;
 260         unsigned host, bus, target, lun;
 261
 262         assert(parent);
 263         assert(path);
 264
 265         if (sd_device_get_sysname(parent, &name) < 0)
 266                 return NULL;
 267         if (sscanf(name, "%u:%u:%u:%u", &host, &bus, &target, &lun) != 4)
 268                 return NULL;
 269
 270         if (sd_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_host", &targetdev) < 0)
 271                 return NULL;
 272
 273         if (sd_device_get_parent(targetdev, &target_parent) < 0)
 274                 return NULL;
 275
 276         if (sd_device_get_sysname(target_parent, &sysname) < 0)
 277                 return NULL;
 278         if (sd_device_new_from_subsystem_sysname(&atadev, "ata_port", sysname) < 0)
 279                 return NULL;
 280
 281         if (sd_device_get_sysattr_value(atadev, "port_no", &port_no) < 0)
 282                 return NULL;
 283
 284         if (bus != 0)
 285                 /* Devices behind port multiplier have a bus != 0*/
 286                 path_prepend(path, "ata-%s.%u.0", port_no, bus);
 287         else
 288                 /* Master/slave are distinguished by target id */
 289                 path_prepend(path, "ata-%s.%u", port_no, target);
 290
 291         /* old compatible persistent link for ATA devices */
 292         if (compat_path)
 293                 path_prepend(compat_path, "ata-%s", port_no);
 294
 295         return parent;
 296 }
 297
 298 static sd_device *handle_scsi_default(sd_device *parent, char **path) {
 299         sd_device *hostdev;
 300         int host, bus, target, lun;
 301         const char *name, *base, *pos;
 302         _cleanup_closedir_ DIR *dir = NULL;
 303         struct dirent *dent;
 304         int basenum = -1;
 305
 306         assert(parent);
 307         assert(path);
 308
 309         if (sd_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_host", &hostdev) < 0)
 310                 return NULL;
 311
 312         if (sd_device_get_sysname(parent, &name) < 0)
 313                 return NULL;
 314         if (sscanf(name, "%d:%d:%d:%d", &host, &bus, &target, &lun) != 4)
 315                 return NULL;
 316
 317         /*
 318          * Rebase host offset to get the local relative number
 319          *
 320          * Note: This is by definition racy, unreliable and too simple.
 321          * Please do not copy this model anywhere. It's just a left-over
 322          * from the time we had no idea how things should look like in
 323          * the end.
 324          *
 325          * Making assumptions about a global in-kernel counter and use
 326          * that to calculate a local offset is a very broken concept. It
 327          * can only work as long as things are in strict order.
 328          *
 329          * The kernel needs to export the instance/port number of a
 330          * controller directly, without the need for rebase magic like
 331          * this. Manual driver unbind/bind, parallel hotplug/unplug will
 332          * get into the way of this "I hope it works" logic.
 333          */
 334
 335         if (sd_device_get_syspath(hostdev, &base) < 0)
 336                 return NULL;
 337         pos = strrchr(base, '/');
 338         if (!pos)
 339                 return NULL;
 340
 341         base = strndupa(base, pos - base);
 342         dir = opendir(base);
 343         if (!dir)
 344                 return NULL;
 345
 346         FOREACH_DIRENT_ALL(dent, dir, break) {
 347                 char *rest;
 348                 int i;
 349
 350                 if (dent->d_name[0] == '.')
 351                         continue;
 352                 if (!IN_SET(dent->d_type, DT_DIR, DT_LNK))
 353                         continue;
 354                 if (!startswith(dent->d_name, "host"))
 355                         continue;
 356                 i = strtoul(&dent->d_name[4], &rest, 10);
 357                 if (rest[0] != '\0')
 358                         continue;
 359                 /*
 360                  * find the smallest number; the host really needs to export its
 361                  * own instance number per parent device; relying on the global host
 362                  * enumeration and plainly rebasing the numbers sounds unreliable
 363                  */
 364                 if (basenum == -1 || i < basenum)
 365                         basenum = i;
 366         }
 367         if (basenum == -1)
 368                 return hostdev;
 369         host -= basenum;
 370
 371         path_prepend(path, "scsi-%u:%u:%u:%u", host, bus, target, lun);
 372         return hostdev;
 373 }
 374
 375 static sd_device *handle_scsi_hyperv(sd_device *parent, char **path, size_t guid_str_len) {
 376         sd_device *hostdev;
 377         sd_device *vmbusdev;
 378         const char *guid_str;
 379         _cleanup_free_ char *lun = NULL;
 380         char guid[39];
 381         size_t i, k;
 382
 383         assert(parent);
 384         assert(path);
 385         assert(guid_str_len < sizeof(guid));
 386
 387         if (sd_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_host", &hostdev) < 0)
 388                 return NULL;
 389
 390         if (sd_device_get_parent(hostdev, &vmbusdev) < 0)
 391                 return NULL;
 392
 393         if (sd_device_get_sysattr_value(vmbusdev, "device_id", &guid_str) < 0)
 394                 return NULL;
 395
 396         if (strlen(guid_str) < guid_str_len || guid_str[0] != '{' || guid_str[guid_str_len-1] != '}')
 397                 return NULL;
 398
 399         for (i = 1, k = 0; i < guid_str_len-1; i++) {
 400                 if (guid_str[i] == '-')
 401                         continue;
 402                 guid[k++] = guid_str[i];
 403         }
 404         guid[k] = '\0';
 405
 406         format_lun_number(parent, &lun);
 407         path_prepend(path, "vmbus-%s-%s", guid, lun);
 408         return parent;
 409 }
 410
 411 static sd_device *handle_scsi(sd_device *parent, char **path, char **compat_path, bool *supported_parent) {
 412         const char *devtype, *id, *name;
 413
 414         if (sd_device_get_devtype(parent, &devtype) < 0 ||
 415             !streq(devtype, "scsi_device"))
 416                 return parent;
 417
 418         /* firewire */
 419         if (sd_device_get_sysattr_value(parent, "ieee1394_id", &id) >= 0) {
 420                 path_prepend(path, "ieee1394-0x%s", id);
 421                 *supported_parent = true;
 422                 return skip_subsystem(parent, "scsi");
 423         }
 424
 425         /* scsi sysfs does not have a "subsystem" for the transport */
 426         if (sd_device_get_syspath(parent, &name) < 0)
 427                 return NULL;
 428
 429         if (strstr(name, "/rport-")) {
 430                 *supported_parent = true;
 431                 return handle_scsi_fibre_channel(parent, path);
 432         }
 433
 434         if (strstr(name, "/end_device-")) {
 435                 *supported_parent = true;
 436                 return handle_scsi_sas(parent, path);
 437         }
 438
 439         if (strstr(name, "/session")) {
 440                 *supported_parent = true;
 441                 return handle_scsi_iscsi(parent, path);
 442         }
 443
 444         if (strstr(name, "/ata"))
 445                 return handle_scsi_ata(parent, path, compat_path);
 446
 447         if (strstr(name, "/vmbus_"))
 448                 return handle_scsi_hyperv(parent, path, 37);
 449         else if (strstr(name, "/VMBUS"))
 450                 return handle_scsi_hyperv(parent, path, 38);
 451
 452         return handle_scsi_default(parent, path);
 453 }
 454
 455 static sd_device *handle_cciss(sd_device *parent, char **path) {
 456         const char *str;
 457         unsigned controller, disk;
 458
 459         if (sd_device_get_sysname(parent, &str) < 0)
 460                 return NULL;
 461         if (sscanf(str, "c%ud%u%*s", &controller, &disk) != 2)
 462                 return NULL;
 463
 464         path_prepend(path, "cciss-disk%u", disk);
 465         return skip_subsystem(parent, "cciss");
 466 }
 467
 468 static void handle_scsi_tape(sd_device *dev, char **path) {
 469         const char *name;
 470
 471         /* must be the last device in the syspath */
 472         if (*path)
 473                 return;
 474
 475         if (sd_device_get_sysname(dev, &name) < 0)
 476                 return;
 477
 478         if (startswith(name, "nst") && strchr("lma", name[3]))
 479                 path_prepend(path, "nst%c", name[3]);
 480         else if (startswith(name, "st") && strchr("lma", name[2]))
 481                 path_prepend(path, "st%c", name[2]);
 482 }
 483
 484 static sd_device *handle_usb(sd_device *parent, char **path) {
 485         const char *devtype, *str, *port;
 486
 487         if (sd_device_get_devtype(parent, &devtype) < 0)
 488                 return parent;
 489         if (!STR_IN_SET(devtype, "usb_interface", "usb_device"))
 490                 return parent;
 491
 492         if (sd_device_get_sysname(parent, &str) < 0)
 493                 return parent;
 494         port = strchr(str, '-');
 495         if (!port)
 496                 return parent;
 497         port++;
 498
 499         path_prepend(path, "usb-0:%s", port);
 500         return skip_subsystem(parent, "usb");
 501 }
 502
 503 static sd_device *handle_bcma(sd_device *parent, char **path) {
 504         const char *sysname;
 505         unsigned core;
 506
 507         if (sd_device_get_sysname(parent, &sysname) < 0)
 508                 return NULL;
 509         if (sscanf(sysname, "bcma%*u:%u", &core) != 1)
 510                 return NULL;
 511
 512         path_prepend(path, "bcma-%u", core);
 513         return parent;
 514 }
 515
 516 /* Handle devices of AP bus in System z platform. */
 517 static sd_device *handle_ap(sd_device *parent, char **path) {
 518         const char *type, *func;
 519
 520         assert(parent);
 521         assert(path);
 522
 523         if (sd_device_get_sysattr_value(parent, "type", &type) >= 0 &&
 524             sd_device_get_sysattr_value(parent, "ap_functions", &func) >= 0)
 525                 path_prepend(path, "ap-%s-%s", type, func);
 526         else {
 527                 const char *sysname;
 528
 529                 if (sd_device_get_sysname(parent, &sysname) >= 0)
 530                         path_prepend(path, "ap-%s", sysname);
 531         }
 532
 533         return skip_subsystem(parent, "ap");
 534 }
 535
 536 static int builtin_path_id(sd_device *dev, int argc, char *argv[], bool test) {
 537         sd_device *parent;
 538         _cleanup_free_ char *path = NULL;
 539         _cleanup_free_ char *compat_path = NULL;
 540         bool supported_transport = false;
 541         bool supported_parent = false;
 542         const char *subsystem;
 543
 544         assert(dev);
 545
 546         /* walk up the chain of devices and compose path */
 547         parent = dev;
 548         while (parent) {
 549                 const char *subsys, *sysname;
 550
 551                 if (sd_device_get_subsystem(parent, &subsys) < 0 ||
 552                     sd_device_get_sysname(parent, &sysname) < 0) {
 553                         ;
 554                 } else if (streq(subsys, "scsi_tape")) {
 555                         handle_scsi_tape(parent, &path);
 556                 } else if (streq(subsys, "scsi")) {
 557                         parent = handle_scsi(parent, &path, &compat_path, &supported_parent);
 558                         supported_transport = true;
 559                 } else if (streq(subsys, "cciss")) {
 560                         parent = handle_cciss(parent, &path);
 561                         supported_transport = true;
 562                 } else if (streq(subsys, "usb")) {
 563                         parent = handle_usb(parent, &path);
 564                         supported_transport = true;
 565                 } else if (streq(subsys, "bcma")) {
 566                         parent = handle_bcma(parent, &path);
 567                         supported_transport = true;
 568                 } else if (streq(subsys, "serio")) {
 569                         const char *sysnum;
 570
 571                         if (sd_device_get_sysnum(parent, &sysnum) >= 0 && sysnum) {
 572                                 path_prepend(&path, "serio-%s", sysnum);
 573                                 parent = skip_subsystem(parent, "serio");
 574                         }
 575                 } else if (streq(subsys, "pci")) {
 576                         path_prepend(&path, "pci-%s", sysname);
 577                         if (compat_path)
 578                                 path_prepend(&compat_path, "pci-%s", sysname);
 579                         parent = skip_subsystem(parent, "pci");
 580                         supported_parent = true;
 581                 } else if (streq(subsys, "platform")) {
 582                         path_prepend(&path, "platform-%s", sysname);
 583                         if (compat_path)
 584                                 path_prepend(&compat_path, "platform-%s", sysname);
 585                         parent = skip_subsystem(parent, "platform");
 586                         supported_transport = true;
 587                         supported_parent = true;
 588                 } else if (streq(subsys, "acpi")) {
 589                         path_prepend(&path, "acpi-%s", sysname);
 590                         if (compat_path)
 591                                 path_prepend(&compat_path, "acpi-%s", sysname);
 592                         parent = skip_subsystem(parent, "acpi");
 593                         supported_parent = true;
 594                 } else if (streq(subsys, "xen")) {
 595                         path_prepend(&path, "xen-%s", sysname);
 596                         if (compat_path)
 597                                 path_prepend(&compat_path, "xen-%s", sysname);
 598                         parent = skip_subsystem(parent, "xen");
 599                         supported_parent = true;
 600                 } else if (streq(subsys, "virtio")) {
 601                         parent = skip_subsystem(parent, "virtio");
 602                         supported_transport = true;
 603                 } else if (streq(subsys, "scm")) {
 604                         path_prepend(&path, "scm-%s", sysname);
 605                         if (compat_path)
 606                                 path_prepend(&compat_path, "scm-%s", sysname);
 607                         parent = skip_subsystem(parent, "scm");
 608                         supported_transport = true;
 609                         supported_parent = true;
 610                 } else if (streq(subsys, "ccw")) {
 611                         path_prepend(&path, "ccw-%s", sysname);
 612                         if (compat_path)
 613                                 path_prepend(&compat_path, "ccw-%s", sysname);
 614                         parent = skip_subsystem(parent, "ccw");
 615                         supported_transport = true;
 616                         supported_parent = true;
 617                 } else if (streq(subsys, "ccwgroup")) {
 618                         path_prepend(&path, "ccwgroup-%s", sysname);
 619                         if (compat_path)
 620                                 path_prepend(&compat_path, "ccwgroup-%s", sysname);
 621                         parent = skip_subsystem(parent, "ccwgroup");
 622                         supported_transport = true;
 623                         supported_parent = true;
 624                 } else if (streq(subsys, "ap")) {
 625                         parent = handle_ap(parent, &path);
 626                         supported_transport = true;
 627                         supported_parent = true;
 628                 } else if (streq(subsys, "iucv")) {
 629                         path_prepend(&path, "iucv-%s", sysname);
 630                         if (compat_path)
 631                                 path_prepend(&compat_path, "iucv-%s", sysname);
 632                         parent = skip_subsystem(parent, "iucv");
 633                         supported_transport = true;
 634                         supported_parent = true;
 635                 } else if (streq(subsys, "nvme")) {
 636                         const char *nsid;
 637
 638                         if (sd_device_get_sysattr_value(dev, "nsid", &nsid) >= 0) {
 639                                 path_prepend(&path, "nvme-%s", nsid);
 640                                 if (compat_path)
 641                                         path_prepend(&compat_path, "nvme-%s", nsid);
 642                                 parent = skip_subsystem(parent, "nvme");
 643                                 supported_parent = true;
 644                                 supported_transport = true;
 645                         }
 646                 }
 647
 648                 if (!parent)
 649                         break;
 650                 if (sd_device_get_parent(parent, &parent) < 0)
 651                         break;
 652         }
 653
 654         if (!path)
 655                 return -ENOENT;
 656
 657         /*
 658          * Do not return devices with an unknown parent device type. They
 659          * might produce conflicting IDs if the parent does not provide a
 660          * unique and predictable name.
 661          */
 662         if (!supported_parent)
 663                 return -ENOENT;
 664
 665         /*
 666          * Do not return block devices without a well-known transport. Some
 667          * devices do not expose their buses and do not provide a unique
 668          * and predictable name that way.
 669          */
 670         if (sd_device_get_subsystem(dev, &subsystem) >= 0 &&
 671             streq(subsystem, "block") &&
 672             !supported_transport)
 673                 return -ENOENT;
 674
 675         {
 676                 char tag[UTIL_NAME_SIZE];
 677                 size_t i;
 678                 const char *p;
 679
 680                 /* compose valid udev tag name */
 681                 for (p = path, i = 0; *p; p++) {
 682                         if ((*p >= '0' && *p <= '9') ||
 683                             (*p >= 'A' && *p <= 'Z') ||
 684                             (*p >= 'a' && *p <= 'z') ||
 685                             *p == '-') {
 686                                 tag[i++] = *p;
 687                                 continue;
 688                         }
 689
 690                         /* skip all leading '_' */
 691                         if (i == 0)
 692                                 continue;
 693
 694                         /* avoid second '_' */
 695                         if (tag[i-1] == '_')
 696                                 continue;
 697
 698                         tag[i++] = '_';
 699                 }
 700                 /* strip trailing '_' */
 701                 while (i > 0 && tag[i-1] == '_')
 702                         i--;
 703                 tag[i] = '\0';
 704
 705                 udev_builtin_add_property(dev, test, "ID_PATH", path);
 706                 udev_builtin_add_property(dev, test, "ID_PATH_TAG", tag);
 707         }
 708
 709         /*
 710          * Compatible link generation for ATA devices
 711          * we assign compat_link to the env variable
 712          * ID_PATH_ATA_COMPAT
 713          */
 714         if (compat_path)
 715                 udev_builtin_add_property(dev, test, "ID_PATH_ATA_COMPAT", compat_path);
 716
 717         return 0;
 718 }
 719
 720 const UdevBuiltin udev_builtin_path_id = {
 721         .name = "path_id",
 722         .cmd = builtin_path_id,
 723         .help = "Compose persistent device path",
 724         .run_once = true,
 725 };