xref: /illumos-gate/usr/src/cmd/devfsadm/disk_link.c (revision e37c6c37)
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 /*
22*e37c6c37Scth  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
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>
337c478bd9Sstevel@tonic-gate #include <sys/stat.h>
3445916cd2Sjpk #include <bsm/devalloc.h>
357c478bd9Sstevel@tonic-gate 
367c478bd9Sstevel@tonic-gate #define	DISK_SUBPATH_MAX 100
377c478bd9Sstevel@tonic-gate #define	RM_STALE 0x01
387c478bd9Sstevel@tonic-gate #define	DISK_LINK_RE	"^r?dsk/c[0-9]+(t[0-9A-F]+)?d[0-9]+(((s|p))[0-9]+)?$"
397c478bd9Sstevel@tonic-gate #define	DISK_LINK_TO_UPPER(ch)\
407c478bd9Sstevel@tonic-gate 	(((ch) >= 'a' && (ch) <= 'z') ? (ch - 'a' + 'A') : ch)
417c478bd9Sstevel@tonic-gate 
427c478bd9Sstevel@tonic-gate #define	SLICE_SMI	"s7"
437c478bd9Sstevel@tonic-gate #define	SLICE_EFI	""
447c478bd9Sstevel@tonic-gate 
457c478bd9Sstevel@tonic-gate #define	MN_SMI		"h"
467c478bd9Sstevel@tonic-gate #define	MN_EFI		"wd"
477c478bd9Sstevel@tonic-gate #define	ASCIIWWNSIZE	255
487c478bd9Sstevel@tonic-gate 
4945916cd2Sjpk extern int system_labeled;
5045916cd2Sjpk 
517c478bd9Sstevel@tonic-gate static int disk_callback_chan(di_minor_t minor, di_node_t node);
527c478bd9Sstevel@tonic-gate static int disk_callback_nchan(di_minor_t minor, di_node_t node);
537c478bd9Sstevel@tonic-gate static int disk_callback_wwn(di_minor_t minor, di_node_t node);
547c478bd9Sstevel@tonic-gate static int disk_callback_fabric(di_minor_t minor, di_node_t node);
557c478bd9Sstevel@tonic-gate static void disk_common(di_minor_t minor, di_node_t node, char *disk,
567c478bd9Sstevel@tonic-gate 				int flags);
577c478bd9Sstevel@tonic-gate static char *diskctrl(di_node_t node, di_minor_t minor);
588d483882Smlf static int reserved_links_exist(di_node_t node, di_minor_t minor, int nflags);
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate 
617c478bd9Sstevel@tonic-gate static devfsadm_create_t disk_cbt[] = {
627c478bd9Sstevel@tonic-gate 	{ "disk", "ddi_block", NULL,
637c478bd9Sstevel@tonic-gate 	    TYPE_EXACT, ILEVEL_0, disk_callback_nchan
647c478bd9Sstevel@tonic-gate 	},
657c478bd9Sstevel@tonic-gate 	{ "disk", "ddi_block:channel", NULL,
667c478bd9Sstevel@tonic-gate 	    TYPE_EXACT, ILEVEL_0, disk_callback_chan
677c478bd9Sstevel@tonic-gate 	},
687c478bd9Sstevel@tonic-gate 	{ "disk", "ddi_block:fabric", NULL,
697c478bd9Sstevel@tonic-gate 		TYPE_EXACT, ILEVEL_0, disk_callback_fabric
707c478bd9Sstevel@tonic-gate 	},
717c478bd9Sstevel@tonic-gate 	{ "disk", "ddi_block:wwn", NULL,
727c478bd9Sstevel@tonic-gate 	    TYPE_EXACT, ILEVEL_0, disk_callback_wwn
737c478bd9Sstevel@tonic-gate 	},
747c478bd9Sstevel@tonic-gate 	{ "disk", "ddi_block:cdrom", NULL,
757c478bd9Sstevel@tonic-gate 	    TYPE_EXACT, ILEVEL_0, disk_callback_nchan
767c478bd9Sstevel@tonic-gate 	},
777c478bd9Sstevel@tonic-gate 	{ "disk", "ddi_block:cdrom:channel", NULL,
787c478bd9Sstevel@tonic-gate 	    TYPE_EXACT, ILEVEL_0, disk_callback_chan
797c478bd9Sstevel@tonic-gate 	},
807c478bd9Sstevel@tonic-gate };
817c478bd9Sstevel@tonic-gate 
827c478bd9Sstevel@tonic-gate DEVFSADM_CREATE_INIT_V0(disk_cbt);
837c478bd9Sstevel@tonic-gate 
847c478bd9Sstevel@tonic-gate /*
857c478bd9Sstevel@tonic-gate  * HOT auto cleanup of disks not desired.
867c478bd9Sstevel@tonic-gate  */
877c478bd9Sstevel@tonic-gate static devfsadm_remove_t disk_remove_cbt[] = {
887c478bd9Sstevel@tonic-gate 	{ "disk", DISK_LINK_RE, RM_POST,
897c478bd9Sstevel@tonic-gate 		ILEVEL_0, devfsadm_rm_all
907c478bd9Sstevel@tonic-gate 	}
917c478bd9Sstevel@tonic-gate };
927c478bd9Sstevel@tonic-gate 
937c478bd9Sstevel@tonic-gate DEVFSADM_REMOVE_INIT_V0(disk_remove_cbt);
947c478bd9Sstevel@tonic-gate 
958d483882Smlf static devlink_re_t disks_re_array[] = {
968d483882Smlf 	{"^r?dsk/c([0-9]+)", 1},
978d483882Smlf 	{"^cfg/c([0-9]+)$", 1},
988d483882Smlf 	{"^scsi/.+/c([0-9]+)", 1},
998d483882Smlf 	{NULL}
1008d483882Smlf };
1018d483882Smlf 
1028d483882Smlf static char *disk_mid = "disk_mid";
1038d483882Smlf static char *modname = "disk_link";
1048d483882Smlf 
1058d483882Smlf int
1068d483882Smlf minor_init()
1078d483882Smlf {
1088d483882Smlf 	devfsadm_print(disk_mid,
1098d483882Smlf 	    "%s: minor_init(): Creating disks reserved ID cache\n",
1108d483882Smlf 	    modname);
1118d483882Smlf 	return (devfsadm_reserve_id_cache(disks_re_array, NULL));
1128d483882Smlf }
1138d483882Smlf 
1147c478bd9Sstevel@tonic-gate static int
1157c478bd9Sstevel@tonic-gate disk_callback_chan(di_minor_t minor, di_node_t node)
1167c478bd9Sstevel@tonic-gate {
1177c478bd9Sstevel@tonic-gate 	char *addr;
1187c478bd9Sstevel@tonic-gate 	char disk[20];
1197c478bd9Sstevel@tonic-gate 	uint_t targ;
1207c478bd9Sstevel@tonic-gate 	uint_t lun;
1217c478bd9Sstevel@tonic-gate 
1227c478bd9Sstevel@tonic-gate 	addr = di_bus_addr(node);
1237c478bd9Sstevel@tonic-gate 	(void) sscanf(addr, "%X,%X", &targ, &lun);
1247c478bd9Sstevel@tonic-gate 	(void) sprintf(disk, "t%dd%d", targ, lun);
1257c478bd9Sstevel@tonic-gate 	disk_common(minor, node, disk, 0);
1267c478bd9Sstevel@tonic-gate 	return (DEVFSADM_CONTINUE);
1277c478bd9Sstevel@tonic-gate 
1287c478bd9Sstevel@tonic-gate }
1297c478bd9Sstevel@tonic-gate 
1307c478bd9Sstevel@tonic-gate static int
1317c478bd9Sstevel@tonic-gate disk_callback_nchan(di_minor_t minor, di_node_t node)
1327c478bd9Sstevel@tonic-gate {
1337c478bd9Sstevel@tonic-gate 	char *addr;
1347c478bd9Sstevel@tonic-gate 	char disk[10];
1357c478bd9Sstevel@tonic-gate 	uint_t lun;
1367c478bd9Sstevel@tonic-gate 
1377c478bd9Sstevel@tonic-gate 	addr = di_bus_addr(node);
1387c478bd9Sstevel@tonic-gate 	(void) sscanf(addr, "%X", &lun);
1397c478bd9Sstevel@tonic-gate 	(void) sprintf(disk, "d%d", lun);
1407c478bd9Sstevel@tonic-gate 	disk_common(minor, node, disk, 0);
1417c478bd9Sstevel@tonic-gate 	return (DEVFSADM_CONTINUE);
1427c478bd9Sstevel@tonic-gate 
1437c478bd9Sstevel@tonic-gate }
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate static int
1467c478bd9Sstevel@tonic-gate disk_callback_wwn(di_minor_t minor, di_node_t node)
1477c478bd9Sstevel@tonic-gate {
1487c478bd9Sstevel@tonic-gate 	char disk[10];
1497c478bd9Sstevel@tonic-gate 	int lun;
1507c478bd9Sstevel@tonic-gate 	int targ;
1517c478bd9Sstevel@tonic-gate 	int *intp;
1527c478bd9Sstevel@tonic-gate 
153*e37c6c37Scth 	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "target", &intp) <= 0) {
1547c478bd9Sstevel@tonic-gate 		return (DEVFSADM_CONTINUE);
1557c478bd9Sstevel@tonic-gate 	}
1567c478bd9Sstevel@tonic-gate 	targ = *intp;
157*e37c6c37Scth 	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "lun", &intp) <= 0) {
158*e37c6c37Scth 		lun = 0;
1597c478bd9Sstevel@tonic-gate 	} else {
160*e37c6c37Scth 		lun = *intp;
1617c478bd9Sstevel@tonic-gate 	}
1627c478bd9Sstevel@tonic-gate 	(void) sprintf(disk, "t%dd%d", targ, lun);
1637c478bd9Sstevel@tonic-gate 
1647c478bd9Sstevel@tonic-gate 	disk_common(minor, node, disk, RM_STALE);
1657c478bd9Sstevel@tonic-gate 
1667c478bd9Sstevel@tonic-gate 	return (DEVFSADM_CONTINUE);
1677c478bd9Sstevel@tonic-gate }
1687c478bd9Sstevel@tonic-gate 
1697c478bd9Sstevel@tonic-gate static int
1707c478bd9Sstevel@tonic-gate disk_callback_fabric(di_minor_t minor, di_node_t node)
1717c478bd9Sstevel@tonic-gate {
1727c478bd9Sstevel@tonic-gate 	char disk[DISK_SUBPATH_MAX];
1737c478bd9Sstevel@tonic-gate 	int lun;
1747c478bd9Sstevel@tonic-gate 	int count;
1757c478bd9Sstevel@tonic-gate 	int *intp;
1767c478bd9Sstevel@tonic-gate 	uchar_t *str;
1777c478bd9Sstevel@tonic-gate 	uchar_t *wwn;
1787c478bd9Sstevel@tonic-gate 	uchar_t ascii_wwn[ASCIIWWNSIZE];
1797c478bd9Sstevel@tonic-gate 
1807c478bd9Sstevel@tonic-gate 	if (di_prop_lookup_strings(DDI_DEV_T_ANY, node,
1817c478bd9Sstevel@tonic-gate 	    "client-guid", (char **)&wwn) > 0) {
182*e37c6c37Scth 		if (strlcpy((char *)ascii_wwn, (char *)wwn,
183*e37c6c37Scth 		    sizeof (ascii_wwn)) >= sizeof (ascii_wwn)) {
1847c478bd9Sstevel@tonic-gate 			devfsadm_errprint("SUNW_disk_link: GUID too long:%d",
185*e37c6c37Scth 			    strlen((char *)wwn));
1867c478bd9Sstevel@tonic-gate 			return (DEVFSADM_CONTINUE);
1877c478bd9Sstevel@tonic-gate 		}
1887c478bd9Sstevel@tonic-gate 		lun = 0;
1897c478bd9Sstevel@tonic-gate 	} else if (di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
1907c478bd9Sstevel@tonic-gate 	    "port-wwn", &wwn) > 0) {
1917c478bd9Sstevel@tonic-gate 		if (di_prop_lookup_ints(DDI_DEV_T_ANY, node,
1927c478bd9Sstevel@tonic-gate 		    "lun", &intp) > 0) {
1937c478bd9Sstevel@tonic-gate 			lun = *intp;
1947c478bd9Sstevel@tonic-gate 		} else {
1957c478bd9Sstevel@tonic-gate 			lun = 0;
1967c478bd9Sstevel@tonic-gate 		}
1977c478bd9Sstevel@tonic-gate 
1987c478bd9Sstevel@tonic-gate 		for (count = 0, str = ascii_wwn; count < 8; count++, str += 2) {
1997c478bd9Sstevel@tonic-gate 			(void) sprintf((caddr_t)str, "%02x", wwn[count]);
2007c478bd9Sstevel@tonic-gate 		}
2017c478bd9Sstevel@tonic-gate 		*str = '\0';
2027c478bd9Sstevel@tonic-gate 	} else {
2037c478bd9Sstevel@tonic-gate 		return (DEVFSADM_CONTINUE);
2047c478bd9Sstevel@tonic-gate 	}
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate 	for (str = ascii_wwn; *str != '\0'; str++) {
2077c478bd9Sstevel@tonic-gate 		*str = DISK_LINK_TO_UPPER(*str);
2087c478bd9Sstevel@tonic-gate 	}
2097c478bd9Sstevel@tonic-gate 
2107c478bd9Sstevel@tonic-gate 	(void) snprintf(disk, DISK_SUBPATH_MAX, "t%sd%d", ascii_wwn, lun);
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate 	disk_common(minor, node, disk, RM_STALE);
2137c478bd9Sstevel@tonic-gate 
2147c478bd9Sstevel@tonic-gate 	return (DEVFSADM_CONTINUE);
2157c478bd9Sstevel@tonic-gate }
2167c478bd9Sstevel@tonic-gate 
2177c478bd9Sstevel@tonic-gate /*
2187c478bd9Sstevel@tonic-gate  * This function is called for every disk minor node.
2197c478bd9Sstevel@tonic-gate  * Calls enumerate to assign a logical controller number, and
2207c478bd9Sstevel@tonic-gate  * then devfsadm_mklink to make the link.
2217c478bd9Sstevel@tonic-gate  */
2227c478bd9Sstevel@tonic-gate static void
2237c478bd9Sstevel@tonic-gate disk_common(di_minor_t minor, di_node_t node, char *disk, int flags)
2247c478bd9Sstevel@tonic-gate {
2257c478bd9Sstevel@tonic-gate 	char l_path[PATH_MAX + 1];
22618c2aff7Sartem 	char sec_path[PATH_MAX + 1];
2277c478bd9Sstevel@tonic-gate 	char stale_re[DISK_SUBPATH_MAX];
2287c478bd9Sstevel@tonic-gate 	char *dir;
2297c478bd9Sstevel@tonic-gate 	char slice[4];
2307c478bd9Sstevel@tonic-gate 	char *mn;
2317c478bd9Sstevel@tonic-gate 	char *ctrl;
23245916cd2Sjpk 	char *nt = NULL;
23318c2aff7Sartem 	int *int_prop;
23445916cd2Sjpk 	int  nflags = 0;
2357c478bd9Sstevel@tonic-gate 
2367c478bd9Sstevel@tonic-gate 	if (strstr(mn = di_minor_name(minor), ",raw")) {
2377c478bd9Sstevel@tonic-gate 		dir = "rdsk";
2387c478bd9Sstevel@tonic-gate 	} else {
2397c478bd9Sstevel@tonic-gate 		dir = "dsk";
2407c478bd9Sstevel@tonic-gate 	}
2417c478bd9Sstevel@tonic-gate 
2427c478bd9Sstevel@tonic-gate 	if (mn[0] < 113) {
2437c478bd9Sstevel@tonic-gate 		(void) sprintf(slice, "s%d", mn[0] - 'a');
2447c478bd9Sstevel@tonic-gate 	} else if (strncmp(mn, MN_EFI, 2) != 0) {
2457c478bd9Sstevel@tonic-gate 		(void) sprintf(slice, "p%d", mn[0] - 'q');
2467c478bd9Sstevel@tonic-gate 	} else {
2477c478bd9Sstevel@tonic-gate 		/* For EFI label */
2487c478bd9Sstevel@tonic-gate 		(void) sprintf(slice, SLICE_EFI);
2497c478bd9Sstevel@tonic-gate 	}
2507c478bd9Sstevel@tonic-gate 
2518d483882Smlf 	nflags = 0;
2528d483882Smlf 	if (system_labeled) {
2538d483882Smlf 		nt = di_minor_nodetype(minor);
2548d483882Smlf 		if ((nt != NULL) &&
2558d483882Smlf 		    ((strcmp(nt, DDI_NT_CD) == 0) ||
2568d483882Smlf 		    (strcmp(nt, DDI_NT_CD_CHAN) == 0) ||
2578d483882Smlf 		    (strcmp(nt, DDI_NT_BLOCK_CHAN) == 0))) {
2588d483882Smlf 			nflags = DA_ADD|DA_CD;
2598d483882Smlf 		}
2608d483882Smlf 	}
2618d483882Smlf 
2628d483882Smlf 	if (reserved_links_exist(node, minor, nflags) == DEVFSADM_SUCCESS) {
2638d483882Smlf 		devfsadm_print(disk_mid, "Reserved link exists. Not "
2648d483882Smlf 		    "creating links for slice %s\n", slice);
2658d483882Smlf 		return;
2668d483882Smlf 	}
2678d483882Smlf 
2687c478bd9Sstevel@tonic-gate 	if (NULL == (ctrl = diskctrl(node, minor)))
2697c478bd9Sstevel@tonic-gate 		return;
2707c478bd9Sstevel@tonic-gate 
2717c478bd9Sstevel@tonic-gate 	(void) strcpy(l_path, dir);
2727c478bd9Sstevel@tonic-gate 	(void) strcat(l_path, "/c");
2737c478bd9Sstevel@tonic-gate 	(void) strcat(l_path, ctrl);
2747c478bd9Sstevel@tonic-gate 	(void) strcat(l_path, disk);
2757c478bd9Sstevel@tonic-gate 
2767c478bd9Sstevel@tonic-gate 	/*
2777c478bd9Sstevel@tonic-gate 	 * If switching between SMI and EFI label or vice versa
2787c478bd9Sstevel@tonic-gate 	 * cleanup the previous label's devlinks.
2797c478bd9Sstevel@tonic-gate 	 */
2807c478bd9Sstevel@tonic-gate 	if (*mn == *(MN_SMI) || (strncmp(mn, MN_EFI, 2) == 0)) {
2817c478bd9Sstevel@tonic-gate 		char *s, tpath[PATH_MAX + 1];
2827c478bd9Sstevel@tonic-gate 		struct stat sb;
2837c478bd9Sstevel@tonic-gate 
2847c478bd9Sstevel@tonic-gate 		s = l_path + strlen(l_path);
2857c478bd9Sstevel@tonic-gate 		(void) strcat(l_path, (*mn == *(MN_SMI))
2867c478bd9Sstevel@tonic-gate 		    ? SLICE_EFI : SLICE_SMI);
2877c478bd9Sstevel@tonic-gate 		/*
2887c478bd9Sstevel@tonic-gate 		 * Attempt the remove only if the stale link exists
2897c478bd9Sstevel@tonic-gate 		 */
2907c478bd9Sstevel@tonic-gate 		(void) snprintf(tpath, sizeof (tpath), "%s/dev/%s",
2917c478bd9Sstevel@tonic-gate 		    devfsadm_root_path(), l_path);
2927c478bd9Sstevel@tonic-gate 		if (lstat(tpath, &sb) != -1)
2937c478bd9Sstevel@tonic-gate 			devfsadm_rm_all(l_path);
2947c478bd9Sstevel@tonic-gate 		*s = '\0';
2957c478bd9Sstevel@tonic-gate 	}
2967c478bd9Sstevel@tonic-gate 	(void) strcat(l_path, slice);
2977c478bd9Sstevel@tonic-gate 
29845916cd2Sjpk 	(void) devfsadm_mklink(l_path, node, minor, nflags);
2997c478bd9Sstevel@tonic-gate 
30018c2aff7Sartem 	/* secondary links for removable and hotpluggable devices */
30118c2aff7Sartem 	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "removable-media",
30218c2aff7Sartem 	    &int_prop) >= 0) {
30318c2aff7Sartem 		(void) strcpy(sec_path, "removable-media/");
30418c2aff7Sartem 		(void) strcat(sec_path, l_path);
30518c2aff7Sartem 		(void) devfsadm_secondary_link(sec_path, l_path, 0);
3067544909dSartem 	}
3077544909dSartem 	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "hotpluggable",
30818c2aff7Sartem 	    &int_prop) >= 0) {
30918c2aff7Sartem 		(void) strcpy(sec_path, "hotpluggable/");
31018c2aff7Sartem 		(void) strcat(sec_path, l_path);
31118c2aff7Sartem 		(void) devfsadm_secondary_link(sec_path, l_path, 0);
31218c2aff7Sartem 	}
31318c2aff7Sartem 
3147c478bd9Sstevel@tonic-gate 	if ((flags & RM_STALE) == RM_STALE) {
3157c478bd9Sstevel@tonic-gate 		(void) strcpy(stale_re, "^");
3167c478bd9Sstevel@tonic-gate 		(void) strcat(stale_re, dir);
3177c478bd9Sstevel@tonic-gate 		(void) strcat(stale_re, "/c");
3187c478bd9Sstevel@tonic-gate 		(void) strcat(stale_re, ctrl);
3197c478bd9Sstevel@tonic-gate 		(void) strcat(stale_re, "t[0-9A-F]+d[0-9]+(s[0-9]+)?$");
3207c478bd9Sstevel@tonic-gate 		/*
3217c478bd9Sstevel@tonic-gate 		 * optimizations are made inside of devfsadm_rm_stale_links
3227c478bd9Sstevel@tonic-gate 		 * instead of before calling the function, as it always
3237c478bd9Sstevel@tonic-gate 		 * needs to add the valid link to the cache.
3247c478bd9Sstevel@tonic-gate 		 */
3257c478bd9Sstevel@tonic-gate 		devfsadm_rm_stale_links(stale_re, l_path, node, minor);
3267c478bd9Sstevel@tonic-gate 	}
3277c478bd9Sstevel@tonic-gate 
3287c478bd9Sstevel@tonic-gate 	free(ctrl);
3297c478bd9Sstevel@tonic-gate }
3307c478bd9Sstevel@tonic-gate 
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate /* index of enumeration rule applicable to this module */
3337c478bd9Sstevel@tonic-gate #define	RULE_INDEX	0
3347c478bd9Sstevel@tonic-gate 
3357c478bd9Sstevel@tonic-gate static char *
3367c478bd9Sstevel@tonic-gate diskctrl(di_node_t node, di_minor_t minor)
3377c478bd9Sstevel@tonic-gate {
3387c478bd9Sstevel@tonic-gate 	char path[PATH_MAX + 1];
3397c478bd9Sstevel@tonic-gate 	char *devfspath;
3407c478bd9Sstevel@tonic-gate 	char *buf, *mn;
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 	devfsadm_enumerate_t rules[3] = {
3437c478bd9Sstevel@tonic-gate 	    {"^r?dsk$/^c([0-9]+)", 1, MATCH_PARENT},
3447c478bd9Sstevel@tonic-gate 	    {"^cfg$/^c([0-9]+)$", 1, MATCH_ADDR},
3457c478bd9Sstevel@tonic-gate 	    {"^scsi$/^.+$/^c([0-9]+)", 1, MATCH_PARENT}
3467c478bd9Sstevel@tonic-gate 	};
3477c478bd9Sstevel@tonic-gate 
3487c478bd9Sstevel@tonic-gate 	mn = di_minor_name(minor);
3497c478bd9Sstevel@tonic-gate 
3507c478bd9Sstevel@tonic-gate 	if ((devfspath = di_devfs_path(node)) == NULL) {
3517c478bd9Sstevel@tonic-gate 		return (NULL);
3527c478bd9Sstevel@tonic-gate 	}
3537c478bd9Sstevel@tonic-gate 	(void) strcpy(path, devfspath);
3547c478bd9Sstevel@tonic-gate 	(void) strcat(path, ":");
3557c478bd9Sstevel@tonic-gate 	(void) strcat(path, mn);
3567c478bd9Sstevel@tonic-gate 	di_devfs_path_free(devfspath);
3577c478bd9Sstevel@tonic-gate 
3587c478bd9Sstevel@tonic-gate 	/*
3597c478bd9Sstevel@tonic-gate 	 * Use controller component of disk path
3607c478bd9Sstevel@tonic-gate 	 */
3617c478bd9Sstevel@tonic-gate 	if (disk_enumerate_int(path, RULE_INDEX, &buf, rules, 3) ==
3627c478bd9Sstevel@tonic-gate 	    DEVFSADM_MULTIPLE) {
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 		/*
3657c478bd9Sstevel@tonic-gate 		 * We failed because there are multiple logical controller
3667c478bd9Sstevel@tonic-gate 		 * numbers for a single physical controller.  If we use node
3677c478bd9Sstevel@tonic-gate 		 * name also in the match it should fix this and only find one
3687c478bd9Sstevel@tonic-gate 		 * logical controller. (See 4045879).
3697c478bd9Sstevel@tonic-gate 		 * NOTE: Rules for controllers are not changed, as there is
3707c478bd9Sstevel@tonic-gate 		 * no unique controller number for them in this case.
3717c478bd9Sstevel@tonic-gate 		 *
3727c478bd9Sstevel@tonic-gate 		 * MATCH_UNCACHED flag is private to the "disks" and "sgen"
3737c478bd9Sstevel@tonic-gate 		 * modules. NOT to be used by other modules.
3747c478bd9Sstevel@tonic-gate 		 */
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate 		rules[0].flags = MATCH_NODE | MATCH_UNCACHED; /* disks */
3777c478bd9Sstevel@tonic-gate 		rules[2].flags = MATCH_NODE | MATCH_UNCACHED; /* generic scsi */
3787c478bd9Sstevel@tonic-gate 		if (devfsadm_enumerate_int(path, RULE_INDEX, &buf, rules, 3)) {
3797c478bd9Sstevel@tonic-gate 			return (NULL);
3807c478bd9Sstevel@tonic-gate 		}
3817c478bd9Sstevel@tonic-gate 	}
3827c478bd9Sstevel@tonic-gate 
3837c478bd9Sstevel@tonic-gate 	return (buf);
3847c478bd9Sstevel@tonic-gate }
3858d483882Smlf 
3868d483882Smlf typedef struct dvlist {
3878d483882Smlf 	char *dv_link;
3888d483882Smlf 	struct dvlist *dv_next;
3898d483882Smlf } dvlist_t;
3908d483882Smlf 
3918d483882Smlf static void
3928d483882Smlf free_dvlist(dvlist_t **pp)
3938d483882Smlf {
3948d483882Smlf 	dvlist_t *entry;
3958d483882Smlf 
3968d483882Smlf 	while (*pp) {
3978d483882Smlf 		entry = *pp;
3988d483882Smlf 		*pp = entry->dv_next;
3998d483882Smlf 		assert(entry->dv_link);
4008d483882Smlf 		free(entry->dv_link);
4018d483882Smlf 		free(entry);
4028d483882Smlf 	}
4038d483882Smlf }
4048d483882Smlf static int
4058d483882Smlf dvlink_cb(di_devlink_t devlink, void *arg)
4068d483882Smlf {
4078d483882Smlf 	char *path;
4088d483882Smlf 	char *can_path;
4098d483882Smlf 	dvlist_t **pp = (dvlist_t **)arg;
4108d483882Smlf 	dvlist_t *entry = NULL;
4118d483882Smlf 
4128d483882Smlf 	entry = calloc(1, sizeof (dvlist_t));
4138d483882Smlf 	if (entry == NULL) {
4148d483882Smlf 		devfsadm_errprint("%s: calloc failed\n", modname);
4158d483882Smlf 		goto error;
4168d483882Smlf 	}
4178d483882Smlf 
4188d483882Smlf 	path = (char *)di_devlink_path(devlink);
4198d483882Smlf 	assert(path);
4208d483882Smlf 	if (path == NULL) {
4218d483882Smlf 		devfsadm_errprint("%s: di_devlink_path() returned NULL\n",
4228d483882Smlf 		    modname);
4238d483882Smlf 		goto error;
4248d483882Smlf 	}
4258d483882Smlf 
4268d483882Smlf 	devfsadm_print(disk_mid, "%s: found link %s in reverse link cache\n",
4278d483882Smlf 	    modname, path);
4288d483882Smlf 
4298d483882Smlf 	/*
4308d483882Smlf 	 * Return linkname in canonical form i.e. without the
4318d483882Smlf 	 * "/dev/" prefix
4328d483882Smlf 	 */
4338d483882Smlf 	can_path = strstr(path, "/dev/");
4348d483882Smlf 	if (can_path == NULL) {
4358d483882Smlf 		devfsadm_errprint("%s: devlink path %s has no /dev/\n",
4368d483882Smlf 		    modname, path);
4378d483882Smlf 		goto error;
4388d483882Smlf 	}
4398d483882Smlf 
4408d483882Smlf 	entry->dv_link = s_strdup(can_path + strlen("/dev/"));
4418d483882Smlf 	entry->dv_next = *pp;
4428d483882Smlf 	*pp = entry;
4438d483882Smlf 
4448d483882Smlf 	return (DI_WALK_CONTINUE);
4458d483882Smlf 
4468d483882Smlf error:
4478d483882Smlf 	free(entry);
4488d483882Smlf 	free_dvlist(pp);
4498d483882Smlf 	*pp = NULL;
4508d483882Smlf 	return (DI_WALK_TERMINATE);
4518d483882Smlf }
4528d483882Smlf 
4538d483882Smlf /*
4548d483882Smlf  * Returns success only if all goes well. If there is no matching reserved link
4558d483882Smlf  * or if there is an error, we assume no match. It is better to err on the side
4568d483882Smlf  * of caution by creating extra links than to miss out creating a required link.
4578d483882Smlf  */
4588d483882Smlf static int
4598d483882Smlf reserved_links_exist(di_node_t node, di_minor_t minor, int nflags)
4608d483882Smlf {
4618d483882Smlf 	di_devlink_handle_t dvlink_cache = devfsadm_devlink_cache();
4628d483882Smlf 	char phys_path[PATH_MAX];
4638d483882Smlf 	char *minor_path;
4648d483882Smlf 	dvlist_t *head;
4658d483882Smlf 	dvlist_t *entry;
4668d483882Smlf 	char *s;
4678d483882Smlf 	char l[PATH_MAX];
4688d483882Smlf 	int switch_link = 0;
4698d483882Smlf 	char *mn = di_minor_name(minor);
4708d483882Smlf 
4718d483882Smlf 	if (dvlink_cache == NULL || mn == NULL) {
4728d483882Smlf 		devfsadm_errprint("%s: No minor or devlink cache\n", modname);
4738d483882Smlf 		return (DEVFSADM_FAILURE);
4748d483882Smlf 	}
4758d483882Smlf 
476*e37c6c37Scth 	if (!devfsadm_have_reserved()) {
477*e37c6c37Scth 		devfsadm_print(disk_mid, "%s: No reserved links\n", modname);
4788d483882Smlf 		return (DEVFSADM_FAILURE);
4798d483882Smlf 	}
4808d483882Smlf 
4818d483882Smlf 	minor_path = di_devfs_minor_path(minor);
4828d483882Smlf 	if (minor_path == NULL) {
4838d483882Smlf 		devfsadm_errprint("%s: di_devfs_minor_path failed\n", modname);
4848d483882Smlf 		return (DEVFSADM_FAILURE);
4858d483882Smlf 	}
4868d483882Smlf 
4878d483882Smlf 	(void) strlcpy(phys_path, minor_path, sizeof (phys_path));
4888d483882Smlf 
4898d483882Smlf 	di_devfs_path_free(minor_path);
4908d483882Smlf 
4918d483882Smlf 	head = NULL;
4928d483882Smlf 	(void) di_devlink_cache_walk(dvlink_cache, DISK_LINK_RE, phys_path,
4938d483882Smlf 	    DI_PRIMARY_LINK, &head, dvlink_cb);
4948d483882Smlf 
4958d483882Smlf 	/*
4968d483882Smlf 	 * We may be switching between EFI label and SMI label in which case
4978d483882Smlf 	 * we only have minors of the other type.
4988d483882Smlf 	 */
4998d483882Smlf 	if (head == NULL && (*mn == *(MN_SMI) ||
5008d483882Smlf 	    (strncmp(mn, MN_EFI, 2) == 0))) {
5018d483882Smlf 		devfsadm_print(disk_mid, "%s: No links for minor %s in /dev. "
5028d483882Smlf 		    "Trying another label\n", modname, mn);
5038d483882Smlf 		s = strrchr(phys_path, ':');
5048d483882Smlf 		if (s == NULL) {
5058d483882Smlf 			devfsadm_errprint("%s: invalid minor path: %s\n",
5068d483882Smlf 			    modname, phys_path);
5078d483882Smlf 			return (DEVFSADM_FAILURE);
5088d483882Smlf 		}
5098d483882Smlf 		(void) snprintf(s+1, sizeof (phys_path) - (s + 1 - phys_path),
510*e37c6c37Scth 		    "%s%s", *mn == *(MN_SMI) ? MN_EFI : MN_SMI,
511*e37c6c37Scth 		    strstr(s, ",raw") ? ",raw" : "");
5128d483882Smlf 		(void) di_devlink_cache_walk(dvlink_cache, DISK_LINK_RE,
5138d483882Smlf 		    phys_path, DI_PRIMARY_LINK, &head, dvlink_cb);
5148d483882Smlf 	}
5158d483882Smlf 
5168d483882Smlf 	if (head == NULL) {
5178d483882Smlf 		devfsadm_print(disk_mid, "%s: minor %s has no links in /dev\n",
5188d483882Smlf 		    modname, phys_path);
5198d483882Smlf 		/* no links on disk */
5208d483882Smlf 		return (DEVFSADM_FAILURE);
5218d483882Smlf 	}
5228d483882Smlf 
5238d483882Smlf 	/*
5248d483882Smlf 	 * It suffices to use 1 link to this minor, since
5258d483882Smlf 	 * we are matching with reserved IDs on the basis of
5268d483882Smlf 	 * the controller number which will be the same for
5278d483882Smlf 	 * all links to this minor.
5288d483882Smlf 	 */
5298d483882Smlf 	if (!devfsadm_is_reserved(disks_re_array, head->dv_link)) {
5308d483882Smlf 		/* not reserved links */
5318d483882Smlf 		devfsadm_print(disk_mid, "%s: devlink %s and its minor "
5328d483882Smlf 		    "are NOT reserved\n", modname, head->dv_link);
5338d483882Smlf 		free_dvlist(&head);
5348d483882Smlf 		return (DEVFSADM_FAILURE);
5358d483882Smlf 	}
5368d483882Smlf 
5378d483882Smlf 	devfsadm_print(disk_mid, "%s: devlink %s and its minor are on "
5388d483882Smlf 	    "reserved list\n", modname, head->dv_link);
5398d483882Smlf 
5408d483882Smlf 	/*
5418d483882Smlf 	 * Switch between SMI and EFI labels if required
5428d483882Smlf 	 */
5438d483882Smlf 	switch_link = 0;
5448d483882Smlf 	if (*mn == *(MN_SMI) || (strncmp(mn, MN_EFI, 2) == 0)) {
5458d483882Smlf 		for (entry = head; entry; entry = entry->dv_next) {
5468d483882Smlf 			s = strrchr(entry->dv_link, '/');
5478d483882Smlf 			assert(s);
5488d483882Smlf 			if (s == NULL) {
5498d483882Smlf 				devfsadm_errprint("%s: disk link %s has no "
5508d483882Smlf 				    "directory\n", modname, entry->dv_link);
5518d483882Smlf 				continue;
5528d483882Smlf 			}
5538d483882Smlf 			if (*mn == *(MN_SMI) && strchr(s, 's') == NULL) {
5548d483882Smlf 				(void) snprintf(l, sizeof (l), "%s%s",
5558d483882Smlf 				    entry->dv_link, SLICE_SMI);
5568d483882Smlf 				switch_link = 1;
5578d483882Smlf 				devfsadm_print(disk_mid, "%s: switching "
5588d483882Smlf 				    "reserved link from EFI to SMI label. "
5598d483882Smlf 				    "New link is %s\n", modname, l);
5608d483882Smlf 			} else if (strncmp(mn, MN_EFI, 2) == 0 &&
5618d483882Smlf 			    (s = strchr(s, 's'))) {
5628d483882Smlf 				*s = '\0';
5638d483882Smlf 				(void) snprintf(l, sizeof (l), "%s",
5648d483882Smlf 				    entry->dv_link);
5658d483882Smlf 				*s = 's';
5668d483882Smlf 				switch_link = 1;
5678d483882Smlf 				devfsadm_print(disk_mid, "%s: switching "
5688d483882Smlf 				    "reserved link from SMI to EFI label. "
5698d483882Smlf 				    "New link is %s\n", modname, l);
5708d483882Smlf 			}
5718d483882Smlf 			if (switch_link) {
5728d483882Smlf 				devfsadm_print(disk_mid, "%s: switching "
5738d483882Smlf 				    "link: deleting %s and creating %s\n",
5748d483882Smlf 				    modname, entry->dv_link, l);
5758d483882Smlf 				devfsadm_rm_link(entry->dv_link);
5768d483882Smlf 				(void) devfsadm_mklink(l, node, minor, nflags);
5778d483882Smlf 			}
5788d483882Smlf 		}
5798d483882Smlf 	}
5808d483882Smlf 	free_dvlist(&head);
5818d483882Smlf 
5828d483882Smlf 	/*
5838d483882Smlf 	 * return SUCCESS to indicate that new links to this minor should not
5848d483882Smlf 	 * be created so that only compatibility links to this minor remain.
5858d483882Smlf 	 */
5868d483882Smlf 	return (DEVFSADM_SUCCESS);
5878d483882Smlf }
588