17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 545916cd2Sjpk * Common Development and Distribution License (the "License"). 645916cd2Sjpk * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22406fc510SToomas Soome * Copyright 2016 Toomas Soome <tsoome@me.com> 23*df8c2287SHans Rosenfeld * Copyright 2016 Nexenta Systems, Inc. All rights reserved. 24d88e498aSjiang wu - Sun Microsystems - Beijing China * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 257c478bd9Sstevel@tonic-gate * Use is subject to license terms. 267c478bd9Sstevel@tonic-gate */ 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #include <devfsadm.h> 297c478bd9Sstevel@tonic-gate #include <stdio.h> 307c478bd9Sstevel@tonic-gate #include <strings.h> 317c478bd9Sstevel@tonic-gate #include <stdlib.h> 327c478bd9Sstevel@tonic-gate #include <limits.h> 3397869ac5Sjhd #include <ctype.h> 34406fc510SToomas Soome #include <unistd.h> 354c06356bSdh #include <sys/int_fmtio.h> 367c478bd9Sstevel@tonic-gate #include <sys/stat.h> 3745916cd2Sjpk #include <bsm/devalloc.h> 384c06356bSdh #include <sys/scsi/scsi_address.h> 394c06356bSdh #include <sys/libdevid.h> 40406fc510SToomas Soome #include <sys/lofi.h> 417c478bd9Sstevel@tonic-gate 427c478bd9Sstevel@tonic-gate #define DISK_SUBPATH_MAX 100 437c478bd9Sstevel@tonic-gate #define RM_STALE 0x01 447c478bd9Sstevel@tonic-gate #define DISK_LINK_RE "^r?dsk/c[0-9]+(t[0-9A-F]+)?d[0-9]+(((s|p))[0-9]+)?$" 457c478bd9Sstevel@tonic-gate #define DISK_LINK_TO_UPPER(ch)\ 467c478bd9Sstevel@tonic-gate (((ch) >= 'a' && (ch) <= 'z') ? (ch - 'a' + 'A') : ch) 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate #define SLICE_SMI "s7" 497c478bd9Sstevel@tonic-gate #define SLICE_EFI "" 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate #define MN_SMI "h" 527c478bd9Sstevel@tonic-gate #define MN_EFI "wd" 537c478bd9Sstevel@tonic-gate #define ASCIIWWNSIZE 255 54aa1b14e7SSheshadri Vasudevan #if defined(__i386) || defined(__amd64) 55aa1b14e7SSheshadri Vasudevan /* 56aa1b14e7SSheshadri Vasudevan * The number of minor nodes per LUN is defined by the disk drivers. 57aa1b14e7SSheshadri Vasudevan * Currently it is set to 64. Refer CMLBUNIT_SHIFT (cmlb_impl.h) 58aa1b14e7SSheshadri Vasudevan */ 59aa1b14e7SSheshadri Vasudevan #define NUM_MINORS_PER_INSTANCE 64 60aa1b14e7SSheshadri Vasudevan #endif 61aa1b14e7SSheshadri Vasudevan 627c478bd9Sstevel@tonic-gate 6345916cd2Sjpk extern int system_labeled; 6445916cd2Sjpk 657c478bd9Sstevel@tonic-gate static int disk_callback_chan(di_minor_t minor, di_node_t node); 667c478bd9Sstevel@tonic-gate static int disk_callback_nchan(di_minor_t minor, di_node_t node); 67*df8c2287SHans Rosenfeld static int disk_callback_blkdev(di_minor_t minor, di_node_t node); 687c478bd9Sstevel@tonic-gate static int disk_callback_wwn(di_minor_t minor, di_node_t node); 6997869ac5Sjhd static int disk_callback_xvmd(di_minor_t minor, di_node_t node); 707c478bd9Sstevel@tonic-gate static int disk_callback_fabric(di_minor_t minor, di_node_t node); 71d88e498aSjiang wu - Sun Microsystems - Beijing China static int disk_callback_sas(di_minor_t minor, di_node_t node); 727c478bd9Sstevel@tonic-gate static void disk_common(di_minor_t minor, di_node_t node, char *disk, 737c478bd9Sstevel@tonic-gate int flags); 747c478bd9Sstevel@tonic-gate static char *diskctrl(di_node_t node, di_minor_t minor); 758d483882Smlf static int reserved_links_exist(di_node_t node, di_minor_t minor, int nflags); 76406fc510SToomas Soome static void disk_rm_lofi_all(char *file); 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate static devfsadm_create_t disk_cbt[] = { 804c06356bSdh { "disk", DDI_NT_BLOCK, NULL, 817c478bd9Sstevel@tonic-gate TYPE_EXACT, ILEVEL_0, disk_callback_nchan 827c478bd9Sstevel@tonic-gate }, 834c06356bSdh { "disk", DDI_NT_BLOCK_CHAN, NULL, 847c478bd9Sstevel@tonic-gate TYPE_EXACT, ILEVEL_0, disk_callback_chan 857c478bd9Sstevel@tonic-gate }, 86*df8c2287SHans Rosenfeld { "disk", DDI_NT_BLOCK_BLKDEV, NULL, 87*df8c2287SHans Rosenfeld TYPE_EXACT, ILEVEL_0, disk_callback_blkdev 88*df8c2287SHans Rosenfeld }, 894c06356bSdh { "disk", DDI_NT_BLOCK_FABRIC, NULL, 907c478bd9Sstevel@tonic-gate TYPE_EXACT, ILEVEL_0, disk_callback_fabric 917c478bd9Sstevel@tonic-gate }, 924c06356bSdh { "disk", DDI_NT_BLOCK_WWN, NULL, 937c478bd9Sstevel@tonic-gate TYPE_EXACT, ILEVEL_0, disk_callback_wwn 947c478bd9Sstevel@tonic-gate }, 954c06356bSdh { "disk", DDI_NT_BLOCK_SAS, NULL, 96d88e498aSjiang wu - Sun Microsystems - Beijing China TYPE_EXACT, ILEVEL_0, disk_callback_sas 97d88e498aSjiang wu - Sun Microsystems - Beijing China }, 984c06356bSdh { "disk", DDI_NT_CD, NULL, 997c478bd9Sstevel@tonic-gate TYPE_EXACT, ILEVEL_0, disk_callback_nchan 1007c478bd9Sstevel@tonic-gate }, 1014c06356bSdh { "disk", DDI_NT_CD_CHAN, NULL, 1027c478bd9Sstevel@tonic-gate TYPE_EXACT, ILEVEL_0, disk_callback_chan 1037c478bd9Sstevel@tonic-gate }, 1044c06356bSdh { "disk", DDI_NT_BLOCK_XVMD, NULL, 10597869ac5Sjhd TYPE_EXACT, ILEVEL_0, disk_callback_xvmd 10697869ac5Sjhd }, 1074c06356bSdh { "disk", DDI_NT_CD_XVMD, NULL, 10897869ac5Sjhd TYPE_EXACT, ILEVEL_0, disk_callback_xvmd 10997869ac5Sjhd }, 1107c478bd9Sstevel@tonic-gate }; 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate DEVFSADM_CREATE_INIT_V0(disk_cbt); 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate /* 115406fc510SToomas Soome * HOT auto cleanup of disks is done for lofi devices only. 1167c478bd9Sstevel@tonic-gate */ 1177c478bd9Sstevel@tonic-gate static devfsadm_remove_t disk_remove_cbt[] = { 118406fc510SToomas Soome { "disk", DISK_LINK_RE, RM_HOT | RM_POST | RM_ALWAYS, 119406fc510SToomas Soome ILEVEL_0, disk_rm_lofi_all 120406fc510SToomas Soome }, 1217c478bd9Sstevel@tonic-gate { "disk", DISK_LINK_RE, RM_POST, 1227c478bd9Sstevel@tonic-gate ILEVEL_0, devfsadm_rm_all 1237c478bd9Sstevel@tonic-gate } 1247c478bd9Sstevel@tonic-gate }; 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate DEVFSADM_REMOVE_INIT_V0(disk_remove_cbt); 1277c478bd9Sstevel@tonic-gate 1288d483882Smlf static devlink_re_t disks_re_array[] = { 1298d483882Smlf {"^r?dsk/c([0-9]+)", 1}, 1308d483882Smlf {"^cfg/c([0-9]+)$", 1}, 1318d483882Smlf {"^scsi/.+/c([0-9]+)", 1}, 1328d483882Smlf {NULL} 1338d483882Smlf }; 1348d483882Smlf 1358d483882Smlf static char *disk_mid = "disk_mid"; 1368d483882Smlf static char *modname = "disk_link"; 1378d483882Smlf 138406fc510SToomas Soome /* 139406fc510SToomas Soome * Check if link is from lofi by checking path from readlink(). 140406fc510SToomas Soome */ 141406fc510SToomas Soome static int 142406fc510SToomas Soome is_lofi_disk(char *file) 143406fc510SToomas Soome { 144406fc510SToomas Soome char buf[PATH_MAX + 1]; 145406fc510SToomas Soome char filepath[PATH_MAX]; 146406fc510SToomas Soome char *ptr; 147406fc510SToomas Soome ssize_t size; 148406fc510SToomas Soome 149406fc510SToomas Soome size = snprintf(filepath, sizeof (filepath), "%s/dev/%s", 150406fc510SToomas Soome devfsadm_root_path(), file); 151406fc510SToomas Soome if (size > sizeof (filepath)) 152406fc510SToomas Soome return (0); 153406fc510SToomas Soome 154406fc510SToomas Soome size = readlink(filepath, buf, sizeof (buf) - 1); 155406fc510SToomas Soome if (size == -1) 156406fc510SToomas Soome return (0); 157406fc510SToomas Soome buf[size] = '\0'; 158406fc510SToomas Soome ptr = strchr(buf, '@'); 159406fc510SToomas Soome if (ptr == NULL) 160406fc510SToomas Soome return (0); 161406fc510SToomas Soome ptr[1] = '\0'; 162406fc510SToomas Soome if (strcmp(buf, "../../devices/pseudo/lofi@") != 0) 163406fc510SToomas Soome return (0); 164406fc510SToomas Soome return (1); 165406fc510SToomas Soome } 166406fc510SToomas Soome 167406fc510SToomas Soome /* 168406fc510SToomas Soome * Wrapper around devfsadm_rm_link() for lofi devices. 169406fc510SToomas Soome */ 170406fc510SToomas Soome static void disk_rm_lofi_all(char *file) 171406fc510SToomas Soome { 172406fc510SToomas Soome if (is_lofi_disk(file)) 173406fc510SToomas Soome devfsadm_rm_link(file); 174406fc510SToomas Soome } 175406fc510SToomas Soome 1768d483882Smlf int 1778d483882Smlf minor_init() 1788d483882Smlf { 1798d483882Smlf devfsadm_print(disk_mid, 1808d483882Smlf "%s: minor_init(): Creating disks reserved ID cache\n", 1818d483882Smlf modname); 1828d483882Smlf return (devfsadm_reserve_id_cache(disks_re_array, NULL)); 1838d483882Smlf } 1848d483882Smlf 1857c478bd9Sstevel@tonic-gate static int 1867c478bd9Sstevel@tonic-gate disk_callback_chan(di_minor_t minor, di_node_t node) 1877c478bd9Sstevel@tonic-gate { 1887c478bd9Sstevel@tonic-gate char *addr; 189406fc510SToomas Soome char disk[23]; 190406fc510SToomas Soome char *driver; 191406fc510SToomas Soome uint_t targ = 0; 192406fc510SToomas Soome uint_t lun = 0; 193406fc510SToomas Soome 194406fc510SToomas Soome driver = di_driver_name(node); 195406fc510SToomas Soome if (strcmp(driver, LOFI_DRIVER_NAME) != 0) { 196406fc510SToomas Soome addr = di_bus_addr(node); 197406fc510SToomas Soome (void) sscanf(addr, "%X,%X", &targ, &lun); 198406fc510SToomas Soome } else { 199406fc510SToomas Soome targ = di_instance(node); 200406fc510SToomas Soome } 2017c478bd9Sstevel@tonic-gate 202406fc510SToomas Soome (void) snprintf(disk, sizeof (disk), "t%dd%d", targ, lun); 2037c478bd9Sstevel@tonic-gate disk_common(minor, node, disk, 0); 2047c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate static int 2097c478bd9Sstevel@tonic-gate disk_callback_nchan(di_minor_t minor, di_node_t node) 2107c478bd9Sstevel@tonic-gate { 2117c478bd9Sstevel@tonic-gate char *addr; 2127c478bd9Sstevel@tonic-gate char disk[10]; 2137c478bd9Sstevel@tonic-gate uint_t lun; 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate addr = di_bus_addr(node); 2167c478bd9Sstevel@tonic-gate (void) sscanf(addr, "%X", &lun); 2177c478bd9Sstevel@tonic-gate (void) sprintf(disk, "d%d", lun); 2187c478bd9Sstevel@tonic-gate disk_common(minor, node, disk, 0); 2197c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate } 2227c478bd9Sstevel@tonic-gate 223*df8c2287SHans Rosenfeld static int 224*df8c2287SHans Rosenfeld disk_callback_blkdev(di_minor_t minor, di_node_t node) 225*df8c2287SHans Rosenfeld { 226*df8c2287SHans Rosenfeld char *addr; 227*df8c2287SHans Rosenfeld char disk[DISK_SUBPATH_MAX]; 228*df8c2287SHans Rosenfeld uint64_t eui64; 229*df8c2287SHans Rosenfeld uint_t lun = 0; 230*df8c2287SHans Rosenfeld 231*df8c2287SHans Rosenfeld addr = di_bus_addr(node); 232*df8c2287SHans Rosenfeld (void) sscanf(addr, "w%016"PRIx64",%X", &eui64, &lun); 233*df8c2287SHans Rosenfeld (void) snprintf(disk, DISK_SUBPATH_MAX, "t%016"PRIX64"d%d", eui64, lun); 234*df8c2287SHans Rosenfeld disk_common(minor, node, disk, RM_STALE); 235*df8c2287SHans Rosenfeld return (DEVFSADM_CONTINUE); 236*df8c2287SHans Rosenfeld } 237*df8c2287SHans Rosenfeld 2387c478bd9Sstevel@tonic-gate static int 2397c478bd9Sstevel@tonic-gate disk_callback_wwn(di_minor_t minor, di_node_t node) 2407c478bd9Sstevel@tonic-gate { 2417c478bd9Sstevel@tonic-gate char disk[10]; 2427c478bd9Sstevel@tonic-gate int lun; 2437c478bd9Sstevel@tonic-gate int targ; 2447c478bd9Sstevel@tonic-gate int *intp; 2457c478bd9Sstevel@tonic-gate 2464c06356bSdh if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, SCSI_ADDR_PROP_TARGET, 2474c06356bSdh &intp) <= 0) { 2487c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 2497c478bd9Sstevel@tonic-gate } 2507c478bd9Sstevel@tonic-gate targ = *intp; 2514c06356bSdh if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, SCSI_ADDR_PROP_LUN, 2524c06356bSdh &intp) <= 0) { 253e37c6c37Scth lun = 0; 2547c478bd9Sstevel@tonic-gate } else { 255e37c6c37Scth lun = *intp; 2567c478bd9Sstevel@tonic-gate } 2577c478bd9Sstevel@tonic-gate (void) sprintf(disk, "t%dd%d", targ, lun); 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate disk_common(minor, node, disk, RM_STALE); 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 2627c478bd9Sstevel@tonic-gate } 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate static int 2657c478bd9Sstevel@tonic-gate disk_callback_fabric(di_minor_t minor, di_node_t node) 2667c478bd9Sstevel@tonic-gate { 2677c478bd9Sstevel@tonic-gate char disk[DISK_SUBPATH_MAX]; 2687c478bd9Sstevel@tonic-gate int lun; 2697c478bd9Sstevel@tonic-gate int count; 2707c478bd9Sstevel@tonic-gate int *intp; 2717c478bd9Sstevel@tonic-gate uchar_t *str; 2727c478bd9Sstevel@tonic-gate uchar_t *wwn; 2737c478bd9Sstevel@tonic-gate uchar_t ascii_wwn[ASCIIWWNSIZE]; 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, 2767c478bd9Sstevel@tonic-gate "client-guid", (char **)&wwn) > 0) { 277e37c6c37Scth if (strlcpy((char *)ascii_wwn, (char *)wwn, 278e37c6c37Scth sizeof (ascii_wwn)) >= sizeof (ascii_wwn)) { 2797c478bd9Sstevel@tonic-gate devfsadm_errprint("SUNW_disk_link: GUID too long:%d", 280e37c6c37Scth strlen((char *)wwn)); 2817c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 2827c478bd9Sstevel@tonic-gate } 2837c478bd9Sstevel@tonic-gate lun = 0; 2847c478bd9Sstevel@tonic-gate } else if (di_prop_lookup_bytes(DDI_DEV_T_ANY, node, 2857c478bd9Sstevel@tonic-gate "port-wwn", &wwn) > 0) { 2867c478bd9Sstevel@tonic-gate if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, 2874c06356bSdh SCSI_ADDR_PROP_LUN, &intp) > 0) { 2887c478bd9Sstevel@tonic-gate lun = *intp; 2897c478bd9Sstevel@tonic-gate } else { 2907c478bd9Sstevel@tonic-gate lun = 0; 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate for (count = 0, str = ascii_wwn; count < 8; count++, str += 2) { 2947c478bd9Sstevel@tonic-gate (void) sprintf((caddr_t)str, "%02x", wwn[count]); 2957c478bd9Sstevel@tonic-gate } 2967c478bd9Sstevel@tonic-gate *str = '\0'; 2977c478bd9Sstevel@tonic-gate } else { 2987c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 2997c478bd9Sstevel@tonic-gate } 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate for (str = ascii_wwn; *str != '\0'; str++) { 3027c478bd9Sstevel@tonic-gate *str = DISK_LINK_TO_UPPER(*str); 3037c478bd9Sstevel@tonic-gate } 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate (void) snprintf(disk, DISK_SUBPATH_MAX, "t%sd%d", ascii_wwn, lun); 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate disk_common(minor, node, disk, RM_STALE); 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate return (DEVFSADM_CONTINUE); 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate 312d88e498aSjiang wu - Sun Microsystems - Beijing China static int 313d88e498aSjiang wu - Sun Microsystems - Beijing China disk_callback_sas(di_minor_t minor, di_node_t node) 314d88e498aSjiang wu - Sun Microsystems - Beijing China { 315d88e498aSjiang wu - Sun Microsystems - Beijing China char disk[DISK_SUBPATH_MAX]; 3164c06356bSdh int lun64_found = 0; 3174c06356bSdh scsi_lun64_t lun64, sl; 3184c06356bSdh scsi_lun_t lun; 3194c06356bSdh int64_t *lun64p; 3204c06356bSdh uint64_t wwn; 321d88e498aSjiang wu - Sun Microsystems - Beijing China int *intp; 3224c06356bSdh char *tgt_port; 3234c06356bSdh uchar_t addr_method; 3244c06356bSdh 3254c06356bSdh /* Get lun property */ 3264c06356bSdh if (di_prop_lookup_int64(DDI_DEV_T_ANY, node, 3274c06356bSdh SCSI_ADDR_PROP_LUN64, &lun64p) > 0) { 3284c06356bSdh if (*lun64p != SCSI_LUN64_ILLEGAL) { 3294c06356bSdh lun64_found = 1; 3304c06356bSdh lun64 = (uint64_t)*lun64p; 3314c06356bSdh } 3324c06356bSdh } 3334c06356bSdh if ((!lun64_found) && (di_prop_lookup_ints(DDI_DEV_T_ANY, node, 3344c06356bSdh SCSI_ADDR_PROP_LUN, &intp) > 0)) { 3354c06356bSdh lun64 = (uint64_t)*intp; 336d88e498aSjiang wu - Sun Microsystems - Beijing China } 3374c06356bSdh 3384c06356bSdh lun = scsi_lun64_to_lun(lun64); 3394c06356bSdh 3404c06356bSdh addr_method = (lun.sl_lun1_msb & SCSI_LUN_AM_MASK); 3414c06356bSdh 342d88e498aSjiang wu - Sun Microsystems - Beijing China if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, 3434c06356bSdh SCSI_ADDR_PROP_TARGET_PORT, &tgt_port) > 0) { 3444c06356bSdh (void) scsi_wwnstr_to_wwn(tgt_port, &wwn); 3454c06356bSdh if ((addr_method == SCSI_LUN_AM_PDEV) && 3464c06356bSdh (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) && 3474c06356bSdh (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) && 3484c06356bSdh (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) { 3494c06356bSdh (void) snprintf(disk, DISK_SUBPATH_MAX, 3504c06356bSdh "t%"PRIX64"d%"PRId64, wwn, lun64); 3514c06356bSdh } else if ((addr_method == SCSI_LUN_AM_FLAT) && 3524c06356bSdh (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) && 3534c06356bSdh (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) && 3544c06356bSdh (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) { 3554c06356bSdh sl = (lun.sl_lun1_msb << 8) | lun.sl_lun1_lsb; 3564c06356bSdh (void) snprintf(disk, DISK_SUBPATH_MAX, 3574c06356bSdh "t%"PRIX64"d%"PRIX16, wwn, sl); 3584c06356bSdh } else { 3594c06356bSdh (void) snprintf(disk, DISK_SUBPATH_MAX, 3604c06356bSdh "t%"PRIX64"d%"PRIX64, wwn, lun64); 361d88e498aSjiang wu - Sun Microsystems - Beijing China } 362d88e498aSjiang wu - Sun Microsystems - Beijing China } else if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, 3634c06356bSdh SCSI_ADDR_PROP_SATA_PHY, &intp) > 0) { 3644c06356bSdh /* Use phy format naming, for SATA devices without wwn */ 3654c06356bSdh if ((addr_method == SCSI_LUN_AM_PDEV) && 3664c06356bSdh (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) && 3674c06356bSdh (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) && 3684c06356bSdh (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) { 3694c06356bSdh (void) snprintf(disk, DISK_SUBPATH_MAX, 37082bff436Sbo zhou - Sun Microsystems - Beijing China "t%dd%"PRId64, *intp, lun64); 3714c06356bSdh } else if ((addr_method == SCSI_LUN_AM_FLAT) && 3724c06356bSdh (lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) && 3734c06356bSdh (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) && 3744c06356bSdh (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) { 3754c06356bSdh sl = (lun.sl_lun1_msb << 8) | lun.sl_lun1_lsb; 3764c06356bSdh (void) snprintf(disk, DISK_SUBPATH_MAX, 37782bff436Sbo zhou - Sun Microsystems - Beijing China "t%dd%"PRIX16, *intp, sl); 3784c06356bSdh } else { 3794c06356bSdh (void) snprintf(disk, DISK_SUBPATH_MAX, 38082bff436Sbo zhou - Sun Microsystems - Beijing China "t%dd%"PRIX64, *intp, lun64); 3814c06356bSdh } 382d88e498aSjiang wu - Sun Microsystems - Beijing China } else { 383d88e498aSjiang wu - Sun Microsystems - Beijing China return (DEVFSADM_CONTINUE); 384d88e498aSjiang wu - Sun Microsystems - Beijing China } 385d88e498aSjiang wu - Sun Microsystems - Beijing China 386d88e498aSjiang wu - Sun Microsystems - Beijing China disk_common(minor, node, disk, RM_STALE); 387d88e498aSjiang wu - Sun Microsystems - Beijing China 388d88e498aSjiang wu - Sun Microsystems - Beijing China return (DEVFSADM_CONTINUE); 389d88e498aSjiang wu - Sun Microsystems - Beijing China } 390d88e498aSjiang wu - Sun Microsystems - Beijing China 39197869ac5Sjhd /* 39297869ac5Sjhd * xVM virtual block device 39397869ac5Sjhd * 394efc44fd7SVitaliy Gusev * Xen passes device number in next format: 39597869ac5Sjhd * 396efc44fd7SVitaliy Gusev * 1 << 28 | disk << 8 | partition xvd, disks or partitions 16 onwards 397efc44fd7SVitaliy Gusev * 202 << 8 | disk << 4 | partition xvd, disks and partitions up to 15 398efc44fd7SVitaliy Gusev * 8 << 8 | disk << 4 | partition sd, disks and partitions up to 15 399efc44fd7SVitaliy Gusev * 3 << 8 | disk << 6 | partition hd, disks 0..1, partitions 0..63 400efc44fd7SVitaliy Gusev * 22 << 8 | (disk-2) << 6 | partition hd, disks 2..3, partitions 0..63 401efc44fd7SVitaliy Gusev * 2 << 28 onwards reserved for future use 402efc44fd7SVitaliy Gusev * other values less than 1 << 28 deprecated / reserved 403efc44fd7SVitaliy Gusev * 404efc44fd7SVitaliy Gusev * The corresponding Solaris /dev/dsk name can be: 405efc44fd7SVitaliy Gusev * 406efc44fd7SVitaliy Gusev * c0tYdXsN 407efc44fd7SVitaliy Gusev * 408efc44fd7SVitaliy Gusev * where Y,X >= 0. 40997869ac5Sjhd * 41097869ac5Sjhd * For PV guests using the legacy naming (0, 1, 2, ...) 41197869ac5Sjhd * the Solaris disk names created will be c0d[0..767]sN 412efc44fd7SVitaliy Gusev */ 413efc44fd7SVitaliy Gusev 414efc44fd7SVitaliy Gusev #define HD_BASE (3 << 8) 415efc44fd7SVitaliy Gusev #define XEN_EXT_SHIFT (28) 416efc44fd7SVitaliy Gusev 417efc44fd7SVitaliy Gusev /* 418efc44fd7SVitaliy Gusev * Return: Number of parsed and written parameters 41997869ac5Sjhd */ 42097869ac5Sjhd static int 421efc44fd7SVitaliy Gusev decode_xen_device(uint_t device, uint_t *disk, uint_t *plun) 42297869ac5Sjhd { 423efc44fd7SVitaliy Gusev uint_t dsk, lun = 0; 424efc44fd7SVitaliy Gusev int ret = 1; 425efc44fd7SVitaliy Gusev 426efc44fd7SVitaliy Gusev if ((device >> XEN_EXT_SHIFT) > 1) 427efc44fd7SVitaliy Gusev return (0); 42897869ac5Sjhd 429efc44fd7SVitaliy Gusev if (device < HD_BASE) { 430efc44fd7SVitaliy Gusev /* legacy device address */ 431efc44fd7SVitaliy Gusev dsk = device; 432efc44fd7SVitaliy Gusev goto end; 433efc44fd7SVitaliy Gusev } 434efc44fd7SVitaliy Gusev 435efc44fd7SVitaliy Gusev ret = 2; 436efc44fd7SVitaliy Gusev if (device & (1 << XEN_EXT_SHIFT)) { 437efc44fd7SVitaliy Gusev /* extended */ 438efc44fd7SVitaliy Gusev dsk = device & (~0xff); 439efc44fd7SVitaliy Gusev lun = device & 0xff; 440efc44fd7SVitaliy Gusev goto end; 441efc44fd7SVitaliy Gusev } 442efc44fd7SVitaliy Gusev 443efc44fd7SVitaliy Gusev switch (device >> 8) { 444efc44fd7SVitaliy Gusev case 202: /* xvd */ 445efc44fd7SVitaliy Gusev dsk = (device >> 4) & 0xf; 446efc44fd7SVitaliy Gusev lun = device & 0xf; 447efc44fd7SVitaliy Gusev break; 448efc44fd7SVitaliy Gusev case 8: /* sd */ 449efc44fd7SVitaliy Gusev dsk = device & (~0xf); 450efc44fd7SVitaliy Gusev lun = device & 0xf; 451efc44fd7SVitaliy Gusev break; 452efc44fd7SVitaliy Gusev case 3: /* hd, disk 0..1 */ 453efc44fd7SVitaliy Gusev dsk = device & (~0x3f); 454efc44fd7SVitaliy Gusev lun = device & 0x3f; 455efc44fd7SVitaliy Gusev break; 456efc44fd7SVitaliy Gusev case 22: /* hd, disk 2..3 */ 457efc44fd7SVitaliy Gusev dsk = device & (~0x3f); 458efc44fd7SVitaliy Gusev lun = device & 0x3f; 459efc44fd7SVitaliy Gusev break; 460efc44fd7SVitaliy Gusev default: 461efc44fd7SVitaliy Gusev return (0); 462efc44fd7SVitaliy Gusev } 463efc44fd7SVitaliy Gusev end: 464efc44fd7SVitaliy Gusev *disk = dsk; 465efc44fd7SVitaliy Gusev *plun = lun; 466efc44fd7SVitaliy Gusev return (ret); 467efc44fd7SVitaliy Gusev } 468efc44fd7SVitaliy Gusev 469efc44fd7SVitaliy Gusev static int 470efc44fd7SVitaliy Gusev disk_callback_xvmd(di_minor_t minor, di_node_t node) 471efc44fd7SVitaliy Gusev { 47297869ac5Sjhd char *addr; 47397869ac5Sjhd char disk[16]; 47497869ac5Sjhd uint_t targ; 475efc44fd7SVitaliy Gusev uint_t dsk, lun; 476efc44fd7SVitaliy Gusev int res; 47797869ac5Sjhd 47897869ac5Sjhd addr = di_bus_addr(node); 47997869ac5Sjhd targ = strtol(addr, (char **)NULL, 10); 480efc44fd7SVitaliy Gusev 481efc44fd7SVitaliy Gusev res = decode_xen_device(targ, &dsk, &lun); 482efc44fd7SVitaliy Gusev 48397869ac5Sjhd /* HVM device names are generated using the standard generator */ 484efc44fd7SVitaliy Gusev 485efc44fd7SVitaliy Gusev if (res == 1) 486efc44fd7SVitaliy Gusev (void) snprintf(disk, sizeof (disk), "d%d", dsk); 487efc44fd7SVitaliy Gusev else if (res == 2) 488efc44fd7SVitaliy Gusev (void) snprintf(disk, sizeof (disk), "t%dd%d", dsk, lun); 489efc44fd7SVitaliy Gusev else { 49097869ac5Sjhd devfsadm_errprint("%s: invalid disk device number (%s)\n", 49197869ac5Sjhd modname, addr); 49297869ac5Sjhd return (DEVFSADM_CONTINUE); 49397869ac5Sjhd } 49497869ac5Sjhd disk_common(minor, node, disk, 0); 49597869ac5Sjhd return (DEVFSADM_CONTINUE); 49697869ac5Sjhd 49797869ac5Sjhd } 49897869ac5Sjhd 4997c478bd9Sstevel@tonic-gate /* 5007c478bd9Sstevel@tonic-gate * This function is called for every disk minor node. 5017c478bd9Sstevel@tonic-gate * Calls enumerate to assign a logical controller number, and 5027c478bd9Sstevel@tonic-gate * then devfsadm_mklink to make the link. 5037c478bd9Sstevel@tonic-gate */ 5047c478bd9Sstevel@tonic-gate static void 5057c478bd9Sstevel@tonic-gate disk_common(di_minor_t minor, di_node_t node, char *disk, int flags) 5067c478bd9Sstevel@tonic-gate { 5077c478bd9Sstevel@tonic-gate char l_path[PATH_MAX + 1]; 50818c2aff7Sartem char sec_path[PATH_MAX + 1]; 5097c478bd9Sstevel@tonic-gate char stale_re[DISK_SUBPATH_MAX]; 5107c478bd9Sstevel@tonic-gate char *dir; 5117c478bd9Sstevel@tonic-gate char slice[4]; 5127c478bd9Sstevel@tonic-gate char *mn; 5137c478bd9Sstevel@tonic-gate char *ctrl; 51445916cd2Sjpk char *nt = NULL; 51518c2aff7Sartem int *int_prop; 51645916cd2Sjpk int nflags = 0; 517aa1b14e7SSheshadri Vasudevan #if defined(__i386) || defined(__amd64) 518aa1b14e7SSheshadri Vasudevan char mn_copy[4]; 519aa1b14e7SSheshadri Vasudevan char *part; 520aa1b14e7SSheshadri Vasudevan int part_num; 521aa1b14e7SSheshadri Vasudevan #endif 522aa1b14e7SSheshadri Vasudevan 523aa1b14e7SSheshadri Vasudevan mn = di_minor_name(minor); 524aa1b14e7SSheshadri Vasudevan if (strstr(mn, ",raw")) { 5257c478bd9Sstevel@tonic-gate dir = "rdsk"; 526aa1b14e7SSheshadri Vasudevan #if defined(__i386) || defined(__amd64) 527aa1b14e7SSheshadri Vasudevan (void) strncpy(mn_copy, mn, 4); 528aa1b14e7SSheshadri Vasudevan part = strtok(mn_copy, ","); 529aa1b14e7SSheshadri Vasudevan #endif 5307c478bd9Sstevel@tonic-gate } else { 5317c478bd9Sstevel@tonic-gate dir = "dsk"; 532aa1b14e7SSheshadri Vasudevan #if defined(__i386) || defined(__amd64) 533aa1b14e7SSheshadri Vasudevan part = mn; 534aa1b14e7SSheshadri Vasudevan #endif 5357c478bd9Sstevel@tonic-gate } 5367c478bd9Sstevel@tonic-gate 537aa1b14e7SSheshadri Vasudevan #if defined(__i386) || defined(__amd64) 538aa1b14e7SSheshadri Vasudevan /* 539aa1b14e7SSheshadri Vasudevan * The following is a table describing the allocation of 540aa1b14e7SSheshadri Vasudevan * minor numbers, minor names and /dev/dsk names for partitions 541aa1b14e7SSheshadri Vasudevan * and slices on x86 systems. 542aa1b14e7SSheshadri Vasudevan * 543aa1b14e7SSheshadri Vasudevan * Minor Number Minor Name /dev/dsk name 544aa1b14e7SSheshadri Vasudevan * --------------------------------------------- 545aa1b14e7SSheshadri Vasudevan * 0 to 15 "a" to "p" s0 to s15 546aa1b14e7SSheshadri Vasudevan * 16 "q" p0 547aa1b14e7SSheshadri Vasudevan * 17 to 20 "r" to "u" p1 to p4 548aa1b14e7SSheshadri Vasudevan * 21 to 52 "p5" to "p36" p5 to p36 549aa1b14e7SSheshadri Vasudevan * 550aa1b14e7SSheshadri Vasudevan */ 551aa1b14e7SSheshadri Vasudevan part_num = atoi(part + 1); 552aa1b14e7SSheshadri Vasudevan 553aa1b14e7SSheshadri Vasudevan if ((mn[0] == 'p') && (part_num >= 5)) { 554aa1b14e7SSheshadri Vasudevan /* logical drive */ 555aa1b14e7SSheshadri Vasudevan (void) snprintf(slice, 4, "%s", part); 556aa1b14e7SSheshadri Vasudevan } else { 557aa1b14e7SSheshadri Vasudevan #endif 558aa1b14e7SSheshadri Vasudevan if (mn[0] < 'q') { 5597c478bd9Sstevel@tonic-gate (void) sprintf(slice, "s%d", mn[0] - 'a'); 5607c478bd9Sstevel@tonic-gate } else if (strncmp(mn, MN_EFI, 2) != 0) { 5617c478bd9Sstevel@tonic-gate (void) sprintf(slice, "p%d", mn[0] - 'q'); 5627c478bd9Sstevel@tonic-gate } else { 5637c478bd9Sstevel@tonic-gate /* For EFI label */ 5647c478bd9Sstevel@tonic-gate (void) sprintf(slice, SLICE_EFI); 5657c478bd9Sstevel@tonic-gate } 566aa1b14e7SSheshadri Vasudevan #if defined(__i386) || defined(__amd64) 567aa1b14e7SSheshadri Vasudevan } 568aa1b14e7SSheshadri Vasudevan #endif 5697c478bd9Sstevel@tonic-gate 5708d483882Smlf nflags = 0; 5718d483882Smlf if (system_labeled) { 5728d483882Smlf nt = di_minor_nodetype(minor); 5738d483882Smlf if ((nt != NULL) && 5748d483882Smlf ((strcmp(nt, DDI_NT_CD) == 0) || 5758d483882Smlf (strcmp(nt, DDI_NT_CD_CHAN) == 0) || 5768d483882Smlf (strcmp(nt, DDI_NT_BLOCK_CHAN) == 0))) { 5778d483882Smlf nflags = DA_ADD|DA_CD; 5788d483882Smlf } 5798d483882Smlf } 5808d483882Smlf 5818d483882Smlf if (reserved_links_exist(node, minor, nflags) == DEVFSADM_SUCCESS) { 5828d483882Smlf devfsadm_print(disk_mid, "Reserved link exists. Not " 5838d483882Smlf "creating links for slice %s\n", slice); 5848d483882Smlf return; 5858d483882Smlf } 5868d483882Smlf 5877c478bd9Sstevel@tonic-gate if (NULL == (ctrl = diskctrl(node, minor))) 5887c478bd9Sstevel@tonic-gate return; 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate (void) strcpy(l_path, dir); 5917c478bd9Sstevel@tonic-gate (void) strcat(l_path, "/c"); 5927c478bd9Sstevel@tonic-gate (void) strcat(l_path, ctrl); 5937c478bd9Sstevel@tonic-gate (void) strcat(l_path, disk); 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate /* 5967c478bd9Sstevel@tonic-gate * If switching between SMI and EFI label or vice versa 5977c478bd9Sstevel@tonic-gate * cleanup the previous label's devlinks. 5987c478bd9Sstevel@tonic-gate */ 5997c478bd9Sstevel@tonic-gate if (*mn == *(MN_SMI) || (strncmp(mn, MN_EFI, 2) == 0)) { 6007c478bd9Sstevel@tonic-gate char *s, tpath[PATH_MAX + 1]; 6017c478bd9Sstevel@tonic-gate struct stat sb; 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate s = l_path + strlen(l_path); 6047c478bd9Sstevel@tonic-gate (void) strcat(l_path, (*mn == *(MN_SMI)) 6057c478bd9Sstevel@tonic-gate ? SLICE_EFI : SLICE_SMI); 6067c478bd9Sstevel@tonic-gate /* 6077c478bd9Sstevel@tonic-gate * Attempt the remove only if the stale link exists 6087c478bd9Sstevel@tonic-gate */ 6097c478bd9Sstevel@tonic-gate (void) snprintf(tpath, sizeof (tpath), "%s/dev/%s", 6107c478bd9Sstevel@tonic-gate devfsadm_root_path(), l_path); 6117c478bd9Sstevel@tonic-gate if (lstat(tpath, &sb) != -1) 6127c478bd9Sstevel@tonic-gate devfsadm_rm_all(l_path); 6137c478bd9Sstevel@tonic-gate *s = '\0'; 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate (void) strcat(l_path, slice); 6167c478bd9Sstevel@tonic-gate 61745916cd2Sjpk (void) devfsadm_mklink(l_path, node, minor, nflags); 6187c478bd9Sstevel@tonic-gate 61918c2aff7Sartem /* secondary links for removable and hotpluggable devices */ 62018c2aff7Sartem if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "removable-media", 62118c2aff7Sartem &int_prop) >= 0) { 62218c2aff7Sartem (void) strcpy(sec_path, "removable-media/"); 62318c2aff7Sartem (void) strcat(sec_path, l_path); 62418c2aff7Sartem (void) devfsadm_secondary_link(sec_path, l_path, 0); 6257544909dSartem } 6267544909dSartem if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "hotpluggable", 62718c2aff7Sartem &int_prop) >= 0) { 62818c2aff7Sartem (void) strcpy(sec_path, "hotpluggable/"); 62918c2aff7Sartem (void) strcat(sec_path, l_path); 63018c2aff7Sartem (void) devfsadm_secondary_link(sec_path, l_path, 0); 63118c2aff7Sartem } 63218c2aff7Sartem 6337c478bd9Sstevel@tonic-gate if ((flags & RM_STALE) == RM_STALE) { 6347c478bd9Sstevel@tonic-gate (void) strcpy(stale_re, "^"); 6357c478bd9Sstevel@tonic-gate (void) strcat(stale_re, dir); 6367c478bd9Sstevel@tonic-gate (void) strcat(stale_re, "/c"); 6377c478bd9Sstevel@tonic-gate (void) strcat(stale_re, ctrl); 6387c478bd9Sstevel@tonic-gate (void) strcat(stale_re, "t[0-9A-F]+d[0-9]+(s[0-9]+)?$"); 6397c478bd9Sstevel@tonic-gate /* 6407c478bd9Sstevel@tonic-gate * optimizations are made inside of devfsadm_rm_stale_links 6417c478bd9Sstevel@tonic-gate * instead of before calling the function, as it always 6427c478bd9Sstevel@tonic-gate * needs to add the valid link to the cache. 6437c478bd9Sstevel@tonic-gate */ 6447c478bd9Sstevel@tonic-gate devfsadm_rm_stale_links(stale_re, l_path, node, minor); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate free(ctrl); 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate 6517c478bd9Sstevel@tonic-gate /* index of enumeration rule applicable to this module */ 6527c478bd9Sstevel@tonic-gate #define RULE_INDEX 0 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate static char * 6557c478bd9Sstevel@tonic-gate diskctrl(di_node_t node, di_minor_t minor) 6567c478bd9Sstevel@tonic-gate { 6577c478bd9Sstevel@tonic-gate char path[PATH_MAX + 1]; 6587c478bd9Sstevel@tonic-gate char *devfspath; 6597c478bd9Sstevel@tonic-gate char *buf, *mn; 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate devfsadm_enumerate_t rules[3] = { 6627c478bd9Sstevel@tonic-gate {"^r?dsk$/^c([0-9]+)", 1, MATCH_PARENT}, 6637c478bd9Sstevel@tonic-gate {"^cfg$/^c([0-9]+)$", 1, MATCH_ADDR}, 6647c478bd9Sstevel@tonic-gate {"^scsi$/^.+$/^c([0-9]+)", 1, MATCH_PARENT} 6657c478bd9Sstevel@tonic-gate }; 6667c478bd9Sstevel@tonic-gate 6677c478bd9Sstevel@tonic-gate mn = di_minor_name(minor); 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate if ((devfspath = di_devfs_path(node)) == NULL) { 6707c478bd9Sstevel@tonic-gate return (NULL); 6717c478bd9Sstevel@tonic-gate } 6727c478bd9Sstevel@tonic-gate (void) strcpy(path, devfspath); 6737c478bd9Sstevel@tonic-gate (void) strcat(path, ":"); 6747c478bd9Sstevel@tonic-gate (void) strcat(path, mn); 6757c478bd9Sstevel@tonic-gate di_devfs_path_free(devfspath); 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate /* 6787c478bd9Sstevel@tonic-gate * Use controller component of disk path 6797c478bd9Sstevel@tonic-gate */ 6807c478bd9Sstevel@tonic-gate if (disk_enumerate_int(path, RULE_INDEX, &buf, rules, 3) == 6817c478bd9Sstevel@tonic-gate DEVFSADM_MULTIPLE) { 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * We failed because there are multiple logical controller 6857c478bd9Sstevel@tonic-gate * numbers for a single physical controller. If we use node 6867c478bd9Sstevel@tonic-gate * name also in the match it should fix this and only find one 6877c478bd9Sstevel@tonic-gate * logical controller. (See 4045879). 6887c478bd9Sstevel@tonic-gate * NOTE: Rules for controllers are not changed, as there is 6897c478bd9Sstevel@tonic-gate * no unique controller number for them in this case. 6907c478bd9Sstevel@tonic-gate * 6917c478bd9Sstevel@tonic-gate * MATCH_UNCACHED flag is private to the "disks" and "sgen" 6927c478bd9Sstevel@tonic-gate * modules. NOT to be used by other modules. 6937c478bd9Sstevel@tonic-gate */ 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate rules[0].flags = MATCH_NODE | MATCH_UNCACHED; /* disks */ 6967c478bd9Sstevel@tonic-gate rules[2].flags = MATCH_NODE | MATCH_UNCACHED; /* generic scsi */ 6977c478bd9Sstevel@tonic-gate if (devfsadm_enumerate_int(path, RULE_INDEX, &buf, rules, 3)) { 6987c478bd9Sstevel@tonic-gate return (NULL); 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate return (buf); 7037c478bd9Sstevel@tonic-gate } 7048d483882Smlf 7058d483882Smlf typedef struct dvlist { 7068d483882Smlf char *dv_link; 7078d483882Smlf struct dvlist *dv_next; 7088d483882Smlf } dvlist_t; 7098d483882Smlf 7108d483882Smlf static void 7118d483882Smlf free_dvlist(dvlist_t **pp) 7128d483882Smlf { 7138d483882Smlf dvlist_t *entry; 7148d483882Smlf 7158d483882Smlf while (*pp) { 7168d483882Smlf entry = *pp; 7178d483882Smlf *pp = entry->dv_next; 7188d483882Smlf assert(entry->dv_link); 7198d483882Smlf free(entry->dv_link); 7208d483882Smlf free(entry); 7218d483882Smlf } 7228d483882Smlf } 7238d483882Smlf static int 7248d483882Smlf dvlink_cb(di_devlink_t devlink, void *arg) 7258d483882Smlf { 7268d483882Smlf char *path; 7278d483882Smlf char *can_path; 7288d483882Smlf dvlist_t **pp = (dvlist_t **)arg; 7298d483882Smlf dvlist_t *entry = NULL; 7308d483882Smlf 7318d483882Smlf entry = calloc(1, sizeof (dvlist_t)); 7328d483882Smlf if (entry == NULL) { 7338d483882Smlf devfsadm_errprint("%s: calloc failed\n", modname); 7348d483882Smlf goto error; 7358d483882Smlf } 7368d483882Smlf 7378d483882Smlf path = (char *)di_devlink_path(devlink); 7388d483882Smlf assert(path); 7398d483882Smlf if (path == NULL) { 7408d483882Smlf devfsadm_errprint("%s: di_devlink_path() returned NULL\n", 7418d483882Smlf modname); 7428d483882Smlf goto error; 7438d483882Smlf } 7448d483882Smlf 7458d483882Smlf devfsadm_print(disk_mid, "%s: found link %s in reverse link cache\n", 7468d483882Smlf modname, path); 7478d483882Smlf 7488d483882Smlf /* 7498d483882Smlf * Return linkname in canonical form i.e. without the 7508d483882Smlf * "/dev/" prefix 7518d483882Smlf */ 7528d483882Smlf can_path = strstr(path, "/dev/"); 7538d483882Smlf if (can_path == NULL) { 7548d483882Smlf devfsadm_errprint("%s: devlink path %s has no /dev/\n", 7558d483882Smlf modname, path); 7568d483882Smlf goto error; 7578d483882Smlf } 7588d483882Smlf 7598d483882Smlf entry->dv_link = s_strdup(can_path + strlen("/dev/")); 7608d483882Smlf entry->dv_next = *pp; 7618d483882Smlf *pp = entry; 7628d483882Smlf 7638d483882Smlf return (DI_WALK_CONTINUE); 7648d483882Smlf 7658d483882Smlf error: 7668d483882Smlf free(entry); 7678d483882Smlf free_dvlist(pp); 7688d483882Smlf *pp = NULL; 7698d483882Smlf return (DI_WALK_TERMINATE); 7708d483882Smlf } 7718d483882Smlf 7728d483882Smlf /* 7738d483882Smlf * Returns success only if all goes well. If there is no matching reserved link 7748d483882Smlf * or if there is an error, we assume no match. It is better to err on the side 7758d483882Smlf * of caution by creating extra links than to miss out creating a required link. 7768d483882Smlf */ 7778d483882Smlf static int 7788d483882Smlf reserved_links_exist(di_node_t node, di_minor_t minor, int nflags) 7798d483882Smlf { 7808d483882Smlf di_devlink_handle_t dvlink_cache = devfsadm_devlink_cache(); 7818d483882Smlf char phys_path[PATH_MAX]; 7828d483882Smlf char *minor_path; 7838d483882Smlf dvlist_t *head; 7848d483882Smlf dvlist_t *entry; 7858d483882Smlf char *s; 7868d483882Smlf char l[PATH_MAX]; 7878d483882Smlf int switch_link = 0; 7888d483882Smlf char *mn = di_minor_name(minor); 7898d483882Smlf 7908d483882Smlf if (dvlink_cache == NULL || mn == NULL) { 7918d483882Smlf devfsadm_errprint("%s: No minor or devlink cache\n", modname); 7928d483882Smlf return (DEVFSADM_FAILURE); 7938d483882Smlf } 7948d483882Smlf 795e37c6c37Scth if (!devfsadm_have_reserved()) { 796e37c6c37Scth devfsadm_print(disk_mid, "%s: No reserved links\n", modname); 7978d483882Smlf return (DEVFSADM_FAILURE); 7988d483882Smlf } 7998d483882Smlf 8008d483882Smlf minor_path = di_devfs_minor_path(minor); 8018d483882Smlf if (minor_path == NULL) { 8028d483882Smlf devfsadm_errprint("%s: di_devfs_minor_path failed\n", modname); 8038d483882Smlf return (DEVFSADM_FAILURE); 8048d483882Smlf } 8058d483882Smlf 8068d483882Smlf (void) strlcpy(phys_path, minor_path, sizeof (phys_path)); 8078d483882Smlf 8088d483882Smlf di_devfs_path_free(minor_path); 8098d483882Smlf 8108d483882Smlf head = NULL; 8118d483882Smlf (void) di_devlink_cache_walk(dvlink_cache, DISK_LINK_RE, phys_path, 8128d483882Smlf DI_PRIMARY_LINK, &head, dvlink_cb); 8138d483882Smlf 8148d483882Smlf /* 8158d483882Smlf * We may be switching between EFI label and SMI label in which case 8168d483882Smlf * we only have minors of the other type. 8178d483882Smlf */ 8188d483882Smlf if (head == NULL && (*mn == *(MN_SMI) || 8198d483882Smlf (strncmp(mn, MN_EFI, 2) == 0))) { 8208d483882Smlf devfsadm_print(disk_mid, "%s: No links for minor %s in /dev. " 8218d483882Smlf "Trying another label\n", modname, mn); 8228d483882Smlf s = strrchr(phys_path, ':'); 8238d483882Smlf if (s == NULL) { 8248d483882Smlf devfsadm_errprint("%s: invalid minor path: %s\n", 8258d483882Smlf modname, phys_path); 8268d483882Smlf return (DEVFSADM_FAILURE); 8278d483882Smlf } 8288d483882Smlf (void) snprintf(s+1, sizeof (phys_path) - (s + 1 - phys_path), 829e37c6c37Scth "%s%s", *mn == *(MN_SMI) ? MN_EFI : MN_SMI, 830e37c6c37Scth strstr(s, ",raw") ? ",raw" : ""); 8318d483882Smlf (void) di_devlink_cache_walk(dvlink_cache, DISK_LINK_RE, 8328d483882Smlf phys_path, DI_PRIMARY_LINK, &head, dvlink_cb); 8338d483882Smlf } 8348d483882Smlf 8358d483882Smlf if (head == NULL) { 8368d483882Smlf devfsadm_print(disk_mid, "%s: minor %s has no links in /dev\n", 8378d483882Smlf modname, phys_path); 8388d483882Smlf /* no links on disk */ 8398d483882Smlf return (DEVFSADM_FAILURE); 8408d483882Smlf } 8418d483882Smlf 8428d483882Smlf /* 8438d483882Smlf * It suffices to use 1 link to this minor, since 8448d483882Smlf * we are matching with reserved IDs on the basis of 8458d483882Smlf * the controller number which will be the same for 8468d483882Smlf * all links to this minor. 8478d483882Smlf */ 8488d483882Smlf if (!devfsadm_is_reserved(disks_re_array, head->dv_link)) { 8498d483882Smlf /* not reserved links */ 8508d483882Smlf devfsadm_print(disk_mid, "%s: devlink %s and its minor " 8518d483882Smlf "are NOT reserved\n", modname, head->dv_link); 8528d483882Smlf free_dvlist(&head); 8538d483882Smlf return (DEVFSADM_FAILURE); 8548d483882Smlf } 8558d483882Smlf 8568d483882Smlf devfsadm_print(disk_mid, "%s: devlink %s and its minor are on " 8578d483882Smlf "reserved list\n", modname, head->dv_link); 8588d483882Smlf 8598d483882Smlf /* 8608d483882Smlf * Switch between SMI and EFI labels if required 8618d483882Smlf */ 8628d483882Smlf switch_link = 0; 8638d483882Smlf if (*mn == *(MN_SMI) || (strncmp(mn, MN_EFI, 2) == 0)) { 8648d483882Smlf for (entry = head; entry; entry = entry->dv_next) { 8658d483882Smlf s = strrchr(entry->dv_link, '/'); 8668d483882Smlf assert(s); 8678d483882Smlf if (s == NULL) { 8688d483882Smlf devfsadm_errprint("%s: disk link %s has no " 8698d483882Smlf "directory\n", modname, entry->dv_link); 8708d483882Smlf continue; 8718d483882Smlf } 8728d483882Smlf if (*mn == *(MN_SMI) && strchr(s, 's') == NULL) { 8738d483882Smlf (void) snprintf(l, sizeof (l), "%s%s", 8748d483882Smlf entry->dv_link, SLICE_SMI); 8758d483882Smlf switch_link = 1; 8768d483882Smlf devfsadm_print(disk_mid, "%s: switching " 8778d483882Smlf "reserved link from EFI to SMI label. " 8788d483882Smlf "New link is %s\n", modname, l); 8798d483882Smlf } else if (strncmp(mn, MN_EFI, 2) == 0 && 8808d483882Smlf (s = strchr(s, 's'))) { 8818d483882Smlf *s = '\0'; 8828d483882Smlf (void) snprintf(l, sizeof (l), "%s", 8838d483882Smlf entry->dv_link); 8848d483882Smlf *s = 's'; 8858d483882Smlf switch_link = 1; 8868d483882Smlf devfsadm_print(disk_mid, "%s: switching " 8878d483882Smlf "reserved link from SMI to EFI label. " 8888d483882Smlf "New link is %s\n", modname, l); 8898d483882Smlf } 8908d483882Smlf if (switch_link) { 8918d483882Smlf devfsadm_print(disk_mid, "%s: switching " 8928d483882Smlf "link: deleting %s and creating %s\n", 8938d483882Smlf modname, entry->dv_link, l); 8948d483882Smlf devfsadm_rm_link(entry->dv_link); 8958d483882Smlf (void) devfsadm_mklink(l, node, minor, nflags); 8968d483882Smlf } 8978d483882Smlf } 8988d483882Smlf } 8998d483882Smlf free_dvlist(&head); 9008d483882Smlf 9018d483882Smlf /* 9028d483882Smlf * return SUCCESS to indicate that new links to this minor should not 9038d483882Smlf * be created so that only compatibility links to this minor remain. 9048d483882Smlf */ 9058d483882Smlf return (DEVFSADM_SUCCESS); 9068d483882Smlf } 907