xref: /illumos-gate/usr/src/uts/common/io/strplumb.c (revision bbf21555)
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 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include	<sys/param.h>
27 #include	<sys/types.h>
28 #include	<sys/user.h>
29 #include	<sys/vfs.h>
30 #include	<sys/vnode.h>
31 #include	<sys/file.h>
32 #include	<sys/stream.h>
33 #include	<sys/stropts.h>
34 #include	<sys/strsubr.h>
35 #include	<sys/dlpi.h>
36 #include	<sys/vnode.h>
37 #include	<sys/socket.h>
38 #include	<sys/sockio.h>
39 #include	<net/if.h>
40 
41 #include	<sys/cred.h>
42 #include	<sys/sysmacros.h>
43 
44 #include	<sys/sad.h>
45 #include	<sys/kstr.h>
46 #include	<sys/bootconf.h>
47 #include	<sys/bootprops.h>
48 
49 #include	<sys/errno.h>
50 #include	<sys/modctl.h>
51 #include	<sys/sunddi.h>
52 #include	<sys/sunldi.h>
53 #include	<sys/esunddi.h>
54 #include	<sys/promif.h>
55 
56 #include	<sys/strlog.h>
57 #include	<sys/log.h>
58 #include	<sys/ethernet.h>
59 #include	<sys/ddi_implfuncs.h>
60 
61 #include	<sys/dld.h>
62 #include	<sys/mac_client.h>
63 
64 /*
65  * Debug Macros
66  */
67 int	strplumbdebug = 0;
68 
69 extern ib_boot_prop_t *iscsiboot_prop;
70 
71 #define	DBG0(_f) \
72 	if (strplumbdebug != 0) \
73 		printf("strplumb: " _f)
74 
75 #define	DBG1(_f, _a) \
76 	if (strplumbdebug != 0) \
77 		printf("strplumb: " _f, (_a))
78 
79 #define	DBG2(_f, _a, _b) \
80 	if (strplumbdebug != 0) \
81 		printf("strplumb: " _f, (_a), (_b))
82 
83 #define	DBG3(_f, _a, _b, _c) \
84 	if (strplumbdebug != 0) \
85 		printf("strplumb: " _f, (_a), (_b), (_c))
86 
87 /*
88  * Module linkage information for the kernel.
89  */
90 #define	STRPLUMB_IDENT	"STREAMS Plumbing Module"
91 
92 static struct modlmisc modlmisc = {
93 	&mod_miscops,
94 	STRPLUMB_IDENT
95 };
96 
97 static struct modlinkage modlinkage = {
98 	MODREV_1,
99 	&modlmisc,
100 	NULL
101 };
102 
103 int
_init(void)104 _init(void)
105 {
106 	return (mod_install(&modlinkage));
107 }
108 
109 int
_fini(void)110 _fini(void)
111 {
112 	return (mod_remove(&modlinkage));
113 }
114 
115 int
_info(struct modinfo * modinfop)116 _info(struct modinfo *modinfop)
117 {
118 	return (mod_info(&modlinkage, modinfop));
119 }
120 
121 #define	ARP		"arp"
122 #define	TCP		"tcp"
123 #define	TCP6		"tcp6"
124 #define	UDP		"udp"
125 #define	UDP6		"udp6"
126 #define	ICMP		"icmp"
127 #define	ICMP6		"icmp6"
128 #define	IP		"ip"
129 #define	IP6		"ip6"
130 #define	TIMOD		"timod"
131 
132 #define	UDPDEV		"/devices/pseudo/udp@0:udp"
133 #define	TCP6DEV		"/devices/pseudo/tcp6@0:tcp6"
134 #define	UDP6DEV		"/devices/pseudo/udp6@0:udp6"
135 #define	IP6DEV		"/devices/pseudo/ip6@0:ip6"
136 
137 typedef struct strplumb_modspec {
138 	char	*sm_type;
139 	char	*sm_name;
140 } strplumb_modspec_t;
141 
142 static strplumb_modspec_t	strplumb_modlist[] = {
143 	{ "drv", DLD_DRIVER_NAME },
144 	{ "drv", IP },
145 	{ "drv", IP6 },
146 	{ "drv", TCP },
147 	{ "drv", TCP6 },
148 	{ "drv", UDP },
149 	{ "drv", UDP6 },
150 	{ "drv", ICMP },
151 	{ "drv", ICMP6 },
152 	{ "drv", ARP },
153 	{ "strmod", TIMOD }
154 };
155 
156 /*
157  * Called from swapgeneric.c:loadrootmodules() in the network boot case.
158  */
159 int
strplumb_load(void)160 strplumb_load(void)
161 {
162 	uint_t			i;
163 	strplumb_modspec_t	*p;
164 
165 	DBG0("loading modules\n");
166 
167 	for (i = 0, p = strplumb_modlist;
168 	    i < sizeof (strplumb_modlist) / sizeof (strplumb_modlist[0]);
169 	    i++, p++) {
170 		if (modloadonly(p->sm_type, p->sm_name) < 0) {
171 			printf("strplumb: failed to load %s/%s\n",
172 			    p->sm_type, p->sm_name);
173 			return (EFAULT);
174 		}
175 	}
176 
177 	return (0);
178 }
179 
180 static int
strplumb_init(void)181 strplumb_init(void)
182 {
183 	uint_t			i;
184 	strplumb_modspec_t	*p;
185 	int			err;
186 
187 	DBG0("initializing modules\n");
188 
189 	for (i = 0, p = strplumb_modlist;
190 	    i < sizeof (strplumb_modlist) / sizeof (strplumb_modlist[0]);
191 	    i++, p++) {
192 		if (strcmp(p->sm_type, "drv") == 0)
193 			err = (i_ddi_attach_pseudo_node(p->sm_name) != NULL) ?
194 			    0 : EFAULT;
195 		else
196 			err = (modload(p->sm_type, p->sm_name) < 0) ?
197 			    EFAULT : 0;
198 
199 		if (err != 0)  {
200 			printf("strplumb: failed to initialize %s/%s\n",
201 			    p->sm_type, p->sm_name);
202 			return (err);
203 		}
204 	}
205 
206 	return (0);
207 }
208 
209 /*
210  * Can be set in /etc/system in the case of local booting. See comment below.
211  */
212 char	*ndev_name = 0;
213 int	ndev_unit = 0;
214 
215 /*
216  * If we booted diskless then strplumb() will have been called from
217  * either:
218  *	in case of x86 NEWBOOT: vfs.c:rootconf()
219  *	in case of nfs root, the rootfs.bo_name is reset from /ramdisk:a
220  *	to empty string and we will copy netdev_path there.
221  * or
222  *	in case of sparc: swapgeneric.c:rootconf().
223  * All we can do in that case is plumb the network device that we booted from.
224  *
225  * If we booted from a local disk, we will have been called from main(),
226  * and normally we defer the plumbing of interfaces until network/physical.
227  * This can be overridden by setting "ndev_name" in /etc/system.
228  */
229 static int
resolve_boot_path(void)230 resolve_boot_path(void)
231 {
232 	char			*devpath;
233 	dev_info_t		*dip;
234 	const char		*driver;
235 	int			instance;
236 #ifdef	_OBP
237 	char			stripped_path[OBP_MAXPATHLEN];
238 #endif
239 
240 	if (strncmp(rootfs.bo_fstype, "nfs", 3) == 0 &&
241 	    rootfs.bo_name[0] != '\0') {
242 		devpath = rootfs.bo_name;
243 	} else {
244 		devpath = strplumb_get_netdev_path();
245 		netdev_path = devpath;
246 		if (netdev_path != NULL) {
247 			(void) strncpy(rootfs.bo_name, netdev_path,
248 			    BO_MAXOBJNAME);
249 		}
250 	}
251 
252 	if (devpath != NULL) {
253 		DBG1("resolving boot-path: %s\n", devpath);
254 #ifdef _OBP
255 		/*
256 		 * OBP passes options e.g, "net:dhcp"
257 		 * remove them here
258 		 */
259 		prom_strip_options(devpath, stripped_path);
260 		devpath = stripped_path;
261 #endif
262 		/*
263 		 * Hold the devi since this is the root device.
264 		 */
265 		if ((dip = e_ddi_hold_devi_by_path(devpath, 0)) == NULL) {
266 			printf("strplumb: unable to hold root device: %s\n",
267 			    devpath);
268 			return (ENXIO);
269 		}
270 
271 		driver = ddi_driver_name(dip);
272 		instance = ddi_get_instance(dip);
273 	} else {
274 		if (ndev_name == NULL)
275 			return (ENODEV);
276 
277 		DBG2("using ndev_name (%s) ndev_unit (%d)\n", ndev_name,
278 		    ndev_unit);
279 
280 		if (i_ddi_attach_hw_nodes(ndev_name) != DDI_SUCCESS) {
281 			printf("strplumb: cannot load ndev_name '%s'\n",
282 			    ndev_name);
283 			return (ENXIO);
284 		}
285 
286 		driver = ndev_name;
287 		instance = ndev_unit;
288 	}
289 
290 	(void) snprintf(rootfs.bo_devname, BO_MAXOBJNAME,
291 	    "/devices/pseudo/clone@0:%s", driver);
292 	(void) snprintf(rootfs.bo_ifname, BO_MAXOBJNAME, "%s%d",
293 	    driver, instance);
294 	rootfs.bo_ppa = instance;
295 	return (0);
296 }
297 
298 static int
getifflags(ldi_handle_t lh,struct lifreq * lifrp)299 getifflags(ldi_handle_t lh, struct lifreq *lifrp)
300 {
301 	struct strioctl	iocb;
302 	int		rval;
303 
304 	iocb.ic_cmd = SIOCGLIFFLAGS;
305 	iocb.ic_timout = 15;
306 	iocb.ic_len = sizeof (struct lifreq);
307 	iocb.ic_dp = (char *)lifrp;
308 
309 	return (ldi_ioctl(lh, I_STR, (intptr_t)&iocb, FKIOCTL, CRED(), &rval));
310 
311 }
312 
313 static int
setifname(ldi_handle_t lh,struct lifreq * lifrp)314 setifname(ldi_handle_t lh, struct lifreq *lifrp)
315 {
316 	struct strioctl	iocb;
317 	int		rval;
318 
319 	iocb.ic_cmd = SIOCSLIFNAME;
320 	iocb.ic_timout = 15;
321 	iocb.ic_len = sizeof (struct lifreq);
322 	iocb.ic_dp = (char *)lifrp;
323 
324 	return (ldi_ioctl(lh, I_STR, (intptr_t)&iocb, FKIOCTL, CRED(), &rval));
325 }
326 
327 static int
strplumb_dev(ldi_ident_t li)328 strplumb_dev(ldi_ident_t li)
329 {
330 	ldi_handle_t	lh = NULL;
331 	ldi_handle_t	mux_lh = NULL;
332 	int		err;
333 	struct lifreq	lifr;
334 	struct ifreq	ifr;
335 	int		rval;
336 	int		af = 0;
337 	char		*name = NULL;
338 
339 	bzero(&lifr, sizeof (struct lifreq));
340 	bzero(&ifr, sizeof (ifr));
341 
342 	if (iscsiboot_prop != NULL) {
343 		af = iscsiboot_prop->boot_nic.sin_family;
344 	}
345 
346 	/*
347 	 * Now set up the links. Ultimately, we should have two streams
348 	 * permanently linked under UDP.  One stream consists of the
349 	 * ARP-[ifname] combination, while the other consists of IP-[ifname].
350 	 *
351 	 * We pin underneath UDP here to match what is done in ifconfig(8);
352 	 * otherwise, ifconfig will be unable to unplumb the stream (the major
353 	 * number and mux id must both match for a successful I_PUNLINK).
354 	 *
355 	 * There are subtleties in the plumbing which make it essential to
356 	 * follow the logic used in ifconfig(8) very closely.
357 	 */
358 
359 	/*
360 	 * Plumb UDP-IP-<dev>
361 	 */
362 
363 	if ((err = ldi_open_by_name(rootfs.bo_devname, FREAD|FWRITE, CRED(),
364 	    &lh, li)) != 0) {
365 		printf("strplumb: open %s failed: %d\n", rootfs.bo_devname,
366 		    err);
367 		goto done;
368 	}
369 
370 
371 	if ((err = ldi_ioctl(lh, I_PUSH, (intptr_t)IP, FKIOCTL, CRED(),
372 	    &rval)) != 0) {
373 		printf("strplumb: push IP failed: %d\n", err);
374 		goto done;
375 	}
376 
377 	if ((err = getifflags(lh, &lifr)) != 0)
378 		goto done;
379 
380 	if (af == 0 || af == AF_INET) {
381 		lifr.lifr_flags |= IFF_IPV4;
382 		lifr.lifr_flags &= ~IFF_IPV6;
383 		name = UDPDEV;
384 	} else {
385 		/*
386 		 * iscsi boot is used with ipv6 enabled
387 		 */
388 		lifr.lifr_flags |= IFF_IPV6;
389 		lifr.lifr_flags &= ~IFF_IPV4;
390 		name = UDP6DEV;
391 	}
392 	(void) strlcpy(lifr.lifr_name, rootfs.bo_ifname,
393 	    sizeof (lifr.lifr_name));
394 	lifr.lifr_ppa = rootfs.bo_ppa;
395 
396 	if ((err = setifname(lh, &lifr)) != 0)
397 		goto done;
398 
399 	/* get the flags and check if ARP is needed */
400 	if ((err = getifflags(lh, &lifr)) != 0) {
401 		printf("strplumb: getifflags %s IP failed, error %d\n",
402 		    lifr.lifr_name, err);
403 		goto done;
404 	}
405 	if ((err = ldi_open_by_name(name, FREAD|FWRITE, CRED(), &mux_lh,
406 	    li)) != 0) {
407 		printf("strplumb: open of %s failed: %d\n", name, err);
408 		goto done;
409 	}
410 	if ((err = ldi_ioctl(mux_lh, I_PLINK, (intptr_t)lh,
411 	    FREAD|FWRITE|FNOCTTY|FKIOCTL, CRED(),
412 	    &(ifr.ifr_ip_muxid))) != 0) {
413 		printf("strplumb: plink UDP-ARP-IP-%s failed: %d\n",
414 		    rootfs.bo_ifname, err);
415 		goto done;
416 	}
417 
418 	/* if ARP is not needed, we are done */
419 	if (lifr.lifr_flags & (IFF_NOARP | IFF_IPV6))
420 		goto done;
421 
422 	DBG2("UDP-ARP-IP-%s muxid: %d\n", rootfs.bo_ifname, ifr.ifr_ip_muxid);
423 
424 	(void) ldi_close(lh, FREAD|FWRITE, CRED());
425 	lh = NULL;
426 
427 	/*
428 	 * Plumb UDP-ARP-<dev>
429 	 */
430 
431 	if ((err = ldi_open_by_name(rootfs.bo_devname, FREAD|FWRITE, CRED(),
432 	    &lh, li)) != 0) {
433 		printf("strplumb: open %s failed: %d\n", rootfs.bo_devname,
434 		    err);
435 		goto done;
436 	}
437 
438 	if ((err = ldi_ioctl(lh, I_PUSH, (intptr_t)ARP, FKIOCTL, CRED(),
439 	    &rval)) != 0) {
440 		printf("strplumb: push ARP failed: %d\n", err);
441 		goto done;
442 	}
443 
444 	if ((err = setifname(lh, &lifr)) != 0)
445 		goto done;
446 
447 	if ((err = ldi_ioctl(mux_lh, I_PLINK, (intptr_t)lh,
448 	    FREAD|FWRITE|FNOCTTY|FKIOCTL, CRED(),
449 	    &(ifr.ifr_arp_muxid))) != 0) {
450 		printf("strplumb: plink UDP-ARP-%s failed: %d\n",
451 		    rootfs.bo_ifname, err);
452 		goto done;
453 	}
454 
455 	DBG2("UDP-ARP-%s muxid: %d\n", rootfs.bo_ifname, ifr.ifr_arp_muxid);
456 
457 	/*
458 	 * Cache the mux ids.
459 	 */
460 	(void) strlcpy(ifr.ifr_name, rootfs.bo_ifname, sizeof (ifr.ifr_name));
461 
462 	if ((err = ldi_ioctl(mux_lh, SIOCSIFMUXID, (intptr_t)&ifr, FKIOCTL,
463 	    CRED(), &rval)) != 0) {
464 		printf("strplumb: SIOCSIFMUXID failed: %d\n", err);
465 		goto done;
466 	}
467 
468 done:
469 	if (lh != NULL)
470 		(void) ldi_close(lh, FREAD|FWRITE, CRED());
471 
472 	if (mux_lh != NULL)
473 		(void) ldi_close(mux_lh, FREAD|FWRITE, CRED());
474 
475 	return (err);
476 }
477 
478 /*
479  * Do streams plumbing for internet protocols.
480  */
481 int
strplumb(void)482 strplumb(void)
483 {
484 	ldi_ident_t	li;
485 	int		err;
486 
487 	if ((err = strplumb_init()) != 0)
488 		return (err);
489 
490 	if ((err = ldi_ident_from_mod(&modlinkage, &li)) != 0)
491 		return (err);
492 
493 	if ((err = resolve_boot_path()) != 0)
494 		goto done;
495 
496 	DBG1("rootfs.bo_devname: %s\n", rootfs.bo_devname);
497 	DBG1("rootfs.bo_ifname: %s\n", rootfs.bo_ifname);
498 	DBG1("rootfs.bo_ppa: %d\n", rootfs.bo_ppa);
499 
500 	if ((err = strplumb_dev(li)) != 0)
501 		goto done;
502 
503 done:
504 	ldi_ident_release(li);
505 
506 	return (err);
507 }
508 
509 /* multiboot:  diskless boot interface discovery */
510 
511 #ifndef	_OBP
512 
513 static uchar_t boot_macaddr[16];
514 static int boot_maclen;
515 static uchar_t *getmacaddr(dev_info_t *dip, size_t *maclenp);
516 static int matchmac(dev_info_t *dip, void *arg);
517 
518 #endif  /* !_OBP */
519 
520 char *
strplumb_get_netdev_path(void)521 strplumb_get_netdev_path(void)
522 {
523 #ifdef	_OBP
524 	char		fstype[OBP_MAXPROPNAME];
525 	static char	iscsi_network_path[BO_MAXOBJNAME]	= {0};
526 	int		proplen;
527 	char		*p	= NULL;
528 
529 	if (bop_getprop("fstype", fstype) == -1)
530 		return (NULL);
531 
532 	if (strncmp(fstype, "nfs", 3) == 0)
533 		return (prom_bootpath());
534 	else if (iscsiboot_prop != NULL) {
535 		proplen =  BOP_GETPROPLEN(bootops,
536 		    BP_ISCSI_NETWORK_BOOTPATH);
537 		if (proplen > 0) {
538 			if (BOP_GETPROP(bootops,
539 			    BP_ISCSI_NETWORK_BOOTPATH,
540 			    iscsi_network_path) > 0) {
541 				p = strchr(iscsi_network_path, ':');
542 				if (p != NULL) {
543 					*p = '\0';
544 				}
545 				return (iscsi_network_path);
546 			}
547 		}
548 	}
549 	return (NULL);
550 #else
551 
552 	char *macstr, *devpath = NULL;
553 	uchar_t *bootp;
554 	uint_t bootp_len;
555 
556 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
557 	    DDI_PROP_DONTPASS, BP_BOOT_MAC, &macstr) == DDI_SUCCESS) {
558 		/*
559 		 * hard coded ether mac len for booting floppy on
560 		 * machines with old cards
561 		 */
562 		boot_maclen = ether_aton(macstr, boot_macaddr);
563 		if (boot_maclen != 6) {
564 			cmn_err(CE_WARN,
565 			    "malformed boot_mac property, %d bytes",
566 			    boot_maclen);
567 		}
568 		ddi_prop_free(macstr);
569 	} else if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, ddi_root_node(),
570 	    DDI_PROP_DONTPASS, BP_BOOTP_RESPONSE, &bootp, &bootp_len)
571 	    == DDI_SUCCESS) {
572 
573 		/*
574 		 * These offsets are defined by dhcp standard
575 		 * Should use structure offsets
576 		 */
577 		boot_maclen = *(bootp + 2);
578 		ASSERT(boot_maclen <= 16);
579 		bcopy(bootp + 28, boot_macaddr, boot_maclen);
580 
581 		dhcack = kmem_alloc(bootp_len, KM_SLEEP);
582 		bcopy(bootp, dhcack, bootp_len);
583 		dhcacklen = bootp_len;
584 
585 		ddi_prop_free(bootp);
586 	} else  if (iscsiboot_prop != NULL) {
587 		bcopy(iscsiboot_prop->boot_nic.nic_mac,
588 		    boot_macaddr, IB_BOOT_MACLEN);
589 		boot_maclen = IB_BOOT_MACLEN;
590 	} else {
591 		return (NULL);
592 	}
593 
594 	ddi_walk_devs(ddi_root_node(), matchmac, (void *)&devpath);
595 	return (devpath);
596 
597 #endif  /* _OBP */
598 }
599 
600 #ifndef _OBP
601 
602 /*
603  * Get boot path from the boot_mac address
604  */
605 /*ARGSUSED*/
606 static int
matchmac(dev_info_t * dip,void * arg)607 matchmac(dev_info_t *dip, void *arg)
608 {
609 	char **devpathp = (char **)arg;
610 	char *model_str;
611 	uchar_t *macaddr;
612 	size_t maclen;
613 
614 	/* XXX Should use "device-type" per IEEE 1275 */
615 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0,
616 	    "model", &model_str) != DDI_SUCCESS)
617 		return (DDI_WALK_CONTINUE);
618 
619 	if (strcmp(model_str, "Ethernet controller") != 0) {
620 		ddi_prop_free(model_str);
621 		return (DDI_WALK_CONTINUE);
622 	}
623 	ddi_prop_free(model_str);
624 
625 	/* We have a network device now */
626 	if (i_ddi_attach_node_hierarchy(dip) != DDI_SUCCESS) {
627 		return (DDI_WALK_CONTINUE);
628 	}
629 
630 	ASSERT(boot_maclen != 0);
631 	macaddr = getmacaddr(dip, &maclen);
632 	if (macaddr == NULL)
633 		return (DDI_WALK_CONTINUE);
634 
635 	if (maclen != boot_maclen ||
636 	    bcmp(macaddr, boot_macaddr, maclen) != 0) {
637 		kmem_free(macaddr, maclen);
638 		return (DDI_WALK_CONTINUE);
639 	}
640 
641 	/* found hardware with the mac address */
642 	(void) localetheraddr((struct ether_addr *)macaddr, NULL);
643 	kmem_free(macaddr, maclen);
644 
645 	*devpathp = kmem_alloc(MAXPATHLEN, KM_SLEEP);
646 	(void) ddi_pathname(dip, *devpathp);
647 
648 	/* fill in dhcifname */
649 	if (dhcack) {
650 		(void) snprintf(dhcifname, IFNAMSIZ, "%s%d",
651 		    ddi_driver_name(dip), i_ddi_devi_get_ppa(dip));
652 	}
653 	return (DDI_WALK_TERMINATE);
654 }
655 
656 static uchar_t *
getmacaddr(dev_info_t * dip,size_t * maclenp)657 getmacaddr(dev_info_t *dip, size_t *maclenp)
658 {
659 	int rc, ppa;
660 	ldi_ident_t li;
661 	ldi_handle_t lh;
662 	const char *drv_name = ddi_driver_name(dip);
663 	char *clonepath;
664 	uchar_t *macaddr = NULL;
665 
666 	if (rc = ldi_ident_from_mod(&modlinkage, &li)) {
667 		cmn_err(CE_WARN,
668 		    "getmacaddr: ldi_ident_from_mod failed: %d\n", rc);
669 		return (NULL);
670 	}
671 
672 	clonepath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
673 	(void) snprintf(clonepath, MAXPATHLEN,
674 	    "/devices/pseudo/clone@0:%s", drv_name);
675 
676 	rc = ldi_open_by_name(clonepath, FREAD|FWRITE, CRED(), &lh, li);
677 	ldi_ident_release(li);
678 	if (rc) {
679 		cmn_err(CE_WARN,
680 		    "getmacaddr: ldi_open_by_name(%s) failed: %d\n",
681 		    clonepath, rc);
682 		kmem_free(clonepath, MAXPATHLEN);
683 		return (NULL);
684 	}
685 	kmem_free(clonepath, MAXPATHLEN);
686 
687 	ppa = i_ddi_devi_get_ppa(dip);
688 	if ((dl_attach(lh, ppa, NULL) != 0) ||
689 	    (dl_bind(lh, ETHERTYPE_IP, NULL) != 0)) {
690 		(void) ldi_close(lh, FREAD|FWRITE, CRED());
691 		cmn_err(CE_WARN,
692 		    "getmacaddr: dl_attach/bind(%s%d) failed: %d\n",
693 		    drv_name, ppa, rc);
694 		return (NULL);
695 	}
696 
697 	*maclenp = ETHERADDRL;
698 	macaddr = kmem_alloc(ETHERADDRL, KM_SLEEP);
699 	if (dl_phys_addr(lh, macaddr, maclenp, NULL) != 0 ||
700 	    *maclenp != ETHERADDRL) {
701 		kmem_free(macaddr, ETHERADDRL);
702 		macaddr = NULL;
703 		*maclenp = 0;
704 		cmn_err(CE_WARN,
705 		    "getmacaddr: dl_phys_addr(%s%d) failed: %d\n",
706 		    drv_name, ppa, rc);
707 	}
708 	(void) ldi_close(lh, FREAD|FWRITE, CRED());
709 	return (macaddr);
710 }
711 #endif	/* !_OBP */
712