usr/src/cmd/devfsadm/disk_link.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2016 Toomas Soome <tsoome@me.com>
  23  * Copyright 2016 Nexenta Systems, Inc.  All rights reserved.
  24  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27
  28 #include <devfsadm.h>
  29 #include <stdio.h>
  30 #include <strings.h>
  31 #include <stdlib.h>
  32 #include <limits.h>
  33 #include <ctype.h>
  34 #include <unistd.h>
  35 #include <sys/int_fmtio.h>
  36 #include <sys/stat.h>
  37 #include <bsm/devalloc.h>
  38 #include <sys/scsi/scsi_address.h>
  39 #include <sys/libdevid.h>
  40 #include <sys/lofi.h>
  41
  42 #define DISK_SUBPATH_MAX 100
  43 #define RM_STALE 0x01
  44 #define DISK_LINK_RE    "^r?dsk/c[0-9]+(t[0-9A-F]+)?d[0-9]+(((s|p))[0-9]+)?$"
  45 #define DISK_LINK_TO_UPPER(ch)\
  46         (((ch) >= 'a' && (ch) <= 'z') ? (ch - 'a' + 'A') : ch)
  47
  48 #define SLICE_SMI       "s7"
  49 #define SLICE_EFI       ""
  50
  51 #define MN_SMI          "h"
  52 #define MN_EFI          "wd"
  53 #define ASCIIWWNSIZE    255
  54 #if defined(__i386) || defined(__amd64)
  55 /*
  56  * The number of minor nodes per LUN is defined by the disk drivers.
  57  * Currently it is set to 64. Refer CMLBUNIT_SHIFT (cmlb_impl.h)
  58  */
  59 #define NUM_MINORS_PER_INSTANCE 64
  60 #endif
  61
  62
  63 static int disk_callback_chan(di_minor_t minor, di_node_t node);
  64 static int disk_callback_nchan(di_minor_t minor, di_node_t node);
  65 static int disk_callback_blkdev(di_minor_t minor, di_node_t node);
  66 static int disk_callback_wwn(di_minor_t minor, di_node_t node);
  67 static int disk_callback_xvmd(di_minor_t minor, di_node_t node);
  68 static int disk_callback_fabric(di_minor_t minor, di_node_t node);
  69 static int disk_callback_sas(di_minor_t minor, di_node_t node);
  70 static void disk_common(di_minor_t minor, di_node_t node, char *disk,
  71                                 int flags);
  72 static char *diskctrl(di_node_t node, di_minor_t minor);
  73 static int reserved_links_exist(di_node_t node, di_minor_t minor, int nflags);
  74 static void disk_rm_lofi_all(char *file);
  75
  76
  77 static devfsadm_create_t disk_cbt[] = {
  78         { "disk", DDI_NT_BLOCK, NULL,
  79             TYPE_EXACT, ILEVEL_0, disk_callback_nchan
  80         },
  81         { "disk", DDI_NT_BLOCK_CHAN, NULL,
  82             TYPE_EXACT, ILEVEL_0, disk_callback_chan
  83         },
  84         { "disk", DDI_NT_BLOCK_BLKDEV, NULL,
  85             TYPE_EXACT, ILEVEL_0, disk_callback_blkdev
  86         },
  87         { "disk", DDI_NT_BLOCK_FABRIC, NULL,
  88                 TYPE_EXACT, ILEVEL_0, disk_callback_fabric
  89         },
  90         { "disk", DDI_NT_BLOCK_WWN, NULL,
  91             TYPE_EXACT, ILEVEL_0, disk_callback_wwn
  92         },
  93         { "disk", DDI_NT_BLOCK_SAS, NULL,
  94             TYPE_EXACT, ILEVEL_0, disk_callback_sas
  95         },
  96         { "disk", DDI_NT_CD, NULL,
  97             TYPE_EXACT, ILEVEL_0, disk_callback_nchan
  98         },
  99         { "disk", DDI_NT_CD_CHAN, NULL,
 100             TYPE_EXACT, ILEVEL_0, disk_callback_chan
 101         },
 102         { "disk", DDI_NT_BLOCK_XVMD, NULL,
 103             TYPE_EXACT, ILEVEL_0, disk_callback_xvmd
 104         },
 105         { "disk", DDI_NT_CD_XVMD, NULL,
 106             TYPE_EXACT, ILEVEL_0, disk_callback_xvmd
 107         },
 108 };
 109
 110 DEVFSADM_CREATE_INIT_V0(disk_cbt);
 111
 112 /*
 113  * HOT auto cleanup of disks is done for lofi devices only.
 114  */
 115 static devfsadm_remove_t disk_remove_cbt[] = {
 116         { "disk", DISK_LINK_RE, RM_HOT | RM_POST | RM_ALWAYS,
 117                 ILEVEL_0, disk_rm_lofi_all
 118         },
 119         { "disk", DISK_LINK_RE, RM_POST,
 120                 ILEVEL_0, devfsadm_rm_all
 121         }
 122 };
 123
 124 DEVFSADM_REMOVE_INIT_V0(disk_remove_cbt);
 125
 126 static devlink_re_t disks_re_array[] = {
 127         {"^r?dsk/c([0-9]+)", 1},
 128         {"^cfg/c([0-9]+)$", 1},
 129         {"^scsi/.+/c([0-9]+)", 1},
 130         {NULL}
 131 };
 132
 133 static char *disk_mid = "disk_mid";
 134 static char *modname = "disk_link";
 135
 136 /*
 137  * Check if link is from lofi by checking path from readlink().
 138  */
 139 static int
 140 is_lofi_disk(char *file)
 141 {
 142         char buf[PATH_MAX + 1];
 143         char filepath[PATH_MAX];
 144         char *ptr;
 145         ssize_t size;
 146
 147         size = snprintf(filepath, sizeof (filepath), "%s/dev/%s",
 148             devfsadm_root_path(), file);
 149         if (size > sizeof (filepath))
 150                 return (0);
 151
 152         size = readlink(filepath, buf, sizeof (buf) - 1);
 153         if (size == -1)
 154                 return (0);
 155         buf[size] = '\0';
 156         ptr = strchr(buf, '@');
 157         if (ptr == NULL)
 158                 return (0);
 159         ptr[1] = '\0';
 160         if (strcmp(buf, "../../devices/pseudo/lofi@") != 0)
 161                 return (0);
 162         return (1);
 163 }
 164
 165 /*
 166  * Wrapper around devfsadm_rm_link() for lofi devices.
 167  */
 168 static void disk_rm_lofi_all(char *file)
 169 {
 170         if (is_lofi_disk(file))
 171                 devfsadm_rm_link(file);
 172 }
 173
 174 int
 175 minor_init()
 176 {
 177         devfsadm_print(disk_mid,
 178             "%s: minor_init(): Creating disks reserved ID cache\n",
 179             modname);
 180         return (devfsadm_reserve_id_cache(disks_re_array, NULL));
 181 }
 182
 183 static int
 184 disk_callback_chan(di_minor_t minor, di_node_t node)
 185 {
 186         char *addr;
 187         char disk[23];
 188         char *driver;
 189         uint_t targ = 0;
 190         uint_t lun = 0;
 191
 192         driver = di_driver_name(node);
 193         if (strcmp(driver, LOFI_DRIVER_NAME) != 0) {
 194                 addr = di_bus_addr(node);
 195                 (void) sscanf(addr, "%X,%X", &targ, &lun);
 196         } else {
 197                 targ = di_instance(node);
 198         }
 199
 200         (void) snprintf(disk, sizeof (disk), "t%dd%d", targ, lun);
 201         disk_common(minor, node, disk, 0);
 202         return (DEVFSADM_CONTINUE);
 203
 204 }
 205
 206 static int
 207 disk_callback_nchan(di_minor_t minor, di_node_t node)
 208 {
 209         char *addr;
 210         char disk[10];
 211         uint_t lun;
 212
 213         addr = di_bus_addr(node);
 214         (void) sscanf(addr, "%X", &lun);
 215         (void) sprintf(disk, "d%d", lun);
 216         disk_common(minor, node, disk, 0);
 217         return (DEVFSADM_CONTINUE);
 218
 219 }
 220
 221 static int
 222 disk_callback_blkdev(di_minor_t minor, di_node_t node)
 223 {
 224         char *addr;
 225         char disk[DISK_SUBPATH_MAX];
 226         uint64_t eui64;
 227         uint_t lun = 0;
 228
 229         addr = di_bus_addr(node);
 230         (void) sscanf(addr, "w%016"PRIx64",%X", &eui64, &lun);
 231         (void) snprintf(disk, DISK_SUBPATH_MAX, "t%016"PRIX64"d%d", eui64, lun);
 232         disk_common(minor, node, disk, RM_STALE);
 233         return (DEVFSADM_CONTINUE);
 234 }
 235
 236 static int
 237 disk_callback_wwn(di_minor_t minor, di_node_t node)
 238 {
 239         char disk[10];
 240         int lun;
 241         int targ;
 242         int *intp;
 243
 244         if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, SCSI_ADDR_PROP_TARGET,
 245             &intp) <= 0) {
 246                 return (DEVFSADM_CONTINUE);
 247         }
 248         targ = *intp;
 249         if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, SCSI_ADDR_PROP_LUN,
 250             &intp) <= 0) {
 251                 lun = 0;
 252         } else {
 253                 lun = *intp;
 254         }
 255         (void) sprintf(disk, "t%dd%d", targ, lun);
 256
 257         disk_common(minor, node, disk, RM_STALE);
 258
 259         return (DEVFSADM_CONTINUE);
 260 }
 261
 262 static int
 263 disk_callback_fabric(di_minor_t minor, di_node_t node)
 264 {
 265         char disk[DISK_SUBPATH_MAX];
 266         int lun;
 267         int count;
 268         int *intp;
 269         uchar_t *str;
 270         uchar_t *wwn;
 271         uchar_t ascii_wwn[ASCIIWWNSIZE];
 272
 273         if (di_prop_lookup_strings(DDI_DEV_T_ANY, node,
 274             "client-guid", (char **)&wwn) > 0) {
 275                 if (strlcpy((char *)ascii_wwn, (char *)wwn,
 276                     sizeof (ascii_wwn)) >= sizeof (ascii_wwn)) {
 277                         devfsadm_errprint("SUNW_disk_link: GUID too long:%d",
 278                             strlen((char *)wwn));
 279                         return (DEVFSADM_CONTINUE);
 280                 }
 281                 lun = 0;
 282         } else if (di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
 283             "port-wwn", &wwn) > 0) {
 284                 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node,
 285                     SCSI_ADDR_PROP_LUN, &intp) > 0) {
 286                         lun = *intp;
 287                 } else {
 288                         lun = 0;
 289                 }
 290
 291                 for (count = 0, str = ascii_wwn; count < 8; count++, str += 2) {
 292                         (void) sprintf((caddr_t)str, "%02x", wwn[count]);
 293                 }
 294                 *str = '\0';
 295         } else {
 296                 return (DEVFSADM_CONTINUE);
 297         }
 298
 299         for (str = ascii_wwn; *str != '\0'; str++) {
 300                 *str = DISK_LINK_TO_UPPER(*str);
 301         }
 302
 303         (void) snprintf(disk, DISK_SUBPATH_MAX, "t%sd%d", ascii_wwn, lun);
 304
 305         disk_common(minor, node, disk, RM_STALE);
 306
 307         return (DEVFSADM_CONTINUE);
 308 }
 309
 310 static int
 311 disk_callback_sas(di_minor_t minor, di_node_t node)
 312 {
 313         char disk[DISK_SUBPATH_MAX];
 314         int lun64_found = 0;
 315         scsi_lun64_t lun64, sl;
 316         scsi_lun_t lun;
 317         int64_t *lun64p;
 318         uint64_t wwn;
 319         int *intp;
 320         char *tgt_port;
 321         uchar_t addr_method;
 322
 323         /* Get lun property */
 324         if (di_prop_lookup_int64(DDI_DEV_T_ANY, node,
 325             SCSI_ADDR_PROP_LUN64, &lun64p) > 0) {
 326                 if (*lun64p != SCSI_LUN64_ILLEGAL) {
 327                         lun64_found = 1;
 328                         lun64 = (uint64_t)*lun64p;
 329                 }
 330         }
 331         if ((!lun64_found) && (di_prop_lookup_ints(DDI_DEV_T_ANY, node,
 332             SCSI_ADDR_PROP_LUN, &intp) > 0)) {
 333                 lun64 = (uint64_t)*intp;
 334         }
 335
 336         lun = scsi_lun64_to_lun(lun64);
 337
 338         addr_method = (lun.sl_lun1_msb & SCSI_LUN_AM_MASK);
 339
 340         if (di_prop_lookup_strings(DDI_DEV_T_ANY, node,
 341             SCSI_ADDR_PROP_TARGET_PORT, &tgt_port) > 0) {
 342                 (void) scsi_wwnstr_to_wwn(tgt_port, &wwn);
 343                 if ((addr_method == SCSI_LUN_AM_PDEV) &&
 344                     (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) &&
 345                     (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) &&
 346                     (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) {
 347                         (void) snprintf(disk, DISK_SUBPATH_MAX,
 348                             "t%"PRIX64"d%"PRId64, wwn, lun64);
 349                 } else if ((addr_method == SCSI_LUN_AM_FLAT) &&
 350                     (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) &&
 351                     (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) &&
 352                     (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) {
 353                         sl = (lun.sl_lun1_msb << 8) | lun.sl_lun1_lsb;
 354                         (void) snprintf(disk, DISK_SUBPATH_MAX,
 355                             "t%"PRIX64"d%"PRIX16, wwn, sl);
 356                 } else {
 357                         (void) snprintf(disk, DISK_SUBPATH_MAX,
 358                             "t%"PRIX64"d%"PRIX64, wwn, lun64);
 359                 }
 360         } else if (di_prop_lookup_ints(DDI_DEV_T_ANY, node,
 361             SCSI_ADDR_PROP_SATA_PHY, &intp) > 0) {
 362                 /* Use phy format naming, for SATA devices without wwn */
 363                 if ((addr_method == SCSI_LUN_AM_PDEV) &&
 364                     (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) &&
 365                     (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) &&
 366                     (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) {
 367                         (void) snprintf(disk, DISK_SUBPATH_MAX,
 368                             "t%dd%"PRId64, *intp, lun64);
 369                 } else if ((addr_method == SCSI_LUN_AM_FLAT) &&
 370                     (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) &&
 371                     (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) &&
 372                     (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) {
 373                         sl = (lun.sl_lun1_msb << 8) | lun.sl_lun1_lsb;
 374                         (void) snprintf(disk, DISK_SUBPATH_MAX,
 375                             "t%dd%"PRIX16, *intp, sl);
 376                 } else {
 377                         (void) snprintf(disk, DISK_SUBPATH_MAX,
 378                             "t%dd%"PRIX64, *intp, lun64);
 379                 }
 380         } else {
 381                 return (DEVFSADM_CONTINUE);
 382         }
 383
 384         disk_common(minor, node, disk, RM_STALE);
 385
 386         return (DEVFSADM_CONTINUE);
 387 }
 388
 389 /*
 390  * xVM virtual block device
 391  *
 392  * Xen passes device number in next format:
 393  *
 394  *    1 << 28 | disk << 8 | partition      xvd, disks or partitions 16 onwards
 395  *  202 <<  8 | disk << 4 | partition      xvd, disks and partitions up to 15
 396  *    8 <<  8 | disk << 4 | partition      sd, disks and partitions up to 15
 397  *    3 <<  8 | disk << 6 | partition      hd, disks 0..1, partitions 0..63
 398  *   22 <<  8 | (disk-2) << 6 | partition  hd, disks 2..3, partitions 0..63
 399  *    2 << 28 onwards                      reserved for future use
 400  *   other values less than 1 << 28        deprecated / reserved
 401  *
 402  * The corresponding Solaris /dev/dsk name can be:
 403  *
 404  *          c0tYdXsN
 405  *
 406  * where Y,X >= 0.
 407  *
 408  * For PV guests using the legacy naming (0, 1, 2, ...)
 409  * the Solaris disk names created will be c0d[0..767]sN
 410  */
 411
 412 #define HD_BASE         (3 << 8)
 413 #define XEN_EXT_SHIFT   (28)
 414
 415 /*
 416  * Return: Number of parsed and written parameters
 417  */
 418 static int
 419 decode_xen_device(uint_t device, uint_t *disk, uint_t *plun)
 420 {
 421         uint_t dsk, lun = 0;
 422         int ret = 1;
 423
 424         if ((device >> XEN_EXT_SHIFT) > 1)
 425                 return (0);
 426
 427         if (device < HD_BASE) {
 428                 /* legacy device address */
 429                 dsk = device;
 430                 goto end;
 431         }
 432
 433         ret = 2;
 434         if (device & (1 << XEN_EXT_SHIFT)) {
 435                 /* extended */
 436                 dsk = device & (~0xff);
 437                 lun = device & 0xff;
 438                 goto end;
 439         }
 440
 441         switch (device >> 8) {
 442         case 202:                               /* xvd */
 443                 dsk = (device >> 4) & 0xf;
 444                 lun =  device & 0xf;
 445                 break;
 446         case 8:                                 /* sd */
 447                 dsk = device & (~0xf);
 448                 lun = device & 0xf;
 449                 break;
 450         case 3:                                 /* hd, disk 0..1 */
 451                 dsk = device & (~0x3f);
 452                 lun = device & 0x3f;
 453                 break;
 454         case 22:                                /* hd, disk 2..3 */
 455                 dsk = device & (~0x3f);
 456                 lun = device & 0x3f;
 457                 break;
 458         default:
 459                 return (0);
 460         }
 461 end:
 462         *disk = dsk;
 463         *plun = lun;
 464         return (ret);
 465 }
 466
 467 static int
 468 disk_callback_xvmd(di_minor_t minor, di_node_t node)
 469 {
 470         char *addr;
 471         char disk[16];
 472         uint_t targ;
 473         uint_t dsk, lun;
 474         int res;
 475
 476         addr = di_bus_addr(node);
 477         targ = strtol(addr, (char **)NULL, 10);
 478
 479         res = decode_xen_device(targ, &dsk, &lun);
 480
 481         /* HVM device names are generated using the standard generator */
 482
 483         if (res == 1)
 484                 (void) snprintf(disk, sizeof (disk),  "d%d", dsk);
 485         else if (res == 2)
 486                 (void) snprintf(disk, sizeof (disk), "t%dd%d", dsk, lun);
 487         else {
 488                 devfsadm_errprint("%s: invalid disk device number (%s)\n",
 489                     modname, addr);
 490                 return (DEVFSADM_CONTINUE);
 491         }
 492         disk_common(minor, node, disk, 0);
 493         return (DEVFSADM_CONTINUE);
 494
 495 }
 496
 497 /*
 498  * This function is called for every disk minor node.
 499  * Calls enumerate to assign a logical controller number, and
 500  * then devfsadm_mklink to make the link.
 501  */
 502 static void
 503 disk_common(di_minor_t minor, di_node_t node, char *disk, int flags)
 504 {
 505         char l_path[PATH_MAX + 1];
 506         char sec_path[PATH_MAX + 1];
 507         char stale_re[DISK_SUBPATH_MAX];
 508         char *dir;
 509         char slice[4];
 510         char *mn;
 511         char *ctrl;
 512         int *int_prop;
 513         int  nflags = 0;
 514 #if defined(__i386) || defined(__amd64)
 515         char mn_copy[4];
 516         char *part;
 517         int part_num;
 518 #endif
 519
 520         mn = di_minor_name(minor);
 521         if (strstr(mn, ",raw")) {
 522                 dir = "rdsk";
 523 #if defined(__i386) || defined(__amd64)
 524                 (void) strncpy(mn_copy, mn, 4);
 525                 part = strtok(mn_copy, ",");
 526 #endif
 527         } else {
 528                 dir = "dsk";
 529 #if defined(__i386) || defined(__amd64)
 530                 part = mn;
 531 #endif
 532         }
 533
 534 #if defined(__i386) || defined(__amd64)
 535         /*
 536          * The following is a table describing the allocation of
 537          * minor numbers, minor names and /dev/dsk names for partitions
 538          * and slices on x86 systems.
 539          *
 540          *      Minor Number    Minor Name      /dev/dsk name
 541          *      ---------------------------------------------
 542          *      0 to 15         "a" to "p"      s0 to s15
 543          *      16              "q"             p0
 544          *      17 to 20        "r" to "u"      p1 to p4
 545          *      21 to 52        "p5" to "p36"   p5 to p36
 546          *
 547          */
 548         part_num = atoi(part + 1);
 549
 550         if ((mn[0] == 'p') && (part_num >= 5)) {
 551                 /* logical drive */
 552                 (void) snprintf(slice, 4, "%s", part);
 553         } else {
 554 #endif
 555         if (mn[0] < 'q') {
 556                 (void) sprintf(slice, "s%d", mn[0] - 'a');
 557         } else if (strncmp(mn, MN_EFI, 2) != 0) {
 558                 (void) sprintf(slice, "p%d", mn[0] - 'q');
 559         } else {
 560                 /* For EFI label */
 561                 (void) sprintf(slice, SLICE_EFI);
 562         }
 563 #if defined(__i386) || defined(__amd64)
 564         }
 565 #endif
 566
 567         nflags = 0;
 568         if (reserved_links_exist(node, minor, nflags) == DEVFSADM_SUCCESS) {
 569                 devfsadm_print(disk_mid, "Reserved link exists. Not "
 570                     "creating links for slice %s\n", slice);
 571                 return;
 572         }
 573
 574         if (NULL == (ctrl = diskctrl(node, minor)))
 575                 return;
 576
 577         (void) strcpy(l_path, dir);
 578         (void) strcat(l_path, "/c");
 579         (void) strcat(l_path, ctrl);
 580         (void) strcat(l_path, disk);
 581
 582         /*
 583          * If switching between SMI and EFI label or vice versa
 584          * cleanup the previous label's devlinks.
 585          */
 586         if (*mn == *(MN_SMI) || (strncmp(mn, MN_EFI, 2) == 0)) {
 587                 char *s, tpath[PATH_MAX + 1];
 588                 struct stat sb;
 589
 590                 s = l_path + strlen(l_path);
 591                 (void) strcat(l_path, (*mn == *(MN_SMI))
 592                     ? SLICE_EFI : SLICE_SMI);
 593                 /*
 594                  * Attempt the remove only if the stale link exists
 595                  */
 596                 (void) snprintf(tpath, sizeof (tpath), "%s/dev/%s",
 597                     devfsadm_root_path(), l_path);
 598                 if (lstat(tpath, &sb) != -1)
 599                         devfsadm_rm_all(l_path);
 600                 *s = '\0';
 601         }
 602         (void) strcat(l_path, slice);
 603
 604         (void) devfsadm_mklink(l_path, node, minor, nflags);
 605
 606         /* secondary links for removable and hotpluggable devices */
 607         if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "removable-media",
 608             &int_prop) >= 0) {
 609                 (void) strcpy(sec_path, "removable-media/");
 610                 (void) strcat(sec_path, l_path);
 611                 (void) devfsadm_secondary_link(sec_path, l_path, 0);
 612         }
 613         if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "hotpluggable",
 614             &int_prop) >= 0) {
 615                 (void) strcpy(sec_path, "hotpluggable/");
 616                 (void) strcat(sec_path, l_path);
 617                 (void) devfsadm_secondary_link(sec_path, l_path, 0);
 618         }
 619
 620         if ((flags & RM_STALE) == RM_STALE) {
 621                 (void) strcpy(stale_re, "^");
 622                 (void) strcat(stale_re, dir);
 623                 (void) strcat(stale_re, "/c");
 624                 (void) strcat(stale_re, ctrl);
 625                 (void) strcat(stale_re, "t[0-9A-F]+d[0-9]+(s[0-9]+)?$");
 626                 /*
 627                  * optimizations are made inside of devfsadm_rm_stale_links
 628                  * instead of before calling the function, as it always
 629                  * needs to add the valid link to the cache.
 630                  */
 631                 devfsadm_rm_stale_links(stale_re, l_path, node, minor);
 632         }
 633
 634         free(ctrl);
 635 }
 636
 637
 638 /* index of enumeration rule applicable to this module */
 639 #define RULE_INDEX      0
 640
 641 static char *
 642 diskctrl(di_node_t node, di_minor_t minor)
 643 {
 644         char path[PATH_MAX + 1];
 645         char *devfspath;
 646         char *buf, *mn;
 647
 648         devfsadm_enumerate_t rules[3] = {
 649             {"^r?dsk$/^c([0-9]+)", 1, MATCH_PARENT},
 650             {"^cfg$/^c([0-9]+)$", 1, MATCH_ADDR},
 651             {"^scsi$/^.+$/^c([0-9]+)", 1, MATCH_PARENT}
 652         };
 653
 654         mn = di_minor_name(minor);
 655
 656         if ((devfspath = di_devfs_path(node)) == NULL) {
 657                 return (NULL);
 658         }
 659         (void) strcpy(path, devfspath);
 660         (void) strcat(path, ":");
 661         (void) strcat(path, mn);
 662         di_devfs_path_free(devfspath);
 663
 664         /*
 665          * Use controller component of disk path
 666          */
 667         if (disk_enumerate_int(path, RULE_INDEX, &buf, rules, 3) ==
 668             DEVFSADM_MULTIPLE) {
 669
 670                 /*
 671                  * We failed because there are multiple logical controller
 672                  * numbers for a single physical controller.  If we use node
 673                  * name also in the match it should fix this and only find one
 674                  * logical controller. (See 4045879).
 675                  * NOTE: Rules for controllers are not changed, as there is
 676                  * no unique controller number for them in this case.
 677                  *
 678                  * MATCH_UNCACHED flag is private to the "disks" and "sgen"
 679                  * modules. NOT to be used by other modules.
 680                  */
 681
 682                 rules[0].flags = MATCH_NODE | MATCH_UNCACHED; /* disks */
 683                 rules[2].flags = MATCH_NODE | MATCH_UNCACHED; /* generic scsi */
 684                 if (devfsadm_enumerate_int(path, RULE_INDEX, &buf, rules, 3)) {
 685                         return (NULL);
 686                 }
 687         }
 688
 689         return (buf);
 690 }
 691
 692 typedef struct dvlist {
 693         char *dv_link;
 694         struct dvlist *dv_next;
 695 } dvlist_t;
 696
 697 static void
 698 free_dvlist(dvlist_t **pp)
 699 {
 700         dvlist_t *entry;
 701
 702         while (*pp) {
 703                 entry = *pp;
 704                 *pp = entry->dv_next;
 705                 assert(entry->dv_link);
 706                 free(entry->dv_link);
 707                 free(entry);
 708         }
 709 }
 710 static int
 711 dvlink_cb(di_devlink_t devlink, void *arg)
 712 {
 713         char *path;
 714         char *can_path;
 715         dvlist_t **pp = (dvlist_t **)arg;
 716         dvlist_t *entry = NULL;
 717
 718         entry = calloc(1, sizeof (dvlist_t));
 719         if (entry == NULL) {
 720                 devfsadm_errprint("%s: calloc failed\n", modname);
 721                 goto error;
 722         }
 723
 724         path = (char *)di_devlink_path(devlink);
 725         assert(path);
 726         if (path == NULL) {
 727                 devfsadm_errprint("%s: di_devlink_path() returned NULL\n",
 728                     modname);
 729                 goto error;
 730         }
 731
 732         devfsadm_print(disk_mid, "%s: found link %s in reverse link cache\n",
 733             modname, path);
 734
 735         /*
 736          * Return linkname in canonical form i.e. without the
 737          * "/dev/" prefix
 738          */
 739         can_path = strstr(path, "/dev/");
 740         if (can_path == NULL) {
 741                 devfsadm_errprint("%s: devlink path %s has no /dev/\n",
 742                     modname, path);
 743                 goto error;
 744         }
 745
 746         entry->dv_link = s_strdup(can_path + strlen("/dev/"));
 747         entry->dv_next = *pp;
 748         *pp = entry;
 749
 750         return (DI_WALK_CONTINUE);
 751
 752 error:
 753         free(entry);
 754         free_dvlist(pp);
 755         *pp = NULL;
 756         return (DI_WALK_TERMINATE);
 757 }
 758
 759 /*
 760  * Returns success only if all goes well. If there is no matching reserved link
 761  * or if there is an error, we assume no match. It is better to err on the side
 762  * of caution by creating extra links than to miss out creating a required link.
 763  */
 764 static int
 765 reserved_links_exist(di_node_t node, di_minor_t minor, int nflags)
 766 {
 767         di_devlink_handle_t dvlink_cache = devfsadm_devlink_cache();
 768         char phys_path[PATH_MAX];
 769         char *minor_path;
 770         dvlist_t *head;
 771         dvlist_t *entry;
 772         char *s;
 773         char l[PATH_MAX];
 774         int switch_link = 0;
 775         char *mn = di_minor_name(minor);
 776
 777         if (dvlink_cache == NULL || mn == NULL) {
 778                 devfsadm_errprint("%s: No minor or devlink cache\n", modname);
 779                 return (DEVFSADM_FAILURE);
 780         }
 781
 782         if (!devfsadm_have_reserved()) {
 783                 devfsadm_print(disk_mid, "%s: No reserved links\n", modname);
 784                 return (DEVFSADM_FAILURE);
 785         }
 786
 787         minor_path = di_devfs_minor_path(minor);
 788         if (minor_path == NULL) {
 789                 devfsadm_errprint("%s: di_devfs_minor_path failed\n", modname);
 790                 return (DEVFSADM_FAILURE);
 791         }
 792
 793         (void) strlcpy(phys_path, minor_path, sizeof (phys_path));
 794
 795         di_devfs_path_free(minor_path);
 796
 797         head = NULL;
 798         (void) di_devlink_cache_walk(dvlink_cache, DISK_LINK_RE, phys_path,
 799             DI_PRIMARY_LINK, &head, dvlink_cb);
 800
 801         /*
 802          * We may be switching between EFI label and SMI label in which case
 803          * we only have minors of the other type.
 804          */
 805         if (head == NULL && (*mn == *(MN_SMI) ||
 806             (strncmp(mn, MN_EFI, 2) == 0))) {
 807                 devfsadm_print(disk_mid, "%s: No links for minor %s in /dev. "
 808                     "Trying another label\n", modname, mn);
 809                 s = strrchr(phys_path, ':');
 810                 if (s == NULL) {
 811                         devfsadm_errprint("%s: invalid minor path: %s\n",
 812                             modname, phys_path);
 813                         return (DEVFSADM_FAILURE);
 814                 }
 815                 (void) snprintf(s+1, sizeof (phys_path) - (s + 1 - phys_path),
 816                     "%s%s", *mn == *(MN_SMI) ? MN_EFI : MN_SMI,
 817                     strstr(s, ",raw") ? ",raw" : "");
 818                 (void) di_devlink_cache_walk(dvlink_cache, DISK_LINK_RE,
 819                     phys_path, DI_PRIMARY_LINK, &head, dvlink_cb);
 820         }
 821
 822         if (head == NULL) {
 823                 devfsadm_print(disk_mid, "%s: minor %s has no links in /dev\n",
 824                     modname, phys_path);
 825                 /* no links on disk */
 826                 return (DEVFSADM_FAILURE);
 827         }
 828
 829         /*
 830          * It suffices to use 1 link to this minor, since
 831          * we are matching with reserved IDs on the basis of
 832          * the controller number which will be the same for
 833          * all links to this minor.
 834          */
 835         if (!devfsadm_is_reserved(disks_re_array, head->dv_link)) {
 836                 /* not reserved links */
 837                 devfsadm_print(disk_mid, "%s: devlink %s and its minor "
 838                     "are NOT reserved\n", modname, head->dv_link);
 839                 free_dvlist(&head);
 840                 return (DEVFSADM_FAILURE);
 841         }
 842
 843         devfsadm_print(disk_mid, "%s: devlink %s and its minor are on "
 844             "reserved list\n", modname, head->dv_link);
 845
 846         /*
 847          * Switch between SMI and EFI labels if required
 848          */
 849         switch_link = 0;
 850         if (*mn == *(MN_SMI) || (strncmp(mn, MN_EFI, 2) == 0)) {
 851                 for (entry = head; entry; entry = entry->dv_next) {
 852                         s = strrchr(entry->dv_link, '/');
 853                         assert(s);
 854                         if (s == NULL) {
 855                                 devfsadm_errprint("%s: disk link %s has no "
 856                                     "directory\n", modname, entry->dv_link);
 857                                 continue;
 858                         }
 859                         if (*mn == *(MN_SMI) && strchr(s, 's') == NULL) {
 860                                 (void) snprintf(l, sizeof (l), "%s%s",
 861                                     entry->dv_link, SLICE_SMI);
 862                                 switch_link = 1;
 863                                 devfsadm_print(disk_mid, "%s: switching "
 864                                     "reserved link from EFI to SMI label. "
 865                                     "New link is %s\n", modname, l);
 866                         } else if (strncmp(mn, MN_EFI, 2) == 0 &&
 867                             (s = strchr(s, 's'))) {
 868                                 *s = '\0';
 869                                 (void) snprintf(l, sizeof (l), "%s",
 870                                     entry->dv_link);
 871                                 *s = 's';
 872                                 switch_link = 1;
 873                                 devfsadm_print(disk_mid, "%s: switching "
 874                                     "reserved link from SMI to EFI label. "
 875                                     "New link is %s\n", modname, l);
 876                         }
 877                         if (switch_link) {
 878                                 devfsadm_print(disk_mid, "%s: switching "
 879                                     "link: deleting %s and creating %s\n",
 880                                     modname, entry->dv_link, l);
 881                                 devfsadm_rm_link(entry->dv_link);
 882                                 (void) devfsadm_mklink(l, node, minor, nflags);
 883                         }
 884                 }
 885         }
 886         free_dvlist(&head);
 887
 888         /*
 889          * return SUCCESS to indicate that new links to this minor should not
 890          * be created so that only compatibility links to this minor remain.
 891          */
 892         return (DEVFSADM_SUCCESS);
 893 }