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 void
print_error(const char * fn,int rc,const char * drv_name,int ppa,dl_error_ack_t * dleap)657 print_error(const char *fn, int rc, const char *drv_name,
658 int ppa, dl_error_ack_t *dleap)
659 {
660 if (rc == ENOTSUP) {
661 cmn_err(CE_WARN,
662 "getmacaddr: %s(%s%d) failed: DL_ERROR_ACK "
663 "DLPI errno 0x%x, UNIX errno %d", fn,
664 drv_name, ppa, dleap->dl_errno, dleap->dl_unix_errno);
665 } else {
666 cmn_err(CE_WARN,
667 "getmacaddr: %s(%s%d) failed: %d", fn, drv_name, ppa, rc);
668 }
669 }
670
671 static uchar_t *
getmacaddr(dev_info_t * dip,size_t * maclenp)672 getmacaddr(dev_info_t *dip, size_t *maclenp)
673 {
674 int rc, ppa;
675 ldi_ident_t li;
676 ldi_handle_t lh;
677 const char *drv_name = ddi_driver_name(dip);
678 char *clonepath;
679 uchar_t *macaddr = NULL;
680 dl_error_ack_t dlea;
681
682 if (rc = ldi_ident_from_mod(&modlinkage, &li)) {
683 cmn_err(CE_WARN,
684 "%s: ldi_ident_from_mod failed: %d", __func__, rc);
685 return (NULL);
686 }
687
688 clonepath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
689 (void) snprintf(clonepath, MAXPATHLEN,
690 "/devices/pseudo/clone@0:%s", drv_name);
691
692 rc = ldi_open_by_name(clonepath, FREAD|FWRITE, CRED(), &lh, li);
693 ldi_ident_release(li);
694 if (rc) {
695 cmn_err(CE_WARN,
696 "%s: ldi_open_by_name(%s) failed: %d",
697 __func__, clonepath, rc);
698 kmem_free(clonepath, MAXPATHLEN);
699 return (NULL);
700 }
701 kmem_free(clonepath, MAXPATHLEN);
702
703 ppa = i_ddi_devi_get_ppa(dip);
704 rc = dl_attach(lh, ppa, &dlea);
705 if (rc != 0) {
706 (void) ldi_close(lh, FREAD|FWRITE, CRED());
707 print_error("dl_attach", rc, drv_name, ppa, &dlea);
708 return (NULL);
709 }
710 rc = dl_bind(lh, ETHERTYPE_IP, &dlea);
711 if (rc != 0) {
712 (void) ldi_close(lh, FREAD|FWRITE, CRED());
713 print_error("dl_bind", rc, drv_name, ppa, &dlea);
714 }
715
716 *maclenp = ETHERADDRL;
717 macaddr = kmem_alloc(ETHERADDRL, KM_SLEEP);
718 rc = dl_phys_addr(lh, macaddr, maclenp, &dlea);
719 if (rc != 0 || *maclenp != ETHERADDRL) {
720 kmem_free(macaddr, ETHERADDRL);
721 macaddr = NULL;
722 *maclenp = 0;
723 print_error("dl_phys_addr", rc, drv_name, ppa, &dlea);
724 }
725 (void) ldi_close(lh, FREAD|FWRITE, CRED());
726 return (macaddr);
727 }
728 #endif /* !_OBP */
729