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 (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 1990 Mentat Inc.
24 */
25
26 /*
27 * This file contains the interface control functions for IP.
28 */
29
30 #include <sys/types.h>
31 #include <sys/stream.h>
32 #include <sys/dlpi.h>
33 #include <sys/stropts.h>
34 #include <sys/strsun.h>
35 #include <sys/sysmacros.h>
36 #include <sys/strsubr.h>
37 #include <sys/strlog.h>
38 #include <sys/ddi.h>
39 #include <sys/sunddi.h>
40 #include <sys/cmn_err.h>
41 #include <sys/kstat.h>
42 #include <sys/debug.h>
43 #include <sys/zone.h>
44 #include <sys/sunldi.h>
45 #include <sys/file.h>
46 #include <sys/bitmap.h>
47 #include <sys/cpuvar.h>
48 #include <sys/time.h>
49 #include <sys/ctype.h>
50 #include <sys/kmem.h>
51 #include <sys/systm.h>
52 #include <sys/param.h>
53 #include <sys/socket.h>
54 #include <sys/isa_defs.h>
55 #include <net/if.h>
56 #include <net/if_arp.h>
57 #include <net/if_types.h>
58 #include <net/if_dl.h>
59 #include <net/route.h>
60 #include <sys/sockio.h>
61 #include <netinet/in.h>
62 #include <netinet/ip6.h>
63 #include <netinet/icmp6.h>
64 #include <netinet/igmp_var.h>
65 #include <sys/policy.h>
66 #include <sys/ethernet.h>
67 #include <sys/callb.h>
68 #include <sys/md5.h>
69
70 #include <inet/common.h> /* for various inet/mi.h and inet/nd.h needs */
71 #include <inet/mi.h>
72 #include <inet/nd.h>
73 #include <inet/tunables.h>
74 #include <inet/arp.h>
75 #include <inet/ip_arp.h>
76 #include <inet/mib2.h>
77 #include <inet/ip.h>
78 #include <inet/ip6.h>
79 #include <inet/ip6_asp.h>
80 #include <inet/tcp.h>
81 #include <inet/ip_multi.h>
82 #include <inet/ip_ire.h>
83 #include <inet/ip_ftable.h>
84 #include <inet/ip_rts.h>
85 #include <inet/ip_ndp.h>
86 #include <inet/ip_if.h>
87 #include <inet/ip_impl.h>
88 #include <inet/sctp_ip.h>
89 #include <inet/ip_netinfo.h>
90 #include <inet/ilb_ip.h>
91
92 #include <netinet/igmp.h>
93 #include <inet/ip_listutils.h>
94 #include <inet/ipclassifier.h>
95 #include <sys/mac_client.h>
96 #include <sys/dld.h>
97 #include <sys/mac_flow.h>
98
99 #include <sys/systeminfo.h>
100 #include <sys/bootconf.h>
101
102 #include <sys/tsol/tndb.h>
103 #include <sys/tsol/tnet.h>
104
105 #include <inet/rawip_impl.h> /* needed for icmp_stack_t */
106 #include <inet/udp_impl.h> /* needed for udp_stack_t */
107 #include <inet/dccp/dccp_stack.h> /* needed for dccp_stack_t */
108
109 /* The character which tells where the ill_name ends */
110 #define IPIF_SEPARATOR_CHAR ':'
111
112 /* IP ioctl function table entry */
113 typedef struct ipft_s {
114 int ipft_cmd;
115 pfi_t ipft_pfi;
116 int ipft_min_size;
117 int ipft_flags;
118 } ipft_t;
119 #define IPFT_F_NO_REPLY 0x1 /* IP ioctl does not expect any reply */
120 #define IPFT_F_SELF_REPLY 0x2 /* ioctl callee does the ioctl reply */
121
122 static int nd_ill_forward_get(queue_t *, mblk_t *, caddr_t, cred_t *);
123 static int nd_ill_forward_set(queue_t *q, mblk_t *mp,
124 char *value, caddr_t cp, cred_t *ioc_cr);
125
126 static boolean_t ill_is_quiescent(ill_t *);
127 static boolean_t ip_addr_ok_v4(ipaddr_t addr, ipaddr_t subnet_mask);
128 static ip_m_t *ip_m_lookup(t_uscalar_t mac_type);
129 static int ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
130 mblk_t *mp, boolean_t need_up);
131 static int ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
132 mblk_t *mp, boolean_t need_up);
133 static int ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid,
134 queue_t *q, mblk_t *mp, boolean_t need_up);
135 static int ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q,
136 mblk_t *mp);
137 static int ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
138 mblk_t *mp);
139 static int ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t, in6_addr_t,
140 queue_t *q, mblk_t *mp, boolean_t need_up);
141 static int ip_sioctl_plink_ipmod(ipsq_t *ipsq, queue_t *q, mblk_t *mp,
142 int ioccmd, struct linkblk *li);
143 static ipaddr_t ip_subnet_mask(ipaddr_t addr, ipif_t **, ip_stack_t *);
144 static void ip_wput_ioctl(queue_t *q, mblk_t *mp);
145 static void ipsq_flush(ill_t *ill);
146
147 static int ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen,
148 queue_t *q, mblk_t *mp, boolean_t need_up);
149 static void ipsq_delete(ipsq_t *);
150
151 static ipif_t *ipif_allocate(ill_t *ill, int id, uint_t ire_type,
152 boolean_t initialize, boolean_t insert, int *errorp);
153 static ire_t **ipif_create_bcast_ires(ipif_t *ipif, ire_t **irep);
154 static void ipif_delete_bcast_ires(ipif_t *ipif);
155 static int ipif_add_ires_v4(ipif_t *, boolean_t);
156 static boolean_t ipif_comp_multi(ipif_t *old_ipif, ipif_t *new_ipif,
157 boolean_t isv6);
158 static int ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp);
159 static void ipif_free(ipif_t *ipif);
160 static void ipif_free_tail(ipif_t *ipif);
161 static void ipif_set_default(ipif_t *ipif);
162 static int ipif_set_values(queue_t *q, mblk_t *mp,
163 char *interf_name, uint_t *ppa);
164 static int ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp,
165 queue_t *q);
166 static ipif_t *ipif_lookup_on_name(char *name, size_t namelen,
167 boolean_t do_alloc, boolean_t *exists, boolean_t isv6, zoneid_t zoneid,
168 ip_stack_t *);
169 static ipif_t *ipif_lookup_on_name_async(char *name, size_t namelen,
170 boolean_t isv6, zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func,
171 int *error, ip_stack_t *);
172
173 static int ill_alloc_ppa(ill_if_t *, ill_t *);
174 static void ill_delete_interface_type(ill_if_t *);
175 static int ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q);
176 static void ill_dl_down(ill_t *ill);
177 static void ill_down(ill_t *ill);
178 static void ill_down_ipifs(ill_t *, boolean_t);
179 static void ill_free_mib(ill_t *ill);
180 static void ill_glist_delete(ill_t *);
181 static void ill_phyint_reinit(ill_t *ill);
182 static void ill_set_nce_router_flags(ill_t *, boolean_t);
183 static void ill_set_phys_addr_tail(ipsq_t *, queue_t *, mblk_t *, void *);
184 static void ill_replumb_tail(ipsq_t *, queue_t *, mblk_t *, void *);
185
186 static ip_v6intfid_func_t ip_ether_v6intfid, ip_ib_v6intfid;
187 static ip_v6intfid_func_t ip_ipv4_v6intfid, ip_ipv6_v6intfid;
188 static ip_v6intfid_func_t ip_ipmp_v6intfid, ip_nodef_v6intfid;
189 static ip_v6intfid_func_t ip_ipv4_v6destintfid, ip_ipv6_v6destintfid;
190 static ip_v4mapinfo_func_t ip_ether_v4_mapping;
191 static ip_v6mapinfo_func_t ip_ether_v6_mapping;
192 static ip_v4mapinfo_func_t ip_ib_v4_mapping;
193 static ip_v6mapinfo_func_t ip_ib_v6_mapping;
194 static ip_v4mapinfo_func_t ip_mbcast_mapping;
195 static void ip_cgtp_bcast_add(ire_t *, ip_stack_t *);
196 static void ip_cgtp_bcast_delete(ire_t *, ip_stack_t *);
197 static void phyint_free(phyint_t *);
198
199 static void ill_capability_dispatch(ill_t *, mblk_t *, dl_capability_sub_t *);
200 static void ill_capability_id_ack(ill_t *, mblk_t *, dl_capability_sub_t *);
201 static void ill_capability_vrrp_ack(ill_t *, mblk_t *, dl_capability_sub_t *);
202 static void ill_capability_hcksum_ack(ill_t *, mblk_t *, dl_capability_sub_t *);
203 static void ill_capability_hcksum_reset_fill(ill_t *, mblk_t *);
204 static void ill_capability_zerocopy_ack(ill_t *, mblk_t *,
205 dl_capability_sub_t *);
206 static void ill_capability_zerocopy_reset_fill(ill_t *, mblk_t *);
207 static void ill_capability_dld_reset_fill(ill_t *, mblk_t *);
208 static void ill_capability_dld_ack(ill_t *, mblk_t *,
209 dl_capability_sub_t *);
210 static void ill_capability_dld_enable(ill_t *);
211 static void ill_capability_ack_thr(void *);
212 static void ill_capability_lso_enable(ill_t *);
213
214 static ill_t *ill_prev_usesrc(ill_t *);
215 static int ill_relink_usesrc_ills(ill_t *, ill_t *, uint_t);
216 static void ill_disband_usesrc_group(ill_t *);
217 static void ip_sioctl_garp_reply(mblk_t *, ill_t *, void *, int);
218
219 #ifdef DEBUG
220 static void ill_trace_cleanup(const ill_t *);
221 static void ipif_trace_cleanup(const ipif_t *);
222 #endif
223
224 static void ill_dlpi_clear_deferred(ill_t *ill);
225
226 /*
227 * if we go over the memory footprint limit more than once in this msec
228 * interval, we'll start pruning aggressively.
229 */
230 int ip_min_frag_prune_time = 0;
231
232 static ipft_t ip_ioctl_ftbl[] = {
233 { IP_IOC_IRE_DELETE, ip_ire_delete, sizeof (ipid_t), 0 },
234 { IP_IOC_IRE_DELETE_NO_REPLY, ip_ire_delete, sizeof (ipid_t),
235 IPFT_F_NO_REPLY },
236 { IP_IOC_RTS_REQUEST, ip_rts_request, 0, IPFT_F_SELF_REPLY },
237 { 0 }
238 };
239
240 /* Simple ICMP IP Header Template */
241 static ipha_t icmp_ipha = {
242 IP_SIMPLE_HDR_VERSION, 0, 0, 0, 0, 0, IPPROTO_ICMP
243 };
244
245 static uchar_t ip_six_byte_all_ones[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
246
247 static ip_m_t ip_m_tbl[] = {
248 { DL_ETHER, IFT_ETHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
249 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_ether_v6intfid,
250 ip_nodef_v6intfid },
251 { DL_CSMACD, IFT_ISO88023, ETHERTYPE_IP, ETHERTYPE_IPV6,
252 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
253 ip_nodef_v6intfid },
254 { DL_TPB, IFT_ISO88024, ETHERTYPE_IP, ETHERTYPE_IPV6,
255 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
256 ip_nodef_v6intfid },
257 { DL_TPR, IFT_ISO88025, ETHERTYPE_IP, ETHERTYPE_IPV6,
258 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
259 ip_nodef_v6intfid },
260 { DL_FDDI, IFT_FDDI, ETHERTYPE_IP, ETHERTYPE_IPV6,
261 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_ether_v6intfid,
262 ip_nodef_v6intfid },
263 { DL_IB, IFT_IB, ETHERTYPE_IP, ETHERTYPE_IPV6,
264 ip_ib_v4_mapping, ip_ib_v6_mapping, ip_ib_v6intfid,
265 ip_nodef_v6intfid },
266 { DL_IPV4, IFT_IPV4, IPPROTO_ENCAP, IPPROTO_IPV6,
267 ip_mbcast_mapping, ip_mbcast_mapping, ip_ipv4_v6intfid,
268 ip_ipv4_v6destintfid },
269 { DL_IPV6, IFT_IPV6, IPPROTO_ENCAP, IPPROTO_IPV6,
270 ip_mbcast_mapping, ip_mbcast_mapping, ip_ipv6_v6intfid,
271 ip_ipv6_v6destintfid },
272 { DL_6TO4, IFT_6TO4, IPPROTO_ENCAP, IPPROTO_IPV6,
273 ip_mbcast_mapping, ip_mbcast_mapping, ip_ipv4_v6intfid,
274 ip_nodef_v6intfid },
275 { SUNW_DL_VNI, IFT_OTHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
276 NULL, NULL, ip_nodef_v6intfid, ip_nodef_v6intfid },
277 { SUNW_DL_IPMP, IFT_OTHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
278 NULL, NULL, ip_ipmp_v6intfid, ip_nodef_v6intfid },
279 { DL_OTHER, IFT_OTHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
280 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
281 ip_nodef_v6intfid }
282 };
283
284 static ill_t ill_null; /* Empty ILL for init. */
285 char ipif_loopback_name[] = "lo0";
286
287 /* These are used by all IP network modules. */
288 sin6_t sin6_null; /* Zero address for quick clears */
289 sin_t sin_null; /* Zero address for quick clears */
290
291 /* When set search for unused ipif_seqid */
292 static ipif_t ipif_zero;
293
294 /*
295 * ppa arena is created after these many
296 * interfaces have been plumbed.
297 */
298 uint_t ill_no_arena = 12; /* Setable in /etc/system */
299
300 /*
301 * Allocate per-interface mibs.
302 * Returns true if ok. False otherwise.
303 * ipsq may not yet be allocated (loopback case ).
304 */
305 static boolean_t
306 ill_allocate_mibs(ill_t *ill)
307 {
308 /* Already allocated? */
309 if (ill->ill_ip_mib != NULL) {
310 if (ill->ill_isv6)
311 ASSERT(ill->ill_icmp6_mib != NULL);
312 return (B_TRUE);
313 }
314
315 ill->ill_ip_mib = kmem_zalloc(sizeof (*ill->ill_ip_mib),
316 KM_NOSLEEP);
317 if (ill->ill_ip_mib == NULL) {
318 return (B_FALSE);
319 }
320
321 /* Setup static information */
322 SET_MIB(ill->ill_ip_mib->ipIfStatsEntrySize,
323 sizeof (mib2_ipIfStatsEntry_t));
324 if (ill->ill_isv6) {
325 ill->ill_ip_mib->ipIfStatsIPVersion = MIB2_INETADDRESSTYPE_ipv6;
326 SET_MIB(ill->ill_ip_mib->ipIfStatsAddrEntrySize,
327 sizeof (mib2_ipv6AddrEntry_t));
328 SET_MIB(ill->ill_ip_mib->ipIfStatsRouteEntrySize,
329 sizeof (mib2_ipv6RouteEntry_t));
330 SET_MIB(ill->ill_ip_mib->ipIfStatsNetToMediaEntrySize,
331 sizeof (mib2_ipv6NetToMediaEntry_t));
332 SET_MIB(ill->ill_ip_mib->ipIfStatsMemberEntrySize,
333 sizeof (ipv6_member_t));
334 SET_MIB(ill->ill_ip_mib->ipIfStatsGroupSourceEntrySize,
335 sizeof (ipv6_grpsrc_t));
336 } else {
337 ill->ill_ip_mib->ipIfStatsIPVersion = MIB2_INETADDRESSTYPE_ipv4;
338 SET_MIB(ill->ill_ip_mib->ipIfStatsAddrEntrySize,
339 sizeof (mib2_ipAddrEntry_t));
340 SET_MIB(ill->ill_ip_mib->ipIfStatsRouteEntrySize,
341 sizeof (mib2_ipRouteEntry_t));
342 SET_MIB(ill->ill_ip_mib->ipIfStatsNetToMediaEntrySize,
343 sizeof (mib2_ipNetToMediaEntry_t));
344 SET_MIB(ill->ill_ip_mib->ipIfStatsMemberEntrySize,
345 sizeof (ip_member_t));
346 SET_MIB(ill->ill_ip_mib->ipIfStatsGroupSourceEntrySize,
347 sizeof (ip_grpsrc_t));
348
349 /*
350 * For a v4 ill, we are done at this point, because per ill
351 * icmp mibs are only used for v6.
352 */
353 return (B_TRUE);
354 }
355
356 ill->ill_icmp6_mib = kmem_zalloc(sizeof (*ill->ill_icmp6_mib),
357 KM_NOSLEEP);
358 if (ill->ill_icmp6_mib == NULL) {
359 kmem_free(ill->ill_ip_mib, sizeof (*ill->ill_ip_mib));
360 ill->ill_ip_mib = NULL;
361 return (B_FALSE);
362 }
363 /* static icmp info */
364 ill->ill_icmp6_mib->ipv6IfIcmpEntrySize =
365 sizeof (mib2_ipv6IfIcmpEntry_t);
366 /*
367 * The ipIfStatsIfindex and ipv6IfIcmpIndex will be assigned later
368 * after the phyint merge occurs in ipif_set_values -> ill_glist_insert
369 * -> ill_phyint_reinit
370 */
371 return (B_TRUE);
372 }
373
374 /*
375 * Completely vaporize a lower level tap and all associated interfaces.
376 * ill_delete is called only out of ip_close when the device control
377 * stream is being closed.
378 */
379 void
380 ill_delete(ill_t *ill)
381 {
382 ipif_t *ipif;
383 ill_t *prev_ill;
384 ip_stack_t *ipst = ill->ill_ipst;
385
386 /*
387 * ill_delete may be forcibly entering the ipsq. The previous
388 * ioctl may not have completed and may need to be aborted.
389 * ipsq_flush takes care of it. If we don't need to enter the
390 * the ipsq forcibly, the 2nd invocation of ipsq_flush in
391 * ill_delete_tail is sufficient.
392 */
393 ipsq_flush(ill);
394
395 /*
396 * Nuke all interfaces. ipif_free will take down the interface,
397 * remove it from the list, and free the data structure.
398 * Walk down the ipif list and remove the logical interfaces
399 * first before removing the main ipif. We can't unplumb
400 * zeroth interface first in the case of IPv6 as update_conn_ill
401 * -> ip_ll_multireq de-references ill_ipif for checking
402 * POINTOPOINT.
403 *
404 * If ill_ipif was not properly initialized (i.e low on memory),
405 * then no interfaces to clean up. In this case just clean up the
406 * ill.
407 */
408 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
409 ipif_free(ipif);
410
411 /*
412 * clean out all the nce_t entries that depend on this
413 * ill for the ill_phys_addr.
414 */
415 nce_flush(ill, B_TRUE);
416
417 /* Clean up msgs on pending upcalls for mrouted */
418 reset_mrt_ill(ill);
419
420 update_conn_ill(ill, ipst);
421
422 /*
423 * Remove multicast references added as a result of calls to
424 * ip_join_allmulti().
425 */
426 ip_purge_allmulti(ill);
427
428 /*
429 * If the ill being deleted is under IPMP, boot it out of the illgrp.
430 */
431 if (IS_UNDER_IPMP(ill))
432 ipmp_ill_leave_illgrp(ill);
433
434 /*
435 * ill_down will arrange to blow off any IRE's dependent on this
436 * ILL, and shut down fragmentation reassembly.
437 */
438 ill_down(ill);
439
440 /* Let SCTP know, so that it can remove this from its list. */
441 sctp_update_ill(ill, SCTP_ILL_REMOVE);
442
443 /*
444 * Walk all CONNs that can have a reference on an ire or nce for this
445 * ill (we actually walk all that now have stale references).
446 */
447 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ipst);
448
449 /* With IPv6 we have dce_ifindex. Cleanup for neatness */
450 if (ill->ill_isv6)
451 dce_cleanup(ill->ill_phyint->phyint_ifindex, ipst);
452
453 /*
454 * If an address on this ILL is being used as a source address then
455 * clear out the pointers in other ILLs that point to this ILL.
456 */
457 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_WRITER);
458 if (ill->ill_usesrc_grp_next != NULL) {
459 if (ill->ill_usesrc_ifindex == 0) { /* usesrc ILL ? */
460 ill_disband_usesrc_group(ill);
461 } else { /* consumer of the usesrc ILL */
462 prev_ill = ill_prev_usesrc(ill);
463 prev_ill->ill_usesrc_grp_next =
464 ill->ill_usesrc_grp_next;
465 }
466 }
467 rw_exit(&ipst->ips_ill_g_usesrc_lock);
468 }
469
470 static void
471 ipif_non_duplicate(ipif_t *ipif)
472 {
473 ill_t *ill = ipif->ipif_ill;
474 mutex_enter(&ill->ill_lock);
475 if (ipif->ipif_flags & IPIF_DUPLICATE) {
476 ipif->ipif_flags &= ~IPIF_DUPLICATE;
477 ASSERT(ill->ill_ipif_dup_count > 0);
478 ill->ill_ipif_dup_count--;
479 }
480 mutex_exit(&ill->ill_lock);
481 }
482
483 /*
484 * ill_delete_tail is called from ip_modclose after all references
485 * to the closing ill are gone. The wait is done in ip_modclose
486 */
487 void
488 ill_delete_tail(ill_t *ill)
489 {
490 mblk_t **mpp;
491 ipif_t *ipif;
492 ip_stack_t *ipst = ill->ill_ipst;
493
494 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
495 ipif_non_duplicate(ipif);
496 (void) ipif_down_tail(ipif);
497 }
498
499 ASSERT(ill->ill_ipif_dup_count == 0);
500
501 /*
502 * If polling capability is enabled (which signifies direct
503 * upcall into IP and driver has ill saved as a handle),
504 * we need to make sure that unbind has completed before we
505 * let the ill disappear and driver no longer has any reference
506 * to this ill.
507 */
508 mutex_enter(&ill->ill_lock);
509 while (ill->ill_state_flags & ILL_DL_UNBIND_IN_PROGRESS)
510 cv_wait(&ill->ill_cv, &ill->ill_lock);
511 mutex_exit(&ill->ill_lock);
512 ASSERT(!(ill->ill_capabilities &
513 (ILL_CAPAB_DLD | ILL_CAPAB_DLD_POLL | ILL_CAPAB_DLD_DIRECT)));
514
515 if (ill->ill_net_type != IRE_LOOPBACK)
516 qprocsoff(ill->ill_rq);
517
518 /*
519 * We do an ipsq_flush once again now. New messages could have
520 * landed up from below (M_ERROR or M_HANGUP). Similarly ioctls
521 * could also have landed up if an ioctl thread had looked up
522 * the ill before we set the ILL_CONDEMNED flag, but not yet
523 * enqueued the ioctl when we did the ipsq_flush last time.
524 */
525 ipsq_flush(ill);
526
527 /*
528 * Free capabilities.
529 */
530 if (ill->ill_hcksum_capab != NULL) {
531 kmem_free(ill->ill_hcksum_capab, sizeof (ill_hcksum_capab_t));
532 ill->ill_hcksum_capab = NULL;
533 }
534
535 if (ill->ill_zerocopy_capab != NULL) {
536 kmem_free(ill->ill_zerocopy_capab,
537 sizeof (ill_zerocopy_capab_t));
538 ill->ill_zerocopy_capab = NULL;
539 }
540
541 if (ill->ill_lso_capab != NULL) {
542 kmem_free(ill->ill_lso_capab, sizeof (ill_lso_capab_t));
543 ill->ill_lso_capab = NULL;
544 }
545
546 if (ill->ill_dld_capab != NULL) {
547 kmem_free(ill->ill_dld_capab, sizeof (ill_dld_capab_t));
548 ill->ill_dld_capab = NULL;
549 }
550
551 /* Clean up ill_allowed_ips* related state */
552 if (ill->ill_allowed_ips != NULL) {
553 ASSERT(ill->ill_allowed_ips_cnt > 0);
554 kmem_free(ill->ill_allowed_ips,
555 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
556 ill->ill_allowed_ips = NULL;
557 ill->ill_allowed_ips_cnt = 0;
558 }
559
560 while (ill->ill_ipif != NULL)
561 ipif_free_tail(ill->ill_ipif);
562
563 /*
564 * We have removed all references to ilm from conn and the ones joined
565 * within the kernel.
566 *
567 * We don't walk conns, mrts and ires because
568 *
569 * 1) update_conn_ill and reset_mrt_ill cleans up conns and mrts.
570 * 2) ill_down ->ill_downi walks all the ires and cleans up
571 * ill references.
572 */
573
574 /*
575 * If this ill is an IPMP meta-interface, blow away the illgrp. This
576 * is safe to do because the illgrp has already been unlinked from the
577 * group by I_PUNLINK, and thus SIOCSLIFGROUPNAME cannot find it.
578 */
579 if (IS_IPMP(ill)) {
580 ipmp_illgrp_destroy(ill->ill_grp);
581 ill->ill_grp = NULL;
582 }
583
584 if (ill->ill_mphysaddr_list != NULL) {
585 multiphysaddr_t *mpa, *tmpa;
586
587 mpa = ill->ill_mphysaddr_list;
588 ill->ill_mphysaddr_list = NULL;
589 while (mpa) {
590 tmpa = mpa->mpa_next;
591 kmem_free(mpa, sizeof (*mpa));
592 mpa = tmpa;
593 }
594 }
595 /*
596 * Take us out of the list of ILLs. ill_glist_delete -> phyint_free
597 * could free the phyint. No more reference to the phyint after this
598 * point.
599 */
600 (void) ill_glist_delete(ill);
601
602 if (ill->ill_frag_ptr != NULL) {
603 uint_t count;
604
605 for (count = 0; count < ILL_FRAG_HASH_TBL_COUNT; count++) {
606 mutex_destroy(&ill->ill_frag_hash_tbl[count].ipfb_lock);
607 }
608 mi_free(ill->ill_frag_ptr);
609 ill->ill_frag_ptr = NULL;
610 ill->ill_frag_hash_tbl = NULL;
611 }
612
613 freemsg(ill->ill_nd_lla_mp);
614 /* Free all retained control messages. */
615 mpp = &ill->ill_first_mp_to_free;
616 do {
617 while (mpp[0]) {
618 mblk_t *mp;
619 mblk_t *mp1;
620
621 mp = mpp[0];
622 mpp[0] = mp->b_next;
623 for (mp1 = mp; mp1 != NULL; mp1 = mp1->b_cont) {
624 mp1->b_next = NULL;
625 mp1->b_prev = NULL;
626 }
627 freemsg(mp);
628 }
629 } while (mpp++ != &ill->ill_last_mp_to_free);
630
631 ill_free_mib(ill);
632
633 #ifdef DEBUG
634 ill_trace_cleanup(ill);
635 #endif
636
637 /* The default multicast interface might have changed */
638 ire_increment_multicast_generation(ipst, ill->ill_isv6);
639
640 /* Drop refcnt here */
641 netstack_rele(ill->ill_ipst->ips_netstack);
642 ill->ill_ipst = NULL;
643 }
644
645 static void
646 ill_free_mib(ill_t *ill)
647 {
648 ip_stack_t *ipst = ill->ill_ipst;
649
650 /*
651 * MIB statistics must not be lost, so when an interface
652 * goes away the counter values will be added to the global
653 * MIBs.
654 */
655 if (ill->ill_ip_mib != NULL) {
656 if (ill->ill_isv6) {
657 ip_mib2_add_ip_stats(&ipst->ips_ip6_mib,
658 ill->ill_ip_mib);
659 } else {
660 ip_mib2_add_ip_stats(&ipst->ips_ip_mib,
661 ill->ill_ip_mib);
662 }
663
664 kmem_free(ill->ill_ip_mib, sizeof (*ill->ill_ip_mib));
665 ill->ill_ip_mib = NULL;
666 }
667 if (ill->ill_icmp6_mib != NULL) {
668 ip_mib2_add_icmp6_stats(&ipst->ips_icmp6_mib,
669 ill->ill_icmp6_mib);
670 kmem_free(ill->ill_icmp6_mib, sizeof (*ill->ill_icmp6_mib));
671 ill->ill_icmp6_mib = NULL;
672 }
673 }
674
675 /*
676 * Concatenate together a physical address and a sap.
677 *
678 * Sap_lengths are interpreted as follows:
679 * sap_length == 0 ==> no sap
680 * sap_length > 0 ==> sap is at the head of the dlpi address
681 * sap_length < 0 ==> sap is at the tail of the dlpi address
682 */
683 static void
684 ill_dlur_copy_address(uchar_t *phys_src, uint_t phys_length,
685 t_scalar_t sap_src, t_scalar_t sap_length, uchar_t *dst)
686 {
687 uint16_t sap_addr = (uint16_t)sap_src;
688
689 if (sap_length == 0) {
690 if (phys_src == NULL)
691 bzero(dst, phys_length);
692 else
693 bcopy(phys_src, dst, phys_length);
694 } else if (sap_length < 0) {
695 if (phys_src == NULL)
696 bzero(dst, phys_length);
697 else
698 bcopy(phys_src, dst, phys_length);
699 bcopy(&sap_addr, (char *)dst + phys_length, sizeof (sap_addr));
700 } else {
701 bcopy(&sap_addr, dst, sizeof (sap_addr));
702 if (phys_src == NULL)
703 bzero((char *)dst + sap_length, phys_length);
704 else
705 bcopy(phys_src, (char *)dst + sap_length, phys_length);
706 }
707 }
708
709 /*
710 * Generate a dl_unitdata_req mblk for the device and address given.
711 * addr_length is the length of the physical portion of the address.
712 * If addr is NULL include an all zero address of the specified length.
713 * TRUE? In any case, addr_length is taken to be the entire length of the
714 * dlpi address, including the absolute value of sap_length.
715 */
716 mblk_t *
717 ill_dlur_gen(uchar_t *addr, uint_t addr_length, t_uscalar_t sap,
718 t_scalar_t sap_length)
719 {
720 dl_unitdata_req_t *dlur;
721 mblk_t *mp;
722 t_scalar_t abs_sap_length; /* absolute value */
723
724 abs_sap_length = ABS(sap_length);
725 mp = ip_dlpi_alloc(sizeof (*dlur) + addr_length + abs_sap_length,
726 DL_UNITDATA_REQ);
727 if (mp == NULL)
728 return (NULL);
729 dlur = (dl_unitdata_req_t *)mp->b_rptr;
730 /* HACK: accomodate incompatible DLPI drivers */
731 if (addr_length == 8)
732 addr_length = 6;
733 dlur->dl_dest_addr_length = addr_length + abs_sap_length;
734 dlur->dl_dest_addr_offset = sizeof (*dlur);
735 dlur->dl_priority.dl_min = 0;
736 dlur->dl_priority.dl_max = 0;
737 ill_dlur_copy_address(addr, addr_length, sap, sap_length,
738 (uchar_t *)&dlur[1]);
739 return (mp);
740 }
741
742 /*
743 * Add the pending mp to the list. There can be only 1 pending mp
744 * in the list. Any exclusive ioctl that needs to wait for a response
745 * from another module or driver needs to use this function to set
746 * the ipx_pending_mp to the ioctl mblk and wait for the response from
747 * the other module/driver. This is also used while waiting for the
748 * ipif/ill/ire refcnts to drop to zero in bringing down an ipif.
749 */
750 boolean_t
751 ipsq_pending_mp_add(conn_t *connp, ipif_t *ipif, queue_t *q, mblk_t *add_mp,
752 int waitfor)
753 {
754 ipxop_t *ipx = ipif->ipif_ill->ill_phyint->phyint_ipsq->ipsq_xop;
755
756 ASSERT(IAM_WRITER_IPIF(ipif));
757 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
758 ASSERT((add_mp->b_next == NULL) && (add_mp->b_prev == NULL));
759 ASSERT(ipx->ipx_pending_mp == NULL);
760 /*
761 * The caller may be using a different ipif than the one passed into
762 * ipsq_current_start() (e.g., suppose an ioctl that came in on the V4
763 * ill needs to wait for the V6 ill to quiesce). So we can't ASSERT
764 * that `ipx_current_ipif == ipif'.
765 */
766 ASSERT(ipx->ipx_current_ipif != NULL);
767
768 /*
769 * M_IOCDATA from ioctls, M_ERROR/M_HANGUP/M_PROTO/M_PCPROTO from the
770 * driver.
771 */
772 ASSERT((DB_TYPE(add_mp) == M_IOCDATA) || (DB_TYPE(add_mp) == M_ERROR) ||
773 (DB_TYPE(add_mp) == M_HANGUP) || (DB_TYPE(add_mp) == M_PROTO) ||
774 (DB_TYPE(add_mp) == M_PCPROTO));
775
776 if (connp != NULL) {
777 ASSERT(MUTEX_HELD(&connp->conn_lock));
778 /*
779 * Return error if the conn has started closing. The conn
780 * could have finished cleaning up the pending mp list,
781 * If so we should not add another mp to the list negating
782 * the cleanup.
783 */
784 if (connp->conn_state_flags & CONN_CLOSING)
785 return (B_FALSE);
786 }
787 mutex_enter(&ipx->ipx_lock);
788 ipx->ipx_pending_ipif = ipif;
789 /*
790 * Note down the queue in b_queue. This will be returned by
791 * ipsq_pending_mp_get. Caller will then use these values to restart
792 * the processing
793 */
794 add_mp->b_next = NULL;
795 add_mp->b_queue = q;
796 ipx->ipx_pending_mp = add_mp;
797 ipx->ipx_waitfor = waitfor;
798 mutex_exit(&ipx->ipx_lock);
799
800 if (connp != NULL)
801 connp->conn_oper_pending_ill = ipif->ipif_ill;
802
803 return (B_TRUE);
804 }
805
806 /*
807 * Retrieve the ipx_pending_mp and return it. There can be only 1 mp
808 * queued in the list.
809 */
810 mblk_t *
811 ipsq_pending_mp_get(ipsq_t *ipsq, conn_t **connpp)
812 {
813 mblk_t *curr = NULL;
814 ipxop_t *ipx = ipsq->ipsq_xop;
815
816 *connpp = NULL;
817 mutex_enter(&ipx->ipx_lock);
818 if (ipx->ipx_pending_mp == NULL) {
819 mutex_exit(&ipx->ipx_lock);
820 return (NULL);
821 }
822
823 /* There can be only 1 such excl message */
824 curr = ipx->ipx_pending_mp;
825 ASSERT(curr->b_next == NULL);
826 ipx->ipx_pending_ipif = NULL;
827 ipx->ipx_pending_mp = NULL;
828 ipx->ipx_waitfor = 0;
829 mutex_exit(&ipx->ipx_lock);
830
831 if (CONN_Q(curr->b_queue)) {
832 /*
833 * This mp did a refhold on the conn, at the start of the ioctl.
834 * So we can safely return a pointer to the conn to the caller.
835 */
836 *connpp = Q_TO_CONN(curr->b_queue);
837 } else {
838 *connpp = NULL;
839 }
840 curr->b_next = NULL;
841 curr->b_prev = NULL;
842 return (curr);
843 }
844
845 /*
846 * Cleanup the ioctl mp queued in ipx_pending_mp
847 * - Called in the ill_delete path
848 * - Called in the M_ERROR or M_HANGUP path on the ill.
849 * - Called in the conn close path.
850 *
851 * Returns success on finding the pending mblk associated with the ioctl or
852 * exclusive operation in progress, failure otherwise.
853 */
854 boolean_t
855 ipsq_pending_mp_cleanup(ill_t *ill, conn_t *connp)
856 {
857 mblk_t *mp;
858 ipxop_t *ipx;
859 queue_t *q;
860 ipif_t *ipif;
861 int cmd;
862
863 ASSERT(IAM_WRITER_ILL(ill));
864 ipx = ill->ill_phyint->phyint_ipsq->ipsq_xop;
865
866 mutex_enter(&ipx->ipx_lock);
867 mp = ipx->ipx_pending_mp;
868 if (connp != NULL) {
869 if (mp == NULL || mp->b_queue != CONNP_TO_WQ(connp)) {
870 /*
871 * Nothing to clean since the conn that is closing
872 * does not have a matching pending mblk in
873 * ipx_pending_mp.
874 */
875 mutex_exit(&ipx->ipx_lock);
876 return (B_FALSE);
877 }
878 } else {
879 /*
880 * A non-zero ill_error signifies we are called in the
881 * M_ERROR or M_HANGUP path and we need to unconditionally
882 * abort any current ioctl and do the corresponding cleanup.
883 * A zero ill_error means we are in the ill_delete path and
884 * we do the cleanup only if there is a pending mp.
885 */
886 if (mp == NULL && ill->ill_error == 0) {
887 mutex_exit(&ipx->ipx_lock);
888 return (B_FALSE);
889 }
890 }
891
892 /* Now remove from the ipx_pending_mp */
893 ipx->ipx_pending_mp = NULL;
894 ipif = ipx->ipx_pending_ipif;
895 ipx->ipx_pending_ipif = NULL;
896 ipx->ipx_waitfor = 0;
897 ipx->ipx_current_ipif = NULL;
898 cmd = ipx->ipx_current_ioctl;
899 ipx->ipx_current_ioctl = 0;
900 ipx->ipx_current_done = B_TRUE;
901 mutex_exit(&ipx->ipx_lock);
902
903 if (mp == NULL)
904 return (B_FALSE);
905
906 q = mp->b_queue;
907 mp->b_next = NULL;
908 mp->b_prev = NULL;
909 mp->b_queue = NULL;
910
911 if (DB_TYPE(mp) == M_IOCTL || DB_TYPE(mp) == M_IOCDATA) {
912 DTRACE_PROBE4(ipif__ioctl,
913 char *, "ipsq_pending_mp_cleanup",
914 int, cmd, ill_t *, ipif == NULL ? NULL : ipif->ipif_ill,
915 ipif_t *, ipif);
916 if (connp == NULL) {
917 ip_ioctl_finish(q, mp, ENXIO, NO_COPYOUT, NULL);
918 } else {
919 ip_ioctl_finish(q, mp, ENXIO, CONN_CLOSE, NULL);
920 mutex_enter(&ipif->ipif_ill->ill_lock);
921 ipif->ipif_state_flags &= ~IPIF_CHANGING;
922 mutex_exit(&ipif->ipif_ill->ill_lock);
923 }
924 } else {
925 inet_freemsg(mp);
926 }
927 return (B_TRUE);
928 }
929
930 /*
931 * Called in the conn close path and ill delete path
932 */
933 static void
934 ipsq_xopq_mp_cleanup(ill_t *ill, conn_t *connp)
935 {
936 ipsq_t *ipsq;
937 mblk_t *prev;
938 mblk_t *curr;
939 mblk_t *next;
940 queue_t *wq, *rq = NULL;
941 mblk_t *tmp_list = NULL;
942
943 ASSERT(IAM_WRITER_ILL(ill));
944 if (connp != NULL)
945 wq = CONNP_TO_WQ(connp);
946 else
947 wq = ill->ill_wq;
948
949 /*
950 * In the case of lo0 being unplumbed, ill_wq will be NULL. Guard
951 * against this here.
952 */
953 if (wq != NULL)
954 rq = RD(wq);
955
956 ipsq = ill->ill_phyint->phyint_ipsq;
957 /*
958 * Cleanup the ioctl mp's queued in ipsq_xopq_pending_mp if any.
959 * In the case of ioctl from a conn, there can be only 1 mp
960 * queued on the ipsq. If an ill is being unplumbed flush all
961 * the messages.
962 */
963 mutex_enter(&ipsq->ipsq_lock);
964 for (prev = NULL, curr = ipsq->ipsq_xopq_mphead; curr != NULL;
965 curr = next) {
966 next = curr->b_next;
967 if (connp == NULL ||
968 (curr->b_queue == wq || curr->b_queue == rq)) {
969 /* Unlink the mblk from the pending mp list */
970 if (prev != NULL) {
971 prev->b_next = curr->b_next;
972 } else {
973 ASSERT(ipsq->ipsq_xopq_mphead == curr);
974 ipsq->ipsq_xopq_mphead = curr->b_next;
975 }
976 if (ipsq->ipsq_xopq_mptail == curr)
977 ipsq->ipsq_xopq_mptail = prev;
978 /*
979 * Create a temporary list and release the ipsq lock
980 * New elements are added to the head of the tmp_list
981 */
982 curr->b_next = tmp_list;
983 tmp_list = curr;
984 } else {
985 prev = curr;
986 }
987 }
988 mutex_exit(&ipsq->ipsq_lock);
989
990 while (tmp_list != NULL) {
991 curr = tmp_list;
992 tmp_list = curr->b_next;
993 curr->b_next = NULL;
994 curr->b_prev = NULL;
995 wq = curr->b_queue;
996 curr->b_queue = NULL;
997 if (DB_TYPE(curr) == M_IOCTL || DB_TYPE(curr) == M_IOCDATA) {
998 DTRACE_PROBE4(ipif__ioctl,
999 char *, "ipsq_xopq_mp_cleanup",
1000 int, 0, ill_t *, NULL, ipif_t *, NULL);
1001 ip_ioctl_finish(wq, curr, ENXIO, connp != NULL ?
1002 CONN_CLOSE : NO_COPYOUT, NULL);
1003 } else {
1004 /*
1005 * IP-MT XXX In the case of TLI/XTI bind / optmgmt
1006 * this can't be just inet_freemsg. we have to
1007 * restart it otherwise the thread will be stuck.
1008 */
1009 inet_freemsg(curr);
1010 }
1011 }
1012 }
1013
1014 /*
1015 * This conn has started closing. Cleanup any pending ioctl from this conn.
1016 * STREAMS ensures that there can be at most 1 active ioctl on a stream.
1017 */
1018 void
1019 conn_ioctl_cleanup(conn_t *connp)
1020 {
1021 ipsq_t *ipsq;
1022 ill_t *ill;
1023 boolean_t refheld;
1024
1025 /*
1026 * Check for a queued ioctl. If the ioctl has not yet started, the mp
1027 * is pending in the list headed by ipsq_xopq_head. If the ioctl has
1028 * started the mp could be present in ipx_pending_mp. Note that if
1029 * conn_oper_pending_ill is NULL, the ioctl may still be in flight and
1030 * not yet queued anywhere. In this case, the conn close code will wait
1031 * until the conn_ref is dropped. If the stream was a tcp stream, then
1032 * tcp_close will wait first until all ioctls have completed for this
1033 * conn.
1034 */
1035 mutex_enter(&connp->conn_lock);
1036 ill = connp->conn_oper_pending_ill;
1037 if (ill == NULL) {
1038 mutex_exit(&connp->conn_lock);
1039 return;
1040 }
1041
1042 /*
1043 * We may not be able to refhold the ill if the ill/ipif
1044 * is changing. But we need to make sure that the ill will
1045 * not vanish. So we just bump up the ill_waiter count.
1046 */
1047 refheld = ill_waiter_inc(ill);
1048 mutex_exit(&connp->conn_lock);
1049 if (refheld) {
1050 if (ipsq_enter(ill, B_TRUE, NEW_OP)) {
1051 ill_waiter_dcr(ill);
1052 /*
1053 * Check whether this ioctl has started and is
1054 * pending. If it is not found there then check
1055 * whether this ioctl has not even started and is in
1056 * the ipsq_xopq list.
1057 */
1058 if (!ipsq_pending_mp_cleanup(ill, connp))
1059 ipsq_xopq_mp_cleanup(ill, connp);
1060 ipsq = ill->ill_phyint->phyint_ipsq;
1061 ipsq_exit(ipsq);
1062 return;
1063 }
1064 }
1065
1066 /*
1067 * The ill is also closing and we could not bump up the
1068 * ill_waiter_count or we could not enter the ipsq. Leave
1069 * the cleanup to ill_delete
1070 */
1071 mutex_enter(&connp->conn_lock);
1072 while (connp->conn_oper_pending_ill != NULL)
1073 cv_wait(&connp->conn_refcv, &connp->conn_lock);
1074 mutex_exit(&connp->conn_lock);
1075 if (refheld)
1076 ill_waiter_dcr(ill);
1077 }
1078
1079 /*
1080 * ipcl_walk function for cleaning up conn_*_ill fields.
1081 * Note that we leave ixa_multicast_ifindex, conn_incoming_ifindex, and
1082 * conn_bound_if in place. We prefer dropping
1083 * packets instead of sending them out the wrong interface, or accepting
1084 * packets from the wrong ifindex.
1085 */
1086 static void
1087 conn_cleanup_ill(conn_t *connp, caddr_t arg)
1088 {
1089 ill_t *ill = (ill_t *)arg;
1090
1091 mutex_enter(&connp->conn_lock);
1092 if (connp->conn_dhcpinit_ill == ill) {
1093 connp->conn_dhcpinit_ill = NULL;
1094 ASSERT(ill->ill_dhcpinit != 0);
1095 atomic_dec_32(&ill->ill_dhcpinit);
1096 ill_set_inputfn(ill);
1097 }
1098 mutex_exit(&connp->conn_lock);
1099 }
1100
1101 static int
1102 ill_down_ipifs_tail(ill_t *ill)
1103 {
1104 ipif_t *ipif;
1105 int err;
1106
1107 ASSERT(IAM_WRITER_ILL(ill));
1108 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
1109 ipif_non_duplicate(ipif);
1110 /*
1111 * ipif_down_tail will call arp_ll_down on the last ipif
1112 * and typically return EINPROGRESS when the DL_UNBIND is sent.
1113 */
1114 if ((err = ipif_down_tail(ipif)) != 0)
1115 return (err);
1116 }
1117 return (0);
1118 }
1119
1120 /* ARGSUSED */
1121 void
1122 ipif_all_down_tail(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg)
1123 {
1124 ASSERT(IAM_WRITER_IPSQ(ipsq));
1125 (void) ill_down_ipifs_tail(q->q_ptr);
1126 freemsg(mp);
1127 ipsq_current_finish(ipsq);
1128 }
1129
1130 /*
1131 * ill_down_start is called when we want to down this ill and bring it up again
1132 * It is called when we receive an M_ERROR / M_HANGUP. In this case we shut down
1133 * all interfaces, but don't tear down any plumbing.
1134 */
1135 boolean_t
1136 ill_down_start(queue_t *q, mblk_t *mp)
1137 {
1138 ill_t *ill = q->q_ptr;
1139 ipif_t *ipif;
1140
1141 ASSERT(IAM_WRITER_ILL(ill));
1142 /*
1143 * It is possible that some ioctl is already in progress while we
1144 * received the M_ERROR / M_HANGUP in which case, we need to abort
1145 * the ioctl. ill_down_start() is being processed as CUR_OP rather
1146 * than as NEW_OP since the cause of the M_ERROR / M_HANGUP may prevent
1147 * the in progress ioctl from ever completing.
1148 *
1149 * The thread that started the ioctl (if any) must have returned,
1150 * since we are now executing as writer. After the 2 calls below,
1151 * the state of the ipsq and the ill would reflect no trace of any
1152 * pending operation. Subsequently if there is any response to the
1153 * original ioctl from the driver, it would be discarded as an
1154 * unsolicited message from the driver.
1155 */
1156 (void) ipsq_pending_mp_cleanup(ill, NULL);
1157 ill_dlpi_clear_deferred(ill);
1158
1159 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
1160 (void) ipif_down(ipif, NULL, NULL);
1161
1162 ill_down(ill);
1163
1164 /*
1165 * Walk all CONNs that can have a reference on an ire or nce for this
1166 * ill (we actually walk all that now have stale references).
1167 */
1168 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ill->ill_ipst);
1169
1170 /* With IPv6 we have dce_ifindex. Cleanup for neatness */
1171 if (ill->ill_isv6)
1172 dce_cleanup(ill->ill_phyint->phyint_ifindex, ill->ill_ipst);
1173
1174 ipsq_current_start(ill->ill_phyint->phyint_ipsq, ill->ill_ipif, 0);
1175
1176 /*
1177 * Atomically test and add the pending mp if references are active.
1178 */
1179 mutex_enter(&ill->ill_lock);
1180 if (!ill_is_quiescent(ill)) {
1181 /* call cannot fail since `conn_t *' argument is NULL */
1182 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
1183 mp, ILL_DOWN);
1184 mutex_exit(&ill->ill_lock);
1185 return (B_FALSE);
1186 }
1187 mutex_exit(&ill->ill_lock);
1188 return (B_TRUE);
1189 }
1190
1191 static void
1192 ill_down(ill_t *ill)
1193 {
1194 mblk_t *mp;
1195 ip_stack_t *ipst = ill->ill_ipst;
1196
1197 /*
1198 * Blow off any IREs dependent on this ILL.
1199 * The caller needs to handle conn_ixa_cleanup
1200 */
1201 ill_delete_ires(ill);
1202
1203 ire_walk_ill(0, 0, ill_downi, ill, ill);
1204
1205 /* Remove any conn_*_ill depending on this ill */
1206 ipcl_walk(conn_cleanup_ill, (caddr_t)ill, ipst);
1207
1208 /*
1209 * Free state for additional IREs.
1210 */
1211 mutex_enter(&ill->ill_saved_ire_lock);
1212 mp = ill->ill_saved_ire_mp;
1213 ill->ill_saved_ire_mp = NULL;
1214 ill->ill_saved_ire_cnt = 0;
1215 mutex_exit(&ill->ill_saved_ire_lock);
1216 freemsg(mp);
1217 }
1218
1219 /*
1220 * ire_walk routine used to delete every IRE that depends on
1221 * 'ill'. (Always called as writer, and may only be called from ire_walk.)
1222 *
1223 * Note: since the routes added by the kernel are deleted separately,
1224 * this will only be 1) IRE_IF_CLONE and 2) manually added IRE_INTERFACE.
1225 *
1226 * We also remove references on ire_nce_cache entries that refer to the ill.
1227 */
1228 void
1229 ill_downi(ire_t *ire, char *ill_arg)
1230 {
1231 ill_t *ill = (ill_t *)ill_arg;
1232 nce_t *nce;
1233
1234 mutex_enter(&ire->ire_lock);
1235 nce = ire->ire_nce_cache;
1236 if (nce != NULL && nce->nce_ill == ill)
1237 ire->ire_nce_cache = NULL;
1238 else
1239 nce = NULL;
1240 mutex_exit(&ire->ire_lock);
1241 if (nce != NULL)
1242 nce_refrele(nce);
1243 if (ire->ire_ill == ill) {
1244 /*
1245 * The existing interface binding for ire must be
1246 * deleted before trying to bind the route to another
1247 * interface. However, since we are using the contents of the
1248 * ire after ire_delete, the caller has to ensure that
1249 * CONDEMNED (deleted) ire's are not removed from the list
1250 * when ire_delete() returns. Currently ill_downi() is
1251 * only called as part of ire_walk*() routines, so that
1252 * the irb_refhold() done by ire_walk*() will ensure that
1253 * ire_delete() does not lead to ire_inactive().
1254 */
1255 ASSERT(ire->ire_bucket->irb_refcnt > 0);
1256 ire_delete(ire);
1257 if (ire->ire_unbound)
1258 ire_rebind(ire);
1259 }
1260 }
1261
1262 /* Remove IRE_IF_CLONE on this ill */
1263 void
1264 ill_downi_if_clone(ire_t *ire, char *ill_arg)
1265 {
1266 ill_t *ill = (ill_t *)ill_arg;
1267
1268 ASSERT(ire->ire_type & IRE_IF_CLONE);
1269 if (ire->ire_ill == ill)
1270 ire_delete(ire);
1271 }
1272
1273 /* Consume an M_IOCACK of the fastpath probe. */
1274 void
1275 ill_fastpath_ack(ill_t *ill, mblk_t *mp)
1276 {
1277 mblk_t *mp1 = mp;
1278
1279 /*
1280 * If this was the first attempt turn on the fastpath probing.
1281 */
1282 mutex_enter(&ill->ill_lock);
1283 if (ill->ill_dlpi_fastpath_state == IDS_INPROGRESS)
1284 ill->ill_dlpi_fastpath_state = IDS_OK;
1285 mutex_exit(&ill->ill_lock);
1286
1287 /* Free the M_IOCACK mblk, hold on to the data */
1288 mp = mp->b_cont;
1289 freeb(mp1);
1290 if (mp == NULL)
1291 return;
1292 if (mp->b_cont != NULL)
1293 nce_fastpath_update(ill, mp);
1294 else
1295 ip0dbg(("ill_fastpath_ack: no b_cont\n"));
1296 freemsg(mp);
1297 }
1298
1299 /*
1300 * Throw an M_IOCTL message downstream asking "do you know fastpath?"
1301 * The data portion of the request is a dl_unitdata_req_t template for
1302 * what we would send downstream in the absence of a fastpath confirmation.
1303 */
1304 int
1305 ill_fastpath_probe(ill_t *ill, mblk_t *dlur_mp)
1306 {
1307 struct iocblk *ioc;
1308 mblk_t *mp;
1309
1310 if (dlur_mp == NULL)
1311 return (EINVAL);
1312
1313 mutex_enter(&ill->ill_lock);
1314 switch (ill->ill_dlpi_fastpath_state) {
1315 case IDS_FAILED:
1316 /*
1317 * Driver NAKed the first fastpath ioctl - assume it doesn't
1318 * support it.
1319 */
1320 mutex_exit(&ill->ill_lock);
1321 return (ENOTSUP);
1322 case IDS_UNKNOWN:
1323 /* This is the first probe */
1324 ill->ill_dlpi_fastpath_state = IDS_INPROGRESS;
1325 break;
1326 default:
1327 break;
1328 }
1329 mutex_exit(&ill->ill_lock);
1330
1331 if ((mp = mkiocb(DL_IOC_HDR_INFO)) == NULL)
1332 return (EAGAIN);
1333
1334 mp->b_cont = copyb(dlur_mp);
1335 if (mp->b_cont == NULL) {
1336 freeb(mp);
1337 return (EAGAIN);
1338 }
1339
1340 ioc = (struct iocblk *)mp->b_rptr;
1341 ioc->ioc_count = msgdsize(mp->b_cont);
1342
1343 DTRACE_PROBE3(ill__dlpi, char *, "ill_fastpath_probe",
1344 char *, "DL_IOC_HDR_INFO", ill_t *, ill);
1345 putnext(ill->ill_wq, mp);
1346 return (0);
1347 }
1348
1349 void
1350 ill_capability_probe(ill_t *ill)
1351 {
1352 mblk_t *mp;
1353
1354 ASSERT(IAM_WRITER_ILL(ill));
1355
1356 if (ill->ill_dlpi_capab_state != IDCS_UNKNOWN &&
1357 ill->ill_dlpi_capab_state != IDCS_FAILED)
1358 return;
1359
1360 /*
1361 * We are starting a new cycle of capability negotiation.
1362 * Free up the capab reset messages of any previous incarnation.
1363 * We will do a fresh allocation when we get the response to our probe
1364 */
1365 if (ill->ill_capab_reset_mp != NULL) {
1366 freemsg(ill->ill_capab_reset_mp);
1367 ill->ill_capab_reset_mp = NULL;
1368 }
1369
1370 ip1dbg(("ill_capability_probe: starting capability negotiation\n"));
1371
1372 mp = ip_dlpi_alloc(sizeof (dl_capability_req_t), DL_CAPABILITY_REQ);
1373 if (mp == NULL)
1374 return;
1375
1376 ill_capability_send(ill, mp);
1377 ill->ill_dlpi_capab_state = IDCS_PROBE_SENT;
1378 }
1379
1380 void
1381 ill_capability_reset(ill_t *ill, boolean_t reneg)
1382 {
1383 ASSERT(IAM_WRITER_ILL(ill));
1384
1385 if (ill->ill_dlpi_capab_state != IDCS_OK)
1386 return;
1387
1388 ill->ill_dlpi_capab_state = reneg ? IDCS_RENEG : IDCS_RESET_SENT;
1389
1390 ill_capability_send(ill, ill->ill_capab_reset_mp);
1391 ill->ill_capab_reset_mp = NULL;
1392 /*
1393 * We turn off all capabilities except those pertaining to
1394 * direct function call capabilities viz. ILL_CAPAB_DLD*
1395 * which will be turned off by the corresponding reset functions.
1396 */
1397 ill->ill_capabilities &= ~(ILL_CAPAB_HCKSUM | ILL_CAPAB_ZEROCOPY);
1398 }
1399
1400 static void
1401 ill_capability_reset_alloc(ill_t *ill)
1402 {
1403 mblk_t *mp;
1404 size_t size = 0;
1405 int err;
1406 dl_capability_req_t *capb;
1407
1408 ASSERT(IAM_WRITER_ILL(ill));
1409 ASSERT(ill->ill_capab_reset_mp == NULL);
1410
1411 if (ILL_HCKSUM_CAPABLE(ill)) {
1412 size += sizeof (dl_capability_sub_t) +
1413 sizeof (dl_capab_hcksum_t);
1414 }
1415
1416 if (ill->ill_capabilities & ILL_CAPAB_ZEROCOPY) {
1417 size += sizeof (dl_capability_sub_t) +
1418 sizeof (dl_capab_zerocopy_t);
1419 }
1420
1421 if (ill->ill_capabilities & ILL_CAPAB_DLD) {
1422 size += sizeof (dl_capability_sub_t) +
1423 sizeof (dl_capab_dld_t);
1424 }
1425
1426 mp = allocb_wait(size + sizeof (dl_capability_req_t), BPRI_MED,
1427 STR_NOSIG, &err);
1428
1429 mp->b_datap->db_type = M_PROTO;
1430 bzero(mp->b_rptr, size + sizeof (dl_capability_req_t));
1431
1432 capb = (dl_capability_req_t *)mp->b_rptr;
1433 capb->dl_primitive = DL_CAPABILITY_REQ;
1434 capb->dl_sub_offset = sizeof (dl_capability_req_t);
1435 capb->dl_sub_length = size;
1436
1437 mp->b_wptr += sizeof (dl_capability_req_t);
1438
1439 /*
1440 * Each handler fills in the corresponding dl_capability_sub_t
1441 * inside the mblk,
1442 */
1443 ill_capability_hcksum_reset_fill(ill, mp);
1444 ill_capability_zerocopy_reset_fill(ill, mp);
1445 ill_capability_dld_reset_fill(ill, mp);
1446
1447 ill->ill_capab_reset_mp = mp;
1448 }
1449
1450 static void
1451 ill_capability_id_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *outers)
1452 {
1453 dl_capab_id_t *id_ic;
1454 uint_t sub_dl_cap = outers->dl_cap;
1455 dl_capability_sub_t *inners;
1456 uint8_t *capend;
1457
1458 ASSERT(sub_dl_cap == DL_CAPAB_ID_WRAPPER);
1459
1460 /*
1461 * Note: range checks here are not absolutely sufficient to
1462 * make us robust against malformed messages sent by drivers;
1463 * this is in keeping with the rest of IP's dlpi handling.
1464 * (Remember, it's coming from something else in the kernel
1465 * address space)
1466 */
1467
1468 capend = (uint8_t *)(outers + 1) + outers->dl_length;
1469 if (capend > mp->b_wptr) {
1470 cmn_err(CE_WARN, "ill_capability_id_ack: "
1471 "malformed sub-capability too long for mblk");
1472 return;
1473 }
1474
1475 id_ic = (dl_capab_id_t *)(outers + 1);
1476
1477 if (outers->dl_length < sizeof (*id_ic) ||
1478 (inners = &id_ic->id_subcap,
1479 inners->dl_length > (outers->dl_length - sizeof (*inners)))) {
1480 cmn_err(CE_WARN, "ill_capability_id_ack: malformed "
1481 "encapsulated capab type %d too long for mblk",
1482 inners->dl_cap);
1483 return;
1484 }
1485
1486 if (!dlcapabcheckqid(&id_ic->id_mid, ill->ill_lmod_rq)) {
1487 ip1dbg(("ill_capability_id_ack: mid token for capab type %d "
1488 "isn't as expected; pass-thru module(s) detected, "
1489 "discarding capability\n", inners->dl_cap));
1490 return;
1491 }
1492
1493 /* Process the encapsulated sub-capability */
1494 ill_capability_dispatch(ill, mp, inners);
1495 }
1496
1497 static void
1498 ill_capability_dld_reset_fill(ill_t *ill, mblk_t *mp)
1499 {
1500 dl_capability_sub_t *dl_subcap;
1501
1502 if (!(ill->ill_capabilities & ILL_CAPAB_DLD))
1503 return;
1504
1505 /*
1506 * The dl_capab_dld_t that follows the dl_capability_sub_t is not
1507 * initialized below since it is not used by DLD.
1508 */
1509 dl_subcap = (dl_capability_sub_t *)mp->b_wptr;
1510 dl_subcap->dl_cap = DL_CAPAB_DLD;
1511 dl_subcap->dl_length = sizeof (dl_capab_dld_t);
1512
1513 mp->b_wptr += sizeof (dl_capability_sub_t) + sizeof (dl_capab_dld_t);
1514 }
1515
1516 static void
1517 ill_capability_dispatch(ill_t *ill, mblk_t *mp, dl_capability_sub_t *subp)
1518 {
1519 /*
1520 * If no ipif was brought up over this ill, this DL_CAPABILITY_REQ/ACK
1521 * is only to get the VRRP capability.
1522 *
1523 * Note that we cannot check ill_ipif_up_count here since
1524 * ill_ipif_up_count is only incremented when the resolver is setup.
1525 * That is done asynchronously, and can race with this function.
1526 */
1527 if (!ill->ill_dl_up) {
1528 if (subp->dl_cap == DL_CAPAB_VRRP)
1529 ill_capability_vrrp_ack(ill, mp, subp);
1530 return;
1531 }
1532
1533 switch (subp->dl_cap) {
1534 case DL_CAPAB_HCKSUM:
1535 ill_capability_hcksum_ack(ill, mp, subp);
1536 break;
1537 case DL_CAPAB_ZEROCOPY:
1538 ill_capability_zerocopy_ack(ill, mp, subp);
1539 break;
1540 case DL_CAPAB_DLD:
1541 ill_capability_dld_ack(ill, mp, subp);
1542 break;
1543 case DL_CAPAB_VRRP:
1544 break;
1545 default:
1546 ip1dbg(("ill_capability_dispatch: unknown capab type %d\n",
1547 subp->dl_cap));
1548 }
1549 }
1550
1551 /*
1552 * Process the vrrp capability received from a DLS Provider. isub must point
1553 * to the sub-capability (DL_CAPAB_VRRP) of a DL_CAPABILITY_ACK message.
1554 */
1555 static void
1556 ill_capability_vrrp_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1557 {
1558 dl_capab_vrrp_t *vrrp;
1559 uint_t sub_dl_cap = isub->dl_cap;
1560 uint8_t *capend;
1561
1562 ASSERT(IAM_WRITER_ILL(ill));
1563 ASSERT(sub_dl_cap == DL_CAPAB_VRRP);
1564
1565 /*
1566 * Note: range checks here are not absolutely sufficient to
1567 * make us robust against malformed messages sent by drivers;
1568 * this is in keeping with the rest of IP's dlpi handling.
1569 * (Remember, it's coming from something else in the kernel
1570 * address space)
1571 */
1572 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1573 if (capend > mp->b_wptr) {
1574 cmn_err(CE_WARN, "ill_capability_vrrp_ack: "
1575 "malformed sub-capability too long for mblk");
1576 return;
1577 }
1578 vrrp = (dl_capab_vrrp_t *)(isub + 1);
1579
1580 /*
1581 * Compare the IP address family and set ILLF_VRRP for the right ill.
1582 */
1583 if ((vrrp->vrrp_af == AF_INET6 && ill->ill_isv6) ||
1584 (vrrp->vrrp_af == AF_INET && !ill->ill_isv6)) {
1585 ill->ill_flags |= ILLF_VRRP;
1586 }
1587 }
1588
1589 /*
1590 * Process a hardware checksum offload capability negotiation ack received
1591 * from a DLS Provider.isub must point to the sub-capability (DL_CAPAB_HCKSUM)
1592 * of a DL_CAPABILITY_ACK message.
1593 */
1594 static void
1595 ill_capability_hcksum_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1596 {
1597 dl_capability_req_t *ocap;
1598 dl_capab_hcksum_t *ihck, *ohck;
1599 ill_hcksum_capab_t **ill_hcksum;
1600 mblk_t *nmp = NULL;
1601 uint_t sub_dl_cap = isub->dl_cap;
1602 uint8_t *capend;
1603
1604 ASSERT(sub_dl_cap == DL_CAPAB_HCKSUM);
1605
1606 ill_hcksum = (ill_hcksum_capab_t **)&ill->ill_hcksum_capab;
1607
1608 /*
1609 * Note: range checks here are not absolutely sufficient to
1610 * make us robust against malformed messages sent by drivers;
1611 * this is in keeping with the rest of IP's dlpi handling.
1612 * (Remember, it's coming from something else in the kernel
1613 * address space)
1614 */
1615 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1616 if (capend > mp->b_wptr) {
1617 cmn_err(CE_WARN, "ill_capability_hcksum_ack: "
1618 "malformed sub-capability too long for mblk");
1619 return;
1620 }
1621
1622 /*
1623 * There are two types of acks we process here:
1624 * 1. acks in reply to a (first form) generic capability req
1625 * (no ENABLE flag set)
1626 * 2. acks in reply to a ENABLE capability req.
1627 * (ENABLE flag set)
1628 */
1629 ihck = (dl_capab_hcksum_t *)(isub + 1);
1630
1631 if (ihck->hcksum_version != HCKSUM_VERSION_1) {
1632 cmn_err(CE_CONT, "ill_capability_hcksum_ack: "
1633 "unsupported hardware checksum "
1634 "sub-capability (version %d, expected %d)",
1635 ihck->hcksum_version, HCKSUM_VERSION_1);
1636 return;
1637 }
1638
1639 if (!dlcapabcheckqid(&ihck->hcksum_mid, ill->ill_lmod_rq)) {
1640 ip1dbg(("ill_capability_hcksum_ack: mid token for hardware "
1641 "checksum capability isn't as expected; pass-thru "
1642 "module(s) detected, discarding capability\n"));
1643 return;
1644 }
1645
1646 #define CURR_HCKSUM_CAPAB \
1647 (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 | \
1648 HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM)
1649
1650 if ((ihck->hcksum_txflags & HCKSUM_ENABLE) &&
1651 (ihck->hcksum_txflags & CURR_HCKSUM_CAPAB)) {
1652 /* do ENABLE processing */
1653 if (*ill_hcksum == NULL) {
1654 *ill_hcksum = kmem_zalloc(sizeof (ill_hcksum_capab_t),
1655 KM_NOSLEEP);
1656
1657 if (*ill_hcksum == NULL) {
1658 cmn_err(CE_WARN, "ill_capability_hcksum_ack: "
1659 "could not enable hcksum version %d "
1660 "for %s (ENOMEM)\n", HCKSUM_CURRENT_VERSION,
1661 ill->ill_name);
1662 return;
1663 }
1664 }
1665
1666 (*ill_hcksum)->ill_hcksum_version = ihck->hcksum_version;
1667 (*ill_hcksum)->ill_hcksum_txflags = ihck->hcksum_txflags;
1668 ill->ill_capabilities |= ILL_CAPAB_HCKSUM;
1669 ip1dbg(("ill_capability_hcksum_ack: interface %s "
1670 "has enabled hardware checksumming\n ",
1671 ill->ill_name));
1672 } else if (ihck->hcksum_txflags & CURR_HCKSUM_CAPAB) {
1673 /*
1674 * Enabling hardware checksum offload
1675 * Currently IP supports {TCP,UDP}/IPv4
1676 * partial and full cksum offload and
1677 * IPv4 header checksum offload.
1678 * Allocate new mblk which will
1679 * contain a new capability request
1680 * to enable hardware checksum offload.
1681 */
1682 uint_t size;
1683 uchar_t *rptr;
1684
1685 size = sizeof (dl_capability_req_t) +
1686 sizeof (dl_capability_sub_t) + isub->dl_length;
1687
1688 if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) {
1689 cmn_err(CE_WARN, "ill_capability_hcksum_ack: "
1690 "could not enable hardware cksum for %s (ENOMEM)\n",
1691 ill->ill_name);
1692 return;
1693 }
1694
1695 rptr = nmp->b_rptr;
1696 /* initialize dl_capability_req_t */
1697 ocap = (dl_capability_req_t *)nmp->b_rptr;
1698 ocap->dl_sub_offset =
1699 sizeof (dl_capability_req_t);
1700 ocap->dl_sub_length =
1701 sizeof (dl_capability_sub_t) +
1702 isub->dl_length;
1703 nmp->b_rptr += sizeof (dl_capability_req_t);
1704
1705 /* initialize dl_capability_sub_t */
1706 bcopy(isub, nmp->b_rptr, sizeof (*isub));
1707 nmp->b_rptr += sizeof (*isub);
1708
1709 /* initialize dl_capab_hcksum_t */
1710 ohck = (dl_capab_hcksum_t *)nmp->b_rptr;
1711 bcopy(ihck, ohck, sizeof (*ihck));
1712
1713 nmp->b_rptr = rptr;
1714 ASSERT(nmp->b_wptr == (nmp->b_rptr + size));
1715
1716 /* Set ENABLE flag */
1717 ohck->hcksum_txflags &= CURR_HCKSUM_CAPAB;
1718 ohck->hcksum_txflags |= HCKSUM_ENABLE;
1719
1720 /*
1721 * nmp points to a DL_CAPABILITY_REQ message to enable
1722 * hardware checksum acceleration.
1723 */
1724 ill_capability_send(ill, nmp);
1725 } else {
1726 ip1dbg(("ill_capability_hcksum_ack: interface %s has "
1727 "advertised %x hardware checksum capability flags\n",
1728 ill->ill_name, ihck->hcksum_txflags));
1729 }
1730 }
1731
1732 static void
1733 ill_capability_hcksum_reset_fill(ill_t *ill, mblk_t *mp)
1734 {
1735 dl_capab_hcksum_t *hck_subcap;
1736 dl_capability_sub_t *dl_subcap;
1737
1738 if (!ILL_HCKSUM_CAPABLE(ill))
1739 return;
1740
1741 ASSERT(ill->ill_hcksum_capab != NULL);
1742
1743 dl_subcap = (dl_capability_sub_t *)mp->b_wptr;
1744 dl_subcap->dl_cap = DL_CAPAB_HCKSUM;
1745 dl_subcap->dl_length = sizeof (*hck_subcap);
1746
1747 hck_subcap = (dl_capab_hcksum_t *)(dl_subcap + 1);
1748 hck_subcap->hcksum_version = ill->ill_hcksum_capab->ill_hcksum_version;
1749 hck_subcap->hcksum_txflags = 0;
1750
1751 mp->b_wptr += sizeof (*dl_subcap) + sizeof (*hck_subcap);
1752 }
1753
1754 static void
1755 ill_capability_zerocopy_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1756 {
1757 mblk_t *nmp = NULL;
1758 dl_capability_req_t *oc;
1759 dl_capab_zerocopy_t *zc_ic, *zc_oc;
1760 ill_zerocopy_capab_t **ill_zerocopy_capab;
1761 uint_t sub_dl_cap = isub->dl_cap;
1762 uint8_t *capend;
1763
1764 ASSERT(sub_dl_cap == DL_CAPAB_ZEROCOPY);
1765
1766 ill_zerocopy_capab = (ill_zerocopy_capab_t **)&ill->ill_zerocopy_capab;
1767
1768 /*
1769 * Note: range checks here are not absolutely sufficient to
1770 * make us robust against malformed messages sent by drivers;
1771 * this is in keeping with the rest of IP's dlpi handling.
1772 * (Remember, it's coming from something else in the kernel
1773 * address space)
1774 */
1775 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1776 if (capend > mp->b_wptr) {
1777 cmn_err(CE_WARN, "ill_capability_zerocopy_ack: "
1778 "malformed sub-capability too long for mblk");
1779 return;
1780 }
1781
1782 zc_ic = (dl_capab_zerocopy_t *)(isub + 1);
1783 if (zc_ic->zerocopy_version != ZEROCOPY_VERSION_1) {
1784 cmn_err(CE_CONT, "ill_capability_zerocopy_ack: "
1785 "unsupported ZEROCOPY sub-capability (version %d, "
1786 "expected %d)", zc_ic->zerocopy_version,
1787 ZEROCOPY_VERSION_1);
1788 return;
1789 }
1790
1791 if (!dlcapabcheckqid(&zc_ic->zerocopy_mid, ill->ill_lmod_rq)) {
1792 ip1dbg(("ill_capability_zerocopy_ack: mid token for zerocopy "
1793 "capability isn't as expected; pass-thru module(s) "
1794 "detected, discarding capability\n"));
1795 return;
1796 }
1797
1798 if ((zc_ic->zerocopy_flags & DL_CAPAB_VMSAFE_MEM) != 0) {
1799 if (*ill_zerocopy_capab == NULL) {
1800 *ill_zerocopy_capab =
1801 kmem_zalloc(sizeof (ill_zerocopy_capab_t),
1802 KM_NOSLEEP);
1803
1804 if (*ill_zerocopy_capab == NULL) {
1805 cmn_err(CE_WARN, "ill_capability_zerocopy_ack: "
1806 "could not enable Zero-copy version %d "
1807 "for %s (ENOMEM)\n", ZEROCOPY_VERSION_1,
1808 ill->ill_name);
1809 return;
1810 }
1811 }
1812
1813 ip1dbg(("ill_capability_zerocopy_ack: interface %s "
1814 "supports Zero-copy version %d\n", ill->ill_name,
1815 ZEROCOPY_VERSION_1));
1816
1817 (*ill_zerocopy_capab)->ill_zerocopy_version =
1818 zc_ic->zerocopy_version;
1819 (*ill_zerocopy_capab)->ill_zerocopy_flags =
1820 zc_ic->zerocopy_flags;
1821
1822 ill->ill_capabilities |= ILL_CAPAB_ZEROCOPY;
1823 } else {
1824 uint_t size;
1825 uchar_t *rptr;
1826
1827 size = sizeof (dl_capability_req_t) +
1828 sizeof (dl_capability_sub_t) +
1829 sizeof (dl_capab_zerocopy_t);
1830
1831 if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) {
1832 cmn_err(CE_WARN, "ill_capability_zerocopy_ack: "
1833 "could not enable zerocopy for %s (ENOMEM)\n",
1834 ill->ill_name);
1835 return;
1836 }
1837
1838 rptr = nmp->b_rptr;
1839 /* initialize dl_capability_req_t */
1840 oc = (dl_capability_req_t *)rptr;
1841 oc->dl_sub_offset = sizeof (dl_capability_req_t);
1842 oc->dl_sub_length = sizeof (dl_capability_sub_t) +
1843 sizeof (dl_capab_zerocopy_t);
1844 rptr += sizeof (dl_capability_req_t);
1845
1846 /* initialize dl_capability_sub_t */
1847 bcopy(isub, rptr, sizeof (*isub));
1848 rptr += sizeof (*isub);
1849
1850 /* initialize dl_capab_zerocopy_t */
1851 zc_oc = (dl_capab_zerocopy_t *)rptr;
1852 *zc_oc = *zc_ic;
1853
1854 ip1dbg(("ill_capability_zerocopy_ack: asking interface %s "
1855 "to enable zero-copy version %d\n", ill->ill_name,
1856 ZEROCOPY_VERSION_1));
1857
1858 /* set VMSAFE_MEM flag */
1859 zc_oc->zerocopy_flags |= DL_CAPAB_VMSAFE_MEM;
1860
1861 /* nmp points to a DL_CAPABILITY_REQ message to enable zcopy */
1862 ill_capability_send(ill, nmp);
1863 }
1864 }
1865
1866 static void
1867 ill_capability_zerocopy_reset_fill(ill_t *ill, mblk_t *mp)
1868 {
1869 dl_capab_zerocopy_t *zerocopy_subcap;
1870 dl_capability_sub_t *dl_subcap;
1871
1872 if (!(ill->ill_capabilities & ILL_CAPAB_ZEROCOPY))
1873 return;
1874
1875 ASSERT(ill->ill_zerocopy_capab != NULL);
1876
1877 dl_subcap = (dl_capability_sub_t *)mp->b_wptr;
1878 dl_subcap->dl_cap = DL_CAPAB_ZEROCOPY;
1879 dl_subcap->dl_length = sizeof (*zerocopy_subcap);
1880
1881 zerocopy_subcap = (dl_capab_zerocopy_t *)(dl_subcap + 1);
1882 zerocopy_subcap->zerocopy_version =
1883 ill->ill_zerocopy_capab->ill_zerocopy_version;
1884 zerocopy_subcap->zerocopy_flags = 0;
1885
1886 mp->b_wptr += sizeof (*dl_subcap) + sizeof (*zerocopy_subcap);
1887 }
1888
1889 /*
1890 * DLD capability
1891 * Refer to dld.h for more information regarding the purpose and usage
1892 * of this capability.
1893 */
1894 static void
1895 ill_capability_dld_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1896 {
1897 dl_capab_dld_t *dld_ic, dld;
1898 uint_t sub_dl_cap = isub->dl_cap;
1899 uint8_t *capend;
1900 ill_dld_capab_t *idc;
1901
1902 ASSERT(IAM_WRITER_ILL(ill));
1903 ASSERT(sub_dl_cap == DL_CAPAB_DLD);
1904
1905 /*
1906 * Note: range checks here are not absolutely sufficient to
1907 * make us robust against malformed messages sent by drivers;
1908 * this is in keeping with the rest of IP's dlpi handling.
1909 * (Remember, it's coming from something else in the kernel
1910 * address space)
1911 */
1912 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1913 if (capend > mp->b_wptr) {
1914 cmn_err(CE_WARN, "ill_capability_dld_ack: "
1915 "malformed sub-capability too long for mblk");
1916 return;
1917 }
1918 dld_ic = (dl_capab_dld_t *)(isub + 1);
1919 if (dld_ic->dld_version != DLD_CURRENT_VERSION) {
1920 cmn_err(CE_CONT, "ill_capability_dld_ack: "
1921 "unsupported DLD sub-capability (version %d, "
1922 "expected %d)", dld_ic->dld_version,
1923 DLD_CURRENT_VERSION);
1924 return;
1925 }
1926 if (!dlcapabcheckqid(&dld_ic->dld_mid, ill->ill_lmod_rq)) {
1927 ip1dbg(("ill_capability_dld_ack: mid token for dld "
1928 "capability isn't as expected; pass-thru module(s) "
1929 "detected, discarding capability\n"));
1930 return;
1931 }
1932
1933 /*
1934 * Copy locally to ensure alignment.
1935 */
1936 bcopy(dld_ic, &dld, sizeof (dl_capab_dld_t));
1937
1938 if ((idc = ill->ill_dld_capab) == NULL) {
1939 idc = kmem_zalloc(sizeof (ill_dld_capab_t), KM_NOSLEEP);
1940 if (idc == NULL) {
1941 cmn_err(CE_WARN, "ill_capability_dld_ack: "
1942 "could not enable DLD version %d "
1943 "for %s (ENOMEM)\n", DLD_CURRENT_VERSION,
1944 ill->ill_name);
1945 return;
1946 }
1947 ill->ill_dld_capab = idc;
1948 }
1949 idc->idc_capab_df = (ip_capab_func_t)dld.dld_capab;
1950 idc->idc_capab_dh = (void *)dld.dld_capab_handle;
1951 ip1dbg(("ill_capability_dld_ack: interface %s "
1952 "supports DLD version %d\n", ill->ill_name, DLD_CURRENT_VERSION));
1953
1954 ill_capability_dld_enable(ill);
1955 }
1956
1957 /*
1958 * Typically capability negotiation between IP and the driver happens via
1959 * DLPI message exchange. However GLD also offers a direct function call
1960 * mechanism to exchange the DLD_DIRECT_CAPAB and DLD_POLL_CAPAB capabilities,
1961 * But arbitrary function calls into IP or GLD are not permitted, since both
1962 * of them are protected by their own perimeter mechanism. The perimeter can
1963 * be viewed as a coarse lock or serialization mechanism. The hierarchy of
1964 * these perimeters is IP -> MAC. Thus for example to enable the squeue
1965 * polling, IP needs to enter its perimeter, then call ill_mac_perim_enter
1966 * to enter the mac perimeter and then do the direct function calls into
1967 * GLD to enable squeue polling. The ring related callbacks from the mac into
1968 * the stack to add, bind, quiesce, restart or cleanup a ring are all
1969 * protected by the mac perimeter.
1970 */
1971 static void
1972 ill_mac_perim_enter(ill_t *ill, mac_perim_handle_t *mphp)
1973 {
1974 ill_dld_capab_t *idc = ill->ill_dld_capab;
1975 int err;
1976
1977 err = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_PERIM, mphp,
1978 DLD_ENABLE);
1979 ASSERT(err == 0);
1980 }
1981
1982 static void
1983 ill_mac_perim_exit(ill_t *ill, mac_perim_handle_t mph)
1984 {
1985 ill_dld_capab_t *idc = ill->ill_dld_capab;
1986 int err;
1987
1988 err = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_PERIM, mph,
1989 DLD_DISABLE);
1990 ASSERT(err == 0);
1991 }
1992
1993 boolean_t
1994 ill_mac_perim_held(ill_t *ill)
1995 {
1996 ill_dld_capab_t *idc = ill->ill_dld_capab;
1997
1998 return (idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_PERIM, NULL,
1999 DLD_QUERY));
2000 }
2001
2002 static void
2003 ill_capability_direct_enable(ill_t *ill)
2004 {
2005 ill_dld_capab_t *idc = ill->ill_dld_capab;
2006 ill_dld_direct_t *idd = &idc->idc_direct;
2007 dld_capab_direct_t direct;
2008 int rc;
2009
2010 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2011
2012 bzero(&direct, sizeof (direct));
2013 direct.di_rx_cf = (uintptr_t)ip_input;
2014 direct.di_rx_ch = ill;
2015
2016 rc = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_DIRECT, &direct,
2017 DLD_ENABLE);
2018 if (rc == 0) {
2019 idd->idd_tx_df = (ip_dld_tx_t)direct.di_tx_df;
2020 idd->idd_tx_dh = direct.di_tx_dh;
2021 idd->idd_tx_cb_df = (ip_dld_callb_t)direct.di_tx_cb_df;
2022 idd->idd_tx_cb_dh = direct.di_tx_cb_dh;
2023 idd->idd_tx_fctl_df = (ip_dld_fctl_t)direct.di_tx_fctl_df;
2024 idd->idd_tx_fctl_dh = direct.di_tx_fctl_dh;
2025 ASSERT(idd->idd_tx_cb_df != NULL);
2026 ASSERT(idd->idd_tx_fctl_df != NULL);
2027 ASSERT(idd->idd_tx_df != NULL);
2028 /*
2029 * One time registration of flow enable callback function
2030 */
2031 ill->ill_flownotify_mh = idd->idd_tx_cb_df(idd->idd_tx_cb_dh,
2032 ill_flow_enable, ill);
2033 ill->ill_capabilities |= ILL_CAPAB_DLD_DIRECT;
2034 DTRACE_PROBE1(direct_on, (ill_t *), ill);
2035 } else {
2036 cmn_err(CE_WARN, "warning: could not enable DIRECT "
2037 "capability, rc = %d\n", rc);
2038 DTRACE_PROBE2(direct_off, (ill_t *), ill, (int), rc);
2039 }
2040 }
2041
2042 static void
2043 ill_capability_poll_enable(ill_t *ill)
2044 {
2045 ill_dld_capab_t *idc = ill->ill_dld_capab;
2046 dld_capab_poll_t poll;
2047 int rc;
2048
2049 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2050
2051 bzero(&poll, sizeof (poll));
2052 poll.poll_ring_add_cf = (uintptr_t)ip_squeue_add_ring;
2053 poll.poll_ring_remove_cf = (uintptr_t)ip_squeue_clean_ring;
2054 poll.poll_ring_quiesce_cf = (uintptr_t)ip_squeue_quiesce_ring;
2055 poll.poll_ring_restart_cf = (uintptr_t)ip_squeue_restart_ring;
2056 poll.poll_ring_bind_cf = (uintptr_t)ip_squeue_bind_ring;
2057 poll.poll_ring_ch = ill;
2058 rc = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_POLL, &poll,
2059 DLD_ENABLE);
2060 if (rc == 0) {
2061 ill->ill_capabilities |= ILL_CAPAB_DLD_POLL;
2062 DTRACE_PROBE1(poll_on, (ill_t *), ill);
2063 } else {
2064 ip1dbg(("warning: could not enable POLL "
2065 "capability, rc = %d\n", rc));
2066 DTRACE_PROBE2(poll_off, (ill_t *), ill, (int), rc);
2067 }
2068 }
2069
2070 /*
2071 * Enable the LSO capability.
2072 */
2073 static void
2074 ill_capability_lso_enable(ill_t *ill)
2075 {
2076 ill_dld_capab_t *idc = ill->ill_dld_capab;
2077 dld_capab_lso_t lso;
2078 int rc;
2079
2080 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2081
2082 if (ill->ill_lso_capab == NULL) {
2083 ill->ill_lso_capab = kmem_zalloc(sizeof (ill_lso_capab_t),
2084 KM_NOSLEEP);
2085 if (ill->ill_lso_capab == NULL) {
2086 cmn_err(CE_WARN, "ill_capability_lso_enable: "
2087 "could not enable LSO for %s (ENOMEM)\n",
2088 ill->ill_name);
2089 return;
2090 }
2091 }
2092
2093 bzero(&lso, sizeof (lso));
2094 if ((rc = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_LSO, &lso,
2095 DLD_ENABLE)) == 0) {
2096 ill->ill_lso_capab->ill_lso_flags = lso.lso_flags;
2097 ill->ill_lso_capab->ill_lso_max = lso.lso_max;
2098 ill->ill_capabilities |= ILL_CAPAB_LSO;
2099 ip1dbg(("ill_capability_lso_enable: interface %s "
2100 "has enabled LSO\n ", ill->ill_name));
2101 } else {
2102 kmem_free(ill->ill_lso_capab, sizeof (ill_lso_capab_t));
2103 ill->ill_lso_capab = NULL;
2104 DTRACE_PROBE2(lso_off, (ill_t *), ill, (int), rc);
2105 }
2106 }
2107
2108 static void
2109 ill_capability_dld_enable(ill_t *ill)
2110 {
2111 mac_perim_handle_t mph;
2112
2113 ASSERT(IAM_WRITER_ILL(ill));
2114
2115 if (ill->ill_isv6)
2116 return;
2117
2118 ill_mac_perim_enter(ill, &mph);
2119 if (!ill->ill_isv6) {
2120 ill_capability_direct_enable(ill);
2121 ill_capability_poll_enable(ill);
2122 ill_capability_lso_enable(ill);
2123 }
2124 ill->ill_capabilities |= ILL_CAPAB_DLD;
2125 ill_mac_perim_exit(ill, mph);
2126 }
2127
2128 static void
2129 ill_capability_dld_disable(ill_t *ill)
2130 {
2131 ill_dld_capab_t *idc;
2132 ill_dld_direct_t *idd;
2133 mac_perim_handle_t mph;
2134
2135 ASSERT(IAM_WRITER_ILL(ill));
2136
2137 if (!(ill->ill_capabilities & ILL_CAPAB_DLD))
2138 return;
2139
2140 ill_mac_perim_enter(ill, &mph);
2141
2142 idc = ill->ill_dld_capab;
2143 if ((ill->ill_capabilities & ILL_CAPAB_DLD_DIRECT) != 0) {
2144 /*
2145 * For performance we avoid locks in the transmit data path
2146 * and don't maintain a count of the number of threads using
2147 * direct calls. Thus some threads could be using direct
2148 * transmit calls to GLD, even after the capability mechanism
2149 * turns it off. This is still safe since the handles used in
2150 * the direct calls continue to be valid until the unplumb is
2151 * completed. Remove the callback that was added (1-time) at
2152 * capab enable time.
2153 */
2154 mutex_enter(&ill->ill_lock);
2155 ill->ill_capabilities &= ~ILL_CAPAB_DLD_DIRECT;
2156 mutex_exit(&ill->ill_lock);
2157 if (ill->ill_flownotify_mh != NULL) {
2158 idd = &idc->idc_direct;
2159 idd->idd_tx_cb_df(idd->idd_tx_cb_dh, NULL,
2160 ill->ill_flownotify_mh);
2161 ill->ill_flownotify_mh = NULL;
2162 }
2163 (void) idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_DIRECT,
2164 NULL, DLD_DISABLE);
2165 }
2166
2167 if ((ill->ill_capabilities & ILL_CAPAB_DLD_POLL) != 0) {
2168 ill->ill_capabilities &= ~ILL_CAPAB_DLD_POLL;
2169 ip_squeue_clean_all(ill);
2170 (void) idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_POLL,
2171 NULL, DLD_DISABLE);
2172 }
2173
2174 if ((ill->ill_capabilities & ILL_CAPAB_LSO) != 0) {
2175 ASSERT(ill->ill_lso_capab != NULL);
2176 /*
2177 * Clear the capability flag for LSO but retain the
2178 * ill_lso_capab structure since it's possible that another
2179 * thread is still referring to it. The structure only gets
2180 * deallocated when we destroy the ill.
2181 */
2182
2183 ill->ill_capabilities &= ~ILL_CAPAB_LSO;
2184 (void) idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_LSO,
2185 NULL, DLD_DISABLE);
2186 }
2187
2188 ill->ill_capabilities &= ~ILL_CAPAB_DLD;
2189 ill_mac_perim_exit(ill, mph);
2190 }
2191
2192 /*
2193 * Capability Negotiation protocol
2194 *
2195 * We don't wait for DLPI capability operations to finish during interface
2196 * bringup or teardown. Doing so would introduce more asynchrony and the
2197 * interface up/down operations will need multiple return and restarts.
2198 * Instead the 'ipsq_current_ipif' of the ipsq is not cleared as long as
2199 * the 'ill_dlpi_deferred' chain is non-empty. This ensures that the next
2200 * exclusive operation won't start until the DLPI operations of the previous
2201 * exclusive operation complete.
2202 *
2203 * The capability state machine is shown below.
2204 *
2205 * state next state event, action
2206 *
2207 * IDCS_UNKNOWN IDCS_PROBE_SENT ill_capability_probe
2208 * IDCS_PROBE_SENT IDCS_OK ill_capability_ack
2209 * IDCS_PROBE_SENT IDCS_FAILED ip_rput_dlpi_writer (nack)
2210 * IDCS_OK IDCS_RENEG Receipt of DL_NOTE_CAPAB_RENEG
2211 * IDCS_OK IDCS_RESET_SENT ill_capability_reset
2212 * IDCS_RESET_SENT IDCS_UNKNOWN ill_capability_ack_thr
2213 * IDCS_RENEG IDCS_PROBE_SENT ill_capability_ack_thr ->
2214 * ill_capability_probe.
2215 */
2216
2217 /*
2218 * Dedicated thread started from ip_stack_init that handles capability
2219 * disable. This thread ensures the taskq dispatch does not fail by waiting
2220 * for resources using TQ_SLEEP. The taskq mechanism is used to ensure
2221 * that direct calls to DLD are done in a cv_waitable context.
2222 */
2223 void
2224 ill_taskq_dispatch(ip_stack_t *ipst)
2225 {
2226 callb_cpr_t cprinfo;
2227 char name[64];
2228 mblk_t *mp;
2229
2230 (void) snprintf(name, sizeof (name), "ill_taskq_dispatch_%d",
2231 ipst->ips_netstack->netstack_stackid);
2232 CALLB_CPR_INIT(&cprinfo, &ipst->ips_capab_taskq_lock, callb_generic_cpr,
2233 name);
2234 mutex_enter(&ipst->ips_capab_taskq_lock);
2235
2236 for (;;) {
2237 mp = ipst->ips_capab_taskq_head;
2238 while (mp != NULL) {
2239 ipst->ips_capab_taskq_head = mp->b_next;
2240 if (ipst->ips_capab_taskq_head == NULL)
2241 ipst->ips_capab_taskq_tail = NULL;
2242 mutex_exit(&ipst->ips_capab_taskq_lock);
2243 mp->b_next = NULL;
2244
2245 VERIFY(taskq_dispatch(system_taskq,
2246 ill_capability_ack_thr, mp, TQ_SLEEP) != 0);
2247 mutex_enter(&ipst->ips_capab_taskq_lock);
2248 mp = ipst->ips_capab_taskq_head;
2249 }
2250
2251 if (ipst->ips_capab_taskq_quit)
2252 break;
2253 CALLB_CPR_SAFE_BEGIN(&cprinfo);
2254 cv_wait(&ipst->ips_capab_taskq_cv, &ipst->ips_capab_taskq_lock);
2255 CALLB_CPR_SAFE_END(&cprinfo, &ipst->ips_capab_taskq_lock);
2256 }
2257 VERIFY(ipst->ips_capab_taskq_head == NULL);
2258 VERIFY(ipst->ips_capab_taskq_tail == NULL);
2259 CALLB_CPR_EXIT(&cprinfo);
2260 thread_exit();
2261 }
2262
2263 /*
2264 * Consume a new-style hardware capabilities negotiation ack.
2265 * Called via taskq on receipt of DL_CAPABILITY_ACK.
2266 */
2267 static void
2268 ill_capability_ack_thr(void *arg)
2269 {
2270 mblk_t *mp = arg;
2271 dl_capability_ack_t *capp;
2272 dl_capability_sub_t *subp, *endp;
2273 ill_t *ill;
2274 boolean_t reneg;
2275
2276 ill = (ill_t *)mp->b_prev;
2277 mp->b_prev = NULL;
2278
2279 VERIFY(ipsq_enter(ill, B_FALSE, CUR_OP) == B_TRUE);
2280
2281 if (ill->ill_dlpi_capab_state == IDCS_RESET_SENT ||
2282 ill->ill_dlpi_capab_state == IDCS_RENEG) {
2283 /*
2284 * We have received the ack for our DL_CAPAB reset request.
2285 * There isnt' anything in the message that needs processing.
2286 * All message based capabilities have been disabled, now
2287 * do the function call based capability disable.
2288 */
2289 reneg = ill->ill_dlpi_capab_state == IDCS_RENEG;
2290 ill_capability_dld_disable(ill);
2291 ill->ill_dlpi_capab_state = IDCS_UNKNOWN;
2292 if (reneg)
2293 ill_capability_probe(ill);
2294 goto done;
2295 }
2296
2297 if (ill->ill_dlpi_capab_state == IDCS_PROBE_SENT)
2298 ill->ill_dlpi_capab_state = IDCS_OK;
2299
2300 capp = (dl_capability_ack_t *)mp->b_rptr;
2301
2302 if (capp->dl_sub_length == 0) {
2303 /* no new-style capabilities */
2304 goto done;
2305 }
2306
2307 /* make sure the driver supplied correct dl_sub_length */
2308 if ((sizeof (*capp) + capp->dl_sub_length) > MBLKL(mp)) {
2309 ip0dbg(("ill_capability_ack: bad DL_CAPABILITY_ACK, "
2310 "invalid dl_sub_length (%d)\n", capp->dl_sub_length));
2311 goto done;
2312 }
2313
2314 #define SC(base, offset) (dl_capability_sub_t *)(((uchar_t *)(base))+(offset))
2315 /*
2316 * There are sub-capabilities. Process the ones we know about.
2317 * Loop until we don't have room for another sub-cap header..
2318 */
2319 for (subp = SC(capp, capp->dl_sub_offset),
2320 endp = SC(subp, capp->dl_sub_length - sizeof (*subp));
2321 subp <= endp;
2322 subp = SC(subp, sizeof (dl_capability_sub_t) + subp->dl_length)) {
2323
2324 switch (subp->dl_cap) {
2325 case DL_CAPAB_ID_WRAPPER:
2326 ill_capability_id_ack(ill, mp, subp);
2327 break;
2328 default:
2329 ill_capability_dispatch(ill, mp, subp);
2330 break;
2331 }
2332 }
2333 #undef SC
2334 done:
2335 inet_freemsg(mp);
2336 ill_capability_done(ill);
2337 ipsq_exit(ill->ill_phyint->phyint_ipsq);
2338 }
2339
2340 /*
2341 * This needs to be started in a taskq thread to provide a cv_waitable
2342 * context.
2343 */
2344 void
2345 ill_capability_ack(ill_t *ill, mblk_t *mp)
2346 {
2347 ip_stack_t *ipst = ill->ill_ipst;
2348
2349 mp->b_prev = (mblk_t *)ill;
2350 ASSERT(mp->b_next == NULL);
2351
2352 if (taskq_dispatch(system_taskq, ill_capability_ack_thr, mp,
2353 TQ_NOSLEEP) != 0)
2354 return;
2355
2356 /*
2357 * The taskq dispatch failed. Signal the ill_taskq_dispatch thread
2358 * which will do the dispatch using TQ_SLEEP to guarantee success.
2359 */
2360 mutex_enter(&ipst->ips_capab_taskq_lock);
2361 if (ipst->ips_capab_taskq_head == NULL) {
2362 ASSERT(ipst->ips_capab_taskq_tail == NULL);
2363 ipst->ips_capab_taskq_head = mp;
2364 } else {
2365 ipst->ips_capab_taskq_tail->b_next = mp;
2366 }
2367 ipst->ips_capab_taskq_tail = mp;
2368
2369 cv_signal(&ipst->ips_capab_taskq_cv);
2370 mutex_exit(&ipst->ips_capab_taskq_lock);
2371 }
2372
2373 /*
2374 * This routine is called to scan the fragmentation reassembly table for
2375 * the specified ILL for any packets that are starting to smell.
2376 * dead_interval is the maximum time in seconds that will be tolerated. It
2377 * will either be the value specified in ip_g_frag_timeout, or zero if the
2378 * ILL is shutting down and it is time to blow everything off.
2379 *
2380 * It returns the number of seconds (as a time_t) that the next frag timer
2381 * should be scheduled for, 0 meaning that the timer doesn't need to be
2382 * re-started. Note that the method of calculating next_timeout isn't
2383 * entirely accurate since time will flow between the time we grab
2384 * current_time and the time we schedule the next timeout. This isn't a
2385 * big problem since this is the timer for sending an ICMP reassembly time
2386 * exceeded messages, and it doesn't have to be exactly accurate.
2387 *
2388 * This function is
2389 * sometimes called as writer, although this is not required.
2390 */
2391 time_t
2392 ill_frag_timeout(ill_t *ill, time_t dead_interval)
2393 {
2394 ipfb_t *ipfb;
2395 ipfb_t *endp;
2396 ipf_t *ipf;
2397 ipf_t *ipfnext;
2398 mblk_t *mp;
2399 time_t current_time = gethrestime_sec();
2400 time_t next_timeout = 0;
2401 uint32_t hdr_length;
2402 mblk_t *send_icmp_head;
2403 mblk_t *send_icmp_head_v6;
2404 ip_stack_t *ipst = ill->ill_ipst;
2405 ip_recv_attr_t iras;
2406
2407 bzero(&iras, sizeof (iras));
2408 iras.ira_flags = 0;
2409 iras.ira_ill = iras.ira_rill = ill;
2410 iras.ira_ruifindex = ill->ill_phyint->phyint_ifindex;
2411 iras.ira_rifindex = iras.ira_ruifindex;
2412
2413 ipfb = ill->ill_frag_hash_tbl;
2414 if (ipfb == NULL)
2415 return (B_FALSE);
2416 endp = &ipfb[ILL_FRAG_HASH_TBL_COUNT];
2417 /* Walk the frag hash table. */
2418 for (; ipfb < endp; ipfb++) {
2419 send_icmp_head = NULL;
2420 send_icmp_head_v6 = NULL;
2421 mutex_enter(&ipfb->ipfb_lock);
2422 while ((ipf = ipfb->ipfb_ipf) != 0) {
2423 time_t frag_time = current_time - ipf->ipf_timestamp;
2424 time_t frag_timeout;
2425
2426 if (frag_time < dead_interval) {
2427 /*
2428 * There are some outstanding fragments
2429 * that will timeout later. Make note of
2430 * the time so that we can reschedule the
2431 * next timeout appropriately.
2432 */
2433 frag_timeout = dead_interval - frag_time;
2434 if (next_timeout == 0 ||
2435 frag_timeout < next_timeout) {
2436 next_timeout = frag_timeout;
2437 }
2438 break;
2439 }
2440 /* Time's up. Get it out of here. */
2441 hdr_length = ipf->ipf_nf_hdr_len;
2442 ipfnext = ipf->ipf_hash_next;
2443 if (ipfnext)
2444 ipfnext->ipf_ptphn = ipf->ipf_ptphn;
2445 *ipf->ipf_ptphn = ipfnext;
2446 mp = ipf->ipf_mp->b_cont;
2447 for (; mp; mp = mp->b_cont) {
2448 /* Extra points for neatness. */
2449 IP_REASS_SET_START(mp, 0);
2450 IP_REASS_SET_END(mp, 0);
2451 }
2452 mp = ipf->ipf_mp->b_cont;
2453 atomic_add_32(&ill->ill_frag_count, -ipf->ipf_count);
2454 ASSERT(ipfb->ipfb_count >= ipf->ipf_count);
2455 ipfb->ipfb_count -= ipf->ipf_count;
2456 ASSERT(ipfb->ipfb_frag_pkts > 0);
2457 ipfb->ipfb_frag_pkts--;
2458 /*
2459 * We do not send any icmp message from here because
2460 * we currently are holding the ipfb_lock for this
2461 * hash chain. If we try and send any icmp messages
2462 * from here we may end up via a put back into ip
2463 * trying to get the same lock, causing a recursive
2464 * mutex panic. Instead we build a list and send all
2465 * the icmp messages after we have dropped the lock.
2466 */
2467 if (ill->ill_isv6) {
2468 if (hdr_length != 0) {
2469 mp->b_next = send_icmp_head_v6;
2470 send_icmp_head_v6 = mp;
2471 } else {
2472 freemsg(mp);
2473 }
2474 } else {
2475 if (hdr_length != 0) {
2476 mp->b_next = send_icmp_head;
2477 send_icmp_head = mp;
2478 } else {
2479 freemsg(mp);
2480 }
2481 }
2482 BUMP_MIB(ill->ill_ip_mib, ipIfStatsReasmFails);
2483 ip_drop_input("ipIfStatsReasmFails", ipf->ipf_mp, ill);
2484 freeb(ipf->ipf_mp);
2485 }
2486 mutex_exit(&ipfb->ipfb_lock);
2487 /*
2488 * Now need to send any icmp messages that we delayed from
2489 * above.
2490 */
2491 while (send_icmp_head_v6 != NULL) {
2492 ip6_t *ip6h;
2493
2494 mp = send_icmp_head_v6;
2495 send_icmp_head_v6 = send_icmp_head_v6->b_next;
2496 mp->b_next = NULL;
2497 ip6h = (ip6_t *)mp->b_rptr;
2498 iras.ira_flags = 0;
2499 /*
2500 * This will result in an incorrect ALL_ZONES zoneid
2501 * for multicast packets, but we
2502 * don't send ICMP errors for those in any case.
2503 */
2504 iras.ira_zoneid =
2505 ipif_lookup_addr_zoneid_v6(&ip6h->ip6_dst,
2506 ill, ipst);
2507 ip_drop_input("ICMP_TIME_EXCEEDED reass", mp, ill);
2508 icmp_time_exceeded_v6(mp,
2509 ICMP_REASSEMBLY_TIME_EXCEEDED, B_FALSE,
2510 &iras);
2511 ASSERT(!(iras.ira_flags & IRAF_IPSEC_SECURE));
2512 }
2513 while (send_icmp_head != NULL) {
2514 ipaddr_t dst;
2515
2516 mp = send_icmp_head;
2517 send_icmp_head = send_icmp_head->b_next;
2518 mp->b_next = NULL;
2519
2520 dst = ((ipha_t *)mp->b_rptr)->ipha_dst;
2521
2522 iras.ira_flags = IRAF_IS_IPV4;
2523 /*
2524 * This will result in an incorrect ALL_ZONES zoneid
2525 * for broadcast and multicast packets, but we
2526 * don't send ICMP errors for those in any case.
2527 */
2528 iras.ira_zoneid = ipif_lookup_addr_zoneid(dst,
2529 ill, ipst);
2530 ip_drop_input("ICMP_TIME_EXCEEDED reass", mp, ill);
2531 icmp_time_exceeded(mp,
2532 ICMP_REASSEMBLY_TIME_EXCEEDED, &iras);
2533 ASSERT(!(iras.ira_flags & IRAF_IPSEC_SECURE));
2534 }
2535 }
2536 /*
2537 * A non-dying ILL will use the return value to decide whether to
2538 * restart the frag timer, and for how long.
2539 */
2540 return (next_timeout);
2541 }
2542
2543 /*
2544 * This routine is called when the approximate count of mblk memory used
2545 * for the specified ILL has exceeded max_count.
2546 */
2547 void
2548 ill_frag_prune(ill_t *ill, uint_t max_count)
2549 {
2550 ipfb_t *ipfb;
2551 ipf_t *ipf;
2552 size_t count;
2553 clock_t now;
2554
2555 /*
2556 * If we are here within ip_min_frag_prune_time msecs remove
2557 * ill_frag_free_num_pkts oldest packets from each bucket and increment
2558 * ill_frag_free_num_pkts.
2559 */
2560 mutex_enter(&ill->ill_lock);
2561 now = ddi_get_lbolt();
2562 if (TICK_TO_MSEC(now - ill->ill_last_frag_clean_time) <=
2563 (ip_min_frag_prune_time != 0 ?
2564 ip_min_frag_prune_time : msec_per_tick)) {
2565
2566 ill->ill_frag_free_num_pkts++;
2567
2568 } else {
2569 ill->ill_frag_free_num_pkts = 0;
2570 }
2571 ill->ill_last_frag_clean_time = now;
2572 mutex_exit(&ill->ill_lock);
2573
2574 /*
2575 * free ill_frag_free_num_pkts oldest packets from each bucket.
2576 */
2577 if (ill->ill_frag_free_num_pkts != 0) {
2578 int ix;
2579
2580 for (ix = 0; ix < ILL_FRAG_HASH_TBL_COUNT; ix++) {
2581 ipfb = &ill->ill_frag_hash_tbl[ix];
2582 mutex_enter(&ipfb->ipfb_lock);
2583 if (ipfb->ipfb_ipf != NULL) {
2584 ill_frag_free_pkts(ill, ipfb, ipfb->ipfb_ipf,
2585 ill->ill_frag_free_num_pkts);
2586 }
2587 mutex_exit(&ipfb->ipfb_lock);
2588 }
2589 }
2590 /*
2591 * While the reassembly list for this ILL is too big, prune a fragment
2592 * queue by age, oldest first.
2593 */
2594 while (ill->ill_frag_count > max_count) {
2595 int ix;
2596 ipfb_t *oipfb = NULL;
2597 uint_t oldest = UINT_MAX;
2598
2599 count = 0;
2600 for (ix = 0; ix < ILL_FRAG_HASH_TBL_COUNT; ix++) {
2601 ipfb = &ill->ill_frag_hash_tbl[ix];
2602 mutex_enter(&ipfb->ipfb_lock);
2603 ipf = ipfb->ipfb_ipf;
2604 if (ipf != NULL && ipf->ipf_gen < oldest) {
2605 oldest = ipf->ipf_gen;
2606 oipfb = ipfb;
2607 }
2608 count += ipfb->ipfb_count;
2609 mutex_exit(&ipfb->ipfb_lock);
2610 }
2611 if (oipfb == NULL)
2612 break;
2613
2614 if (count <= max_count)
2615 return; /* Somebody beat us to it, nothing to do */
2616 mutex_enter(&oipfb->ipfb_lock);
2617 ipf = oipfb->ipfb_ipf;
2618 if (ipf != NULL) {
2619 ill_frag_free_pkts(ill, oipfb, ipf, 1);
2620 }
2621 mutex_exit(&oipfb->ipfb_lock);
2622 }
2623 }
2624
2625 /*
2626 * free 'free_cnt' fragmented packets starting at ipf.
2627 */
2628 void
2629 ill_frag_free_pkts(ill_t *ill, ipfb_t *ipfb, ipf_t *ipf, int free_cnt)
2630 {
2631 size_t count;
2632 mblk_t *mp;
2633 mblk_t *tmp;
2634 ipf_t **ipfp = ipf->ipf_ptphn;
2635
2636 ASSERT(MUTEX_HELD(&ipfb->ipfb_lock));
2637 ASSERT(ipfp != NULL);
2638 ASSERT(ipf != NULL);
2639
2640 while (ipf != NULL && free_cnt-- > 0) {
2641 count = ipf->ipf_count;
2642 mp = ipf->ipf_mp;
2643 ipf = ipf->ipf_hash_next;
2644 for (tmp = mp; tmp; tmp = tmp->b_cont) {
2645 IP_REASS_SET_START(tmp, 0);
2646 IP_REASS_SET_END(tmp, 0);
2647 }
2648 atomic_add_32(&ill->ill_frag_count, -count);
2649 ASSERT(ipfb->ipfb_count >= count);
2650 ipfb->ipfb_count -= count;
2651 ASSERT(ipfb->ipfb_frag_pkts > 0);
2652 ipfb->ipfb_frag_pkts--;
2653 BUMP_MIB(ill->ill_ip_mib, ipIfStatsReasmFails);
2654 ip_drop_input("ipIfStatsReasmFails", mp, ill);
2655 freemsg(mp);
2656 }
2657
2658 if (ipf)
2659 ipf->ipf_ptphn = ipfp;
2660 ipfp[0] = ipf;
2661 }
2662
2663 /*
2664 * Helper function for ill_forward_set().
2665 */
2666 static void
2667 ill_forward_set_on_ill(ill_t *ill, boolean_t enable)
2668 {
2669 ip_stack_t *ipst = ill->ill_ipst;
2670
2671 ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ipst->ips_ill_g_lock));
2672
2673 ip1dbg(("ill_forward_set: %s %s forwarding on %s",
2674 (enable ? "Enabling" : "Disabling"),
2675 (ill->ill_isv6 ? "IPv6" : "IPv4"), ill->ill_name));
2676 mutex_enter(&ill->ill_lock);
2677 if (enable)
2678 ill->ill_flags |= ILLF_ROUTER;
2679 else
2680 ill->ill_flags &= ~ILLF_ROUTER;
2681 mutex_exit(&ill->ill_lock);
2682 if (ill->ill_isv6)
2683 ill_set_nce_router_flags(ill, enable);
2684 /* Notify routing socket listeners of this change. */
2685 if (ill->ill_ipif != NULL)
2686 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
2687 }
2688
2689 /*
2690 * Set an ill's ILLF_ROUTER flag appropriately. Send up RTS_IFINFO routing
2691 * socket messages for each interface whose flags we change.
2692 */
2693 int
2694 ill_forward_set(ill_t *ill, boolean_t enable)
2695 {
2696 ipmp_illgrp_t *illg;
2697 ip_stack_t *ipst = ill->ill_ipst;
2698
2699 ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ipst->ips_ill_g_lock));
2700
2701 if ((enable && (ill->ill_flags & ILLF_ROUTER)) ||
2702 (!enable && !(ill->ill_flags & ILLF_ROUTER)))
2703 return (0);
2704
2705 if (IS_LOOPBACK(ill))
2706 return (EINVAL);
2707
2708 if (enable && ill->ill_allowed_ips_cnt > 0)
2709 return (EPERM);
2710
2711 if (IS_IPMP(ill) || IS_UNDER_IPMP(ill)) {
2712 /*
2713 * Update all of the interfaces in the group.
2714 */
2715 illg = ill->ill_grp;
2716 ill = list_head(&illg->ig_if);
2717 for (; ill != NULL; ill = list_next(&illg->ig_if, ill))
2718 ill_forward_set_on_ill(ill, enable);
2719
2720 /*
2721 * Update the IPMP meta-interface.
2722 */
2723 ill_forward_set_on_ill(ipmp_illgrp_ipmp_ill(illg), enable);
2724 return (0);
2725 }
2726
2727 ill_forward_set_on_ill(ill, enable);
2728 return (0);
2729 }
2730
2731 /*
2732 * Based on the ILLF_ROUTER flag of an ill, make sure all local nce's for
2733 * addresses assigned to the ill have the NCE_F_ISROUTER flag appropriately
2734 * set or clear.
2735 */
2736 static void
2737 ill_set_nce_router_flags(ill_t *ill, boolean_t enable)
2738 {
2739 ipif_t *ipif;
2740 ncec_t *ncec;
2741 nce_t *nce;
2742
2743 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
2744 /*
2745 * NOTE: we match across the illgrp because nce's for
2746 * addresses on IPMP interfaces have an nce_ill that points to
2747 * the bound underlying ill.
2748 */
2749 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
2750 if (nce != NULL) {
2751 ncec = nce->nce_common;
2752 mutex_enter(&ncec->ncec_lock);
2753 if (enable)
2754 ncec->ncec_flags |= NCE_F_ISROUTER;
2755 else
2756 ncec->ncec_flags &= ~NCE_F_ISROUTER;
2757 mutex_exit(&ncec->ncec_lock);
2758 nce_refrele(nce);
2759 }
2760 }
2761 }
2762
2763 /*
2764 * Intializes the context structure and returns the first ill in the list
2765 * cuurently start_list and end_list can have values:
2766 * MAX_G_HEADS Traverse both IPV4 and IPV6 lists.
2767 * IP_V4_G_HEAD Traverse IPV4 list only.
2768 * IP_V6_G_HEAD Traverse IPV6 list only.
2769 */
2770
2771 /*
2772 * We don't check for CONDEMNED ills here. Caller must do that if
2773 * necessary under the ill lock.
2774 */
2775 ill_t *
2776 ill_first(int start_list, int end_list, ill_walk_context_t *ctx,
2777 ip_stack_t *ipst)
2778 {
2779 ill_if_t *ifp;
2780 ill_t *ill;
2781 avl_tree_t *avl_tree;
2782
2783 ASSERT(RW_LOCK_HELD(&ipst->ips_ill_g_lock));
2784 ASSERT(end_list <= MAX_G_HEADS && start_list >= 0);
2785
2786 /*
2787 * setup the lists to search
2788 */
2789 if (end_list != MAX_G_HEADS) {
2790 ctx->ctx_current_list = start_list;
2791 ctx->ctx_last_list = end_list;
2792 } else {
2793 ctx->ctx_last_list = MAX_G_HEADS - 1;
2794 ctx->ctx_current_list = 0;
2795 }
2796
2797 while (ctx->ctx_current_list <= ctx->ctx_last_list) {
2798 ifp = IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst);
2799 if (ifp != (ill_if_t *)
2800 &IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst)) {
2801 avl_tree = &ifp->illif_avl_by_ppa;
2802 ill = avl_first(avl_tree);
2803 /*
2804 * ill is guaranteed to be non NULL or ifp should have
2805 * not existed.
2806 */
2807 ASSERT(ill != NULL);
2808 return (ill);
2809 }
2810 ctx->ctx_current_list++;
2811 }
2812
2813 return (NULL);
2814 }
2815
2816 /*
2817 * returns the next ill in the list. ill_first() must have been called
2818 * before calling ill_next() or bad things will happen.
2819 */
2820
2821 /*
2822 * We don't check for CONDEMNED ills here. Caller must do that if
2823 * necessary under the ill lock.
2824 */
2825 ill_t *
2826 ill_next(ill_walk_context_t *ctx, ill_t *lastill)
2827 {
2828 ill_if_t *ifp;
2829 ill_t *ill;
2830 ip_stack_t *ipst = lastill->ill_ipst;
2831
2832 ASSERT(lastill->ill_ifptr != (ill_if_t *)
2833 &IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst));
2834 if ((ill = avl_walk(&lastill->ill_ifptr->illif_avl_by_ppa, lastill,
2835 AVL_AFTER)) != NULL) {
2836 return (ill);
2837 }
2838
2839 /* goto next ill_ifp in the list. */
2840 ifp = lastill->ill_ifptr->illif_next;
2841
2842 /* make sure not at end of circular list */
2843 while (ifp ==
2844 (ill_if_t *)&IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst)) {
2845 if (++ctx->ctx_current_list > ctx->ctx_last_list)
2846 return (NULL);
2847 ifp = IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst);
2848 }
2849
2850 return (avl_first(&ifp->illif_avl_by_ppa));
2851 }
2852
2853 /*
2854 * Check interface name for correct format: [a-zA-Z]+[a-zA-Z0-9._]*[0-9]+
2855 * The final number (PPA) must not have any leading zeros. Upon success, a
2856 * pointer to the start of the PPA is returned; otherwise NULL is returned.
2857 */
2858 static char *
2859 ill_get_ppa_ptr(char *name)
2860 {
2861 int namelen = strlen(name);
2862 int end_ndx = namelen - 1;
2863 int ppa_ndx, i;
2864
2865 /*
2866 * Check that the first character is [a-zA-Z], and that the last
2867 * character is [0-9].
2868 */
2869 if (namelen == 0 || !isalpha(name[0]) || !isdigit(name[end_ndx]))
2870 return (NULL);
2871
2872 /*
2873 * Set `ppa_ndx' to the PPA start, and check for leading zeroes.
2874 */
2875 for (ppa_ndx = end_ndx; ppa_ndx > 0; ppa_ndx--)
2876 if (!isdigit(name[ppa_ndx - 1]))
2877 break;
2878
2879 if (name[ppa_ndx] == '0' && ppa_ndx < end_ndx)
2880 return (NULL);
2881
2882 /*
2883 * Check that the intermediate characters are [a-z0-9.]
2884 */
2885 for (i = 1; i < ppa_ndx; i++) {
2886 if (!isalpha(name[i]) && !isdigit(name[i]) &&
2887 name[i] != '.' && name[i] != '_') {
2888 return (NULL);
2889 }
2890 }
2891
2892 return (name + ppa_ndx);
2893 }
2894
2895 /*
2896 * use avl tree to locate the ill.
2897 */
2898 static ill_t *
2899 ill_find_by_name(char *name, boolean_t isv6, ip_stack_t *ipst)
2900 {
2901 char *ppa_ptr = NULL;
2902 int len;
2903 uint_t ppa;
2904 ill_t *ill = NULL;
2905 ill_if_t *ifp;
2906 int list;
2907
2908 /*
2909 * get ppa ptr
2910 */
2911 if (isv6)
2912 list = IP_V6_G_HEAD;
2913 else
2914 list = IP_V4_G_HEAD;
2915
2916 if ((ppa_ptr = ill_get_ppa_ptr(name)) == NULL) {
2917 return (NULL);
2918 }
2919
2920 len = ppa_ptr - name + 1;
2921
2922 ppa = stoi(&ppa_ptr);
2923
2924 ifp = IP_VX_ILL_G_LIST(list, ipst);
2925
2926 while (ifp != (ill_if_t *)&IP_VX_ILL_G_LIST(list, ipst)) {
2927 /*
2928 * match is done on len - 1 as the name is not null
2929 * terminated it contains ppa in addition to the interface
2930 * name.
2931 */
2932 if ((ifp->illif_name_len == len) &&
2933 bcmp(ifp->illif_name, name, len - 1) == 0) {
2934 break;
2935 } else {
2936 ifp = ifp->illif_next;
2937 }
2938 }
2939
2940 if (ifp == (ill_if_t *)&IP_VX_ILL_G_LIST(list, ipst)) {
2941 /*
2942 * Even the interface type does not exist.
2943 */
2944 return (NULL);
2945 }
2946
2947 ill = avl_find(&ifp->illif_avl_by_ppa, (void *) &ppa, NULL);
2948 if (ill != NULL) {
2949 mutex_enter(&ill->ill_lock);
2950 if (ILL_CAN_LOOKUP(ill)) {
2951 ill_refhold_locked(ill);
2952 mutex_exit(&ill->ill_lock);
2953 return (ill);
2954 }
2955 mutex_exit(&ill->ill_lock);
2956 }
2957 return (NULL);
2958 }
2959
2960 /*
2961 * comparison function for use with avl.
2962 */
2963 static int
2964 ill_compare_ppa(const void *ppa_ptr, const void *ill_ptr)
2965 {
2966 uint_t ppa;
2967 uint_t ill_ppa;
2968
2969 ASSERT(ppa_ptr != NULL && ill_ptr != NULL);
2970
2971 ppa = *((uint_t *)ppa_ptr);
2972 ill_ppa = ((const ill_t *)ill_ptr)->ill_ppa;
2973 /*
2974 * We want the ill with the lowest ppa to be on the
2975 * top.
2976 */
2977 if (ill_ppa < ppa)
2978 return (1);
2979 if (ill_ppa > ppa)
2980 return (-1);
2981 return (0);
2982 }
2983
2984 /*
2985 * remove an interface type from the global list.
2986 */
2987 static void
2988 ill_delete_interface_type(ill_if_t *interface)
2989 {
2990 ASSERT(interface != NULL);
2991 ASSERT(avl_numnodes(&interface->illif_avl_by_ppa) == 0);
2992
2993 avl_destroy(&interface->illif_avl_by_ppa);
2994 if (interface->illif_ppa_arena != NULL)
2995 vmem_destroy(interface->illif_ppa_arena);
2996
2997 remque(interface);
2998
2999 mi_free(interface);
3000 }
3001
3002 /*
3003 * remove ill from the global list.
3004 */
3005 static void
3006 ill_glist_delete(ill_t *ill)
3007 {
3008 ip_stack_t *ipst;
3009 phyint_t *phyi;
3010
3011 if (ill == NULL)
3012 return;
3013 ipst = ill->ill_ipst;
3014 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
3015
3016 /*
3017 * If the ill was never inserted into the AVL tree
3018 * we skip the if branch.
3019 */
3020 if (ill->ill_ifptr != NULL) {
3021 /*
3022 * remove from AVL tree and free ppa number
3023 */
3024 avl_remove(&ill->ill_ifptr->illif_avl_by_ppa, ill);
3025
3026 if (ill->ill_ifptr->illif_ppa_arena != NULL) {
3027 vmem_free(ill->ill_ifptr->illif_ppa_arena,
3028 (void *)(uintptr_t)(ill->ill_ppa+1), 1);
3029 }
3030 if (avl_numnodes(&ill->ill_ifptr->illif_avl_by_ppa) == 0) {
3031 ill_delete_interface_type(ill->ill_ifptr);
3032 }
3033
3034 /*
3035 * Indicate ill is no longer in the list.
3036 */
3037 ill->ill_ifptr = NULL;
3038 ill->ill_name_length = 0;
3039 ill->ill_name[0] = '\0';
3040 ill->ill_ppa = UINT_MAX;
3041 }
3042
3043 /* Generate one last event for this ill. */
3044 ill_nic_event_dispatch(ill, 0, NE_UNPLUMB, ill->ill_name,
3045 ill->ill_name_length);
3046
3047 ASSERT(ill->ill_phyint != NULL);
3048 phyi = ill->ill_phyint;
3049 ill->ill_phyint = NULL;
3050
3051 /*
3052 * ill_init allocates a phyint always to store the copy
3053 * of flags relevant to phyint. At that point in time, we could
3054 * not assign the name and hence phyint_illv4/v6 could not be
3055 * initialized. Later in ipif_set_values, we assign the name to
3056 * the ill, at which point in time we assign phyint_illv4/v6.
3057 * Thus we don't rely on phyint_illv6 to be initialized always.
3058 */
3059 if (ill->ill_flags & ILLF_IPV6)
3060 phyi->phyint_illv6 = NULL;
3061 else
3062 phyi->phyint_illv4 = NULL;
3063
3064 if (phyi->phyint_illv4 != NULL || phyi->phyint_illv6 != NULL) {
3065 rw_exit(&ipst->ips_ill_g_lock);
3066 return;
3067 }
3068
3069 /*
3070 * There are no ills left on this phyint; pull it out of the phyint
3071 * avl trees, and free it.
3072 */
3073 if (phyi->phyint_ifindex > 0) {
3074 avl_remove(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3075 phyi);
3076 avl_remove(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
3077 phyi);
3078 }
3079 rw_exit(&ipst->ips_ill_g_lock);
3080
3081 phyint_free(phyi);
3082 }
3083
3084 /*
3085 * allocate a ppa, if the number of plumbed interfaces of this type are
3086 * less than ill_no_arena do a linear search to find a unused ppa.
3087 * When the number goes beyond ill_no_arena switch to using an arena.
3088 * Note: ppa value of zero cannot be allocated from vmem_arena as it
3089 * is the return value for an error condition, so allocation starts at one
3090 * and is decremented by one.
3091 */
3092 static int
3093 ill_alloc_ppa(ill_if_t *ifp, ill_t *ill)
3094 {
3095 ill_t *tmp_ill;
3096 uint_t start, end;
3097 int ppa;
3098
3099 if (ifp->illif_ppa_arena == NULL &&
3100 (avl_numnodes(&ifp->illif_avl_by_ppa) + 1 > ill_no_arena)) {
3101 /*
3102 * Create an arena.
3103 */
3104 ifp->illif_ppa_arena = vmem_create(ifp->illif_name,
3105 (void *)1, UINT_MAX - 1, 1, NULL, NULL,
3106 NULL, 0, VM_SLEEP | VMC_IDENTIFIER);
3107 /* allocate what has already been assigned */
3108 for (tmp_ill = avl_first(&ifp->illif_avl_by_ppa);
3109 tmp_ill != NULL; tmp_ill = avl_walk(&ifp->illif_avl_by_ppa,
3110 tmp_ill, AVL_AFTER)) {
3111 ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena,
3112 1, /* size */
3113 1, /* align/quantum */
3114 0, /* phase */
3115 0, /* nocross */
3116 /* minaddr */
3117 (void *)((uintptr_t)tmp_ill->ill_ppa + 1),
3118 /* maxaddr */
3119 (void *)((uintptr_t)tmp_ill->ill_ppa + 2),
3120 VM_NOSLEEP|VM_FIRSTFIT);
3121 if (ppa == 0) {
3122 ip1dbg(("ill_alloc_ppa: ppa allocation"
3123 " failed while switching"));
3124 vmem_destroy(ifp->illif_ppa_arena);
3125 ifp->illif_ppa_arena = NULL;
3126 break;
3127 }
3128 }
3129 }
3130
3131 if (ifp->illif_ppa_arena != NULL) {
3132 if (ill->ill_ppa == UINT_MAX) {
3133 ppa = (int)(uintptr_t)vmem_alloc(ifp->illif_ppa_arena,
3134 1, VM_NOSLEEP|VM_FIRSTFIT);
3135 if (ppa == 0)
3136 return (EAGAIN);
3137 ill->ill_ppa = --ppa;
3138 } else {
3139 ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena,
3140 1, /* size */
3141 1, /* align/quantum */
3142 0, /* phase */
3143 0, /* nocross */
3144 (void *)(uintptr_t)(ill->ill_ppa + 1), /* minaddr */
3145 (void *)(uintptr_t)(ill->ill_ppa + 2), /* maxaddr */
3146 VM_NOSLEEP|VM_FIRSTFIT);
3147 /*
3148 * Most likely the allocation failed because
3149 * the requested ppa was in use.
3150 */
3151 if (ppa == 0)
3152 return (EEXIST);
3153 }
3154 return (0);
3155 }
3156
3157 /*
3158 * No arena is in use and not enough (>ill_no_arena) interfaces have
3159 * been plumbed to create one. Do a linear search to get a unused ppa.
3160 */
3161 if (ill->ill_ppa == UINT_MAX) {
3162 end = UINT_MAX - 1;
3163 start = 0;
3164 } else {
3165 end = start = ill->ill_ppa;
3166 }
3167
3168 tmp_ill = avl_find(&ifp->illif_avl_by_ppa, (void *)&start, NULL);
3169 while (tmp_ill != NULL && tmp_ill->ill_ppa == start) {
3170 if (start++ >= end) {
3171 if (ill->ill_ppa == UINT_MAX)
3172 return (EAGAIN);
3173 else
3174 return (EEXIST);
3175 }
3176 tmp_ill = avl_walk(&ifp->illif_avl_by_ppa, tmp_ill, AVL_AFTER);
3177 }
3178 ill->ill_ppa = start;
3179 return (0);
3180 }
3181
3182 /*
3183 * Insert ill into the list of configured ill's. Once this function completes,
3184 * the ill is globally visible and is available through lookups. More precisely
3185 * this happens after the caller drops the ill_g_lock.
3186 */
3187 static int
3188 ill_glist_insert(ill_t *ill, char *name, boolean_t isv6)
3189 {
3190 ill_if_t *ill_interface;
3191 avl_index_t where = 0;
3192 int error;
3193 int name_length;
3194 int index;
3195 boolean_t check_length = B_FALSE;
3196 ip_stack_t *ipst = ill->ill_ipst;
3197
3198 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock));
3199
3200 name_length = mi_strlen(name) + 1;
3201
3202 if (isv6)
3203 index = IP_V6_G_HEAD;
3204 else
3205 index = IP_V4_G_HEAD;
3206
3207 ill_interface = IP_VX_ILL_G_LIST(index, ipst);
3208 /*
3209 * Search for interface type based on name
3210 */
3211 while (ill_interface != (ill_if_t *)&IP_VX_ILL_G_LIST(index, ipst)) {
3212 if ((ill_interface->illif_name_len == name_length) &&
3213 (strcmp(ill_interface->illif_name, name) == 0)) {
3214 break;
3215 }
3216 ill_interface = ill_interface->illif_next;
3217 }
3218
3219 /*
3220 * Interface type not found, create one.
3221 */
3222 if (ill_interface == (ill_if_t *)&IP_VX_ILL_G_LIST(index, ipst)) {
3223 ill_g_head_t ghead;
3224
3225 /*
3226 * allocate ill_if_t structure
3227 */
3228 ill_interface = (ill_if_t *)mi_zalloc(sizeof (ill_if_t));
3229 if (ill_interface == NULL) {
3230 return (ENOMEM);
3231 }
3232
3233 (void) strcpy(ill_interface->illif_name, name);
3234 ill_interface->illif_name_len = name_length;
3235
3236 avl_create(&ill_interface->illif_avl_by_ppa,
3237 ill_compare_ppa, sizeof (ill_t),
3238 offsetof(struct ill_s, ill_avl_byppa));
3239
3240 /*
3241 * link the structure in the back to maintain order
3242 * of configuration for ifconfig output.
3243 */
3244 ghead = ipst->ips_ill_g_heads[index];
3245 insque(ill_interface, ghead.ill_g_list_tail);
3246 }
3247
3248 if (ill->ill_ppa == UINT_MAX)
3249 check_length = B_TRUE;
3250
3251 error = ill_alloc_ppa(ill_interface, ill);
3252 if (error != 0) {
3253 if (avl_numnodes(&ill_interface->illif_avl_by_ppa) == 0)
3254 ill_delete_interface_type(ill->ill_ifptr);
3255 return (error);
3256 }
3257
3258 /*
3259 * When the ppa is choosen by the system, check that there is
3260 * enough space to insert ppa. if a specific ppa was passed in this
3261 * check is not required as the interface name passed in will have
3262 * the right ppa in it.
3263 */
3264 if (check_length) {
3265 /*
3266 * UINT_MAX - 1 should fit in 10 chars, alloc 12 chars.
3267 */
3268 char buf[sizeof (uint_t) * 3];
3269
3270 /*
3271 * convert ppa to string to calculate the amount of space
3272 * required for it in the name.
3273 */
3274 numtos(ill->ill_ppa, buf);
3275
3276 /* Do we have enough space to insert ppa ? */
3277
3278 if ((mi_strlen(name) + mi_strlen(buf) + 1) > LIFNAMSIZ) {
3279 /* Free ppa and interface type struct */
3280 if (ill_interface->illif_ppa_arena != NULL) {
3281 vmem_free(ill_interface->illif_ppa_arena,
3282 (void *)(uintptr_t)(ill->ill_ppa+1), 1);
3283 }
3284 if (avl_numnodes(&ill_interface->illif_avl_by_ppa) == 0)
3285 ill_delete_interface_type(ill->ill_ifptr);
3286
3287 return (EINVAL);
3288 }
3289 }
3290
3291 (void) sprintf(ill->ill_name, "%s%u", name, ill->ill_ppa);
3292 ill->ill_name_length = mi_strlen(ill->ill_name) + 1;
3293
3294 (void) avl_find(&ill_interface->illif_avl_by_ppa, &ill->ill_ppa,
3295 &where);
3296 ill->ill_ifptr = ill_interface;
3297 avl_insert(&ill_interface->illif_avl_by_ppa, ill, where);
3298
3299 ill_phyint_reinit(ill);
3300 return (0);
3301 }
3302
3303 /* Initialize the per phyint ipsq used for serialization */
3304 static boolean_t
3305 ipsq_init(ill_t *ill, boolean_t enter)
3306 {
3307 ipsq_t *ipsq;
3308 ipxop_t *ipx;
3309
3310 if ((ipsq = kmem_zalloc(sizeof (ipsq_t), KM_NOSLEEP)) == NULL)
3311 return (B_FALSE);
3312
3313 ill->ill_phyint->phyint_ipsq = ipsq;
3314 ipx = ipsq->ipsq_xop = &ipsq->ipsq_ownxop;
3315 ipx->ipx_ipsq = ipsq;
3316 ipsq->ipsq_next = ipsq;
3317 ipsq->ipsq_phyint = ill->ill_phyint;
3318 mutex_init(&ipsq->ipsq_lock, NULL, MUTEX_DEFAULT, 0);
3319 mutex_init(&ipx->ipx_lock, NULL, MUTEX_DEFAULT, 0);
3320 ipsq->ipsq_ipst = ill->ill_ipst; /* No netstack_hold */
3321 if (enter) {
3322 ipx->ipx_writer = curthread;
3323 ipx->ipx_forced = B_FALSE;
3324 ipx->ipx_reentry_cnt = 1;
3325 #ifdef DEBUG
3326 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
3327 #endif
3328 }
3329 return (B_TRUE);
3330 }
3331
3332 /*
3333 * ill_init is called by ip_open when a device control stream is opened.
3334 * It does a few initializations, and shoots a DL_INFO_REQ message down
3335 * to the driver. The response is later picked up in ip_rput_dlpi and
3336 * used to set up default mechanisms for talking to the driver. (Always
3337 * called as writer.)
3338 *
3339 * If this function returns error, ip_open will call ip_close which in
3340 * turn will call ill_delete to clean up any memory allocated here that
3341 * is not yet freed.
3342 */
3343 int
3344 ill_init(queue_t *q, ill_t *ill)
3345 {
3346 int count;
3347 dl_info_req_t *dlir;
3348 mblk_t *info_mp;
3349 uchar_t *frag_ptr;
3350
3351 /*
3352 * The ill is initialized to zero by mi_alloc*(). In addition
3353 * some fields already contain valid values, initialized in
3354 * ip_open(), before we reach here.
3355 */
3356 mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, 0);
3357 mutex_init(&ill->ill_saved_ire_lock, NULL, MUTEX_DEFAULT, NULL);
3358 ill->ill_saved_ire_cnt = 0;
3359
3360 ill->ill_rq = q;
3361 ill->ill_wq = WR(q);
3362
3363 info_mp = allocb(MAX(sizeof (dl_info_req_t), sizeof (dl_info_ack_t)),
3364 BPRI_HI);
3365 if (info_mp == NULL)
3366 return (ENOMEM);
3367
3368 /*
3369 * Allocate sufficient space to contain our fragment hash table and
3370 * the device name.
3371 */
3372 frag_ptr = (uchar_t *)mi_zalloc(ILL_FRAG_HASH_TBL_SIZE + 2 * LIFNAMSIZ);
3373 if (frag_ptr == NULL) {
3374 freemsg(info_mp);
3375 return (ENOMEM);
3376 }
3377 ill->ill_frag_ptr = frag_ptr;
3378 ill->ill_frag_free_num_pkts = 0;
3379 ill->ill_last_frag_clean_time = 0;
3380 ill->ill_frag_hash_tbl = (ipfb_t *)frag_ptr;
3381 ill->ill_name = (char *)(frag_ptr + ILL_FRAG_HASH_TBL_SIZE);
3382 for (count = 0; count < ILL_FRAG_HASH_TBL_COUNT; count++) {
3383 mutex_init(&ill->ill_frag_hash_tbl[count].ipfb_lock,
3384 NULL, MUTEX_DEFAULT, NULL);
3385 }
3386
3387 ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t));
3388 if (ill->ill_phyint == NULL) {
3389 freemsg(info_mp);
3390 mi_free(frag_ptr);
3391 return (ENOMEM);
3392 }
3393
3394 mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0);
3395 /*
3396 * For now pretend this is a v4 ill. We need to set phyint_ill*
3397 * at this point because of the following reason. If we can't
3398 * enter the ipsq at some point and cv_wait, the writer that
3399 * wakes us up tries to locate us using the list of all phyints
3400 * in an ipsq and the ills from the phyint thru the phyint_ill*.
3401 * If we don't set it now, we risk a missed wakeup.
3402 */
3403 ill->ill_phyint->phyint_illv4 = ill;
3404 ill->ill_ppa = UINT_MAX;
3405 list_create(&ill->ill_nce, sizeof (nce_t), offsetof(nce_t, nce_node));
3406
3407 ill_set_inputfn(ill);
3408
3409 if (!ipsq_init(ill, B_TRUE)) {
3410 freemsg(info_mp);
3411 mi_free(frag_ptr);
3412 mi_free(ill->ill_phyint);
3413 return (ENOMEM);
3414 }
3415
3416 ill->ill_state_flags |= ILL_LL_SUBNET_PENDING;
3417
3418 /* Frag queue limit stuff */
3419 ill->ill_frag_count = 0;
3420 ill->ill_ipf_gen = 0;
3421
3422 rw_init(&ill->ill_mcast_lock, NULL, RW_DEFAULT, NULL);
3423 mutex_init(&ill->ill_mcast_serializer, NULL, MUTEX_DEFAULT, NULL);
3424 ill->ill_global_timer = INFINITY;
3425 ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0;
3426 ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0;
3427 ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS;
3428 ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL;
3429
3430 /*
3431 * Initialize IPv6 configuration variables. The IP module is always
3432 * opened as an IPv4 module. Instead tracking down the cases where
3433 * it switches to do ipv6, we'll just initialize the IPv6 configuration
3434 * here for convenience, this has no effect until the ill is set to do
3435 * IPv6.
3436 */
3437 ill->ill_reachable_time = ND_REACHABLE_TIME;
3438 ill->ill_xmit_count = ND_MAX_MULTICAST_SOLICIT;
3439 ill->ill_max_buf = ND_MAX_Q;
3440 ill->ill_refcnt = 0;
3441
3442 /* Send down the Info Request to the driver. */
3443 info_mp->b_datap->db_type = M_PCPROTO;
3444 dlir = (dl_info_req_t *)info_mp->b_rptr;
3445 info_mp->b_wptr = (uchar_t *)&dlir[1];
3446 dlir->dl_primitive = DL_INFO_REQ;
3447
3448 ill->ill_dlpi_pending = DL_PRIM_INVAL;
3449
3450 qprocson(q);
3451 ill_dlpi_send(ill, info_mp);
3452
3453 return (0);
3454 }
3455
3456 /*
3457 * ill_dls_info
3458 * creates datalink socket info from the device.
3459 */
3460 int
3461 ill_dls_info(struct sockaddr_dl *sdl, const ill_t *ill)
3462 {
3463 size_t len;
3464
3465 sdl->sdl_family = AF_LINK;
3466 sdl->sdl_index = ill_get_upper_ifindex(ill);
3467 sdl->sdl_type = ill->ill_type;
3468 ill_get_name(ill, sdl->sdl_data, sizeof (sdl->sdl_data));
3469 len = strlen(sdl->sdl_data);
3470 ASSERT(len < 256);
3471 sdl->sdl_nlen = (uchar_t)len;
3472 sdl->sdl_alen = ill->ill_phys_addr_length;
3473 sdl->sdl_slen = 0;
3474 if (ill->ill_phys_addr_length != 0 && ill->ill_phys_addr != NULL)
3475 bcopy(ill->ill_phys_addr, &sdl->sdl_data[len], sdl->sdl_alen);
3476
3477 return (sizeof (struct sockaddr_dl));
3478 }
3479
3480 /*
3481 * ill_xarp_info
3482 * creates xarp info from the device.
3483 */
3484 static int
3485 ill_xarp_info(struct sockaddr_dl *sdl, ill_t *ill)
3486 {
3487 sdl->sdl_family = AF_LINK;
3488 sdl->sdl_index = ill->ill_phyint->phyint_ifindex;
3489 sdl->sdl_type = ill->ill_type;
3490 ill_get_name(ill, sdl->sdl_data, sizeof (sdl->sdl_data));
3491 sdl->sdl_nlen = (uchar_t)mi_strlen(sdl->sdl_data);
3492 sdl->sdl_alen = ill->ill_phys_addr_length;
3493 sdl->sdl_slen = 0;
3494 return (sdl->sdl_nlen);
3495 }
3496
3497 static int
3498 loopback_kstat_update(kstat_t *ksp, int rw)
3499 {
3500 kstat_named_t *kn;
3501 netstackid_t stackid;
3502 netstack_t *ns;
3503 ip_stack_t *ipst;
3504
3505 if (ksp == NULL || ksp->ks_data == NULL)
3506 return (EIO);
3507
3508 if (rw == KSTAT_WRITE)
3509 return (EACCES);
3510
3511 kn = KSTAT_NAMED_PTR(ksp);
3512 stackid = (zoneid_t)(uintptr_t)ksp->ks_private;
3513
3514 ns = netstack_find_by_stackid(stackid);
3515 if (ns == NULL)
3516 return (-1);
3517
3518 ipst = ns->netstack_ip;
3519 if (ipst == NULL) {
3520 netstack_rele(ns);
3521 return (-1);
3522 }
3523 kn[0].value.ui32 = ipst->ips_loopback_packets;
3524 kn[1].value.ui32 = ipst->ips_loopback_packets;
3525 netstack_rele(ns);
3526 return (0);
3527 }
3528
3529 /*
3530 * Has ifindex been plumbed already?
3531 */
3532 static boolean_t
3533 phyint_exists(uint_t index, ip_stack_t *ipst)
3534 {
3535 ASSERT(index != 0);
3536 ASSERT(RW_LOCK_HELD(&ipst->ips_ill_g_lock));
3537
3538 return (avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3539 &index, NULL) != NULL);
3540 }
3541
3542 /*
3543 * Pick a unique ifindex.
3544 * When the index counter passes IF_INDEX_MAX for the first time, the wrap
3545 * flag is set so that next time time ip_assign_ifindex() is called, it
3546 * falls through and resets the index counter back to 1, the minimum value
3547 * for the interface index. The logic below assumes that ips_ill_index
3548 * can hold a value of IF_INDEX_MAX+1 without there being any loss
3549 * (i.e. reset back to 0.)
3550 */
3551 boolean_t
3552 ip_assign_ifindex(uint_t *indexp, ip_stack_t *ipst)
3553 {
3554 uint_t loops;
3555
3556 if (!ipst->ips_ill_index_wrap) {
3557 *indexp = ipst->ips_ill_index++;
3558 if (ipst->ips_ill_index > IF_INDEX_MAX) {
3559 /*
3560 * Reached the maximum ifindex value, set the wrap
3561 * flag to indicate that it is no longer possible
3562 * to assume that a given index is unallocated.
3563 */
3564 ipst->ips_ill_index_wrap = B_TRUE;
3565 }
3566 return (B_TRUE);
3567 }
3568
3569 if (ipst->ips_ill_index > IF_INDEX_MAX)
3570 ipst->ips_ill_index = 1;
3571
3572 /*
3573 * Start reusing unused indexes. Note that we hold the ill_g_lock
3574 * at this point and don't want to call any function that attempts
3575 * to get the lock again.
3576 */
3577 for (loops = IF_INDEX_MAX; loops > 0; loops--) {
3578 if (!phyint_exists(ipst->ips_ill_index, ipst)) {
3579 /* found unused index - use it */
3580 *indexp = ipst->ips_ill_index;
3581 return (B_TRUE);
3582 }
3583
3584 ipst->ips_ill_index++;
3585 if (ipst->ips_ill_index > IF_INDEX_MAX)
3586 ipst->ips_ill_index = 1;
3587 }
3588
3589 /*
3590 * all interface indicies are inuse.
3591 */
3592 return (B_FALSE);
3593 }
3594
3595 /*
3596 * Assign a unique interface index for the phyint.
3597 */
3598 static boolean_t
3599 phyint_assign_ifindex(phyint_t *phyi, ip_stack_t *ipst)
3600 {
3601 ASSERT(phyi->phyint_ifindex == 0);
3602 return (ip_assign_ifindex(&phyi->phyint_ifindex, ipst));
3603 }
3604
3605 /*
3606 * Initialize the flags on `phyi' as per the provided mactype.
3607 */
3608 static void
3609 phyint_flags_init(phyint_t *phyi, t_uscalar_t mactype)
3610 {
3611 uint64_t flags = 0;
3612
3613 /*
3614 * Initialize PHYI_RUNNING and PHYI_FAILED. For non-IPMP interfaces,
3615 * we always presume the underlying hardware is working and set
3616 * PHYI_RUNNING (if it's not, the driver will subsequently send a
3617 * DL_NOTE_LINK_DOWN message). For IPMP interfaces, at initialization
3618 * there are no active interfaces in the group so we set PHYI_FAILED.
3619 */
3620 if (mactype == SUNW_DL_IPMP)
3621 flags |= PHYI_FAILED;
3622 else
3623 flags |= PHYI_RUNNING;
3624
3625 switch (mactype) {
3626 case SUNW_DL_VNI:
3627 flags |= PHYI_VIRTUAL;
3628 break;
3629 case SUNW_DL_IPMP:
3630 flags |= PHYI_IPMP;
3631 break;
3632 case DL_LOOP:
3633 flags |= (PHYI_LOOPBACK | PHYI_VIRTUAL);
3634 break;
3635 }
3636
3637 mutex_enter(&phyi->phyint_lock);
3638 phyi->phyint_flags |= flags;
3639 mutex_exit(&phyi->phyint_lock);
3640 }
3641
3642 /*
3643 * Return a pointer to the ill which matches the supplied name. Note that
3644 * the ill name length includes the null termination character. (May be
3645 * called as writer.)
3646 * If do_alloc and the interface is "lo0" it will be automatically created.
3647 * Cannot bump up reference on condemned ills. So dup detect can't be done
3648 * using this func.
3649 */
3650 ill_t *
3651 ill_lookup_on_name(char *name, boolean_t do_alloc, boolean_t isv6,
3652 boolean_t *did_alloc, ip_stack_t *ipst)
3653 {
3654 ill_t *ill;
3655 ipif_t *ipif;
3656 ipsq_t *ipsq;
3657 kstat_named_t *kn;
3658 boolean_t isloopback;
3659 in6_addr_t ov6addr;
3660
3661 isloopback = mi_strcmp(name, ipif_loopback_name) == 0;
3662
3663 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
3664 ill = ill_find_by_name(name, isv6, ipst);
3665 rw_exit(&ipst->ips_ill_g_lock);
3666 if (ill != NULL)
3667 return (ill);
3668
3669 /*
3670 * Couldn't find it. Does this happen to be a lookup for the
3671 * loopback device and are we allowed to allocate it?
3672 */
3673 if (!isloopback || !do_alloc)
3674 return (NULL);
3675
3676 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
3677 ill = ill_find_by_name(name, isv6, ipst);
3678 if (ill != NULL) {
3679 rw_exit(&ipst->ips_ill_g_lock);
3680 return (ill);
3681 }
3682
3683 /* Create the loopback device on demand */
3684 ill = (ill_t *)(mi_alloc(sizeof (ill_t) +
3685 sizeof (ipif_loopback_name), BPRI_MED));
3686 if (ill == NULL)
3687 goto done;
3688
3689 *ill = ill_null;
3690 mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, NULL);
3691 ill->ill_ipst = ipst;
3692 list_create(&ill->ill_nce, sizeof (nce_t), offsetof(nce_t, nce_node));
3693 netstack_hold(ipst->ips_netstack);
3694 /*
3695 * For exclusive stacks we set the zoneid to zero
3696 * to make IP operate as if in the global zone.
3697 */
3698 ill->ill_zoneid = GLOBAL_ZONEID;
3699
3700 ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t));
3701 if (ill->ill_phyint == NULL)
3702 goto done;
3703
3704 if (isv6)
3705 ill->ill_phyint->phyint_illv6 = ill;
3706 else
3707 ill->ill_phyint->phyint_illv4 = ill;
3708 mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0);
3709 phyint_flags_init(ill->ill_phyint, DL_LOOP);
3710
3711 if (isv6) {
3712 ill->ill_isv6 = B_TRUE;
3713 ill->ill_max_frag = ip_loopback_mtu_v6plus;
3714 } else {
3715 ill->ill_max_frag = ip_loopback_mtuplus;
3716 }
3717 if (!ill_allocate_mibs(ill))
3718 goto done;
3719 ill->ill_current_frag = ill->ill_max_frag;
3720 ill->ill_mtu = ill->ill_max_frag; /* Initial value */
3721 ill->ill_mc_mtu = ill->ill_mtu;
3722 /*
3723 * ipif_loopback_name can't be pointed at directly because its used
3724 * by both the ipv4 and ipv6 interfaces. When the ill is removed
3725 * from the glist, ill_glist_delete() sets the first character of
3726 * ill_name to '\0'.
3727 */
3728 ill->ill_name = (char *)ill + sizeof (*ill);
3729 (void) strcpy(ill->ill_name, ipif_loopback_name);
3730 ill->ill_name_length = sizeof (ipif_loopback_name);
3731 /* Set ill_dlpi_pending for ipsq_current_finish() to work properly */
3732 ill->ill_dlpi_pending = DL_PRIM_INVAL;
3733
3734 rw_init(&ill->ill_mcast_lock, NULL, RW_DEFAULT, NULL);
3735 mutex_init(&ill->ill_mcast_serializer, NULL, MUTEX_DEFAULT, NULL);
3736 ill->ill_global_timer = INFINITY;
3737 ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0;
3738 ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0;
3739 ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS;
3740 ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL;
3741
3742 /* No resolver here. */
3743 ill->ill_net_type = IRE_LOOPBACK;
3744
3745 /* Initialize the ipsq */
3746 if (!ipsq_init(ill, B_FALSE))
3747 goto done;
3748
3749 ipif = ipif_allocate(ill, 0L, IRE_LOOPBACK, B_TRUE, B_TRUE, NULL);
3750 if (ipif == NULL)
3751 goto done;
3752
3753 ill->ill_flags = ILLF_MULTICAST;
3754
3755 ov6addr = ipif->ipif_v6lcl_addr;
3756 /* Set up default loopback address and mask. */
3757 if (!isv6) {
3758 ipaddr_t inaddr_loopback = htonl(INADDR_LOOPBACK);
3759
3760 IN6_IPADDR_TO_V4MAPPED(inaddr_loopback, &ipif->ipif_v6lcl_addr);
3761 V4MASK_TO_V6(htonl(IN_CLASSA_NET), ipif->ipif_v6net_mask);
3762 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
3763 ipif->ipif_v6subnet);
3764 ill->ill_flags |= ILLF_IPV4;
3765 } else {
3766 ipif->ipif_v6lcl_addr = ipv6_loopback;
3767 ipif->ipif_v6net_mask = ipv6_all_ones;
3768 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
3769 ipif->ipif_v6subnet);
3770 ill->ill_flags |= ILLF_IPV6;
3771 }
3772
3773 /*
3774 * Chain us in at the end of the ill list. hold the ill
3775 * before we make it globally visible. 1 for the lookup.
3776 */
3777 ill->ill_refcnt = 0;
3778 ill_refhold(ill);
3779
3780 ill->ill_frag_count = 0;
3781 ill->ill_frag_free_num_pkts = 0;
3782 ill->ill_last_frag_clean_time = 0;
3783
3784 ipsq = ill->ill_phyint->phyint_ipsq;
3785
3786 ill_set_inputfn(ill);
3787
3788 if (ill_glist_insert(ill, "lo", isv6) != 0)
3789 cmn_err(CE_PANIC, "cannot insert loopback interface");
3790
3791 /* Let SCTP know so that it can add this to its list */
3792 sctp_update_ill(ill, SCTP_ILL_INSERT);
3793
3794 /*
3795 * We have already assigned ipif_v6lcl_addr above, but we need to
3796 * call sctp_update_ipif_addr() after SCTP_ILL_INSERT, which
3797 * requires to be after ill_glist_insert() since we need the
3798 * ill_index set. Pass on ipv6_loopback as the old address.
3799 */
3800 sctp_update_ipif_addr(ipif, ov6addr);
3801
3802 ip_rts_newaddrmsg(RTM_CHGADDR, 0, ipif, RTSQ_DEFAULT);
3803
3804 /*
3805 * ill_glist_insert() -> ill_phyint_reinit() may have merged IPSQs.
3806 * If so, free our original one.
3807 */
3808 if (ipsq != ill->ill_phyint->phyint_ipsq)
3809 ipsq_delete(ipsq);
3810
3811 if (ipst->ips_loopback_ksp == NULL) {
3812 /* Export loopback interface statistics */
3813 ipst->ips_loopback_ksp = kstat_create_netstack("lo", 0,
3814 ipif_loopback_name, "net",
3815 KSTAT_TYPE_NAMED, 2, 0,
3816 ipst->ips_netstack->netstack_stackid);
3817 if (ipst->ips_loopback_ksp != NULL) {
3818 ipst->ips_loopback_ksp->ks_update =
3819 loopback_kstat_update;
3820 kn = KSTAT_NAMED_PTR(ipst->ips_loopback_ksp);
3821 kstat_named_init(&kn[0], "ipackets", KSTAT_DATA_UINT32);
3822 kstat_named_init(&kn[1], "opackets", KSTAT_DATA_UINT32);
3823 ipst->ips_loopback_ksp->ks_private =
3824 (void *)(uintptr_t)ipst->ips_netstack->
3825 netstack_stackid;
3826 kstat_install(ipst->ips_loopback_ksp);
3827 }
3828 }
3829
3830 *did_alloc = B_TRUE;
3831 rw_exit(&ipst->ips_ill_g_lock);
3832 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ill->ill_ipif->ipif_id),
3833 NE_PLUMB, ill->ill_name, ill->ill_name_length);
3834 return (ill);
3835 done:
3836 if (ill != NULL) {
3837 if (ill->ill_phyint != NULL) {
3838 ipsq = ill->ill_phyint->phyint_ipsq;
3839 if (ipsq != NULL) {
3840 ipsq->ipsq_phyint = NULL;
3841 ipsq_delete(ipsq);
3842 }
3843 mi_free(ill->ill_phyint);
3844 }
3845 ill_free_mib(ill);
3846 if (ill->ill_ipst != NULL)
3847 netstack_rele(ill->ill_ipst->ips_netstack);
3848 mi_free(ill);
3849 }
3850 rw_exit(&ipst->ips_ill_g_lock);
3851 return (NULL);
3852 }
3853
3854 /*
3855 * For IPP calls - use the ip_stack_t for global stack.
3856 */
3857 ill_t *
3858 ill_lookup_on_ifindex_global_instance(uint_t index, boolean_t isv6)
3859 {
3860 ip_stack_t *ipst;
3861 ill_t *ill;
3862
3863 ipst = netstack_find_by_stackid(GLOBAL_NETSTACKID)->netstack_ip;
3864 if (ipst == NULL) {
3865 cmn_err(CE_WARN, "No ip_stack_t for zoneid zero!\n");
3866 return (NULL);
3867 }
3868
3869 ill = ill_lookup_on_ifindex(index, isv6, ipst);
3870 netstack_rele(ipst->ips_netstack);
3871 return (ill);
3872 }
3873
3874 /*
3875 * Return a pointer to the ill which matches the index and IP version type.
3876 */
3877 ill_t *
3878 ill_lookup_on_ifindex(uint_t index, boolean_t isv6, ip_stack_t *ipst)
3879 {
3880 ill_t *ill;
3881 phyint_t *phyi;
3882
3883 /*
3884 * Indexes are stored in the phyint - a common structure
3885 * to both IPv4 and IPv6.
3886 */
3887 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
3888 phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3889 (void *) &index, NULL);
3890 if (phyi != NULL) {
3891 ill = isv6 ? phyi->phyint_illv6: phyi->phyint_illv4;
3892 if (ill != NULL) {
3893 mutex_enter(&ill->ill_lock);
3894 if (!ILL_IS_CONDEMNED(ill)) {
3895 ill_refhold_locked(ill);
3896 mutex_exit(&ill->ill_lock);
3897 rw_exit(&ipst->ips_ill_g_lock);
3898 return (ill);
3899 }
3900 mutex_exit(&ill->ill_lock);
3901 }
3902 }
3903 rw_exit(&ipst->ips_ill_g_lock);
3904 return (NULL);
3905 }
3906
3907 /*
3908 * Verify whether or not an interface index is valid for the specified zoneid
3909 * to transmit packets.
3910 * It can be zero (meaning "reset") or an interface index assigned
3911 * to a non-VNI interface. (We don't use VNI interface to send packets.)
3912 */
3913 boolean_t
3914 ip_xmit_ifindex_valid(uint_t ifindex, zoneid_t zoneid, boolean_t isv6,
3915 ip_stack_t *ipst)
3916 {
3917 ill_t *ill;
3918
3919 if (ifindex == 0)
3920 return (B_TRUE);
3921
3922 ill = ill_lookup_on_ifindex_zoneid(ifindex, zoneid, isv6, ipst);
3923 if (ill == NULL)
3924 return (B_FALSE);
3925 if (IS_VNI(ill)) {
3926 ill_refrele(ill);
3927 return (B_FALSE);
3928 }
3929 ill_refrele(ill);
3930 return (B_TRUE);
3931 }
3932
3933 /*
3934 * Return the ifindex next in sequence after the passed in ifindex.
3935 * If there is no next ifindex for the given protocol, return 0.
3936 */
3937 uint_t
3938 ill_get_next_ifindex(uint_t index, boolean_t isv6, ip_stack_t *ipst)
3939 {
3940 phyint_t *phyi;
3941 phyint_t *phyi_initial;
3942 uint_t ifindex;
3943
3944 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
3945
3946 if (index == 0) {
3947 phyi = avl_first(
3948 &ipst->ips_phyint_g_list->phyint_list_avl_by_index);
3949 } else {
3950 phyi = phyi_initial = avl_find(
3951 &ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3952 (void *) &index, NULL);
3953 }
3954
3955 for (; phyi != NULL;
3956 phyi = avl_walk(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3957 phyi, AVL_AFTER)) {
3958 /*
3959 * If we're not returning the first interface in the tree
3960 * and we still haven't moved past the phyint_t that
3961 * corresponds to index, avl_walk needs to be called again
3962 */
3963 if (!((index != 0) && (phyi == phyi_initial))) {
3964 if (isv6) {
3965 if ((phyi->phyint_illv6) &&
3966 ILL_CAN_LOOKUP(phyi->phyint_illv6) &&
3967 (phyi->phyint_illv6->ill_isv6 == 1))
3968 break;
3969 } else {
3970 if ((phyi->phyint_illv4) &&
3971 ILL_CAN_LOOKUP(phyi->phyint_illv4) &&
3972 (phyi->phyint_illv4->ill_isv6 == 0))
3973 break;
3974 }
3975 }
3976 }
3977
3978 rw_exit(&ipst->ips_ill_g_lock);
3979
3980 if (phyi != NULL)
3981 ifindex = phyi->phyint_ifindex;
3982 else
3983 ifindex = 0;
3984
3985 return (ifindex);
3986 }
3987
3988 /*
3989 * Return the ifindex for the named interface.
3990 * If there is no next ifindex for the interface, return 0.
3991 */
3992 uint_t
3993 ill_get_ifindex_by_name(char *name, ip_stack_t *ipst)
3994 {
3995 phyint_t *phyi;
3996 avl_index_t where = 0;
3997 uint_t ifindex;
3998
3999 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4000
4001 if ((phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
4002 name, &where)) == NULL) {
4003 rw_exit(&ipst->ips_ill_g_lock);
4004 return (0);
4005 }
4006
4007 ifindex = phyi->phyint_ifindex;
4008
4009 rw_exit(&ipst->ips_ill_g_lock);
4010
4011 return (ifindex);
4012 }
4013
4014 /*
4015 * Return the ifindex to be used by upper layer protocols for instance
4016 * for IPV6_RECVPKTINFO. If IPMP this is the one for the upper ill.
4017 */
4018 uint_t
4019 ill_get_upper_ifindex(const ill_t *ill)
4020 {
4021 if (IS_UNDER_IPMP(ill))
4022 return (ipmp_ill_get_ipmp_ifindex(ill));
4023 else
4024 return (ill->ill_phyint->phyint_ifindex);
4025 }
4026
4027
4028 /*
4029 * Obtain a reference to the ill. The ill_refcnt is a dynamic refcnt
4030 * that gives a running thread a reference to the ill. This reference must be
4031 * released by the thread when it is done accessing the ill and related
4032 * objects. ill_refcnt can not be used to account for static references
4033 * such as other structures pointing to an ill. Callers must generally
4034 * check whether an ill can be refheld by using ILL_CAN_LOOKUP macros
4035 * or be sure that the ill is not being deleted or changing state before
4036 * calling the refhold functions. A non-zero ill_refcnt ensures that the
4037 * ill won't change any of its critical state such as address, netmask etc.
4038 */
4039 void
4040 ill_refhold(ill_t *ill)
4041 {
4042 mutex_enter(&ill->ill_lock);
4043 ill->ill_refcnt++;
4044 ILL_TRACE_REF(ill);
4045 mutex_exit(&ill->ill_lock);
4046 }
4047
4048 void
4049 ill_refhold_locked(ill_t *ill)
4050 {
4051 ASSERT(MUTEX_HELD(&ill->ill_lock));
4052 ill->ill_refcnt++;
4053 ILL_TRACE_REF(ill);
4054 }
4055
4056 /* Returns true if we managed to get a refhold */
4057 boolean_t
4058 ill_check_and_refhold(ill_t *ill)
4059 {
4060 mutex_enter(&ill->ill_lock);
4061 if (!ILL_IS_CONDEMNED(ill)) {
4062 ill_refhold_locked(ill);
4063 mutex_exit(&ill->ill_lock);
4064 return (B_TRUE);
4065 }
4066 mutex_exit(&ill->ill_lock);
4067 return (B_FALSE);
4068 }
4069
4070 /*
4071 * Must not be called while holding any locks. Otherwise if this is
4072 * the last reference to be released, there is a chance of recursive mutex
4073 * panic due to ill_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
4074 * to restart an ioctl.
4075 */
4076 void
4077 ill_refrele(ill_t *ill)
4078 {
4079 mutex_enter(&ill->ill_lock);
4080 ASSERT(ill->ill_refcnt != 0);
4081 ill->ill_refcnt--;
4082 ILL_UNTRACE_REF(ill);
4083 if (ill->ill_refcnt != 0) {
4084 /* Every ire pointing to the ill adds 1 to ill_refcnt */
4085 mutex_exit(&ill->ill_lock);
4086 return;
4087 }
4088
4089 /* Drops the ill_lock */
4090 ipif_ill_refrele_tail(ill);
4091 }
4092
4093 /*
4094 * Obtain a weak reference count on the ill. This reference ensures the
4095 * ill won't be freed, but the ill may change any of its critical state
4096 * such as netmask, address etc. Returns an error if the ill has started
4097 * closing.
4098 */
4099 boolean_t
4100 ill_waiter_inc(ill_t *ill)
4101 {
4102 mutex_enter(&ill->ill_lock);
4103 if (ill->ill_state_flags & ILL_CONDEMNED) {
4104 mutex_exit(&ill->ill_lock);
4105 return (B_FALSE);
4106 }
4107 ill->ill_waiters++;
4108 mutex_exit(&ill->ill_lock);
4109 return (B_TRUE);
4110 }
4111
4112 void
4113 ill_waiter_dcr(ill_t *ill)
4114 {
4115 mutex_enter(&ill->ill_lock);
4116 ill->ill_waiters--;
4117 if (ill->ill_waiters == 0)
4118 cv_broadcast(&ill->ill_cv);
4119 mutex_exit(&ill->ill_lock);
4120 }
4121
4122 /*
4123 * ip_ll_subnet_defaults is called when we get the DL_INFO_ACK back from the
4124 * driver. We construct best guess defaults for lower level information that
4125 * we need. If an interface is brought up without injection of any overriding
4126 * information from outside, we have to be ready to go with these defaults.
4127 * When we get the first DL_INFO_ACK (from ip_open() sending a DL_INFO_REQ)
4128 * we primarely want the dl_provider_style.
4129 * The subsequent DL_INFO_ACK is received after doing a DL_ATTACH and DL_BIND
4130 * at which point we assume the other part of the information is valid.
4131 */
4132 void
4133 ip_ll_subnet_defaults(ill_t *ill, mblk_t *mp)
4134 {
4135 uchar_t *brdcst_addr;
4136 uint_t brdcst_addr_length, phys_addr_length;
4137 t_scalar_t sap_length;
4138 dl_info_ack_t *dlia;
4139 ip_m_t *ipm;
4140 dl_qos_cl_sel1_t *sel1;
4141 int min_mtu;
4142
4143 ASSERT(IAM_WRITER_ILL(ill));
4144
4145 /*
4146 * Till the ill is fully up the ill is not globally visible.
4147 * So no need for a lock.
4148 */
4149 dlia = (dl_info_ack_t *)mp->b_rptr;
4150 ill->ill_mactype = dlia->dl_mac_type;
4151
4152 ipm = ip_m_lookup(dlia->dl_mac_type);
4153 if (ipm == NULL) {
4154 ipm = ip_m_lookup(DL_OTHER);
4155 ASSERT(ipm != NULL);
4156 }
4157 ill->ill_media = ipm;
4158
4159 /*
4160 * When the new DLPI stuff is ready we'll pull lengths
4161 * from dlia.
4162 */
4163 if (dlia->dl_version == DL_VERSION_2) {
4164 brdcst_addr_length = dlia->dl_brdcst_addr_length;
4165 brdcst_addr = mi_offset_param(mp, dlia->dl_brdcst_addr_offset,
4166 brdcst_addr_length);
4167 if (brdcst_addr == NULL) {
4168 brdcst_addr_length = 0;
4169 }
4170 sap_length = dlia->dl_sap_length;
4171 phys_addr_length = dlia->dl_addr_length - ABS(sap_length);
4172 ip1dbg(("ip: bcast_len %d, sap_len %d, phys_len %d\n",
4173 brdcst_addr_length, sap_length, phys_addr_length));
4174 } else {
4175 brdcst_addr_length = 6;
4176 brdcst_addr = ip_six_byte_all_ones;
4177 sap_length = -2;
4178 phys_addr_length = brdcst_addr_length;
4179 }
4180
4181 ill->ill_bcast_addr_length = brdcst_addr_length;
4182 ill->ill_phys_addr_length = phys_addr_length;
4183 ill->ill_sap_length = sap_length;
4184
4185 /*
4186 * Synthetic DLPI types such as SUNW_DL_IPMP specify a zero SDU,
4187 * but we must ensure a minimum IP MTU is used since other bits of
4188 * IP will fly apart otherwise.
4189 */
4190 min_mtu = ill->ill_isv6 ? IPV6_MIN_MTU : IP_MIN_MTU;
4191 ill->ill_max_frag = MAX(min_mtu, dlia->dl_max_sdu);
4192 ill->ill_current_frag = ill->ill_max_frag;
4193 ill->ill_mtu = ill->ill_max_frag;
4194 ill->ill_mc_mtu = ill->ill_mtu; /* Overridden by DL_NOTE_SDU_SIZE2 */
4195
4196 ill->ill_type = ipm->ip_m_type;
4197
4198 if (!ill->ill_dlpi_style_set) {
4199 if (dlia->dl_provider_style == DL_STYLE2)
4200 ill->ill_needs_attach = 1;
4201
4202 phyint_flags_init(ill->ill_phyint, ill->ill_mactype);
4203
4204 /*
4205 * Allocate the first ipif on this ill. We don't delay it
4206 * further as ioctl handling assumes at least one ipif exists.
4207 *
4208 * At this point we don't know whether the ill is v4 or v6.
4209 * We will know this whan the SIOCSLIFNAME happens and
4210 * the correct value for ill_isv6 will be assigned in
4211 * ipif_set_values(). We need to hold the ill lock and
4212 * clear the ILL_LL_SUBNET_PENDING flag and atomically do
4213 * the wakeup.
4214 */
4215 (void) ipif_allocate(ill, 0, IRE_LOCAL,
4216 dlia->dl_provider_style != DL_STYLE2, B_TRUE, NULL);
4217 mutex_enter(&ill->ill_lock);
4218 ASSERT(ill->ill_dlpi_style_set == 0);
4219 ill->ill_dlpi_style_set = 1;
4220 ill->ill_state_flags &= ~ILL_LL_SUBNET_PENDING;
4221 cv_broadcast(&ill->ill_cv);
4222 mutex_exit(&ill->ill_lock);
4223 freemsg(mp);
4224 return;
4225 }
4226 ASSERT(ill->ill_ipif != NULL);
4227 /*
4228 * We know whether it is IPv4 or IPv6 now, as this is the
4229 * second DL_INFO_ACK we are recieving in response to the
4230 * DL_INFO_REQ sent in ipif_set_values.
4231 */
4232 ill->ill_sap = (ill->ill_isv6) ? ipm->ip_m_ipv6sap : ipm->ip_m_ipv4sap;
4233 /*
4234 * Clear all the flags that were set based on ill_bcast_addr_length
4235 * and ill_phys_addr_length (in ipif_set_values) as these could have
4236 * changed now and we need to re-evaluate.
4237 */
4238 ill->ill_flags &= ~(ILLF_MULTICAST | ILLF_NONUD | ILLF_NOARP);
4239 ill->ill_ipif->ipif_flags &= ~(IPIF_BROADCAST | IPIF_POINTOPOINT);
4240
4241 /*
4242 * Free ill_bcast_mp as things could have changed now.
4243 *
4244 * NOTE: The IPMP meta-interface is special-cased because it starts
4245 * with no underlying interfaces (and thus an unknown broadcast
4246 * address length), but we enforce that an interface is broadcast-
4247 * capable as part of allowing it to join a group.
4248 */
4249 if (ill->ill_bcast_addr_length == 0 && !IS_IPMP(ill)) {
4250 if (ill->ill_bcast_mp != NULL)
4251 freemsg(ill->ill_bcast_mp);
4252 ill->ill_net_type = IRE_IF_NORESOLVER;
4253
4254 ill->ill_bcast_mp = ill_dlur_gen(NULL,
4255 ill->ill_phys_addr_length,
4256 ill->ill_sap,
4257 ill->ill_sap_length);
4258
4259 if (ill->ill_isv6)
4260 /*
4261 * Note: xresolv interfaces will eventually need NOARP
4262 * set here as well, but that will require those
4263 * external resolvers to have some knowledge of
4264 * that flag and act appropriately. Not to be changed
4265 * at present.
4266 */
4267 ill->ill_flags |= ILLF_NONUD;
4268 else
4269 ill->ill_flags |= ILLF_NOARP;
4270
4271 if (ill->ill_mactype == SUNW_DL_VNI) {
4272 ill->ill_ipif->ipif_flags |= IPIF_NOXMIT;
4273 } else if (ill->ill_phys_addr_length == 0 ||
4274 ill->ill_mactype == DL_IPV4 ||
4275 ill->ill_mactype == DL_IPV6) {
4276 /*
4277 * The underying link is point-to-point, so mark the
4278 * interface as such. We can do IP multicast over
4279 * such a link since it transmits all network-layer
4280 * packets to the remote side the same way.
4281 */
4282 ill->ill_flags |= ILLF_MULTICAST;
4283 ill->ill_ipif->ipif_flags |= IPIF_POINTOPOINT;
4284 }
4285 } else {
4286 ill->ill_net_type = IRE_IF_RESOLVER;
4287 if (ill->ill_bcast_mp != NULL)
4288 freemsg(ill->ill_bcast_mp);
4289 ill->ill_bcast_mp = ill_dlur_gen(brdcst_addr,
4290 ill->ill_bcast_addr_length, ill->ill_sap,
4291 ill->ill_sap_length);
4292 /*
4293 * Later detect lack of DLPI driver multicast
4294 * capability by catching DL_ENABMULTI errors in
4295 * ip_rput_dlpi.
4296 */
4297 ill->ill_flags |= ILLF_MULTICAST;
4298 if (!ill->ill_isv6)
4299 ill->ill_ipif->ipif_flags |= IPIF_BROADCAST;
4300 }
4301
4302 /* For IPMP, PHYI_IPMP should already be set by phyint_flags_init() */
4303 if (ill->ill_mactype == SUNW_DL_IPMP)
4304 ASSERT(ill->ill_phyint->phyint_flags & PHYI_IPMP);
4305
4306 /* By default an interface does not support any CoS marking */
4307 ill->ill_flags &= ~ILLF_COS_ENABLED;
4308
4309 /*
4310 * If we get QoS information in DL_INFO_ACK, the device supports
4311 * some form of CoS marking, set ILLF_COS_ENABLED.
4312 */
4313 sel1 = (dl_qos_cl_sel1_t *)mi_offset_param(mp, dlia->dl_qos_offset,
4314 dlia->dl_qos_length);
4315 if ((sel1 != NULL) && (sel1->dl_qos_type == DL_QOS_CL_SEL1)) {
4316 ill->ill_flags |= ILLF_COS_ENABLED;
4317 }
4318
4319 /* Clear any previous error indication. */
4320 ill->ill_error = 0;
4321 freemsg(mp);
4322 }
4323
4324 /*
4325 * Perform various checks to verify that an address would make sense as a
4326 * local, remote, or subnet interface address.
4327 */
4328 static boolean_t
4329 ip_addr_ok_v4(ipaddr_t addr, ipaddr_t subnet_mask)
4330 {
4331 ipaddr_t net_mask;
4332
4333 /*
4334 * Don't allow all zeroes, or all ones, but allow
4335 * all ones netmask.
4336 */
4337 if ((net_mask = ip_net_mask(addr)) == 0)
4338 return (B_FALSE);
4339 /* A given netmask overrides the "guess" netmask */
4340 if (subnet_mask != 0)
4341 net_mask = subnet_mask;
4342 if ((net_mask != ~(ipaddr_t)0) && ((addr == (addr & net_mask)) ||
4343 (addr == (addr | ~net_mask)))) {
4344 return (B_FALSE);
4345 }
4346
4347 /*
4348 * Even if the netmask is all ones, we do not allow address to be
4349 * 255.255.255.255
4350 */
4351 if (addr == INADDR_BROADCAST)
4352 return (B_FALSE);
4353
4354 if (CLASSD(addr))
4355 return (B_FALSE);
4356
4357 return (B_TRUE);
4358 }
4359
4360 #define V6_IPIF_LINKLOCAL(p) \
4361 IN6_IS_ADDR_LINKLOCAL(&(p)->ipif_v6lcl_addr)
4362
4363 /*
4364 * Compare two given ipifs and check if the second one is better than
4365 * the first one using the order of preference (not taking deprecated
4366 * into acount) specified in ipif_lookup_multicast().
4367 */
4368 static boolean_t
4369 ipif_comp_multi(ipif_t *old_ipif, ipif_t *new_ipif, boolean_t isv6)
4370 {
4371 /* Check the least preferred first. */
4372 if (IS_LOOPBACK(old_ipif->ipif_ill)) {
4373 /* If both ipifs are the same, use the first one. */
4374 if (IS_LOOPBACK(new_ipif->ipif_ill))
4375 return (B_FALSE);
4376 else
4377 return (B_TRUE);
4378 }
4379
4380 /* For IPv6, check for link local address. */
4381 if (isv6 && V6_IPIF_LINKLOCAL(old_ipif)) {
4382 if (IS_LOOPBACK(new_ipif->ipif_ill) ||
4383 V6_IPIF_LINKLOCAL(new_ipif)) {
4384 /* The second one is equal or less preferred. */
4385 return (B_FALSE);
4386 } else {
4387 return (B_TRUE);
4388 }
4389 }
4390
4391 /* Then check for point to point interface. */
4392 if (old_ipif->ipif_flags & IPIF_POINTOPOINT) {
4393 if (IS_LOOPBACK(new_ipif->ipif_ill) ||
4394 (isv6 && V6_IPIF_LINKLOCAL(new_ipif)) ||
4395 (new_ipif->ipif_flags & IPIF_POINTOPOINT)) {
4396 return (B_FALSE);
4397 } else {
4398 return (B_TRUE);
4399 }
4400 }
4401
4402 /* old_ipif is a normal interface, so no need to use the new one. */
4403 return (B_FALSE);
4404 }
4405
4406 /*
4407 * Find a mulitcast-capable ipif given an IP instance and zoneid.
4408 * The ipif must be up, and its ill must multicast-capable, not
4409 * condemned, not an underlying interface in an IPMP group, and
4410 * not a VNI interface. Order of preference:
4411 *
4412 * 1a. normal
4413 * 1b. normal, but deprecated
4414 * 2a. point to point
4415 * 2b. point to point, but deprecated
4416 * 3a. link local
4417 * 3b. link local, but deprecated
4418 * 4. loopback.
4419 */
4420 static ipif_t *
4421 ipif_lookup_multicast(ip_stack_t *ipst, zoneid_t zoneid, boolean_t isv6)
4422 {
4423 ill_t *ill;
4424 ill_walk_context_t ctx;
4425 ipif_t *ipif;
4426 ipif_t *saved_ipif = NULL;
4427 ipif_t *dep_ipif = NULL;
4428
4429 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4430 if (isv6)
4431 ill = ILL_START_WALK_V6(&ctx, ipst);
4432 else
4433 ill = ILL_START_WALK_V4(&ctx, ipst);
4434
4435 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4436 mutex_enter(&ill->ill_lock);
4437 if (IS_VNI(ill) || IS_UNDER_IPMP(ill) ||
4438 ILL_IS_CONDEMNED(ill) ||
4439 !(ill->ill_flags & ILLF_MULTICAST)) {
4440 mutex_exit(&ill->ill_lock);
4441 continue;
4442 }
4443 for (ipif = ill->ill_ipif; ipif != NULL;
4444 ipif = ipif->ipif_next) {
4445 if (zoneid != ipif->ipif_zoneid &&
4446 zoneid != ALL_ZONES &&
4447 ipif->ipif_zoneid != ALL_ZONES) {
4448 continue;
4449 }
4450 if (!(ipif->ipif_flags & IPIF_UP) ||
4451 IPIF_IS_CONDEMNED(ipif)) {
4452 continue;
4453 }
4454
4455 /*
4456 * Found one candidate. If it is deprecated,
4457 * remember it in dep_ipif. If it is not deprecated,
4458 * remember it in saved_ipif.
4459 */
4460 if (ipif->ipif_flags & IPIF_DEPRECATED) {
4461 if (dep_ipif == NULL) {
4462 dep_ipif = ipif;
4463 } else if (ipif_comp_multi(dep_ipif, ipif,
4464 isv6)) {
4465 /*
4466 * If the previous dep_ipif does not
4467 * belong to the same ill, we've done
4468 * a ipif_refhold() on it. So we need
4469 * to release it.
4470 */
4471 if (dep_ipif->ipif_ill != ill)
4472 ipif_refrele(dep_ipif);
4473 dep_ipif = ipif;
4474 }
4475 continue;
4476 }
4477 if (saved_ipif == NULL) {
4478 saved_ipif = ipif;
4479 } else {
4480 if (ipif_comp_multi(saved_ipif, ipif, isv6)) {
4481 if (saved_ipif->ipif_ill != ill)
4482 ipif_refrele(saved_ipif);
4483 saved_ipif = ipif;
4484 }
4485 }
4486 }
4487 /*
4488 * Before going to the next ill, do a ipif_refhold() on the
4489 * saved ones.
4490 */
4491 if (saved_ipif != NULL && saved_ipif->ipif_ill == ill)
4492 ipif_refhold_locked(saved_ipif);
4493 if (dep_ipif != NULL && dep_ipif->ipif_ill == ill)
4494 ipif_refhold_locked(dep_ipif);
4495 mutex_exit(&ill->ill_lock);
4496 }
4497 rw_exit(&ipst->ips_ill_g_lock);
4498
4499 /*
4500 * If we have only the saved_ipif, return it. But if we have both
4501 * saved_ipif and dep_ipif, check to see which one is better.
4502 */
4503 if (saved_ipif != NULL) {
4504 if (dep_ipif != NULL) {
4505 if (ipif_comp_multi(saved_ipif, dep_ipif, isv6)) {
4506 ipif_refrele(saved_ipif);
4507 return (dep_ipif);
4508 } else {
4509 ipif_refrele(dep_ipif);
4510 return (saved_ipif);
4511 }
4512 }
4513 return (saved_ipif);
4514 } else {
4515 return (dep_ipif);
4516 }
4517 }
4518
4519 ill_t *
4520 ill_lookup_multicast(ip_stack_t *ipst, zoneid_t zoneid, boolean_t isv6)
4521 {
4522 ipif_t *ipif;
4523 ill_t *ill;
4524
4525 ipif = ipif_lookup_multicast(ipst, zoneid, isv6);
4526 if (ipif == NULL)
4527 return (NULL);
4528
4529 ill = ipif->ipif_ill;
4530 ill_refhold(ill);
4531 ipif_refrele(ipif);
4532 return (ill);
4533 }
4534
4535 /*
4536 * This function is called when an application does not specify an interface
4537 * to be used for multicast traffic (joining a group/sending data). It
4538 * calls ire_lookup_multi() to look for an interface route for the
4539 * specified multicast group. Doing this allows the administrator to add
4540 * prefix routes for multicast to indicate which interface to be used for
4541 * multicast traffic in the above scenario. The route could be for all
4542 * multicast (224.0/4), for a single multicast group (a /32 route) or
4543 * anything in between. If there is no such multicast route, we just find
4544 * any multicast capable interface and return it. The returned ipif
4545 * is refhold'ed.
4546 *
4547 * We support MULTIRT and RTF_SETSRC on the multicast routes added to the
4548 * unicast table. This is used by CGTP.
4549 */
4550 ill_t *
4551 ill_lookup_group_v4(ipaddr_t group, zoneid_t zoneid, ip_stack_t *ipst,
4552 boolean_t *multirtp, ipaddr_t *setsrcp)
4553 {
4554 ill_t *ill;
4555
4556 ill = ire_lookup_multi_ill_v4(group, zoneid, ipst, multirtp, setsrcp);
4557 if (ill != NULL)
4558 return (ill);
4559
4560 return (ill_lookup_multicast(ipst, zoneid, B_FALSE));
4561 }
4562
4563 /*
4564 * Look for an ipif with the specified interface address and destination.
4565 * The destination address is used only for matching point-to-point interfaces.
4566 */
4567 ipif_t *
4568 ipif_lookup_interface(ipaddr_t if_addr, ipaddr_t dst, ip_stack_t *ipst)
4569 {
4570 ipif_t *ipif;
4571 ill_t *ill;
4572 ill_walk_context_t ctx;
4573
4574 /*
4575 * First match all the point-to-point interfaces
4576 * before looking at non-point-to-point interfaces.
4577 * This is done to avoid returning non-point-to-point
4578 * ipif instead of unnumbered point-to-point ipif.
4579 */
4580 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4581 ill = ILL_START_WALK_V4(&ctx, ipst);
4582 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4583 mutex_enter(&ill->ill_lock);
4584 for (ipif = ill->ill_ipif; ipif != NULL;
4585 ipif = ipif->ipif_next) {
4586 /* Allow the ipif to be down */
4587 if ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
4588 (ipif->ipif_lcl_addr == if_addr) &&
4589 (ipif->ipif_pp_dst_addr == dst)) {
4590 if (!IPIF_IS_CONDEMNED(ipif)) {
4591 ipif_refhold_locked(ipif);
4592 mutex_exit(&ill->ill_lock);
4593 rw_exit(&ipst->ips_ill_g_lock);
4594 return (ipif);
4595 }
4596 }
4597 }
4598 mutex_exit(&ill->ill_lock);
4599 }
4600 rw_exit(&ipst->ips_ill_g_lock);
4601
4602 /* lookup the ipif based on interface address */
4603 ipif = ipif_lookup_addr(if_addr, NULL, ALL_ZONES, ipst);
4604 ASSERT(ipif == NULL || !ipif->ipif_isv6);
4605 return (ipif);
4606 }
4607
4608 /*
4609 * Common function for ipif_lookup_addr() and ipif_lookup_addr_exact().
4610 */
4611 static ipif_t *
4612 ipif_lookup_addr_common(ipaddr_t addr, ill_t *match_ill, uint32_t match_flags,
4613 zoneid_t zoneid, ip_stack_t *ipst)
4614 {
4615 ipif_t *ipif;
4616 ill_t *ill;
4617 boolean_t ptp = B_FALSE;
4618 ill_walk_context_t ctx;
4619 boolean_t match_illgrp = (match_flags & IPIF_MATCH_ILLGRP);
4620 boolean_t no_duplicate = (match_flags & IPIF_MATCH_NONDUP);
4621
4622 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4623 /*
4624 * Repeat twice, first based on local addresses and
4625 * next time for pointopoint.
4626 */
4627 repeat:
4628 ill = ILL_START_WALK_V4(&ctx, ipst);
4629 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4630 if (match_ill != NULL && ill != match_ill &&
4631 (!match_illgrp || !IS_IN_SAME_ILLGRP(ill, match_ill))) {
4632 continue;
4633 }
4634 mutex_enter(&ill->ill_lock);
4635 for (ipif = ill->ill_ipif; ipif != NULL;
4636 ipif = ipif->ipif_next) {
4637 if (zoneid != ALL_ZONES &&
4638 zoneid != ipif->ipif_zoneid &&
4639 ipif->ipif_zoneid != ALL_ZONES)
4640 continue;
4641
4642 if (no_duplicate && !(ipif->ipif_flags & IPIF_UP))
4643 continue;
4644
4645 /* Allow the ipif to be down */
4646 if ((!ptp && (ipif->ipif_lcl_addr == addr) &&
4647 ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) ||
4648 (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) &&
4649 (ipif->ipif_pp_dst_addr == addr))) {
4650 if (!IPIF_IS_CONDEMNED(ipif)) {
4651 ipif_refhold_locked(ipif);
4652 mutex_exit(&ill->ill_lock);
4653 rw_exit(&ipst->ips_ill_g_lock);
4654 return (ipif);
4655 }
4656 }
4657 }
4658 mutex_exit(&ill->ill_lock);
4659 }
4660
4661 /* If we already did the ptp case, then we are done */
4662 if (ptp) {
4663 rw_exit(&ipst->ips_ill_g_lock);
4664 return (NULL);
4665 }
4666 ptp = B_TRUE;
4667 goto repeat;
4668 }
4669
4670 /*
4671 * Lookup an ipif with the specified address. For point-to-point links we
4672 * look for matches on either the destination address or the local address,
4673 * but we skip the local address check if IPIF_UNNUMBERED is set. If the
4674 * `match_ill' argument is non-NULL, the lookup is restricted to that ill
4675 * (or illgrp if `match_ill' is in an IPMP group).
4676 */
4677 ipif_t *
4678 ipif_lookup_addr(ipaddr_t addr, ill_t *match_ill, zoneid_t zoneid,
4679 ip_stack_t *ipst)
4680 {
4681 return (ipif_lookup_addr_common(addr, match_ill, IPIF_MATCH_ILLGRP,
4682 zoneid, ipst));
4683 }
4684
4685 /*
4686 * Lookup an ipif with the specified address. Similar to ipif_lookup_addr,
4687 * except that we will only return an address if it is not marked as
4688 * IPIF_DUPLICATE
4689 */
4690 ipif_t *
4691 ipif_lookup_addr_nondup(ipaddr_t addr, ill_t *match_ill, zoneid_t zoneid,
4692 ip_stack_t *ipst)
4693 {
4694 return (ipif_lookup_addr_common(addr, match_ill,
4695 (IPIF_MATCH_ILLGRP | IPIF_MATCH_NONDUP),
4696 zoneid, ipst));
4697 }
4698
4699 /*
4700 * Special abbreviated version of ipif_lookup_addr() that doesn't match
4701 * `match_ill' across the IPMP group. This function is only needed in some
4702 * corner-cases; almost everything should use ipif_lookup_addr().
4703 */
4704 ipif_t *
4705 ipif_lookup_addr_exact(ipaddr_t addr, ill_t *match_ill, ip_stack_t *ipst)
4706 {
4707 ASSERT(match_ill != NULL);
4708 return (ipif_lookup_addr_common(addr, match_ill, 0, ALL_ZONES,
4709 ipst));
4710 }
4711
4712 /*
4713 * Look for an ipif with the specified address. For point-point links
4714 * we look for matches on either the destination address and the local
4715 * address, but we ignore the check on the local address if IPIF_UNNUMBERED
4716 * is set.
4717 * If the `match_ill' argument is non-NULL, the lookup is restricted to that
4718 * ill (or illgrp if `match_ill' is in an IPMP group).
4719 * Return the zoneid for the ipif which matches. ALL_ZONES if no match.
4720 */
4721 zoneid_t
4722 ipif_lookup_addr_zoneid(ipaddr_t addr, ill_t *match_ill, ip_stack_t *ipst)
4723 {
4724 zoneid_t zoneid;
4725 ipif_t *ipif;
4726 ill_t *ill;
4727 boolean_t ptp = B_FALSE;
4728 ill_walk_context_t ctx;
4729
4730 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4731 /*
4732 * Repeat twice, first based on local addresses and
4733 * next time for pointopoint.
4734 */
4735 repeat:
4736 ill = ILL_START_WALK_V4(&ctx, ipst);
4737 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4738 if (match_ill != NULL && ill != match_ill &&
4739 !IS_IN_SAME_ILLGRP(ill, match_ill)) {
4740 continue;
4741 }
4742 mutex_enter(&ill->ill_lock);
4743 for (ipif = ill->ill_ipif; ipif != NULL;
4744 ipif = ipif->ipif_next) {
4745 /* Allow the ipif to be down */
4746 if ((!ptp && (ipif->ipif_lcl_addr == addr) &&
4747 ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) ||
4748 (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) &&
4749 (ipif->ipif_pp_dst_addr == addr)) &&
4750 !(ipif->ipif_state_flags & IPIF_CONDEMNED)) {
4751 zoneid = ipif->ipif_zoneid;
4752 mutex_exit(&ill->ill_lock);
4753 rw_exit(&ipst->ips_ill_g_lock);
4754 /*
4755 * If ipif_zoneid was ALL_ZONES then we have
4756 * a trusted extensions shared IP address.
4757 * In that case GLOBAL_ZONEID works to send.
4758 */
4759 if (zoneid == ALL_ZONES)
4760 zoneid = GLOBAL_ZONEID;
4761 return (zoneid);
4762 }
4763 }
4764 mutex_exit(&ill->ill_lock);
4765 }
4766
4767 /* If we already did the ptp case, then we are done */
4768 if (ptp) {
4769 rw_exit(&ipst->ips_ill_g_lock);
4770 return (ALL_ZONES);
4771 }
4772 ptp = B_TRUE;
4773 goto repeat;
4774 }
4775
4776 /*
4777 * Look for an ipif that matches the specified remote address i.e. the
4778 * ipif that would receive the specified packet.
4779 * First look for directly connected interfaces and then do a recursive
4780 * IRE lookup and pick the first ipif corresponding to the source address in the
4781 * ire.
4782 * Returns: held ipif
4783 *
4784 * This is only used for ICMP_ADDRESS_MASK_REQUESTs
4785 */
4786 ipif_t *
4787 ipif_lookup_remote(ill_t *ill, ipaddr_t addr, zoneid_t zoneid)
4788 {
4789 ipif_t *ipif;
4790
4791 ASSERT(!ill->ill_isv6);
4792
4793 /*
4794 * Someone could be changing this ipif currently or change it
4795 * after we return this. Thus a few packets could use the old
4796 * old values. However structure updates/creates (ire, ilg, ilm etc)
4797 * will atomically be updated or cleaned up with the new value
4798 * Thus we don't need a lock to check the flags or other attrs below.
4799 */
4800 mutex_enter(&ill->ill_lock);
4801 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4802 if (IPIF_IS_CONDEMNED(ipif))
4803 continue;
4804 if (zoneid != ALL_ZONES && zoneid != ipif->ipif_zoneid &&
4805 ipif->ipif_zoneid != ALL_ZONES)
4806 continue;
4807 /* Allow the ipif to be down */
4808 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
4809 if ((ipif->ipif_pp_dst_addr == addr) ||
4810 (!(ipif->ipif_flags & IPIF_UNNUMBERED) &&
4811 ipif->ipif_lcl_addr == addr)) {
4812 ipif_refhold_locked(ipif);
4813 mutex_exit(&ill->ill_lock);
4814 return (ipif);
4815 }
4816 } else if (ipif->ipif_subnet == (addr & ipif->ipif_net_mask)) {
4817 ipif_refhold_locked(ipif);
4818 mutex_exit(&ill->ill_lock);
4819 return (ipif);
4820 }
4821 }
4822 mutex_exit(&ill->ill_lock);
4823 /*
4824 * For a remote destination it isn't possible to nail down a particular
4825 * ipif.
4826 */
4827
4828 /* Pick the first interface */
4829 ipif = ipif_get_next_ipif(NULL, ill);
4830 return (ipif);
4831 }
4832
4833 /*
4834 * This func does not prevent refcnt from increasing. But if
4835 * the caller has taken steps to that effect, then this func
4836 * can be used to determine whether the ill has become quiescent
4837 */
4838 static boolean_t
4839 ill_is_quiescent(ill_t *ill)
4840 {
4841 ipif_t *ipif;
4842
4843 ASSERT(MUTEX_HELD(&ill->ill_lock));
4844
4845 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4846 if (ipif->ipif_refcnt != 0)
4847 return (B_FALSE);
4848 }
4849 if (!ILL_DOWN_OK(ill) || ill->ill_refcnt != 0) {
4850 return (B_FALSE);
4851 }
4852 return (B_TRUE);
4853 }
4854
4855 boolean_t
4856 ill_is_freeable(ill_t *ill)
4857 {
4858 ipif_t *ipif;
4859
4860 ASSERT(MUTEX_HELD(&ill->ill_lock));
4861
4862 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4863 if (ipif->ipif_refcnt != 0) {
4864 return (B_FALSE);
4865 }
4866 }
4867 if (!ILL_FREE_OK(ill) || ill->ill_refcnt != 0) {
4868 return (B_FALSE);
4869 }
4870 return (B_TRUE);
4871 }
4872
4873 /*
4874 * This func does not prevent refcnt from increasing. But if
4875 * the caller has taken steps to that effect, then this func
4876 * can be used to determine whether the ipif has become quiescent
4877 */
4878 static boolean_t
4879 ipif_is_quiescent(ipif_t *ipif)
4880 {
4881 ill_t *ill;
4882
4883 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
4884
4885 if (ipif->ipif_refcnt != 0)
4886 return (B_FALSE);
4887
4888 ill = ipif->ipif_ill;
4889 if (ill->ill_ipif_up_count != 0 || ill->ill_ipif_dup_count != 0 ||
4890 ill->ill_logical_down) {
4891 return (B_TRUE);
4892 }
4893
4894 /* This is the last ipif going down or being deleted on this ill */
4895 if (ill->ill_ire_cnt != 0 || ill->ill_refcnt != 0) {
4896 return (B_FALSE);
4897 }
4898
4899 return (B_TRUE);
4900 }
4901
4902 /*
4903 * return true if the ipif can be destroyed: the ipif has to be quiescent
4904 * with zero references from ire/ilm to it.
4905 */
4906 static boolean_t
4907 ipif_is_freeable(ipif_t *ipif)
4908 {
4909 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
4910 ASSERT(ipif->ipif_id != 0);
4911 return (ipif->ipif_refcnt == 0);
4912 }
4913
4914 /*
4915 * The ipif/ill/ire has been refreled. Do the tail processing.
4916 * Determine if the ipif or ill in question has become quiescent and if so
4917 * wakeup close and/or restart any queued pending ioctl that is waiting
4918 * for the ipif_down (or ill_down)
4919 */
4920 void
4921 ipif_ill_refrele_tail(ill_t *ill)
4922 {
4923 mblk_t *mp;
4924 conn_t *connp;
4925 ipsq_t *ipsq;
4926 ipxop_t *ipx;
4927 ipif_t *ipif;
4928 dl_notify_ind_t *dlindp;
4929
4930 ASSERT(MUTEX_HELD(&ill->ill_lock));
4931
4932 if ((ill->ill_state_flags & ILL_CONDEMNED) && ill_is_freeable(ill)) {
4933 /* ip_modclose() may be waiting */
4934 cv_broadcast(&ill->ill_cv);
4935 }
4936
4937 ipsq = ill->ill_phyint->phyint_ipsq;
4938 mutex_enter(&ipsq->ipsq_lock);
4939 ipx = ipsq->ipsq_xop;
4940 mutex_enter(&ipx->ipx_lock);
4941 if (ipx->ipx_waitfor == 0) /* no one's waiting; bail */
4942 goto unlock;
4943
4944 ASSERT(ipx->ipx_pending_mp != NULL && ipx->ipx_pending_ipif != NULL);
4945
4946 ipif = ipx->ipx_pending_ipif;
4947 if (ipif->ipif_ill != ill) /* wait is for another ill; bail */
4948 goto unlock;
4949
4950 switch (ipx->ipx_waitfor) {
4951 case IPIF_DOWN:
4952 if (!ipif_is_quiescent(ipif))
4953 goto unlock;
4954 break;
4955 case IPIF_FREE:
4956 if (!ipif_is_freeable(ipif))
4957 goto unlock;
4958 break;
4959 case ILL_DOWN:
4960 if (!ill_is_quiescent(ill))
4961 goto unlock;
4962 break;
4963 case ILL_FREE:
4964 /*
4965 * ILL_FREE is only for loopback; normal ill teardown waits
4966 * synchronously in ip_modclose() without using ipx_waitfor,
4967 * handled by the cv_broadcast() at the top of this function.
4968 */
4969 if (!ill_is_freeable(ill))
4970 goto unlock;
4971 break;
4972 default:
4973 cmn_err(CE_PANIC, "ipsq: %p unknown ipx_waitfor %d\n",
4974 (void *)ipsq, ipx->ipx_waitfor);
4975 }
4976
4977 ill_refhold_locked(ill); /* for qwriter_ip() call below */
4978 mutex_exit(&ipx->ipx_lock);
4979 mp = ipsq_pending_mp_get(ipsq, &connp);
4980 mutex_exit(&ipsq->ipsq_lock);
4981 mutex_exit(&ill->ill_lock);
4982
4983 ASSERT(mp != NULL);
4984 /*
4985 * NOTE: all of the qwriter_ip() calls below use CUR_OP since
4986 * we can only get here when the current operation decides it
4987 * it needs to quiesce via ipsq_pending_mp_add().
4988 */
4989 switch (mp->b_datap->db_type) {
4990 case M_PCPROTO:
4991 case M_PROTO:
4992 /*
4993 * For now, only DL_NOTIFY_IND messages can use this facility.
4994 */
4995 dlindp = (dl_notify_ind_t *)mp->b_rptr;
4996 ASSERT(dlindp->dl_primitive == DL_NOTIFY_IND);
4997
4998 switch (dlindp->dl_notification) {
4999 case DL_NOTE_PHYS_ADDR:
5000 qwriter_ip(ill, ill->ill_rq, mp,
5001 ill_set_phys_addr_tail, CUR_OP, B_TRUE);
5002 return;
5003 case DL_NOTE_REPLUMB:
5004 qwriter_ip(ill, ill->ill_rq, mp,
5005 ill_replumb_tail, CUR_OP, B_TRUE);
5006 return;
5007 default:
5008 ASSERT(0);
5009 ill_refrele(ill);
5010 }
5011 break;
5012
5013 case M_ERROR:
5014 case M_HANGUP:
5015 qwriter_ip(ill, ill->ill_rq, mp, ipif_all_down_tail, CUR_OP,
5016 B_TRUE);
5017 return;
5018
5019 case M_IOCTL:
5020 case M_IOCDATA:
5021 qwriter_ip(ill, (connp != NULL ? CONNP_TO_WQ(connp) :
5022 ill->ill_wq), mp, ip_reprocess_ioctl, CUR_OP, B_TRUE);
5023 return;
5024
5025 default:
5026 cmn_err(CE_PANIC, "ipif_ill_refrele_tail mp %p "
5027 "db_type %d\n", (void *)mp, mp->b_datap->db_type);
5028 }
5029 return;
5030 unlock:
5031 mutex_exit(&ipsq->ipsq_lock);
5032 mutex_exit(&ipx->ipx_lock);
5033 mutex_exit(&ill->ill_lock);
5034 }
5035
5036 #ifdef DEBUG
5037 /* Reuse trace buffer from beginning (if reached the end) and record trace */
5038 static void
5039 th_trace_rrecord(th_trace_t *th_trace)
5040 {
5041 tr_buf_t *tr_buf;
5042 uint_t lastref;
5043
5044 lastref = th_trace->th_trace_lastref;
5045 lastref++;
5046 if (lastref == TR_BUF_MAX)
5047 lastref = 0;
5048 th_trace->th_trace_lastref = lastref;
5049 tr_buf = &th_trace->th_trbuf[lastref];
5050 tr_buf->tr_time = ddi_get_lbolt();
5051 tr_buf->tr_depth = getpcstack(tr_buf->tr_stack, TR_STACK_DEPTH);
5052 }
5053
5054 static void
5055 th_trace_free(void *value)
5056 {
5057 th_trace_t *th_trace = value;
5058
5059 ASSERT(th_trace->th_refcnt == 0);
5060 kmem_free(th_trace, sizeof (*th_trace));
5061 }
5062
5063 /*
5064 * Find or create the per-thread hash table used to track object references.
5065 * The ipst argument is NULL if we shouldn't allocate.
5066 *
5067 * Accesses per-thread data, so there's no need to lock here.
5068 */
5069 static mod_hash_t *
5070 th_trace_gethash(ip_stack_t *ipst)
5071 {
5072 th_hash_t *thh;
5073
5074 if ((thh = tsd_get(ip_thread_data)) == NULL && ipst != NULL) {
5075 mod_hash_t *mh;
5076 char name[256];
5077 size_t objsize, rshift;
5078 int retv;
5079
5080 if ((thh = kmem_alloc(sizeof (*thh), KM_NOSLEEP)) == NULL)
5081 return (NULL);
5082 (void) snprintf(name, sizeof (name), "th_trace_%p",
5083 (void *)curthread);
5084
5085 /*
5086 * We use mod_hash_create_extended here rather than the more
5087 * obvious mod_hash_create_ptrhash because the latter has a
5088 * hard-coded KM_SLEEP, and we'd prefer to fail rather than
5089 * block.
5090 */
5091 objsize = MAX(MAX(sizeof (ill_t), sizeof (ipif_t)),
5092 MAX(sizeof (ire_t), sizeof (ncec_t)));
5093 rshift = highbit(objsize);
5094 mh = mod_hash_create_extended(name, 64, mod_hash_null_keydtor,
5095 th_trace_free, mod_hash_byptr, (void *)rshift,
5096 mod_hash_ptrkey_cmp, KM_NOSLEEP);
5097 if (mh == NULL) {
5098 kmem_free(thh, sizeof (*thh));
5099 return (NULL);
5100 }
5101 thh->thh_hash = mh;
5102 thh->thh_ipst = ipst;
5103 /*
5104 * We trace ills, ipifs, ires, and nces. All of these are
5105 * per-IP-stack, so the lock on the thread list is as well.
5106 */
5107 rw_enter(&ip_thread_rwlock, RW_WRITER);
5108 list_insert_tail(&ip_thread_list, thh);
5109 rw_exit(&ip_thread_rwlock);
5110 retv = tsd_set(ip_thread_data, thh);
5111 ASSERT(retv == 0);
5112 }
5113 return (thh != NULL ? thh->thh_hash : NULL);
5114 }
5115
5116 boolean_t
5117 th_trace_ref(const void *obj, ip_stack_t *ipst)
5118 {
5119 th_trace_t *th_trace;
5120 mod_hash_t *mh;
5121 mod_hash_val_t val;
5122
5123 if ((mh = th_trace_gethash(ipst)) == NULL)
5124 return (B_FALSE);
5125
5126 /*
5127 * Attempt to locate the trace buffer for this obj and thread.
5128 * If it does not exist, then allocate a new trace buffer and
5129 * insert into the hash.
5130 */
5131 if (mod_hash_find(mh, (mod_hash_key_t)obj, &val) == MH_ERR_NOTFOUND) {
5132 th_trace = kmem_zalloc(sizeof (th_trace_t), KM_NOSLEEP);
5133 if (th_trace == NULL)
5134 return (B_FALSE);
5135
5136 th_trace->th_id = curthread;
5137 if (mod_hash_insert(mh, (mod_hash_key_t)obj,
5138 (mod_hash_val_t)th_trace) != 0) {
5139 kmem_free(th_trace, sizeof (th_trace_t));
5140 return (B_FALSE);
5141 }
5142 } else {
5143 th_trace = (th_trace_t *)val;
5144 }
5145
5146 ASSERT(th_trace->th_refcnt >= 0 &&
5147 th_trace->th_refcnt < TR_BUF_MAX - 1);
5148
5149 th_trace->th_refcnt++;
5150 th_trace_rrecord(th_trace);
5151 return (B_TRUE);
5152 }
5153
5154 /*
5155 * For the purpose of tracing a reference release, we assume that global
5156 * tracing is always on and that the same thread initiated the reference hold
5157 * is releasing.
5158 */
5159 void
5160 th_trace_unref(const void *obj)
5161 {
5162 int retv;
5163 mod_hash_t *mh;
5164 th_trace_t *th_trace;
5165 mod_hash_val_t val;
5166
5167 mh = th_trace_gethash(NULL);
5168 retv = mod_hash_find(mh, (mod_hash_key_t)obj, &val);
5169 ASSERT(retv == 0);
5170 th_trace = (th_trace_t *)val;
5171
5172 ASSERT(th_trace->th_refcnt > 0);
5173 th_trace->th_refcnt--;
5174 th_trace_rrecord(th_trace);
5175 }
5176
5177 /*
5178 * If tracing has been disabled, then we assume that the reference counts are
5179 * now useless, and we clear them out before destroying the entries.
5180 */
5181 void
5182 th_trace_cleanup(const void *obj, boolean_t trace_disable)
5183 {
5184 th_hash_t *thh;
5185 mod_hash_t *mh;
5186 mod_hash_val_t val;
5187 th_trace_t *th_trace;
5188 int retv;
5189
5190 rw_enter(&ip_thread_rwlock, RW_READER);
5191 for (thh = list_head(&ip_thread_list); thh != NULL;
5192 thh = list_next(&ip_thread_list, thh)) {
5193 if (mod_hash_find(mh = thh->thh_hash, (mod_hash_key_t)obj,
5194 &val) == 0) {
5195 th_trace = (th_trace_t *)val;
5196 if (trace_disable)
5197 th_trace->th_refcnt = 0;
5198 retv = mod_hash_destroy(mh, (mod_hash_key_t)obj);
5199 ASSERT(retv == 0);
5200 }
5201 }
5202 rw_exit(&ip_thread_rwlock);
5203 }
5204
5205 void
5206 ipif_trace_ref(ipif_t *ipif)
5207 {
5208 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5209
5210 if (ipif->ipif_trace_disable)
5211 return;
5212
5213 if (!th_trace_ref(ipif, ipif->ipif_ill->ill_ipst)) {
5214 ipif->ipif_trace_disable = B_TRUE;
5215 ipif_trace_cleanup(ipif);
5216 }
5217 }
5218
5219 void
5220 ipif_untrace_ref(ipif_t *ipif)
5221 {
5222 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5223
5224 if (!ipif->ipif_trace_disable)
5225 th_trace_unref(ipif);
5226 }
5227
5228 void
5229 ill_trace_ref(ill_t *ill)
5230 {
5231 ASSERT(MUTEX_HELD(&ill->ill_lock));
5232
5233 if (ill->ill_trace_disable)
5234 return;
5235
5236 if (!th_trace_ref(ill, ill->ill_ipst)) {
5237 ill->ill_trace_disable = B_TRUE;
5238 ill_trace_cleanup(ill);
5239 }
5240 }
5241
5242 void
5243 ill_untrace_ref(ill_t *ill)
5244 {
5245 ASSERT(MUTEX_HELD(&ill->ill_lock));
5246
5247 if (!ill->ill_trace_disable)
5248 th_trace_unref(ill);
5249 }
5250
5251 /*
5252 * Called when ipif is unplumbed or when memory alloc fails. Note that on
5253 * failure, ipif_trace_disable is set.
5254 */
5255 static void
5256 ipif_trace_cleanup(const ipif_t *ipif)
5257 {
5258 th_trace_cleanup(ipif, ipif->ipif_trace_disable);
5259 }
5260
5261 /*
5262 * Called when ill is unplumbed or when memory alloc fails. Note that on
5263 * failure, ill_trace_disable is set.
5264 */
5265 static void
5266 ill_trace_cleanup(const ill_t *ill)
5267 {
5268 th_trace_cleanup(ill, ill->ill_trace_disable);
5269 }
5270 #endif /* DEBUG */
5271
5272 void
5273 ipif_refhold_locked(ipif_t *ipif)
5274 {
5275 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5276 ipif->ipif_refcnt++;
5277 IPIF_TRACE_REF(ipif);
5278 }
5279
5280 void
5281 ipif_refhold(ipif_t *ipif)
5282 {
5283 ill_t *ill;
5284
5285 ill = ipif->ipif_ill;
5286 mutex_enter(&ill->ill_lock);
5287 ipif->ipif_refcnt++;
5288 IPIF_TRACE_REF(ipif);
5289 mutex_exit(&ill->ill_lock);
5290 }
5291
5292 /*
5293 * Must not be called while holding any locks. Otherwise if this is
5294 * the last reference to be released there is a chance of recursive mutex
5295 * panic due to ipif_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
5296 * to restart an ioctl.
5297 */
5298 void
5299 ipif_refrele(ipif_t *ipif)
5300 {
5301 ill_t *ill;
5302
5303 ill = ipif->ipif_ill;
5304
5305 mutex_enter(&ill->ill_lock);
5306 ASSERT(ipif->ipif_refcnt != 0);
5307 ipif->ipif_refcnt--;
5308 IPIF_UNTRACE_REF(ipif);
5309 if (ipif->ipif_refcnt != 0) {
5310 mutex_exit(&ill->ill_lock);
5311 return;
5312 }
5313
5314 /* Drops the ill_lock */
5315 ipif_ill_refrele_tail(ill);
5316 }
5317
5318 ipif_t *
5319 ipif_get_next_ipif(ipif_t *curr, ill_t *ill)
5320 {
5321 ipif_t *ipif;
5322
5323 mutex_enter(&ill->ill_lock);
5324 for (ipif = (curr == NULL ? ill->ill_ipif : curr->ipif_next);
5325 ipif != NULL; ipif = ipif->ipif_next) {
5326 if (IPIF_IS_CONDEMNED(ipif))
5327 continue;
5328 ipif_refhold_locked(ipif);
5329 mutex_exit(&ill->ill_lock);
5330 return (ipif);
5331 }
5332 mutex_exit(&ill->ill_lock);
5333 return (NULL);
5334 }
5335
5336 /*
5337 * TODO: make this table extendible at run time
5338 * Return a pointer to the mac type info for 'mac_type'
5339 */
5340 static ip_m_t *
5341 ip_m_lookup(t_uscalar_t mac_type)
5342 {
5343 ip_m_t *ipm;
5344
5345 for (ipm = ip_m_tbl; ipm < A_END(ip_m_tbl); ipm++)
5346 if (ipm->ip_m_mac_type == mac_type)
5347 return (ipm);
5348 return (NULL);
5349 }
5350
5351 /*
5352 * Make a link layer address from the multicast IP address *addr.
5353 * To form the link layer address, invoke the ip_m_v*mapping function
5354 * associated with the link-layer type.
5355 */
5356 void
5357 ip_mcast_mapping(ill_t *ill, uchar_t *addr, uchar_t *hwaddr)
5358 {
5359 ip_m_t *ipm;
5360
5361 if (ill->ill_net_type == IRE_IF_NORESOLVER)
5362 return;
5363
5364 ASSERT(addr != NULL);
5365
5366 ipm = ip_m_lookup(ill->ill_mactype);
5367 if (ipm == NULL ||
5368 (ill->ill_isv6 && ipm->ip_m_v6mapping == NULL) ||
5369 (!ill->ill_isv6 && ipm->ip_m_v4mapping == NULL)) {
5370 ip0dbg(("no mapping for ill %s mactype 0x%x\n",
5371 ill->ill_name, ill->ill_mactype));
5372 return;
5373 }
5374 if (ill->ill_isv6)
5375 (*ipm->ip_m_v6mapping)(ill, addr, hwaddr);
5376 else
5377 (*ipm->ip_m_v4mapping)(ill, addr, hwaddr);
5378 }
5379
5380 /*
5381 * Returns B_FALSE if the IPv4 netmask pointed by `mask' is non-contiguous.
5382 * Otherwise returns B_TRUE.
5383 *
5384 * The netmask can be verified to be contiguous with 32 shifts and or
5385 * operations. Take the contiguous mask (in host byte order) and compute
5386 * mask | mask << 1 | mask << 2 | ... | mask << 31
5387 * the result will be the same as the 'mask' for contiguous mask.
5388 */
5389 static boolean_t
5390 ip_contiguous_mask(uint32_t mask)
5391 {
5392 uint32_t m = mask;
5393 int i;
5394
5395 for (i = 1; i < 32; i++)
5396 m |= (mask << i);
5397
5398 return (m == mask);
5399 }
5400
5401 /*
5402 * ip_rt_add is called to add an IPv4 route to the forwarding table.
5403 * ill is passed in to associate it with the correct interface.
5404 * If ire_arg is set, then we return the held IRE in that location.
5405 */
5406 int
5407 ip_rt_add(ipaddr_t dst_addr, ipaddr_t mask, ipaddr_t gw_addr,
5408 ipaddr_t src_addr, int flags, ill_t *ill, ire_t **ire_arg,
5409 boolean_t ioctl_msg, struct rtsa_s *sp, ip_stack_t *ipst, zoneid_t zoneid)
5410 {
5411 ire_t *ire, *nire;
5412 ire_t *gw_ire = NULL;
5413 ipif_t *ipif = NULL;
5414 uint_t type;
5415 int match_flags = MATCH_IRE_TYPE;
5416 tsol_gc_t *gc = NULL;
5417 tsol_gcgrp_t *gcgrp = NULL;
5418 boolean_t gcgrp_xtraref = B_FALSE;
5419 boolean_t cgtp_broadcast;
5420 boolean_t unbound = B_FALSE;
5421
5422 ip1dbg(("ip_rt_add:"));
5423
5424 if (ire_arg != NULL)
5425 *ire_arg = NULL;
5426
5427 /* disallow non-contiguous netmasks */
5428 if (!ip_contiguous_mask(ntohl(mask)))
5429 return (ENOTSUP);
5430
5431 /*
5432 * If this is the case of RTF_HOST being set, then we set the netmask
5433 * to all ones (regardless if one was supplied).
5434 */
5435 if (flags & RTF_HOST)
5436 mask = IP_HOST_MASK;
5437
5438 /*
5439 * Prevent routes with a zero gateway from being created (since
5440 * interfaces can currently be plumbed and brought up no assigned
5441 * address).
5442 */
5443 if (gw_addr == 0)
5444 return (ENETUNREACH);
5445 /*
5446 * Get the ipif, if any, corresponding to the gw_addr
5447 * If -ifp was specified we restrict ourselves to the ill, otherwise
5448 * we match on the gatway and destination to handle unnumbered pt-pt
5449 * interfaces.
5450 */
5451 if (ill != NULL)
5452 ipif = ipif_lookup_addr(gw_addr, ill, ALL_ZONES, ipst);
5453 else
5454 ipif = ipif_lookup_interface(gw_addr, dst_addr, ipst);
5455 if (ipif != NULL) {
5456 if (IS_VNI(ipif->ipif_ill)) {
5457 ipif_refrele(ipif);
5458 return (EINVAL);
5459 }
5460 }
5461
5462 /*
5463 * GateD will attempt to create routes with a loopback interface
5464 * address as the gateway and with RTF_GATEWAY set. We allow
5465 * these routes to be added, but create them as interface routes
5466 * since the gateway is an interface address.
5467 */
5468 if ((ipif != NULL) && (ipif->ipif_ire_type == IRE_LOOPBACK)) {
5469 flags &= ~RTF_GATEWAY;
5470 if (gw_addr == INADDR_LOOPBACK && dst_addr == INADDR_LOOPBACK &&
5471 mask == IP_HOST_MASK) {
5472 ire = ire_ftable_lookup_v4(dst_addr, 0, 0, IRE_LOOPBACK,
5473 NULL, ALL_ZONES, NULL, MATCH_IRE_TYPE, 0, ipst,
5474 NULL);
5475 if (ire != NULL) {
5476 ire_refrele(ire);
5477 ipif_refrele(ipif);
5478 return (EEXIST);
5479 }
5480 ip1dbg(("ip_rt_add: 0x%p creating IRE 0x%x"
5481 "for 0x%x\n", (void *)ipif,
5482 ipif->ipif_ire_type,
5483 ntohl(ipif->ipif_lcl_addr)));
5484 ire = ire_create(
5485 (uchar_t *)&dst_addr, /* dest address */
5486 (uchar_t *)&mask, /* mask */
5487 NULL, /* no gateway */
5488 ipif->ipif_ire_type, /* LOOPBACK */
5489 ipif->ipif_ill,
5490 zoneid,
5491 (ipif->ipif_flags & IPIF_PRIVATE) ? RTF_PRIVATE : 0,
5492 NULL,
5493 ipst);
5494
5495 if (ire == NULL) {
5496 ipif_refrele(ipif);
5497 return (ENOMEM);
5498 }
5499 /* src address assigned by the caller? */
5500 if ((src_addr != INADDR_ANY) && (flags & RTF_SETSRC))
5501 ire->ire_setsrc_addr = src_addr;
5502
5503 nire = ire_add(ire);
5504 if (nire == NULL) {
5505 /*
5506 * In the result of failure, ire_add() will have
5507 * already deleted the ire in question, so there
5508 * is no need to do that here.
5509 */
5510 ipif_refrele(ipif);
5511 return (ENOMEM);
5512 }
5513 /*
5514 * Check if it was a duplicate entry. This handles
5515 * the case of two racing route adds for the same route
5516 */
5517 if (nire != ire) {
5518 ASSERT(nire->ire_identical_ref > 1);
5519 ire_delete(nire);
5520 ire_refrele(nire);
5521 ipif_refrele(ipif);
5522 return (EEXIST);
5523 }
5524 ire = nire;
5525 goto save_ire;
5526 }
5527 }
5528
5529 /*
5530 * The routes for multicast with CGTP are quite special in that
5531 * the gateway is the local interface address, yet RTF_GATEWAY
5532 * is set. We turn off RTF_GATEWAY to provide compatibility with
5533 * this undocumented and unusual use of multicast routes.
5534 */
5535 if ((flags & RTF_MULTIRT) && ipif != NULL)
5536 flags &= ~RTF_GATEWAY;
5537
5538 /*
5539 * Traditionally, interface routes are ones where RTF_GATEWAY isn't set
5540 * and the gateway address provided is one of the system's interface
5541 * addresses. By using the routing socket interface and supplying an
5542 * RTA_IFP sockaddr with an interface index, an alternate method of
5543 * specifying an interface route to be created is available which uses
5544 * the interface index that specifies the outgoing interface rather than
5545 * the address of an outgoing interface (which may not be able to
5546 * uniquely identify an interface). When coupled with the RTF_GATEWAY
5547 * flag, routes can be specified which not only specify the next-hop to
5548 * be used when routing to a certain prefix, but also which outgoing
5549 * interface should be used.
5550 *
5551 * Previously, interfaces would have unique addresses assigned to them
5552 * and so the address assigned to a particular interface could be used
5553 * to identify a particular interface. One exception to this was the
5554 * case of an unnumbered interface (where IPIF_UNNUMBERED was set).
5555 *
5556 * With the advent of IPv6 and its link-local addresses, this
5557 * restriction was relaxed and interfaces could share addresses between
5558 * themselves. In fact, typically all of the link-local interfaces on
5559 * an IPv6 node or router will have the same link-local address. In
5560 * order to differentiate between these interfaces, the use of an
5561 * interface index is necessary and this index can be carried inside a
5562 * RTA_IFP sockaddr (which is actually a sockaddr_dl). One restriction
5563 * of using the interface index, however, is that all of the ipif's that
5564 * are part of an ill have the same index and so the RTA_IFP sockaddr
5565 * cannot be used to differentiate between ipif's (or logical
5566 * interfaces) that belong to the same ill (physical interface).
5567 *
5568 * For example, in the following case involving IPv4 interfaces and
5569 * logical interfaces
5570 *
5571 * 192.0.2.32 255.255.255.224 192.0.2.33 U if0
5572 * 192.0.2.32 255.255.255.224 192.0.2.34 U if0
5573 * 192.0.2.32 255.255.255.224 192.0.2.35 U if0
5574 *
5575 * the ipif's corresponding to each of these interface routes can be
5576 * uniquely identified by the "gateway" (actually interface address).
5577 *
5578 * In this case involving multiple IPv6 default routes to a particular
5579 * link-local gateway, the use of RTA_IFP is necessary to specify which
5580 * default route is of interest:
5581 *
5582 * default fe80::123:4567:89ab:cdef U if0
5583 * default fe80::123:4567:89ab:cdef U if1
5584 */
5585
5586 /* RTF_GATEWAY not set */
5587 if (!(flags & RTF_GATEWAY)) {
5588 if (sp != NULL) {
5589 ip2dbg(("ip_rt_add: gateway security attributes "
5590 "cannot be set with interface route\n"));
5591 if (ipif != NULL)
5592 ipif_refrele(ipif);
5593 return (EINVAL);
5594 }
5595
5596 /*
5597 * Whether or not ill (RTA_IFP) is set, we require that
5598 * the gateway is one of our local addresses.
5599 */
5600 if (ipif == NULL)
5601 return (ENETUNREACH);
5602
5603 /*
5604 * We use MATCH_IRE_ILL here. If the caller specified an
5605 * interface (from the RTA_IFP sockaddr) we use it, otherwise
5606 * we use the ill derived from the gateway address.
5607 * We can always match the gateway address since we record it
5608 * in ire_gateway_addr.
5609 * We don't allow RTA_IFP to specify a different ill than the
5610 * one matching the ipif to make sure we can delete the route.
5611 */
5612 match_flags |= MATCH_IRE_GW | MATCH_IRE_ILL;
5613 if (ill == NULL) {
5614 ill = ipif->ipif_ill;
5615 } else if (ill != ipif->ipif_ill) {
5616 ipif_refrele(ipif);
5617 return (EINVAL);
5618 }
5619
5620 /*
5621 * We check for an existing entry at this point.
5622 *
5623 * Since a netmask isn't passed in via the ioctl interface
5624 * (SIOCADDRT), we don't check for a matching netmask in that
5625 * case.
5626 */
5627 if (!ioctl_msg)
5628 match_flags |= MATCH_IRE_MASK;
5629 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr,
5630 IRE_INTERFACE, ill, ALL_ZONES, NULL, match_flags, 0, ipst,
5631 NULL);
5632 if (ire != NULL) {
5633 ire_refrele(ire);
5634 ipif_refrele(ipif);
5635 return (EEXIST);
5636 }
5637
5638 /*
5639 * Some software (for example, GateD and Sun Cluster) attempts
5640 * to create (what amount to) IRE_PREFIX routes with the
5641 * loopback address as the gateway. This is primarily done to
5642 * set up prefixes with the RTF_REJECT flag set (for example,
5643 * when generating aggregate routes.)
5644 *
5645 * If the IRE type (as defined by ill->ill_net_type) would be
5646 * IRE_LOOPBACK, then we map the request into a
5647 * IRE_IF_NORESOLVER. We also OR in the RTF_BLACKHOLE flag as
5648 * these interface routes, by definition, can only be that.
5649 *
5650 * Needless to say, the real IRE_LOOPBACK is NOT created by this
5651 * routine, but rather using ire_create() directly.
5652 *
5653 */
5654 type = ill->ill_net_type;
5655 if (type == IRE_LOOPBACK) {
5656 type = IRE_IF_NORESOLVER;
5657 flags |= RTF_BLACKHOLE;
5658 }
5659
5660 /*
5661 * Create a copy of the IRE_IF_NORESOLVER or
5662 * IRE_IF_RESOLVER with the modified address, netmask, and
5663 * gateway.
5664 */
5665 ire = ire_create(
5666 (uchar_t *)&dst_addr,
5667 (uint8_t *)&mask,
5668 (uint8_t *)&gw_addr,
5669 type,
5670 ill,
5671 zoneid,
5672 flags,
5673 NULL,
5674 ipst);
5675 if (ire == NULL) {
5676 ipif_refrele(ipif);
5677 return (ENOMEM);
5678 }
5679
5680 /* src address assigned by the caller? */
5681 if ((src_addr != INADDR_ANY) && (flags & RTF_SETSRC))
5682 ire->ire_setsrc_addr = src_addr;
5683
5684 nire = ire_add(ire);
5685 if (nire == NULL) {
5686 /*
5687 * In the result of failure, ire_add() will have
5688 * already deleted the ire in question, so there
5689 * is no need to do that here.
5690 */
5691 ipif_refrele(ipif);
5692 return (ENOMEM);
5693 }
5694 /*
5695 * Check if it was a duplicate entry. This handles
5696 * the case of two racing route adds for the same route
5697 */
5698 if (nire != ire) {
5699 ire_delete(nire);
5700 ire_refrele(nire);
5701 ipif_refrele(ipif);
5702 return (EEXIST);
5703 }
5704 ire = nire;
5705 goto save_ire;
5706 }
5707
5708 /*
5709 * Get an interface IRE for the specified gateway.
5710 * If we don't have an IRE_IF_NORESOLVER or IRE_IF_RESOLVER for the
5711 * gateway, it is currently unreachable and we fail the request
5712 * accordingly. We reject any RTF_GATEWAY routes where the gateway
5713 * is an IRE_LOCAL or IRE_LOOPBACK.
5714 * If RTA_IFP was specified we look on that particular ill.
5715 */
5716 if (ill != NULL)
5717 match_flags |= MATCH_IRE_ILL;
5718
5719 /* Check whether the gateway is reachable. */
5720 again:
5721 type = IRE_INTERFACE | IRE_LOCAL | IRE_LOOPBACK;
5722 if (flags & RTF_INDIRECT)
5723 type |= IRE_OFFLINK;
5724
5725 gw_ire = ire_ftable_lookup_v4(gw_addr, 0, 0, type, ill,
5726 ALL_ZONES, NULL, match_flags, 0, ipst, NULL);
5727 if (gw_ire == NULL) {
5728 /*
5729 * With IPMP, we allow host routes to influence in.mpathd's
5730 * target selection. However, if the test addresses are on
5731 * their own network, the above lookup will fail since the
5732 * underlying IRE_INTERFACEs are marked hidden. So allow
5733 * hidden test IREs to be found and try again.
5734 */
5735 if (!(match_flags & MATCH_IRE_TESTHIDDEN)) {
5736 match_flags |= MATCH_IRE_TESTHIDDEN;
5737 goto again;
5738 }
5739 if (ipif != NULL)
5740 ipif_refrele(ipif);
5741 return (ENETUNREACH);
5742 }
5743 if (gw_ire->ire_type & (IRE_LOCAL|IRE_LOOPBACK)) {
5744 ire_refrele(gw_ire);
5745 if (ipif != NULL)
5746 ipif_refrele(ipif);
5747 return (ENETUNREACH);
5748 }
5749
5750 if (ill == NULL && !(flags & RTF_INDIRECT)) {
5751 unbound = B_TRUE;
5752 if (ipst->ips_ip_strict_src_multihoming > 0)
5753 ill = gw_ire->ire_ill;
5754 }
5755
5756 /*
5757 * We create one of three types of IREs as a result of this request
5758 * based on the netmask. A netmask of all ones (which is automatically
5759 * assumed when RTF_HOST is set) results in an IRE_HOST being created.
5760 * An all zeroes netmask implies a default route so an IRE_DEFAULT is
5761 * created. Otherwise, an IRE_PREFIX route is created for the
5762 * destination prefix.
5763 */
5764 if (mask == IP_HOST_MASK)
5765 type = IRE_HOST;
5766 else if (mask == 0)
5767 type = IRE_DEFAULT;
5768 else
5769 type = IRE_PREFIX;
5770
5771 /* check for a duplicate entry */
5772 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr, type, ill,
5773 ALL_ZONES, NULL, match_flags | MATCH_IRE_MASK | MATCH_IRE_GW,
5774 0, ipst, NULL);
5775 if (ire != NULL) {
5776 if (ipif != NULL)
5777 ipif_refrele(ipif);
5778 ire_refrele(gw_ire);
5779 ire_refrele(ire);
5780 return (EEXIST);
5781 }
5782
5783 /* Security attribute exists */
5784 if (sp != NULL) {
5785 tsol_gcgrp_addr_t ga;
5786
5787 /* find or create the gateway credentials group */
5788 ga.ga_af = AF_INET;
5789 IN6_IPADDR_TO_V4MAPPED(gw_addr, &ga.ga_addr);
5790
5791 /* we hold reference to it upon success */
5792 gcgrp = gcgrp_lookup(&ga, B_TRUE);
5793 if (gcgrp == NULL) {
5794 if (ipif != NULL)
5795 ipif_refrele(ipif);
5796 ire_refrele(gw_ire);
5797 return (ENOMEM);
5798 }
5799
5800 /*
5801 * Create and add the security attribute to the group; a
5802 * reference to the group is made upon allocating a new
5803 * entry successfully. If it finds an already-existing
5804 * entry for the security attribute in the group, it simply
5805 * returns it and no new reference is made to the group.
5806 */
5807 gc = gc_create(sp, gcgrp, &gcgrp_xtraref);
5808 if (gc == NULL) {
5809 if (ipif != NULL)
5810 ipif_refrele(ipif);
5811 /* release reference held by gcgrp_lookup */
5812 GCGRP_REFRELE(gcgrp);
5813 ire_refrele(gw_ire);
5814 return (ENOMEM);
5815 }
5816 }
5817
5818 /* Create the IRE. */
5819 ire = ire_create(
5820 (uchar_t *)&dst_addr, /* dest address */
5821 (uchar_t *)&mask, /* mask */
5822 (uchar_t *)&gw_addr, /* gateway address */
5823 (ushort_t)type, /* IRE type */
5824 ill,
5825 zoneid,
5826 flags,
5827 gc, /* security attribute */
5828 ipst);
5829
5830 /*
5831 * The ire holds a reference to the 'gc' and the 'gc' holds a
5832 * reference to the 'gcgrp'. We can now release the extra reference
5833 * the 'gcgrp' acquired in the gcgrp_lookup, if it was not used.
5834 */
5835 if (gcgrp_xtraref)
5836 GCGRP_REFRELE(gcgrp);
5837 if (ire == NULL) {
5838 if (gc != NULL)
5839 GC_REFRELE(gc);
5840 if (ipif != NULL)
5841 ipif_refrele(ipif);
5842 ire_refrele(gw_ire);
5843 return (ENOMEM);
5844 }
5845
5846 /* Before we add, check if an extra CGTP broadcast is needed */
5847 cgtp_broadcast = ((flags & RTF_MULTIRT) &&
5848 ip_type_v4(ire->ire_addr, ipst) == IRE_BROADCAST);
5849
5850 /* src address assigned by the caller? */
5851 if ((src_addr != INADDR_ANY) && (flags & RTF_SETSRC))
5852 ire->ire_setsrc_addr = src_addr;
5853
5854 ire->ire_unbound = unbound;
5855
5856 /*
5857 * POLICY: should we allow an RTF_HOST with address INADDR_ANY?
5858 * SUN/OS socket stuff does but do we really want to allow 0.0.0.0?
5859 */
5860
5861 /* Add the new IRE. */
5862 nire = ire_add(ire);
5863 if (nire == NULL) {
5864 /*
5865 * In the result of failure, ire_add() will have
5866 * already deleted the ire in question, so there
5867 * is no need to do that here.
5868 */
5869 if (ipif != NULL)
5870 ipif_refrele(ipif);
5871 ire_refrele(gw_ire);
5872 return (ENOMEM);
5873 }
5874 /*
5875 * Check if it was a duplicate entry. This handles
5876 * the case of two racing route adds for the same route
5877 */
5878 if (nire != ire) {
5879 ire_delete(nire);
5880 ire_refrele(nire);
5881 if (ipif != NULL)
5882 ipif_refrele(ipif);
5883 ire_refrele(gw_ire);
5884 return (EEXIST);
5885 }
5886 ire = nire;
5887
5888 if (flags & RTF_MULTIRT) {
5889 /*
5890 * Invoke the CGTP (multirouting) filtering module
5891 * to add the dst address in the filtering database.
5892 * Replicated inbound packets coming from that address
5893 * will be filtered to discard the duplicates.
5894 * It is not necessary to call the CGTP filter hook
5895 * when the dst address is a broadcast or multicast,
5896 * because an IP source address cannot be a broadcast
5897 * or a multicast.
5898 */
5899 if (cgtp_broadcast) {
5900 ip_cgtp_bcast_add(ire, ipst);
5901 goto save_ire;
5902 }
5903 if (ipst->ips_ip_cgtp_filter_ops != NULL &&
5904 !CLASSD(ire->ire_addr)) {
5905 int res;
5906 ipif_t *src_ipif;
5907
5908 /* Find the source address corresponding to gw_ire */
5909 src_ipif = ipif_lookup_addr(gw_ire->ire_gateway_addr,
5910 NULL, zoneid, ipst);
5911 if (src_ipif != NULL) {
5912 res = ipst->ips_ip_cgtp_filter_ops->
5913 cfo_add_dest_v4(
5914 ipst->ips_netstack->netstack_stackid,
5915 ire->ire_addr,
5916 ire->ire_gateway_addr,
5917 ire->ire_setsrc_addr,
5918 src_ipif->ipif_lcl_addr);
5919 ipif_refrele(src_ipif);
5920 } else {
5921 res = EADDRNOTAVAIL;
5922 }
5923 if (res != 0) {
5924 if (ipif != NULL)
5925 ipif_refrele(ipif);
5926 ire_refrele(gw_ire);
5927 ire_delete(ire);
5928 ire_refrele(ire); /* Held in ire_add */
5929 return (res);
5930 }
5931 }
5932 }
5933
5934 save_ire:
5935 if (gw_ire != NULL) {
5936 ire_refrele(gw_ire);
5937 gw_ire = NULL;
5938 }
5939 if (ill != NULL) {
5940 /*
5941 * Save enough information so that we can recreate the IRE if
5942 * the interface goes down and then up. The metrics associated
5943 * with the route will be saved as well when rts_setmetrics() is
5944 * called after the IRE has been created. In the case where
5945 * memory cannot be allocated, none of this information will be
5946 * saved.
5947 */
5948 ill_save_ire(ill, ire);
5949 }
5950 if (ioctl_msg)
5951 ip_rts_rtmsg(RTM_OLDADD, ire, 0, ipst);
5952 if (ire_arg != NULL) {
5953 /*
5954 * Store the ire that was successfully added into where ire_arg
5955 * points to so that callers don't have to look it up
5956 * themselves (but they are responsible for ire_refrele()ing
5957 * the ire when they are finished with it).
5958 */
5959 *ire_arg = ire;
5960 } else {
5961 ire_refrele(ire); /* Held in ire_add */
5962 }
5963 if (ipif != NULL)
5964 ipif_refrele(ipif);
5965 return (0);
5966 }
5967
5968 /*
5969 * ip_rt_delete is called to delete an IPv4 route.
5970 * ill is passed in to associate it with the correct interface.
5971 */
5972 /* ARGSUSED4 */
5973 int
5974 ip_rt_delete(ipaddr_t dst_addr, ipaddr_t mask, ipaddr_t gw_addr,
5975 uint_t rtm_addrs, int flags, ill_t *ill, boolean_t ioctl_msg,
5976 ip_stack_t *ipst, zoneid_t zoneid)
5977 {
5978 ire_t *ire = NULL;
5979 ipif_t *ipif;
5980 uint_t type;
5981 uint_t match_flags = MATCH_IRE_TYPE;
5982 int err = 0;
5983
5984 ip1dbg(("ip_rt_delete:"));
5985 /*
5986 * If this is the case of RTF_HOST being set, then we set the netmask
5987 * to all ones. Otherwise, we use the netmask if one was supplied.
5988 */
5989 if (flags & RTF_HOST) {
5990 mask = IP_HOST_MASK;
5991 match_flags |= MATCH_IRE_MASK;
5992 } else if (rtm_addrs & RTA_NETMASK) {
5993 match_flags |= MATCH_IRE_MASK;
5994 }
5995
5996 /*
5997 * Note that RTF_GATEWAY is never set on a delete, therefore
5998 * we check if the gateway address is one of our interfaces first,
5999 * and fall back on RTF_GATEWAY routes.
6000 *
6001 * This makes it possible to delete an original
6002 * IRE_IF_NORESOLVER/IRE_IF_RESOLVER - consistent with SunOS 4.1.
6003 * However, we have RTF_KERNEL set on the ones created by ipif_up
6004 * and those can not be deleted here.
6005 *
6006 * We use MATCH_IRE_ILL if we know the interface. If the caller
6007 * specified an interface (from the RTA_IFP sockaddr) we use it,
6008 * otherwise we use the ill derived from the gateway address.
6009 * We can always match the gateway address since we record it
6010 * in ire_gateway_addr.
6011 *
6012 * For more detail on specifying routes by gateway address and by
6013 * interface index, see the comments in ip_rt_add().
6014 */
6015 ipif = ipif_lookup_interface(gw_addr, dst_addr, ipst);
6016 if (ipif != NULL) {
6017 ill_t *ill_match;
6018
6019 if (ill != NULL)
6020 ill_match = ill;
6021 else
6022 ill_match = ipif->ipif_ill;
6023
6024 match_flags |= MATCH_IRE_ILL;
6025 if (ipif->ipif_ire_type == IRE_LOOPBACK) {
6026 ire = ire_ftable_lookup_v4(dst_addr, mask, 0,
6027 IRE_LOOPBACK, ill_match, ALL_ZONES, NULL,
6028 match_flags, 0, ipst, NULL);
6029 }
6030 if (ire == NULL) {
6031 match_flags |= MATCH_IRE_GW;
6032 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr,
6033 IRE_INTERFACE, ill_match, ALL_ZONES, NULL,
6034 match_flags, 0, ipst, NULL);
6035 }
6036 /* Avoid deleting routes created by kernel from an ipif */
6037 if (ire != NULL && (ire->ire_flags & RTF_KERNEL)) {
6038 ire_refrele(ire);
6039 ire = NULL;
6040 }
6041
6042 /* Restore in case we didn't find a match */
6043 match_flags &= ~(MATCH_IRE_GW|MATCH_IRE_ILL);
6044 }
6045
6046 if (ire == NULL) {
6047 /*
6048 * At this point, the gateway address is not one of our own
6049 * addresses or a matching interface route was not found. We
6050 * set the IRE type to lookup based on whether
6051 * this is a host route, a default route or just a prefix.
6052 *
6053 * If an ill was passed in, then the lookup is based on an
6054 * interface index so MATCH_IRE_ILL is added to match_flags.
6055 */
6056 match_flags |= MATCH_IRE_GW;
6057 if (ill != NULL)
6058 match_flags |= MATCH_IRE_ILL;
6059 if (mask == IP_HOST_MASK)
6060 type = IRE_HOST;
6061 else if (mask == 0)
6062 type = IRE_DEFAULT;
6063 else
6064 type = IRE_PREFIX;
6065 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr, type, ill,
6066 ALL_ZONES, NULL, match_flags, 0, ipst, NULL);
6067 }
6068
6069 if (ipif != NULL) {
6070 ipif_refrele(ipif);
6071 ipif = NULL;
6072 }
6073
6074 if (ire == NULL)
6075 return (ESRCH);
6076
6077 if (ire->ire_flags & RTF_MULTIRT) {
6078 /*
6079 * Invoke the CGTP (multirouting) filtering module
6080 * to remove the dst address from the filtering database.
6081 * Packets coming from that address will no longer be
6082 * filtered to remove duplicates.
6083 */
6084 if (ipst->ips_ip_cgtp_filter_ops != NULL) {
6085 err = ipst->ips_ip_cgtp_filter_ops->cfo_del_dest_v4(
6086 ipst->ips_netstack->netstack_stackid,
6087 ire->ire_addr, ire->ire_gateway_addr);
6088 }
6089 ip_cgtp_bcast_delete(ire, ipst);
6090 }
6091
6092 ill = ire->ire_ill;
6093 if (ill != NULL)
6094 ill_remove_saved_ire(ill, ire);
6095 if (ioctl_msg)
6096 ip_rts_rtmsg(RTM_OLDDEL, ire, 0, ipst);
6097 ire_delete(ire);
6098 ire_refrele(ire);
6099 return (err);
6100 }
6101
6102 /*
6103 * ip_siocaddrt is called to complete processing of an SIOCADDRT IOCTL.
6104 */
6105 /* ARGSUSED */
6106 int
6107 ip_siocaddrt(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
6108 ip_ioctl_cmd_t *ipip, void *dummy_if_req)
6109 {
6110 ipaddr_t dst_addr;
6111 ipaddr_t gw_addr;
6112 ipaddr_t mask;
6113 int error = 0;
6114 mblk_t *mp1;
6115 struct rtentry *rt;
6116 ipif_t *ipif = NULL;
6117 ip_stack_t *ipst;
6118
6119 ASSERT(q->q_next == NULL);
6120 ipst = CONNQ_TO_IPST(q);
6121
6122 ip1dbg(("ip_siocaddrt:"));
6123 /* Existence of mp1 verified in ip_wput_nondata */
6124 mp1 = mp->b_cont->b_cont;
6125 rt = (struct rtentry *)mp1->b_rptr;
6126
6127 dst_addr = ((sin_t *)&rt->rt_dst)->sin_addr.s_addr;
6128 gw_addr = ((sin_t *)&rt->rt_gateway)->sin_addr.s_addr;
6129
6130 /*
6131 * If the RTF_HOST flag is on, this is a request to assign a gateway
6132 * to a particular host address. In this case, we set the netmask to
6133 * all ones for the particular destination address. Otherwise,
6134 * determine the netmask to be used based on dst_addr and the interfaces
6135 * in use.
6136 */
6137 if (rt->rt_flags & RTF_HOST) {
6138 mask = IP_HOST_MASK;
6139 } else {
6140 /*
6141 * Note that ip_subnet_mask returns a zero mask in the case of
6142 * default (an all-zeroes address).
6143 */
6144 mask = ip_subnet_mask(dst_addr, &ipif, ipst);
6145 }
6146
6147 error = ip_rt_add(dst_addr, mask, gw_addr, 0, rt->rt_flags, NULL, NULL,
6148 B_TRUE, NULL, ipst, ALL_ZONES);
6149 if (ipif != NULL)
6150 ipif_refrele(ipif);
6151 return (error);
6152 }
6153
6154 /*
6155 * ip_siocdelrt is called to complete processing of an SIOCDELRT IOCTL.
6156 */
6157 /* ARGSUSED */
6158 int
6159 ip_siocdelrt(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
6160 ip_ioctl_cmd_t *ipip, void *dummy_if_req)
6161 {
6162 ipaddr_t dst_addr;
6163 ipaddr_t gw_addr;
6164 ipaddr_t mask;
6165 int error;
6166 mblk_t *mp1;
6167 struct rtentry *rt;
6168 ipif_t *ipif = NULL;
6169 ip_stack_t *ipst;
6170
6171 ASSERT(q->q_next == NULL);
6172 ipst = CONNQ_TO_IPST(q);
6173
6174 ip1dbg(("ip_siocdelrt:"));
6175 /* Existence of mp1 verified in ip_wput_nondata */
6176 mp1 = mp->b_cont->b_cont;
6177 rt = (struct rtentry *)mp1->b_rptr;
6178
6179 dst_addr = ((sin_t *)&rt->rt_dst)->sin_addr.s_addr;
6180 gw_addr = ((sin_t *)&rt->rt_gateway)->sin_addr.s_addr;
6181
6182 /*
6183 * If the RTF_HOST flag is on, this is a request to delete a gateway
6184 * to a particular host address. In this case, we set the netmask to
6185 * all ones for the particular destination address. Otherwise,
6186 * determine the netmask to be used based on dst_addr and the interfaces
6187 * in use.
6188 */
6189 if (rt->rt_flags & RTF_HOST) {
6190 mask = IP_HOST_MASK;
6191 } else {
6192 /*
6193 * Note that ip_subnet_mask returns a zero mask in the case of
6194 * default (an all-zeroes address).
6195 */
6196 mask = ip_subnet_mask(dst_addr, &ipif, ipst);
6197 }
6198
6199 error = ip_rt_delete(dst_addr, mask, gw_addr,
6200 RTA_DST | RTA_GATEWAY | RTA_NETMASK, rt->rt_flags, NULL, B_TRUE,
6201 ipst, ALL_ZONES);
6202 if (ipif != NULL)
6203 ipif_refrele(ipif);
6204 return (error);
6205 }
6206
6207 /*
6208 * Enqueue the mp onto the ipsq, chained by b_next.
6209 * b_prev stores the function to be executed later, and b_queue the queue
6210 * where this mp originated.
6211 */
6212 void
6213 ipsq_enq(ipsq_t *ipsq, queue_t *q, mblk_t *mp, ipsq_func_t func, int type,
6214 ill_t *pending_ill)
6215 {
6216 conn_t *connp;
6217 ipxop_t *ipx = ipsq->ipsq_xop;
6218
6219 ASSERT(MUTEX_HELD(&ipsq->ipsq_lock));
6220 ASSERT(MUTEX_HELD(&ipx->ipx_lock));
6221 ASSERT(func != NULL);
6222
6223 mp->b_queue = q;
6224 mp->b_prev = (void *)func;
6225 mp->b_next = NULL;
6226
6227 switch (type) {
6228 case CUR_OP:
6229 if (ipx->ipx_mptail != NULL) {
6230 ASSERT(ipx->ipx_mphead != NULL);
6231 ipx->ipx_mptail->b_next = mp;
6232 } else {
6233 ASSERT(ipx->ipx_mphead == NULL);
6234 ipx->ipx_mphead = mp;
6235 }
6236 ipx->ipx_mptail = mp;
6237 break;
6238
6239 case NEW_OP:
6240 if (ipsq->ipsq_xopq_mptail != NULL) {
6241 ASSERT(ipsq->ipsq_xopq_mphead != NULL);
6242 ipsq->ipsq_xopq_mptail->b_next = mp;
6243 } else {
6244 ASSERT(ipsq->ipsq_xopq_mphead == NULL);
6245 ipsq->ipsq_xopq_mphead = mp;
6246 }
6247 ipsq->ipsq_xopq_mptail = mp;
6248 ipx->ipx_ipsq_queued = B_TRUE;
6249 break;
6250
6251 case SWITCH_OP:
6252 ASSERT(ipsq->ipsq_swxop != NULL);
6253 /* only one switch operation is currently allowed */
6254 ASSERT(ipsq->ipsq_switch_mp == NULL);
6255 ipsq->ipsq_switch_mp = mp;
6256 ipx->ipx_ipsq_queued = B_TRUE;
6257 break;
6258 default:
6259 cmn_err(CE_PANIC, "ipsq_enq %d type \n", type);
6260 }
6261
6262 if (CONN_Q(q) && pending_ill != NULL) {
6263 connp = Q_TO_CONN(q);
6264 ASSERT(MUTEX_HELD(&connp->conn_lock));
6265 connp->conn_oper_pending_ill = pending_ill;
6266 }
6267 }
6268
6269 /*
6270 * Dequeue the next message that requested exclusive access to this IPSQ's
6271 * xop. Specifically:
6272 *
6273 * 1. If we're still processing the current operation on `ipsq', then
6274 * dequeue the next message for the operation (from ipx_mphead), or
6275 * return NULL if there are no queued messages for the operation.
6276 * These messages are queued via CUR_OP to qwriter_ip() and friends.
6277 *
6278 * 2. If the current operation on `ipsq' has completed (ipx_current_ipif is
6279 * not set) see if the ipsq has requested an xop switch. If so, switch
6280 * `ipsq' to a different xop. Xop switches only happen when joining or
6281 * leaving IPMP groups and require a careful dance -- see the comments
6282 * in-line below for details. If we're leaving a group xop or if we're
6283 * joining a group xop and become writer on it, then we proceed to (3).
6284 * Otherwise, we return NULL and exit the xop.
6285 *
6286 * 3. For each IPSQ in the xop, return any switch operation stored on
6287 * ipsq_switch_mp (set via SWITCH_OP); these must be processed before
6288 * any other messages queued on the IPSQ. Otherwise, dequeue the next
6289 * exclusive operation (queued via NEW_OP) stored on ipsq_xopq_mphead.
6290 * Note that if the phyint tied to `ipsq' is not using IPMP there will
6291 * only be one IPSQ in the xop. Otherwise, there will be one IPSQ for
6292 * each phyint in the group, including the IPMP meta-interface phyint.
6293 */
6294 static mblk_t *
6295 ipsq_dq(ipsq_t *ipsq)
6296 {
6297 ill_t *illv4, *illv6;
6298 mblk_t *mp;
6299 ipsq_t *xopipsq;
6300 ipsq_t *leftipsq = NULL;
6301 ipxop_t *ipx;
6302 phyint_t *phyi = ipsq->ipsq_phyint;
6303 ip_stack_t *ipst = ipsq->ipsq_ipst;
6304 boolean_t emptied = B_FALSE;
6305
6306 /*
6307 * Grab all the locks we need in the defined order (ill_g_lock ->
6308 * ipsq_lock -> ipx_lock); ill_g_lock is needed to use ipsq_next.
6309 */
6310 rw_enter(&ipst->ips_ill_g_lock,
6311 ipsq->ipsq_swxop != NULL ? RW_WRITER : RW_READER);
6312 mutex_enter(&ipsq->ipsq_lock);
6313 ipx = ipsq->ipsq_xop;
6314 mutex_enter(&ipx->ipx_lock);
6315
6316 /*
6317 * Dequeue the next message associated with the current exclusive
6318 * operation, if any.
6319 */
6320 if ((mp = ipx->ipx_mphead) != NULL) {
6321 ipx->ipx_mphead = mp->b_next;
6322 if (ipx->ipx_mphead == NULL)
6323 ipx->ipx_mptail = NULL;
6324 mp->b_next = (void *)ipsq;
6325 goto out;
6326 }
6327
6328 if (ipx->ipx_current_ipif != NULL)
6329 goto empty;
6330
6331 if (ipsq->ipsq_swxop != NULL) {
6332 /*
6333 * The exclusive operation that is now being completed has
6334 * requested a switch to a different xop. This happens
6335 * when an interface joins or leaves an IPMP group. Joins
6336 * happen through SIOCSLIFGROUPNAME (ip_sioctl_groupname()).
6337 * Leaves happen via SIOCSLIFGROUPNAME, interface unplumb
6338 * (phyint_free()), or interface plumb for an ill type
6339 * not in the IPMP group (ip_rput_dlpi_writer()).
6340 *
6341 * Xop switches are not allowed on the IPMP meta-interface.
6342 */
6343 ASSERT(phyi == NULL || !(phyi->phyint_flags & PHYI_IPMP));
6344 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock));
6345 DTRACE_PROBE1(ipsq__switch, (ipsq_t *), ipsq);
6346
6347 if (ipsq->ipsq_swxop == &ipsq->ipsq_ownxop) {
6348 /*
6349 * We're switching back to our own xop, so we have two
6350 * xop's to drain/exit: our own, and the group xop
6351 * that we are leaving.
6352 *
6353 * First, pull ourselves out of the group ipsq list.
6354 * This is safe since we're writer on ill_g_lock.
6355 */
6356 ASSERT(ipsq->ipsq_xop != &ipsq->ipsq_ownxop);
6357
6358 xopipsq = ipx->ipx_ipsq;
6359 while (xopipsq->ipsq_next != ipsq)
6360 xopipsq = xopipsq->ipsq_next;
6361
6362 xopipsq->ipsq_next = ipsq->ipsq_next;
6363 ipsq->ipsq_next = ipsq;
6364 ipsq->ipsq_xop = ipsq->ipsq_swxop;
6365 ipsq->ipsq_swxop = NULL;
6366
6367 /*
6368 * Second, prepare to exit the group xop. The actual
6369 * ipsq_exit() is done at the end of this function
6370 * since we cannot hold any locks across ipsq_exit().
6371 * Note that although we drop the group's ipx_lock, no
6372 * threads can proceed since we're still ipx_writer.
6373 */
6374 leftipsq = xopipsq;
6375 mutex_exit(&ipx->ipx_lock);
6376
6377 /*
6378 * Third, set ipx to point to our own xop (which was
6379 * inactive and therefore can be entered).
6380 */
6381 ipx = ipsq->ipsq_xop;
6382 mutex_enter(&ipx->ipx_lock);
6383 ASSERT(ipx->ipx_writer == NULL);
6384 ASSERT(ipx->ipx_current_ipif == NULL);
6385 } else {
6386 /*
6387 * We're switching from our own xop to a group xop.
6388 * The requestor of the switch must ensure that the
6389 * group xop cannot go away (e.g. by ensuring the
6390 * phyint associated with the xop cannot go away).
6391 *
6392 * If we can become writer on our new xop, then we'll
6393 * do the drain. Otherwise, the current writer of our
6394 * new xop will do the drain when it exits.
6395 *
6396 * First, splice ourselves into the group IPSQ list.
6397 * This is safe since we're writer on ill_g_lock.
6398 */
6399 ASSERT(ipsq->ipsq_xop == &ipsq->ipsq_ownxop);
6400
6401 xopipsq = ipsq->ipsq_swxop->ipx_ipsq;
6402 while (xopipsq->ipsq_next != ipsq->ipsq_swxop->ipx_ipsq)
6403 xopipsq = xopipsq->ipsq_next;
6404
6405 xopipsq->ipsq_next = ipsq;
6406 ipsq->ipsq_next = ipsq->ipsq_swxop->ipx_ipsq;
6407 ipsq->ipsq_xop = ipsq->ipsq_swxop;
6408 ipsq->ipsq_swxop = NULL;
6409
6410 /*
6411 * Second, exit our own xop, since it's now unused.
6412 * This is safe since we've got the only reference.
6413 */
6414 ASSERT(ipx->ipx_writer == curthread);
6415 ipx->ipx_writer = NULL;
6416 VERIFY(--ipx->ipx_reentry_cnt == 0);
6417 ipx->ipx_ipsq_queued = B_FALSE;
6418 mutex_exit(&ipx->ipx_lock);
6419
6420 /*
6421 * Third, set ipx to point to our new xop, and check
6422 * if we can become writer on it. If we cannot, then
6423 * the current writer will drain the IPSQ group when
6424 * it exits. Our ipsq_xop is guaranteed to be stable
6425 * because we're still holding ipsq_lock.
6426 */
6427 ipx = ipsq->ipsq_xop;
6428 mutex_enter(&ipx->ipx_lock);
6429 if (ipx->ipx_writer != NULL ||
6430 ipx->ipx_current_ipif != NULL) {
6431 goto out;
6432 }
6433 }
6434
6435 /*
6436 * Fourth, become writer on our new ipx before we continue
6437 * with the drain. Note that we never dropped ipsq_lock
6438 * above, so no other thread could've raced with us to
6439 * become writer first. Also, we're holding ipx_lock, so
6440 * no other thread can examine the ipx right now.
6441 */
6442 ASSERT(ipx->ipx_current_ipif == NULL);
6443 ASSERT(ipx->ipx_mphead == NULL && ipx->ipx_mptail == NULL);
6444 VERIFY(ipx->ipx_reentry_cnt++ == 0);
6445 ipx->ipx_writer = curthread;
6446 ipx->ipx_forced = B_FALSE;
6447 #ifdef DEBUG
6448 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
6449 #endif
6450 }
6451
6452 xopipsq = ipsq;
6453 do {
6454 /*
6455 * So that other operations operate on a consistent and
6456 * complete phyint, a switch message on an IPSQ must be
6457 * handled prior to any other operations on that IPSQ.
6458 */
6459 if ((mp = xopipsq->ipsq_switch_mp) != NULL) {
6460 xopipsq->ipsq_switch_mp = NULL;
6461 ASSERT(mp->b_next == NULL);
6462 mp->b_next = (void *)xopipsq;
6463 goto out;
6464 }
6465
6466 if ((mp = xopipsq->ipsq_xopq_mphead) != NULL) {
6467 xopipsq->ipsq_xopq_mphead = mp->b_next;
6468 if (xopipsq->ipsq_xopq_mphead == NULL)
6469 xopipsq->ipsq_xopq_mptail = NULL;
6470 mp->b_next = (void *)xopipsq;
6471 goto out;
6472 }
6473 } while ((xopipsq = xopipsq->ipsq_next) != ipsq);
6474 empty:
6475 /*
6476 * There are no messages. Further, we are holding ipx_lock, hence no
6477 * new messages can end up on any IPSQ in the xop.
6478 */
6479 ipx->ipx_writer = NULL;
6480 ipx->ipx_forced = B_FALSE;
6481 VERIFY(--ipx->ipx_reentry_cnt == 0);
6482 ipx->ipx_ipsq_queued = B_FALSE;
6483 emptied = B_TRUE;
6484 #ifdef DEBUG
6485 ipx->ipx_depth = 0;
6486 #endif
6487 out:
6488 mutex_exit(&ipx->ipx_lock);
6489 mutex_exit(&ipsq->ipsq_lock);
6490
6491 /*
6492 * If we completely emptied the xop, then wake up any threads waiting
6493 * to enter any of the IPSQ's associated with it.
6494 */
6495 if (emptied) {
6496 xopipsq = ipsq;
6497 do {
6498 if ((phyi = xopipsq->ipsq_phyint) == NULL)
6499 continue;
6500
6501 illv4 = phyi->phyint_illv4;
6502 illv6 = phyi->phyint_illv6;
6503
6504 GRAB_ILL_LOCKS(illv4, illv6);
6505 if (illv4 != NULL)
6506 cv_broadcast(&illv4->ill_cv);
6507 if (illv6 != NULL)
6508 cv_broadcast(&illv6->ill_cv);
6509 RELEASE_ILL_LOCKS(illv4, illv6);
6510 } while ((xopipsq = xopipsq->ipsq_next) != ipsq);
6511 }
6512 rw_exit(&ipst->ips_ill_g_lock);
6513
6514 /*
6515 * Now that all locks are dropped, exit the IPSQ we left.
6516 */
6517 if (leftipsq != NULL)
6518 ipsq_exit(leftipsq);
6519
6520 return (mp);
6521 }
6522
6523 /*
6524 * Return completion status of previously initiated DLPI operations on
6525 * ills in the purview of an ipsq.
6526 */
6527 static boolean_t
6528 ipsq_dlpi_done(ipsq_t *ipsq)
6529 {
6530 ipsq_t *ipsq_start;
6531 phyint_t *phyi;
6532 ill_t *ill;
6533
6534 ASSERT(RW_LOCK_HELD(&ipsq->ipsq_ipst->ips_ill_g_lock));
6535 ipsq_start = ipsq;
6536
6537 do {
6538 /*
6539 * The only current users of this function are ipsq_try_enter
6540 * and ipsq_enter which have made sure that ipsq_writer is
6541 * NULL before we reach here. ill_dlpi_pending is modified
6542 * only by an ipsq writer
6543 */
6544 ASSERT(ipsq->ipsq_xop->ipx_writer == NULL);
6545 phyi = ipsq->ipsq_phyint;
6546 /*
6547 * phyi could be NULL if a phyint that is part of an
6548 * IPMP group is being unplumbed. A more detailed
6549 * comment is in ipmp_grp_update_kstats()
6550 */
6551 if (phyi != NULL) {
6552 ill = phyi->phyint_illv4;
6553 if (ill != NULL &&
6554 (ill->ill_dlpi_pending != DL_PRIM_INVAL ||
6555 ill->ill_arl_dlpi_pending))
6556 return (B_FALSE);
6557
6558 ill = phyi->phyint_illv6;
6559 if (ill != NULL &&
6560 ill->ill_dlpi_pending != DL_PRIM_INVAL)
6561 return (B_FALSE);
6562 }
6563
6564 } while ((ipsq = ipsq->ipsq_next) != ipsq_start);
6565
6566 return (B_TRUE);
6567 }
6568
6569 /*
6570 * Enter the ipsq corresponding to ill, by waiting synchronously till
6571 * we can enter the ipsq exclusively. Unless 'force' is used, the ipsq
6572 * will have to drain completely before ipsq_enter returns success.
6573 * ipx_current_ipif will be set if some exclusive op is in progress,
6574 * and the ipsq_exit logic will start the next enqueued op after
6575 * completion of the current op. If 'force' is used, we don't wait
6576 * for the enqueued ops. This is needed when a conn_close wants to
6577 * enter the ipsq and abort an ioctl that is somehow stuck. Unplumb
6578 * of an ill can also use this option. But we dont' use it currently.
6579 */
6580 #define ENTER_SQ_WAIT_TICKS 100
6581 boolean_t
6582 ipsq_enter(ill_t *ill, boolean_t force, int type)
6583 {
6584 ipsq_t *ipsq;
6585 ipxop_t *ipx;
6586 boolean_t waited_enough = B_FALSE;
6587 ip_stack_t *ipst = ill->ill_ipst;
6588
6589 /*
6590 * Note that the relationship between ill and ipsq is fixed as long as
6591 * the ill is not ILL_CONDEMNED. Holding ipsq_lock ensures the
6592 * relationship between the IPSQ and xop cannot change. However,
6593 * since we cannot hold ipsq_lock across the cv_wait(), it may change
6594 * while we're waiting. We wait on ill_cv and rely on ipsq_exit()
6595 * waking up all ills in the xop when it becomes available.
6596 */
6597 for (;;) {
6598 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
6599 mutex_enter(&ill->ill_lock);
6600 if (ill->ill_state_flags & ILL_CONDEMNED) {
6601 mutex_exit(&ill->ill_lock);
6602 rw_exit(&ipst->ips_ill_g_lock);
6603 return (B_FALSE);
6604 }
6605
6606 ipsq = ill->ill_phyint->phyint_ipsq;
6607 mutex_enter(&ipsq->ipsq_lock);
6608 ipx = ipsq->ipsq_xop;
6609 mutex_enter(&ipx->ipx_lock);
6610
6611 if (ipx->ipx_writer == NULL && (type == CUR_OP ||
6612 (ipx->ipx_current_ipif == NULL && ipsq_dlpi_done(ipsq)) ||
6613 waited_enough))
6614 break;
6615
6616 rw_exit(&ipst->ips_ill_g_lock);
6617
6618 if (!force || ipx->ipx_writer != NULL) {
6619 mutex_exit(&ipx->ipx_lock);
6620 mutex_exit(&ipsq->ipsq_lock);
6621 cv_wait(&ill->ill_cv, &ill->ill_lock);
6622 } else {
6623 mutex_exit(&ipx->ipx_lock);
6624 mutex_exit(&ipsq->ipsq_lock);
6625 (void) cv_reltimedwait(&ill->ill_cv,
6626 &ill->ill_lock, ENTER_SQ_WAIT_TICKS, TR_CLOCK_TICK);
6627 waited_enough = B_TRUE;
6628 }
6629 mutex_exit(&ill->ill_lock);
6630 }
6631
6632 ASSERT(ipx->ipx_mphead == NULL && ipx->ipx_mptail == NULL);
6633 ASSERT(ipx->ipx_reentry_cnt == 0);
6634 ipx->ipx_writer = curthread;
6635 ipx->ipx_forced = (ipx->ipx_current_ipif != NULL);
6636 ipx->ipx_reentry_cnt++;
6637 #ifdef DEBUG
6638 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
6639 #endif
6640 mutex_exit(&ipx->ipx_lock);
6641 mutex_exit(&ipsq->ipsq_lock);
6642 mutex_exit(&ill->ill_lock);
6643 rw_exit(&ipst->ips_ill_g_lock);
6644
6645 return (B_TRUE);
6646 }
6647
6648 /*
6649 * ipif_set_values() has a constraint that it cannot drop the ips_ill_g_lock
6650 * across the call to the core interface ipsq_try_enter() and hence calls this
6651 * function directly. This is explained more fully in ipif_set_values().
6652 * In order to support the above constraint, ipsq_try_enter is implemented as
6653 * a wrapper that grabs the ips_ill_g_lock and calls this function subsequently
6654 */
6655 static ipsq_t *
6656 ipsq_try_enter_internal(ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func,
6657 int type, boolean_t reentry_ok)
6658 {
6659 ipsq_t *ipsq;
6660 ipxop_t *ipx;
6661 ip_stack_t *ipst = ill->ill_ipst;
6662
6663 /*
6664 * lock ordering:
6665 * ill_g_lock -> conn_lock -> ill_lock -> ipsq_lock -> ipx_lock.
6666 *
6667 * ipx of an ipsq can't change when ipsq_lock is held.
6668 */
6669 ASSERT(RW_LOCK_HELD(&ipst->ips_ill_g_lock));
6670 GRAB_CONN_LOCK(q);
6671 mutex_enter(&ill->ill_lock);
6672 ipsq = ill->ill_phyint->phyint_ipsq;
6673 mutex_enter(&ipsq->ipsq_lock);
6674 ipx = ipsq->ipsq_xop;
6675 mutex_enter(&ipx->ipx_lock);
6676
6677 /*
6678 * 1. Enter the ipsq if we are already writer and reentry is ok.
6679 * (Note: If the caller does not specify reentry_ok then neither
6680 * 'func' nor any of its callees must ever attempt to enter the ipsq
6681 * again. Otherwise it can lead to an infinite loop
6682 * 2. Enter the ipsq if there is no current writer and this attempted
6683 * entry is part of the current operation
6684 * 3. Enter the ipsq if there is no current writer and this is a new
6685 * operation and the operation queue is empty and there is no
6686 * operation currently in progress and if all previously initiated
6687 * DLPI operations have completed.
6688 */
6689 if ((ipx->ipx_writer == curthread && reentry_ok) ||
6690 (ipx->ipx_writer == NULL && (type == CUR_OP || (type == NEW_OP &&
6691 !ipx->ipx_ipsq_queued && ipx->ipx_current_ipif == NULL &&
6692 ipsq_dlpi_done(ipsq))))) {
6693 /* Success. */
6694 ipx->ipx_reentry_cnt++;
6695 ipx->ipx_writer = curthread;
6696 ipx->ipx_forced = B_FALSE;
6697 mutex_exit(&ipx->ipx_lock);
6698 mutex_exit(&ipsq->ipsq_lock);
6699 mutex_exit(&ill->ill_lock);
6700 RELEASE_CONN_LOCK(q);
6701 #ifdef DEBUG
6702 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
6703 #endif
6704 return (ipsq);
6705 }
6706
6707 if (func != NULL)
6708 ipsq_enq(ipsq, q, mp, func, type, ill);
6709
6710 mutex_exit(&ipx->ipx_lock);
6711 mutex_exit(&ipsq->ipsq_lock);
6712 mutex_exit(&ill->ill_lock);
6713 RELEASE_CONN_LOCK(q);
6714 return (NULL);
6715 }
6716
6717 /*
6718 * The ipsq_t (ipsq) is the synchronization data structure used to serialize
6719 * certain critical operations like plumbing (i.e. most set ioctls), etc.
6720 * There is one ipsq per phyint. The ipsq
6721 * serializes exclusive ioctls issued by applications on a per ipsq basis in
6722 * ipsq_xopq_mphead. It also protects against multiple threads executing in
6723 * the ipsq. Responses from the driver pertain to the current ioctl (say a
6724 * DL_BIND_ACK in response to a DL_BIND_REQ initiated as part of bringing
6725 * up the interface) and are enqueued in ipx_mphead.
6726 *
6727 * If a thread does not want to reenter the ipsq when it is already writer,
6728 * it must make sure that the specified reentry point to be called later
6729 * when the ipsq is empty, nor any code path starting from the specified reentry
6730 * point must never ever try to enter the ipsq again. Otherwise it can lead
6731 * to an infinite loop. The reentry point ip_rput_dlpi_writer is an example.
6732 * When the thread that is currently exclusive finishes, it (ipsq_exit)
6733 * dequeues the requests waiting to become exclusive in ipx_mphead and calls
6734 * the reentry point. When the list at ipx_mphead becomes empty ipsq_exit
6735 * proceeds to dequeue the next ioctl in ipsq_xopq_mphead and start the next
6736 * ioctl if the current ioctl has completed. If the current ioctl is still
6737 * in progress it simply returns. The current ioctl could be waiting for
6738 * a response from another module (the driver or could be waiting for
6739 * the ipif/ill/ire refcnts to drop to zero. In such a case the ipx_pending_mp
6740 * and ipx_pending_ipif are set. ipx_current_ipif is set throughout the
6741 * execution of the ioctl and ipsq_exit does not start the next ioctl unless
6742 * ipx_current_ipif is NULL which happens only once the ioctl is complete and
6743 * all associated DLPI operations have completed.
6744 */
6745
6746 /*
6747 * Try to enter the IPSQ corresponding to `ipif' or `ill' exclusively (`ipif'
6748 * and `ill' cannot both be specified). Returns a pointer to the entered IPSQ
6749 * on success, or NULL on failure. The caller ensures ipif/ill is valid by
6750 * refholding it as necessary. If the IPSQ cannot be entered and `func' is
6751 * non-NULL, then `func' will be called back with `q' and `mp' once the IPSQ
6752 * can be entered. If `func' is NULL, then `q' and `mp' are ignored.
6753 */
6754 ipsq_t *
6755 ipsq_try_enter(ipif_t *ipif, ill_t *ill, queue_t *q, mblk_t *mp,
6756 ipsq_func_t func, int type, boolean_t reentry_ok)
6757 {
6758 ip_stack_t *ipst;
6759 ipsq_t *ipsq;
6760
6761 /* Only 1 of ipif or ill can be specified */
6762 ASSERT((ipif != NULL) ^ (ill != NULL));
6763
6764 if (ipif != NULL)
6765 ill = ipif->ipif_ill;
6766 ipst = ill->ill_ipst;
6767
6768 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
6769 ipsq = ipsq_try_enter_internal(ill, q, mp, func, type, reentry_ok);
6770 rw_exit(&ipst->ips_ill_g_lock);
6771
6772 return (ipsq);
6773 }
6774
6775 /*
6776 * Try to enter the IPSQ corresponding to `ill' as writer. The caller ensures
6777 * ill is valid by refholding it if necessary; we will refrele. If the IPSQ
6778 * cannot be entered, the mp is queued for completion.
6779 */
6780 void
6781 qwriter_ip(ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func, int type,
6782 boolean_t reentry_ok)
6783 {
6784 ipsq_t *ipsq;
6785
6786 ipsq = ipsq_try_enter(NULL, ill, q, mp, func, type, reentry_ok);
6787
6788 /*
6789 * Drop the caller's refhold on the ill. This is safe since we either
6790 * entered the IPSQ (and thus are exclusive), or failed to enter the
6791 * IPSQ, in which case we return without accessing ill anymore. This
6792 * is needed because func needs to see the correct refcount.
6793 * e.g. removeif can work only then.
6794 */
6795 ill_refrele(ill);
6796 if (ipsq != NULL) {
6797 (*func)(ipsq, q, mp, NULL);
6798 ipsq_exit(ipsq);
6799 }
6800 }
6801
6802 /*
6803 * Exit the specified IPSQ. If this is the final exit on it then drain it
6804 * prior to exiting. Caller must be writer on the specified IPSQ.
6805 */
6806 void
6807 ipsq_exit(ipsq_t *ipsq)
6808 {
6809 mblk_t *mp;
6810 ipsq_t *mp_ipsq;
6811 queue_t *q;
6812 phyint_t *phyi;
6813 ipsq_func_t func;
6814
6815 ASSERT(IAM_WRITER_IPSQ(ipsq));
6816
6817 ASSERT(ipsq->ipsq_xop->ipx_reentry_cnt >= 1);
6818 if (ipsq->ipsq_xop->ipx_reentry_cnt != 1) {
6819 ipsq->ipsq_xop->ipx_reentry_cnt--;
6820 return;
6821 }
6822
6823 for (;;) {
6824 phyi = ipsq->ipsq_phyint;
6825 mp = ipsq_dq(ipsq);
6826 mp_ipsq = (mp == NULL) ? NULL : (ipsq_t *)mp->b_next;
6827
6828 /*
6829 * If we've changed to a new IPSQ, and the phyint associated
6830 * with the old one has gone away, free the old IPSQ. Note
6831 * that this cannot happen while the IPSQ is in a group.
6832 */
6833 if (mp_ipsq != ipsq && phyi == NULL) {
6834 ASSERT(ipsq->ipsq_next == ipsq);
6835 ASSERT(ipsq->ipsq_xop == &ipsq->ipsq_ownxop);
6836 ipsq_delete(ipsq);
6837 }
6838
6839 if (mp == NULL)
6840 break;
6841
6842 q = mp->b_queue;
6843 func = (ipsq_func_t)mp->b_prev;
6844 ipsq = mp_ipsq;
6845 mp->b_next = mp->b_prev = NULL;
6846 mp->b_queue = NULL;
6847
6848 /*
6849 * If 'q' is an conn queue, it is valid, since we did a
6850 * a refhold on the conn at the start of the ioctl.
6851 * If 'q' is an ill queue, it is valid, since close of an
6852 * ill will clean up its IPSQ.
6853 */
6854 (*func)(ipsq, q, mp, NULL);
6855 }
6856 }
6857
6858 /*
6859 * Used to start any igmp or mld timers that could not be started
6860 * while holding ill_mcast_lock. The timers can't be started while holding
6861 * the lock, since mld/igmp_start_timers may need to call untimeout()
6862 * which can't be done while holding the lock which the timeout handler
6863 * acquires. Otherwise
6864 * there could be a deadlock since the timeout handlers
6865 * mld_timeout_handler_per_ill/igmp_timeout_handler_per_ill also acquire
6866 * ill_mcast_lock.
6867 */
6868 void
6869 ill_mcast_timer_start(ip_stack_t *ipst)
6870 {
6871 int next;
6872
6873 mutex_enter(&ipst->ips_igmp_timer_lock);
6874 next = ipst->ips_igmp_deferred_next;
6875 ipst->ips_igmp_deferred_next = INFINITY;
6876 mutex_exit(&ipst->ips_igmp_timer_lock);
6877
6878 if (next != INFINITY)
6879 igmp_start_timers(next, ipst);
6880
6881 mutex_enter(&ipst->ips_mld_timer_lock);
6882 next = ipst->ips_mld_deferred_next;
6883 ipst->ips_mld_deferred_next = INFINITY;
6884 mutex_exit(&ipst->ips_mld_timer_lock);
6885
6886 if (next != INFINITY)
6887 mld_start_timers(next, ipst);
6888 }
6889
6890 /*
6891 * Start the current exclusive operation on `ipsq'; associate it with `ipif'
6892 * and `ioccmd'.
6893 */
6894 void
6895 ipsq_current_start(ipsq_t *ipsq, ipif_t *ipif, int ioccmd)
6896 {
6897 ill_t *ill = ipif->ipif_ill;
6898 ipxop_t *ipx = ipsq->ipsq_xop;
6899
6900 ASSERT(IAM_WRITER_IPSQ(ipsq));
6901 ASSERT(ipx->ipx_current_ipif == NULL);
6902 ASSERT(ipx->ipx_current_ioctl == 0);
6903
6904 ipx->ipx_current_done = B_FALSE;
6905 ipx->ipx_current_ioctl = ioccmd;
6906 mutex_enter(&ipx->ipx_lock);
6907 ipx->ipx_current_ipif = ipif;
6908 mutex_exit(&ipx->ipx_lock);
6909
6910 /*
6911 * Set IPIF_CHANGING on one or more ipifs associated with the
6912 * current exclusive operation. IPIF_CHANGING prevents any new
6913 * references to the ipif (so that the references will eventually
6914 * drop to zero) and also prevents any "get" operations (e.g.,
6915 * SIOCGLIFFLAGS) from being able to access the ipif until the
6916 * operation has completed and the ipif is again in a stable state.
6917 *
6918 * For ioctls, IPIF_CHANGING is set on the ipif associated with the
6919 * ioctl. For internal operations (where ioccmd is zero), all ipifs
6920 * on the ill are marked with IPIF_CHANGING since it's unclear which
6921 * ipifs will be affected.
6922 *
6923 * Note that SIOCLIFREMOVEIF is a special case as it sets
6924 * IPIF_CONDEMNED internally after identifying the right ipif to
6925 * operate on.
6926 */
6927 switch (ioccmd) {
6928 case SIOCLIFREMOVEIF:
6929 break;
6930 case 0:
6931 mutex_enter(&ill->ill_lock);
6932 ipif = ipif->ipif_ill->ill_ipif;
6933 for (; ipif != NULL; ipif = ipif->ipif_next)
6934 ipif->ipif_state_flags |= IPIF_CHANGING;
6935 mutex_exit(&ill->ill_lock);
6936 break;
6937 default:
6938 mutex_enter(&ill->ill_lock);
6939 ipif->ipif_state_flags |= IPIF_CHANGING;
6940 mutex_exit(&ill->ill_lock);
6941 }
6942 }
6943
6944 /*
6945 * Finish the current exclusive operation on `ipsq'. Usually, this will allow
6946 * the next exclusive operation to begin once we ipsq_exit(). However, if
6947 * pending DLPI operations remain, then we will wait for the queue to drain
6948 * before allowing the next exclusive operation to begin. This ensures that
6949 * DLPI operations from one exclusive operation are never improperly processed
6950 * as part of a subsequent exclusive operation.
6951 */
6952 void
6953 ipsq_current_finish(ipsq_t *ipsq)
6954 {
6955 ipxop_t *ipx = ipsq->ipsq_xop;
6956 t_uscalar_t dlpi_pending = DL_PRIM_INVAL;
6957 ipif_t *ipif = ipx->ipx_current_ipif;
6958
6959 ASSERT(IAM_WRITER_IPSQ(ipsq));
6960
6961 /*
6962 * For SIOCLIFREMOVEIF, the ipif has been already been blown away
6963 * (but in that case, IPIF_CHANGING will already be clear and no
6964 * pending DLPI messages can remain).
6965 */
6966 if (ipx->ipx_current_ioctl != SIOCLIFREMOVEIF) {
6967 ill_t *ill = ipif->ipif_ill;
6968
6969 mutex_enter(&ill->ill_lock);
6970 dlpi_pending = ill->ill_dlpi_pending;
6971 if (ipx->ipx_current_ioctl == 0) {
6972 ipif = ill->ill_ipif;
6973 for (; ipif != NULL; ipif = ipif->ipif_next)
6974 ipif->ipif_state_flags &= ~IPIF_CHANGING;
6975 } else {
6976 ipif->ipif_state_flags &= ~IPIF_CHANGING;
6977 }
6978 mutex_exit(&ill->ill_lock);
6979 }
6980
6981 ASSERT(!ipx->ipx_current_done);
6982 ipx->ipx_current_done = B_TRUE;
6983 ipx->ipx_current_ioctl = 0;
6984 if (dlpi_pending == DL_PRIM_INVAL) {
6985 mutex_enter(&ipx->ipx_lock);
6986 ipx->ipx_current_ipif = NULL;
6987 mutex_exit(&ipx->ipx_lock);
6988 }
6989 }
6990
6991 /*
6992 * The ill is closing. Flush all messages on the ipsq that originated
6993 * from this ill. Usually there wont' be any messages on the ipsq_xopq_mphead
6994 * for this ill since ipsq_enter could not have entered until then.
6995 * New messages can't be queued since the CONDEMNED flag is set.
6996 */
6997 static void
6998 ipsq_flush(ill_t *ill)
6999 {
7000 queue_t *q;
7001 mblk_t *prev;
7002 mblk_t *mp;
7003 mblk_t *mp_next;
7004 ipxop_t *ipx = ill->ill_phyint->phyint_ipsq->ipsq_xop;
7005
7006 ASSERT(IAM_WRITER_ILL(ill));
7007
7008 /*
7009 * Flush any messages sent up by the driver.
7010 */
7011 mutex_enter(&ipx->ipx_lock);
7012 for (prev = NULL, mp = ipx->ipx_mphead; mp != NULL; mp = mp_next) {
7013 mp_next = mp->b_next;
7014 q = mp->b_queue;
7015 if (q == ill->ill_rq || q == ill->ill_wq) {
7016 /* dequeue mp */
7017 if (prev == NULL)
7018 ipx->ipx_mphead = mp->b_next;
7019 else
7020 prev->b_next = mp->b_next;
7021 if (ipx->ipx_mptail == mp) {
7022 ASSERT(mp_next == NULL);
7023 ipx->ipx_mptail = prev;
7024 }
7025 inet_freemsg(mp);
7026 } else {
7027 prev = mp;
7028 }
7029 }
7030 mutex_exit(&ipx->ipx_lock);
7031 (void) ipsq_pending_mp_cleanup(ill, NULL);
7032 ipsq_xopq_mp_cleanup(ill, NULL);
7033 }
7034
7035 /*
7036 * Parse an ifreq or lifreq struct coming down ioctls and refhold
7037 * and return the associated ipif.
7038 * Return value:
7039 * Non zero: An error has occurred. ci may not be filled out.
7040 * zero : ci is filled out with the ioctl cmd in ci.ci_name, and
7041 * a held ipif in ci.ci_ipif.
7042 */
7043 int
7044 ip_extract_lifreq(queue_t *q, mblk_t *mp, const ip_ioctl_cmd_t *ipip,
7045 cmd_info_t *ci)
7046 {
7047 char *name;
7048 struct ifreq *ifr;
7049 struct lifreq *lifr;
7050 ipif_t *ipif = NULL;
7051 ill_t *ill;
7052 conn_t *connp;
7053 boolean_t isv6;
7054 int err;
7055 mblk_t *mp1;
7056 zoneid_t zoneid;
7057 ip_stack_t *ipst;
7058
7059 if (q->q_next != NULL) {
7060 ill = (ill_t *)q->q_ptr;
7061 isv6 = ill->ill_isv6;
7062 connp = NULL;
7063 zoneid = ALL_ZONES;
7064 ipst = ill->ill_ipst;
7065 } else {
7066 ill = NULL;
7067 connp = Q_TO_CONN(q);
7068 isv6 = (connp->conn_family == AF_INET6);
7069 zoneid = connp->conn_zoneid;
7070 if (zoneid == GLOBAL_ZONEID) {
7071 /* global zone can access ipifs in all zones */
7072 zoneid = ALL_ZONES;
7073 }
7074 ipst = connp->conn_netstack->netstack_ip;
7075 }
7076
7077 /* Has been checked in ip_wput_nondata */
7078 mp1 = mp->b_cont->b_cont;
7079
7080 if (ipip->ipi_cmd_type == IF_CMD) {
7081 /* This a old style SIOC[GS]IF* command */
7082 ifr = (struct ifreq *)mp1->b_rptr;
7083 /*
7084 * Null terminate the string to protect against buffer
7085 * overrun. String was generated by user code and may not
7086 * be trusted.
7087 */
7088 ifr->ifr_name[IFNAMSIZ - 1] = '\0';
7089 name = ifr->ifr_name;
7090 ci->ci_sin = (sin_t *)&ifr->ifr_addr;
7091 ci->ci_sin6 = NULL;
7092 ci->ci_lifr = (struct lifreq *)ifr;
7093 } else {
7094 /* This a new style SIOC[GS]LIF* command */
7095 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
7096 lifr = (struct lifreq *)mp1->b_rptr;
7097 /*
7098 * Null terminate the string to protect against buffer
7099 * overrun. String was generated by user code and may not
7100 * be trusted.
7101 */
7102 lifr->lifr_name[LIFNAMSIZ - 1] = '\0';
7103 name = lifr->lifr_name;
7104 ci->ci_sin = (sin_t *)&lifr->lifr_addr;
7105 ci->ci_sin6 = (sin6_t *)&lifr->lifr_addr;
7106 ci->ci_lifr = lifr;
7107 }
7108
7109 if (ipip->ipi_cmd == SIOCSLIFNAME) {
7110 /*
7111 * The ioctl will be failed if the ioctl comes down
7112 * an conn stream
7113 */
7114 if (ill == NULL) {
7115 /*
7116 * Not an ill queue, return EINVAL same as the
7117 * old error code.
7118 */
7119 return (ENXIO);
7120 }
7121 ipif = ill->ill_ipif;
7122 ipif_refhold(ipif);
7123 } else {
7124 /*
7125 * Ensure that ioctls don't see any internal state changes
7126 * caused by set ioctls by deferring them if IPIF_CHANGING is
7127 * set.
7128 */
7129 ipif = ipif_lookup_on_name_async(name, mi_strlen(name),
7130 isv6, zoneid, q, mp, ip_process_ioctl, &err, ipst);
7131 if (ipif == NULL) {
7132 if (err == EINPROGRESS)
7133 return (err);
7134 err = 0; /* Ensure we don't use it below */
7135 }
7136 }
7137
7138 /*
7139 * Old style [GS]IFCMD does not admit IPv6 ipif
7140 */
7141 if (ipif != NULL && ipif->ipif_isv6 && ipip->ipi_cmd_type == IF_CMD) {
7142 ipif_refrele(ipif);
7143 return (ENXIO);
7144 }
7145
7146 if (ipif == NULL && ill != NULL && ill->ill_ipif != NULL &&
7147 name[0] == '\0') {
7148 /*
7149 * Handle a or a SIOC?IF* with a null name
7150 * during plumb (on the ill queue before the I_PLINK).
7151 */
7152 ipif = ill->ill_ipif;
7153 ipif_refhold(ipif);
7154 }
7155
7156 if (ipif == NULL)
7157 return (ENXIO);
7158
7159 DTRACE_PROBE4(ipif__ioctl, char *, "ip_extract_lifreq",
7160 int, ipip->ipi_cmd, ill_t *, ipif->ipif_ill, ipif_t *, ipif);
7161
7162 ci->ci_ipif = ipif;
7163 return (0);
7164 }
7165
7166 /*
7167 * Return the total number of ipifs.
7168 */
7169 static uint_t
7170 ip_get_numifs(zoneid_t zoneid, ip_stack_t *ipst)
7171 {
7172 uint_t numifs = 0;
7173 ill_t *ill;
7174 ill_walk_context_t ctx;
7175 ipif_t *ipif;
7176
7177 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7178 ill = ILL_START_WALK_V4(&ctx, ipst);
7179 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7180 if (IS_UNDER_IPMP(ill))
7181 continue;
7182 for (ipif = ill->ill_ipif; ipif != NULL;
7183 ipif = ipif->ipif_next) {
7184 if (ipif->ipif_zoneid == zoneid ||
7185 ipif->ipif_zoneid == ALL_ZONES)
7186 numifs++;
7187 }
7188 }
7189 rw_exit(&ipst->ips_ill_g_lock);
7190 return (numifs);
7191 }
7192
7193 /*
7194 * Return the total number of ipifs.
7195 */
7196 static uint_t
7197 ip_get_numlifs(int family, int lifn_flags, zoneid_t zoneid, ip_stack_t *ipst)
7198 {
7199 uint_t numifs = 0;
7200 ill_t *ill;
7201 ipif_t *ipif;
7202 ill_walk_context_t ctx;
7203
7204 ip1dbg(("ip_get_numlifs(%d %u %d)\n", family, lifn_flags, (int)zoneid));
7205
7206 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7207 if (family == AF_INET)
7208 ill = ILL_START_WALK_V4(&ctx, ipst);
7209 else if (family == AF_INET6)
7210 ill = ILL_START_WALK_V6(&ctx, ipst);
7211 else
7212 ill = ILL_START_WALK_ALL(&ctx, ipst);
7213
7214 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7215 if (IS_UNDER_IPMP(ill) && !(lifn_flags & LIFC_UNDER_IPMP))
7216 continue;
7217
7218 for (ipif = ill->ill_ipif; ipif != NULL;
7219 ipif = ipif->ipif_next) {
7220 if ((ipif->ipif_flags & IPIF_NOXMIT) &&
7221 !(lifn_flags & LIFC_NOXMIT))
7222 continue;
7223 if ((ipif->ipif_flags & IPIF_TEMPORARY) &&
7224 !(lifn_flags & LIFC_TEMPORARY))
7225 continue;
7226 if (((ipif->ipif_flags &
7227 (IPIF_NOXMIT|IPIF_NOLOCAL|
7228 IPIF_DEPRECATED)) ||
7229 IS_LOOPBACK(ill) ||
7230 !(ipif->ipif_flags & IPIF_UP)) &&
7231 (lifn_flags & LIFC_EXTERNAL_SOURCE))
7232 continue;
7233
7234 if (zoneid != ipif->ipif_zoneid &&
7235 ipif->ipif_zoneid != ALL_ZONES &&
7236 (zoneid != GLOBAL_ZONEID ||
7237 !(lifn_flags & LIFC_ALLZONES)))
7238 continue;
7239
7240 numifs++;
7241 }
7242 }
7243 rw_exit(&ipst->ips_ill_g_lock);
7244 return (numifs);
7245 }
7246
7247 uint_t
7248 ip_get_lifsrcofnum(ill_t *ill)
7249 {
7250 uint_t numifs = 0;
7251 ill_t *ill_head = ill;
7252 ip_stack_t *ipst = ill->ill_ipst;
7253
7254 /*
7255 * ill_g_usesrc_lock protects ill_usesrc_grp_next, for example, some
7256 * other thread may be trying to relink the ILLs in this usesrc group
7257 * and adjusting the ill_usesrc_grp_next pointers
7258 */
7259 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_READER);
7260 if ((ill->ill_usesrc_ifindex == 0) &&
7261 (ill->ill_usesrc_grp_next != NULL)) {
7262 for (; (ill != NULL) && (ill->ill_usesrc_grp_next != ill_head);
7263 ill = ill->ill_usesrc_grp_next)
7264 numifs++;
7265 }
7266 rw_exit(&ipst->ips_ill_g_usesrc_lock);
7267
7268 return (numifs);
7269 }
7270
7271 /* Null values are passed in for ipif, sin, and ifreq */
7272 /* ARGSUSED */
7273 int
7274 ip_sioctl_get_ifnum(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7275 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7276 {
7277 int *nump;
7278 conn_t *connp = Q_TO_CONN(q);
7279
7280 ASSERT(q->q_next == NULL); /* not a valid ioctl for ip as a module */
7281
7282 /* Existence of b_cont->b_cont checked in ip_wput_nondata */
7283 nump = (int *)mp->b_cont->b_cont->b_rptr;
7284
7285 *nump = ip_get_numifs(connp->conn_zoneid,
7286 connp->conn_netstack->netstack_ip);
7287 ip1dbg(("ip_sioctl_get_ifnum numifs %d", *nump));
7288 return (0);
7289 }
7290
7291 /* Null values are passed in for ipif, sin, and ifreq */
7292 /* ARGSUSED */
7293 int
7294 ip_sioctl_get_lifnum(ipif_t *dummy_ipif, sin_t *dummy_sin,
7295 queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7296 {
7297 struct lifnum *lifn;
7298 mblk_t *mp1;
7299 conn_t *connp = Q_TO_CONN(q);
7300
7301 ASSERT(q->q_next == NULL); /* not a valid ioctl for ip as a module */
7302
7303 /* Existence checked in ip_wput_nondata */
7304 mp1 = mp->b_cont->b_cont;
7305
7306 lifn = (struct lifnum *)mp1->b_rptr;
7307 switch (lifn->lifn_family) {
7308 case AF_UNSPEC:
7309 case AF_INET:
7310 case AF_INET6:
7311 break;
7312 default:
7313 return (EAFNOSUPPORT);
7314 }
7315
7316 lifn->lifn_count = ip_get_numlifs(lifn->lifn_family, lifn->lifn_flags,
7317 connp->conn_zoneid, connp->conn_netstack->netstack_ip);
7318 ip1dbg(("ip_sioctl_get_lifnum numifs %d", lifn->lifn_count));
7319 return (0);
7320 }
7321
7322 /* ARGSUSED */
7323 int
7324 ip_sioctl_get_ifconf(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7325 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7326 {
7327 STRUCT_HANDLE(ifconf, ifc);
7328 mblk_t *mp1;
7329 struct iocblk *iocp;
7330 struct ifreq *ifr;
7331 ill_walk_context_t ctx;
7332 ill_t *ill;
7333 ipif_t *ipif;
7334 struct sockaddr_in *sin;
7335 int32_t ifclen;
7336 zoneid_t zoneid;
7337 ip_stack_t *ipst = CONNQ_TO_IPST(q);
7338
7339 ASSERT(q->q_next == NULL); /* not valid ioctls for ip as a module */
7340
7341 ip1dbg(("ip_sioctl_get_ifconf"));
7342 /* Existence verified in ip_wput_nondata */
7343 mp1 = mp->b_cont->b_cont;
7344 iocp = (struct iocblk *)mp->b_rptr;
7345 zoneid = Q_TO_CONN(q)->conn_zoneid;
7346
7347 /*
7348 * The original SIOCGIFCONF passed in a struct ifconf which specified
7349 * the user buffer address and length into which the list of struct
7350 * ifreqs was to be copied. Since AT&T Streams does not seem to
7351 * allow M_COPYOUT to be used in conjunction with I_STR IOCTLS,
7352 * the SIOCGIFCONF operation was redefined to simply provide
7353 * a large output buffer into which we are supposed to jam the ifreq
7354 * array. The same ioctl command code was used, despite the fact that
7355 * both the applications and the kernel code had to change, thus making
7356 * it impossible to support both interfaces.
7357 *
7358 * For reasons not good enough to try to explain, the following
7359 * algorithm is used for deciding what to do with one of these:
7360 * If the IOCTL comes in as an I_STR, it is assumed to be of the new
7361 * form with the output buffer coming down as the continuation message.
7362 * If it arrives as a TRANSPARENT IOCTL, it is assumed to be old style,
7363 * and we have to copy in the ifconf structure to find out how big the
7364 * output buffer is and where to copy out to. Sure no problem...
7365 *
7366 */
7367 STRUCT_SET_HANDLE(ifc, iocp->ioc_flag, NULL);
7368 if ((mp1->b_wptr - mp1->b_rptr) == STRUCT_SIZE(ifc)) {
7369 int numifs = 0;
7370 size_t ifc_bufsize;
7371
7372 /*
7373 * Must be (better be!) continuation of a TRANSPARENT
7374 * IOCTL. We just copied in the ifconf structure.
7375 */
7376 STRUCT_SET_HANDLE(ifc, iocp->ioc_flag,
7377 (struct ifconf *)mp1->b_rptr);
7378
7379 /*
7380 * Allocate a buffer to hold requested information.
7381 *
7382 * If ifc_len is larger than what is needed, we only
7383 * allocate what we will use.
7384 *
7385 * If ifc_len is smaller than what is needed, return
7386 * EINVAL.
7387 *
7388 * XXX: the ill_t structure can hava 2 counters, for
7389 * v4 and v6 (not just ill_ipif_up_count) to store the
7390 * number of interfaces for a device, so we don't need
7391 * to count them here...
7392 */
7393 numifs = ip_get_numifs(zoneid, ipst);
7394
7395 ifclen = STRUCT_FGET(ifc, ifc_len);
7396 ifc_bufsize = numifs * sizeof (struct ifreq);
7397 if (ifc_bufsize > ifclen) {
7398 if (iocp->ioc_cmd == O_SIOCGIFCONF) {
7399 /* old behaviour */
7400 return (EINVAL);
7401 } else {
7402 ifc_bufsize = ifclen;
7403 }
7404 }
7405
7406 mp1 = mi_copyout_alloc(q, mp,
7407 STRUCT_FGETP(ifc, ifc_buf), ifc_bufsize, B_FALSE);
7408 if (mp1 == NULL)
7409 return (ENOMEM);
7410
7411 mp1->b_wptr = mp1->b_rptr + ifc_bufsize;
7412 }
7413 bzero(mp1->b_rptr, mp1->b_wptr - mp1->b_rptr);
7414 /*
7415 * the SIOCGIFCONF ioctl only knows about
7416 * IPv4 addresses, so don't try to tell
7417 * it about interfaces with IPv6-only
7418 * addresses. (Last parm 'isv6' is B_FALSE)
7419 */
7420
7421 ifr = (struct ifreq *)mp1->b_rptr;
7422
7423 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7424 ill = ILL_START_WALK_V4(&ctx, ipst);
7425 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7426 if (IS_UNDER_IPMP(ill))
7427 continue;
7428 for (ipif = ill->ill_ipif; ipif != NULL;
7429 ipif = ipif->ipif_next) {
7430 if (zoneid != ipif->ipif_zoneid &&
7431 ipif->ipif_zoneid != ALL_ZONES)
7432 continue;
7433 if ((uchar_t *)&ifr[1] > mp1->b_wptr) {
7434 if (iocp->ioc_cmd == O_SIOCGIFCONF) {
7435 /* old behaviour */
7436 rw_exit(&ipst->ips_ill_g_lock);
7437 return (EINVAL);
7438 } else {
7439 goto if_copydone;
7440 }
7441 }
7442 ipif_get_name(ipif, ifr->ifr_name,
7443 sizeof (ifr->ifr_name));
7444 sin = (sin_t *)&ifr->ifr_addr;
7445 *sin = sin_null;
7446 sin->sin_family = AF_INET;
7447 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
7448 ifr++;
7449 }
7450 }
7451 if_copydone:
7452 rw_exit(&ipst->ips_ill_g_lock);
7453 mp1->b_wptr = (uchar_t *)ifr;
7454
7455 if (STRUCT_BUF(ifc) != NULL) {
7456 STRUCT_FSET(ifc, ifc_len,
7457 (int)((uchar_t *)ifr - mp1->b_rptr));
7458 }
7459 return (0);
7460 }
7461
7462 /*
7463 * Get the interfaces using the address hosted on the interface passed in,
7464 * as a source adddress
7465 */
7466 /* ARGSUSED */
7467 int
7468 ip_sioctl_get_lifsrcof(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7469 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7470 {
7471 mblk_t *mp1;
7472 ill_t *ill, *ill_head;
7473 ipif_t *ipif, *orig_ipif;
7474 int numlifs = 0;
7475 size_t lifs_bufsize, lifsmaxlen;
7476 struct lifreq *lifr;
7477 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7478 uint_t ifindex;
7479 zoneid_t zoneid;
7480 boolean_t isv6 = B_FALSE;
7481 struct sockaddr_in *sin;
7482 struct sockaddr_in6 *sin6;
7483 STRUCT_HANDLE(lifsrcof, lifs);
7484 ip_stack_t *ipst;
7485
7486 ipst = CONNQ_TO_IPST(q);
7487
7488 ASSERT(q->q_next == NULL);
7489
7490 zoneid = Q_TO_CONN(q)->conn_zoneid;
7491
7492 /* Existence verified in ip_wput_nondata */
7493 mp1 = mp->b_cont->b_cont;
7494
7495 /*
7496 * Must be (better be!) continuation of a TRANSPARENT
7497 * IOCTL. We just copied in the lifsrcof structure.
7498 */
7499 STRUCT_SET_HANDLE(lifs, iocp->ioc_flag,
7500 (struct lifsrcof *)mp1->b_rptr);
7501
7502 if (MBLKL(mp1) != STRUCT_SIZE(lifs))
7503 return (EINVAL);
7504
7505 ifindex = STRUCT_FGET(lifs, lifs_ifindex);
7506 isv6 = (Q_TO_CONN(q))->conn_family == AF_INET6;
7507 ipif = ipif_lookup_on_ifindex(ifindex, isv6, zoneid, ipst);
7508 if (ipif == NULL) {
7509 ip1dbg(("ip_sioctl_get_lifsrcof: no ipif for ifindex %d\n",
7510 ifindex));
7511 return (ENXIO);
7512 }
7513
7514 /* Allocate a buffer to hold requested information */
7515 numlifs = ip_get_lifsrcofnum(ipif->ipif_ill);
7516 lifs_bufsize = numlifs * sizeof (struct lifreq);
7517 lifsmaxlen = STRUCT_FGET(lifs, lifs_maxlen);
7518 /* The actual size needed is always returned in lifs_len */
7519 STRUCT_FSET(lifs, lifs_len, lifs_bufsize);
7520
7521 /* If the amount we need is more than what is passed in, abort */
7522 if (lifs_bufsize > lifsmaxlen || lifs_bufsize == 0) {
7523 ipif_refrele(ipif);
7524 return (0);
7525 }
7526
7527 mp1 = mi_copyout_alloc(q, mp,
7528 STRUCT_FGETP(lifs, lifs_buf), lifs_bufsize, B_FALSE);
7529 if (mp1 == NULL) {
7530 ipif_refrele(ipif);
7531 return (ENOMEM);
7532 }
7533
7534 mp1->b_wptr = mp1->b_rptr + lifs_bufsize;
7535 bzero(mp1->b_rptr, lifs_bufsize);
7536
7537 lifr = (struct lifreq *)mp1->b_rptr;
7538
7539 ill = ill_head = ipif->ipif_ill;
7540 orig_ipif = ipif;
7541
7542 /* ill_g_usesrc_lock protects ill_usesrc_grp_next */
7543 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_READER);
7544 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7545
7546 ill = ill->ill_usesrc_grp_next; /* start from next ill */
7547 for (; (ill != NULL) && (ill != ill_head);
7548 ill = ill->ill_usesrc_grp_next) {
7549
7550 if ((uchar_t *)&lifr[1] > mp1->b_wptr)
7551 break;
7552
7553 ipif = ill->ill_ipif;
7554 ipif_get_name(ipif, lifr->lifr_name, sizeof (lifr->lifr_name));
7555 if (ipif->ipif_isv6) {
7556 sin6 = (sin6_t *)&lifr->lifr_addr;
7557 *sin6 = sin6_null;
7558 sin6->sin6_family = AF_INET6;
7559 sin6->sin6_addr = ipif->ipif_v6lcl_addr;
7560 lifr->lifr_addrlen = ip_mask_to_plen_v6(
7561 &ipif->ipif_v6net_mask);
7562 } else {
7563 sin = (sin_t *)&lifr->lifr_addr;
7564 *sin = sin_null;
7565 sin->sin_family = AF_INET;
7566 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
7567 lifr->lifr_addrlen = ip_mask_to_plen(
7568 ipif->ipif_net_mask);
7569 }
7570 lifr++;
7571 }
7572 rw_exit(&ipst->ips_ill_g_lock);
7573 rw_exit(&ipst->ips_ill_g_usesrc_lock);
7574 ipif_refrele(orig_ipif);
7575 mp1->b_wptr = (uchar_t *)lifr;
7576 STRUCT_FSET(lifs, lifs_len, (int)((uchar_t *)lifr - mp1->b_rptr));
7577
7578 return (0);
7579 }
7580
7581 /* ARGSUSED */
7582 int
7583 ip_sioctl_get_lifconf(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7584 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7585 {
7586 mblk_t *mp1;
7587 int list;
7588 ill_t *ill;
7589 ipif_t *ipif;
7590 int flags;
7591 int numlifs = 0;
7592 size_t lifc_bufsize;
7593 struct lifreq *lifr;
7594 sa_family_t family;
7595 struct sockaddr_in *sin;
7596 struct sockaddr_in6 *sin6;
7597 ill_walk_context_t ctx;
7598 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7599 int32_t lifclen;
7600 zoneid_t zoneid;
7601 STRUCT_HANDLE(lifconf, lifc);
7602 ip_stack_t *ipst = CONNQ_TO_IPST(q);
7603
7604 ip1dbg(("ip_sioctl_get_lifconf"));
7605
7606 ASSERT(q->q_next == NULL);
7607
7608 zoneid = Q_TO_CONN(q)->conn_zoneid;
7609
7610 /* Existence verified in ip_wput_nondata */
7611 mp1 = mp->b_cont->b_cont;
7612
7613 /*
7614 * An extended version of SIOCGIFCONF that takes an
7615 * additional address family and flags field.
7616 * AF_UNSPEC retrieve both IPv4 and IPv6.
7617 * Unless LIFC_NOXMIT is specified the IPIF_NOXMIT
7618 * interfaces are omitted.
7619 * Similarly, IPIF_TEMPORARY interfaces are omitted
7620 * unless LIFC_TEMPORARY is specified.
7621 * If LIFC_EXTERNAL_SOURCE is specified, IPIF_NOXMIT,
7622 * IPIF_NOLOCAL, PHYI_LOOPBACK, IPIF_DEPRECATED and
7623 * not IPIF_UP interfaces are omitted. LIFC_EXTERNAL_SOURCE
7624 * has priority over LIFC_NOXMIT.
7625 */
7626 STRUCT_SET_HANDLE(lifc, iocp->ioc_flag, NULL);
7627
7628 if ((mp1->b_wptr - mp1->b_rptr) != STRUCT_SIZE(lifc))
7629 return (EINVAL);
7630
7631 /*
7632 * Must be (better be!) continuation of a TRANSPARENT
7633 * IOCTL. We just copied in the lifconf structure.
7634 */
7635 STRUCT_SET_HANDLE(lifc, iocp->ioc_flag, (struct lifconf *)mp1->b_rptr);
7636
7637 family = STRUCT_FGET(lifc, lifc_family);
7638 flags = STRUCT_FGET(lifc, lifc_flags);
7639
7640 switch (family) {
7641 case AF_UNSPEC:
7642 /*
7643 * walk all ILL's.
7644 */
7645 list = MAX_G_HEADS;
7646 break;
7647 case AF_INET:
7648 /*
7649 * walk only IPV4 ILL's.
7650 */
7651 list = IP_V4_G_HEAD;
7652 break;
7653 case AF_INET6:
7654 /*
7655 * walk only IPV6 ILL's.
7656 */
7657 list = IP_V6_G_HEAD;
7658 break;
7659 default:
7660 return (EAFNOSUPPORT);
7661 }
7662
7663 /*
7664 * Allocate a buffer to hold requested information.
7665 *
7666 * If lifc_len is larger than what is needed, we only
7667 * allocate what we will use.
7668 *
7669 * If lifc_len is smaller than what is needed, return
7670 * EINVAL.
7671 */
7672 numlifs = ip_get_numlifs(family, flags, zoneid, ipst);
7673 lifc_bufsize = numlifs * sizeof (struct lifreq);
7674 lifclen = STRUCT_FGET(lifc, lifc_len);
7675 if (lifc_bufsize > lifclen) {
7676 if (iocp->ioc_cmd == O_SIOCGLIFCONF)
7677 return (EINVAL);
7678 else
7679 lifc_bufsize = lifclen;
7680 }
7681
7682 mp1 = mi_copyout_alloc(q, mp,
7683 STRUCT_FGETP(lifc, lifc_buf), lifc_bufsize, B_FALSE);
7684 if (mp1 == NULL)
7685 return (ENOMEM);
7686
7687 mp1->b_wptr = mp1->b_rptr + lifc_bufsize;
7688 bzero(mp1->b_rptr, mp1->b_wptr - mp1->b_rptr);
7689
7690 lifr = (struct lifreq *)mp1->b_rptr;
7691
7692 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7693 ill = ill_first(list, list, &ctx, ipst);
7694 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7695 if (IS_UNDER_IPMP(ill) && !(flags & LIFC_UNDER_IPMP))
7696 continue;
7697
7698 for (ipif = ill->ill_ipif; ipif != NULL;
7699 ipif = ipif->ipif_next) {
7700 if ((ipif->ipif_flags & IPIF_NOXMIT) &&
7701 !(flags & LIFC_NOXMIT))
7702 continue;
7703
7704 if ((ipif->ipif_flags & IPIF_TEMPORARY) &&
7705 !(flags & LIFC_TEMPORARY))
7706 continue;
7707
7708 if (((ipif->ipif_flags &
7709 (IPIF_NOXMIT|IPIF_NOLOCAL|
7710 IPIF_DEPRECATED)) ||
7711 IS_LOOPBACK(ill) ||
7712 !(ipif->ipif_flags & IPIF_UP)) &&
7713 (flags & LIFC_EXTERNAL_SOURCE))
7714 continue;
7715
7716 if (zoneid != ipif->ipif_zoneid &&
7717 ipif->ipif_zoneid != ALL_ZONES &&
7718 (zoneid != GLOBAL_ZONEID ||
7719 !(flags & LIFC_ALLZONES)))
7720 continue;
7721
7722 if ((uchar_t *)&lifr[1] > mp1->b_wptr) {
7723 if (iocp->ioc_cmd == O_SIOCGLIFCONF) {
7724 rw_exit(&ipst->ips_ill_g_lock);
7725 return (EINVAL);
7726 } else {
7727 goto lif_copydone;
7728 }
7729 }
7730
7731 ipif_get_name(ipif, lifr->lifr_name,
7732 sizeof (lifr->lifr_name));
7733 lifr->lifr_type = ill->ill_type;
7734 if (ipif->ipif_isv6) {
7735 sin6 = (sin6_t *)&lifr->lifr_addr;
7736 *sin6 = sin6_null;
7737 sin6->sin6_family = AF_INET6;
7738 sin6->sin6_addr =
7739 ipif->ipif_v6lcl_addr;
7740 lifr->lifr_addrlen =
7741 ip_mask_to_plen_v6(
7742 &ipif->ipif_v6net_mask);
7743 } else {
7744 sin = (sin_t *)&lifr->lifr_addr;
7745 *sin = sin_null;
7746 sin->sin_family = AF_INET;
7747 sin->sin_addr.s_addr =
7748 ipif->ipif_lcl_addr;
7749 lifr->lifr_addrlen =
7750 ip_mask_to_plen(
7751 ipif->ipif_net_mask);
7752 }
7753 lifr++;
7754 }
7755 }
7756 lif_copydone:
7757 rw_exit(&ipst->ips_ill_g_lock);
7758
7759 mp1->b_wptr = (uchar_t *)lifr;
7760 if (STRUCT_BUF(lifc) != NULL) {
7761 STRUCT_FSET(lifc, lifc_len,
7762 (int)((uchar_t *)lifr - mp1->b_rptr));
7763 }
7764 return (0);
7765 }
7766
7767 static void
7768 ip_sioctl_ip6addrpolicy(queue_t *q, mblk_t *mp)
7769 {
7770 ip6_asp_t *table;
7771 size_t table_size;
7772 mblk_t *data_mp;
7773 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7774 ip_stack_t *ipst;
7775
7776 if (q->q_next == NULL)
7777 ipst = CONNQ_TO_IPST(q);
7778 else
7779 ipst = ILLQ_TO_IPST(q);
7780
7781 /* These two ioctls are I_STR only */
7782 if (iocp->ioc_count == TRANSPARENT) {
7783 miocnak(q, mp, 0, EINVAL);
7784 return;
7785 }
7786
7787 data_mp = mp->b_cont;
7788 if (data_mp == NULL) {
7789 /* The user passed us a NULL argument */
7790 table = NULL;
7791 table_size = iocp->ioc_count;
7792 } else {
7793 /*
7794 * The user provided a table. The stream head
7795 * may have copied in the user data in chunks,
7796 * so make sure everything is pulled up
7797 * properly.
7798 */
7799 if (MBLKL(data_mp) < iocp->ioc_count) {
7800 mblk_t *new_data_mp;
7801 if ((new_data_mp = msgpullup(data_mp, -1)) ==
7802 NULL) {
7803 miocnak(q, mp, 0, ENOMEM);
7804 return;
7805 }
7806 freemsg(data_mp);
7807 data_mp = new_data_mp;
7808 mp->b_cont = data_mp;
7809 }
7810 table = (ip6_asp_t *)data_mp->b_rptr;
7811 table_size = iocp->ioc_count;
7812 }
7813
7814 switch (iocp->ioc_cmd) {
7815 case SIOCGIP6ADDRPOLICY:
7816 iocp->ioc_rval = ip6_asp_get(table, table_size, ipst);
7817 if (iocp->ioc_rval == -1)
7818 iocp->ioc_error = EINVAL;
7819 #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4
7820 else if (table != NULL &&
7821 (iocp->ioc_flag & IOC_MODELS) == IOC_ILP32) {
7822 ip6_asp_t *src = table;
7823 ip6_asp32_t *dst = (void *)table;
7824 int count = table_size / sizeof (ip6_asp_t);
7825 int i;
7826
7827 /*
7828 * We need to do an in-place shrink of the array
7829 * to match the alignment attributes of the
7830 * 32-bit ABI looking at it.
7831 */
7832 /* LINTED: logical expression always true: op "||" */
7833 ASSERT(sizeof (*src) > sizeof (*dst));
7834 for (i = 1; i < count; i++)
7835 bcopy(src + i, dst + i, sizeof (*dst));
7836 }
7837 #endif
7838 break;
7839
7840 case SIOCSIP6ADDRPOLICY:
7841 ASSERT(mp->b_prev == NULL);
7842 mp->b_prev = (void *)q;
7843 #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4
7844 /*
7845 * We pass in the datamodel here so that the ip6_asp_replace()
7846 * routine can handle converting from 32-bit to native formats
7847 * where necessary.
7848 *
7849 * A better way to handle this might be to convert the inbound
7850 * data structure here, and hang it off a new 'mp'; thus the
7851 * ip6_asp_replace() logic would always be dealing with native
7852 * format data structures..
7853 *
7854 * (An even simpler way to handle these ioctls is to just
7855 * add a 32-bit trailing 'pad' field to the ip6_asp_t structure
7856 * and just recompile everything that depends on it.)
7857 */
7858 #endif
7859 ip6_asp_replace(mp, table, table_size, B_FALSE, ipst,
7860 iocp->ioc_flag & IOC_MODELS);
7861 return;
7862 }
7863
7864 DB_TYPE(mp) = (iocp->ioc_error == 0) ? M_IOCACK : M_IOCNAK;
7865 qreply(q, mp);
7866 }
7867
7868 static void
7869 ip_sioctl_dstinfo(queue_t *q, mblk_t *mp)
7870 {
7871 mblk_t *data_mp;
7872 struct dstinforeq *dir;
7873 uint8_t *end, *cur;
7874 in6_addr_t *daddr, *saddr;
7875 ipaddr_t v4daddr;
7876 ire_t *ire;
7877 ipaddr_t v4setsrc;
7878 in6_addr_t v6setsrc;
7879 char *slabel, *dlabel;
7880 boolean_t isipv4;
7881 int match_ire;
7882 ill_t *dst_ill;
7883 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7884 conn_t *connp = Q_TO_CONN(q);
7885 zoneid_t zoneid = IPCL_ZONEID(connp);
7886 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
7887 uint64_t ipif_flags;
7888
7889 ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */
7890
7891 /*
7892 * This ioctl is I_STR only, and must have a
7893 * data mblk following the M_IOCTL mblk.
7894 */
7895 data_mp = mp->b_cont;
7896 if (iocp->ioc_count == TRANSPARENT || data_mp == NULL) {
7897 miocnak(q, mp, 0, EINVAL);
7898 return;
7899 }
7900
7901 if (MBLKL(data_mp) < iocp->ioc_count) {
7902 mblk_t *new_data_mp;
7903
7904 if ((new_data_mp = msgpullup(data_mp, -1)) == NULL) {
7905 miocnak(q, mp, 0, ENOMEM);
7906 return;
7907 }
7908 freemsg(data_mp);
7909 data_mp = new_data_mp;
7910 mp->b_cont = data_mp;
7911 }
7912 match_ire = MATCH_IRE_DSTONLY;
7913
7914 for (cur = data_mp->b_rptr, end = data_mp->b_wptr;
7915 end - cur >= sizeof (struct dstinforeq);
7916 cur += sizeof (struct dstinforeq)) {
7917 dir = (struct dstinforeq *)cur;
7918 daddr = &dir->dir_daddr;
7919 saddr = &dir->dir_saddr;
7920
7921 /*
7922 * ip_addr_scope_v6() and ip6_asp_lookup() handle
7923 * v4 mapped addresses; ire_ftable_lookup_v6()
7924 * and ip_select_source_v6() do not.
7925 */
7926 dir->dir_dscope = ip_addr_scope_v6(daddr);
7927 dlabel = ip6_asp_lookup(daddr, &dir->dir_precedence, ipst);
7928
7929 isipv4 = IN6_IS_ADDR_V4MAPPED(daddr);
7930 if (isipv4) {
7931 IN6_V4MAPPED_TO_IPADDR(daddr, v4daddr);
7932 v4setsrc = INADDR_ANY;
7933 ire = ire_route_recursive_v4(v4daddr, 0, NULL, zoneid,
7934 NULL, match_ire, IRR_ALLOCATE, 0, ipst, &v4setsrc,
7935 NULL, NULL);
7936 } else {
7937 v6setsrc = ipv6_all_zeros;
7938 ire = ire_route_recursive_v6(daddr, 0, NULL, zoneid,
7939 NULL, match_ire, IRR_ALLOCATE, 0, ipst, &v6setsrc,
7940 NULL, NULL);
7941 }
7942 ASSERT(ire != NULL);
7943 if (ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
7944 ire_refrele(ire);
7945 dir->dir_dreachable = 0;
7946
7947 /* move on to next dst addr */
7948 continue;
7949 }
7950 dir->dir_dreachable = 1;
7951
7952 dst_ill = ire_nexthop_ill(ire);
7953 if (dst_ill == NULL) {
7954 ire_refrele(ire);
7955 continue;
7956 }
7957
7958 /* With ipmp we most likely look at the ipmp ill here */
7959 dir->dir_dmactype = dst_ill->ill_mactype;
7960
7961 if (isipv4) {
7962 ipaddr_t v4saddr;
7963
7964 if (ip_select_source_v4(dst_ill, v4setsrc, v4daddr,
7965 connp->conn_ixa->ixa_multicast_ifaddr, zoneid, ipst,
7966 &v4saddr, NULL, &ipif_flags) != 0) {
7967 v4saddr = INADDR_ANY;
7968 ipif_flags = 0;
7969 }
7970 IN6_IPADDR_TO_V4MAPPED(v4saddr, saddr);
7971 } else {
7972 if (ip_select_source_v6(dst_ill, &v6setsrc, daddr,
7973 zoneid, ipst, B_FALSE, IPV6_PREFER_SRC_DEFAULT,
7974 saddr, NULL, &ipif_flags) != 0) {
7975 *saddr = ipv6_all_zeros;
7976 ipif_flags = 0;
7977 }
7978 }
7979
7980 dir->dir_sscope = ip_addr_scope_v6(saddr);
7981 slabel = ip6_asp_lookup(saddr, NULL, ipst);
7982 dir->dir_labelmatch = ip6_asp_labelcmp(dlabel, slabel);
7983 dir->dir_sdeprecated = (ipif_flags & IPIF_DEPRECATED) ? 1 : 0;
7984 ire_refrele(ire);
7985 ill_refrele(dst_ill);
7986 }
7987 miocack(q, mp, iocp->ioc_count, 0);
7988 }
7989
7990 /*
7991 * Check if this is an address assigned to this machine.
7992 * Skips interfaces that are down by using ire checks.
7993 * Translates mapped addresses to v4 addresses and then
7994 * treats them as such, returning true if the v4 address
7995 * associated with this mapped address is configured.
7996 * Note: Applications will have to be careful what they do
7997 * with the response; use of mapped addresses limits
7998 * what can be done with the socket, especially with
7999 * respect to socket options and ioctls - neither IPv4
8000 * options nor IPv6 sticky options/ancillary data options
8001 * may be used.
8002 */
8003 /* ARGSUSED */
8004 int
8005 ip_sioctl_tmyaddr(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
8006 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
8007 {
8008 struct sioc_addrreq *sia;
8009 sin_t *sin;
8010 ire_t *ire;
8011 mblk_t *mp1;
8012 zoneid_t zoneid;
8013 ip_stack_t *ipst;
8014
8015 ip1dbg(("ip_sioctl_tmyaddr"));
8016
8017 ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */
8018 zoneid = Q_TO_CONN(q)->conn_zoneid;
8019 ipst = CONNQ_TO_IPST(q);
8020
8021 /* Existence verified in ip_wput_nondata */
8022 mp1 = mp->b_cont->b_cont;
8023 sia = (struct sioc_addrreq *)mp1->b_rptr;
8024 sin = (sin_t *)&sia->sa_addr;
8025 switch (sin->sin_family) {
8026 case AF_INET6: {
8027 sin6_t *sin6 = (sin6_t *)sin;
8028
8029 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
8030 ipaddr_t v4_addr;
8031
8032 IN6_V4MAPPED_TO_IPADDR(&sin6->sin6_addr,
8033 v4_addr);
8034 ire = ire_ftable_lookup_v4(v4_addr, 0, 0,
8035 IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, NULL,
8036 MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY, 0, ipst, NULL);
8037 } else {
8038 in6_addr_t v6addr;
8039
8040 v6addr = sin6->sin6_addr;
8041 ire = ire_ftable_lookup_v6(&v6addr, 0, 0,
8042 IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, NULL,
8043 MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY, 0, ipst, NULL);
8044 }
8045 break;
8046 }
8047 case AF_INET: {
8048 ipaddr_t v4addr;
8049
8050 v4addr = sin->sin_addr.s_addr;
8051 ire = ire_ftable_lookup_v4(v4addr, 0, 0,
8052 IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid,
8053 NULL, MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY, 0, ipst, NULL);
8054 break;
8055 }
8056 default:
8057 return (EAFNOSUPPORT);
8058 }
8059 if (ire != NULL) {
8060 sia->sa_res = 1;
8061 ire_refrele(ire);
8062 } else {
8063 sia->sa_res = 0;
8064 }
8065 return (0);
8066 }
8067
8068 /*
8069 * Check if this is an address assigned on-link i.e. neighbor,
8070 * and makes sure it's reachable from the current zone.
8071 * Returns true for my addresses as well.
8072 * Translates mapped addresses to v4 addresses and then
8073 * treats them as such, returning true if the v4 address
8074 * associated with this mapped address is configured.
8075 * Note: Applications will have to be careful what they do
8076 * with the response; use of mapped addresses limits
8077 * what can be done with the socket, especially with
8078 * respect to socket options and ioctls - neither IPv4
8079 * options nor IPv6 sticky options/ancillary data options
8080 * may be used.
8081 */
8082 /* ARGSUSED */
8083 int
8084 ip_sioctl_tonlink(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
8085 ip_ioctl_cmd_t *ipip, void *duymmy_ifreq)
8086 {
8087 struct sioc_addrreq *sia;
8088 sin_t *sin;
8089 mblk_t *mp1;
8090 ire_t *ire = NULL;
8091 zoneid_t zoneid;
8092 ip_stack_t *ipst;
8093
8094 ip1dbg(("ip_sioctl_tonlink"));
8095
8096 ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */
8097 zoneid = Q_TO_CONN(q)->conn_zoneid;
8098 ipst = CONNQ_TO_IPST(q);
8099
8100 /* Existence verified in ip_wput_nondata */
8101 mp1 = mp->b_cont->b_cont;
8102 sia = (struct sioc_addrreq *)mp1->b_rptr;
8103 sin = (sin_t *)&sia->sa_addr;
8104
8105 /*
8106 * We check for IRE_ONLINK and exclude IRE_BROADCAST|IRE_MULTICAST
8107 * to make sure we only look at on-link unicast address.
8108 */
8109 switch (sin->sin_family) {
8110 case AF_INET6: {
8111 sin6_t *sin6 = (sin6_t *)sin;
8112
8113 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
8114 ipaddr_t v4_addr;
8115
8116 IN6_V4MAPPED_TO_IPADDR(&sin6->sin6_addr,
8117 v4_addr);
8118 if (!CLASSD(v4_addr)) {
8119 ire = ire_ftable_lookup_v4(v4_addr, 0, 0, 0,
8120 NULL, zoneid, NULL, MATCH_IRE_DSTONLY,
8121 0, ipst, NULL);
8122 }
8123 } else {
8124 in6_addr_t v6addr;
8125
8126 v6addr = sin6->sin6_addr;
8127 if (!IN6_IS_ADDR_MULTICAST(&v6addr)) {
8128 ire = ire_ftable_lookup_v6(&v6addr, 0, 0, 0,
8129 NULL, zoneid, NULL, MATCH_IRE_DSTONLY, 0,
8130 ipst, NULL);
8131 }
8132 }
8133 break;
8134 }
8135 case AF_INET: {
8136 ipaddr_t v4addr;
8137
8138 v4addr = sin->sin_addr.s_addr;
8139 if (!CLASSD(v4addr)) {
8140 ire = ire_ftable_lookup_v4(v4addr, 0, 0, 0, NULL,
8141 zoneid, NULL, MATCH_IRE_DSTONLY, 0, ipst, NULL);
8142 }
8143 break;
8144 }
8145 default:
8146 return (EAFNOSUPPORT);
8147 }
8148 sia->sa_res = 0;
8149 if (ire != NULL) {
8150 ASSERT(!(ire->ire_type & IRE_MULTICAST));
8151
8152 if ((ire->ire_type & IRE_ONLINK) &&
8153 !(ire->ire_type & IRE_BROADCAST))
8154 sia->sa_res = 1;
8155 ire_refrele(ire);
8156 }
8157 return (0);
8158 }
8159
8160 /*
8161 * TBD: implement when kernel maintaines a list of site prefixes.
8162 */
8163 /* ARGSUSED */
8164 int
8165 ip_sioctl_tmysite(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
8166 ip_ioctl_cmd_t *ipip, void *ifreq)
8167 {
8168 return (ENXIO);
8169 }
8170
8171 /* ARP IOCTLs. */
8172 /* ARGSUSED */
8173 int
8174 ip_sioctl_arp(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
8175 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
8176 {
8177 int err;
8178 ipaddr_t ipaddr;
8179 struct iocblk *iocp;
8180 conn_t *connp;
8181 struct arpreq *ar;
8182 struct xarpreq *xar;
8183 int arp_flags, flags, alength;
8184 uchar_t *lladdr;
8185 ip_stack_t *ipst;
8186 ill_t *ill = ipif->ipif_ill;
8187 ill_t *proxy_ill = NULL;
8188 ipmp_arpent_t *entp = NULL;
8189 boolean_t proxyarp = B_FALSE;
8190 boolean_t if_arp_ioctl = B_FALSE;
8191 ncec_t *ncec = NULL;
8192 nce_t *nce;
8193
8194 ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL);
8195 connp = Q_TO_CONN(q);
8196 ipst = connp->conn_netstack->netstack_ip;
8197 iocp = (struct iocblk *)mp->b_rptr;
8198
8199 if (ipip->ipi_cmd_type == XARP_CMD) {
8200 /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->XARPREQ_MBLK */
8201 xar = (struct xarpreq *)mp->b_cont->b_cont->b_rptr;
8202 ar = NULL;
8203
8204 arp_flags = xar->xarp_flags;
8205 lladdr = (uchar_t *)LLADDR(&xar->xarp_ha);
8206 if_arp_ioctl = (xar->xarp_ha.sdl_nlen != 0);
8207 /*
8208 * Validate against user's link layer address length
8209 * input and name and addr length limits.
8210 */
8211 alength = ill->ill_phys_addr_length;
8212 if (ipip->ipi_cmd == SIOCSXARP) {
8213 if (alength != xar->xarp_ha.sdl_alen ||
8214 (alength + xar->xarp_ha.sdl_nlen >
8215 sizeof (xar->xarp_ha.sdl_data)))
8216 return (EINVAL);
8217 }
8218 } else {
8219 /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->ARPREQ_MBLK */
8220 ar = (struct arpreq *)mp->b_cont->b_cont->b_rptr;
8221 xar = NULL;
8222
8223 arp_flags = ar->arp_flags;
8224 lladdr = (uchar_t *)ar->arp_ha.sa_data;
8225 /*
8226 * Theoretically, the sa_family could tell us what link
8227 * layer type this operation is trying to deal with. By
8228 * common usage AF_UNSPEC means ethernet. We'll assume
8229 * any attempt to use the SIOC?ARP ioctls is for ethernet,
8230 * for now. Our new SIOC*XARP ioctls can be used more
8231 * generally.
8232 *
8233 * If the underlying media happens to have a non 6 byte
8234 * address, arp module will fail set/get, but the del
8235 * operation will succeed.
8236 */
8237 alength = 6;
8238 if ((ipip->ipi_cmd != SIOCDARP) &&
8239 (alength != ill->ill_phys_addr_length)) {
8240 return (EINVAL);
8241 }
8242 }
8243
8244 /* Translate ATF* flags to NCE* flags */
8245 flags = 0;
8246 if (arp_flags & ATF_AUTHORITY)
8247 flags |= NCE_F_AUTHORITY;
8248 if (arp_flags & ATF_PERM)
8249 flags |= NCE_F_NONUD; /* not subject to aging */
8250 if (arp_flags & ATF_PUBL)
8251 flags |= NCE_F_PUBLISH;
8252
8253 /*
8254 * IPMP ARP special handling:
8255 *
8256 * 1. Since ARP mappings must appear consistent across the group,
8257 * prohibit changing ARP mappings on the underlying interfaces.
8258 *
8259 * 2. Since ARP mappings for IPMP data addresses are maintained by
8260 * IP itself, prohibit changing them.
8261 *
8262 * 3. For proxy ARP, use a functioning hardware address in the group,
8263 * provided one exists. If one doesn't, just add the entry as-is;
8264 * ipmp_illgrp_refresh_arpent() will refresh it if things change.
8265 */
8266 if (IS_UNDER_IPMP(ill)) {
8267 if (ipip->ipi_cmd != SIOCGARP && ipip->ipi_cmd != SIOCGXARP)
8268 return (EPERM);
8269 }
8270 if (IS_IPMP(ill)) {
8271 ipmp_illgrp_t *illg = ill->ill_grp;
8272
8273 switch (ipip->ipi_cmd) {
8274 case SIOCSARP:
8275 case SIOCSXARP:
8276 proxy_ill = ipmp_illgrp_find_ill(illg, lladdr, alength);
8277 if (proxy_ill != NULL) {
8278 proxyarp = B_TRUE;
8279 if (!ipmp_ill_is_active(proxy_ill))
8280 proxy_ill = ipmp_illgrp_next_ill(illg);
8281 if (proxy_ill != NULL)
8282 lladdr = proxy_ill->ill_phys_addr;
8283 }
8284 /* FALLTHRU */
8285 }
8286 }
8287
8288 ipaddr = sin->sin_addr.s_addr;
8289 /*
8290 * don't match across illgrp per case (1) and (2).
8291 * XXX use IS_IPMP(ill) like ndp_sioc_update?
8292 */
8293 nce = nce_lookup_v4(ill, &ipaddr);
8294 if (nce != NULL)
8295 ncec = nce->nce_common;
8296
8297 switch (iocp->ioc_cmd) {
8298 case SIOCDARP:
8299 case SIOCDXARP: {
8300 /*
8301 * Delete the NCE if any.
8302 */
8303 if (ncec == NULL) {
8304 iocp->ioc_error = ENXIO;
8305 break;
8306 }
8307 /* Don't allow changes to arp mappings of local addresses. */
8308 if (NCE_MYADDR(ncec)) {
8309 nce_refrele(nce);
8310 return (ENOTSUP);
8311 }
8312 iocp->ioc_error = 0;
8313
8314 /*
8315 * Delete the nce_common which has ncec_ill set to ipmp_ill.
8316 * This will delete all the nce entries on the under_ills.
8317 */
8318 ncec_delete(ncec);
8319 /*
8320 * Once the NCE has been deleted, then the ire_dep* consistency
8321 * mechanism will find any IRE which depended on the now
8322 * condemned NCE (as part of sending packets).
8323 * That mechanism handles redirects by deleting redirects
8324 * that refer to UNREACHABLE nces.
8325 */
8326 break;
8327 }
8328 case SIOCGARP:
8329 case SIOCGXARP:
8330 if (ncec != NULL) {
8331 lladdr = ncec->ncec_lladdr;
8332 flags = ncec->ncec_flags;
8333 iocp->ioc_error = 0;
8334 ip_sioctl_garp_reply(mp, ncec->ncec_ill, lladdr, flags);
8335 } else {
8336 iocp->ioc_error = ENXIO;
8337 }
8338 break;
8339 case SIOCSARP:
8340 case SIOCSXARP:
8341 /* Don't allow changes to arp mappings of local addresses. */
8342 if (ncec != NULL && NCE_MYADDR(ncec)) {
8343 nce_refrele(nce);
8344 return (ENOTSUP);
8345 }
8346
8347 /* static arp entries will undergo NUD if ATF_PERM is not set */
8348 flags |= NCE_F_STATIC;
8349 if (!if_arp_ioctl) {
8350 ip_nce_lookup_and_update(&ipaddr, NULL, ipst,
8351 lladdr, alength, flags);
8352 } else {
8353 ipif_t *ipif = ipif_get_next_ipif(NULL, ill);
8354 if (ipif != NULL) {
8355 ip_nce_lookup_and_update(&ipaddr, ipif, ipst,
8356 lladdr, alength, flags);
8357 ipif_refrele(ipif);
8358 }
8359 }
8360 if (nce != NULL) {
8361 nce_refrele(nce);
8362 nce = NULL;
8363 }
8364 /*
8365 * NCE_F_STATIC entries will be added in state ND_REACHABLE
8366 * by nce_add_common()
8367 */
8368 err = nce_lookup_then_add_v4(ill, lladdr,
8369 ill->ill_phys_addr_length, &ipaddr, flags, ND_UNCHANGED,
8370 &nce);
8371 if (err == EEXIST) {
8372 ncec = nce->nce_common;
8373 mutex_enter(&ncec->ncec_lock);
8374 ncec->ncec_state = ND_REACHABLE;
8375 ncec->ncec_flags = flags;
8376 nce_update(ncec, ND_UNCHANGED, lladdr);
8377 mutex_exit(&ncec->ncec_lock);
8378 err = 0;
8379 }
8380 if (nce != NULL) {
8381 nce_refrele(nce);
8382 nce = NULL;
8383 }
8384 if (IS_IPMP(ill) && err == 0) {
8385 entp = ipmp_illgrp_create_arpent(ill->ill_grp,
8386 proxyarp, ipaddr, lladdr, ill->ill_phys_addr_length,
8387 flags);
8388 if (entp == NULL || (proxyarp && proxy_ill == NULL)) {
8389 iocp->ioc_error = (entp == NULL ? ENOMEM : 0);
8390 break;
8391 }
8392 }
8393 iocp->ioc_error = err;
8394 }
8395
8396 if (nce != NULL) {
8397 nce_refrele(nce);
8398 }
8399
8400 /*
8401 * If we created an IPMP ARP entry, mark that we've notified ARP.
8402 */
8403 if (entp != NULL)
8404 ipmp_illgrp_mark_arpent(ill->ill_grp, entp);
8405
8406 return (iocp->ioc_error);
8407 }
8408
8409 /*
8410 * Parse an [x]arpreq structure coming down SIOC[GSD][X]ARP ioctls, identify
8411 * the associated sin and refhold and return the associated ipif via `ci'.
8412 */
8413 int
8414 ip_extract_arpreq(queue_t *q, mblk_t *mp, const ip_ioctl_cmd_t *ipip,
8415 cmd_info_t *ci)
8416 {
8417 mblk_t *mp1;
8418 sin_t *sin;
8419 conn_t *connp;
8420 ipif_t *ipif;
8421 ire_t *ire = NULL;
8422 ill_t *ill = NULL;
8423 boolean_t exists;
8424 ip_stack_t *ipst;
8425 struct arpreq *ar;
8426 struct xarpreq *xar;
8427 struct sockaddr_dl *sdl;
8428
8429 /* ioctl comes down on a conn */
8430 ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL);
8431 connp = Q_TO_CONN(q);
8432 if (connp->conn_family == AF_INET6)
8433 return (ENXIO);
8434
8435 ipst = connp->conn_netstack->netstack_ip;
8436
8437 /* Verified in ip_wput_nondata */
8438 mp1 = mp->b_cont->b_cont;
8439
8440 if (ipip->ipi_cmd_type == XARP_CMD) {
8441 ASSERT(MBLKL(mp1) >= sizeof (struct xarpreq));
8442 xar = (struct xarpreq *)mp1->b_rptr;
8443 sin = (sin_t *)&xar->xarp_pa;
8444 sdl = &xar->xarp_ha;
8445
8446 if (sdl->sdl_family != AF_LINK || sin->sin_family != AF_INET)
8447 return (ENXIO);
8448 if (sdl->sdl_nlen >= LIFNAMSIZ)
8449 return (EINVAL);
8450 } else {
8451 ASSERT(ipip->ipi_cmd_type == ARP_CMD);
8452 ASSERT(MBLKL(mp1) >= sizeof (struct arpreq));
8453 ar = (struct arpreq *)mp1->b_rptr;
8454 sin = (sin_t *)&ar->arp_pa;
8455 }
8456
8457 if (ipip->ipi_cmd_type == XARP_CMD && sdl->sdl_nlen != 0) {
8458 ipif = ipif_lookup_on_name(sdl->sdl_data, sdl->sdl_nlen,
8459 B_FALSE, &exists, B_FALSE, ALL_ZONES, ipst);
8460 if (ipif == NULL)
8461 return (ENXIO);
8462 if (ipif->ipif_id != 0) {
8463 ipif_refrele(ipif);
8464 return (ENXIO);
8465 }
8466 } else {
8467 /*
8468 * Either an SIOC[DGS]ARP or an SIOC[DGS]XARP with an sdl_nlen
8469 * of 0: use the IP address to find the ipif. If the IP
8470 * address is an IPMP test address, ire_ftable_lookup() will
8471 * find the wrong ill, so we first do an ipif_lookup_addr().
8472 */
8473 ipif = ipif_lookup_addr(sin->sin_addr.s_addr, NULL, ALL_ZONES,
8474 ipst);
8475 if (ipif == NULL) {
8476 ire = ire_ftable_lookup_v4(sin->sin_addr.s_addr,
8477 0, 0, IRE_IF_RESOLVER, NULL, ALL_ZONES,
8478 NULL, MATCH_IRE_TYPE, 0, ipst, NULL);
8479 if (ire == NULL || ((ill = ire->ire_ill) == NULL)) {
8480 if (ire != NULL)
8481 ire_refrele(ire);
8482 return (ENXIO);
8483 }
8484 ASSERT(ire != NULL && ill != NULL);
8485 ipif = ill->ill_ipif;
8486 ipif_refhold(ipif);
8487 ire_refrele(ire);
8488 }
8489 }
8490
8491 if (ipif->ipif_ill->ill_net_type != IRE_IF_RESOLVER) {
8492 ipif_refrele(ipif);
8493 return (ENXIO);
8494 }
8495
8496 ci->ci_sin = sin;
8497 ci->ci_ipif = ipif;
8498 return (0);
8499 }
8500
8501 /*
8502 * Link or unlink the illgrp on IPMP meta-interface `ill' depending on the
8503 * value of `ioccmd'. While an illgrp is linked to an ipmp_grp_t, it is
8504 * accessible from that ipmp_grp_t, which means SIOCSLIFGROUPNAME can look it
8505 * up and thus an ill can join that illgrp.
8506 *
8507 * We use I_PLINK/I_PUNLINK to do the link/unlink operations rather than
8508 * open()/close() primarily because close() is not allowed to fail or block
8509 * forever. On the other hand, I_PUNLINK *can* fail, and there's no reason
8510 * why anyone should ever need to I_PUNLINK an in-use IPMP stream. To ensure
8511 * symmetric behavior (e.g., doing an I_PLINK after and I_PUNLINK undoes the
8512 * I_PUNLINK) we defer linking to I_PLINK. Separately, we also fail attempts
8513 * to I_LINK since I_UNLINK is optional and we'd end up in an inconsistent
8514 * state if I_UNLINK didn't occur.
8515 *
8516 * Note that for each plumb/unplumb operation, we may end up here more than
8517 * once because of the way ifconfig works. However, it's OK to link the same
8518 * illgrp more than once, or unlink an illgrp that's already unlinked.
8519 */
8520 static int
8521 ip_sioctl_plink_ipmp(ill_t *ill, int ioccmd)
8522 {
8523 int err;
8524 ip_stack_t *ipst = ill->ill_ipst;
8525
8526 ASSERT(IS_IPMP(ill));
8527 ASSERT(IAM_WRITER_ILL(ill));
8528
8529 switch (ioccmd) {
8530 case I_LINK:
8531 return (ENOTSUP);
8532
8533 case I_PLINK:
8534 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
8535 ipmp_illgrp_link_grp(ill->ill_grp, ill->ill_phyint->phyint_grp);
8536 rw_exit(&ipst->ips_ipmp_lock);
8537 break;
8538
8539 case I_PUNLINK:
8540 /*
8541 * Require all UP ipifs be brought down prior to unlinking the
8542 * illgrp so any associated IREs (and other state) is torched.
8543 */
8544 if (ill->ill_ipif_up_count + ill->ill_ipif_dup_count > 0)
8545 return (EBUSY);
8546
8547 /*
8548 * NOTE: We hold ipmp_lock across the unlink to prevent a race
8549 * with an SIOCSLIFGROUPNAME request from an ill trying to
8550 * join this group. Specifically: ills trying to join grab
8551 * ipmp_lock and bump a "pending join" counter checked by
8552 * ipmp_illgrp_unlink_grp(). During the unlink no new pending
8553 * joins can occur (since we have ipmp_lock). Once we drop
8554 * ipmp_lock, subsequent SIOCSLIFGROUPNAME requests will not
8555 * find the illgrp (since we unlinked it) and will return
8556 * EAFNOSUPPORT. This will then take them back through the
8557 * IPMP meta-interface plumbing logic in ifconfig, and thus
8558 * back through I_PLINK above.
8559 */
8560 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
8561 err = ipmp_illgrp_unlink_grp(ill->ill_grp);
8562 rw_exit(&ipst->ips_ipmp_lock);
8563 return (err);
8564 default:
8565 break;
8566 }
8567 return (0);
8568 }
8569
8570 /*
8571 * Do I_PLINK/I_LINK or I_PUNLINK/I_UNLINK with consistency checks and also
8572 * atomically set/clear the muxids. Also complete the ioctl by acking or
8573 * naking it. Note that the code is structured such that the link type,
8574 * whether it's persistent or not, is treated equally. ifconfig(1M) and
8575 * its clones use the persistent link, while pppd(1M) and perhaps many
8576 * other daemons may use non-persistent link. When combined with some
8577 * ill_t states, linking and unlinking lower streams may be used as
8578 * indicators of dynamic re-plumbing events [see PSARC/1999/348].
8579 */
8580 /* ARGSUSED */
8581 void
8582 ip_sioctl_plink(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg)
8583 {
8584 mblk_t *mp1;
8585 struct linkblk *li;
8586 int ioccmd = ((struct iocblk *)mp->b_rptr)->ioc_cmd;
8587 int err = 0;
8588
8589 ASSERT(ioccmd == I_PLINK || ioccmd == I_PUNLINK ||
8590 ioccmd == I_LINK || ioccmd == I_UNLINK);
8591
8592 mp1 = mp->b_cont; /* This is the linkblk info */
8593 li = (struct linkblk *)mp1->b_rptr;
8594
8595 err = ip_sioctl_plink_ipmod(ipsq, q, mp, ioccmd, li);
8596 if (err == EINPROGRESS)
8597 return;
8598 if (err == 0)
8599 miocack(q, mp, 0, 0);
8600 else
8601 miocnak(q, mp, 0, err);
8602
8603 /* Conn was refheld in ip_sioctl_copyin_setup */
8604 if (CONN_Q(q)) {
8605 CONN_DEC_IOCTLREF(Q_TO_CONN(q));
8606 CONN_OPER_PENDING_DONE(Q_TO_CONN(q));
8607 }
8608 }
8609
8610 /*
8611 * Process I_{P}LINK and I_{P}UNLINK requests named by `ioccmd' and pointed to
8612 * by `mp' and `li' for the IP module stream (if li->q_bot is in fact an IP
8613 * module stream).
8614 * Returns zero on success, EINPROGRESS if the operation is still pending, or
8615 * an error code on failure.
8616 */
8617 static int
8618 ip_sioctl_plink_ipmod(ipsq_t *ipsq, queue_t *q, mblk_t *mp, int ioccmd,
8619 struct linkblk *li)
8620 {
8621 int err = 0;
8622 ill_t *ill;
8623 queue_t *ipwq, *dwq;
8624 const char *name;
8625 struct qinit *qinfo;
8626 boolean_t islink = (ioccmd == I_PLINK || ioccmd == I_LINK);
8627 boolean_t entered_ipsq = B_FALSE;
8628 boolean_t is_ip = B_FALSE;
8629 arl_t *arl;
8630
8631 /*
8632 * Walk the lower stream to verify it's the IP module stream.
8633 * The IP module is identified by its name, wput function,
8634 * and non-NULL q_next. STREAMS ensures that the lower stream
8635 * (li->l_qbot) will not vanish until this ioctl completes.
8636 */
8637 for (ipwq = li->l_qbot; ipwq != NULL; ipwq = ipwq->q_next) {
8638 qinfo = ipwq->q_qinfo;
8639 name = qinfo->qi_minfo->mi_idname;
8640 if (name != NULL && strcmp(name, ip_mod_info.mi_idname) == 0 &&
8641 qinfo->qi_putp != (pfi_t)ip_lwput && ipwq->q_next != NULL) {
8642 is_ip = B_TRUE;
8643 break;
8644 }
8645 if (name != NULL && strcmp(name, arp_mod_info.mi_idname) == 0 &&
8646 qinfo->qi_putp != (pfi_t)ip_lwput && ipwq->q_next != NULL) {
8647 break;
8648 }
8649 }
8650
8651 /*
8652 * If this isn't an IP module stream, bail.
8653 */
8654 if (ipwq == NULL)
8655 return (0);
8656
8657 if (!is_ip) {
8658 arl = (arl_t *)ipwq->q_ptr;
8659 ill = arl_to_ill(arl);
8660 if (ill == NULL)
8661 return (0);
8662 } else {
8663 ill = ipwq->q_ptr;
8664 }
8665 ASSERT(ill != NULL);
8666
8667 if (ipsq == NULL) {
8668 ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_sioctl_plink,
8669 NEW_OP, B_FALSE);
8670 if (ipsq == NULL) {
8671 if (!is_ip)
8672 ill_refrele(ill);
8673 return (EINPROGRESS);
8674 }
8675 entered_ipsq = B_TRUE;
8676 }
8677 ASSERT(IAM_WRITER_ILL(ill));
8678 mutex_enter(&ill->ill_lock);
8679 if (!is_ip) {
8680 if (islink && ill->ill_muxid == 0) {
8681 /*
8682 * Plumbing has to be done with IP plumbed first, arp
8683 * second, but here we have arp being plumbed first.
8684 */
8685 mutex_exit(&ill->ill_lock);
8686 if (entered_ipsq)
8687 ipsq_exit(ipsq);
8688 ill_refrele(ill);
8689 return (EINVAL);
8690 }
8691 }
8692 mutex_exit(&ill->ill_lock);
8693 if (!is_ip) {
8694 arl->arl_muxid = islink ? li->l_index : 0;
8695 ill_refrele(ill);
8696 goto done;
8697 }
8698
8699 if (IS_IPMP(ill) && (err = ip_sioctl_plink_ipmp(ill, ioccmd)) != 0)
8700 goto done;
8701
8702 /*
8703 * As part of I_{P}LINKing, stash the number of downstream modules and
8704 * the read queue of the module immediately below IP in the ill.
8705 * These are used during the capability negotiation below.
8706 */
8707 ill->ill_lmod_rq = NULL;
8708 ill->ill_lmod_cnt = 0;
8709 if (islink && ((dwq = ipwq->q_next) != NULL)) {
8710 ill->ill_lmod_rq = RD(dwq);
8711 for (; dwq != NULL; dwq = dwq->q_next)
8712 ill->ill_lmod_cnt++;
8713 }
8714
8715 ill->ill_muxid = islink ? li->l_index : 0;
8716
8717 /*
8718 * Mark the ipsq busy until the capability operations initiated below
8719 * complete. The PLINK/UNLINK ioctl itself completes when our caller
8720 * returns, but the capability operation may complete asynchronously
8721 * much later.
8722 */
8723 ipsq_current_start(ipsq, ill->ill_ipif, ioccmd);
8724 /*
8725 * If there's at least one up ipif on this ill, then we're bound to
8726 * the underlying driver via DLPI. In that case, renegotiate
8727 * capabilities to account for any possible change in modules
8728 * interposed between IP and the driver.
8729 */
8730 if (ill->ill_ipif_up_count > 0) {
8731 if (islink)
8732 ill_capability_probe(ill);
8733 else
8734 ill_capability_reset(ill, B_FALSE);
8735 }
8736 ipsq_current_finish(ipsq);
8737 done:
8738 if (entered_ipsq)
8739 ipsq_exit(ipsq);
8740
8741 return (err);
8742 }
8743
8744 /*
8745 * Search the ioctl command in the ioctl tables and return a pointer
8746 * to the ioctl command information. The ioctl command tables are
8747 * static and fully populated at compile time.
8748 */
8749 ip_ioctl_cmd_t *
8750 ip_sioctl_lookup(int ioc_cmd)
8751 {
8752 int index;
8753 ip_ioctl_cmd_t *ipip;
8754 ip_ioctl_cmd_t *ipip_end;
8755
8756 if (ioc_cmd == IPI_DONTCARE)
8757 return (NULL);
8758
8759 /*
8760 * Do a 2 step search. First search the indexed table
8761 * based on the least significant byte of the ioctl cmd.
8762 * If we don't find a match, then search the misc table
8763 * serially.
8764 */
8765 index = ioc_cmd & 0xFF;
8766 if (index < ip_ndx_ioctl_count) {
8767 ipip = &ip_ndx_ioctl_table[index];
8768 if (ipip->ipi_cmd == ioc_cmd) {
8769 /* Found a match in the ndx table */
8770 return (ipip);
8771 }
8772 }
8773
8774 /* Search the misc table */
8775 ipip_end = &ip_misc_ioctl_table[ip_misc_ioctl_count];
8776 for (ipip = ip_misc_ioctl_table; ipip < ipip_end; ipip++) {
8777 if (ipip->ipi_cmd == ioc_cmd)
8778 /* Found a match in the misc table */
8779 return (ipip);
8780 }
8781
8782 return (NULL);
8783 }
8784
8785 /*
8786 * helper function for ip_sioctl_getsetprop(), which does some sanity checks
8787 */
8788 static boolean_t
8789 getset_ioctl_checks(mblk_t *mp)
8790 {
8791 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
8792 mblk_t *mp1 = mp->b_cont;
8793 mod_ioc_prop_t *pioc;
8794 uint_t flags;
8795 uint_t pioc_size;
8796
8797 /* do sanity checks on various arguments */
8798 if (mp1 == NULL || iocp->ioc_count == 0 ||
8799 iocp->ioc_count == TRANSPARENT) {
8800 return (B_FALSE);
8801 }
8802 if (msgdsize(mp1) < iocp->ioc_count) {
8803 if (!pullupmsg(mp1, iocp->ioc_count))
8804 return (B_FALSE);
8805 }
8806
8807 pioc = (mod_ioc_prop_t *)mp1->b_rptr;
8808
8809 /* sanity checks on mpr_valsize */
8810 pioc_size = sizeof (mod_ioc_prop_t);
8811 if (pioc->mpr_valsize != 0)
8812 pioc_size += pioc->mpr_valsize - 1;
8813
8814 if (iocp->ioc_count != pioc_size)
8815 return (B_FALSE);
8816
8817 flags = pioc->mpr_flags;
8818 if (iocp->ioc_cmd == SIOCSETPROP) {
8819 /*
8820 * One can either reset the value to it's default value or
8821 * change the current value or append/remove the value from
8822 * a multi-valued properties.
8823 */
8824 if ((flags & MOD_PROP_DEFAULT) != MOD_PROP_DEFAULT &&
8825 flags != MOD_PROP_ACTIVE &&
8826 flags != (MOD_PROP_ACTIVE|MOD_PROP_APPEND) &&
8827 flags != (MOD_PROP_ACTIVE|MOD_PROP_REMOVE))
8828 return (B_FALSE);
8829 } else {
8830 ASSERT(iocp->ioc_cmd == SIOCGETPROP);
8831
8832 /*
8833 * One can retrieve only one kind of property information
8834 * at a time.
8835 */
8836 if ((flags & MOD_PROP_ACTIVE) != MOD_PROP_ACTIVE &&
8837 (flags & MOD_PROP_DEFAULT) != MOD_PROP_DEFAULT &&
8838 (flags & MOD_PROP_POSSIBLE) != MOD_PROP_POSSIBLE &&
8839 (flags & MOD_PROP_PERM) != MOD_PROP_PERM)
8840 return (B_FALSE);
8841 }
8842
8843 return (B_TRUE);
8844 }
8845
8846 /*
8847 * process the SIOC{SET|GET}PROP ioctl's
8848 */
8849 /* ARGSUSED */
8850 static void
8851 ip_sioctl_getsetprop(queue_t *q, mblk_t *mp)
8852 {
8853 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
8854 mblk_t *mp1 = mp->b_cont;
8855 mod_ioc_prop_t *pioc;
8856 mod_prop_info_t *ptbl = NULL, *pinfo = NULL;
8857 ip_stack_t *ipst;
8858 icmp_stack_t *is;
8859 tcp_stack_t *tcps;
8860 sctp_stack_t *sctps;
8861 dccp_stack_t *dccps;
8862 udp_stack_t *us;
8863 netstack_t *stack;
8864 void *cbarg;
8865 cred_t *cr;
8866 boolean_t set;
8867 int err;
8868
8869 ASSERT(q->q_next == NULL);
8870 ASSERT(CONN_Q(q));
8871
8872 if (!getset_ioctl_checks(mp)) {
8873 miocnak(q, mp, 0, EINVAL);
8874 return;
8875 }
8876 ipst = CONNQ_TO_IPST(q);
8877 stack = ipst->ips_netstack;
8878 pioc = (mod_ioc_prop_t *)mp1->b_rptr;
8879
8880 switch (pioc->mpr_proto) {
8881 case MOD_PROTO_IP:
8882 case MOD_PROTO_IPV4:
8883 case MOD_PROTO_IPV6:
8884 ptbl = ipst->ips_propinfo_tbl;
8885 cbarg = ipst;
8886 break;
8887 case MOD_PROTO_RAWIP:
8888 is = stack->netstack_icmp;
8889 ptbl = is->is_propinfo_tbl;
8890 cbarg = is;
8891 break;
8892 case MOD_PROTO_TCP:
8893 tcps = stack->netstack_tcp;
8894 ptbl = tcps->tcps_propinfo_tbl;
8895 cbarg = tcps;
8896 break;
8897 case MOD_PROTO_UDP:
8898 us = stack->netstack_udp;
8899 ptbl = us->us_propinfo_tbl;
8900 cbarg = us;
8901 break;
8902 case MOD_PROTO_SCTP:
8903 sctps = stack->netstack_sctp;
8904 ptbl = sctps->sctps_propinfo_tbl;
8905 cbarg = sctps;
8906 break;
8907 case MOD_PROTO_DCCP:
8908 dccps = stack->netstack_dccp;
8909 ptbl = dccps->dccps_propinfo_tbl;
8910 cbarg = dccps;
8911 default:
8912 miocnak(q, mp, 0, EINVAL);
8913 return;
8914 }
8915
8916 /* search for given property in respective protocol propinfo table */
8917 for (pinfo = ptbl; pinfo->mpi_name != NULL; pinfo++) {
8918 if (strcmp(pinfo->mpi_name, pioc->mpr_name) == 0 &&
8919 pinfo->mpi_proto == pioc->mpr_proto)
8920 break;
8921 }
8922 if (pinfo->mpi_name == NULL) {
8923 miocnak(q, mp, 0, ENOENT);
8924 return;
8925 }
8926
8927 set = (iocp->ioc_cmd == SIOCSETPROP) ? B_TRUE : B_FALSE;
8928 if (set && pinfo->mpi_setf != NULL) {
8929 cr = msg_getcred(mp, NULL);
8930 if (cr == NULL)
8931 cr = iocp->ioc_cr;
8932 err = pinfo->mpi_setf(cbarg, cr, pinfo, pioc->mpr_ifname,
8933 pioc->mpr_val, pioc->mpr_flags);
8934 } else if (!set && pinfo->mpi_getf != NULL) {
8935 err = pinfo->mpi_getf(cbarg, pinfo, pioc->mpr_ifname,
8936 pioc->mpr_val, pioc->mpr_valsize, pioc->mpr_flags);
8937 } else {
8938 err = EPERM;
8939 }
8940
8941 if (err != 0) {
8942 miocnak(q, mp, 0, err);
8943 } else {
8944 if (set)
8945 miocack(q, mp, 0, 0);
8946 else /* For get, we need to return back the data */
8947 miocack(q, mp, iocp->ioc_count, 0);
8948 }
8949 }
8950
8951 /*
8952 * process the legacy ND_GET, ND_SET ioctl just for {ip|ip6}_forwarding
8953 * as several routing daemons have unfortunately used this 'unpublished'
8954 * but well-known ioctls.
8955 */
8956 /* ARGSUSED */
8957 static void
8958 ip_process_legacy_nddprop(queue_t *q, mblk_t *mp)
8959 {
8960 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
8961 mblk_t *mp1 = mp->b_cont;
8962 char *pname, *pval, *buf;
8963 uint_t bufsize, proto;
8964 mod_prop_info_t *ptbl = NULL, *pinfo = NULL;
8965 ip_stack_t *ipst;
8966 int err = 0;
8967
8968 ASSERT(CONN_Q(q));
8969 ipst = CONNQ_TO_IPST(q);
8970
8971 if (iocp->ioc_count == 0 || mp1 == NULL) {
8972 miocnak(q, mp, 0, EINVAL);
8973 return;
8974 }
8975
8976 mp1->b_datap->db_lim[-1] = '\0'; /* Force null termination */
8977 pval = buf = pname = (char *)mp1->b_rptr;
8978 bufsize = MBLKL(mp1);
8979
8980 if (strcmp(pname, "ip_forwarding") == 0) {
8981 pname = "forwarding";
8982 proto = MOD_PROTO_IPV4;
8983 } else if (strcmp(pname, "ip6_forwarding") == 0) {
8984 pname = "forwarding";
8985 proto = MOD_PROTO_IPV6;
8986 } else {
8987 miocnak(q, mp, 0, EINVAL);
8988 return;
8989 }
8990
8991 ptbl = ipst->ips_propinfo_tbl;
8992 for (pinfo = ptbl; pinfo->mpi_name != NULL; pinfo++) {
8993 if (strcmp(pinfo->mpi_name, pname) == 0 &&
8994 pinfo->mpi_proto == proto)
8995 break;
8996 }
8997
8998 ASSERT(pinfo->mpi_name != NULL);
8999
9000 switch (iocp->ioc_cmd) {
9001 case ND_GET:
9002 if ((err = pinfo->mpi_getf(ipst, pinfo, NULL, buf, bufsize,
9003 0)) == 0) {
9004 miocack(q, mp, iocp->ioc_count, 0);
9005 return;
9006 }
9007 break;
9008 case ND_SET:
9009 /*
9010 * buffer will have property name and value in the following
9011 * format,
9012 * <property name>'\0'<property value>'\0', extract them;
9013 */
9014 while (*pval++)
9015 noop;
9016
9017 if (!*pval || pval >= (char *)mp1->b_wptr) {
9018 err = EINVAL;
9019 } else if ((err = pinfo->mpi_setf(ipst, NULL, pinfo, NULL,
9020 pval, 0)) == 0) {
9021 miocack(q, mp, 0, 0);
9022 return;
9023 }
9024 break;
9025 default:
9026 err = EINVAL;
9027 break;
9028 }
9029 miocnak(q, mp, 0, err);
9030 }
9031
9032 /*
9033 * Wrapper function for resuming deferred ioctl processing
9034 * Used for SIOCGDSTINFO, SIOCGIP6ADDRPOLICY, SIOCGMSFILTER,
9035 * SIOCSMSFILTER, SIOCGIPMSFILTER, and SIOCSIPMSFILTER currently.
9036 */
9037 /* ARGSUSED */
9038 void
9039 ip_sioctl_copyin_resume(ipsq_t *dummy_ipsq, queue_t *q, mblk_t *mp,
9040 void *dummy_arg)
9041 {
9042 ip_sioctl_copyin_setup(q, mp);
9043 }
9044
9045 /*
9046 * ip_sioctl_copyin_setup is called by ip_wput_nondata with any M_IOCTL message
9047 * that arrives. Most of the IOCTLs are "socket" IOCTLs which we handle
9048 * in either I_STR or TRANSPARENT form, using the mi_copy facility.
9049 * We establish here the size of the block to be copied in. mi_copyin
9050 * arranges for this to happen, an processing continues in ip_wput_nondata with
9051 * an M_IOCDATA message.
9052 */
9053 void
9054 ip_sioctl_copyin_setup(queue_t *q, mblk_t *mp)
9055 {
9056 int copyin_size;
9057 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
9058 ip_ioctl_cmd_t *ipip;
9059 cred_t *cr;
9060 ip_stack_t *ipst;
9061
9062 if (CONN_Q(q))
9063 ipst = CONNQ_TO_IPST(q);
9064 else
9065 ipst = ILLQ_TO_IPST(q);
9066
9067 ipip = ip_sioctl_lookup(iocp->ioc_cmd);
9068 if (ipip == NULL) {
9069 /*
9070 * The ioctl is not one we understand or own.
9071 * Pass it along to be processed down stream,
9072 * if this is a module instance of IP, else nak
9073 * the ioctl.
9074 */
9075 if (q->q_next == NULL) {
9076 goto nak;
9077 } else {
9078 putnext(q, mp);
9079 return;
9080 }
9081 }
9082
9083 /*
9084 * If this is deferred, then we will do all the checks when we
9085 * come back.
9086 */
9087 if ((iocp->ioc_cmd == SIOCGDSTINFO ||
9088 iocp->ioc_cmd == SIOCGIP6ADDRPOLICY) && !ip6_asp_can_lookup(ipst)) {
9089 ip6_asp_pending_op(q, mp, ip_sioctl_copyin_resume);
9090 return;
9091 }
9092
9093 /*
9094 * Only allow a very small subset of IP ioctls on this stream if
9095 * IP is a module and not a driver. Allowing ioctls to be processed
9096 * in this case may cause assert failures or data corruption.
9097 * Typically G[L]IFFLAGS, SLIFNAME/IF_UNITSEL are the only few
9098 * ioctls allowed on an IP module stream, after which this stream
9099 * normally becomes a multiplexor (at which time the stream head
9100 * will fail all ioctls).
9101 */
9102 if ((q->q_next != NULL) && !(ipip->ipi_flags & IPI_MODOK)) {
9103 goto nak;
9104 }
9105
9106 /* Make sure we have ioctl data to process. */
9107 if (mp->b_cont == NULL && !(ipip->ipi_flags & IPI_NULL_BCONT))
9108 goto nak;
9109
9110 /*
9111 * Prefer dblk credential over ioctl credential; some synthesized
9112 * ioctls have kcred set because there's no way to crhold()
9113 * a credential in some contexts. (ioc_cr is not crfree() by
9114 * the framework; the caller of ioctl needs to hold the reference
9115 * for the duration of the call).
9116 */
9117 cr = msg_getcred(mp, NULL);
9118 if (cr == NULL)
9119 cr = iocp->ioc_cr;
9120
9121 /* Make sure normal users don't send down privileged ioctls */
9122 if ((ipip->ipi_flags & IPI_PRIV) &&
9123 (cr != NULL) && secpolicy_ip_config(cr, B_TRUE) != 0) {
9124 /* We checked the privilege earlier but log it here */
9125 miocnak(q, mp, 0, secpolicy_ip_config(cr, B_FALSE));
9126 return;
9127 }
9128
9129 /*
9130 * The ioctl command tables can only encode fixed length
9131 * ioctl data. If the length is variable, the table will
9132 * encode the length as zero. Such special cases are handled
9133 * below in the switch.
9134 */
9135 if (ipip->ipi_copyin_size != 0) {
9136 mi_copyin(q, mp, NULL, ipip->ipi_copyin_size);
9137 return;
9138 }
9139
9140 switch (iocp->ioc_cmd) {
9141 case O_SIOCGIFCONF:
9142 case SIOCGIFCONF:
9143 /*
9144 * This IOCTL is hilarious. See comments in
9145 * ip_sioctl_get_ifconf for the story.
9146 */
9147 if (iocp->ioc_count == TRANSPARENT)
9148 copyin_size = SIZEOF_STRUCT(ifconf,
9149 iocp->ioc_flag);
9150 else
9151 copyin_size = iocp->ioc_count;
9152 mi_copyin(q, mp, NULL, copyin_size);
9153 return;
9154
9155 case O_SIOCGLIFCONF:
9156 case SIOCGLIFCONF:
9157 copyin_size = SIZEOF_STRUCT(lifconf, iocp->ioc_flag);
9158 mi_copyin(q, mp, NULL, copyin_size);
9159 return;
9160
9161 case SIOCGLIFSRCOF:
9162 copyin_size = SIZEOF_STRUCT(lifsrcof, iocp->ioc_flag);
9163 mi_copyin(q, mp, NULL, copyin_size);
9164 return;
9165
9166 case SIOCGIP6ADDRPOLICY:
9167 ip_sioctl_ip6addrpolicy(q, mp);
9168 ip6_asp_table_refrele(ipst);
9169 return;
9170
9171 case SIOCSIP6ADDRPOLICY:
9172 ip_sioctl_ip6addrpolicy(q, mp);
9173 return;
9174
9175 case SIOCGDSTINFO:
9176 ip_sioctl_dstinfo(q, mp);
9177 ip6_asp_table_refrele(ipst);
9178 return;
9179
9180 case ND_SET:
9181 case ND_GET:
9182 ip_process_legacy_nddprop(q, mp);
9183 return;
9184
9185 case SIOCSETPROP:
9186 case SIOCGETPROP:
9187 ip_sioctl_getsetprop(q, mp);
9188 return;
9189
9190 case I_PLINK:
9191 case I_PUNLINK:
9192 case I_LINK:
9193 case I_UNLINK:
9194 /*
9195 * We treat non-persistent link similarly as the persistent
9196 * link case, in terms of plumbing/unplumbing, as well as
9197 * dynamic re-plumbing events indicator. See comments
9198 * in ip_sioctl_plink() for more.
9199 *
9200 * Request can be enqueued in the 'ipsq' while waiting
9201 * to become exclusive. So bump up the conn ref.
9202 */
9203 if (CONN_Q(q)) {
9204 CONN_INC_REF(Q_TO_CONN(q));
9205 CONN_INC_IOCTLREF(Q_TO_CONN(q))
9206 }
9207 ip_sioctl_plink(NULL, q, mp, NULL);
9208 return;
9209
9210 case IP_IOCTL:
9211 ip_wput_ioctl(q, mp);
9212 return;
9213
9214 case SIOCILB:
9215 /* The ioctl length varies depending on the ILB command. */
9216 copyin_size = iocp->ioc_count;
9217 if (copyin_size < sizeof (ilb_cmd_t))
9218 goto nak;
9219 mi_copyin(q, mp, NULL, copyin_size);
9220 return;
9221
9222 default:
9223 cmn_err(CE_PANIC, "should not happen ");
9224 }
9225 nak:
9226 if (mp->b_cont != NULL) {
9227 freemsg(mp->b_cont);
9228 mp->b_cont = NULL;
9229 }
9230 iocp->ioc_error = EINVAL;
9231 mp->b_datap->db_type = M_IOCNAK;
9232 iocp->ioc_count = 0;
9233 qreply(q, mp);
9234 }
9235
9236 static void
9237 ip_sioctl_garp_reply(mblk_t *mp, ill_t *ill, void *hwaddr, int flags)
9238 {
9239 struct arpreq *ar;
9240 struct xarpreq *xar;
9241 mblk_t *tmp;
9242 struct iocblk *iocp;
9243 int x_arp_ioctl = B_FALSE;
9244 int *flagsp;
9245 char *storage = NULL;
9246
9247 ASSERT(ill != NULL);
9248
9249 iocp = (struct iocblk *)mp->b_rptr;
9250 ASSERT(iocp->ioc_cmd == SIOCGXARP || iocp->ioc_cmd == SIOCGARP);
9251
9252 tmp = (mp->b_cont)->b_cont; /* xarpreq/arpreq */
9253 if ((iocp->ioc_cmd == SIOCGXARP) ||
9254 (iocp->ioc_cmd == SIOCSXARP)) {
9255 x_arp_ioctl = B_TRUE;
9256 xar = (struct xarpreq *)tmp->b_rptr;
9257 flagsp = &xar->xarp_flags;
9258 storage = xar->xarp_ha.sdl_data;
9259 } else {
9260 ar = (struct arpreq *)tmp->b_rptr;
9261 flagsp = &ar->arp_flags;
9262 storage = ar->arp_ha.sa_data;
9263 }
9264
9265 /*
9266 * We're done if this is not an SIOCG{X}ARP
9267 */
9268 if (x_arp_ioctl) {
9269 storage += ill_xarp_info(&xar->xarp_ha, ill);
9270 if ((ill->ill_phys_addr_length + ill->ill_name_length) >
9271 sizeof (xar->xarp_ha.sdl_data)) {
9272 iocp->ioc_error = EINVAL;
9273 return;
9274 }
9275 }
9276 *flagsp = ATF_INUSE;
9277 /*
9278 * If /sbin/arp told us we are the authority using the "permanent"
9279 * flag, or if this is one of my addresses print "permanent"
9280 * in the /sbin/arp output.
9281 */
9282 if ((flags & NCE_F_MYADDR) || (flags & NCE_F_AUTHORITY))
9283 *flagsp |= ATF_AUTHORITY;
9284 if (flags & NCE_F_NONUD)
9285 *flagsp |= ATF_PERM; /* not subject to aging */
9286 if (flags & NCE_F_PUBLISH)
9287 *flagsp |= ATF_PUBL;
9288 if (hwaddr != NULL) {
9289 *flagsp |= ATF_COM;
9290 bcopy((char *)hwaddr, storage, ill->ill_phys_addr_length);
9291 }
9292 }
9293
9294 /*
9295 * Create a new logical interface. If ipif_id is zero (i.e. not a logical
9296 * interface) create the next available logical interface for this
9297 * physical interface.
9298 * If ipif is NULL (i.e. the lookup didn't find one) attempt to create an
9299 * ipif with the specified name.
9300 *
9301 * If the address family is not AF_UNSPEC then set the address as well.
9302 *
9303 * If ip_sioctl_addr returns EINPROGRESS then the ioctl (the copyout)
9304 * is completed when the DL_BIND_ACK arrive in ip_rput_dlpi_writer.
9305 *
9306 * Executed as a writer on the ill.
9307 * So no lock is needed to traverse the ipif chain, or examine the
9308 * phyint flags.
9309 */
9310 /* ARGSUSED */
9311 int
9312 ip_sioctl_addif(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
9313 ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq)
9314 {
9315 mblk_t *mp1;
9316 struct lifreq *lifr;
9317 boolean_t isv6;
9318 boolean_t exists;
9319 char *name;
9320 char *endp;
9321 char *cp;
9322 int namelen;
9323 ipif_t *ipif;
9324 long id;
9325 ipsq_t *ipsq;
9326 ill_t *ill;
9327 sin_t *sin;
9328 int err = 0;
9329 boolean_t found_sep = B_FALSE;
9330 conn_t *connp;
9331 zoneid_t zoneid;
9332 ip_stack_t *ipst = CONNQ_TO_IPST(q);
9333
9334 ASSERT(q->q_next == NULL);
9335 ip1dbg(("ip_sioctl_addif\n"));
9336 /* Existence of mp1 has been checked in ip_wput_nondata */
9337 mp1 = mp->b_cont->b_cont;
9338 /*
9339 * Null terminate the string to protect against buffer
9340 * overrun. String was generated by user code and may not
9341 * be trusted.
9342 */
9343 lifr = (struct lifreq *)mp1->b_rptr;
9344 lifr->lifr_name[LIFNAMSIZ - 1] = '\0';
9345 name = lifr->lifr_name;
9346 ASSERT(CONN_Q(q));
9347 connp = Q_TO_CONN(q);
9348 isv6 = (connp->conn_family == AF_INET6);
9349 zoneid = connp->conn_zoneid;
9350 namelen = mi_strlen(name);
9351 if (namelen == 0)
9352 return (EINVAL);
9353
9354 exists = B_FALSE;
9355 if ((namelen + 1 == sizeof (ipif_loopback_name)) &&
9356 (mi_strcmp(name, ipif_loopback_name) == 0)) {
9357 /*
9358 * Allow creating lo0 using SIOCLIFADDIF.
9359 * can't be any other writer thread. So can pass null below
9360 * for the last 4 args to ipif_lookup_name.
9361 */
9362 ipif = ipif_lookup_on_name(lifr->lifr_name, namelen, B_TRUE,
9363 &exists, isv6, zoneid, ipst);
9364 /* Prevent any further action */
9365 if (ipif == NULL) {
9366 return (ENOBUFS);
9367 } else if (!exists) {
9368 /* We created the ipif now and as writer */
9369 ipif_refrele(ipif);
9370 return (0);
9371 } else {
9372 ill = ipif->ipif_ill;
9373 ill_refhold(ill);
9374 ipif_refrele(ipif);
9375 }
9376 } else {
9377 /* Look for a colon in the name. */
9378 endp = &name[namelen];
9379 for (cp = endp; --cp > name; ) {
9380 if (*cp == IPIF_SEPARATOR_CHAR) {
9381 found_sep = B_TRUE;
9382 /*
9383 * Reject any non-decimal aliases for plumbing
9384 * of logical interfaces. Aliases with leading
9385 * zeroes are also rejected as they introduce
9386 * ambiguity in the naming of the interfaces.
9387 * Comparing with "0" takes care of all such
9388 * cases.
9389 */
9390 if ((strncmp("0", cp+1, 1)) == 0)
9391 return (EINVAL);
9392
9393 if (ddi_strtol(cp+1, &endp, 10, &id) != 0 ||
9394 id <= 0 || *endp != '\0') {
9395 return (EINVAL);
9396 }
9397 *cp = '\0';
9398 break;
9399 }
9400 }
9401 ill = ill_lookup_on_name(name, B_FALSE, isv6, NULL, ipst);
9402 if (found_sep)
9403 *cp = IPIF_SEPARATOR_CHAR;
9404 if (ill == NULL)
9405 return (ENXIO);
9406 }
9407
9408 ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_process_ioctl, NEW_OP,
9409 B_TRUE);
9410
9411 /*
9412 * Release the refhold due to the lookup, now that we are excl
9413 * or we are just returning
9414 */
9415 ill_refrele(ill);
9416
9417 if (ipsq == NULL)
9418 return (EINPROGRESS);
9419
9420 /* We are now exclusive on the IPSQ */
9421 ASSERT(IAM_WRITER_ILL(ill));
9422
9423 if (found_sep) {
9424 /* Now see if there is an IPIF with this unit number. */
9425 for (ipif = ill->ill_ipif; ipif != NULL;
9426 ipif = ipif->ipif_next) {
9427 if (ipif->ipif_id == id) {
9428 err = EEXIST;
9429 goto done;
9430 }
9431 }
9432 }
9433
9434 /*
9435 * We use IRE_LOCAL for lo0:1 etc. for "receive only" use
9436 * of lo0. Plumbing for lo0:0 happens in ipif_lookup_on_name()
9437 * instead.
9438 */
9439 if ((ipif = ipif_allocate(ill, found_sep ? id : -1, IRE_LOCAL,
9440 B_TRUE, B_TRUE, &err)) == NULL) {
9441 goto done;
9442 }
9443
9444 /* Return created name with ioctl */
9445 (void) sprintf(lifr->lifr_name, "%s%c%d", ill->ill_name,
9446 IPIF_SEPARATOR_CHAR, ipif->ipif_id);
9447 ip1dbg(("created %s\n", lifr->lifr_name));
9448
9449 /* Set address */
9450 sin = (sin_t *)&lifr->lifr_addr;
9451 if (sin->sin_family != AF_UNSPEC) {
9452 err = ip_sioctl_addr(ipif, sin, q, mp,
9453 &ip_ndx_ioctl_table[SIOCLIFADDR_NDX], lifr);
9454 }
9455
9456 done:
9457 ipsq_exit(ipsq);
9458 return (err);
9459 }
9460
9461 /*
9462 * Remove an existing logical interface. If ipif_id is zero (i.e. not a logical
9463 * interface) delete it based on the IP address (on this physical interface).
9464 * Otherwise delete it based on the ipif_id.
9465 * Also, special handling to allow a removeif of lo0.
9466 */
9467 /* ARGSUSED */
9468 int
9469 ip_sioctl_removeif(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9470 ip_ioctl_cmd_t *ipip, void *dummy_if_req)
9471 {
9472 conn_t *connp;
9473 ill_t *ill = ipif->ipif_ill;
9474 boolean_t success;
9475 ip_stack_t *ipst;
9476
9477 ipst = CONNQ_TO_IPST(q);
9478
9479 ASSERT(q->q_next == NULL);
9480 ip1dbg(("ip_sioctl_remove_if(%s:%u %p)\n",
9481 ill->ill_name, ipif->ipif_id, (void *)ipif));
9482 ASSERT(IAM_WRITER_IPIF(ipif));
9483
9484 connp = Q_TO_CONN(q);
9485 /*
9486 * Special case for unplumbing lo0 (the loopback physical interface).
9487 * If unplumbing lo0, the incoming address structure has been
9488 * initialized to all zeros. When unplumbing lo0, all its logical
9489 * interfaces must be removed too.
9490 *
9491 * Note that this interface may be called to remove a specific
9492 * loopback logical interface (eg, lo0:1). But in that case
9493 * ipif->ipif_id != 0 so that the code path for that case is the
9494 * same as any other interface (meaning it skips the code directly
9495 * below).
9496 */
9497 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9498 if (sin->sin_family == AF_UNSPEC &&
9499 (IN6_IS_ADDR_UNSPECIFIED(&((sin6_t *)sin)->sin6_addr))) {
9500 /*
9501 * Mark it condemned. No new ref. will be made to ill.
9502 */
9503 mutex_enter(&ill->ill_lock);
9504 ill->ill_state_flags |= ILL_CONDEMNED;
9505 for (ipif = ill->ill_ipif; ipif != NULL;
9506 ipif = ipif->ipif_next) {
9507 ipif->ipif_state_flags |= IPIF_CONDEMNED;
9508 }
9509 mutex_exit(&ill->ill_lock);
9510
9511 ipif = ill->ill_ipif;
9512 /* unplumb the loopback interface */
9513 ill_delete(ill);
9514 mutex_enter(&connp->conn_lock);
9515 mutex_enter(&ill->ill_lock);
9516
9517 /* Are any references to this ill active */
9518 if (ill_is_freeable(ill)) {
9519 mutex_exit(&ill->ill_lock);
9520 mutex_exit(&connp->conn_lock);
9521 ill_delete_tail(ill);
9522 mi_free(ill);
9523 return (0);
9524 }
9525 success = ipsq_pending_mp_add(connp, ipif,
9526 CONNP_TO_WQ(connp), mp, ILL_FREE);
9527 mutex_exit(&connp->conn_lock);
9528 mutex_exit(&ill->ill_lock);
9529 if (success)
9530 return (EINPROGRESS);
9531 else
9532 return (EINTR);
9533 }
9534 }
9535
9536 if (ipif->ipif_id == 0) {
9537 ipsq_t *ipsq;
9538
9539 /* Find based on address */
9540 if (ipif->ipif_isv6) {
9541 sin6_t *sin6;
9542
9543 if (sin->sin_family != AF_INET6)
9544 return (EAFNOSUPPORT);
9545
9546 sin6 = (sin6_t *)sin;
9547 /* We are a writer, so we should be able to lookup */
9548 ipif = ipif_lookup_addr_exact_v6(&sin6->sin6_addr, ill,
9549 ipst);
9550 } else {
9551 if (sin->sin_family != AF_INET)
9552 return (EAFNOSUPPORT);
9553
9554 /* We are a writer, so we should be able to lookup */
9555 ipif = ipif_lookup_addr_exact(sin->sin_addr.s_addr, ill,
9556 ipst);
9557 }
9558 if (ipif == NULL) {
9559 return (EADDRNOTAVAIL);
9560 }
9561
9562 /*
9563 * It is possible for a user to send an SIOCLIFREMOVEIF with
9564 * lifr_name of the physical interface but with an ip address
9565 * lifr_addr of a logical interface plumbed over it.
9566 * So update ipx_current_ipif now that ipif points to the
9567 * correct one.
9568 */
9569 ipsq = ipif->ipif_ill->ill_phyint->phyint_ipsq;
9570 ipsq->ipsq_xop->ipx_current_ipif = ipif;
9571
9572 /* This is a writer */
9573 ipif_refrele(ipif);
9574 }
9575
9576 /*
9577 * Can not delete instance zero since it is tied to the ill.
9578 */
9579 if (ipif->ipif_id == 0)
9580 return (EBUSY);
9581
9582 mutex_enter(&ill->ill_lock);
9583 ipif->ipif_state_flags |= IPIF_CONDEMNED;
9584 mutex_exit(&ill->ill_lock);
9585
9586 ipif_free(ipif);
9587
9588 mutex_enter(&connp->conn_lock);
9589 mutex_enter(&ill->ill_lock);
9590
9591 /* Are any references to this ipif active */
9592 if (ipif_is_freeable(ipif)) {
9593 mutex_exit(&ill->ill_lock);
9594 mutex_exit(&connp->conn_lock);
9595 ipif_non_duplicate(ipif);
9596 (void) ipif_down_tail(ipif);
9597 ipif_free_tail(ipif); /* frees ipif */
9598 return (0);
9599 }
9600 success = ipsq_pending_mp_add(connp, ipif, CONNP_TO_WQ(connp), mp,
9601 IPIF_FREE);
9602 mutex_exit(&ill->ill_lock);
9603 mutex_exit(&connp->conn_lock);
9604 if (success)
9605 return (EINPROGRESS);
9606 else
9607 return (EINTR);
9608 }
9609
9610 /*
9611 * Restart the removeif ioctl. The refcnt has gone down to 0.
9612 * The ipif is already condemned. So can't find it thru lookups.
9613 */
9614 /* ARGSUSED */
9615 int
9616 ip_sioctl_removeif_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q,
9617 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_if_req)
9618 {
9619 ill_t *ill = ipif->ipif_ill;
9620
9621 ASSERT(IAM_WRITER_IPIF(ipif));
9622 ASSERT(ipif->ipif_state_flags & IPIF_CONDEMNED);
9623
9624 ip1dbg(("ip_sioctl_removeif_restart(%s:%u %p)\n",
9625 ill->ill_name, ipif->ipif_id, (void *)ipif));
9626
9627 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9628 ASSERT(ill->ill_state_flags & ILL_CONDEMNED);
9629 ill_delete_tail(ill);
9630 mi_free(ill);
9631 return (0);
9632 }
9633
9634 ipif_non_duplicate(ipif);
9635 (void) ipif_down_tail(ipif);
9636 ipif_free_tail(ipif);
9637
9638 return (0);
9639 }
9640
9641 /*
9642 * Set the local interface address using the given prefix and ill_token.
9643 */
9644 /* ARGSUSED */
9645 int
9646 ip_sioctl_prefix(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9647 ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq)
9648 {
9649 int err;
9650 in6_addr_t v6addr;
9651 sin6_t *sin6;
9652 ill_t *ill;
9653 int i;
9654
9655 ip1dbg(("ip_sioctl_prefix(%s:%u %p)\n",
9656 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9657
9658 ASSERT(IAM_WRITER_IPIF(ipif));
9659
9660 if (!ipif->ipif_isv6)
9661 return (EINVAL);
9662
9663 if (sin->sin_family != AF_INET6)
9664 return (EAFNOSUPPORT);
9665
9666 sin6 = (sin6_t *)sin;
9667 v6addr = sin6->sin6_addr;
9668 ill = ipif->ipif_ill;
9669
9670 if (IN6_IS_ADDR_UNSPECIFIED(&v6addr) ||
9671 IN6_IS_ADDR_UNSPECIFIED(&ill->ill_token))
9672 return (EADDRNOTAVAIL);
9673
9674 for (i = 0; i < 4; i++)
9675 sin6->sin6_addr.s6_addr32[i] |= ill->ill_token.s6_addr32[i];
9676
9677 err = ip_sioctl_addr(ipif, sin, q, mp,
9678 &ip_ndx_ioctl_table[SIOCLIFADDR_NDX], dummy_ifreq);
9679 return (err);
9680 }
9681
9682 /*
9683 * Restart entry point to restart the address set operation after the
9684 * refcounts have dropped to zero.
9685 */
9686 /* ARGSUSED */
9687 int
9688 ip_sioctl_prefix_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9689 ip_ioctl_cmd_t *ipip, void *ifreq)
9690 {
9691 ip1dbg(("ip_sioctl_prefix_restart(%s:%u %p)\n",
9692 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9693 return (ip_sioctl_addr_restart(ipif, sin, q, mp, ipip, ifreq));
9694 }
9695
9696 /*
9697 * Set the local interface address.
9698 * Allow an address of all zero when the interface is down.
9699 */
9700 /* ARGSUSED */
9701 int
9702 ip_sioctl_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9703 ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq)
9704 {
9705 int err = 0;
9706 in6_addr_t v6addr;
9707 boolean_t need_up = B_FALSE;
9708 ill_t *ill;
9709 int i;
9710
9711 ip1dbg(("ip_sioctl_addr(%s:%u %p)\n",
9712 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9713
9714 ASSERT(IAM_WRITER_IPIF(ipif));
9715
9716 ill = ipif->ipif_ill;
9717 if (ipif->ipif_isv6) {
9718 sin6_t *sin6;
9719 phyint_t *phyi;
9720
9721 if (sin->sin_family != AF_INET6)
9722 return (EAFNOSUPPORT);
9723
9724 sin6 = (sin6_t *)sin;
9725 v6addr = sin6->sin6_addr;
9726 phyi = ill->ill_phyint;
9727
9728 /*
9729 * Enforce that true multicast interfaces have a link-local
9730 * address for logical unit 0.
9731 *
9732 * However for those ipif's for which link-local address was
9733 * not created by default, also allow setting :: as the address.
9734 * This scenario would arise, when we delete an address on ipif
9735 * with logical unit 0, we would want to set :: as the address.
9736 */
9737 if (ipif->ipif_id == 0 &&
9738 (ill->ill_flags & ILLF_MULTICAST) &&
9739 !(ipif->ipif_flags & (IPIF_POINTOPOINT)) &&
9740 !(phyi->phyint_flags & (PHYI_LOOPBACK)) &&
9741 !IN6_IS_ADDR_LINKLOCAL(&v6addr)) {
9742
9743 /*
9744 * if default link-local was not created by kernel for
9745 * this ill, allow setting :: as the address on ipif:0.
9746 */
9747 if (ill->ill_flags & ILLF_NOLINKLOCAL) {
9748 if (!IN6_IS_ADDR_UNSPECIFIED(&v6addr))
9749 return (EADDRNOTAVAIL);
9750 } else {
9751 return (EADDRNOTAVAIL);
9752 }
9753 }
9754
9755 /*
9756 * up interfaces shouldn't have the unspecified address
9757 * unless they also have the IPIF_NOLOCAL flags set and
9758 * have a subnet assigned.
9759 */
9760 if ((ipif->ipif_flags & IPIF_UP) &&
9761 IN6_IS_ADDR_UNSPECIFIED(&v6addr) &&
9762 (!(ipif->ipif_flags & IPIF_NOLOCAL) ||
9763 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) {
9764 return (EADDRNOTAVAIL);
9765 }
9766
9767 if (!ip_local_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask))
9768 return (EADDRNOTAVAIL);
9769 } else {
9770 ipaddr_t addr;
9771
9772 if (sin->sin_family != AF_INET)
9773 return (EAFNOSUPPORT);
9774
9775 addr = sin->sin_addr.s_addr;
9776
9777 /* Allow INADDR_ANY as the local address. */
9778 if (addr != INADDR_ANY &&
9779 !ip_addr_ok_v4(addr, ipif->ipif_net_mask))
9780 return (EADDRNOTAVAIL);
9781
9782 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
9783 }
9784 /*
9785 * verify that the address being configured is permitted by the
9786 * ill_allowed_ips[] for the interface.
9787 */
9788 if (ill->ill_allowed_ips_cnt > 0) {
9789 for (i = 0; i < ill->ill_allowed_ips_cnt; i++) {
9790 if (IN6_ARE_ADDR_EQUAL(&ill->ill_allowed_ips[i],
9791 &v6addr))
9792 break;
9793 }
9794 if (i == ill->ill_allowed_ips_cnt) {
9795 pr_addr_dbg("!allowed addr %s\n", AF_INET6, &v6addr);
9796 return (EPERM);
9797 }
9798 }
9799 /*
9800 * Even if there is no change we redo things just to rerun
9801 * ipif_set_default.
9802 */
9803 if (ipif->ipif_flags & IPIF_UP) {
9804 /*
9805 * Setting a new local address, make sure
9806 * we have net and subnet bcast ire's for
9807 * the old address if we need them.
9808 */
9809 /*
9810 * If the interface is already marked up,
9811 * we call ipif_down which will take care
9812 * of ditching any IREs that have been set
9813 * up based on the old interface address.
9814 */
9815 err = ipif_logical_down(ipif, q, mp);
9816 if (err == EINPROGRESS)
9817 return (err);
9818 (void) ipif_down_tail(ipif);
9819 need_up = 1;
9820 }
9821
9822 err = ip_sioctl_addr_tail(ipif, sin, q, mp, need_up);
9823 return (err);
9824 }
9825
9826 int
9827 ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9828 boolean_t need_up)
9829 {
9830 in6_addr_t v6addr;
9831 in6_addr_t ov6addr;
9832 ipaddr_t addr;
9833 sin6_t *sin6;
9834 int sinlen;
9835 int err = 0;
9836 ill_t *ill = ipif->ipif_ill;
9837 boolean_t need_dl_down;
9838 boolean_t need_arp_down;
9839 struct iocblk *iocp;
9840
9841 iocp = (mp != NULL) ? (struct iocblk *)mp->b_rptr : NULL;
9842
9843 ip1dbg(("ip_sioctl_addr_tail(%s:%u %p)\n",
9844 ill->ill_name, ipif->ipif_id, (void *)ipif));
9845 ASSERT(IAM_WRITER_IPIF(ipif));
9846
9847 /* Must cancel any pending timer before taking the ill_lock */
9848 if (ipif->ipif_recovery_id != 0)
9849 (void) untimeout(ipif->ipif_recovery_id);
9850 ipif->ipif_recovery_id = 0;
9851
9852 if (ipif->ipif_isv6) {
9853 sin6 = (sin6_t *)sin;
9854 v6addr = sin6->sin6_addr;
9855 sinlen = sizeof (struct sockaddr_in6);
9856 } else {
9857 addr = sin->sin_addr.s_addr;
9858 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
9859 sinlen = sizeof (struct sockaddr_in);
9860 }
9861 mutex_enter(&ill->ill_lock);
9862 ov6addr = ipif->ipif_v6lcl_addr;
9863 ipif->ipif_v6lcl_addr = v6addr;
9864 sctp_update_ipif_addr(ipif, ov6addr);
9865 ipif->ipif_addr_ready = 0;
9866
9867 ip_rts_newaddrmsg(RTM_CHGADDR, 0, ipif, RTSQ_DEFAULT);
9868
9869 /*
9870 * If the interface was previously marked as a duplicate, then since
9871 * we've now got a "new" address, it should no longer be considered a
9872 * duplicate -- even if the "new" address is the same as the old one.
9873 * Note that if all ipifs are down, we may have a pending ARP down
9874 * event to handle. This is because we want to recover from duplicates
9875 * and thus delay tearing down ARP until the duplicates have been
9876 * removed or disabled.
9877 */
9878 need_dl_down = need_arp_down = B_FALSE;
9879 if (ipif->ipif_flags & IPIF_DUPLICATE) {
9880 need_arp_down = !need_up;
9881 ipif->ipif_flags &= ~IPIF_DUPLICATE;
9882 if (--ill->ill_ipif_dup_count == 0 && !need_up &&
9883 ill->ill_ipif_up_count == 0 && ill->ill_dl_up) {
9884 need_dl_down = B_TRUE;
9885 }
9886 }
9887
9888 ipif_set_default(ipif);
9889
9890 /*
9891 * If we've just manually set the IPv6 link-local address (0th ipif),
9892 * tag the ill so that future updates to the interface ID don't result
9893 * in this address getting automatically reconfigured from under the
9894 * administrator.
9895 */
9896 if (ipif->ipif_isv6 && ipif->ipif_id == 0) {
9897 if (iocp == NULL || (iocp->ioc_cmd == SIOCSLIFADDR &&
9898 !IN6_IS_ADDR_UNSPECIFIED(&v6addr)))
9899 ill->ill_manual_linklocal = 1;
9900 }
9901
9902 /*
9903 * When publishing an interface address change event, we only notify
9904 * the event listeners of the new address. It is assumed that if they
9905 * actively care about the addresses assigned that they will have
9906 * already discovered the previous address assigned (if there was one.)
9907 *
9908 * Don't attach nic event message for SIOCLIFADDIF ioctl.
9909 */
9910 if (iocp != NULL && iocp->ioc_cmd != SIOCLIFADDIF) {
9911 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ipif->ipif_id),
9912 NE_ADDRESS_CHANGE, sin, sinlen);
9913 }
9914
9915 mutex_exit(&ill->ill_lock);
9916
9917 if (need_up) {
9918 /*
9919 * Now bring the interface back up. If this
9920 * is the only IPIF for the ILL, ipif_up
9921 * will have to re-bind to the device, so
9922 * we may get back EINPROGRESS, in which
9923 * case, this IOCTL will get completed in
9924 * ip_rput_dlpi when we see the DL_BIND_ACK.
9925 */
9926 err = ipif_up(ipif, q, mp);
9927 } else {
9928 /* Perhaps ilgs should use this ill */
9929 update_conn_ill(NULL, ill->ill_ipst);
9930 }
9931
9932 if (need_dl_down)
9933 ill_dl_down(ill);
9934
9935 if (need_arp_down && !ill->ill_isv6)
9936 (void) ipif_arp_down(ipif);
9937
9938 /*
9939 * The default multicast interface might have changed (for
9940 * instance if the IPv6 scope of the address changed)
9941 */
9942 ire_increment_multicast_generation(ill->ill_ipst, ill->ill_isv6);
9943
9944 return (err);
9945 }
9946
9947 /*
9948 * Restart entry point to restart the address set operation after the
9949 * refcounts have dropped to zero.
9950 */
9951 /* ARGSUSED */
9952 int
9953 ip_sioctl_addr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9954 ip_ioctl_cmd_t *ipip, void *ifreq)
9955 {
9956 ip1dbg(("ip_sioctl_addr_restart(%s:%u %p)\n",
9957 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9958 ASSERT(IAM_WRITER_IPIF(ipif));
9959 (void) ipif_down_tail(ipif);
9960 return (ip_sioctl_addr_tail(ipif, sin, q, mp, B_TRUE));
9961 }
9962
9963 /* ARGSUSED */
9964 int
9965 ip_sioctl_get_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9966 ip_ioctl_cmd_t *ipip, void *if_req)
9967 {
9968 sin6_t *sin6 = (struct sockaddr_in6 *)sin;
9969 struct lifreq *lifr = (struct lifreq *)if_req;
9970
9971 ip1dbg(("ip_sioctl_get_addr(%s:%u %p)\n",
9972 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9973 /*
9974 * The net mask and address can't change since we have a
9975 * reference to the ipif. So no lock is necessary.
9976 */
9977 if (ipif->ipif_isv6) {
9978 *sin6 = sin6_null;
9979 sin6->sin6_family = AF_INET6;
9980 sin6->sin6_addr = ipif->ipif_v6lcl_addr;
9981 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
9982 lifr->lifr_addrlen =
9983 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
9984 } else {
9985 *sin = sin_null;
9986 sin->sin_family = AF_INET;
9987 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
9988 if (ipip->ipi_cmd_type == LIF_CMD) {
9989 lifr->lifr_addrlen =
9990 ip_mask_to_plen(ipif->ipif_net_mask);
9991 }
9992 }
9993 return (0);
9994 }
9995
9996 /*
9997 * Set the destination address for a pt-pt interface.
9998 */
9999 /* ARGSUSED */
10000 int
10001 ip_sioctl_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10002 ip_ioctl_cmd_t *ipip, void *if_req)
10003 {
10004 int err = 0;
10005 in6_addr_t v6addr;
10006 boolean_t need_up = B_FALSE;
10007
10008 ip1dbg(("ip_sioctl_dstaddr(%s:%u %p)\n",
10009 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10010 ASSERT(IAM_WRITER_IPIF(ipif));
10011
10012 if (ipif->ipif_isv6) {
10013 sin6_t *sin6;
10014
10015 if (sin->sin_family != AF_INET6)
10016 return (EAFNOSUPPORT);
10017
10018 sin6 = (sin6_t *)sin;
10019 v6addr = sin6->sin6_addr;
10020
10021 if (!ip_remote_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask))
10022 return (EADDRNOTAVAIL);
10023 } else {
10024 ipaddr_t addr;
10025
10026 if (sin->sin_family != AF_INET)
10027 return (EAFNOSUPPORT);
10028
10029 addr = sin->sin_addr.s_addr;
10030 if (addr != INADDR_ANY &&
10031 !ip_addr_ok_v4(addr, ipif->ipif_net_mask)) {
10032 return (EADDRNOTAVAIL);
10033 }
10034
10035 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
10036 }
10037
10038 if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6pp_dst_addr, &v6addr))
10039 return (0); /* No change */
10040
10041 if (ipif->ipif_flags & IPIF_UP) {
10042 /*
10043 * If the interface is already marked up,
10044 * we call ipif_down which will take care
10045 * of ditching any IREs that have been set
10046 * up based on the old pp dst address.
10047 */
10048 err = ipif_logical_down(ipif, q, mp);
10049 if (err == EINPROGRESS)
10050 return (err);
10051 (void) ipif_down_tail(ipif);
10052 need_up = B_TRUE;
10053 }
10054 /*
10055 * could return EINPROGRESS. If so ioctl will complete in
10056 * ip_rput_dlpi_writer
10057 */
10058 err = ip_sioctl_dstaddr_tail(ipif, sin, q, mp, need_up);
10059 return (err);
10060 }
10061
10062 static int
10063 ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10064 boolean_t need_up)
10065 {
10066 in6_addr_t v6addr;
10067 ill_t *ill = ipif->ipif_ill;
10068 int err = 0;
10069 boolean_t need_dl_down;
10070 boolean_t need_arp_down;
10071
10072 ip1dbg(("ip_sioctl_dstaddr_tail(%s:%u %p)\n", ill->ill_name,
10073 ipif->ipif_id, (void *)ipif));
10074
10075 /* Must cancel any pending timer before taking the ill_lock */
10076 if (ipif->ipif_recovery_id != 0)
10077 (void) untimeout(ipif->ipif_recovery_id);
10078 ipif->ipif_recovery_id = 0;
10079
10080 if (ipif->ipif_isv6) {
10081 sin6_t *sin6;
10082
10083 sin6 = (sin6_t *)sin;
10084 v6addr = sin6->sin6_addr;
10085 } else {
10086 ipaddr_t addr;
10087
10088 addr = sin->sin_addr.s_addr;
10089 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
10090 }
10091 mutex_enter(&ill->ill_lock);
10092 /* Set point to point destination address. */
10093 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
10094 /*
10095 * Allow this as a means of creating logical
10096 * pt-pt interfaces on top of e.g. an Ethernet.
10097 * XXX Undocumented HACK for testing.
10098 * pt-pt interfaces are created with NUD disabled.
10099 */
10100 ipif->ipif_flags |= IPIF_POINTOPOINT;
10101 ipif->ipif_flags &= ~IPIF_BROADCAST;
10102 if (ipif->ipif_isv6)
10103 ill->ill_flags |= ILLF_NONUD;
10104 }
10105
10106 /*
10107 * If the interface was previously marked as a duplicate, then since
10108 * we've now got a "new" address, it should no longer be considered a
10109 * duplicate -- even if the "new" address is the same as the old one.
10110 * Note that if all ipifs are down, we may have a pending ARP down
10111 * event to handle.
10112 */
10113 need_dl_down = need_arp_down = B_FALSE;
10114 if (ipif->ipif_flags & IPIF_DUPLICATE) {
10115 need_arp_down = !need_up;
10116 ipif->ipif_flags &= ~IPIF_DUPLICATE;
10117 if (--ill->ill_ipif_dup_count == 0 && !need_up &&
10118 ill->ill_ipif_up_count == 0 && ill->ill_dl_up) {
10119 need_dl_down = B_TRUE;
10120 }
10121 }
10122
10123 /*
10124 * If we've just manually set the IPv6 destination link-local address
10125 * (0th ipif), tag the ill so that future updates to the destination
10126 * interface ID (as can happen with interfaces over IP tunnels) don't
10127 * result in this address getting automatically reconfigured from
10128 * under the administrator.
10129 */
10130 if (ipif->ipif_isv6 && ipif->ipif_id == 0)
10131 ill->ill_manual_dst_linklocal = 1;
10132
10133 /* Set the new address. */
10134 ipif->ipif_v6pp_dst_addr = v6addr;
10135 /* Make sure subnet tracks pp_dst */
10136 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
10137 mutex_exit(&ill->ill_lock);
10138
10139 if (need_up) {
10140 /*
10141 * Now bring the interface back up. If this
10142 * is the only IPIF for the ILL, ipif_up
10143 * will have to re-bind to the device, so
10144 * we may get back EINPROGRESS, in which
10145 * case, this IOCTL will get completed in
10146 * ip_rput_dlpi when we see the DL_BIND_ACK.
10147 */
10148 err = ipif_up(ipif, q, mp);
10149 }
10150
10151 if (need_dl_down)
10152 ill_dl_down(ill);
10153 if (need_arp_down && !ipif->ipif_isv6)
10154 (void) ipif_arp_down(ipif);
10155
10156 return (err);
10157 }
10158
10159 /*
10160 * Restart entry point to restart the dstaddress set operation after the
10161 * refcounts have dropped to zero.
10162 */
10163 /* ARGSUSED */
10164 int
10165 ip_sioctl_dstaddr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10166 ip_ioctl_cmd_t *ipip, void *ifreq)
10167 {
10168 ip1dbg(("ip_sioctl_dstaddr_restart(%s:%u %p)\n",
10169 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10170 (void) ipif_down_tail(ipif);
10171 return (ip_sioctl_dstaddr_tail(ipif, sin, q, mp, B_TRUE));
10172 }
10173
10174 /* ARGSUSED */
10175 int
10176 ip_sioctl_get_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10177 ip_ioctl_cmd_t *ipip, void *if_req)
10178 {
10179 sin6_t *sin6 = (struct sockaddr_in6 *)sin;
10180
10181 ip1dbg(("ip_sioctl_get_dstaddr(%s:%u %p)\n",
10182 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10183 /*
10184 * Get point to point destination address. The addresses can't
10185 * change since we hold a reference to the ipif.
10186 */
10187 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0)
10188 return (EADDRNOTAVAIL);
10189
10190 if (ipif->ipif_isv6) {
10191 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
10192 *sin6 = sin6_null;
10193 sin6->sin6_family = AF_INET6;
10194 sin6->sin6_addr = ipif->ipif_v6pp_dst_addr;
10195 } else {
10196 *sin = sin_null;
10197 sin->sin_family = AF_INET;
10198 sin->sin_addr.s_addr = ipif->ipif_pp_dst_addr;
10199 }
10200 return (0);
10201 }
10202
10203 /*
10204 * Check which flags will change by the given flags being set
10205 * silently ignore flags which userland is not allowed to control.
10206 * (Because these flags may change between SIOCGLIFFLAGS and
10207 * SIOCSLIFFLAGS, and that's outside of userland's control,
10208 * we need to silently ignore them rather than fail.)
10209 */
10210 static void
10211 ip_sioctl_flags_onoff(ipif_t *ipif, uint64_t flags, uint64_t *onp,
10212 uint64_t *offp)
10213 {
10214 ill_t *ill = ipif->ipif_ill;
10215 phyint_t *phyi = ill->ill_phyint;
10216 uint64_t cantchange_flags, intf_flags;
10217 uint64_t turn_on, turn_off;
10218
10219 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10220 cantchange_flags = IFF_CANTCHANGE;
10221 if (IS_IPMP(ill))
10222 cantchange_flags |= IFF_IPMP_CANTCHANGE;
10223 turn_on = (flags ^ intf_flags) & ~cantchange_flags;
10224 turn_off = intf_flags & turn_on;
10225 turn_on ^= turn_off;
10226 *onp = turn_on;
10227 *offp = turn_off;
10228 }
10229
10230 /*
10231 * Set interface flags. Many flags require special handling (e.g.,
10232 * bringing the interface down); see below for details.
10233 *
10234 * NOTE : We really don't enforce that ipif_id zero should be used
10235 * for setting any flags other than IFF_LOGINT_FLAGS. This
10236 * is because applications generally does SICGLIFFLAGS and
10237 * ORs in the new flags (that affects the logical) and does a
10238 * SIOCSLIFFLAGS. Thus, "flags" below could contain bits other
10239 * than IFF_LOGINT_FLAGS. One could check whether "turn_on" - the
10240 * flags that will be turned on is correct with respect to
10241 * ipif_id 0. For backward compatibility reasons, it is not done.
10242 */
10243 /* ARGSUSED */
10244 int
10245 ip_sioctl_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10246 ip_ioctl_cmd_t *ipip, void *if_req)
10247 {
10248 uint64_t turn_on;
10249 uint64_t turn_off;
10250 int err = 0;
10251 phyint_t *phyi;
10252 ill_t *ill;
10253 conn_t *connp;
10254 uint64_t intf_flags;
10255 boolean_t phyint_flags_modified = B_FALSE;
10256 uint64_t flags;
10257 struct ifreq *ifr;
10258 struct lifreq *lifr;
10259 boolean_t set_linklocal = B_FALSE;
10260
10261 ip1dbg(("ip_sioctl_flags(%s:%u %p)\n",
10262 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10263
10264 ASSERT(IAM_WRITER_IPIF(ipif));
10265
10266 ill = ipif->ipif_ill;
10267 phyi = ill->ill_phyint;
10268
10269 if (ipip->ipi_cmd_type == IF_CMD) {
10270 ifr = (struct ifreq *)if_req;
10271 flags = (uint64_t)(ifr->ifr_flags & 0x0000ffff);
10272 } else {
10273 lifr = (struct lifreq *)if_req;
10274 flags = lifr->lifr_flags;
10275 }
10276
10277 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10278
10279 /*
10280 * Have the flags been set correctly until now?
10281 */
10282 ASSERT((phyi->phyint_flags & ~(IFF_PHYINT_FLAGS)) == 0);
10283 ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0);
10284 ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0);
10285 /*
10286 * Compare the new flags to the old, and partition
10287 * into those coming on and those going off.
10288 * For the 16 bit command keep the bits above bit 16 unchanged.
10289 */
10290 if (ipip->ipi_cmd == SIOCSIFFLAGS)
10291 flags |= intf_flags & ~0xFFFF;
10292
10293 /*
10294 * Explicitly fail attempts to change flags that are always invalid on
10295 * an IPMP meta-interface.
10296 */
10297 if (IS_IPMP(ill) && ((flags ^ intf_flags) & IFF_IPMP_INVALID))
10298 return (EINVAL);
10299
10300 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10301 if ((turn_on|turn_off) == 0)
10302 return (0); /* No change */
10303
10304 /*
10305 * All test addresses must be IFF_DEPRECATED (to ensure source address
10306 * selection avoids them) -- so force IFF_DEPRECATED on, and do not
10307 * allow it to be turned off.
10308 */
10309 if ((turn_off & (IFF_DEPRECATED|IFF_NOFAILOVER)) == IFF_DEPRECATED &&
10310 (turn_on|intf_flags) & IFF_NOFAILOVER)
10311 return (EINVAL);
10312
10313 if ((connp = Q_TO_CONN(q)) == NULL)
10314 return (EINVAL);
10315
10316 /*
10317 * Only vrrp control socket is allowed to change IFF_UP and
10318 * IFF_NOACCEPT flags when IFF_VRRP is set.
10319 */
10320 if ((intf_flags & IFF_VRRP) && ((turn_off | turn_on) & IFF_UP)) {
10321 if (!connp->conn_isvrrp)
10322 return (EINVAL);
10323 }
10324
10325 /*
10326 * The IFF_NOACCEPT flag can only be set on an IFF_VRRP IP address by
10327 * VRRP control socket.
10328 */
10329 if ((turn_off | turn_on) & IFF_NOACCEPT) {
10330 if (!connp->conn_isvrrp || !(intf_flags & IFF_VRRP))
10331 return (EINVAL);
10332 }
10333
10334 if (turn_on & IFF_NOFAILOVER) {
10335 turn_on |= IFF_DEPRECATED;
10336 flags |= IFF_DEPRECATED;
10337 }
10338
10339 /*
10340 * On underlying interfaces, only allow applications to manage test
10341 * addresses -- otherwise, they may get confused when the address
10342 * moves as part of being brought up. Likewise, prevent an
10343 * application-managed test address from being converted to a data
10344 * address. To prevent migration of administratively up addresses in
10345 * the kernel, we don't allow them to be converted either.
10346 */
10347 if (IS_UNDER_IPMP(ill)) {
10348 const uint64_t appflags = IFF_DHCPRUNNING | IFF_ADDRCONF;
10349
10350 if ((turn_on & appflags) && !(flags & IFF_NOFAILOVER))
10351 return (EINVAL);
10352
10353 if ((turn_off & IFF_NOFAILOVER) &&
10354 (flags & (appflags | IFF_UP | IFF_DUPLICATE)))
10355 return (EINVAL);
10356 }
10357
10358 /*
10359 * Only allow IFF_TEMPORARY flag to be set on
10360 * IPv6 interfaces.
10361 */
10362 if ((turn_on & IFF_TEMPORARY) && !(ipif->ipif_isv6))
10363 return (EINVAL);
10364
10365 /*
10366 * cannot turn off IFF_NOXMIT on VNI interfaces.
10367 */
10368 if ((turn_off & IFF_NOXMIT) && IS_VNI(ipif->ipif_ill))
10369 return (EINVAL);
10370
10371 /*
10372 * Don't allow the IFF_ROUTER flag to be turned on on loopback
10373 * interfaces. It makes no sense in that context.
10374 */
10375 if ((turn_on & IFF_ROUTER) && (phyi->phyint_flags & PHYI_LOOPBACK))
10376 return (EINVAL);
10377
10378 /*
10379 * For IPv6 ipif_id 0, don't allow the interface to be up without
10380 * a link local address if IFF_NOLOCAL or IFF_ANYCAST are not set.
10381 * If the link local address isn't set, and can be set, it will get
10382 * set later on in this function.
10383 */
10384 if (ipif->ipif_id == 0 && ipif->ipif_isv6 &&
10385 (flags & IFF_UP) && !(flags & (IFF_NOLOCAL|IFF_ANYCAST)) &&
10386 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) {
10387 if (ipif_cant_setlinklocal(ipif))
10388 return (EINVAL);
10389 set_linklocal = B_TRUE;
10390 }
10391
10392 /*
10393 * If we modify physical interface flags, we'll potentially need to
10394 * send up two routing socket messages for the changes (one for the
10395 * IPv4 ill, and another for the IPv6 ill). Note that here.
10396 */
10397 if ((turn_on|turn_off) & IFF_PHYINT_FLAGS)
10398 phyint_flags_modified = B_TRUE;
10399
10400 /*
10401 * All functioning PHYI_STANDBY interfaces start life PHYI_INACTIVE
10402 * (otherwise, we'd immediately use them, defeating standby). Also,
10403 * since PHYI_INACTIVE has a separate meaning when PHYI_STANDBY is not
10404 * set, don't allow PHYI_STANDBY to be set if PHYI_INACTIVE is already
10405 * set, and clear PHYI_INACTIVE if PHYI_STANDBY is being cleared. We
10406 * also don't allow PHYI_STANDBY if VNI is enabled since its semantics
10407 * will not be honored.
10408 */
10409 if (turn_on & PHYI_STANDBY) {
10410 /*
10411 * No need to grab ill_g_usesrc_lock here; see the
10412 * synchronization notes in ip.c.
10413 */
10414 if (ill->ill_usesrc_grp_next != NULL ||
10415 intf_flags & PHYI_INACTIVE)
10416 return (EINVAL);
10417 if (!(flags & PHYI_FAILED)) {
10418 flags |= PHYI_INACTIVE;
10419 turn_on |= PHYI_INACTIVE;
10420 }
10421 }
10422
10423 if (turn_off & PHYI_STANDBY) {
10424 flags &= ~PHYI_INACTIVE;
10425 turn_off |= PHYI_INACTIVE;
10426 }
10427
10428 /*
10429 * PHYI_FAILED and PHYI_INACTIVE are mutually exclusive; fail if both
10430 * would end up on.
10431 */
10432 if ((flags & (PHYI_FAILED | PHYI_INACTIVE)) ==
10433 (PHYI_FAILED | PHYI_INACTIVE))
10434 return (EINVAL);
10435
10436 /*
10437 * If ILLF_ROUTER changes, we need to change the ip forwarding
10438 * status of the interface.
10439 */
10440 if ((turn_on | turn_off) & ILLF_ROUTER) {
10441 err = ill_forward_set(ill, ((turn_on & ILLF_ROUTER) != 0));
10442 if (err != 0)
10443 return (err);
10444 }
10445
10446 /*
10447 * If the interface is not UP and we are not going to
10448 * bring it UP, record the flags and return. When the
10449 * interface comes UP later, the right actions will be
10450 * taken.
10451 */
10452 if (!(ipif->ipif_flags & IPIF_UP) &&
10453 !(turn_on & IPIF_UP)) {
10454 /* Record new flags in their respective places. */
10455 mutex_enter(&ill->ill_lock);
10456 mutex_enter(&ill->ill_phyint->phyint_lock);
10457 ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS);
10458 ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS);
10459 ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS);
10460 ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS);
10461 phyi->phyint_flags |= (turn_on & IFF_PHYINT_FLAGS);
10462 phyi->phyint_flags &= (~turn_off & IFF_PHYINT_FLAGS);
10463 mutex_exit(&ill->ill_lock);
10464 mutex_exit(&ill->ill_phyint->phyint_lock);
10465
10466 /*
10467 * PHYI_FAILED, PHYI_INACTIVE, and PHYI_OFFLINE are all the
10468 * same to the kernel: if any of them has been set by
10469 * userland, the interface cannot be used for data traffic.
10470 */
10471 if ((turn_on|turn_off) &
10472 (PHYI_FAILED | PHYI_INACTIVE | PHYI_OFFLINE)) {
10473 ASSERT(!IS_IPMP(ill));
10474 /*
10475 * It's possible the ill is part of an "anonymous"
10476 * IPMP group rather than a real group. In that case,
10477 * there are no other interfaces in the group and thus
10478 * no need to call ipmp_phyint_refresh_active().
10479 */
10480 if (IS_UNDER_IPMP(ill))
10481 ipmp_phyint_refresh_active(phyi);
10482 }
10483
10484 if (phyint_flags_modified) {
10485 if (phyi->phyint_illv4 != NULL) {
10486 ip_rts_ifmsg(phyi->phyint_illv4->
10487 ill_ipif, RTSQ_DEFAULT);
10488 }
10489 if (phyi->phyint_illv6 != NULL) {
10490 ip_rts_ifmsg(phyi->phyint_illv6->
10491 ill_ipif, RTSQ_DEFAULT);
10492 }
10493 }
10494 /* The default multicast interface might have changed */
10495 ire_increment_multicast_generation(ill->ill_ipst,
10496 ill->ill_isv6);
10497
10498 return (0);
10499 } else if (set_linklocal) {
10500 mutex_enter(&ill->ill_lock);
10501 if (set_linklocal)
10502 ipif->ipif_state_flags |= IPIF_SET_LINKLOCAL;
10503 mutex_exit(&ill->ill_lock);
10504 }
10505
10506 /*
10507 * Disallow IPv6 interfaces coming up that have the unspecified address,
10508 * or point-to-point interfaces with an unspecified destination. We do
10509 * allow the address to be unspecified for IPIF_NOLOCAL interfaces that
10510 * have a subnet assigned, which is how in.ndpd currently manages its
10511 * onlink prefix list when no addresses are configured with those
10512 * prefixes.
10513 */
10514 if (ipif->ipif_isv6 &&
10515 ((IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) &&
10516 (!(ipif->ipif_flags & IPIF_NOLOCAL) && !(turn_on & IPIF_NOLOCAL) ||
10517 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) ||
10518 ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
10519 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6pp_dst_addr)))) {
10520 return (EINVAL);
10521 }
10522
10523 /*
10524 * Prevent IPv4 point-to-point interfaces with a 0.0.0.0 destination
10525 * from being brought up.
10526 */
10527 if (!ipif->ipif_isv6 &&
10528 ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
10529 ipif->ipif_pp_dst_addr == INADDR_ANY)) {
10530 return (EINVAL);
10531 }
10532
10533 /*
10534 * If we are going to change one or more of the flags that are
10535 * IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT, IPIF_NOLOCAL, ILLF_NOARP,
10536 * ILLF_NONUD, IPIF_PRIVATE, IPIF_ANYCAST, IPIF_PREFERRED, and
10537 * IPIF_NOFAILOVER, we will take special action. This is
10538 * done by bring the ipif down, changing the flags and bringing
10539 * it back up again. For IPIF_NOFAILOVER, the act of bringing it
10540 * back up will trigger the address to be moved.
10541 *
10542 * If we are going to change IFF_NOACCEPT, we need to bring
10543 * all the ipifs down then bring them up again. The act of
10544 * bringing all the ipifs back up will trigger the local
10545 * ires being recreated with "no_accept" set/cleared.
10546 *
10547 * Note that ILLF_NOACCEPT is always set separately from the
10548 * other flags.
10549 */
10550 if ((turn_on|turn_off) &
10551 (IPIF_UP|IPIF_DEPRECATED|IPIF_NOXMIT|IPIF_NOLOCAL|ILLF_NOARP|
10552 ILLF_NONUD|IPIF_PRIVATE|IPIF_ANYCAST|IPIF_PREFERRED|
10553 IPIF_NOFAILOVER)) {
10554 /*
10555 * ipif_down() will ire_delete bcast ire's for the subnet,
10556 * while the ire_identical_ref tracks the case of IRE_BROADCAST
10557 * entries shared between multiple ipifs on the same subnet.
10558 */
10559 if (((ipif->ipif_flags | turn_on) & IPIF_UP) &&
10560 !(turn_off & IPIF_UP)) {
10561 if (ipif->ipif_flags & IPIF_UP)
10562 ill->ill_logical_down = 1;
10563 turn_on &= ~IPIF_UP;
10564 }
10565 err = ipif_down(ipif, q, mp);
10566 ip1dbg(("ipif_down returns %d err ", err));
10567 if (err == EINPROGRESS)
10568 return (err);
10569 (void) ipif_down_tail(ipif);
10570 } else if ((turn_on|turn_off) & ILLF_NOACCEPT) {
10571 /*
10572 * If we can quiesce the ill, then continue. If not, then
10573 * ip_sioctl_flags_tail() will be called from
10574 * ipif_ill_refrele_tail().
10575 */
10576 ill_down_ipifs(ill, B_TRUE);
10577
10578 mutex_enter(&connp->conn_lock);
10579 mutex_enter(&ill->ill_lock);
10580 if (!ill_is_quiescent(ill)) {
10581 boolean_t success;
10582
10583 success = ipsq_pending_mp_add(connp, ill->ill_ipif,
10584 q, mp, ILL_DOWN);
10585 mutex_exit(&ill->ill_lock);
10586 mutex_exit(&connp->conn_lock);
10587 return (success ? EINPROGRESS : EINTR);
10588 }
10589 mutex_exit(&ill->ill_lock);
10590 mutex_exit(&connp->conn_lock);
10591 }
10592 return (ip_sioctl_flags_tail(ipif, flags, q, mp));
10593 }
10594
10595 static int
10596 ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q, mblk_t *mp)
10597 {
10598 ill_t *ill;
10599 phyint_t *phyi;
10600 uint64_t turn_on, turn_off;
10601 boolean_t phyint_flags_modified = B_FALSE;
10602 int err = 0;
10603 boolean_t set_linklocal = B_FALSE;
10604
10605 ip1dbg(("ip_sioctl_flags_tail(%s:%u)\n",
10606 ipif->ipif_ill->ill_name, ipif->ipif_id));
10607
10608 ASSERT(IAM_WRITER_IPIF(ipif));
10609
10610 ill = ipif->ipif_ill;
10611 phyi = ill->ill_phyint;
10612
10613 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10614
10615 /*
10616 * IFF_UP is handled separately.
10617 */
10618 turn_on &= ~IFF_UP;
10619 turn_off &= ~IFF_UP;
10620
10621 if ((turn_on|turn_off) & IFF_PHYINT_FLAGS)
10622 phyint_flags_modified = B_TRUE;
10623
10624 /*
10625 * Now we change the flags. Track current value of
10626 * other flags in their respective places.
10627 */
10628 mutex_enter(&ill->ill_lock);
10629 mutex_enter(&phyi->phyint_lock);
10630 ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS);
10631 ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS);
10632 ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS);
10633 ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS);
10634 phyi->phyint_flags |= (turn_on & IFF_PHYINT_FLAGS);
10635 phyi->phyint_flags &= (~turn_off & IFF_PHYINT_FLAGS);
10636 if (ipif->ipif_state_flags & IPIF_SET_LINKLOCAL) {
10637 set_linklocal = B_TRUE;
10638 ipif->ipif_state_flags &= ~IPIF_SET_LINKLOCAL;
10639 }
10640
10641 mutex_exit(&ill->ill_lock);
10642 mutex_exit(&phyi->phyint_lock);
10643
10644 if (set_linklocal)
10645 (void) ipif_setlinklocal(ipif);
10646
10647 /*
10648 * PHYI_FAILED, PHYI_INACTIVE, and PHYI_OFFLINE are all the same to
10649 * the kernel: if any of them has been set by userland, the interface
10650 * cannot be used for data traffic.
10651 */
10652 if ((turn_on|turn_off) & (PHYI_FAILED | PHYI_INACTIVE | PHYI_OFFLINE)) {
10653 ASSERT(!IS_IPMP(ill));
10654 /*
10655 * It's possible the ill is part of an "anonymous" IPMP group
10656 * rather than a real group. In that case, there are no other
10657 * interfaces in the group and thus no need for us to call
10658 * ipmp_phyint_refresh_active().
10659 */
10660 if (IS_UNDER_IPMP(ill))
10661 ipmp_phyint_refresh_active(phyi);
10662 }
10663
10664 if ((turn_on|turn_off) & ILLF_NOACCEPT) {
10665 /*
10666 * If the ILLF_NOACCEPT flag is changed, bring up all the
10667 * ipifs that were brought down.
10668 *
10669 * The routing sockets messages are sent as the result
10670 * of ill_up_ipifs(), further, SCTP's IPIF list was updated
10671 * as well.
10672 */
10673 err = ill_up_ipifs(ill, q, mp);
10674 } else if ((flags & IFF_UP) && !(ipif->ipif_flags & IPIF_UP)) {
10675 /*
10676 * XXX ipif_up really does not know whether a phyint flags
10677 * was modified or not. So, it sends up information on
10678 * only one routing sockets message. As we don't bring up
10679 * the interface and also set PHYI_ flags simultaneously
10680 * it should be okay.
10681 */
10682 err = ipif_up(ipif, q, mp);
10683 } else {
10684 /*
10685 * Make sure routing socket sees all changes to the flags.
10686 * ipif_up_done* handles this when we use ipif_up.
10687 */
10688 if (phyint_flags_modified) {
10689 if (phyi->phyint_illv4 != NULL) {
10690 ip_rts_ifmsg(phyi->phyint_illv4->
10691 ill_ipif, RTSQ_DEFAULT);
10692 }
10693 if (phyi->phyint_illv6 != NULL) {
10694 ip_rts_ifmsg(phyi->phyint_illv6->
10695 ill_ipif, RTSQ_DEFAULT);
10696 }
10697 } else {
10698 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
10699 }
10700 /*
10701 * Update the flags in SCTP's IPIF list, ipif_up() will do
10702 * this in need_up case.
10703 */
10704 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
10705 }
10706
10707 /* The default multicast interface might have changed */
10708 ire_increment_multicast_generation(ill->ill_ipst, ill->ill_isv6);
10709 return (err);
10710 }
10711
10712 /*
10713 * Restart the flags operation now that the refcounts have dropped to zero.
10714 */
10715 /* ARGSUSED */
10716 int
10717 ip_sioctl_flags_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10718 ip_ioctl_cmd_t *ipip, void *if_req)
10719 {
10720 uint64_t flags;
10721 struct ifreq *ifr = if_req;
10722 struct lifreq *lifr = if_req;
10723 uint64_t turn_on, turn_off;
10724
10725 ip1dbg(("ip_sioctl_flags_restart(%s:%u %p)\n",
10726 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10727
10728 if (ipip->ipi_cmd_type == IF_CMD) {
10729 /* cast to uint16_t prevents unwanted sign extension */
10730 flags = (uint16_t)ifr->ifr_flags;
10731 } else {
10732 flags = lifr->lifr_flags;
10733 }
10734
10735 /*
10736 * If this function call is a result of the ILLF_NOACCEPT flag
10737 * change, do not call ipif_down_tail(). See ip_sioctl_flags().
10738 */
10739 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10740 if (!((turn_on|turn_off) & ILLF_NOACCEPT))
10741 (void) ipif_down_tail(ipif);
10742
10743 return (ip_sioctl_flags_tail(ipif, flags, q, mp));
10744 }
10745
10746 /*
10747 * Can operate on either a module or a driver queue.
10748 */
10749 /* ARGSUSED */
10750 int
10751 ip_sioctl_get_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10752 ip_ioctl_cmd_t *ipip, void *if_req)
10753 {
10754 /*
10755 * Has the flags been set correctly till now ?
10756 */
10757 ill_t *ill = ipif->ipif_ill;
10758 phyint_t *phyi = ill->ill_phyint;
10759
10760 ip1dbg(("ip_sioctl_get_flags(%s:%u %p)\n",
10761 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10762 ASSERT((phyi->phyint_flags & ~(IFF_PHYINT_FLAGS)) == 0);
10763 ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0);
10764 ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0);
10765
10766 /*
10767 * Need a lock since some flags can be set even when there are
10768 * references to the ipif.
10769 */
10770 mutex_enter(&ill->ill_lock);
10771 if (ipip->ipi_cmd_type == IF_CMD) {
10772 struct ifreq *ifr = (struct ifreq *)if_req;
10773
10774 /* Get interface flags (low 16 only). */
10775 ifr->ifr_flags = ((ipif->ipif_flags |
10776 ill->ill_flags | phyi->phyint_flags) & 0xffff);
10777 } else {
10778 struct lifreq *lifr = (struct lifreq *)if_req;
10779
10780 /* Get interface flags. */
10781 lifr->lifr_flags = ipif->ipif_flags |
10782 ill->ill_flags | phyi->phyint_flags;
10783 }
10784 mutex_exit(&ill->ill_lock);
10785 return (0);
10786 }
10787
10788 /*
10789 * We allow the MTU to be set on an ILL, but not have it be different
10790 * for different IPIFs since we don't actually send packets on IPIFs.
10791 */
10792 /* ARGSUSED */
10793 int
10794 ip_sioctl_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10795 ip_ioctl_cmd_t *ipip, void *if_req)
10796 {
10797 int mtu;
10798 int ip_min_mtu;
10799 struct ifreq *ifr;
10800 struct lifreq *lifr;
10801 ill_t *ill;
10802
10803 ip1dbg(("ip_sioctl_mtu(%s:%u %p)\n", ipif->ipif_ill->ill_name,
10804 ipif->ipif_id, (void *)ipif));
10805 if (ipip->ipi_cmd_type == IF_CMD) {
10806 ifr = (struct ifreq *)if_req;
10807 mtu = ifr->ifr_metric;
10808 } else {
10809 lifr = (struct lifreq *)if_req;
10810 mtu = lifr->lifr_mtu;
10811 }
10812 /* Only allow for logical unit zero i.e. not on "bge0:17" */
10813 if (ipif->ipif_id != 0)
10814 return (EINVAL);
10815
10816 ill = ipif->ipif_ill;
10817 if (ipif->ipif_isv6)
10818 ip_min_mtu = IPV6_MIN_MTU;
10819 else
10820 ip_min_mtu = IP_MIN_MTU;
10821
10822 mutex_enter(&ill->ill_lock);
10823 if (mtu > ill->ill_max_frag || mtu < ip_min_mtu) {
10824 mutex_exit(&ill->ill_lock);
10825 return (EINVAL);
10826 }
10827 /* Avoid increasing ill_mc_mtu */
10828 if (ill->ill_mc_mtu > mtu)
10829 ill->ill_mc_mtu = mtu;
10830
10831 /*
10832 * The dce and fragmentation code can handle changes to ill_mtu
10833 * concurrent with sending/fragmenting packets.
10834 */
10835 ill->ill_mtu = mtu;
10836 ill->ill_flags |= ILLF_FIXEDMTU;
10837 mutex_exit(&ill->ill_lock);
10838
10839 /*
10840 * Make sure all dce_generation checks find out
10841 * that ill_mtu/ill_mc_mtu has changed.
10842 */
10843 dce_increment_all_generations(ill->ill_isv6, ill->ill_ipst);
10844
10845 /*
10846 * Refresh IPMP meta-interface MTU if necessary.
10847 */
10848 if (IS_UNDER_IPMP(ill))
10849 ipmp_illgrp_refresh_mtu(ill->ill_grp);
10850
10851 /* Update the MTU in SCTP's list */
10852 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
10853 return (0);
10854 }
10855
10856 /* Get interface MTU. */
10857 /* ARGSUSED */
10858 int
10859 ip_sioctl_get_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10860 ip_ioctl_cmd_t *ipip, void *if_req)
10861 {
10862 struct ifreq *ifr;
10863 struct lifreq *lifr;
10864
10865 ip1dbg(("ip_sioctl_get_mtu(%s:%u %p)\n",
10866 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10867
10868 /*
10869 * We allow a get on any logical interface even though the set
10870 * can only be done on logical unit 0.
10871 */
10872 if (ipip->ipi_cmd_type == IF_CMD) {
10873 ifr = (struct ifreq *)if_req;
10874 ifr->ifr_metric = ipif->ipif_ill->ill_mtu;
10875 } else {
10876 lifr = (struct lifreq *)if_req;
10877 lifr->lifr_mtu = ipif->ipif_ill->ill_mtu;
10878 }
10879 return (0);
10880 }
10881
10882 /* Set interface broadcast address. */
10883 /* ARGSUSED2 */
10884 int
10885 ip_sioctl_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10886 ip_ioctl_cmd_t *ipip, void *if_req)
10887 {
10888 ipaddr_t addr;
10889 ire_t *ire;
10890 ill_t *ill = ipif->ipif_ill;
10891 ip_stack_t *ipst = ill->ill_ipst;
10892
10893 ip1dbg(("ip_sioctl_brdaddr(%s:%u)\n", ill->ill_name,
10894 ipif->ipif_id));
10895
10896 ASSERT(IAM_WRITER_IPIF(ipif));
10897 if (!(ipif->ipif_flags & IPIF_BROADCAST))
10898 return (EADDRNOTAVAIL);
10899
10900 ASSERT(!(ipif->ipif_isv6)); /* No IPv6 broadcast */
10901
10902 if (sin->sin_family != AF_INET)
10903 return (EAFNOSUPPORT);
10904
10905 addr = sin->sin_addr.s_addr;
10906
10907 if (ipif->ipif_flags & IPIF_UP) {
10908 /*
10909 * If we are already up, make sure the new
10910 * broadcast address makes sense. If it does,
10911 * there should be an IRE for it already.
10912 */
10913 ire = ire_ftable_lookup_v4(addr, 0, 0, IRE_BROADCAST,
10914 ill, ipif->ipif_zoneid, NULL,
10915 (MATCH_IRE_ILL | MATCH_IRE_TYPE), 0, ipst, NULL);
10916 if (ire == NULL) {
10917 return (EINVAL);
10918 } else {
10919 ire_refrele(ire);
10920 }
10921 }
10922 /*
10923 * Changing the broadcast addr for this ipif. Since the IRE_BROADCAST
10924 * needs to already exist we never need to change the set of
10925 * IRE_BROADCASTs when we are UP.
10926 */
10927 if (addr != ipif->ipif_brd_addr)
10928 IN6_IPADDR_TO_V4MAPPED(addr, &ipif->ipif_v6brd_addr);
10929
10930 return (0);
10931 }
10932
10933 /* Get interface broadcast address. */
10934 /* ARGSUSED */
10935 int
10936 ip_sioctl_get_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10937 ip_ioctl_cmd_t *ipip, void *if_req)
10938 {
10939 ip1dbg(("ip_sioctl_get_brdaddr(%s:%u %p)\n",
10940 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10941 if (!(ipif->ipif_flags & IPIF_BROADCAST))
10942 return (EADDRNOTAVAIL);
10943
10944 /* IPIF_BROADCAST not possible with IPv6 */
10945 ASSERT(!ipif->ipif_isv6);
10946 *sin = sin_null;
10947 sin->sin_family = AF_INET;
10948 sin->sin_addr.s_addr = ipif->ipif_brd_addr;
10949 return (0);
10950 }
10951
10952 /*
10953 * This routine is called to handle the SIOCS*IFNETMASK IOCTL.
10954 */
10955 /* ARGSUSED */
10956 int
10957 ip_sioctl_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10958 ip_ioctl_cmd_t *ipip, void *if_req)
10959 {
10960 int err = 0;
10961 in6_addr_t v6mask;
10962
10963 ip1dbg(("ip_sioctl_netmask(%s:%u %p)\n",
10964 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10965
10966 ASSERT(IAM_WRITER_IPIF(ipif));
10967
10968 if (ipif->ipif_isv6) {
10969 sin6_t *sin6;
10970
10971 if (sin->sin_family != AF_INET6)
10972 return (EAFNOSUPPORT);
10973
10974 sin6 = (sin6_t *)sin;
10975 v6mask = sin6->sin6_addr;
10976 } else {
10977 ipaddr_t mask;
10978
10979 if (sin->sin_family != AF_INET)
10980 return (EAFNOSUPPORT);
10981
10982 mask = sin->sin_addr.s_addr;
10983 if (!ip_contiguous_mask(ntohl(mask)))
10984 return (ENOTSUP);
10985 V4MASK_TO_V6(mask, v6mask);
10986 }
10987
10988 /*
10989 * No big deal if the interface isn't already up, or the mask
10990 * isn't really changing, or this is pt-pt.
10991 */
10992 if (!(ipif->ipif_flags & IPIF_UP) ||
10993 IN6_ARE_ADDR_EQUAL(&v6mask, &ipif->ipif_v6net_mask) ||
10994 (ipif->ipif_flags & IPIF_POINTOPOINT)) {
10995 ipif->ipif_v6net_mask = v6mask;
10996 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
10997 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
10998 ipif->ipif_v6net_mask,
10999 ipif->ipif_v6subnet);
11000 }
11001 return (0);
11002 }
11003 /*
11004 * Make sure we have valid net and subnet broadcast ire's
11005 * for the old netmask, if needed by other logical interfaces.
11006 */
11007 err = ipif_logical_down(ipif, q, mp);
11008 if (err == EINPROGRESS)
11009 return (err);
11010 (void) ipif_down_tail(ipif);
11011 err = ip_sioctl_netmask_tail(ipif, sin, q, mp);
11012 return (err);
11013 }
11014
11015 static int
11016 ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp)
11017 {
11018 in6_addr_t v6mask;
11019 int err = 0;
11020
11021 ip1dbg(("ip_sioctl_netmask_tail(%s:%u %p)\n",
11022 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11023
11024 if (ipif->ipif_isv6) {
11025 sin6_t *sin6;
11026
11027 sin6 = (sin6_t *)sin;
11028 v6mask = sin6->sin6_addr;
11029 } else {
11030 ipaddr_t mask;
11031
11032 mask = sin->sin_addr.s_addr;
11033 V4MASK_TO_V6(mask, v6mask);
11034 }
11035
11036 ipif->ipif_v6net_mask = v6mask;
11037 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
11038 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
11039 ipif->ipif_v6subnet);
11040 }
11041 err = ipif_up(ipif, q, mp);
11042
11043 if (err == 0 || err == EINPROGRESS) {
11044 /*
11045 * The interface must be DL_BOUND if this packet has to
11046 * go out on the wire. Since we only go through a logical
11047 * down and are bound with the driver during an internal
11048 * down/up that is satisfied.
11049 */
11050 if (!ipif->ipif_isv6 && ipif->ipif_ill->ill_wq != NULL) {
11051 /* Potentially broadcast an address mask reply. */
11052 ipif_mask_reply(ipif);
11053 }
11054 }
11055 return (err);
11056 }
11057
11058 /* ARGSUSED */
11059 int
11060 ip_sioctl_netmask_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11061 ip_ioctl_cmd_t *ipip, void *if_req)
11062 {
11063 ip1dbg(("ip_sioctl_netmask_restart(%s:%u %p)\n",
11064 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11065 (void) ipif_down_tail(ipif);
11066 return (ip_sioctl_netmask_tail(ipif, sin, q, mp));
11067 }
11068
11069 /* Get interface net mask. */
11070 /* ARGSUSED */
11071 int
11072 ip_sioctl_get_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11073 ip_ioctl_cmd_t *ipip, void *if_req)
11074 {
11075 struct lifreq *lifr = (struct lifreq *)if_req;
11076 struct sockaddr_in6 *sin6 = (sin6_t *)sin;
11077
11078 ip1dbg(("ip_sioctl_get_netmask(%s:%u %p)\n",
11079 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11080
11081 /*
11082 * net mask can't change since we have a reference to the ipif.
11083 */
11084 if (ipif->ipif_isv6) {
11085 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
11086 *sin6 = sin6_null;
11087 sin6->sin6_family = AF_INET6;
11088 sin6->sin6_addr = ipif->ipif_v6net_mask;
11089 lifr->lifr_addrlen =
11090 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
11091 } else {
11092 *sin = sin_null;
11093 sin->sin_family = AF_INET;
11094 sin->sin_addr.s_addr = ipif->ipif_net_mask;
11095 if (ipip->ipi_cmd_type == LIF_CMD) {
11096 lifr->lifr_addrlen =
11097 ip_mask_to_plen(ipif->ipif_net_mask);
11098 }
11099 }
11100 return (0);
11101 }
11102
11103 /* ARGSUSED */
11104 int
11105 ip_sioctl_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11106 ip_ioctl_cmd_t *ipip, void *if_req)
11107 {
11108 ip1dbg(("ip_sioctl_metric(%s:%u %p)\n",
11109 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11110
11111 /*
11112 * Since no applications should ever be setting metrics on underlying
11113 * interfaces, we explicitly fail to smoke 'em out.
11114 */
11115 if (IS_UNDER_IPMP(ipif->ipif_ill))
11116 return (EINVAL);
11117
11118 /*
11119 * Set interface metric. We don't use this for
11120 * anything but we keep track of it in case it is
11121 * important to routing applications or such.
11122 */
11123 if (ipip->ipi_cmd_type == IF_CMD) {
11124 struct ifreq *ifr;
11125
11126 ifr = (struct ifreq *)if_req;
11127 ipif->ipif_ill->ill_metric = ifr->ifr_metric;
11128 } else {
11129 struct lifreq *lifr;
11130
11131 lifr = (struct lifreq *)if_req;
11132 ipif->ipif_ill->ill_metric = lifr->lifr_metric;
11133 }
11134 return (0);
11135 }
11136
11137 /* ARGSUSED */
11138 int
11139 ip_sioctl_get_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11140 ip_ioctl_cmd_t *ipip, void *if_req)
11141 {
11142 /* Get interface metric. */
11143 ip1dbg(("ip_sioctl_get_metric(%s:%u %p)\n",
11144 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11145
11146 if (ipip->ipi_cmd_type == IF_CMD) {
11147 struct ifreq *ifr;
11148
11149 ifr = (struct ifreq *)if_req;
11150 ifr->ifr_metric = ipif->ipif_ill->ill_metric;
11151 } else {
11152 struct lifreq *lifr;
11153
11154 lifr = (struct lifreq *)if_req;
11155 lifr->lifr_metric = ipif->ipif_ill->ill_metric;
11156 }
11157
11158 return (0);
11159 }
11160
11161 /* ARGSUSED */
11162 int
11163 ip_sioctl_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11164 ip_ioctl_cmd_t *ipip, void *if_req)
11165 {
11166 int arp_muxid;
11167
11168 ip1dbg(("ip_sioctl_muxid(%s:%u %p)\n",
11169 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11170 /*
11171 * Set the muxid returned from I_PLINK.
11172 */
11173 if (ipip->ipi_cmd_type == IF_CMD) {
11174 struct ifreq *ifr = (struct ifreq *)if_req;
11175
11176 ipif->ipif_ill->ill_muxid = ifr->ifr_ip_muxid;
11177 arp_muxid = ifr->ifr_arp_muxid;
11178 } else {
11179 struct lifreq *lifr = (struct lifreq *)if_req;
11180
11181 ipif->ipif_ill->ill_muxid = lifr->lifr_ip_muxid;
11182 arp_muxid = lifr->lifr_arp_muxid;
11183 }
11184 arl_set_muxid(ipif->ipif_ill, arp_muxid);
11185 return (0);
11186 }
11187
11188 /* ARGSUSED */
11189 int
11190 ip_sioctl_get_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11191 ip_ioctl_cmd_t *ipip, void *if_req)
11192 {
11193 int arp_muxid = 0;
11194
11195 ip1dbg(("ip_sioctl_get_muxid(%s:%u %p)\n",
11196 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11197 /*
11198 * Get the muxid saved in ill for I_PUNLINK.
11199 */
11200 arp_muxid = arl_get_muxid(ipif->ipif_ill);
11201 if (ipip->ipi_cmd_type == IF_CMD) {
11202 struct ifreq *ifr = (struct ifreq *)if_req;
11203
11204 ifr->ifr_ip_muxid = ipif->ipif_ill->ill_muxid;
11205 ifr->ifr_arp_muxid = arp_muxid;
11206 } else {
11207 struct lifreq *lifr = (struct lifreq *)if_req;
11208
11209 lifr->lifr_ip_muxid = ipif->ipif_ill->ill_muxid;
11210 lifr->lifr_arp_muxid = arp_muxid;
11211 }
11212 return (0);
11213 }
11214
11215 /*
11216 * Set the subnet prefix. Does not modify the broadcast address.
11217 */
11218 /* ARGSUSED */
11219 int
11220 ip_sioctl_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11221 ip_ioctl_cmd_t *ipip, void *if_req)
11222 {
11223 int err = 0;
11224 in6_addr_t v6addr;
11225 in6_addr_t v6mask;
11226 boolean_t need_up = B_FALSE;
11227 int addrlen;
11228
11229 ip1dbg(("ip_sioctl_subnet(%s:%u %p)\n",
11230 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11231
11232 ASSERT(IAM_WRITER_IPIF(ipif));
11233 addrlen = ((struct lifreq *)if_req)->lifr_addrlen;
11234
11235 if (ipif->ipif_isv6) {
11236 sin6_t *sin6;
11237
11238 if (sin->sin_family != AF_INET6)
11239 return (EAFNOSUPPORT);
11240
11241 sin6 = (sin6_t *)sin;
11242 v6addr = sin6->sin6_addr;
11243 if (!ip_remote_addr_ok_v6(&v6addr, &ipv6_all_ones))
11244 return (EADDRNOTAVAIL);
11245 } else {
11246 ipaddr_t addr;
11247
11248 if (sin->sin_family != AF_INET)
11249 return (EAFNOSUPPORT);
11250
11251 addr = sin->sin_addr.s_addr;
11252 if (!ip_addr_ok_v4(addr, 0xFFFFFFFF))
11253 return (EADDRNOTAVAIL);
11254 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
11255 /* Add 96 bits */
11256 addrlen += IPV6_ABITS - IP_ABITS;
11257 }
11258
11259 if (ip_plen_to_mask_v6(addrlen, &v6mask) == NULL)
11260 return (EINVAL);
11261
11262 /* Check if bits in the address is set past the mask */
11263 if (!V6_MASK_EQ(v6addr, v6mask, v6addr))
11264 return (EINVAL);
11265
11266 if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6subnet, &v6addr) &&
11267 IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6net_mask, &v6mask))
11268 return (0); /* No change */
11269
11270 if (ipif->ipif_flags & IPIF_UP) {
11271 /*
11272 * If the interface is already marked up,
11273 * we call ipif_down which will take care
11274 * of ditching any IREs that have been set
11275 * up based on the old interface address.
11276 */
11277 err = ipif_logical_down(ipif, q, mp);
11278 if (err == EINPROGRESS)
11279 return (err);
11280 (void) ipif_down_tail(ipif);
11281 need_up = B_TRUE;
11282 }
11283
11284 err = ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, need_up);
11285 return (err);
11286 }
11287
11288 static int
11289 ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t v6addr, in6_addr_t v6mask,
11290 queue_t *q, mblk_t *mp, boolean_t need_up)
11291 {
11292 ill_t *ill = ipif->ipif_ill;
11293 int err = 0;
11294
11295 ip1dbg(("ip_sioctl_subnet_tail(%s:%u %p)\n",
11296 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11297
11298 /* Set the new address. */
11299 mutex_enter(&ill->ill_lock);
11300 ipif->ipif_v6net_mask = v6mask;
11301 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
11302 V6_MASK_COPY(v6addr, ipif->ipif_v6net_mask,
11303 ipif->ipif_v6subnet);
11304 }
11305 mutex_exit(&ill->ill_lock);
11306
11307 if (need_up) {
11308 /*
11309 * Now bring the interface back up. If this
11310 * is the only IPIF for the ILL, ipif_up
11311 * will have to re-bind to the device, so
11312 * we may get back EINPROGRESS, in which
11313 * case, this IOCTL will get completed in
11314 * ip_rput_dlpi when we see the DL_BIND_ACK.
11315 */
11316 err = ipif_up(ipif, q, mp);
11317 if (err == EINPROGRESS)
11318 return (err);
11319 }
11320 return (err);
11321 }
11322
11323 /* ARGSUSED */
11324 int
11325 ip_sioctl_subnet_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11326 ip_ioctl_cmd_t *ipip, void *if_req)
11327 {
11328 int addrlen;
11329 in6_addr_t v6addr;
11330 in6_addr_t v6mask;
11331 struct lifreq *lifr = (struct lifreq *)if_req;
11332
11333 ip1dbg(("ip_sioctl_subnet_restart(%s:%u %p)\n",
11334 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11335 (void) ipif_down_tail(ipif);
11336
11337 addrlen = lifr->lifr_addrlen;
11338 if (ipif->ipif_isv6) {
11339 sin6_t *sin6;
11340
11341 sin6 = (sin6_t *)sin;
11342 v6addr = sin6->sin6_addr;
11343 } else {
11344 ipaddr_t addr;
11345
11346 addr = sin->sin_addr.s_addr;
11347 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
11348 addrlen += IPV6_ABITS - IP_ABITS;
11349 }
11350 (void) ip_plen_to_mask_v6(addrlen, &v6mask);
11351
11352 return (ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, B_TRUE));
11353 }
11354
11355 /* ARGSUSED */
11356 int
11357 ip_sioctl_get_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11358 ip_ioctl_cmd_t *ipip, void *if_req)
11359 {
11360 struct lifreq *lifr = (struct lifreq *)if_req;
11361 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sin;
11362
11363 ip1dbg(("ip_sioctl_get_subnet(%s:%u %p)\n",
11364 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11365 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
11366
11367 if (ipif->ipif_isv6) {
11368 *sin6 = sin6_null;
11369 sin6->sin6_family = AF_INET6;
11370 sin6->sin6_addr = ipif->ipif_v6subnet;
11371 lifr->lifr_addrlen =
11372 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
11373 } else {
11374 *sin = sin_null;
11375 sin->sin_family = AF_INET;
11376 sin->sin_addr.s_addr = ipif->ipif_subnet;
11377 lifr->lifr_addrlen = ip_mask_to_plen(ipif->ipif_net_mask);
11378 }
11379 return (0);
11380 }
11381
11382 /*
11383 * Set the IPv6 address token.
11384 */
11385 /* ARGSUSED */
11386 int
11387 ip_sioctl_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11388 ip_ioctl_cmd_t *ipi, void *if_req)
11389 {
11390 ill_t *ill = ipif->ipif_ill;
11391 int err;
11392 in6_addr_t v6addr;
11393 in6_addr_t v6mask;
11394 boolean_t need_up = B_FALSE;
11395 int i;
11396 sin6_t *sin6 = (sin6_t *)sin;
11397 struct lifreq *lifr = (struct lifreq *)if_req;
11398 int addrlen;
11399
11400 ip1dbg(("ip_sioctl_token(%s:%u %p)\n",
11401 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11402 ASSERT(IAM_WRITER_IPIF(ipif));
11403
11404 addrlen = lifr->lifr_addrlen;
11405 /* Only allow for logical unit zero i.e. not on "le0:17" */
11406 if (ipif->ipif_id != 0)
11407 return (EINVAL);
11408
11409 if (!ipif->ipif_isv6)
11410 return (EINVAL);
11411
11412 if (addrlen > IPV6_ABITS)
11413 return (EINVAL);
11414
11415 v6addr = sin6->sin6_addr;
11416
11417 /*
11418 * The length of the token is the length from the end. To get
11419 * the proper mask for this, compute the mask of the bits not
11420 * in the token; ie. the prefix, and then xor to get the mask.
11421 */
11422 if (ip_plen_to_mask_v6(IPV6_ABITS - addrlen, &v6mask) == NULL)
11423 return (EINVAL);
11424 for (i = 0; i < 4; i++) {
11425 v6mask.s6_addr32[i] ^= (uint32_t)0xffffffff;
11426 }
11427
11428 if (V6_MASK_EQ(v6addr, v6mask, ill->ill_token) &&
11429 ill->ill_token_length == addrlen)
11430 return (0); /* No change */
11431
11432 if (ipif->ipif_flags & IPIF_UP) {
11433 err = ipif_logical_down(ipif, q, mp);
11434 if (err == EINPROGRESS)
11435 return (err);
11436 (void) ipif_down_tail(ipif);
11437 need_up = B_TRUE;
11438 }
11439 err = ip_sioctl_token_tail(ipif, sin6, addrlen, q, mp, need_up);
11440 return (err);
11441 }
11442
11443 static int
11444 ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen, queue_t *q,
11445 mblk_t *mp, boolean_t need_up)
11446 {
11447 in6_addr_t v6addr;
11448 in6_addr_t v6mask;
11449 ill_t *ill = ipif->ipif_ill;
11450 int i;
11451 int err = 0;
11452
11453 ip1dbg(("ip_sioctl_token_tail(%s:%u %p)\n",
11454 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11455 v6addr = sin6->sin6_addr;
11456 /*
11457 * The length of the token is the length from the end. To get
11458 * the proper mask for this, compute the mask of the bits not
11459 * in the token; ie. the prefix, and then xor to get the mask.
11460 */
11461 (void) ip_plen_to_mask_v6(IPV6_ABITS - addrlen, &v6mask);
11462 for (i = 0; i < 4; i++)
11463 v6mask.s6_addr32[i] ^= (uint32_t)0xffffffff;
11464
11465 mutex_enter(&ill->ill_lock);
11466 V6_MASK_COPY(v6addr, v6mask, ill->ill_token);
11467 ill->ill_token_length = addrlen;
11468 ill->ill_manual_token = 1;
11469
11470 /* Reconfigure the link-local address based on this new token */
11471 ipif_setlinklocal(ill->ill_ipif);
11472
11473 mutex_exit(&ill->ill_lock);
11474
11475 if (need_up) {
11476 /*
11477 * Now bring the interface back up. If this
11478 * is the only IPIF for the ILL, ipif_up
11479 * will have to re-bind to the device, so
11480 * we may get back EINPROGRESS, in which
11481 * case, this IOCTL will get completed in
11482 * ip_rput_dlpi when we see the DL_BIND_ACK.
11483 */
11484 err = ipif_up(ipif, q, mp);
11485 if (err == EINPROGRESS)
11486 return (err);
11487 }
11488 return (err);
11489 }
11490
11491 /* ARGSUSED */
11492 int
11493 ip_sioctl_get_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11494 ip_ioctl_cmd_t *ipi, void *if_req)
11495 {
11496 ill_t *ill;
11497 sin6_t *sin6 = (sin6_t *)sin;
11498 struct lifreq *lifr = (struct lifreq *)if_req;
11499
11500 ip1dbg(("ip_sioctl_get_token(%s:%u %p)\n",
11501 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11502 if (ipif->ipif_id != 0)
11503 return (EINVAL);
11504
11505 ill = ipif->ipif_ill;
11506 if (!ill->ill_isv6)
11507 return (ENXIO);
11508
11509 *sin6 = sin6_null;
11510 sin6->sin6_family = AF_INET6;
11511 ASSERT(!IN6_IS_ADDR_V4MAPPED(&ill->ill_token));
11512 sin6->sin6_addr = ill->ill_token;
11513 lifr->lifr_addrlen = ill->ill_token_length;
11514 return (0);
11515 }
11516
11517 /*
11518 * Set (hardware) link specific information that might override
11519 * what was acquired through the DL_INFO_ACK.
11520 */
11521 /* ARGSUSED */
11522 int
11523 ip_sioctl_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11524 ip_ioctl_cmd_t *ipi, void *if_req)
11525 {
11526 ill_t *ill = ipif->ipif_ill;
11527 int ip_min_mtu;
11528 struct lifreq *lifr = (struct lifreq *)if_req;
11529 lif_ifinfo_req_t *lir;
11530
11531 ip1dbg(("ip_sioctl_lnkinfo(%s:%u %p)\n",
11532 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11533 lir = &lifr->lifr_ifinfo;
11534 ASSERT(IAM_WRITER_IPIF(ipif));
11535
11536 /* Only allow for logical unit zero i.e. not on "bge0:17" */
11537 if (ipif->ipif_id != 0)
11538 return (EINVAL);
11539
11540 /* Set interface MTU. */
11541 if (ipif->ipif_isv6)
11542 ip_min_mtu = IPV6_MIN_MTU;
11543 else
11544 ip_min_mtu = IP_MIN_MTU;
11545
11546 /*
11547 * Verify values before we set anything. Allow zero to
11548 * mean unspecified.
11549 *
11550 * XXX We should be able to set the user-defined lir_mtu to some value
11551 * that is greater than ill_current_frag but less than ill_max_frag- the
11552 * ill_max_frag value tells us the max MTU that can be handled by the
11553 * datalink, whereas the ill_current_frag is dynamically computed for
11554 * some link-types like tunnels, based on the tunnel PMTU. However,
11555 * since there is currently no way of distinguishing between
11556 * administratively fixed link mtu values (e.g., those set via
11557 * /sbin/dladm) and dynamically discovered MTUs (e.g., those discovered
11558 * for tunnels) we conservatively choose the ill_current_frag as the
11559 * upper-bound.
11560 */
11561 if (lir->lir_maxmtu != 0 &&
11562 (lir->lir_maxmtu > ill->ill_current_frag ||
11563 lir->lir_maxmtu < ip_min_mtu))
11564 return (EINVAL);
11565 if (lir->lir_reachtime != 0 &&
11566 lir->lir_reachtime > ND_MAX_REACHTIME)
11567 return (EINVAL);
11568 if (lir->lir_reachretrans != 0 &&
11569 lir->lir_reachretrans > ND_MAX_REACHRETRANSTIME)
11570 return (EINVAL);
11571
11572 mutex_enter(&ill->ill_lock);
11573 /*
11574 * The dce and fragmentation code can handle changes to ill_mtu
11575 * concurrent with sending/fragmenting packets.
11576 */
11577 if (lir->lir_maxmtu != 0)
11578 ill->ill_user_mtu = lir->lir_maxmtu;
11579
11580 if (lir->lir_reachtime != 0)
11581 ill->ill_reachable_time = lir->lir_reachtime;
11582
11583 if (lir->lir_reachretrans != 0)
11584 ill->ill_reachable_retrans_time = lir->lir_reachretrans;
11585
11586 ill->ill_max_hops = lir->lir_maxhops;
11587 ill->ill_max_buf = ND_MAX_Q;
11588 if (!(ill->ill_flags & ILLF_FIXEDMTU) && ill->ill_user_mtu != 0) {
11589 /*
11590 * ill_mtu is the actual interface MTU, obtained as the min
11591 * of user-configured mtu and the value announced by the
11592 * driver (via DL_NOTE_SDU_SIZE/DL_INFO_ACK). Note that since
11593 * we have already made the choice of requiring
11594 * ill_user_mtu < ill_current_frag by the time we get here,
11595 * the ill_mtu effectively gets assigned to the ill_user_mtu
11596 * here.
11597 */
11598 ill->ill_mtu = MIN(ill->ill_current_frag, ill->ill_user_mtu);
11599 ill->ill_mc_mtu = MIN(ill->ill_mc_mtu, ill->ill_user_mtu);
11600 }
11601 mutex_exit(&ill->ill_lock);
11602
11603 /*
11604 * Make sure all dce_generation checks find out
11605 * that ill_mtu/ill_mc_mtu has changed.
11606 */
11607 if (!(ill->ill_flags & ILLF_FIXEDMTU) && (lir->lir_maxmtu != 0))
11608 dce_increment_all_generations(ill->ill_isv6, ill->ill_ipst);
11609
11610 /*
11611 * Refresh IPMP meta-interface MTU if necessary.
11612 */
11613 if (IS_UNDER_IPMP(ill))
11614 ipmp_illgrp_refresh_mtu(ill->ill_grp);
11615
11616 return (0);
11617 }
11618
11619 /* ARGSUSED */
11620 int
11621 ip_sioctl_get_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11622 ip_ioctl_cmd_t *ipi, void *if_req)
11623 {
11624 struct lif_ifinfo_req *lir;
11625 ill_t *ill = ipif->ipif_ill;
11626
11627 ip1dbg(("ip_sioctl_get_lnkinfo(%s:%u %p)\n",
11628 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11629 if (ipif->ipif_id != 0)
11630 return (EINVAL);
11631
11632 lir = &((struct lifreq *)if_req)->lifr_ifinfo;
11633 lir->lir_maxhops = ill->ill_max_hops;
11634 lir->lir_reachtime = ill->ill_reachable_time;
11635 lir->lir_reachretrans = ill->ill_reachable_retrans_time;
11636 lir->lir_maxmtu = ill->ill_mtu;
11637
11638 return (0);
11639 }
11640
11641 /*
11642 * Return best guess as to the subnet mask for the specified address.
11643 * Based on the subnet masks for all the configured interfaces.
11644 *
11645 * We end up returning a zero mask in the case of default, multicast or
11646 * experimental.
11647 */
11648 static ipaddr_t
11649 ip_subnet_mask(ipaddr_t addr, ipif_t **ipifp, ip_stack_t *ipst)
11650 {
11651 ipaddr_t net_mask;
11652 ill_t *ill;
11653 ipif_t *ipif;
11654 ill_walk_context_t ctx;
11655 ipif_t *fallback_ipif = NULL;
11656
11657 net_mask = ip_net_mask(addr);
11658 if (net_mask == 0) {
11659 *ipifp = NULL;
11660 return (0);
11661 }
11662
11663 /* Let's check to see if this is maybe a local subnet route. */
11664 /* this function only applies to IPv4 interfaces */
11665 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
11666 ill = ILL_START_WALK_V4(&ctx, ipst);
11667 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
11668 mutex_enter(&ill->ill_lock);
11669 for (ipif = ill->ill_ipif; ipif != NULL;
11670 ipif = ipif->ipif_next) {
11671 if (IPIF_IS_CONDEMNED(ipif))
11672 continue;
11673 if (!(ipif->ipif_flags & IPIF_UP))
11674 continue;
11675 if ((ipif->ipif_subnet & net_mask) ==
11676 (addr & net_mask)) {
11677 /*
11678 * Don't trust pt-pt interfaces if there are
11679 * other interfaces.
11680 */
11681 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
11682 if (fallback_ipif == NULL) {
11683 ipif_refhold_locked(ipif);
11684 fallback_ipif = ipif;
11685 }
11686 continue;
11687 }
11688
11689 /*
11690 * Fine. Just assume the same net mask as the
11691 * directly attached subnet interface is using.
11692 */
11693 ipif_refhold_locked(ipif);
11694 mutex_exit(&ill->ill_lock);
11695 rw_exit(&ipst->ips_ill_g_lock);
11696 if (fallback_ipif != NULL)
11697 ipif_refrele(fallback_ipif);
11698 *ipifp = ipif;
11699 return (ipif->ipif_net_mask);
11700 }
11701 }
11702 mutex_exit(&ill->ill_lock);
11703 }
11704 rw_exit(&ipst->ips_ill_g_lock);
11705
11706 *ipifp = fallback_ipif;
11707 return ((fallback_ipif != NULL) ?
11708 fallback_ipif->ipif_net_mask : net_mask);
11709 }
11710
11711 /*
11712 * ip_sioctl_copyin_setup calls ip_wput_ioctl to process the IP_IOCTL ioctl.
11713 */
11714 static void
11715 ip_wput_ioctl(queue_t *q, mblk_t *mp)
11716 {
11717 IOCP iocp;
11718 ipft_t *ipft;
11719 ipllc_t *ipllc;
11720 mblk_t *mp1;
11721 cred_t *cr;
11722 int error = 0;
11723 conn_t *connp;
11724
11725 ip1dbg(("ip_wput_ioctl"));
11726 iocp = (IOCP)mp->b_rptr;
11727 mp1 = mp->b_cont;
11728 if (mp1 == NULL) {
11729 iocp->ioc_error = EINVAL;
11730 mp->b_datap->db_type = M_IOCNAK;
11731 iocp->ioc_count = 0;
11732 qreply(q, mp);
11733 return;
11734 }
11735
11736 /*
11737 * These IOCTLs provide various control capabilities to
11738 * upstream agents such as ULPs and processes. There
11739 * are currently two such IOCTLs implemented. They
11740 * are used by TCP to provide update information for
11741 * existing IREs and to forcibly delete an IRE for a
11742 * host that is not responding, thereby forcing an
11743 * attempt at a new route.
11744 */
11745 iocp->ioc_error = EINVAL;
11746 if (!pullupmsg(mp1, sizeof (ipllc->ipllc_cmd)))
11747 goto done;
11748
11749 ipllc = (ipllc_t *)mp1->b_rptr;
11750 for (ipft = ip_ioctl_ftbl; ipft->ipft_pfi; ipft++) {
11751 if (ipllc->ipllc_cmd == ipft->ipft_cmd)
11752 break;
11753 }
11754 /*
11755 * prefer credential from mblk over ioctl;
11756 * see ip_sioctl_copyin_setup
11757 */
11758 cr = msg_getcred(mp, NULL);
11759 if (cr == NULL)
11760 cr = iocp->ioc_cr;
11761
11762 /*
11763 * Refhold the conn in case the request gets queued up in some lookup
11764 */
11765 ASSERT(CONN_Q(q));
11766 connp = Q_TO_CONN(q);
11767 CONN_INC_REF(connp);
11768 CONN_INC_IOCTLREF(connp);
11769 if (ipft->ipft_pfi &&
11770 ((mp1->b_wptr - mp1->b_rptr) >= ipft->ipft_min_size ||
11771 pullupmsg(mp1, ipft->ipft_min_size))) {
11772 error = (*ipft->ipft_pfi)(q,
11773 (ipft->ipft_flags & IPFT_F_SELF_REPLY) ? mp : mp1, cr);
11774 }
11775 if (ipft->ipft_flags & IPFT_F_SELF_REPLY) {
11776 /*
11777 * CONN_OPER_PENDING_DONE happens in the function called
11778 * through ipft_pfi above.
11779 */
11780 return;
11781 }
11782
11783 CONN_DEC_IOCTLREF(connp);
11784 CONN_OPER_PENDING_DONE(connp);
11785 if (ipft->ipft_flags & IPFT_F_NO_REPLY) {
11786 freemsg(mp);
11787 return;
11788 }
11789 iocp->ioc_error = error;
11790
11791 done:
11792 mp->b_datap->db_type = M_IOCACK;
11793 if (iocp->ioc_error)
11794 iocp->ioc_count = 0;
11795 qreply(q, mp);
11796 }
11797
11798 /*
11799 * Assign a unique id for the ipif. This is used by sctp_addr.c
11800 * Note: remove if sctp_addr.c is redone to not shadow ill/ipif data structures.
11801 */
11802 static void
11803 ipif_assign_seqid(ipif_t *ipif)
11804 {
11805 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
11806
11807 ipif->ipif_seqid = atomic_add_64_nv(&ipst->ips_ipif_g_seqid, 1);
11808 }
11809
11810 /*
11811 * Clone the contents of `sipif' to `dipif'. Requires that both ipifs are
11812 * administratively down (i.e., no DAD), of the same type, and locked. Note
11813 * that the clone is complete -- including the seqid -- and the expectation is
11814 * that the caller will either free or overwrite `sipif' before it's unlocked.
11815 */
11816 static void
11817 ipif_clone(const ipif_t *sipif, ipif_t *dipif)
11818 {
11819 ASSERT(MUTEX_HELD(&sipif->ipif_ill->ill_lock));
11820 ASSERT(MUTEX_HELD(&dipif->ipif_ill->ill_lock));
11821 ASSERT(!(sipif->ipif_flags & (IPIF_UP|IPIF_DUPLICATE)));
11822 ASSERT(!(dipif->ipif_flags & (IPIF_UP|IPIF_DUPLICATE)));
11823 ASSERT(sipif->ipif_ire_type == dipif->ipif_ire_type);
11824
11825 dipif->ipif_flags = sipif->ipif_flags;
11826 dipif->ipif_zoneid = sipif->ipif_zoneid;
11827 dipif->ipif_v6subnet = sipif->ipif_v6subnet;
11828 dipif->ipif_v6lcl_addr = sipif->ipif_v6lcl_addr;
11829 dipif->ipif_v6net_mask = sipif->ipif_v6net_mask;
11830 dipif->ipif_v6brd_addr = sipif->ipif_v6brd_addr;
11831 dipif->ipif_v6pp_dst_addr = sipif->ipif_v6pp_dst_addr;
11832
11833 /*
11834 * As per the comment atop the function, we assume that these sipif
11835 * fields will be changed before sipif is unlocked.
11836 */
11837 dipif->ipif_seqid = sipif->ipif_seqid;
11838 dipif->ipif_state_flags = sipif->ipif_state_flags;
11839 }
11840
11841 /*
11842 * Transfer the contents of `sipif' to `dipif', and then free (if `virgipif'
11843 * is NULL) or overwrite `sipif' with `virgipif', which must be a virgin
11844 * (unreferenced) ipif. Also, if `sipif' is used by the current xop, then
11845 * transfer the xop to `dipif'. Requires that all ipifs are administratively
11846 * down (i.e., no DAD), of the same type, and unlocked.
11847 */
11848 static void
11849 ipif_transfer(ipif_t *sipif, ipif_t *dipif, ipif_t *virgipif)
11850 {
11851 ipsq_t *ipsq = sipif->ipif_ill->ill_phyint->phyint_ipsq;
11852 ipxop_t *ipx = ipsq->ipsq_xop;
11853
11854 ASSERT(sipif != dipif);
11855 ASSERT(sipif != virgipif);
11856
11857 /*
11858 * Grab all of the locks that protect the ipif in a defined order.
11859 */
11860 GRAB_ILL_LOCKS(sipif->ipif_ill, dipif->ipif_ill);
11861
11862 ipif_clone(sipif, dipif);
11863 if (virgipif != NULL) {
11864 ipif_clone(virgipif, sipif);
11865 mi_free(virgipif);
11866 }
11867
11868 RELEASE_ILL_LOCKS(sipif->ipif_ill, dipif->ipif_ill);
11869
11870 /*
11871 * Transfer ownership of the current xop, if necessary.
11872 */
11873 if (ipx->ipx_current_ipif == sipif) {
11874 ASSERT(ipx->ipx_pending_ipif == NULL);
11875 mutex_enter(&ipx->ipx_lock);
11876 ipx->ipx_current_ipif = dipif;
11877 mutex_exit(&ipx->ipx_lock);
11878 }
11879
11880 if (virgipif == NULL)
11881 mi_free(sipif);
11882 }
11883
11884 /*
11885 * checks if:
11886 * - <ill_name>:<ipif_id> is at most LIFNAMSIZ - 1 and
11887 * - logical interface is within the allowed range
11888 */
11889 static int
11890 is_lifname_valid(ill_t *ill, unsigned int ipif_id)
11891 {
11892 if (snprintf(NULL, 0, "%s:%d", ill->ill_name, ipif_id) >= LIFNAMSIZ)
11893 return (ENAMETOOLONG);
11894
11895 if (ipif_id >= ill->ill_ipst->ips_ip_addrs_per_if)
11896 return (ERANGE);
11897 return (0);
11898 }
11899
11900 /*
11901 * Insert the ipif, so that the list of ipifs on the ill will be sorted
11902 * with respect to ipif_id. Note that an ipif with an ipif_id of -1 will
11903 * be inserted into the first space available in the list. The value of
11904 * ipif_id will then be set to the appropriate value for its position.
11905 */
11906 static int
11907 ipif_insert(ipif_t *ipif, boolean_t acquire_g_lock)
11908 {
11909 ill_t *ill;
11910 ipif_t *tipif;
11911 ipif_t **tipifp;
11912 int id, err;
11913 ip_stack_t *ipst;
11914
11915 ASSERT(ipif->ipif_ill->ill_net_type == IRE_LOOPBACK ||
11916 IAM_WRITER_IPIF(ipif));
11917
11918 ill = ipif->ipif_ill;
11919 ASSERT(ill != NULL);
11920 ipst = ill->ill_ipst;
11921
11922 /*
11923 * In the case of lo0:0 we already hold the ill_g_lock.
11924 * ill_lookup_on_name (acquires ill_g_lock) -> ipif_allocate ->
11925 * ipif_insert.
11926 */
11927 if (acquire_g_lock)
11928 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
11929 mutex_enter(&ill->ill_lock);
11930 id = ipif->ipif_id;
11931 tipifp = &(ill->ill_ipif);
11932 if (id == -1) { /* need to find a real id */
11933 id = 0;
11934 while ((tipif = *tipifp) != NULL) {
11935 ASSERT(tipif->ipif_id >= id);
11936 if (tipif->ipif_id != id)
11937 break; /* non-consecutive id */
11938 id++;
11939 tipifp = &(tipif->ipif_next);
11940 }
11941 if ((err = is_lifname_valid(ill, id)) != 0) {
11942 mutex_exit(&ill->ill_lock);
11943 if (acquire_g_lock)
11944 rw_exit(&ipst->ips_ill_g_lock);
11945 return (err);
11946 }
11947 ipif->ipif_id = id; /* assign new id */
11948 } else if ((err = is_lifname_valid(ill, id)) == 0) {
11949 /* we have a real id; insert ipif in the right place */
11950 while ((tipif = *tipifp) != NULL) {
11951 ASSERT(tipif->ipif_id != id);
11952 if (tipif->ipif_id > id)
11953 break; /* found correct location */
11954 tipifp = &(tipif->ipif_next);
11955 }
11956 } else {
11957 mutex_exit(&ill->ill_lock);
11958 if (acquire_g_lock)
11959 rw_exit(&ipst->ips_ill_g_lock);
11960 return (err);
11961 }
11962
11963 ASSERT(tipifp != &(ill->ill_ipif) || id == 0);
11964
11965 ipif->ipif_next = tipif;
11966 *tipifp = ipif;
11967 mutex_exit(&ill->ill_lock);
11968 if (acquire_g_lock)
11969 rw_exit(&ipst->ips_ill_g_lock);
11970
11971 return (0);
11972 }
11973
11974 static void
11975 ipif_remove(ipif_t *ipif)
11976 {
11977 ipif_t **ipifp;
11978 ill_t *ill = ipif->ipif_ill;
11979
11980 ASSERT(RW_WRITE_HELD(&ill->ill_ipst->ips_ill_g_lock));
11981
11982 mutex_enter(&ill->ill_lock);
11983 ipifp = &ill->ill_ipif;
11984 for (; *ipifp != NULL; ipifp = &ipifp[0]->ipif_next) {
11985 if (*ipifp == ipif) {
11986 *ipifp = ipif->ipif_next;
11987 break;
11988 }
11989 }
11990 mutex_exit(&ill->ill_lock);
11991 }
11992
11993 /*
11994 * Allocate and initialize a new interface control structure. (Always
11995 * called as writer.)
11996 * When ipif_allocate() is called from ip_ll_subnet_defaults, the ill
11997 * is not part of the global linked list of ills. ipif_seqid is unique
11998 * in the system and to preserve the uniqueness, it is assigned only
11999 * when ill becomes part of the global list. At that point ill will
12000 * have a name. If it doesn't get assigned here, it will get assigned
12001 * in ipif_set_values() as part of SIOCSLIFNAME processing.
12002 * Aditionally, if we come here from ip_ll_subnet_defaults, we don't set
12003 * the interface flags or any other information from the DL_INFO_ACK for
12004 * DL_STYLE2 drivers (initialize == B_FALSE), since we won't have them at
12005 * this point. The flags etc. will be set in ip_ll_subnet_defaults when the
12006 * second DL_INFO_ACK comes in from the driver.
12007 */
12008 static ipif_t *
12009 ipif_allocate(ill_t *ill, int id, uint_t ire_type, boolean_t initialize,
12010 boolean_t insert, int *errorp)
12011 {
12012 int err;
12013 ipif_t *ipif;
12014 ip_stack_t *ipst = ill->ill_ipst;
12015
12016 ip1dbg(("ipif_allocate(%s:%d ill %p)\n",
12017 ill->ill_name, id, (void *)ill));
12018 ASSERT(ire_type == IRE_LOOPBACK || IAM_WRITER_ILL(ill));
12019
12020 if (errorp != NULL)
12021 *errorp = 0;
12022
12023 if ((ipif = mi_alloc(sizeof (ipif_t), BPRI_MED)) == NULL) {
12024 if (errorp != NULL)
12025 *errorp = ENOMEM;
12026 return (NULL);
12027 }
12028 *ipif = ipif_zero; /* start clean */
12029
12030 ipif->ipif_ill = ill;
12031 ipif->ipif_id = id; /* could be -1 */
12032 /*
12033 * Inherit the zoneid from the ill; for the shared stack instance
12034 * this is always the global zone
12035 */
12036 ipif->ipif_zoneid = ill->ill_zoneid;
12037
12038 ipif->ipif_refcnt = 0;
12039
12040 if (insert) {
12041 if ((err = ipif_insert(ipif, ire_type != IRE_LOOPBACK)) != 0) {
12042 mi_free(ipif);
12043 if (errorp != NULL)
12044 *errorp = err;
12045 return (NULL);
12046 }
12047 /* -1 id should have been replaced by real id */
12048 id = ipif->ipif_id;
12049 ASSERT(id >= 0);
12050 }
12051
12052 if (ill->ill_name[0] != '\0')
12053 ipif_assign_seqid(ipif);
12054
12055 /*
12056 * If this is the zeroth ipif on the IPMP ill, create the illgrp
12057 * (which must not exist yet because the zeroth ipif is created once
12058 * per ill). However, do not not link it to the ipmp_grp_t until
12059 * I_PLINK is called; see ip_sioctl_plink_ipmp() for details.
12060 */
12061 if (id == 0 && IS_IPMP(ill)) {
12062 if (ipmp_illgrp_create(ill) == NULL) {
12063 if (insert) {
12064 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
12065 ipif_remove(ipif);
12066 rw_exit(&ipst->ips_ill_g_lock);
12067 }
12068 mi_free(ipif);
12069 if (errorp != NULL)
12070 *errorp = ENOMEM;
12071 return (NULL);
12072 }
12073 }
12074
12075 /*
12076 * We grab ill_lock to protect the flag changes. The ipif is still
12077 * not up and can't be looked up until the ioctl completes and the
12078 * IPIF_CHANGING flag is cleared.
12079 */
12080 mutex_enter(&ill->ill_lock);
12081
12082 ipif->ipif_ire_type = ire_type;
12083
12084 if (ipif->ipif_isv6) {
12085 ill->ill_flags |= ILLF_IPV6;
12086 } else {
12087 ipaddr_t inaddr_any = INADDR_ANY;
12088
12089 ill->ill_flags |= ILLF_IPV4;
12090
12091 /* Keep the IN6_IS_ADDR_V4MAPPED assertions happy */
12092 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12093 &ipif->ipif_v6lcl_addr);
12094 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12095 &ipif->ipif_v6subnet);
12096 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12097 &ipif->ipif_v6net_mask);
12098 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12099 &ipif->ipif_v6brd_addr);
12100 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12101 &ipif->ipif_v6pp_dst_addr);
12102 }
12103
12104 /*
12105 * Don't set the interface flags etc. now, will do it in
12106 * ip_ll_subnet_defaults.
12107 */
12108 if (!initialize)
12109 goto out;
12110
12111 /*
12112 * NOTE: The IPMP meta-interface is special-cased because it starts
12113 * with no underlying interfaces (and thus an unknown broadcast
12114 * address length), but all interfaces that can be placed into an IPMP
12115 * group are required to be broadcast-capable.
12116 */
12117 if (ill->ill_bcast_addr_length != 0 || IS_IPMP(ill)) {
12118 /*
12119 * Later detect lack of DLPI driver multicast capability by
12120 * catching DL_ENABMULTI_REQ errors in ip_rput_dlpi().
12121 */
12122 ill->ill_flags |= ILLF_MULTICAST;
12123 if (!ipif->ipif_isv6)
12124 ipif->ipif_flags |= IPIF_BROADCAST;
12125 } else {
12126 if (ill->ill_net_type != IRE_LOOPBACK) {
12127 if (ipif->ipif_isv6)
12128 /*
12129 * Note: xresolv interfaces will eventually need
12130 * NOARP set here as well, but that will require
12131 * those external resolvers to have some
12132 * knowledge of that flag and act appropriately.
12133 * Not to be changed at present.
12134 */
12135 ill->ill_flags |= ILLF_NONUD;
12136 else
12137 ill->ill_flags |= ILLF_NOARP;
12138 }
12139 if (ill->ill_phys_addr_length == 0) {
12140 if (IS_VNI(ill)) {
12141 ipif->ipif_flags |= IPIF_NOXMIT;
12142 } else {
12143 /* pt-pt supports multicast. */
12144 ill->ill_flags |= ILLF_MULTICAST;
12145 if (ill->ill_net_type != IRE_LOOPBACK)
12146 ipif->ipif_flags |= IPIF_POINTOPOINT;
12147 }
12148 }
12149 }
12150 out:
12151 mutex_exit(&ill->ill_lock);
12152 return (ipif);
12153 }
12154
12155 /*
12156 * Remove the neighbor cache entries associated with this logical
12157 * interface.
12158 */
12159 int
12160 ipif_arp_down(ipif_t *ipif)
12161 {
12162 ill_t *ill = ipif->ipif_ill;
12163 int err = 0;
12164
12165 ip1dbg(("ipif_arp_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
12166 ASSERT(IAM_WRITER_IPIF(ipif));
12167
12168 DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_down",
12169 ill_t *, ill, ipif_t *, ipif);
12170 ipif_nce_down(ipif);
12171
12172 /*
12173 * If this is the last ipif that is going down and there are no
12174 * duplicate addresses we may yet attempt to re-probe, then we need to
12175 * clean up ARP completely.
12176 */
12177 if (ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
12178 !ill->ill_logical_down && ill->ill_net_type == IRE_IF_RESOLVER) {
12179 /*
12180 * If this was the last ipif on an IPMP interface, purge any
12181 * static ARP entries associated with it.
12182 */
12183 if (IS_IPMP(ill))
12184 ipmp_illgrp_refresh_arpent(ill->ill_grp);
12185
12186 /* UNBIND, DETACH */
12187 err = arp_ll_down(ill);
12188 }
12189
12190 return (err);
12191 }
12192
12193 /*
12194 * Get the resolver set up for a new IP address. (Always called as writer.)
12195 * Called both for IPv4 and IPv6 interfaces, though it only does some
12196 * basic DAD related initialization for IPv6. Honors ILLF_NOARP.
12197 *
12198 * The enumerated value res_act tunes the behavior:
12199 * * Res_act_initial: set up all the resolver structures for a new
12200 * IP address.
12201 * * Res_act_defend: tell ARP that it needs to send a single gratuitous
12202 * ARP message in defense of the address.
12203 * * Res_act_rebind: tell ARP to change the hardware address for an IP
12204 * address (and issue gratuitous ARPs). Used by ipmp_ill_bind_ipif().
12205 *
12206 * Returns zero on success, or an errno upon failure.
12207 */
12208 int
12209 ipif_resolver_up(ipif_t *ipif, enum ip_resolver_action res_act)
12210 {
12211 ill_t *ill = ipif->ipif_ill;
12212 int err;
12213 boolean_t was_dup;
12214
12215 ip1dbg(("ipif_resolver_up(%s:%u) flags 0x%x\n",
12216 ill->ill_name, ipif->ipif_id, (uint_t)ipif->ipif_flags));
12217 ASSERT(IAM_WRITER_IPIF(ipif));
12218
12219 was_dup = B_FALSE;
12220 if (res_act == Res_act_initial) {
12221 ipif->ipif_addr_ready = 0;
12222 /*
12223 * We're bringing an interface up here. There's no way that we
12224 * should need to shut down ARP now.
12225 */
12226 mutex_enter(&ill->ill_lock);
12227 if (ipif->ipif_flags & IPIF_DUPLICATE) {
12228 ipif->ipif_flags &= ~IPIF_DUPLICATE;
12229 ill->ill_ipif_dup_count--;
12230 was_dup = B_TRUE;
12231 }
12232 mutex_exit(&ill->ill_lock);
12233 }
12234 if (ipif->ipif_recovery_id != 0)
12235 (void) untimeout(ipif->ipif_recovery_id);
12236 ipif->ipif_recovery_id = 0;
12237 if (ill->ill_net_type != IRE_IF_RESOLVER) {
12238 ipif->ipif_addr_ready = 1;
12239 return (0);
12240 }
12241 /* NDP will set the ipif_addr_ready flag when it's ready */
12242 if (ill->ill_isv6)
12243 return (0);
12244
12245 err = ipif_arp_up(ipif, res_act, was_dup);
12246 return (err);
12247 }
12248
12249 /*
12250 * This routine restarts IPv4/IPv6 duplicate address detection (DAD)
12251 * when a link has just gone back up.
12252 */
12253 static void
12254 ipif_nce_start_dad(ipif_t *ipif)
12255 {
12256 ncec_t *ncec;
12257 ill_t *ill = ipif->ipif_ill;
12258 boolean_t isv6 = ill->ill_isv6;
12259
12260 if (isv6) {
12261 ncec = ncec_lookup_illgrp_v6(ipif->ipif_ill,
12262 &ipif->ipif_v6lcl_addr);
12263 } else {
12264 ipaddr_t v4addr;
12265
12266 if (ill->ill_net_type != IRE_IF_RESOLVER ||
12267 (ipif->ipif_flags & IPIF_UNNUMBERED) ||
12268 ipif->ipif_lcl_addr == INADDR_ANY) {
12269 /*
12270 * If we can't contact ARP for some reason,
12271 * that's not really a problem. Just send
12272 * out the routing socket notification that
12273 * DAD completion would have done, and continue.
12274 */
12275 ipif_mask_reply(ipif);
12276 ipif_up_notify(ipif);
12277 ipif->ipif_addr_ready = 1;
12278 return;
12279 }
12280
12281 IN6_V4MAPPED_TO_IPADDR(&ipif->ipif_v6lcl_addr, v4addr);
12282 ncec = ncec_lookup_illgrp_v4(ipif->ipif_ill, &v4addr);
12283 }
12284
12285 if (ncec == NULL) {
12286 ip1dbg(("couldn't find ncec for ipif %p leaving !ready\n",
12287 (void *)ipif));
12288 return;
12289 }
12290 if (!nce_restart_dad(ncec)) {
12291 /*
12292 * If we can't restart DAD for some reason, that's not really a
12293 * problem. Just send out the routing socket notification that
12294 * DAD completion would have done, and continue.
12295 */
12296 ipif_up_notify(ipif);
12297 ipif->ipif_addr_ready = 1;
12298 }
12299 ncec_refrele(ncec);
12300 }
12301
12302 /*
12303 * Restart duplicate address detection on all interfaces on the given ill.
12304 *
12305 * This is called when an interface transitions from down to up
12306 * (DL_NOTE_LINK_UP) or up to down (DL_NOTE_LINK_DOWN).
12307 *
12308 * Note that since the underlying physical link has transitioned, we must cause
12309 * at least one routing socket message to be sent here, either via DAD
12310 * completion or just by default on the first ipif. (If we don't do this, then
12311 * in.mpathd will see long delays when doing link-based failure recovery.)
12312 */
12313 void
12314 ill_restart_dad(ill_t *ill, boolean_t went_up)
12315 {
12316 ipif_t *ipif;
12317
12318 if (ill == NULL)
12319 return;
12320
12321 /*
12322 * If layer two doesn't support duplicate address detection, then just
12323 * send the routing socket message now and be done with it.
12324 */
12325 if (!ill->ill_isv6 && arp_no_defense) {
12326 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
12327 return;
12328 }
12329
12330 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12331 if (went_up) {
12332
12333 if (ipif->ipif_flags & IPIF_UP) {
12334 ipif_nce_start_dad(ipif);
12335 } else if (ipif->ipif_flags & IPIF_DUPLICATE) {
12336 /*
12337 * kick off the bring-up process now.
12338 */
12339 ipif_do_recovery(ipif);
12340 } else {
12341 /*
12342 * Unfortunately, the first ipif is "special"
12343 * and represents the underlying ill in the
12344 * routing socket messages. Thus, when this
12345 * one ipif is down, we must still notify so
12346 * that the user knows the IFF_RUNNING status
12347 * change. (If the first ipif is up, then
12348 * we'll handle eventual routing socket
12349 * notification via DAD completion.)
12350 */
12351 if (ipif == ill->ill_ipif) {
12352 ip_rts_ifmsg(ill->ill_ipif,
12353 RTSQ_DEFAULT);
12354 }
12355 }
12356 } else {
12357 /*
12358 * After link down, we'll need to send a new routing
12359 * message when the link comes back, so clear
12360 * ipif_addr_ready.
12361 */
12362 ipif->ipif_addr_ready = 0;
12363 }
12364 }
12365
12366 /*
12367 * If we've torn down links, then notify the user right away.
12368 */
12369 if (!went_up)
12370 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
12371 }
12372
12373 static void
12374 ipsq_delete(ipsq_t *ipsq)
12375 {
12376 ipxop_t *ipx = ipsq->ipsq_xop;
12377
12378 ipsq->ipsq_ipst = NULL;
12379 ASSERT(ipsq->ipsq_phyint == NULL);
12380 ASSERT(ipsq->ipsq_xop != NULL);
12381 ASSERT(ipsq->ipsq_xopq_mphead == NULL && ipx->ipx_mphead == NULL);
12382 ASSERT(ipx->ipx_pending_mp == NULL);
12383 kmem_free(ipsq, sizeof (ipsq_t));
12384 }
12385
12386 static int
12387 ill_up_ipifs_on_ill(ill_t *ill, queue_t *q, mblk_t *mp)
12388 {
12389 int err = 0;
12390 ipif_t *ipif;
12391
12392 if (ill == NULL)
12393 return (0);
12394
12395 ASSERT(IAM_WRITER_ILL(ill));
12396 ill->ill_up_ipifs = B_TRUE;
12397 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12398 if (ipif->ipif_was_up) {
12399 if (!(ipif->ipif_flags & IPIF_UP))
12400 err = ipif_up(ipif, q, mp);
12401 ipif->ipif_was_up = B_FALSE;
12402 if (err != 0) {
12403 ASSERT(err == EINPROGRESS);
12404 return (err);
12405 }
12406 }
12407 }
12408 ill->ill_up_ipifs = B_FALSE;
12409 return (0);
12410 }
12411
12412 /*
12413 * This function is called to bring up all the ipifs that were up before
12414 * bringing the ill down via ill_down_ipifs().
12415 */
12416 int
12417 ill_up_ipifs(ill_t *ill, queue_t *q, mblk_t *mp)
12418 {
12419 int err;
12420
12421 ASSERT(IAM_WRITER_ILL(ill));
12422
12423 if (ill->ill_replumbing) {
12424 ill->ill_replumbing = 0;
12425 /*
12426 * Send down REPLUMB_DONE notification followed by the
12427 * BIND_REQ on the arp stream.
12428 */
12429 if (!ill->ill_isv6)
12430 arp_send_replumb_conf(ill);
12431 }
12432 err = ill_up_ipifs_on_ill(ill->ill_phyint->phyint_illv4, q, mp);
12433 if (err != 0)
12434 return (err);
12435
12436 return (ill_up_ipifs_on_ill(ill->ill_phyint->phyint_illv6, q, mp));
12437 }
12438
12439 /*
12440 * Bring down any IPIF_UP ipifs on ill. If "logical" is B_TRUE, we bring
12441 * down the ipifs without sending DL_UNBIND_REQ to the driver.
12442 */
12443 static void
12444 ill_down_ipifs(ill_t *ill, boolean_t logical)
12445 {
12446 ipif_t *ipif;
12447
12448 ASSERT(IAM_WRITER_ILL(ill));
12449
12450 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12451 /*
12452 * We go through the ipif_down logic even if the ipif
12453 * is already down, since routes can be added based
12454 * on down ipifs. Going through ipif_down once again
12455 * will delete any IREs created based on these routes.
12456 */
12457 if (ipif->ipif_flags & IPIF_UP)
12458 ipif->ipif_was_up = B_TRUE;
12459
12460 if (logical) {
12461 (void) ipif_logical_down(ipif, NULL, NULL);
12462 ipif_non_duplicate(ipif);
12463 (void) ipif_down_tail(ipif);
12464 } else {
12465 (void) ipif_down(ipif, NULL, NULL);
12466 }
12467 }
12468 }
12469
12470 /*
12471 * Redo source address selection. This makes IXAF_VERIFY_SOURCE take
12472 * a look again at valid source addresses.
12473 * This should be called each time after the set of source addresses has been
12474 * changed.
12475 */
12476 void
12477 ip_update_source_selection(ip_stack_t *ipst)
12478 {
12479 /* We skip past SRC_GENERATION_VERIFY */
12480 if (atomic_add_32_nv(&ipst->ips_src_generation, 1) ==
12481 SRC_GENERATION_VERIFY)
12482 atomic_add_32(&ipst->ips_src_generation, 1);
12483 }
12484
12485 /*
12486 * Finish the group join started in ip_sioctl_groupname().
12487 */
12488 /* ARGSUSED */
12489 static void
12490 ip_join_illgrps(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy)
12491 {
12492 ill_t *ill = q->q_ptr;
12493 phyint_t *phyi = ill->ill_phyint;
12494 ipmp_grp_t *grp = phyi->phyint_grp;
12495 ip_stack_t *ipst = ill->ill_ipst;
12496
12497 /* IS_UNDER_IPMP() won't work until ipmp_ill_join_illgrp() is called */
12498 ASSERT(!IS_IPMP(ill) && grp != NULL);
12499 ASSERT(IAM_WRITER_IPSQ(ipsq));
12500
12501 if (phyi->phyint_illv4 != NULL) {
12502 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
12503 VERIFY(grp->gr_pendv4-- > 0);
12504 rw_exit(&ipst->ips_ipmp_lock);
12505 ipmp_ill_join_illgrp(phyi->phyint_illv4, grp->gr_v4);
12506 }
12507 if (phyi->phyint_illv6 != NULL) {
12508 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
12509 VERIFY(grp->gr_pendv6-- > 0);
12510 rw_exit(&ipst->ips_ipmp_lock);
12511 ipmp_ill_join_illgrp(phyi->phyint_illv6, grp->gr_v6);
12512 }
12513 freemsg(mp);
12514 }
12515
12516 /*
12517 * Process an SIOCSLIFGROUPNAME request.
12518 */
12519 /* ARGSUSED */
12520 int
12521 ip_sioctl_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12522 ip_ioctl_cmd_t *ipip, void *ifreq)
12523 {
12524 struct lifreq *lifr = ifreq;
12525 ill_t *ill = ipif->ipif_ill;
12526 ip_stack_t *ipst = ill->ill_ipst;
12527 phyint_t *phyi = ill->ill_phyint;
12528 ipmp_grp_t *grp = phyi->phyint_grp;
12529 mblk_t *ipsq_mp;
12530 int err = 0;
12531
12532 /*
12533 * Note that phyint_grp can only change here, where we're exclusive.
12534 */
12535 ASSERT(IAM_WRITER_ILL(ill));
12536
12537 if (ipif->ipif_id != 0 || ill->ill_usesrc_grp_next != NULL ||
12538 (phyi->phyint_flags & PHYI_VIRTUAL))
12539 return (EINVAL);
12540
12541 lifr->lifr_groupname[LIFGRNAMSIZ - 1] = '\0';
12542
12543 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
12544
12545 /*
12546 * If the name hasn't changed, there's nothing to do.
12547 */
12548 if (grp != NULL && strcmp(grp->gr_name, lifr->lifr_groupname) == 0)
12549 goto unlock;
12550
12551 /*
12552 * Handle requests to rename an IPMP meta-interface.
12553 *
12554 * Note that creation of the IPMP meta-interface is handled in
12555 * userland through the standard plumbing sequence. As part of the
12556 * plumbing the IPMP meta-interface, its initial groupname is set to
12557 * the name of the interface (see ipif_set_values_tail()).
12558 */
12559 if (IS_IPMP(ill)) {
12560 err = ipmp_grp_rename(grp, lifr->lifr_groupname);
12561 goto unlock;
12562 }
12563
12564 /*
12565 * Handle requests to add or remove an IP interface from a group.
12566 */
12567 if (lifr->lifr_groupname[0] != '\0') { /* add */
12568 /*
12569 * Moves are handled by first removing the interface from
12570 * its existing group, and then adding it to another group.
12571 * So, fail if it's already in a group.
12572 */
12573 if (IS_UNDER_IPMP(ill)) {
12574 err = EALREADY;
12575 goto unlock;
12576 }
12577
12578 grp = ipmp_grp_lookup(lifr->lifr_groupname, ipst);
12579 if (grp == NULL) {
12580 err = ENOENT;
12581 goto unlock;
12582 }
12583
12584 /*
12585 * Check if the phyint and its ills are suitable for
12586 * inclusion into the group.
12587 */
12588 if ((err = ipmp_grp_vet_phyint(grp, phyi)) != 0)
12589 goto unlock;
12590
12591 /*
12592 * Checks pass; join the group, and enqueue the remaining
12593 * illgrp joins for when we've become part of the group xop
12594 * and are exclusive across its IPSQs. Since qwriter_ip()
12595 * requires an mblk_t to scribble on, and since `mp' will be
12596 * freed as part of completing the ioctl, allocate another.
12597 */
12598 if ((ipsq_mp = allocb(0, BPRI_MED)) == NULL) {
12599 err = ENOMEM;
12600 goto unlock;
12601 }
12602
12603 /*
12604 * Before we drop ipmp_lock, bump gr_pend* to ensure that the
12605 * IPMP meta-interface ills needed by `phyi' cannot go away
12606 * before ip_join_illgrps() is called back. See the comments
12607 * in ip_sioctl_plink_ipmp() for more.
12608 */
12609 if (phyi->phyint_illv4 != NULL)
12610 grp->gr_pendv4++;
12611 if (phyi->phyint_illv6 != NULL)
12612 grp->gr_pendv6++;
12613
12614 rw_exit(&ipst->ips_ipmp_lock);
12615
12616 ipmp_phyint_join_grp(phyi, grp);
12617 ill_refhold(ill);
12618 qwriter_ip(ill, ill->ill_rq, ipsq_mp, ip_join_illgrps,
12619 SWITCH_OP, B_FALSE);
12620 return (0);
12621 } else {
12622 /*
12623 * Request to remove the interface from a group. If the
12624 * interface is not in a group, this trivially succeeds.
12625 */
12626 rw_exit(&ipst->ips_ipmp_lock);
12627 if (IS_UNDER_IPMP(ill))
12628 ipmp_phyint_leave_grp(phyi);
12629 return (0);
12630 }
12631 unlock:
12632 rw_exit(&ipst->ips_ipmp_lock);
12633 return (err);
12634 }
12635
12636 /*
12637 * Process an SIOCGLIFBINDING request.
12638 */
12639 /* ARGSUSED */
12640 int
12641 ip_sioctl_get_binding(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12642 ip_ioctl_cmd_t *ipip, void *ifreq)
12643 {
12644 ill_t *ill;
12645 struct lifreq *lifr = ifreq;
12646 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
12647
12648 if (!IS_IPMP(ipif->ipif_ill))
12649 return (EINVAL);
12650
12651 rw_enter(&ipst->ips_ipmp_lock, RW_READER);
12652 if ((ill = ipif->ipif_bound_ill) == NULL)
12653 lifr->lifr_binding[0] = '\0';
12654 else
12655 (void) strlcpy(lifr->lifr_binding, ill->ill_name, LIFNAMSIZ);
12656 rw_exit(&ipst->ips_ipmp_lock);
12657 return (0);
12658 }
12659
12660 /*
12661 * Process an SIOCGLIFGROUPNAME request.
12662 */
12663 /* ARGSUSED */
12664 int
12665 ip_sioctl_get_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12666 ip_ioctl_cmd_t *ipip, void *ifreq)
12667 {
12668 ipmp_grp_t *grp;
12669 struct lifreq *lifr = ifreq;
12670 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
12671
12672 rw_enter(&ipst->ips_ipmp_lock, RW_READER);
12673 if ((grp = ipif->ipif_ill->ill_phyint->phyint_grp) == NULL)
12674 lifr->lifr_groupname[0] = '\0';
12675 else
12676 (void) strlcpy(lifr->lifr_groupname, grp->gr_name, LIFGRNAMSIZ);
12677 rw_exit(&ipst->ips_ipmp_lock);
12678 return (0);
12679 }
12680
12681 /*
12682 * Process an SIOCGLIFGROUPINFO request.
12683 */
12684 /* ARGSUSED */
12685 int
12686 ip_sioctl_groupinfo(ipif_t *dummy_ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12687 ip_ioctl_cmd_t *ipip, void *dummy)
12688 {
12689 ipmp_grp_t *grp;
12690 lifgroupinfo_t *lifgr;
12691 ip_stack_t *ipst = CONNQ_TO_IPST(q);
12692
12693 /* ip_wput_nondata() verified mp->b_cont->b_cont */
12694 lifgr = (lifgroupinfo_t *)mp->b_cont->b_cont->b_rptr;
12695 lifgr->gi_grname[LIFGRNAMSIZ - 1] = '\0';
12696
12697 rw_enter(&ipst->ips_ipmp_lock, RW_READER);
12698 if ((grp = ipmp_grp_lookup(lifgr->gi_grname, ipst)) == NULL) {
12699 rw_exit(&ipst->ips_ipmp_lock);
12700 return (ENOENT);
12701 }
12702 ipmp_grp_info(grp, lifgr);
12703 rw_exit(&ipst->ips_ipmp_lock);
12704 return (0);
12705 }
12706
12707 static void
12708 ill_dl_down(ill_t *ill)
12709 {
12710 DTRACE_PROBE2(ill__downup, char *, "ill_dl_down", ill_t *, ill);
12711
12712 /*
12713 * The ill is down; unbind but stay attached since we're still
12714 * associated with a PPA. If we have negotiated DLPI capabilites
12715 * with the data link service provider (IDS_OK) then reset them.
12716 * The interval between unbinding and rebinding is potentially
12717 * unbounded hence we cannot assume things will be the same.
12718 * The DLPI capabilities will be probed again when the data link
12719 * is brought up.
12720 */
12721 mblk_t *mp = ill->ill_unbind_mp;
12722
12723 ip1dbg(("ill_dl_down(%s)\n", ill->ill_name));
12724
12725 if (!ill->ill_replumbing) {
12726 /* Free all ilms for this ill */
12727 update_conn_ill(ill, ill->ill_ipst);
12728 } else {
12729 ill_leave_multicast(ill);
12730 }
12731
12732 ill->ill_unbind_mp = NULL;
12733 if (mp != NULL) {
12734 ip1dbg(("ill_dl_down: %s (%u) for %s\n",
12735 dl_primstr(*(int *)mp->b_rptr), *(int *)mp->b_rptr,
12736 ill->ill_name));
12737 mutex_enter(&ill->ill_lock);
12738 ill->ill_state_flags |= ILL_DL_UNBIND_IN_PROGRESS;
12739 mutex_exit(&ill->ill_lock);
12740 /*
12741 * ip_rput does not pass up normal (M_PROTO) DLPI messages
12742 * after ILL_CONDEMNED is set. So in the unplumb case, we call
12743 * ill_capability_dld_disable disable rightaway. If this is not
12744 * an unplumb operation then the disable happens on receipt of
12745 * the capab ack via ip_rput_dlpi_writer ->
12746 * ill_capability_ack_thr. In both cases the order of
12747 * the operations seen by DLD is capability disable followed
12748 * by DL_UNBIND. Also the DLD capability disable needs a
12749 * cv_wait'able context.
12750 */
12751 if (ill->ill_state_flags & ILL_CONDEMNED)
12752 ill_capability_dld_disable(ill);
12753 ill_capability_reset(ill, B_FALSE);
12754 ill_dlpi_send(ill, mp);
12755 }
12756 mutex_enter(&ill->ill_lock);
12757 ill->ill_dl_up = 0;
12758 ill_nic_event_dispatch(ill, 0, NE_DOWN, NULL, 0);
12759 mutex_exit(&ill->ill_lock);
12760 }
12761
12762 void
12763 ill_dlpi_dispatch(ill_t *ill, mblk_t *mp)
12764 {
12765 union DL_primitives *dlp;
12766 t_uscalar_t prim;
12767 boolean_t waitack = B_FALSE;
12768
12769 ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO);
12770
12771 dlp = (union DL_primitives *)mp->b_rptr;
12772 prim = dlp->dl_primitive;
12773
12774 ip1dbg(("ill_dlpi_dispatch: sending %s (%u) to %s\n",
12775 dl_primstr(prim), prim, ill->ill_name));
12776
12777 switch (prim) {
12778 case DL_PHYS_ADDR_REQ:
12779 {
12780 dl_phys_addr_req_t *dlpap = (dl_phys_addr_req_t *)mp->b_rptr;
12781 ill->ill_phys_addr_pend = dlpap->dl_addr_type;
12782 break;
12783 }
12784 case DL_BIND_REQ:
12785 mutex_enter(&ill->ill_lock);
12786 ill->ill_state_flags &= ~ILL_DL_UNBIND_IN_PROGRESS;
12787 mutex_exit(&ill->ill_lock);
12788 break;
12789 }
12790
12791 /*
12792 * Except for the ACKs for the M_PCPROTO messages, all other ACKs
12793 * are dropped by ip_rput() if ILL_CONDEMNED is set. Therefore
12794 * we only wait for the ACK of the DL_UNBIND_REQ.
12795 */
12796 mutex_enter(&ill->ill_lock);
12797 if (!(ill->ill_state_flags & ILL_CONDEMNED) ||
12798 (prim == DL_UNBIND_REQ)) {
12799 ill->ill_dlpi_pending = prim;
12800 waitack = B_TRUE;
12801 }
12802
12803 mutex_exit(&ill->ill_lock);
12804 DTRACE_PROBE3(ill__dlpi, char *, "ill_dlpi_dispatch",
12805 char *, dl_primstr(prim), ill_t *, ill);
12806 putnext(ill->ill_wq, mp);
12807
12808 /*
12809 * There is no ack for DL_NOTIFY_CONF messages
12810 */
12811 if (waitack && prim == DL_NOTIFY_CONF)
12812 ill_dlpi_done(ill, prim);
12813 }
12814
12815 /*
12816 * Helper function for ill_dlpi_send().
12817 */
12818 /* ARGSUSED */
12819 static void
12820 ill_dlpi_send_writer(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *arg)
12821 {
12822 ill_dlpi_send(q->q_ptr, mp);
12823 }
12824
12825 /*
12826 * Send a DLPI control message to the driver but make sure there
12827 * is only one outstanding message. Uses ill_dlpi_pending to tell
12828 * when it must queue. ip_rput_dlpi_writer calls ill_dlpi_done()
12829 * when an ACK or a NAK is received to process the next queued message.
12830 */
12831 void
12832 ill_dlpi_send(ill_t *ill, mblk_t *mp)
12833 {
12834 mblk_t **mpp;
12835
12836 ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO);
12837
12838 /*
12839 * To ensure that any DLPI requests for current exclusive operation
12840 * are always completely sent before any DLPI messages for other
12841 * operations, require writer access before enqueuing.
12842 */
12843 if (!IAM_WRITER_ILL(ill)) {
12844 ill_refhold(ill);
12845 /* qwriter_ip() does the ill_refrele() */
12846 qwriter_ip(ill, ill->ill_wq, mp, ill_dlpi_send_writer,
12847 NEW_OP, B_TRUE);
12848 return;
12849 }
12850
12851 mutex_enter(&ill->ill_lock);
12852 if (ill->ill_dlpi_pending != DL_PRIM_INVAL) {
12853 /* Must queue message. Tail insertion */
12854 mpp = &ill->ill_dlpi_deferred;
12855 while (*mpp != NULL)
12856 mpp = &((*mpp)->b_next);
12857
12858 ip1dbg(("ill_dlpi_send: deferring request for %s "
12859 "while %s pending\n", ill->ill_name,
12860 dl_primstr(ill->ill_dlpi_pending)));
12861
12862 *mpp = mp;
12863 mutex_exit(&ill->ill_lock);
12864 return;
12865 }
12866 mutex_exit(&ill->ill_lock);
12867 ill_dlpi_dispatch(ill, mp);
12868 }
12869
12870 void
12871 ill_capability_send(ill_t *ill, mblk_t *mp)
12872 {
12873 ill->ill_capab_pending_cnt++;
12874 ill_dlpi_send(ill, mp);
12875 }
12876
12877 void
12878 ill_capability_done(ill_t *ill)
12879 {
12880 ASSERT(ill->ill_capab_pending_cnt != 0);
12881
12882 ill_dlpi_done(ill, DL_CAPABILITY_REQ);
12883
12884 ill->ill_capab_pending_cnt--;
12885 if (ill->ill_capab_pending_cnt == 0 &&
12886 ill->ill_dlpi_capab_state == IDCS_OK)
12887 ill_capability_reset_alloc(ill);
12888 }
12889
12890 /*
12891 * Send all deferred DLPI messages without waiting for their ACKs.
12892 */
12893 void
12894 ill_dlpi_send_deferred(ill_t *ill)
12895 {
12896 mblk_t *mp, *nextmp;
12897
12898 /*
12899 * Clear ill_dlpi_pending so that the message is not queued in
12900 * ill_dlpi_send().
12901 */
12902 mutex_enter(&ill->ill_lock);
12903 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12904 mp = ill->ill_dlpi_deferred;
12905 ill->ill_dlpi_deferred = NULL;
12906 mutex_exit(&ill->ill_lock);
12907
12908 for (; mp != NULL; mp = nextmp) {
12909 nextmp = mp->b_next;
12910 mp->b_next = NULL;
12911 ill_dlpi_send(ill, mp);
12912 }
12913 }
12914
12915 /*
12916 * Clear all the deferred DLPI messages. Called on receiving an M_ERROR
12917 * or M_HANGUP
12918 */
12919 static void
12920 ill_dlpi_clear_deferred(ill_t *ill)
12921 {
12922 mblk_t *mp, *nextmp;
12923
12924 mutex_enter(&ill->ill_lock);
12925 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12926 mp = ill->ill_dlpi_deferred;
12927 ill->ill_dlpi_deferred = NULL;
12928 mutex_exit(&ill->ill_lock);
12929
12930 for (; mp != NULL; mp = nextmp) {
12931 nextmp = mp->b_next;
12932 inet_freemsg(mp);
12933 }
12934 }
12935
12936 /*
12937 * Check if the DLPI primitive `prim' is pending; print a warning if not.
12938 */
12939 boolean_t
12940 ill_dlpi_pending(ill_t *ill, t_uscalar_t prim)
12941 {
12942 t_uscalar_t pending;
12943
12944 mutex_enter(&ill->ill_lock);
12945 if (ill->ill_dlpi_pending == prim) {
12946 mutex_exit(&ill->ill_lock);
12947 return (B_TRUE);
12948 }
12949
12950 /*
12951 * During teardown, ill_dlpi_dispatch() will send DLPI requests
12952 * without waiting, so don't print any warnings in that case.
12953 */
12954 if (ill->ill_state_flags & ILL_CONDEMNED) {
12955 mutex_exit(&ill->ill_lock);
12956 return (B_FALSE);
12957 }
12958 pending = ill->ill_dlpi_pending;
12959 mutex_exit(&ill->ill_lock);
12960
12961 if (pending == DL_PRIM_INVAL) {
12962 (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE,
12963 "received unsolicited ack for %s on %s\n",
12964 dl_primstr(prim), ill->ill_name);
12965 } else {
12966 (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE,
12967 "received unexpected ack for %s on %s (expecting %s)\n",
12968 dl_primstr(prim), ill->ill_name, dl_primstr(pending));
12969 }
12970 return (B_FALSE);
12971 }
12972
12973 /*
12974 * Complete the current DLPI operation associated with `prim' on `ill' and
12975 * start the next queued DLPI operation (if any). If there are no queued DLPI
12976 * operations and the ill's current exclusive IPSQ operation has finished
12977 * (i.e., ipsq_current_finish() was called), then clear ipsq_current_ipif to
12978 * allow the next exclusive IPSQ operation to begin upon ipsq_exit(). See
12979 * the comments above ipsq_current_finish() for details.
12980 */
12981 void
12982 ill_dlpi_done(ill_t *ill, t_uscalar_t prim)
12983 {
12984 mblk_t *mp;
12985 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
12986 ipxop_t *ipx = ipsq->ipsq_xop;
12987
12988 ASSERT(IAM_WRITER_IPSQ(ipsq));
12989 mutex_enter(&ill->ill_lock);
12990
12991 ASSERT(prim != DL_PRIM_INVAL);
12992 ASSERT(ill->ill_dlpi_pending == prim);
12993
12994 ip1dbg(("ill_dlpi_done: %s has completed %s (%u)\n", ill->ill_name,
12995 dl_primstr(ill->ill_dlpi_pending), ill->ill_dlpi_pending));
12996
12997 if ((mp = ill->ill_dlpi_deferred) == NULL) {
12998 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12999 if (ipx->ipx_current_done) {
13000 mutex_enter(&ipx->ipx_lock);
13001 ipx->ipx_current_ipif = NULL;
13002 mutex_exit(&ipx->ipx_lock);
13003 }
13004 cv_signal(&ill->ill_cv);
13005 mutex_exit(&ill->ill_lock);
13006 return;
13007 }
13008
13009 ill->ill_dlpi_deferred = mp->b_next;
13010 mp->b_next = NULL;
13011 mutex_exit(&ill->ill_lock);
13012
13013 ill_dlpi_dispatch(ill, mp);
13014 }
13015
13016 /*
13017 * Queue a (multicast) DLPI control message to be sent to the driver by
13018 * later calling ill_dlpi_send_queued.
13019 * We queue them while holding a lock (ill_mcast_lock) to ensure that they
13020 * are sent in order i.e., prevent a DL_DISABMULTI_REQ and DL_ENABMULTI_REQ
13021 * for the same group to race.
13022 * We send DLPI control messages in order using ill_lock.
13023 * For IPMP we should be called on the cast_ill.
13024 */
13025 void
13026 ill_dlpi_queue(ill_t *ill, mblk_t *mp)
13027 {
13028 mblk_t **mpp;
13029
13030 ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO);
13031
13032 mutex_enter(&ill->ill_lock);
13033 /* Must queue message. Tail insertion */
13034 mpp = &ill->ill_dlpi_deferred;
13035 while (*mpp != NULL)
13036 mpp = &((*mpp)->b_next);
13037
13038 *mpp = mp;
13039 mutex_exit(&ill->ill_lock);
13040 }
13041
13042 /*
13043 * Send the messages that were queued. Make sure there is only
13044 * one outstanding message. ip_rput_dlpi_writer calls ill_dlpi_done()
13045 * when an ACK or a NAK is received to process the next queued message.
13046 * For IPMP we are called on the upper ill, but when send what is queued
13047 * on the cast_ill.
13048 */
13049 void
13050 ill_dlpi_send_queued(ill_t *ill)
13051 {
13052 mblk_t *mp;
13053 union DL_primitives *dlp;
13054 t_uscalar_t prim;
13055 ill_t *release_ill = NULL;
13056
13057 if (IS_IPMP(ill)) {
13058 /* On the upper IPMP ill. */
13059 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13060 if (release_ill == NULL) {
13061 /* Avoid ever sending anything down to the ipmpstub */
13062 return;
13063 }
13064 ill = release_ill;
13065 }
13066 mutex_enter(&ill->ill_lock);
13067 while ((mp = ill->ill_dlpi_deferred) != NULL) {
13068 if (ill->ill_dlpi_pending != DL_PRIM_INVAL) {
13069 /* Can't send. Somebody else will send it */
13070 mutex_exit(&ill->ill_lock);
13071 goto done;
13072 }
13073 ill->ill_dlpi_deferred = mp->b_next;
13074 mp->b_next = NULL;
13075 if (!ill->ill_dl_up) {
13076 /*
13077 * Nobody there. All multicast addresses will be
13078 * re-joined when we get the DL_BIND_ACK bringing the
13079 * interface up.
13080 */
13081 freemsg(mp);
13082 continue;
13083 }
13084 dlp = (union DL_primitives *)mp->b_rptr;
13085 prim = dlp->dl_primitive;
13086
13087 if (!(ill->ill_state_flags & ILL_CONDEMNED) ||
13088 (prim == DL_UNBIND_REQ)) {
13089 ill->ill_dlpi_pending = prim;
13090 }
13091 mutex_exit(&ill->ill_lock);
13092
13093 DTRACE_PROBE3(ill__dlpi, char *, "ill_dlpi_send_queued",
13094 char *, dl_primstr(prim), ill_t *, ill);
13095 putnext(ill->ill_wq, mp);
13096 mutex_enter(&ill->ill_lock);
13097 }
13098 mutex_exit(&ill->ill_lock);
13099 done:
13100 if (release_ill != NULL)
13101 ill_refrele(release_ill);
13102 }
13103
13104 /*
13105 * Queue an IP (IGMP/MLD) message to be sent by IP from
13106 * ill_mcast_send_queued
13107 * We queue them while holding a lock (ill_mcast_lock) to ensure that they
13108 * are sent in order i.e., prevent a IGMP leave and IGMP join for the same
13109 * group to race.
13110 * We send them in order using ill_lock.
13111 * For IPMP we are called on the upper ill, but we queue on the cast_ill.
13112 */
13113 void
13114 ill_mcast_queue(ill_t *ill, mblk_t *mp)
13115 {
13116 mblk_t **mpp;
13117 ill_t *release_ill = NULL;
13118
13119 ASSERT(RW_LOCK_HELD(&ill->ill_mcast_lock));
13120
13121 if (IS_IPMP(ill)) {
13122 /* On the upper IPMP ill. */
13123 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13124 if (release_ill == NULL) {
13125 /* Discard instead of queuing for the ipmp interface */
13126 BUMP_MIB(ill->ill_ip_mib, ipIfStatsOutDiscards);
13127 ip_drop_output("ipIfStatsOutDiscards - no cast_ill",
13128 mp, ill);
13129 freemsg(mp);
13130 return;
13131 }
13132 ill = release_ill;
13133 }
13134
13135 mutex_enter(&ill->ill_lock);
13136 /* Must queue message. Tail insertion */
13137 mpp = &ill->ill_mcast_deferred;
13138 while (*mpp != NULL)
13139 mpp = &((*mpp)->b_next);
13140
13141 *mpp = mp;
13142 mutex_exit(&ill->ill_lock);
13143 if (release_ill != NULL)
13144 ill_refrele(release_ill);
13145 }
13146
13147 /*
13148 * Send the IP packets that were queued by ill_mcast_queue.
13149 * These are IGMP/MLD packets.
13150 *
13151 * For IPMP we are called on the upper ill, but when send what is queued
13152 * on the cast_ill.
13153 *
13154 * Request loopback of the report if we are acting as a multicast
13155 * router, so that the process-level routing demon can hear it.
13156 * This will run multiple times for the same group if there are members
13157 * on the same group for multiple ipif's on the same ill. The
13158 * igmp_input/mld_input code will suppress this due to the loopback thus we
13159 * always loopback membership report.
13160 *
13161 * We also need to make sure that this does not get load balanced
13162 * by IPMP. We do this by passing an ill to ip_output_simple.
13163 */
13164 void
13165 ill_mcast_send_queued(ill_t *ill)
13166 {
13167 mblk_t *mp;
13168 ip_xmit_attr_t ixas;
13169 ill_t *release_ill = NULL;
13170
13171 if (IS_IPMP(ill)) {
13172 /* On the upper IPMP ill. */
13173 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13174 if (release_ill == NULL) {
13175 /*
13176 * We should have no messages on the ipmp interface
13177 * but no point in trying to send them.
13178 */
13179 return;
13180 }
13181 ill = release_ill;
13182 }
13183 bzero(&ixas, sizeof (ixas));
13184 ixas.ixa_zoneid = ALL_ZONES;
13185 ixas.ixa_cred = kcred;
13186 ixas.ixa_cpid = NOPID;
13187 ixas.ixa_tsl = NULL;
13188 /*
13189 * Here we set ixa_ifindex. If IPMP it will be the lower ill which
13190 * makes ip_select_route pick the IRE_MULTICAST for the cast_ill.
13191 * That is necessary to handle IGMP/MLD snooping switches.
13192 */
13193 ixas.ixa_ifindex = ill->ill_phyint->phyint_ifindex;
13194 ixas.ixa_ipst = ill->ill_ipst;
13195
13196 mutex_enter(&ill->ill_lock);
13197 while ((mp = ill->ill_mcast_deferred) != NULL) {
13198 ill->ill_mcast_deferred = mp->b_next;
13199 mp->b_next = NULL;
13200 if (!ill->ill_dl_up) {
13201 /*
13202 * Nobody there. Just drop the ip packets.
13203 * IGMP/MLD will resend later, if this is a replumb.
13204 */
13205 freemsg(mp);
13206 continue;
13207 }
13208 mutex_enter(&ill->ill_phyint->phyint_lock);
13209 if (IS_UNDER_IPMP(ill) && !ipmp_ill_is_active(ill)) {
13210 /*
13211 * When the ill is getting deactivated, we only want to
13212 * send the DLPI messages, so drop IGMP/MLD packets.
13213 * DLPI messages are handled by ill_dlpi_send_queued()
13214 */
13215 mutex_exit(&ill->ill_phyint->phyint_lock);
13216 freemsg(mp);
13217 continue;
13218 }
13219 mutex_exit(&ill->ill_phyint->phyint_lock);
13220 mutex_exit(&ill->ill_lock);
13221
13222 /* Check whether we are sending IPv4 or IPv6. */
13223 if (ill->ill_isv6) {
13224 ip6_t *ip6h = (ip6_t *)mp->b_rptr;
13225
13226 ixas.ixa_multicast_ttl = ip6h->ip6_hops;
13227 ixas.ixa_flags = IXAF_BASIC_SIMPLE_V6;
13228 } else {
13229 ipha_t *ipha = (ipha_t *)mp->b_rptr;
13230
13231 ixas.ixa_multicast_ttl = ipha->ipha_ttl;
13232 ixas.ixa_flags = IXAF_BASIC_SIMPLE_V4;
13233 ixas.ixa_flags &= ~IXAF_SET_ULP_CKSUM;
13234 }
13235 ixas.ixa_flags &= ~IXAF_VERIFY_SOURCE;
13236 ixas.ixa_flags |= IXAF_MULTICAST_LOOP | IXAF_SET_SOURCE;
13237 (void) ip_output_simple(mp, &ixas);
13238 ixa_cleanup(&ixas);
13239
13240 mutex_enter(&ill->ill_lock);
13241 }
13242 mutex_exit(&ill->ill_lock);
13243
13244 done:
13245 if (release_ill != NULL)
13246 ill_refrele(release_ill);
13247 }
13248
13249 /*
13250 * Take down a specific interface, but don't lose any information about it.
13251 * (Always called as writer.)
13252 * This function goes through the down sequence even if the interface is
13253 * already down. There are 2 reasons.
13254 * a. Currently we permit interface routes that depend on down interfaces
13255 * to be added. This behaviour itself is questionable. However it appears
13256 * that both Solaris and 4.3 BSD have exhibited this behaviour for a long
13257 * time. We go thru the cleanup in order to remove these routes.
13258 * b. The bringup of the interface could fail in ill_dl_up i.e. we get
13259 * DL_ERROR_ACK in response to the DL_BIND request. The interface is
13260 * down, but we need to cleanup i.e. do ill_dl_down and
13261 * ip_rput_dlpi_writer (DL_ERROR_ACK) -> ipif_down.
13262 *
13263 * IP-MT notes:
13264 *
13265 * Model of reference to interfaces.
13266 *
13267 * The following members in ipif_t track references to the ipif.
13268 * int ipif_refcnt; Active reference count
13269 *
13270 * The following members in ill_t track references to the ill.
13271 * int ill_refcnt; active refcnt
13272 * uint_t ill_ire_cnt; Number of ires referencing ill
13273 * uint_t ill_ncec_cnt; Number of ncecs referencing ill
13274 * uint_t ill_nce_cnt; Number of nces referencing ill
13275 * uint_t ill_ilm_cnt; Number of ilms referencing ill
13276 *
13277 * Reference to an ipif or ill can be obtained in any of the following ways.
13278 *
13279 * Through the lookup functions ipif_lookup_* / ill_lookup_* functions
13280 * Pointers to ipif / ill from other data structures viz ire and conn.
13281 * Implicit reference to the ipif / ill by holding a reference to the ire.
13282 *
13283 * The ipif/ill lookup functions return a reference held ipif / ill.
13284 * ipif_refcnt and ill_refcnt track the reference counts respectively.
13285 * This is a purely dynamic reference count associated with threads holding
13286 * references to the ipif / ill. Pointers from other structures do not
13287 * count towards this reference count.
13288 *
13289 * ill_ire_cnt is the number of ire's associated with the
13290 * ill. This is incremented whenever a new ire is created referencing the
13291 * ill. This is done atomically inside ire_add_v[46] where the ire is
13292 * actually added to the ire hash table. The count is decremented in
13293 * ire_inactive where the ire is destroyed.
13294 *
13295 * ill_ncec_cnt is the number of ncec's referencing the ill thru ncec_ill.
13296 * This is incremented atomically in
13297 * ndp_add_v4()/ndp_add_v6() where the nce is actually added to the
13298 * table. Similarly it is decremented in ncec_inactive() where the ncec
13299 * is destroyed.
13300 *
13301 * ill_nce_cnt is the number of nce's referencing the ill thru nce_ill. This is
13302 * incremented atomically in nce_add() where the nce is actually added to the
13303 * ill_nce. Similarly it is decremented in nce_inactive() where the nce
13304 * is destroyed.
13305 *
13306 * ill_ilm_cnt is the ilm's reference to the ill. It is incremented in
13307 * ilm_add() and decremented before the ilm is freed in ilm_delete().
13308 *
13309 * Flow of ioctls involving interface down/up
13310 *
13311 * The following is the sequence of an attempt to set some critical flags on an
13312 * up interface.
13313 * ip_sioctl_flags
13314 * ipif_down
13315 * wait for ipif to be quiescent
13316 * ipif_down_tail
13317 * ip_sioctl_flags_tail
13318 *
13319 * All set ioctls that involve down/up sequence would have a skeleton similar
13320 * to the above. All the *tail functions are called after the refcounts have
13321 * dropped to the appropriate values.
13322 *
13323 * SIOC ioctls during the IPIF_CHANGING interval.
13324 *
13325 * Threads handling SIOC set ioctls serialize on the squeue, but this
13326 * is not done for SIOC get ioctls. Since a set ioctl can cause several
13327 * steps of internal changes to the state, some of which are visible in
13328 * ipif_flags (such as IFF_UP being cleared and later set), and we want
13329 * the set ioctl to be atomic related to the get ioctls, the SIOC get code
13330 * will wait and restart ioctls if IPIF_CHANGING is set. The mblk is then
13331 * enqueued in the ipsq and the operation is restarted by ipsq_exit() when
13332 * the current exclusive operation completes. The IPIF_CHANGING check
13333 * and enqueue is atomic using the ill_lock and ipsq_lock. The
13334 * lookup is done holding the ill_lock. Hence the ill/ipif state flags can't
13335 * change while the ill_lock is held. Before dropping the ill_lock we acquire
13336 * the ipsq_lock and call ipsq_enq. This ensures that ipsq_exit can't finish
13337 * until we release the ipsq_lock, even though the ill/ipif state flags
13338 * can change after we drop the ill_lock.
13339 */
13340 int
13341 ipif_down(ipif_t *ipif, queue_t *q, mblk_t *mp)
13342 {
13343 ill_t *ill = ipif->ipif_ill;
13344 conn_t *connp;
13345 boolean_t success;
13346 boolean_t ipif_was_up = B_FALSE;
13347 ip_stack_t *ipst = ill->ill_ipst;
13348
13349 ASSERT(IAM_WRITER_IPIF(ipif));
13350
13351 ip1dbg(("ipif_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
13352
13353 DTRACE_PROBE3(ipif__downup, char *, "ipif_down",
13354 ill_t *, ill, ipif_t *, ipif);
13355
13356 if (ipif->ipif_flags & IPIF_UP) {
13357 mutex_enter(&ill->ill_lock);
13358 ipif->ipif_flags &= ~IPIF_UP;
13359 ASSERT(ill->ill_ipif_up_count > 0);
13360 --ill->ill_ipif_up_count;
13361 mutex_exit(&ill->ill_lock);
13362 ipif_was_up = B_TRUE;
13363 /* Update status in SCTP's list */
13364 sctp_update_ipif(ipif, SCTP_IPIF_DOWN);
13365 ill_nic_event_dispatch(ipif->ipif_ill,
13366 MAP_IPIF_ID(ipif->ipif_id), NE_LIF_DOWN, NULL, 0);
13367 }
13368
13369 /*
13370 * Removal of the last ipif from an ill may result in a DL_UNBIND
13371 * being sent to the driver, and we must not send any data packets to
13372 * the driver after the DL_UNBIND_REQ. To ensure this, all the
13373 * ire and nce entries used in the data path will be cleaned
13374 * up, and we also set the ILL_DOWN_IN_PROGRESS bit to make
13375 * sure on new entries will be added until the ill is bound
13376 * again. The ILL_DOWN_IN_PROGRESS bit is turned off upon
13377 * receipt of a DL_BIND_ACK.
13378 */
13379 if (ill->ill_wq != NULL && !ill->ill_logical_down &&
13380 ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
13381 ill->ill_dl_up) {
13382 ill->ill_state_flags |= ILL_DOWN_IN_PROGRESS;
13383 }
13384
13385 /*
13386 * Blow away memberships we established in ipif_multicast_up().
13387 */
13388 ipif_multicast_down(ipif);
13389
13390 /*
13391 * Remove from the mapping for __sin6_src_id. We insert only
13392 * when the address is not INADDR_ANY. As IPv4 addresses are
13393 * stored as mapped addresses, we need to check for mapped
13394 * INADDR_ANY also.
13395 */
13396 if (ipif_was_up && !IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) &&
13397 !IN6_IS_ADDR_V4MAPPED_ANY(&ipif->ipif_v6lcl_addr) &&
13398 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
13399 int err;
13400
13401 err = ip_srcid_remove(&ipif->ipif_v6lcl_addr,
13402 ipif->ipif_zoneid, ipst);
13403 if (err != 0) {
13404 ip0dbg(("ipif_down: srcid_remove %d\n", err));
13405 }
13406 }
13407
13408 if (ipif_was_up) {
13409 /* only delete if we'd added ire's before */
13410 if (ipif->ipif_isv6)
13411 ipif_delete_ires_v6(ipif);
13412 else
13413 ipif_delete_ires_v4(ipif);
13414 }
13415
13416 if (ipif_was_up && ill->ill_ipif_up_count == 0) {
13417 /*
13418 * Since the interface is now down, it may have just become
13419 * inactive. Note that this needs to be done even for a
13420 * lll_logical_down(), or ARP entries will not get correctly
13421 * restored when the interface comes back up.
13422 */
13423 if (IS_UNDER_IPMP(ill))
13424 ipmp_ill_refresh_active(ill);
13425 }
13426
13427 /*
13428 * neighbor-discovery or arp entries for this interface. The ipif
13429 * has to be quiesced, so we walk all the nce's and delete those
13430 * that point at the ipif->ipif_ill. At the same time, we also
13431 * update IPMP so that ipifs for data addresses are unbound. We dont
13432 * call ipif_arp_down to DL_UNBIND the arp stream itself here, but defer
13433 * that for ipif_down_tail()
13434 */
13435 ipif_nce_down(ipif);
13436
13437 /*
13438 * If this is the last ipif on the ill, we also need to remove
13439 * any IREs with ire_ill set. Otherwise ipif_is_quiescent() will
13440 * never succeed.
13441 */
13442 if (ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0)
13443 ire_walk_ill(0, 0, ill_downi, ill, ill);
13444
13445 /*
13446 * Walk all CONNs that can have a reference on an ire for this
13447 * ipif (we actually walk all that now have stale references).
13448 */
13449 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ipst);
13450
13451 /*
13452 * If mp is NULL the caller will wait for the appropriate refcnt.
13453 * Eg. ip_sioctl_removeif -> ipif_free -> ipif_down
13454 * and ill_delete -> ipif_free -> ipif_down
13455 */
13456 if (mp == NULL) {
13457 ASSERT(q == NULL);
13458 return (0);
13459 }
13460
13461 if (CONN_Q(q)) {
13462 connp = Q_TO_CONN(q);
13463 mutex_enter(&connp->conn_lock);
13464 } else {
13465 connp = NULL;
13466 }
13467 mutex_enter(&ill->ill_lock);
13468 /*
13469 * Are there any ire's pointing to this ipif that are still active ?
13470 * If this is the last ipif going down, are there any ire's pointing
13471 * to this ill that are still active ?
13472 */
13473 if (ipif_is_quiescent(ipif)) {
13474 mutex_exit(&ill->ill_lock);
13475 if (connp != NULL)
13476 mutex_exit(&connp->conn_lock);
13477 return (0);
13478 }
13479
13480 ip1dbg(("ipif_down: need to wait, adding pending mp %s ill %p",
13481 ill->ill_name, (void *)ill));
13482 /*
13483 * Enqueue the mp atomically in ipsq_pending_mp. When the refcount
13484 * drops down, the operation will be restarted by ipif_ill_refrele_tail
13485 * which in turn is called by the last refrele on the ipif/ill/ire.
13486 */
13487 success = ipsq_pending_mp_add(connp, ipif, q, mp, IPIF_DOWN);
13488 if (!success) {
13489 /* The conn is closing. So just return */
13490 ASSERT(connp != NULL);
13491 mutex_exit(&ill->ill_lock);
13492 mutex_exit(&connp->conn_lock);
13493 return (EINTR);
13494 }
13495
13496 mutex_exit(&ill->ill_lock);
13497 if (connp != NULL)
13498 mutex_exit(&connp->conn_lock);
13499 return (EINPROGRESS);
13500 }
13501
13502 int
13503 ipif_down_tail(ipif_t *ipif)
13504 {
13505 ill_t *ill = ipif->ipif_ill;
13506 int err = 0;
13507
13508 DTRACE_PROBE3(ipif__downup, char *, "ipif_down_tail",
13509 ill_t *, ill, ipif_t *, ipif);
13510
13511 /*
13512 * Skip any loopback interface (null wq).
13513 * If this is the last logical interface on the ill
13514 * have ill_dl_down tell the driver we are gone (unbind)
13515 * Note that lun 0 can ipif_down even though
13516 * there are other logical units that are up.
13517 * This occurs e.g. when we change a "significant" IFF_ flag.
13518 */
13519 if (ill->ill_wq != NULL && !ill->ill_logical_down &&
13520 ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
13521 ill->ill_dl_up) {
13522 ill_dl_down(ill);
13523 }
13524 if (!ipif->ipif_isv6)
13525 err = ipif_arp_down(ipif);
13526
13527 ill->ill_logical_down = 0;
13528
13529 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
13530 ip_rts_newaddrmsg(RTM_DELETE, 0, ipif, RTSQ_DEFAULT);
13531 return (err);
13532 }
13533
13534 /*
13535 * Bring interface logically down without bringing the physical interface
13536 * down e.g. when the netmask is changed. This avoids long lasting link
13537 * negotiations between an ethernet interface and a certain switches.
13538 */
13539 static int
13540 ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp)
13541 {
13542 DTRACE_PROBE3(ipif__downup, char *, "ipif_logical_down",
13543 ill_t *, ipif->ipif_ill, ipif_t *, ipif);
13544
13545 /*
13546 * The ill_logical_down flag is a transient flag. It is set here
13547 * and is cleared once the down has completed in ipif_down_tail.
13548 * This flag does not indicate whether the ill stream is in the
13549 * DL_BOUND state with the driver. Instead this flag is used by
13550 * ipif_down_tail to determine whether to DL_UNBIND the stream with
13551 * the driver. The state of the ill stream i.e. whether it is
13552 * DL_BOUND with the driver or not is indicated by the ill_dl_up flag.
13553 */
13554 ipif->ipif_ill->ill_logical_down = 1;
13555 return (ipif_down(ipif, q, mp));
13556 }
13557
13558 /*
13559 * Initiate deallocate of an IPIF. Always called as writer. Called by
13560 * ill_delete or ip_sioctl_removeif.
13561 */
13562 static void
13563 ipif_free(ipif_t *ipif)
13564 {
13565 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13566
13567 ASSERT(IAM_WRITER_IPIF(ipif));
13568
13569 if (ipif->ipif_recovery_id != 0)
13570 (void) untimeout(ipif->ipif_recovery_id);
13571 ipif->ipif_recovery_id = 0;
13572
13573 /*
13574 * Take down the interface. We can be called either from ill_delete
13575 * or from ip_sioctl_removeif.
13576 */
13577 (void) ipif_down(ipif, NULL, NULL);
13578
13579 /*
13580 * Now that the interface is down, there's no chance it can still
13581 * become a duplicate. Cancel any timer that may have been set while
13582 * tearing down.
13583 */
13584 if (ipif->ipif_recovery_id != 0)
13585 (void) untimeout(ipif->ipif_recovery_id);
13586 ipif->ipif_recovery_id = 0;
13587
13588 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
13589 /* Remove pointers to this ill in the multicast routing tables */
13590 reset_mrt_vif_ipif(ipif);
13591 /* If necessary, clear the cached source ipif rotor. */
13592 if (ipif->ipif_ill->ill_src_ipif == ipif)
13593 ipif->ipif_ill->ill_src_ipif = NULL;
13594 rw_exit(&ipst->ips_ill_g_lock);
13595 }
13596
13597 static void
13598 ipif_free_tail(ipif_t *ipif)
13599 {
13600 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13601
13602 /*
13603 * Need to hold both ill_g_lock and ill_lock while
13604 * inserting or removing an ipif from the linked list
13605 * of ipifs hanging off the ill.
13606 */
13607 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
13608
13609 #ifdef DEBUG
13610 ipif_trace_cleanup(ipif);
13611 #endif
13612
13613 /* Ask SCTP to take it out of it list */
13614 sctp_update_ipif(ipif, SCTP_IPIF_REMOVE);
13615 ip_rts_newaddrmsg(RTM_FREEADDR, 0, ipif, RTSQ_DEFAULT);
13616
13617 /* Get it out of the ILL interface list. */
13618 ipif_remove(ipif);
13619 rw_exit(&ipst->ips_ill_g_lock);
13620
13621 ASSERT(!(ipif->ipif_flags & (IPIF_UP | IPIF_DUPLICATE)));
13622 ASSERT(ipif->ipif_recovery_id == 0);
13623 ASSERT(ipif->ipif_ire_local == NULL);
13624 ASSERT(ipif->ipif_ire_if == NULL);
13625
13626 /* Free the memory. */
13627 mi_free(ipif);
13628 }
13629
13630 /*
13631 * Sets `buf' to an ipif name of the form "ill_name:id", or "ill_name" if "id"
13632 * is zero.
13633 */
13634 void
13635 ipif_get_name(const ipif_t *ipif, char *buf, int len)
13636 {
13637 char lbuf[LIFNAMSIZ];
13638 char *name;
13639 size_t name_len;
13640
13641 buf[0] = '\0';
13642 name = ipif->ipif_ill->ill_name;
13643 name_len = ipif->ipif_ill->ill_name_length;
13644 if (ipif->ipif_id != 0) {
13645 (void) sprintf(lbuf, "%s%c%d", name, IPIF_SEPARATOR_CHAR,
13646 ipif->ipif_id);
13647 name = lbuf;
13648 name_len = mi_strlen(name) + 1;
13649 }
13650 len -= 1;
13651 buf[len] = '\0';
13652 len = MIN(len, name_len);
13653 bcopy(name, buf, len);
13654 }
13655
13656 /*
13657 * Sets `buf' to an ill name.
13658 */
13659 void
13660 ill_get_name(const ill_t *ill, char *buf, int len)
13661 {
13662 char *name;
13663 size_t name_len;
13664
13665 name = ill->ill_name;
13666 name_len = ill->ill_name_length;
13667 len -= 1;
13668 buf[len] = '\0';
13669 len = MIN(len, name_len);
13670 bcopy(name, buf, len);
13671 }
13672
13673 /*
13674 * Find an IPIF based on the name passed in. Names can be of the form <phys>
13675 * (e.g., le0) or <phys>:<#> (e.g., le0:1). When there is no colon, the
13676 * implied unit id is zero. <phys> must correspond to the name of an ILL.
13677 * (May be called as writer.)
13678 */
13679 static ipif_t *
13680 ipif_lookup_on_name(char *name, size_t namelen, boolean_t do_alloc,
13681 boolean_t *exists, boolean_t isv6, zoneid_t zoneid, ip_stack_t *ipst)
13682 {
13683 char *cp;
13684 char *endp;
13685 long id;
13686 ill_t *ill;
13687 ipif_t *ipif;
13688 uint_t ire_type;
13689 boolean_t did_alloc = B_FALSE;
13690 char last;
13691
13692 /*
13693 * If the caller wants to us to create the ipif, make sure we have a
13694 * valid zoneid
13695 */
13696 ASSERT(!do_alloc || zoneid != ALL_ZONES);
13697
13698 if (namelen == 0) {
13699 return (NULL);
13700 }
13701
13702 *exists = B_FALSE;
13703 /* Look for a colon in the name. */
13704 endp = &name[namelen];
13705 for (cp = endp; --cp > name; ) {
13706 if (*cp == IPIF_SEPARATOR_CHAR)
13707 break;
13708 }
13709
13710 if (*cp == IPIF_SEPARATOR_CHAR) {
13711 /*
13712 * Reject any non-decimal aliases for logical
13713 * interfaces. Aliases with leading zeroes
13714 * are also rejected as they introduce ambiguity
13715 * in the naming of the interfaces.
13716 * In order to confirm with existing semantics,
13717 * and to not break any programs/script relying
13718 * on that behaviour, if<0>:0 is considered to be
13719 * a valid interface.
13720 *
13721 * If alias has two or more digits and the first
13722 * is zero, fail.
13723 */
13724 if (&cp[2] < endp && cp[1] == '0') {
13725 return (NULL);
13726 }
13727 }
13728
13729 if (cp <= name) {
13730 cp = endp;
13731 }
13732 last = *cp;
13733 *cp = '\0';
13734
13735 /*
13736 * Look up the ILL, based on the portion of the name
13737 * before the slash. ill_lookup_on_name returns a held ill.
13738 * Temporary to check whether ill exists already. If so
13739 * ill_lookup_on_name will clear it.
13740 */
13741 ill = ill_lookup_on_name(name, do_alloc, isv6,
13742 &did_alloc, ipst);
13743 *cp = last;
13744 if (ill == NULL)
13745 return (NULL);
13746
13747 /* Establish the unit number in the name. */
13748 id = 0;
13749 if (cp < endp && *endp == '\0') {
13750 /* If there was a colon, the unit number follows. */
13751 cp++;
13752 if (ddi_strtol(cp, NULL, 0, &id) != 0) {
13753 ill_refrele(ill);
13754 return (NULL);
13755 }
13756 }
13757
13758 mutex_enter(&ill->ill_lock);
13759 /* Now see if there is an IPIF with this unit number. */
13760 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13761 if (ipif->ipif_id == id) {
13762 if (zoneid != ALL_ZONES &&
13763 zoneid != ipif->ipif_zoneid &&
13764 ipif->ipif_zoneid != ALL_ZONES) {
13765 mutex_exit(&ill->ill_lock);
13766 ill_refrele(ill);
13767 return (NULL);
13768 }
13769 if (IPIF_CAN_LOOKUP(ipif)) {
13770 ipif_refhold_locked(ipif);
13771 mutex_exit(&ill->ill_lock);
13772 if (!did_alloc)
13773 *exists = B_TRUE;
13774 /*
13775 * Drop locks before calling ill_refrele
13776 * since it can potentially call into
13777 * ipif_ill_refrele_tail which can end up
13778 * in trying to acquire any lock.
13779 */
13780 ill_refrele(ill);
13781 return (ipif);
13782 }
13783 }
13784 }
13785
13786 if (!do_alloc) {
13787 mutex_exit(&ill->ill_lock);
13788 ill_refrele(ill);
13789 return (NULL);
13790 }
13791
13792 /*
13793 * If none found, atomically allocate and return a new one.
13794 * Historically, we used IRE_LOOPBACK only for lun 0, and IRE_LOCAL
13795 * to support "receive only" use of lo0:1 etc. as is still done
13796 * below as an initial guess.
13797 * However, this is now likely to be overriden later in ipif_up_done()
13798 * when we know for sure what address has been configured on the
13799 * interface, since we might have more than one loopback interface
13800 * with a loopback address, e.g. in the case of zones, and all the
13801 * interfaces with loopback addresses need to be marked IRE_LOOPBACK.
13802 */
13803 if (ill->ill_net_type == IRE_LOOPBACK && id == 0)
13804 ire_type = IRE_LOOPBACK;
13805 else
13806 ire_type = IRE_LOCAL;
13807 ipif = ipif_allocate(ill, id, ire_type, B_TRUE, B_TRUE, NULL);
13808 if (ipif != NULL)
13809 ipif_refhold_locked(ipif);
13810 mutex_exit(&ill->ill_lock);
13811 ill_refrele(ill);
13812 return (ipif);
13813 }
13814
13815 /*
13816 * Variant of the above that queues the request on the ipsq when
13817 * IPIF_CHANGING is set.
13818 */
13819 static ipif_t *
13820 ipif_lookup_on_name_async(char *name, size_t namelen, boolean_t isv6,
13821 zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error,
13822 ip_stack_t *ipst)
13823 {
13824 char *cp;
13825 char *endp;
13826 long id;
13827 ill_t *ill;
13828 ipif_t *ipif;
13829 boolean_t did_alloc = B_FALSE;
13830 ipsq_t *ipsq;
13831
13832 if (error != NULL)
13833 *error = 0;
13834
13835 if (namelen == 0) {
13836 if (error != NULL)
13837 *error = ENXIO;
13838 return (NULL);
13839 }
13840
13841 /* Look for a colon in the name. */
13842 endp = &name[namelen];
13843 for (cp = endp; --cp > name; ) {
13844 if (*cp == IPIF_SEPARATOR_CHAR)
13845 break;
13846 }
13847
13848 if (*cp == IPIF_SEPARATOR_CHAR) {
13849 /*
13850 * Reject any non-decimal aliases for logical
13851 * interfaces. Aliases with leading zeroes
13852 * are also rejected as they introduce ambiguity
13853 * in the naming of the interfaces.
13854 * In order to confirm with existing semantics,
13855 * and to not break any programs/script relying
13856 * on that behaviour, if<0>:0 is considered to be
13857 * a valid interface.
13858 *
13859 * If alias has two or more digits and the first
13860 * is zero, fail.
13861 */
13862 if (&cp[2] < endp && cp[1] == '0') {
13863 if (error != NULL)
13864 *error = EINVAL;
13865 return (NULL);
13866 }
13867 }
13868
13869 if (cp <= name) {
13870 cp = endp;
13871 } else {
13872 *cp = '\0';
13873 }
13874
13875 /*
13876 * Look up the ILL, based on the portion of the name
13877 * before the slash. ill_lookup_on_name returns a held ill.
13878 * Temporary to check whether ill exists already. If so
13879 * ill_lookup_on_name will clear it.
13880 */
13881 ill = ill_lookup_on_name(name, B_FALSE, isv6, &did_alloc, ipst);
13882 if (cp != endp)
13883 *cp = IPIF_SEPARATOR_CHAR;
13884 if (ill == NULL)
13885 return (NULL);
13886
13887 /* Establish the unit number in the name. */
13888 id = 0;
13889 if (cp < endp && *endp == '\0') {
13890 /* If there was a colon, the unit number follows. */
13891 cp++;
13892 if (ddi_strtol(cp, NULL, 0, &id) != 0) {
13893 ill_refrele(ill);
13894 if (error != NULL)
13895 *error = ENXIO;
13896 return (NULL);
13897 }
13898 }
13899
13900 GRAB_CONN_LOCK(q);
13901 mutex_enter(&ill->ill_lock);
13902 /* Now see if there is an IPIF with this unit number. */
13903 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13904 if (ipif->ipif_id == id) {
13905 if (zoneid != ALL_ZONES &&
13906 zoneid != ipif->ipif_zoneid &&
13907 ipif->ipif_zoneid != ALL_ZONES) {
13908 mutex_exit(&ill->ill_lock);
13909 RELEASE_CONN_LOCK(q);
13910 ill_refrele(ill);
13911 if (error != NULL)
13912 *error = ENXIO;
13913 return (NULL);
13914 }
13915
13916 if (!(IPIF_IS_CHANGING(ipif) ||
13917 IPIF_IS_CONDEMNED(ipif)) ||
13918 IAM_WRITER_IPIF(ipif)) {
13919 ipif_refhold_locked(ipif);
13920 mutex_exit(&ill->ill_lock);
13921 /*
13922 * Drop locks before calling ill_refrele
13923 * since it can potentially call into
13924 * ipif_ill_refrele_tail which can end up
13925 * in trying to acquire any lock.
13926 */
13927 RELEASE_CONN_LOCK(q);
13928 ill_refrele(ill);
13929 return (ipif);
13930 } else if (q != NULL && !IPIF_IS_CONDEMNED(ipif)) {
13931 ipsq = ill->ill_phyint->phyint_ipsq;
13932 mutex_enter(&ipsq->ipsq_lock);
13933 mutex_enter(&ipsq->ipsq_xop->ipx_lock);
13934 mutex_exit(&ill->ill_lock);
13935 ipsq_enq(ipsq, q, mp, func, NEW_OP, ill);
13936 mutex_exit(&ipsq->ipsq_xop->ipx_lock);
13937 mutex_exit(&ipsq->ipsq_lock);
13938 RELEASE_CONN_LOCK(q);
13939 ill_refrele(ill);
13940 if (error != NULL)
13941 *error = EINPROGRESS;
13942 return (NULL);
13943 }
13944 }
13945 }
13946 RELEASE_CONN_LOCK(q);
13947 mutex_exit(&ill->ill_lock);
13948 ill_refrele(ill);
13949 if (error != NULL)
13950 *error = ENXIO;
13951 return (NULL);
13952 }
13953
13954 /*
13955 * This routine is called whenever a new address comes up on an ipif. If
13956 * we are configured to respond to address mask requests, then we are supposed
13957 * to broadcast an address mask reply at this time. This routine is also
13958 * called if we are already up, but a netmask change is made. This is legal
13959 * but might not make the system manager very popular. (May be called
13960 * as writer.)
13961 */
13962 void
13963 ipif_mask_reply(ipif_t *ipif)
13964 {
13965 icmph_t *icmph;
13966 ipha_t *ipha;
13967 mblk_t *mp;
13968 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13969 ip_xmit_attr_t ixas;
13970
13971 #define REPLY_LEN (sizeof (icmp_ipha) + sizeof (icmph_t) + IP_ADDR_LEN)
13972
13973 if (!ipst->ips_ip_respond_to_address_mask_broadcast)
13974 return;
13975
13976 /* ICMP mask reply is IPv4 only */
13977 ASSERT(!ipif->ipif_isv6);
13978 /* ICMP mask reply is not for a loopback interface */
13979 ASSERT(ipif->ipif_ill->ill_wq != NULL);
13980
13981 if (ipif->ipif_lcl_addr == INADDR_ANY)
13982 return;
13983
13984 mp = allocb(REPLY_LEN, BPRI_HI);
13985 if (mp == NULL)
13986 return;
13987 mp->b_wptr = mp->b_rptr + REPLY_LEN;
13988
13989 ipha = (ipha_t *)mp->b_rptr;
13990 bzero(ipha, REPLY_LEN);
13991 *ipha = icmp_ipha;
13992 ipha->ipha_ttl = ipst->ips_ip_broadcast_ttl;
13993 ipha->ipha_src = ipif->ipif_lcl_addr;
13994 ipha->ipha_dst = ipif->ipif_brd_addr;
13995 ipha->ipha_length = htons(REPLY_LEN);
13996 ipha->ipha_ident = 0;
13997
13998 icmph = (icmph_t *)&ipha[1];
13999 icmph->icmph_type = ICMP_ADDRESS_MASK_REPLY;
14000 bcopy(&ipif->ipif_net_mask, &icmph[1], IP_ADDR_LEN);
14001 icmph->icmph_checksum = IP_CSUM(mp, sizeof (ipha_t), 0);
14002
14003 bzero(&ixas, sizeof (ixas));
14004 ixas.ixa_flags = IXAF_BASIC_SIMPLE_V4;
14005 ixas.ixa_zoneid = ALL_ZONES;
14006 ixas.ixa_ifindex = 0;
14007 ixas.ixa_ipst = ipst;
14008 ixas.ixa_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
14009 (void) ip_output_simple(mp, &ixas);
14010 ixa_cleanup(&ixas);
14011 #undef REPLY_LEN
14012 }
14013
14014 /*
14015 * Join the ipif specific multicast groups.
14016 * Must be called after a mapping has been set up in the resolver. (Always
14017 * called as writer.)
14018 */
14019 void
14020 ipif_multicast_up(ipif_t *ipif)
14021 {
14022 int err;
14023 ill_t *ill;
14024 ilm_t *ilm;
14025
14026 ASSERT(IAM_WRITER_IPIF(ipif));
14027
14028 ill = ipif->ipif_ill;
14029
14030 ip1dbg(("ipif_multicast_up\n"));
14031 if (!(ill->ill_flags & ILLF_MULTICAST) ||
14032 ipif->ipif_allhosts_ilm != NULL)
14033 return;
14034
14035 if (ipif->ipif_isv6) {
14036 in6_addr_t v6allmc = ipv6_all_hosts_mcast;
14037 in6_addr_t v6solmc = ipv6_solicited_node_mcast;
14038
14039 v6solmc.s6_addr32[3] |= ipif->ipif_v6lcl_addr.s6_addr32[3];
14040
14041 if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr))
14042 return;
14043
14044 ip1dbg(("ipif_multicast_up - addmulti\n"));
14045
14046 /*
14047 * Join the all hosts multicast address. We skip this for
14048 * underlying IPMP interfaces since they should be invisible.
14049 */
14050 if (!IS_UNDER_IPMP(ill)) {
14051 ilm = ip_addmulti(&v6allmc, ill, ipif->ipif_zoneid,
14052 &err);
14053 if (ilm == NULL) {
14054 ASSERT(err != 0);
14055 ip0dbg(("ipif_multicast_up: "
14056 "all_hosts_mcast failed %d\n", err));
14057 return;
14058 }
14059 ipif->ipif_allhosts_ilm = ilm;
14060 }
14061
14062 /*
14063 * Enable multicast for the solicited node multicast address.
14064 * If IPMP we need to put the membership on the upper ill.
14065 */
14066 if (!(ipif->ipif_flags & IPIF_NOLOCAL)) {
14067 ill_t *mcast_ill = NULL;
14068 boolean_t need_refrele;
14069
14070 if (IS_UNDER_IPMP(ill) &&
14071 (mcast_ill = ipmp_ill_hold_ipmp_ill(ill)) != NULL) {
14072 need_refrele = B_TRUE;
14073 } else {
14074 mcast_ill = ill;
14075 need_refrele = B_FALSE;
14076 }
14077
14078 ilm = ip_addmulti(&v6solmc, mcast_ill,
14079 ipif->ipif_zoneid, &err);
14080 if (need_refrele)
14081 ill_refrele(mcast_ill);
14082
14083 if (ilm == NULL) {
14084 ASSERT(err != 0);
14085 ip0dbg(("ipif_multicast_up: solicited MC"
14086 " failed %d\n", err));
14087 if ((ilm = ipif->ipif_allhosts_ilm) != NULL) {
14088 ipif->ipif_allhosts_ilm = NULL;
14089 (void) ip_delmulti(ilm);
14090 }
14091 return;
14092 }
14093 ipif->ipif_solmulti_ilm = ilm;
14094 }
14095 } else {
14096 in6_addr_t v6group;
14097
14098 if (ipif->ipif_lcl_addr == INADDR_ANY || IS_UNDER_IPMP(ill))
14099 return;
14100
14101 /* Join the all hosts multicast address */
14102 ip1dbg(("ipif_multicast_up - addmulti\n"));
14103 IN6_IPADDR_TO_V4MAPPED(htonl(INADDR_ALLHOSTS_GROUP), &v6group);
14104
14105 ilm = ip_addmulti(&v6group, ill, ipif->ipif_zoneid, &err);
14106 if (ilm == NULL) {
14107 ASSERT(err != 0);
14108 ip0dbg(("ipif_multicast_up: failed %d\n", err));
14109 return;
14110 }
14111 ipif->ipif_allhosts_ilm = ilm;
14112 }
14113 }
14114
14115 /*
14116 * Blow away any multicast groups that we joined in ipif_multicast_up().
14117 * (ilms from explicit memberships are handled in conn_update_ill.)
14118 */
14119 void
14120 ipif_multicast_down(ipif_t *ipif)
14121 {
14122 ASSERT(IAM_WRITER_IPIF(ipif));
14123
14124 ip1dbg(("ipif_multicast_down\n"));
14125
14126 if (ipif->ipif_allhosts_ilm != NULL) {
14127 (void) ip_delmulti(ipif->ipif_allhosts_ilm);
14128 ipif->ipif_allhosts_ilm = NULL;
14129 }
14130 if (ipif->ipif_solmulti_ilm != NULL) {
14131 (void) ip_delmulti(ipif->ipif_solmulti_ilm);
14132 ipif->ipif_solmulti_ilm = NULL;
14133 }
14134 }
14135
14136 /*
14137 * Used when an interface comes up to recreate any extra routes on this
14138 * interface.
14139 */
14140 int
14141 ill_recover_saved_ire(ill_t *ill)
14142 {
14143 mblk_t *mp;
14144 ip_stack_t *ipst = ill->ill_ipst;
14145
14146 ip1dbg(("ill_recover_saved_ire(%s)", ill->ill_name));
14147
14148 mutex_enter(&ill->ill_saved_ire_lock);
14149 for (mp = ill->ill_saved_ire_mp; mp != NULL; mp = mp->b_cont) {
14150 ire_t *ire, *nire;
14151 ifrt_t *ifrt;
14152
14153 ifrt = (ifrt_t *)mp->b_rptr;
14154 /*
14155 * Create a copy of the IRE with the saved address and netmask.
14156 */
14157 if (ill->ill_isv6) {
14158 ire = ire_create_v6(
14159 &ifrt->ifrt_v6addr,
14160 &ifrt->ifrt_v6mask,
14161 &ifrt->ifrt_v6gateway_addr,
14162 ifrt->ifrt_type,
14163 ill,
14164 ifrt->ifrt_zoneid,
14165 ifrt->ifrt_flags,
14166 NULL,
14167 ipst);
14168 } else {
14169 ire = ire_create(
14170 (uint8_t *)&ifrt->ifrt_addr,
14171 (uint8_t *)&ifrt->ifrt_mask,
14172 (uint8_t *)&ifrt->ifrt_gateway_addr,
14173 ifrt->ifrt_type,
14174 ill,
14175 ifrt->ifrt_zoneid,
14176 ifrt->ifrt_flags,
14177 NULL,
14178 ipst);
14179 }
14180 if (ire == NULL) {
14181 mutex_exit(&ill->ill_saved_ire_lock);
14182 return (ENOMEM);
14183 }
14184
14185 if (ifrt->ifrt_flags & RTF_SETSRC) {
14186 if (ill->ill_isv6) {
14187 ire->ire_setsrc_addr_v6 =
14188 ifrt->ifrt_v6setsrc_addr;
14189 } else {
14190 ire->ire_setsrc_addr = ifrt->ifrt_setsrc_addr;
14191 }
14192 }
14193
14194 /*
14195 * Some software (for example, GateD and Sun Cluster) attempts
14196 * to create (what amount to) IRE_PREFIX routes with the
14197 * loopback address as the gateway. This is primarily done to
14198 * set up prefixes with the RTF_REJECT flag set (for example,
14199 * when generating aggregate routes.)
14200 *
14201 * If the IRE type (as defined by ill->ill_net_type) is
14202 * IRE_LOOPBACK, then we map the request into a
14203 * IRE_IF_NORESOLVER.
14204 */
14205 if (ill->ill_net_type == IRE_LOOPBACK)
14206 ire->ire_type = IRE_IF_NORESOLVER;
14207
14208 /*
14209 * ire held by ire_add, will be refreled' towards the
14210 * the end of ipif_up_done
14211 */
14212 nire = ire_add(ire);
14213 /*
14214 * Check if it was a duplicate entry. This handles
14215 * the case of two racing route adds for the same route
14216 */
14217 if (nire == NULL) {
14218 ip1dbg(("ill_recover_saved_ire: FAILED\n"));
14219 } else if (nire != ire) {
14220 ip1dbg(("ill_recover_saved_ire: duplicate ire %p\n",
14221 (void *)nire));
14222 ire_delete(nire);
14223 } else {
14224 ip1dbg(("ill_recover_saved_ire: added ire %p\n",
14225 (void *)nire));
14226 }
14227 if (nire != NULL)
14228 ire_refrele(nire);
14229 }
14230 mutex_exit(&ill->ill_saved_ire_lock);
14231 return (0);
14232 }
14233
14234 /*
14235 * Used to set the netmask and broadcast address to default values when the
14236 * interface is brought up. (Always called as writer.)
14237 */
14238 static void
14239 ipif_set_default(ipif_t *ipif)
14240 {
14241 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
14242
14243 if (!ipif->ipif_isv6) {
14244 /*
14245 * Interface holds an IPv4 address. Default
14246 * mask is the natural netmask.
14247 */
14248 if (!ipif->ipif_net_mask) {
14249 ipaddr_t v4mask;
14250
14251 v4mask = ip_net_mask(ipif->ipif_lcl_addr);
14252 V4MASK_TO_V6(v4mask, ipif->ipif_v6net_mask);
14253 }
14254 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14255 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
14256 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
14257 } else {
14258 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
14259 ipif->ipif_v6net_mask, ipif->ipif_v6subnet);
14260 }
14261 /*
14262 * NOTE: SunOS 4.X does this even if the broadcast address
14263 * has been already set thus we do the same here.
14264 */
14265 if (ipif->ipif_flags & IPIF_BROADCAST) {
14266 ipaddr_t v4addr;
14267
14268 v4addr = ipif->ipif_subnet | ~ipif->ipif_net_mask;
14269 IN6_IPADDR_TO_V4MAPPED(v4addr, &ipif->ipif_v6brd_addr);
14270 }
14271 } else {
14272 /*
14273 * Interface holds an IPv6-only address. Default
14274 * mask is all-ones.
14275 */
14276 if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6net_mask))
14277 ipif->ipif_v6net_mask = ipv6_all_ones;
14278 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14279 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
14280 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
14281 } else {
14282 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
14283 ipif->ipif_v6net_mask, ipif->ipif_v6subnet);
14284 }
14285 }
14286 }
14287
14288 /*
14289 * Return 0 if this address can be used as local address without causing
14290 * duplicate address problems. Otherwise, return EADDRNOTAVAIL if the address
14291 * is already up on a different ill, and EADDRINUSE if it's up on the same ill.
14292 * Note that the same IPv6 link-local address is allowed as long as the ills
14293 * are not on the same link.
14294 */
14295 int
14296 ip_addr_availability_check(ipif_t *new_ipif)
14297 {
14298 in6_addr_t our_v6addr;
14299 ill_t *ill;
14300 ipif_t *ipif;
14301 ill_walk_context_t ctx;
14302 ip_stack_t *ipst = new_ipif->ipif_ill->ill_ipst;
14303
14304 ASSERT(IAM_WRITER_IPIF(new_ipif));
14305 ASSERT(MUTEX_HELD(&ipst->ips_ip_addr_avail_lock));
14306 ASSERT(RW_READ_HELD(&ipst->ips_ill_g_lock));
14307
14308 new_ipif->ipif_flags &= ~IPIF_UNNUMBERED;
14309 if (IN6_IS_ADDR_UNSPECIFIED(&new_ipif->ipif_v6lcl_addr) ||
14310 IN6_IS_ADDR_V4MAPPED_ANY(&new_ipif->ipif_v6lcl_addr))
14311 return (0);
14312
14313 our_v6addr = new_ipif->ipif_v6lcl_addr;
14314
14315 if (new_ipif->ipif_isv6)
14316 ill = ILL_START_WALK_V6(&ctx, ipst);
14317 else
14318 ill = ILL_START_WALK_V4(&ctx, ipst);
14319
14320 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
14321 for (ipif = ill->ill_ipif; ipif != NULL;
14322 ipif = ipif->ipif_next) {
14323 if ((ipif == new_ipif) ||
14324 !(ipif->ipif_flags & IPIF_UP) ||
14325 (ipif->ipif_flags & IPIF_UNNUMBERED) ||
14326 !IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6lcl_addr,
14327 &our_v6addr))
14328 continue;
14329
14330 if (new_ipif->ipif_flags & IPIF_POINTOPOINT)
14331 new_ipif->ipif_flags |= IPIF_UNNUMBERED;
14332 else if (ipif->ipif_flags & IPIF_POINTOPOINT)
14333 ipif->ipif_flags |= IPIF_UNNUMBERED;
14334 else if ((IN6_IS_ADDR_LINKLOCAL(&our_v6addr) ||
14335 IN6_IS_ADDR_SITELOCAL(&our_v6addr)) &&
14336 !IS_ON_SAME_LAN(ill, new_ipif->ipif_ill))
14337 continue;
14338 else if (new_ipif->ipif_zoneid != ipif->ipif_zoneid &&
14339 ipif->ipif_zoneid != ALL_ZONES && IS_LOOPBACK(ill))
14340 continue;
14341 else if (new_ipif->ipif_ill == ill)
14342 return (EADDRINUSE);
14343 else
14344 return (EADDRNOTAVAIL);
14345 }
14346 }
14347
14348 return (0);
14349 }
14350
14351 /*
14352 * Bring up an ipif: bring up arp/ndp, bring up the DLPI stream, and add
14353 * IREs for the ipif.
14354 * When the routine returns EINPROGRESS then mp has been consumed and
14355 * the ioctl will be acked from ip_rput_dlpi.
14356 */
14357 int
14358 ipif_up(ipif_t *ipif, queue_t *q, mblk_t *mp)
14359 {
14360 ill_t *ill = ipif->ipif_ill;
14361 boolean_t isv6 = ipif->ipif_isv6;
14362 int err = 0;
14363 boolean_t success;
14364 uint_t ipif_orig_id;
14365 ip_stack_t *ipst = ill->ill_ipst;
14366
14367 ASSERT(IAM_WRITER_IPIF(ipif));
14368
14369 ip1dbg(("ipif_up(%s:%u)\n", ill->ill_name, ipif->ipif_id));
14370 DTRACE_PROBE3(ipif__downup, char *, "ipif_up",
14371 ill_t *, ill, ipif_t *, ipif);
14372
14373 /* Shouldn't get here if it is already up. */
14374 if (ipif->ipif_flags & IPIF_UP)
14375 return (EALREADY);
14376
14377 /*
14378 * If this is a request to bring up a data address on an interface
14379 * under IPMP, then move the address to its IPMP meta-interface and
14380 * try to bring it up. One complication is that the zeroth ipif for
14381 * an ill is special, in that every ill always has one, and that code
14382 * throughout IP deferences ill->ill_ipif without holding any locks.
14383 */
14384 if (IS_UNDER_IPMP(ill) && ipmp_ipif_is_dataaddr(ipif) &&
14385 (!ipif->ipif_isv6 || !V6_IPIF_LINKLOCAL(ipif))) {
14386 ipif_t *stubipif = NULL, *moveipif = NULL;
14387 ill_t *ipmp_ill = ipmp_illgrp_ipmp_ill(ill->ill_grp);
14388
14389 /*
14390 * The ipif being brought up should be quiesced. If it's not,
14391 * something has gone amiss and we need to bail out. (If it's
14392 * quiesced, we know it will remain so via IPIF_CONDEMNED.)
14393 */
14394 mutex_enter(&ill->ill_lock);
14395 if (!ipif_is_quiescent(ipif)) {
14396 mutex_exit(&ill->ill_lock);
14397 return (EINVAL);
14398 }
14399 mutex_exit(&ill->ill_lock);
14400
14401 /*
14402 * If we're going to need to allocate ipifs, do it prior
14403 * to starting the move (and grabbing locks).
14404 */
14405 if (ipif->ipif_id == 0) {
14406 if ((moveipif = ipif_allocate(ill, 0, IRE_LOCAL, B_TRUE,
14407 B_FALSE, &err)) == NULL) {
14408 return (err);
14409 }
14410 if ((stubipif = ipif_allocate(ill, 0, IRE_LOCAL, B_TRUE,
14411 B_FALSE, &err)) == NULL) {
14412 mi_free(moveipif);
14413 return (err);
14414 }
14415 }
14416
14417 /*
14418 * Grab or transfer the ipif to move. During the move, keep
14419 * ill_g_lock held to prevent any ill walker threads from
14420 * seeing things in an inconsistent state.
14421 */
14422 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
14423 if (ipif->ipif_id != 0) {
14424 ipif_remove(ipif);
14425 } else {
14426 ipif_transfer(ipif, moveipif, stubipif);
14427 ipif = moveipif;
14428 }
14429
14430 /*
14431 * Place the ipif on the IPMP ill. If the zeroth ipif on
14432 * the IPMP ill is a stub (0.0.0.0 down address) then we
14433 * replace that one. Otherwise, pick the next available slot.
14434 */
14435 ipif->ipif_ill = ipmp_ill;
14436 ipif_orig_id = ipif->ipif_id;
14437
14438 if (ipmp_ipif_is_stubaddr(ipmp_ill->ill_ipif)) {
14439 ipif_transfer(ipif, ipmp_ill->ill_ipif, NULL);
14440 ipif = ipmp_ill->ill_ipif;
14441 } else {
14442 ipif->ipif_id = -1;
14443 if ((err = ipif_insert(ipif, B_FALSE)) != 0) {
14444 /*
14445 * No more available ipif_id's -- put it back
14446 * on the original ill and fail the operation.
14447 * Since we're writer on the ill, we can be
14448 * sure our old slot is still available.
14449 */
14450 ipif->ipif_id = ipif_orig_id;
14451 ipif->ipif_ill = ill;
14452 if (ipif_orig_id == 0) {
14453 ipif_transfer(ipif, ill->ill_ipif,
14454 NULL);
14455 } else {
14456 VERIFY(ipif_insert(ipif, B_FALSE) == 0);
14457 }
14458 rw_exit(&ipst->ips_ill_g_lock);
14459 return (err);
14460 }
14461 }
14462 rw_exit(&ipst->ips_ill_g_lock);
14463
14464 /*
14465 * Tell SCTP that the ipif has moved. Note that even if we
14466 * had to allocate a new ipif, the original sequence id was
14467 * preserved and therefore SCTP won't know.
14468 */
14469 sctp_move_ipif(ipif, ill, ipmp_ill);
14470
14471 /*
14472 * If the ipif being brought up was on slot zero, then we
14473 * first need to bring up the placeholder we stuck there. In
14474 * ip_rput_dlpi_writer(), arp_bringup_done(), or the recursive
14475 * call to ipif_up() itself, if we successfully bring up the
14476 * placeholder, we'll check ill_move_ipif and bring it up too.
14477 */
14478 if (ipif_orig_id == 0) {
14479 ASSERT(ill->ill_move_ipif == NULL);
14480 ill->ill_move_ipif = ipif;
14481 if ((err = ipif_up(ill->ill_ipif, q, mp)) == 0)
14482 ASSERT(ill->ill_move_ipif == NULL);
14483 if (err != EINPROGRESS)
14484 ill->ill_move_ipif = NULL;
14485 return (err);
14486 }
14487
14488 /*
14489 * Bring it up on the IPMP ill.
14490 */
14491 return (ipif_up(ipif, q, mp));
14492 }
14493
14494 /* Skip arp/ndp for any loopback interface. */
14495 if (ill->ill_wq != NULL) {
14496 conn_t *connp = CONN_Q(q) ? Q_TO_CONN(q) : NULL;
14497 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
14498
14499 if (!ill->ill_dl_up) {
14500 /*
14501 * ill_dl_up is not yet set. i.e. we are yet to
14502 * DL_BIND with the driver and this is the first
14503 * logical interface on the ill to become "up".
14504 * Tell the driver to get going (via DL_BIND_REQ).
14505 * Note that changing "significant" IFF_ flags
14506 * address/netmask etc cause a down/up dance, but
14507 * does not cause an unbind (DL_UNBIND) with the driver
14508 */
14509 return (ill_dl_up(ill, ipif, mp, q));
14510 }
14511
14512 /*
14513 * ipif_resolver_up may end up needeing to bind/attach
14514 * the ARP stream, which in turn necessitates a
14515 * DLPI message exchange with the driver. ioctls are
14516 * serialized and so we cannot send more than one
14517 * interface up message at a time. If ipif_resolver_up
14518 * does need to wait for the DLPI handshake for the ARP stream,
14519 * we get EINPROGRESS and we will complete in arp_bringup_done.
14520 */
14521
14522 ASSERT(connp != NULL || !CONN_Q(q));
14523 if (connp != NULL)
14524 mutex_enter(&connp->conn_lock);
14525 mutex_enter(&ill->ill_lock);
14526 success = ipsq_pending_mp_add(connp, ipif, q, mp, 0);
14527 mutex_exit(&ill->ill_lock);
14528 if (connp != NULL)
14529 mutex_exit(&connp->conn_lock);
14530 if (!success)
14531 return (EINTR);
14532
14533 /*
14534 * Crank up IPv6 neighbor discovery. Unlike ARP, this should
14535 * complete when ipif_ndp_up returns.
14536 */
14537 err = ipif_resolver_up(ipif, Res_act_initial);
14538 if (err == EINPROGRESS) {
14539 /* We will complete it in arp_bringup_done() */
14540 return (err);
14541 }
14542
14543 if (isv6 && err == 0)
14544 err = ipif_ndp_up(ipif, B_TRUE);
14545
14546 ASSERT(err != EINPROGRESS);
14547 mp = ipsq_pending_mp_get(ipsq, &connp);
14548 ASSERT(mp != NULL);
14549 if (err != 0)
14550 return (err);
14551 } else {
14552 /*
14553 * Interfaces without underlying hardware don't do duplicate
14554 * address detection.
14555 */
14556 ASSERT(!(ipif->ipif_flags & IPIF_DUPLICATE));
14557 ipif->ipif_addr_ready = 1;
14558 err = ill_add_ires(ill);
14559 /* allocation failure? */
14560 if (err != 0)
14561 return (err);
14562 }
14563
14564 err = (isv6 ? ipif_up_done_v6(ipif) : ipif_up_done(ipif));
14565 if (err == 0 && ill->ill_move_ipif != NULL) {
14566 ipif = ill->ill_move_ipif;
14567 ill->ill_move_ipif = NULL;
14568 return (ipif_up(ipif, q, mp));
14569 }
14570 return (err);
14571 }
14572
14573 /*
14574 * Add any IREs tied to the ill. For now this is just an IRE_MULTICAST.
14575 * The identical set of IREs need to be removed in ill_delete_ires().
14576 */
14577 int
14578 ill_add_ires(ill_t *ill)
14579 {
14580 ire_t *ire;
14581 in6_addr_t dummy6 = {(uint32_t)V6_MCAST, 0, 0, 1};
14582 in_addr_t dummy4 = htonl(INADDR_ALLHOSTS_GROUP);
14583
14584 if (ill->ill_ire_multicast != NULL)
14585 return (0);
14586
14587 /*
14588 * provide some dummy ire_addr for creating the ire.
14589 */
14590 if (ill->ill_isv6) {
14591 ire = ire_create_v6(&dummy6, 0, 0, IRE_MULTICAST, ill,
14592 ALL_ZONES, RTF_UP, NULL, ill->ill_ipst);
14593 } else {
14594 ire = ire_create((uchar_t *)&dummy4, 0, 0, IRE_MULTICAST, ill,
14595 ALL_ZONES, RTF_UP, NULL, ill->ill_ipst);
14596 }
14597 if (ire == NULL)
14598 return (ENOMEM);
14599
14600 ill->ill_ire_multicast = ire;
14601 return (0);
14602 }
14603
14604 void
14605 ill_delete_ires(ill_t *ill)
14606 {
14607 if (ill->ill_ire_multicast != NULL) {
14608 /*
14609 * BIND/ATTACH completed; Release the ref for ill_ire_multicast
14610 * which was taken without any th_tracing enabled.
14611 * We also mark it as condemned (note that it was never added)
14612 * so that caching conn's can move off of it.
14613 */
14614 ire_make_condemned(ill->ill_ire_multicast);
14615 ire_refrele_notr(ill->ill_ire_multicast);
14616 ill->ill_ire_multicast = NULL;
14617 }
14618 }
14619
14620 /*
14621 * Perform a bind for the physical device.
14622 * When the routine returns EINPROGRESS then mp has been consumed and
14623 * the ioctl will be acked from ip_rput_dlpi.
14624 * Allocate an unbind message and save it until ipif_down.
14625 */
14626 static int
14627 ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
14628 {
14629 mblk_t *bind_mp = NULL;
14630 mblk_t *unbind_mp = NULL;
14631 conn_t *connp;
14632 boolean_t success;
14633 int err;
14634
14635 DTRACE_PROBE2(ill__downup, char *, "ill_dl_up", ill_t *, ill);
14636
14637 ip1dbg(("ill_dl_up(%s)\n", ill->ill_name));
14638 ASSERT(IAM_WRITER_ILL(ill));
14639 ASSERT(mp != NULL);
14640
14641 /*
14642 * Make sure we have an IRE_MULTICAST in case we immediately
14643 * start receiving packets.
14644 */
14645 err = ill_add_ires(ill);
14646 if (err != 0)
14647 goto bad;
14648
14649 bind_mp = ip_dlpi_alloc(sizeof (dl_bind_req_t) + sizeof (long),
14650 DL_BIND_REQ);
14651 if (bind_mp == NULL)
14652 goto bad;
14653 ((dl_bind_req_t *)bind_mp->b_rptr)->dl_sap = ill->ill_sap;
14654 ((dl_bind_req_t *)bind_mp->b_rptr)->dl_service_mode = DL_CLDLS;
14655
14656 /*
14657 * ill_unbind_mp would be non-null if the following sequence had
14658 * happened:
14659 * - send DL_BIND_REQ to driver, wait for response
14660 * - multiple ioctls that need to bring the ipif up are encountered,
14661 * but they cannot enter the ipsq due to the outstanding DL_BIND_REQ.
14662 * These ioctls will then be enqueued on the ipsq
14663 * - a DL_ERROR_ACK is returned for the DL_BIND_REQ
14664 * At this point, the pending ioctls in the ipsq will be drained, and
14665 * since ill->ill_dl_up was not set, ill_dl_up would be invoked with
14666 * a non-null ill->ill_unbind_mp
14667 */
14668 if (ill->ill_unbind_mp == NULL) {
14669 unbind_mp = ip_dlpi_alloc(sizeof (dl_unbind_req_t),
14670 DL_UNBIND_REQ);
14671 if (unbind_mp == NULL)
14672 goto bad;
14673 }
14674 /*
14675 * Record state needed to complete this operation when the
14676 * DL_BIND_ACK shows up. Also remember the pre-allocated mblks.
14677 */
14678 connp = CONN_Q(q) ? Q_TO_CONN(q) : NULL;
14679 ASSERT(connp != NULL || !CONN_Q(q));
14680 GRAB_CONN_LOCK(q);
14681 mutex_enter(&ipif->ipif_ill->ill_lock);
14682 success = ipsq_pending_mp_add(connp, ipif, q, mp, 0);
14683 mutex_exit(&ipif->ipif_ill->ill_lock);
14684 RELEASE_CONN_LOCK(q);
14685 if (!success)
14686 goto bad;
14687
14688 /*
14689 * Save the unbind message for ill_dl_down(); it will be consumed when
14690 * the interface goes down.
14691 */
14692 if (ill->ill_unbind_mp == NULL)
14693 ill->ill_unbind_mp = unbind_mp;
14694
14695 ill_dlpi_send(ill, bind_mp);
14696 /* Send down link-layer capabilities probe if not already done. */
14697 ill_capability_probe(ill);
14698
14699 /*
14700 * Sysid used to rely on the fact that netboots set domainname
14701 * and the like. Now that miniroot boots aren't strictly netboots
14702 * and miniroot network configuration is driven from userland
14703 * these things still need to be set. This situation can be detected
14704 * by comparing the interface being configured here to the one
14705 * dhcifname was set to reference by the boot loader. Once sysid is
14706 * converted to use dhcp_ipc_getinfo() this call can go away.
14707 */
14708 if ((ipif->ipif_flags & IPIF_DHCPRUNNING) &&
14709 (strcmp(ill->ill_name, dhcifname) == 0) &&
14710 (strlen(srpc_domain) == 0)) {
14711 if (dhcpinit() != 0)
14712 cmn_err(CE_WARN, "no cached dhcp response");
14713 }
14714
14715 /*
14716 * This operation will complete in ip_rput_dlpi with either
14717 * a DL_BIND_ACK or DL_ERROR_ACK.
14718 */
14719 return (EINPROGRESS);
14720 bad:
14721 ip1dbg(("ill_dl_up(%s) FAILED\n", ill->ill_name));
14722
14723 freemsg(bind_mp);
14724 freemsg(unbind_mp);
14725 return (ENOMEM);
14726 }
14727
14728 /* Add room for tcp+ip headers */
14729 uint_t ip_loopback_mtuplus = IP_LOOPBACK_MTU + IP_SIMPLE_HDR_LENGTH + 20;
14730
14731 /*
14732 * DLPI and ARP is up.
14733 * Create all the IREs associated with an interface. Bring up multicast.
14734 * Set the interface flag and finish other initialization
14735 * that potentially had to be deferred to after DL_BIND_ACK.
14736 */
14737 int
14738 ipif_up_done(ipif_t *ipif)
14739 {
14740 ill_t *ill = ipif->ipif_ill;
14741 int err = 0;
14742 boolean_t loopback = B_FALSE;
14743 boolean_t update_src_selection = B_TRUE;
14744 ipif_t *tmp_ipif;
14745
14746 ip1dbg(("ipif_up_done(%s:%u)\n",
14747 ipif->ipif_ill->ill_name, ipif->ipif_id));
14748 DTRACE_PROBE3(ipif__downup, char *, "ipif_up_done",
14749 ill_t *, ill, ipif_t *, ipif);
14750
14751 /* Check if this is a loopback interface */
14752 if (ipif->ipif_ill->ill_wq == NULL)
14753 loopback = B_TRUE;
14754
14755 ASSERT(!MUTEX_HELD(&ipif->ipif_ill->ill_lock));
14756
14757 /*
14758 * If all other interfaces for this ill are down or DEPRECATED,
14759 * or otherwise unsuitable for source address selection,
14760 * reset the src generation numbers to make sure source
14761 * address selection gets to take this new ipif into account.
14762 * No need to hold ill_lock while traversing the ipif list since
14763 * we are writer
14764 */
14765 for (tmp_ipif = ill->ill_ipif; tmp_ipif;
14766 tmp_ipif = tmp_ipif->ipif_next) {
14767 if (((tmp_ipif->ipif_flags &
14768 (IPIF_NOXMIT|IPIF_ANYCAST|IPIF_NOLOCAL|IPIF_DEPRECATED)) ||
14769 !(tmp_ipif->ipif_flags & IPIF_UP)) ||
14770 (tmp_ipif == ipif))
14771 continue;
14772 /* first useable pre-existing interface */
14773 update_src_selection = B_FALSE;
14774 break;
14775 }
14776 if (update_src_selection)
14777 ip_update_source_selection(ill->ill_ipst);
14778
14779 if (IS_LOOPBACK(ill) || ill->ill_net_type == IRE_IF_NORESOLVER) {
14780 nce_t *loop_nce = NULL;
14781 uint16_t flags = (NCE_F_MYADDR | NCE_F_AUTHORITY | NCE_F_NONUD);
14782
14783 /*
14784 * lo0:1 and subsequent ipifs were marked IRE_LOCAL in
14785 * ipif_lookup_on_name(), but in the case of zones we can have
14786 * several loopback addresses on lo0. So all the interfaces with
14787 * loopback addresses need to be marked IRE_LOOPBACK.
14788 */
14789 if (V4_PART_OF_V6(ipif->ipif_v6lcl_addr) ==
14790 htonl(INADDR_LOOPBACK))
14791 ipif->ipif_ire_type = IRE_LOOPBACK;
14792 else
14793 ipif->ipif_ire_type = IRE_LOCAL;
14794 if (ill->ill_net_type != IRE_LOOPBACK)
14795 flags |= NCE_F_PUBLISH;
14796
14797 /* add unicast nce for the local addr */
14798 err = nce_lookup_then_add_v4(ill, NULL,
14799 ill->ill_phys_addr_length, &ipif->ipif_lcl_addr, flags,
14800 ND_REACHABLE, &loop_nce);
14801 /* A shared-IP zone sees EEXIST for lo0:N */
14802 if (err == 0 || err == EEXIST) {
14803 ipif->ipif_added_nce = 1;
14804 loop_nce->nce_ipif_cnt++;
14805 nce_refrele(loop_nce);
14806 err = 0;
14807 } else {
14808 ASSERT(loop_nce == NULL);
14809 return (err);
14810 }
14811 }
14812
14813 /* Create all the IREs associated with this interface */
14814 err = ipif_add_ires_v4(ipif, loopback);
14815 if (err != 0) {
14816 /*
14817 * see comments about return value from
14818 * ip_addr_availability_check() in ipif_add_ires_v4().
14819 */
14820 if (err != EADDRINUSE) {
14821 (void) ipif_arp_down(ipif);
14822 } else {
14823 /*
14824 * Make IPMP aware of the deleted ipif so that
14825 * the needed ipmp cleanup (e.g., of ipif_bound_ill)
14826 * can be completed. Note that we do not want to
14827 * destroy the nce that was created on the ipmp_ill
14828 * for the active copy of the duplicate address in
14829 * use.
14830 */
14831 if (IS_IPMP(ill))
14832 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
14833 err = EADDRNOTAVAIL;
14834 }
14835 return (err);
14836 }
14837
14838 if (ill->ill_ipif_up_count == 1 && !loopback) {
14839 /* Recover any additional IREs entries for this ill */
14840 (void) ill_recover_saved_ire(ill);
14841 }
14842
14843 if (ill->ill_need_recover_multicast) {
14844 /*
14845 * Need to recover all multicast memberships in the driver.
14846 * This had to be deferred until we had attached. The same
14847 * code exists in ipif_up_done_v6() to recover IPv6
14848 * memberships.
14849 *
14850 * Note that it would be preferable to unconditionally do the
14851 * ill_recover_multicast() in ill_dl_up(), but we cannot do
14852 * that since ill_join_allmulti() depends on ill_dl_up being
14853 * set, and it is not set until we receive a DL_BIND_ACK after
14854 * having called ill_dl_up().
14855 */
14856 ill_recover_multicast(ill);
14857 }
14858
14859 if (ill->ill_ipif_up_count == 1) {
14860 /*
14861 * Since the interface is now up, it may now be active.
14862 */
14863 if (IS_UNDER_IPMP(ill))
14864 ipmp_ill_refresh_active(ill);
14865
14866 /*
14867 * If this is an IPMP interface, we may now be able to
14868 * establish ARP entries.
14869 */
14870 if (IS_IPMP(ill))
14871 ipmp_illgrp_refresh_arpent(ill->ill_grp);
14872 }
14873
14874 /* Join the allhosts multicast address */
14875 ipif_multicast_up(ipif);
14876
14877 if (!loopback && !update_src_selection &&
14878 !(ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST|IPIF_DEPRECATED)))
14879 ip_update_source_selection(ill->ill_ipst);
14880
14881 if (!loopback && ipif->ipif_addr_ready) {
14882 /* Broadcast an address mask reply. */
14883 ipif_mask_reply(ipif);
14884 }
14885 /* Perhaps ilgs should use this ill */
14886 update_conn_ill(NULL, ill->ill_ipst);
14887
14888 /*
14889 * This had to be deferred until we had bound. Tell routing sockets and
14890 * others that this interface is up if it looks like the address has
14891 * been validated. Otherwise, if it isn't ready yet, wait for
14892 * duplicate address detection to do its thing.
14893 */
14894 if (ipif->ipif_addr_ready)
14895 ipif_up_notify(ipif);
14896 return (0);
14897 }
14898
14899 /*
14900 * Add the IREs associated with the ipif.
14901 * Those MUST be explicitly removed in ipif_delete_ires_v4.
14902 */
14903 static int
14904 ipif_add_ires_v4(ipif_t *ipif, boolean_t loopback)
14905 {
14906 ill_t *ill = ipif->ipif_ill;
14907 ip_stack_t *ipst = ill->ill_ipst;
14908 ire_t *ire_array[20];
14909 ire_t **irep = ire_array;
14910 ire_t **irep1;
14911 ipaddr_t net_mask = 0;
14912 ipaddr_t subnet_mask, route_mask;
14913 int err;
14914 ire_t *ire_local = NULL; /* LOCAL or LOOPBACK */
14915 ire_t *ire_if = NULL;
14916 uchar_t *gw;
14917
14918 if ((ipif->ipif_lcl_addr != INADDR_ANY) &&
14919 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
14920 /*
14921 * If we're on a labeled system then make sure that zone-
14922 * private addresses have proper remote host database entries.
14923 */
14924 if (is_system_labeled() &&
14925 ipif->ipif_ire_type != IRE_LOOPBACK &&
14926 !tsol_check_interface_address(ipif))
14927 return (EINVAL);
14928
14929 /* Register the source address for __sin6_src_id */
14930 err = ip_srcid_insert(&ipif->ipif_v6lcl_addr,
14931 ipif->ipif_zoneid, ipst);
14932 if (err != 0) {
14933 ip0dbg(("ipif_add_ires: srcid_insert %d\n", err));
14934 return (err);
14935 }
14936
14937 if (loopback)
14938 gw = (uchar_t *)&ipif->ipif_lcl_addr;
14939 else
14940 gw = NULL;
14941
14942 /* If the interface address is set, create the local IRE. */
14943 ire_local = ire_create(
14944 (uchar_t *)&ipif->ipif_lcl_addr, /* dest address */
14945 (uchar_t *)&ip_g_all_ones, /* mask */
14946 gw, /* gateway */
14947 ipif->ipif_ire_type, /* LOCAL or LOOPBACK */
14948 ipif->ipif_ill,
14949 ipif->ipif_zoneid,
14950 ((ipif->ipif_flags & IPIF_PRIVATE) ?
14951 RTF_PRIVATE : 0) | RTF_KERNEL,
14952 NULL,
14953 ipst);
14954 ip1dbg(("ipif_add_ires: 0x%p creating IRE %p type 0x%x"
14955 " for 0x%x\n", (void *)ipif, (void *)ire_local,
14956 ipif->ipif_ire_type,
14957 ntohl(ipif->ipif_lcl_addr)));
14958 if (ire_local == NULL) {
14959 ip1dbg(("ipif_up_done: NULL ire_local\n"));
14960 err = ENOMEM;
14961 goto bad;
14962 }
14963 } else {
14964 ip1dbg((
14965 "ipif_add_ires: not creating IRE %d for 0x%x: flags 0x%x\n",
14966 ipif->ipif_ire_type,
14967 ntohl(ipif->ipif_lcl_addr),
14968 (uint_t)ipif->ipif_flags));
14969 }
14970 if ((ipif->ipif_lcl_addr != INADDR_ANY) &&
14971 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
14972 net_mask = ip_net_mask(ipif->ipif_lcl_addr);
14973 } else {
14974 net_mask = htonl(IN_CLASSA_NET); /* fallback */
14975 }
14976
14977 subnet_mask = ipif->ipif_net_mask;
14978
14979 /*
14980 * If mask was not specified, use natural netmask of
14981 * interface address. Also, store this mask back into the
14982 * ipif struct.
14983 */
14984 if (subnet_mask == 0) {
14985 subnet_mask = net_mask;
14986 V4MASK_TO_V6(subnet_mask, ipif->ipif_v6net_mask);
14987 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
14988 ipif->ipif_v6subnet);
14989 }
14990
14991 /* Set up the IRE_IF_RESOLVER or IRE_IF_NORESOLVER, as appropriate. */
14992 if (!loopback && !(ipif->ipif_flags & IPIF_NOXMIT) &&
14993 ipif->ipif_subnet != INADDR_ANY) {
14994 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
14995
14996 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14997 route_mask = IP_HOST_MASK;
14998 } else {
14999 route_mask = subnet_mask;
15000 }
15001
15002 ip1dbg(("ipif_add_ires: ipif 0x%p ill 0x%p "
15003 "creating if IRE ill_net_type 0x%x for 0x%x\n",
15004 (void *)ipif, (void *)ill, ill->ill_net_type,
15005 ntohl(ipif->ipif_subnet)));
15006 ire_if = ire_create(
15007 (uchar_t *)&ipif->ipif_subnet,
15008 (uchar_t *)&route_mask,
15009 (uchar_t *)&ipif->ipif_lcl_addr,
15010 ill->ill_net_type,
15011 ill,
15012 ipif->ipif_zoneid,
15013 ((ipif->ipif_flags & IPIF_PRIVATE) ?
15014 RTF_PRIVATE: 0) | RTF_KERNEL,
15015 NULL,
15016 ipst);
15017 if (ire_if == NULL) {
15018 ip1dbg(("ipif_up_done: NULL ire_if\n"));
15019 err = ENOMEM;
15020 goto bad;
15021 }
15022 }
15023
15024 /*
15025 * Create any necessary broadcast IREs.
15026 */
15027 if ((ipif->ipif_flags & IPIF_BROADCAST) &&
15028 !(ipif->ipif_flags & IPIF_NOXMIT))
15029 irep = ipif_create_bcast_ires(ipif, irep);
15030
15031 /* If an earlier ire_create failed, get out now */
15032 for (irep1 = irep; irep1 > ire_array; ) {
15033 irep1--;
15034 if (*irep1 == NULL) {
15035 ip1dbg(("ipif_up_done: NULL ire found in ire_array\n"));
15036 err = ENOMEM;
15037 goto bad;
15038 }
15039 }
15040
15041 /*
15042 * Need to atomically check for IP address availability under
15043 * ip_addr_avail_lock. ill_g_lock is held as reader to ensure no new
15044 * ills or new ipifs can be added while we are checking availability.
15045 */
15046 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
15047 mutex_enter(&ipst->ips_ip_addr_avail_lock);
15048 /* Mark it up, and increment counters. */
15049 ipif->ipif_flags |= IPIF_UP;
15050 ill->ill_ipif_up_count++;
15051 err = ip_addr_availability_check(ipif);
15052 mutex_exit(&ipst->ips_ip_addr_avail_lock);
15053 rw_exit(&ipst->ips_ill_g_lock);
15054
15055 if (err != 0) {
15056 /*
15057 * Our address may already be up on the same ill. In this case,
15058 * the ARP entry for our ipif replaced the one for the other
15059 * ipif. So we don't want to delete it (otherwise the other ipif
15060 * would be unable to send packets).
15061 * ip_addr_availability_check() identifies this case for us and
15062 * returns EADDRINUSE; Caller should turn it into EADDRNOTAVAIL
15063 * which is the expected error code.
15064 */
15065 ill->ill_ipif_up_count--;
15066 ipif->ipif_flags &= ~IPIF_UP;
15067 goto bad;
15068 }
15069
15070 /*
15071 * Add in all newly created IREs. ire_create_bcast() has
15072 * already checked for duplicates of the IRE_BROADCAST type.
15073 * We add the IRE_INTERFACE before the IRE_LOCAL to ensure
15074 * that lookups find the IRE_LOCAL even if the IRE_INTERFACE is
15075 * a /32 route.
15076 */
15077 if (ire_if != NULL) {
15078 ire_if = ire_add(ire_if);
15079 if (ire_if == NULL) {
15080 err = ENOMEM;
15081 goto bad2;
15082 }
15083 #ifdef DEBUG
15084 ire_refhold_notr(ire_if);
15085 ire_refrele(ire_if);
15086 #endif
15087 }
15088 if (ire_local != NULL) {
15089 ire_local = ire_add(ire_local);
15090 if (ire_local == NULL) {
15091 err = ENOMEM;
15092 goto bad2;
15093 }
15094 #ifdef DEBUG
15095 ire_refhold_notr(ire_local);
15096 ire_refrele(ire_local);
15097 #endif
15098 }
15099 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15100 if (ire_local != NULL)
15101 ipif->ipif_ire_local = ire_local;
15102 if (ire_if != NULL)
15103 ipif->ipif_ire_if = ire_if;
15104 rw_exit(&ipst->ips_ill_g_lock);
15105 ire_local = NULL;
15106 ire_if = NULL;
15107
15108 /*
15109 * We first add all of them, and if that succeeds we refrele the
15110 * bunch. That enables us to delete all of them should any of the
15111 * ire_adds fail.
15112 */
15113 for (irep1 = irep; irep1 > ire_array; ) {
15114 irep1--;
15115 ASSERT(!MUTEX_HELD(&((*irep1)->ire_ill->ill_lock)));
15116 *irep1 = ire_add(*irep1);
15117 if (*irep1 == NULL) {
15118 err = ENOMEM;
15119 goto bad2;
15120 }
15121 }
15122
15123 for (irep1 = irep; irep1 > ire_array; ) {
15124 irep1--;
15125 /* refheld by ire_add. */
15126 if (*irep1 != NULL) {
15127 ire_refrele(*irep1);
15128 *irep1 = NULL;
15129 }
15130 }
15131
15132 if (!loopback) {
15133 /*
15134 * If the broadcast address has been set, make sure it makes
15135 * sense based on the interface address.
15136 * Only match on ill since we are sharing broadcast addresses.
15137 */
15138 if ((ipif->ipif_brd_addr != INADDR_ANY) &&
15139 (ipif->ipif_flags & IPIF_BROADCAST)) {
15140 ire_t *ire;
15141
15142 ire = ire_ftable_lookup_v4(ipif->ipif_brd_addr, 0, 0,
15143 IRE_BROADCAST, ipif->ipif_ill, ALL_ZONES, NULL,
15144 (MATCH_IRE_TYPE | MATCH_IRE_ILL), 0, ipst, NULL);
15145
15146 if (ire == NULL) {
15147 /*
15148 * If there isn't a matching broadcast IRE,
15149 * revert to the default for this netmask.
15150 */
15151 ipif->ipif_v6brd_addr = ipv6_all_zeros;
15152 mutex_enter(&ipif->ipif_ill->ill_lock);
15153 ipif_set_default(ipif);
15154 mutex_exit(&ipif->ipif_ill->ill_lock);
15155 } else {
15156 ire_refrele(ire);
15157 }
15158 }
15159
15160 }
15161 return (0);
15162
15163 bad2:
15164 ill->ill_ipif_up_count--;
15165 ipif->ipif_flags &= ~IPIF_UP;
15166
15167 bad:
15168 ip1dbg(("ipif_add_ires: FAILED \n"));
15169 if (ire_local != NULL)
15170 ire_delete(ire_local);
15171 if (ire_if != NULL)
15172 ire_delete(ire_if);
15173
15174 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15175 ire_local = ipif->ipif_ire_local;
15176 ipif->ipif_ire_local = NULL;
15177 ire_if = ipif->ipif_ire_if;
15178 ipif->ipif_ire_if = NULL;
15179 rw_exit(&ipst->ips_ill_g_lock);
15180 if (ire_local != NULL) {
15181 ire_delete(ire_local);
15182 ire_refrele_notr(ire_local);
15183 }
15184 if (ire_if != NULL) {
15185 ire_delete(ire_if);
15186 ire_refrele_notr(ire_if);
15187 }
15188
15189 while (irep > ire_array) {
15190 irep--;
15191 if (*irep != NULL) {
15192 ire_delete(*irep);
15193 }
15194 }
15195 (void) ip_srcid_remove(&ipif->ipif_v6lcl_addr, ipif->ipif_zoneid, ipst);
15196
15197 return (err);
15198 }
15199
15200 /* Remove all the IREs created by ipif_add_ires_v4 */
15201 void
15202 ipif_delete_ires_v4(ipif_t *ipif)
15203 {
15204 ill_t *ill = ipif->ipif_ill;
15205 ip_stack_t *ipst = ill->ill_ipst;
15206 ire_t *ire;
15207
15208 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15209 ire = ipif->ipif_ire_local;
15210 ipif->ipif_ire_local = NULL;
15211 rw_exit(&ipst->ips_ill_g_lock);
15212 if (ire != NULL) {
15213 /*
15214 * Move count to ipif so we don't loose the count due to
15215 * a down/up dance.
15216 */
15217 atomic_add_32(&ipif->ipif_ib_pkt_count, ire->ire_ib_pkt_count);
15218
15219 ire_delete(ire);
15220 ire_refrele_notr(ire);
15221 }
15222 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15223 ire = ipif->ipif_ire_if;
15224 ipif->ipif_ire_if = NULL;
15225 rw_exit(&ipst->ips_ill_g_lock);
15226 if (ire != NULL) {
15227 ire_delete(ire);
15228 ire_refrele_notr(ire);
15229 }
15230
15231 /*
15232 * Delete the broadcast IREs.
15233 */
15234 if ((ipif->ipif_flags & IPIF_BROADCAST) &&
15235 !(ipif->ipif_flags & IPIF_NOXMIT))
15236 ipif_delete_bcast_ires(ipif);
15237 }
15238
15239 /*
15240 * Checks for availbility of a usable source address (if there is one) when the
15241 * destination ILL has the ill_usesrc_ifindex pointing to another ILL. Note
15242 * this selection is done regardless of the destination.
15243 */
15244 boolean_t
15245 ipif_zone_avail(uint_t ifindex, boolean_t isv6, zoneid_t zoneid,
15246 ip_stack_t *ipst)
15247 {
15248 ipif_t *ipif = NULL;
15249 ill_t *uill;
15250
15251 ASSERT(ifindex != 0);
15252
15253 uill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
15254 if (uill == NULL)
15255 return (B_FALSE);
15256
15257 mutex_enter(&uill->ill_lock);
15258 for (ipif = uill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15259 if (IPIF_IS_CONDEMNED(ipif))
15260 continue;
15261 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15262 continue;
15263 if (!(ipif->ipif_flags & IPIF_UP))
15264 continue;
15265 if (ipif->ipif_zoneid != zoneid)
15266 continue;
15267 if (isv6 ? IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) :
15268 ipif->ipif_lcl_addr == INADDR_ANY)
15269 continue;
15270 mutex_exit(&uill->ill_lock);
15271 ill_refrele(uill);
15272 return (B_TRUE);
15273 }
15274 mutex_exit(&uill->ill_lock);
15275 ill_refrele(uill);
15276 return (B_FALSE);
15277 }
15278
15279 /*
15280 * Find an ipif with a good local address on the ill+zoneid.
15281 */
15282 ipif_t *
15283 ipif_good_addr(ill_t *ill, zoneid_t zoneid)
15284 {
15285 ipif_t *ipif;
15286
15287 mutex_enter(&ill->ill_lock);
15288 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15289 if (IPIF_IS_CONDEMNED(ipif))
15290 continue;
15291 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15292 continue;
15293 if (!(ipif->ipif_flags & IPIF_UP))
15294 continue;
15295 if (ipif->ipif_zoneid != zoneid &&
15296 ipif->ipif_zoneid != ALL_ZONES && zoneid != ALL_ZONES)
15297 continue;
15298 if (ill->ill_isv6 ?
15299 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) :
15300 ipif->ipif_lcl_addr == INADDR_ANY)
15301 continue;
15302 ipif_refhold_locked(ipif);
15303 mutex_exit(&ill->ill_lock);
15304 return (ipif);
15305 }
15306 mutex_exit(&ill->ill_lock);
15307 return (NULL);
15308 }
15309
15310 /*
15311 * IP source address type, sorted from worst to best. For a given type,
15312 * always prefer IP addresses on the same subnet. All-zones addresses are
15313 * suboptimal because they pose problems with unlabeled destinations.
15314 */
15315 typedef enum {
15316 IPIF_NONE,
15317 IPIF_DIFFNET_DEPRECATED, /* deprecated and different subnet */
15318 IPIF_SAMENET_DEPRECATED, /* deprecated and same subnet */
15319 IPIF_DIFFNET_ALLZONES, /* allzones and different subnet */
15320 IPIF_SAMENET_ALLZONES, /* allzones and same subnet */
15321 IPIF_DIFFNET, /* normal and different subnet */
15322 IPIF_SAMENET, /* normal and same subnet */
15323 IPIF_LOCALADDR /* local loopback */
15324 } ipif_type_t;
15325
15326 /*
15327 * Pick the optimal ipif on `ill' for sending to destination `dst' from zone
15328 * `zoneid'. We rate usable ipifs from low -> high as per the ipif_type_t
15329 * enumeration, and return the highest-rated ipif. If there's a tie, we pick
15330 * the first one, unless IPMP is used in which case we round-robin among them;
15331 * see below for more.
15332 *
15333 * Returns NULL if there is no suitable source address for the ill.
15334 * This only occurs when there is no valid source address for the ill.
15335 */
15336 ipif_t *
15337 ipif_select_source_v4(ill_t *ill, ipaddr_t dst, zoneid_t zoneid,
15338 boolean_t allow_usesrc, boolean_t *notreadyp)
15339 {
15340 ill_t *usill = NULL;
15341 ill_t *ipmp_ill = NULL;
15342 ipif_t *start_ipif, *next_ipif, *ipif, *best_ipif;
15343 ipif_type_t type, best_type;
15344 tsol_tpc_t *src_rhtp, *dst_rhtp;
15345 ip_stack_t *ipst = ill->ill_ipst;
15346 boolean_t samenet;
15347
15348 if (ill->ill_usesrc_ifindex != 0 && allow_usesrc) {
15349 usill = ill_lookup_on_ifindex(ill->ill_usesrc_ifindex,
15350 B_FALSE, ipst);
15351 if (usill != NULL)
15352 ill = usill; /* Select source from usesrc ILL */
15353 else
15354 return (NULL);
15355 }
15356
15357 /*
15358 * Test addresses should never be used for source address selection,
15359 * so if we were passed one, switch to the IPMP meta-interface.
15360 */
15361 if (IS_UNDER_IPMP(ill)) {
15362 if ((ipmp_ill = ipmp_ill_hold_ipmp_ill(ill)) != NULL)
15363 ill = ipmp_ill; /* Select source from IPMP ill */
15364 else
15365 return (NULL);
15366 }
15367
15368 /*
15369 * If we're dealing with an unlabeled destination on a labeled system,
15370 * make sure that we ignore source addresses that are incompatible with
15371 * the destination's default label. That destination's default label
15372 * must dominate the minimum label on the source address.
15373 */
15374 dst_rhtp = NULL;
15375 if (is_system_labeled()) {
15376 dst_rhtp = find_tpc(&dst, IPV4_VERSION, B_FALSE);
15377 if (dst_rhtp == NULL)
15378 return (NULL);
15379 if (dst_rhtp->tpc_tp.host_type != UNLABELED) {
15380 TPC_RELE(dst_rhtp);
15381 dst_rhtp = NULL;
15382 }
15383 }
15384
15385 /*
15386 * Hold the ill_g_lock as reader. This makes sure that no ipif/ill
15387 * can be deleted. But an ipif/ill can get CONDEMNED any time.
15388 * After selecting the right ipif, under ill_lock make sure ipif is
15389 * not condemned, and increment refcnt. If ipif is CONDEMNED,
15390 * we retry. Inside the loop we still need to check for CONDEMNED,
15391 * but not under a lock.
15392 */
15393 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
15394 retry:
15395 /*
15396 * For source address selection, we treat the ipif list as circular
15397 * and continue until we get back to where we started. This allows
15398 * IPMP to vary source address selection (which improves inbound load
15399 * spreading) by caching its last ending point and starting from
15400 * there. NOTE: we don't have to worry about ill_src_ipif changing
15401 * ills since that can't happen on the IPMP ill.
15402 */
15403 start_ipif = ill->ill_ipif;
15404 if (IS_IPMP(ill) && ill->ill_src_ipif != NULL)
15405 start_ipif = ill->ill_src_ipif;
15406
15407 ipif = start_ipif;
15408 best_ipif = NULL;
15409 best_type = IPIF_NONE;
15410 do {
15411 if ((next_ipif = ipif->ipif_next) == NULL)
15412 next_ipif = ill->ill_ipif;
15413
15414 if (IPIF_IS_CONDEMNED(ipif))
15415 continue;
15416 /* Always skip NOLOCAL and ANYCAST interfaces */
15417 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15418 continue;
15419 /* Always skip NOACCEPT interfaces */
15420 if (ipif->ipif_ill->ill_flags & ILLF_NOACCEPT)
15421 continue;
15422 if (!(ipif->ipif_flags & IPIF_UP))
15423 continue;
15424
15425 if (!ipif->ipif_addr_ready) {
15426 if (notreadyp != NULL)
15427 *notreadyp = B_TRUE;
15428 continue;
15429 }
15430
15431 if (zoneid != ALL_ZONES &&
15432 ipif->ipif_zoneid != zoneid &&
15433 ipif->ipif_zoneid != ALL_ZONES)
15434 continue;
15435
15436 /*
15437 * Interfaces with 0.0.0.0 address are allowed to be UP, but
15438 * are not valid as source addresses.
15439 */
15440 if (ipif->ipif_lcl_addr == INADDR_ANY)
15441 continue;
15442
15443 /*
15444 * Check compatibility of local address for destination's
15445 * default label if we're on a labeled system. Incompatible
15446 * addresses can't be used at all.
15447 */
15448 if (dst_rhtp != NULL) {
15449 boolean_t incompat;
15450
15451 src_rhtp = find_tpc(&ipif->ipif_lcl_addr,
15452 IPV4_VERSION, B_FALSE);
15453 if (src_rhtp == NULL)
15454 continue;
15455 incompat = src_rhtp->tpc_tp.host_type != SUN_CIPSO ||
15456 src_rhtp->tpc_tp.tp_doi !=
15457 dst_rhtp->tpc_tp.tp_doi ||
15458 (!_blinrange(&dst_rhtp->tpc_tp.tp_def_label,
15459 &src_rhtp->tpc_tp.tp_sl_range_cipso) &&
15460 !blinlset(&dst_rhtp->tpc_tp.tp_def_label,
15461 src_rhtp->tpc_tp.tp_sl_set_cipso));
15462 TPC_RELE(src_rhtp);
15463 if (incompat)
15464 continue;
15465 }
15466
15467 samenet = ((ipif->ipif_net_mask & dst) == ipif->ipif_subnet);
15468
15469 if (ipif->ipif_lcl_addr == dst) {
15470 type = IPIF_LOCALADDR;
15471 } else if (ipif->ipif_flags & IPIF_DEPRECATED) {
15472 type = samenet ? IPIF_SAMENET_DEPRECATED :
15473 IPIF_DIFFNET_DEPRECATED;
15474 } else if (ipif->ipif_zoneid == ALL_ZONES) {
15475 type = samenet ? IPIF_SAMENET_ALLZONES :
15476 IPIF_DIFFNET_ALLZONES;
15477 } else {
15478 type = samenet ? IPIF_SAMENET : IPIF_DIFFNET;
15479 }
15480
15481 if (type > best_type) {
15482 best_type = type;
15483 best_ipif = ipif;
15484 if (best_type == IPIF_LOCALADDR)
15485 break; /* can't get better */
15486 }
15487 } while ((ipif = next_ipif) != start_ipif);
15488
15489 if ((ipif = best_ipif) != NULL) {
15490 mutex_enter(&ipif->ipif_ill->ill_lock);
15491 if (IPIF_IS_CONDEMNED(ipif)) {
15492 mutex_exit(&ipif->ipif_ill->ill_lock);
15493 goto retry;
15494 }
15495 ipif_refhold_locked(ipif);
15496
15497 /*
15498 * For IPMP, update the source ipif rotor to the next ipif,
15499 * provided we can look it up. (We must not use it if it's
15500 * IPIF_CONDEMNED since we may have grabbed ill_g_lock after
15501 * ipif_free() checked ill_src_ipif.)
15502 */
15503 if (IS_IPMP(ill) && ipif != NULL) {
15504 next_ipif = ipif->ipif_next;
15505 if (next_ipif != NULL && !IPIF_IS_CONDEMNED(next_ipif))
15506 ill->ill_src_ipif = next_ipif;
15507 else
15508 ill->ill_src_ipif = NULL;
15509 }
15510 mutex_exit(&ipif->ipif_ill->ill_lock);
15511 }
15512
15513 rw_exit(&ipst->ips_ill_g_lock);
15514 if (usill != NULL)
15515 ill_refrele(usill);
15516 if (ipmp_ill != NULL)
15517 ill_refrele(ipmp_ill);
15518 if (dst_rhtp != NULL)
15519 TPC_RELE(dst_rhtp);
15520
15521 #ifdef DEBUG
15522 if (ipif == NULL) {
15523 char buf1[INET6_ADDRSTRLEN];
15524
15525 ip1dbg(("ipif_select_source_v4(%s, %s) -> NULL\n",
15526 ill->ill_name,
15527 inet_ntop(AF_INET, &dst, buf1, sizeof (buf1))));
15528 } else {
15529 char buf1[INET6_ADDRSTRLEN];
15530 char buf2[INET6_ADDRSTRLEN];
15531
15532 ip1dbg(("ipif_select_source_v4(%s, %s) -> %s\n",
15533 ipif->ipif_ill->ill_name,
15534 inet_ntop(AF_INET, &dst, buf1, sizeof (buf1)),
15535 inet_ntop(AF_INET, &ipif->ipif_lcl_addr,
15536 buf2, sizeof (buf2))));
15537 }
15538 #endif /* DEBUG */
15539 return (ipif);
15540 }
15541
15542 /*
15543 * Pick a source address based on the destination ill and an optional setsrc
15544 * address.
15545 * The result is stored in srcp. If generation is set, then put the source
15546 * generation number there before we look for the source address (to avoid
15547 * missing changes in the set of source addresses.
15548 * If flagsp is set, then us it to pass back ipif_flags.
15549 *
15550 * If the caller wants to cache the returned source address and detect when
15551 * that might be stale, the caller should pass in a generation argument,
15552 * which the caller can later compare against ips_src_generation
15553 *
15554 * The precedence order for selecting an IPv4 source address is:
15555 * - RTF_SETSRC on the offlink ire always wins.
15556 * - If usrsrc is set, swap the ill to be the usesrc one.
15557 * - If IPMP is used on the ill, select a random address from the most
15558 * preferred ones below:
15559 * 1. If onlink destination, same subnet and not deprecated, not ALL_ZONES
15560 * 2. Not deprecated, not ALL_ZONES
15561 * 3. If onlink destination, same subnet and not deprecated, ALL_ZONES
15562 * 4. Not deprecated, ALL_ZONES
15563 * 5. If onlink destination, same subnet and deprecated
15564 * 6. Deprecated.
15565 *
15566 * We have lower preference for ALL_ZONES IP addresses,
15567 * as they pose problems with unlabeled destinations.
15568 *
15569 * Note that when multiple IP addresses match e.g., #1 we pick
15570 * the first one if IPMP is not in use. With IPMP we randomize.
15571 */
15572 int
15573 ip_select_source_v4(ill_t *ill, ipaddr_t setsrc, ipaddr_t dst,
15574 ipaddr_t multicast_ifaddr,
15575 zoneid_t zoneid, ip_stack_t *ipst, ipaddr_t *srcp,
15576 uint32_t *generation, uint64_t *flagsp)
15577 {
15578 ipif_t *ipif;
15579 boolean_t notready = B_FALSE; /* Set if !ipif_addr_ready found */
15580
15581 if (flagsp != NULL)
15582 *flagsp = 0;
15583
15584 /*
15585 * Need to grab the generation number before we check to
15586 * avoid a race with a change to the set of local addresses.
15587 * No lock needed since the thread which updates the set of local
15588 * addresses use ipif/ill locks and exit those (hence a store memory
15589 * barrier) before doing the atomic increase of ips_src_generation.
15590 */
15591 if (generation != NULL) {
15592 *generation = ipst->ips_src_generation;
15593 }
15594
15595 if (CLASSD(dst) && multicast_ifaddr != INADDR_ANY) {
15596 *srcp = multicast_ifaddr;
15597 return (0);
15598 }
15599
15600 /* Was RTF_SETSRC set on the first IRE in the recursive lookup? */
15601 if (setsrc != INADDR_ANY) {
15602 *srcp = setsrc;
15603 return (0);
15604 }
15605 ipif = ipif_select_source_v4(ill, dst, zoneid, B_TRUE, ¬ready);
15606 if (ipif == NULL) {
15607 if (notready)
15608 return (ENETDOWN);
15609 else
15610 return (EADDRNOTAVAIL);
15611 }
15612 *srcp = ipif->ipif_lcl_addr;
15613 if (flagsp != NULL)
15614 *flagsp = ipif->ipif_flags;
15615 ipif_refrele(ipif);
15616 return (0);
15617 }
15618
15619 /* ARGSUSED */
15620 int
15621 if_unitsel_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15622 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
15623 {
15624 /*
15625 * ill_phyint_reinit merged the v4 and v6 into a single
15626 * ipsq. We might not have been able to complete the
15627 * operation in ipif_set_values, if we could not become
15628 * exclusive. If so restart it here.
15629 */
15630 return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q));
15631 }
15632
15633 /*
15634 * Can operate on either a module or a driver queue.
15635 * Returns an error if not a module queue.
15636 */
15637 /* ARGSUSED */
15638 int
15639 if_unitsel(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15640 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
15641 {
15642 queue_t *q1 = q;
15643 char *cp;
15644 char interf_name[LIFNAMSIZ];
15645 uint_t ppa = *(uint_t *)mp->b_cont->b_cont->b_rptr;
15646
15647 if (q->q_next == NULL) {
15648 ip1dbg((
15649 "if_unitsel: IF_UNITSEL: no q_next\n"));
15650 return (EINVAL);
15651 }
15652
15653 if (((ill_t *)(q->q_ptr))->ill_name[0] != '\0')
15654 return (EALREADY);
15655
15656 do {
15657 q1 = q1->q_next;
15658 } while (q1->q_next);
15659 cp = q1->q_qinfo->qi_minfo->mi_idname;
15660 (void) sprintf(interf_name, "%s%d", cp, ppa);
15661
15662 /*
15663 * Here we are not going to delay the ioack until after
15664 * ACKs from DL_ATTACH_REQ/DL_BIND_REQ. So no need to save the
15665 * original ioctl message before sending the requests.
15666 */
15667 return (ipif_set_values(q, mp, interf_name, &ppa));
15668 }
15669
15670 /* ARGSUSED */
15671 int
15672 ip_sioctl_sifname(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15673 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
15674 {
15675 return (ENXIO);
15676 }
15677
15678 /*
15679 * Create any IRE_BROADCAST entries for `ipif', and store those entries in
15680 * `irep'. Returns a pointer to the next free `irep' entry
15681 * A mirror exists in ipif_delete_bcast_ires().
15682 *
15683 * The management of any "extra" or seemingly duplicate IRE_BROADCASTs is
15684 * done in ire_add.
15685 */
15686 static ire_t **
15687 ipif_create_bcast_ires(ipif_t *ipif, ire_t **irep)
15688 {
15689 ipaddr_t addr;
15690 ipaddr_t netmask = ip_net_mask(ipif->ipif_lcl_addr);
15691 ipaddr_t subnetmask = ipif->ipif_net_mask;
15692 ill_t *ill = ipif->ipif_ill;
15693 zoneid_t zoneid = ipif->ipif_zoneid;
15694
15695 ip1dbg(("ipif_create_bcast_ires: creating broadcast IREs\n"));
15696
15697 ASSERT(ipif->ipif_flags & IPIF_BROADCAST);
15698 ASSERT(!(ipif->ipif_flags & IPIF_NOXMIT));
15699
15700 if (ipif->ipif_lcl_addr == INADDR_ANY ||
15701 (ipif->ipif_flags & IPIF_NOLOCAL))
15702 netmask = htonl(IN_CLASSA_NET); /* fallback */
15703
15704 irep = ire_create_bcast(ill, 0, zoneid, irep);
15705 irep = ire_create_bcast(ill, INADDR_BROADCAST, zoneid, irep);
15706
15707 /*
15708 * For backward compatibility, we create net broadcast IREs based on
15709 * the old "IP address class system", since some old machines only
15710 * respond to these class derived net broadcast. However, we must not
15711 * create these net broadcast IREs if the subnetmask is shorter than
15712 * the IP address class based derived netmask. Otherwise, we may
15713 * create a net broadcast address which is the same as an IP address
15714 * on the subnet -- and then TCP will refuse to talk to that address.
15715 */
15716 if (netmask < subnetmask) {
15717 addr = netmask & ipif->ipif_subnet;
15718 irep = ire_create_bcast(ill, addr, zoneid, irep);
15719 irep = ire_create_bcast(ill, ~netmask | addr, zoneid, irep);
15720 }
15721
15722 /*
15723 * Don't create IRE_BROADCAST IREs for the interface if the subnetmask
15724 * is 0xFFFFFFFF, as an IRE_LOCAL for that interface is already
15725 * created. Creating these broadcast IREs will only create confusion
15726 * as `addr' will be the same as the IP address.
15727 */
15728 if (subnetmask != 0xFFFFFFFF) {
15729 addr = ipif->ipif_subnet;
15730 irep = ire_create_bcast(ill, addr, zoneid, irep);
15731 irep = ire_create_bcast(ill, ~subnetmask | addr, zoneid, irep);
15732 }
15733
15734 return (irep);
15735 }
15736
15737 /*
15738 * Mirror of ipif_create_bcast_ires()
15739 */
15740 static void
15741 ipif_delete_bcast_ires(ipif_t *ipif)
15742 {
15743 ipaddr_t addr;
15744 ipaddr_t netmask = ip_net_mask(ipif->ipif_lcl_addr);
15745 ipaddr_t subnetmask = ipif->ipif_net_mask;
15746 ill_t *ill = ipif->ipif_ill;
15747 zoneid_t zoneid = ipif->ipif_zoneid;
15748 ire_t *ire;
15749
15750 ASSERT(ipif->ipif_flags & IPIF_BROADCAST);
15751 ASSERT(!(ipif->ipif_flags & IPIF_NOXMIT));
15752
15753 if (ipif->ipif_lcl_addr == INADDR_ANY ||
15754 (ipif->ipif_flags & IPIF_NOLOCAL))
15755 netmask = htonl(IN_CLASSA_NET); /* fallback */
15756
15757 ire = ire_lookup_bcast(ill, 0, zoneid);
15758 ASSERT(ire != NULL);
15759 ire_delete(ire); ire_refrele(ire);
15760 ire = ire_lookup_bcast(ill, INADDR_BROADCAST, zoneid);
15761 ASSERT(ire != NULL);
15762 ire_delete(ire); ire_refrele(ire);
15763
15764 /*
15765 * For backward compatibility, we create net broadcast IREs based on
15766 * the old "IP address class system", since some old machines only
15767 * respond to these class derived net broadcast. However, we must not
15768 * create these net broadcast IREs if the subnetmask is shorter than
15769 * the IP address class based derived netmask. Otherwise, we may
15770 * create a net broadcast address which is the same as an IP address
15771 * on the subnet -- and then TCP will refuse to talk to that address.
15772 */
15773 if (netmask < subnetmask) {
15774 addr = netmask & ipif->ipif_subnet;
15775 ire = ire_lookup_bcast(ill, addr, zoneid);
15776 ASSERT(ire != NULL);
15777 ire_delete(ire); ire_refrele(ire);
15778 ire = ire_lookup_bcast(ill, ~netmask | addr, zoneid);
15779 ASSERT(ire != NULL);
15780 ire_delete(ire); ire_refrele(ire);
15781 }
15782
15783 /*
15784 * Don't create IRE_BROADCAST IREs for the interface if the subnetmask
15785 * is 0xFFFFFFFF, as an IRE_LOCAL for that interface is already
15786 * created. Creating these broadcast IREs will only create confusion
15787 * as `addr' will be the same as the IP address.
15788 */
15789 if (subnetmask != 0xFFFFFFFF) {
15790 addr = ipif->ipif_subnet;
15791 ire = ire_lookup_bcast(ill, addr, zoneid);
15792 ASSERT(ire != NULL);
15793 ire_delete(ire); ire_refrele(ire);
15794 ire = ire_lookup_bcast(ill, ~subnetmask | addr, zoneid);
15795 ASSERT(ire != NULL);
15796 ire_delete(ire); ire_refrele(ire);
15797 }
15798 }
15799
15800 /*
15801 * Extract both the flags (including IFF_CANTCHANGE) such as IFF_IPV*
15802 * from lifr_flags and the name from lifr_name.
15803 * Set IFF_IPV* and ill_isv6 prior to doing the lookup
15804 * since ipif_lookup_on_name uses the _isv6 flags when matching.
15805 * Returns EINPROGRESS when mp has been consumed by queueing it on
15806 * ipx_pending_mp and the ioctl will complete in ip_rput.
15807 *
15808 * Can operate on either a module or a driver queue.
15809 * Returns an error if not a module queue.
15810 */
15811 /* ARGSUSED */
15812 int
15813 ip_sioctl_slifname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15814 ip_ioctl_cmd_t *ipip, void *if_req)
15815 {
15816 ill_t *ill = q->q_ptr;
15817 phyint_t *phyi;
15818 ip_stack_t *ipst;
15819 struct lifreq *lifr = if_req;
15820 uint64_t new_flags;
15821
15822 ASSERT(ipif != NULL);
15823 ip1dbg(("ip_sioctl_slifname %s\n", lifr->lifr_name));
15824
15825 if (q->q_next == NULL) {
15826 ip1dbg(("if_sioctl_slifname: SIOCSLIFNAME: no q_next\n"));
15827 return (EINVAL);
15828 }
15829
15830 /*
15831 * If we are not writer on 'q' then this interface exists already
15832 * and previous lookups (ip_extract_lifreq()) found this ipif --
15833 * so return EALREADY.
15834 */
15835 if (ill != ipif->ipif_ill)
15836 return (EALREADY);
15837
15838 if (ill->ill_name[0] != '\0')
15839 return (EALREADY);
15840
15841 /*
15842 * If there's another ill already with the requested name, ensure
15843 * that it's of the same type. Otherwise, ill_phyint_reinit() will
15844 * fuse together two unrelated ills, which will cause chaos.
15845 */
15846 ipst = ill->ill_ipst;
15847 phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
15848 lifr->lifr_name, NULL);
15849 if (phyi != NULL) {
15850 ill_t *ill_mate = phyi->phyint_illv4;
15851
15852 if (ill_mate == NULL)
15853 ill_mate = phyi->phyint_illv6;
15854 ASSERT(ill_mate != NULL);
15855
15856 if (ill_mate->ill_media->ip_m_mac_type !=
15857 ill->ill_media->ip_m_mac_type) {
15858 ip1dbg(("if_sioctl_slifname: SIOCSLIFNAME: attempt to "
15859 "use the same ill name on differing media\n"));
15860 return (EINVAL);
15861 }
15862 }
15863
15864 /*
15865 * We start off as IFF_IPV4 in ipif_allocate and become
15866 * IFF_IPV4 or IFF_IPV6 here depending on lifr_flags value.
15867 * The only flags that we read from user space are IFF_IPV4,
15868 * IFF_IPV6, and IFF_BROADCAST.
15869 *
15870 * This ill has not been inserted into the global list.
15871 * So we are still single threaded and don't need any lock
15872 *
15873 * Saniy check the flags.
15874 */
15875
15876 if ((lifr->lifr_flags & IFF_BROADCAST) &&
15877 ((lifr->lifr_flags & IFF_IPV6) ||
15878 (!ill->ill_needs_attach && ill->ill_bcast_addr_length == 0))) {
15879 ip1dbg(("ip_sioctl_slifname: link not broadcast capable "
15880 "or IPv6 i.e., no broadcast \n"));
15881 return (EINVAL);
15882 }
15883
15884 new_flags =
15885 lifr->lifr_flags & (IFF_IPV6|IFF_IPV4|IFF_BROADCAST);
15886
15887 if ((new_flags ^ (IFF_IPV6|IFF_IPV4)) == 0) {
15888 ip1dbg(("ip_sioctl_slifname: flags must be exactly one of "
15889 "IFF_IPV4 or IFF_IPV6\n"));
15890 return (EINVAL);
15891 }
15892
15893 /*
15894 * We always start off as IPv4, so only need to check for IPv6.
15895 */
15896 if ((new_flags & IFF_IPV6) != 0) {
15897 ill->ill_flags |= ILLF_IPV6;
15898 ill->ill_flags &= ~ILLF_IPV4;
15899
15900 if (lifr->lifr_flags & IFF_NOLINKLOCAL)
15901 ill->ill_flags |= ILLF_NOLINKLOCAL;
15902 }
15903
15904 if ((new_flags & IFF_BROADCAST) != 0)
15905 ipif->ipif_flags |= IPIF_BROADCAST;
15906 else
15907 ipif->ipif_flags &= ~IPIF_BROADCAST;
15908
15909 /* We started off as V4. */
15910 if (ill->ill_flags & ILLF_IPV6) {
15911 ill->ill_phyint->phyint_illv6 = ill;
15912 ill->ill_phyint->phyint_illv4 = NULL;
15913 }
15914
15915 return (ipif_set_values(q, mp, lifr->lifr_name, &lifr->lifr_ppa));
15916 }
15917
15918 /* ARGSUSED */
15919 int
15920 ip_sioctl_slifname_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15921 ip_ioctl_cmd_t *ipip, void *if_req)
15922 {
15923 /*
15924 * ill_phyint_reinit merged the v4 and v6 into a single
15925 * ipsq. We might not have been able to complete the
15926 * slifname in ipif_set_values, if we could not become
15927 * exclusive. If so restart it here
15928 */
15929 return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q));
15930 }
15931
15932 /*
15933 * Return a pointer to the ipif which matches the index, IP version type and
15934 * zoneid.
15935 */
15936 ipif_t *
15937 ipif_lookup_on_ifindex(uint_t index, boolean_t isv6, zoneid_t zoneid,
15938 ip_stack_t *ipst)
15939 {
15940 ill_t *ill;
15941 ipif_t *ipif = NULL;
15942
15943 ill = ill_lookup_on_ifindex(index, isv6, ipst);
15944 if (ill != NULL) {
15945 mutex_enter(&ill->ill_lock);
15946 for (ipif = ill->ill_ipif; ipif != NULL;
15947 ipif = ipif->ipif_next) {
15948 if (!IPIF_IS_CONDEMNED(ipif) && (zoneid == ALL_ZONES ||
15949 zoneid == ipif->ipif_zoneid ||
15950 ipif->ipif_zoneid == ALL_ZONES)) {
15951 ipif_refhold_locked(ipif);
15952 break;
15953 }
15954 }
15955 mutex_exit(&ill->ill_lock);
15956 ill_refrele(ill);
15957 }
15958 return (ipif);
15959 }
15960
15961 /*
15962 * Change an existing physical interface's index. If the new index
15963 * is acceptable we update the index and the phyint_list_avl_by_index tree.
15964 * Finally, we update other systems which may have a dependence on the
15965 * index value.
15966 */
15967 /* ARGSUSED */
15968 int
15969 ip_sioctl_slifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15970 ip_ioctl_cmd_t *ipip, void *ifreq)
15971 {
15972 ill_t *ill;
15973 phyint_t *phyi;
15974 struct ifreq *ifr = (struct ifreq *)ifreq;
15975 struct lifreq *lifr = (struct lifreq *)ifreq;
15976 uint_t old_index, index;
15977 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
15978 avl_index_t where;
15979
15980 if (ipip->ipi_cmd_type == IF_CMD)
15981 index = ifr->ifr_index;
15982 else
15983 index = lifr->lifr_index;
15984
15985 /*
15986 * Only allow on physical interface. Also, index zero is illegal.
15987 */
15988 ill = ipif->ipif_ill;
15989 phyi = ill->ill_phyint;
15990 if (ipif->ipif_id != 0 || index == 0 || index > IF_INDEX_MAX) {
15991 return (EINVAL);
15992 }
15993
15994 /* If the index is not changing, no work to do */
15995 if (phyi->phyint_ifindex == index)
15996 return (0);
15997
15998 /*
15999 * Use phyint_exists() to determine if the new interface index
16000 * is already in use. If the index is unused then we need to
16001 * change the phyint's position in the phyint_list_avl_by_index
16002 * tree. If we do not do this, subsequent lookups (using the new
16003 * index value) will not find the phyint.
16004 */
16005 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
16006 if (phyint_exists(index, ipst)) {
16007 rw_exit(&ipst->ips_ill_g_lock);
16008 return (EEXIST);
16009 }
16010
16011 /*
16012 * The new index is unused. Set it in the phyint. However we must not
16013 * forget to trigger NE_IFINDEX_CHANGE event before the ifindex
16014 * changes. The event must be bound to old ifindex value.
16015 */
16016 ill_nic_event_dispatch(ill, 0, NE_IFINDEX_CHANGE,
16017 &index, sizeof (index));
16018
16019 old_index = phyi->phyint_ifindex;
16020 phyi->phyint_ifindex = index;
16021
16022 avl_remove(&ipst->ips_phyint_g_list->phyint_list_avl_by_index, phyi);
16023 (void) avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
16024 &index, &where);
16025 avl_insert(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
16026 phyi, where);
16027 rw_exit(&ipst->ips_ill_g_lock);
16028
16029 /* Update SCTP's ILL list */
16030 sctp_ill_reindex(ill, old_index);
16031
16032 /* Send the routing sockets message */
16033 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
16034 if (ILL_OTHER(ill))
16035 ip_rts_ifmsg(ILL_OTHER(ill)->ill_ipif, RTSQ_DEFAULT);
16036
16037 /* Perhaps ilgs should use this ill */
16038 update_conn_ill(NULL, ill->ill_ipst);
16039 return (0);
16040 }
16041
16042 /* ARGSUSED */
16043 int
16044 ip_sioctl_get_lifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16045 ip_ioctl_cmd_t *ipip, void *ifreq)
16046 {
16047 struct ifreq *ifr = (struct ifreq *)ifreq;
16048 struct lifreq *lifr = (struct lifreq *)ifreq;
16049
16050 ip1dbg(("ip_sioctl_get_lifindex(%s:%u %p)\n",
16051 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16052 /* Get the interface index */
16053 if (ipip->ipi_cmd_type == IF_CMD) {
16054 ifr->ifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex;
16055 } else {
16056 lifr->lifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex;
16057 }
16058 return (0);
16059 }
16060
16061 /* ARGSUSED */
16062 int
16063 ip_sioctl_get_lifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16064 ip_ioctl_cmd_t *ipip, void *ifreq)
16065 {
16066 struct lifreq *lifr = (struct lifreq *)ifreq;
16067
16068 ip1dbg(("ip_sioctl_get_lifzone(%s:%u %p)\n",
16069 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16070 /* Get the interface zone */
16071 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
16072 lifr->lifr_zoneid = ipif->ipif_zoneid;
16073 return (0);
16074 }
16075
16076 /*
16077 * Set the zoneid of an interface.
16078 */
16079 /* ARGSUSED */
16080 int
16081 ip_sioctl_slifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16082 ip_ioctl_cmd_t *ipip, void *ifreq)
16083 {
16084 struct lifreq *lifr = (struct lifreq *)ifreq;
16085 int err = 0;
16086 boolean_t need_up = B_FALSE;
16087 zone_t *zptr;
16088 zone_status_t status;
16089 zoneid_t zoneid;
16090
16091 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
16092 if ((zoneid = lifr->lifr_zoneid) == ALL_ZONES) {
16093 if (!is_system_labeled())
16094 return (ENOTSUP);
16095 zoneid = GLOBAL_ZONEID;
16096 }
16097
16098 /* cannot assign instance zero to a non-global zone */
16099 if (ipif->ipif_id == 0 && zoneid != GLOBAL_ZONEID)
16100 return (ENOTSUP);
16101
16102 /*
16103 * Cannot assign to a zone that doesn't exist or is shutting down. In
16104 * the event of a race with the zone shutdown processing, since IP
16105 * serializes this ioctl and SIOCGLIFCONF/SIOCLIFREMOVEIF, we know the
16106 * interface will be cleaned up even if the zone is shut down
16107 * immediately after the status check. If the interface can't be brought
16108 * down right away, and the zone is shut down before the restart
16109 * function is called, we resolve the possible races by rechecking the
16110 * zone status in the restart function.
16111 */
16112 if ((zptr = zone_find_by_id(zoneid)) == NULL)
16113 return (EINVAL);
16114 status = zone_status_get(zptr);
16115 zone_rele(zptr);
16116
16117 if (status != ZONE_IS_READY && status != ZONE_IS_RUNNING)
16118 return (EINVAL);
16119
16120 if (ipif->ipif_flags & IPIF_UP) {
16121 /*
16122 * If the interface is already marked up,
16123 * we call ipif_down which will take care
16124 * of ditching any IREs that have been set
16125 * up based on the old interface address.
16126 */
16127 err = ipif_logical_down(ipif, q, mp);
16128 if (err == EINPROGRESS)
16129 return (err);
16130 (void) ipif_down_tail(ipif);
16131 need_up = B_TRUE;
16132 }
16133
16134 err = ip_sioctl_slifzone_tail(ipif, lifr->lifr_zoneid, q, mp, need_up);
16135 return (err);
16136 }
16137
16138 static int
16139 ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid,
16140 queue_t *q, mblk_t *mp, boolean_t need_up)
16141 {
16142 int err = 0;
16143 ip_stack_t *ipst;
16144
16145 ip1dbg(("ip_sioctl_zoneid_tail(%s:%u %p)\n",
16146 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16147
16148 if (CONN_Q(q))
16149 ipst = CONNQ_TO_IPST(q);
16150 else
16151 ipst = ILLQ_TO_IPST(q);
16152
16153 /*
16154 * For exclusive stacks we don't allow a different zoneid than
16155 * global.
16156 */
16157 if (ipst->ips_netstack->netstack_stackid != GLOBAL_NETSTACKID &&
16158 zoneid != GLOBAL_ZONEID)
16159 return (EINVAL);
16160
16161 /* Set the new zone id. */
16162 ipif->ipif_zoneid = zoneid;
16163
16164 /* Update sctp list */
16165 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
16166
16167 /* The default multicast interface might have changed */
16168 ire_increment_multicast_generation(ipst, ipif->ipif_ill->ill_isv6);
16169
16170 if (need_up) {
16171 /*
16172 * Now bring the interface back up. If this
16173 * is the only IPIF for the ILL, ipif_up
16174 * will have to re-bind to the device, so
16175 * we may get back EINPROGRESS, in which
16176 * case, this IOCTL will get completed in
16177 * ip_rput_dlpi when we see the DL_BIND_ACK.
16178 */
16179 err = ipif_up(ipif, q, mp);
16180 }
16181 return (err);
16182 }
16183
16184 /* ARGSUSED */
16185 int
16186 ip_sioctl_slifzone_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16187 ip_ioctl_cmd_t *ipip, void *if_req)
16188 {
16189 struct lifreq *lifr = (struct lifreq *)if_req;
16190 zoneid_t zoneid;
16191 zone_t *zptr;
16192 zone_status_t status;
16193
16194 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
16195 if ((zoneid = lifr->lifr_zoneid) == ALL_ZONES)
16196 zoneid = GLOBAL_ZONEID;
16197
16198 ip1dbg(("ip_sioctl_slifzone_restart(%s:%u %p)\n",
16199 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16200
16201 /*
16202 * We recheck the zone status to resolve the following race condition:
16203 * 1) process sends SIOCSLIFZONE to put hme0:1 in zone "myzone";
16204 * 2) hme0:1 is up and can't be brought down right away;
16205 * ip_sioctl_slifzone() returns EINPROGRESS and the request is queued;
16206 * 3) zone "myzone" is halted; the zone status switches to
16207 * 'shutting_down' and the zones framework sends SIOCGLIFCONF to list
16208 * the interfaces to remove - hme0:1 is not returned because it's not
16209 * yet in "myzone", so it won't be removed;
16210 * 4) the restart function for SIOCSLIFZONE is called; without the
16211 * status check here, we would have hme0:1 in "myzone" after it's been
16212 * destroyed.
16213 * Note that if the status check fails, we need to bring the interface
16214 * back to its state prior to ip_sioctl_slifzone(), hence the call to
16215 * ipif_up_done[_v6]().
16216 */
16217 status = ZONE_IS_UNINITIALIZED;
16218 if ((zptr = zone_find_by_id(zoneid)) != NULL) {
16219 status = zone_status_get(zptr);
16220 zone_rele(zptr);
16221 }
16222 if (status != ZONE_IS_READY && status != ZONE_IS_RUNNING) {
16223 if (ipif->ipif_isv6) {
16224 (void) ipif_up_done_v6(ipif);
16225 } else {
16226 (void) ipif_up_done(ipif);
16227 }
16228 return (EINVAL);
16229 }
16230
16231 (void) ipif_down_tail(ipif);
16232
16233 return (ip_sioctl_slifzone_tail(ipif, lifr->lifr_zoneid, q, mp,
16234 B_TRUE));
16235 }
16236
16237 /*
16238 * Return the number of addresses on `ill' with one or more of the values
16239 * in `set' set and all of the values in `clear' clear.
16240 */
16241 static uint_t
16242 ill_flagaddr_cnt(const ill_t *ill, uint64_t set, uint64_t clear)
16243 {
16244 ipif_t *ipif;
16245 uint_t cnt = 0;
16246
16247 ASSERT(IAM_WRITER_ILL(ill));
16248
16249 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
16250 if ((ipif->ipif_flags & set) && !(ipif->ipif_flags & clear))
16251 cnt++;
16252
16253 return (cnt);
16254 }
16255
16256 /*
16257 * Return the number of migratable addresses on `ill' that are under
16258 * application control.
16259 */
16260 uint_t
16261 ill_appaddr_cnt(const ill_t *ill)
16262 {
16263 return (ill_flagaddr_cnt(ill, IPIF_DHCPRUNNING | IPIF_ADDRCONF,
16264 IPIF_NOFAILOVER));
16265 }
16266
16267 /*
16268 * Return the number of point-to-point addresses on `ill'.
16269 */
16270 uint_t
16271 ill_ptpaddr_cnt(const ill_t *ill)
16272 {
16273 return (ill_flagaddr_cnt(ill, IPIF_POINTOPOINT, 0));
16274 }
16275
16276 /* ARGSUSED */
16277 int
16278 ip_sioctl_get_lifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16279 ip_ioctl_cmd_t *ipip, void *ifreq)
16280 {
16281 struct lifreq *lifr = ifreq;
16282
16283 ASSERT(q->q_next == NULL);
16284 ASSERT(CONN_Q(q));
16285
16286 ip1dbg(("ip_sioctl_get_lifusesrc(%s:%u %p)\n",
16287 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16288 lifr->lifr_index = ipif->ipif_ill->ill_usesrc_ifindex;
16289 ip1dbg(("ip_sioctl_get_lifusesrc:lifr_index = %d\n", lifr->lifr_index));
16290
16291 return (0);
16292 }
16293
16294 /* Find the previous ILL in this usesrc group */
16295 static ill_t *
16296 ill_prev_usesrc(ill_t *uill)
16297 {
16298 ill_t *ill;
16299
16300 for (ill = uill->ill_usesrc_grp_next;
16301 ASSERT(ill), ill->ill_usesrc_grp_next != uill;
16302 ill = ill->ill_usesrc_grp_next)
16303 /* do nothing */;
16304 return (ill);
16305 }
16306
16307 /*
16308 * Release all members of the usesrc group. This routine is called
16309 * from ill_delete when the interface being unplumbed is the
16310 * group head.
16311 *
16312 * This silently clears the usesrc that ifconfig setup.
16313 * An alternative would be to keep that ifindex, and drop packets on the floor
16314 * since no source address can be selected.
16315 * Even if we keep the current semantics, don't need a lock and a linked list.
16316 * Can walk all the ills checking if they have a ill_usesrc_ifindex matching
16317 * the one that is being removed. Issue is how we return the usesrc users
16318 * (SIOCGLIFSRCOF). We want to be able to find the ills which have an
16319 * ill_usesrc_ifindex matching a target ill. We could also do that with an
16320 * ill walk, but the walker would need to insert in the ioctl response.
16321 */
16322 static void
16323 ill_disband_usesrc_group(ill_t *uill)
16324 {
16325 ill_t *next_ill, *tmp_ill;
16326 ip_stack_t *ipst = uill->ill_ipst;
16327
16328 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_usesrc_lock));
16329 next_ill = uill->ill_usesrc_grp_next;
16330
16331 do {
16332 ASSERT(next_ill != NULL);
16333 tmp_ill = next_ill->ill_usesrc_grp_next;
16334 ASSERT(tmp_ill != NULL);
16335 next_ill->ill_usesrc_grp_next = NULL;
16336 next_ill->ill_usesrc_ifindex = 0;
16337 next_ill = tmp_ill;
16338 } while (next_ill->ill_usesrc_ifindex != 0);
16339 uill->ill_usesrc_grp_next = NULL;
16340 }
16341
16342 /*
16343 * Remove the client usesrc ILL from the list and relink to a new list
16344 */
16345 int
16346 ill_relink_usesrc_ills(ill_t *ucill, ill_t *uill, uint_t ifindex)
16347 {
16348 ill_t *ill, *tmp_ill;
16349 ip_stack_t *ipst = ucill->ill_ipst;
16350
16351 ASSERT((ucill != NULL) && (ucill->ill_usesrc_grp_next != NULL) &&
16352 (uill != NULL) && RW_WRITE_HELD(&ipst->ips_ill_g_usesrc_lock));
16353
16354 /*
16355 * Check if the usesrc client ILL passed in is not already
16356 * in use as a usesrc ILL i.e one whose source address is
16357 * in use OR a usesrc ILL is not already in use as a usesrc
16358 * client ILL
16359 */
16360 if ((ucill->ill_usesrc_ifindex == 0) ||
16361 (uill->ill_usesrc_ifindex != 0)) {
16362 return (-1);
16363 }
16364
16365 ill = ill_prev_usesrc(ucill);
16366 ASSERT(ill->ill_usesrc_grp_next != NULL);
16367
16368 /* Remove from the current list */
16369 if (ill->ill_usesrc_grp_next->ill_usesrc_grp_next == ill) {
16370 /* Only two elements in the list */
16371 ASSERT(ill->ill_usesrc_ifindex == 0);
16372 ill->ill_usesrc_grp_next = NULL;
16373 } else {
16374 ill->ill_usesrc_grp_next = ucill->ill_usesrc_grp_next;
16375 }
16376
16377 if (ifindex == 0) {
16378 ucill->ill_usesrc_ifindex = 0;
16379 ucill->ill_usesrc_grp_next = NULL;
16380 return (0);
16381 }
16382
16383 ucill->ill_usesrc_ifindex = ifindex;
16384 tmp_ill = uill->ill_usesrc_grp_next;
16385 uill->ill_usesrc_grp_next = ucill;
16386 ucill->ill_usesrc_grp_next =
16387 (tmp_ill != NULL) ? tmp_ill : uill;
16388 return (0);
16389 }
16390
16391 /*
16392 * Set the ill_usesrc and ill_usesrc_head fields. See synchronization notes in
16393 * ip.c for locking details.
16394 */
16395 /* ARGSUSED */
16396 int
16397 ip_sioctl_slifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16398 ip_ioctl_cmd_t *ipip, void *ifreq)
16399 {
16400 struct lifreq *lifr = (struct lifreq *)ifreq;
16401 boolean_t isv6 = B_FALSE, reset_flg = B_FALSE;
16402 ill_t *usesrc_ill, *usesrc_cli_ill = ipif->ipif_ill;
16403 int err = 0, ret;
16404 uint_t ifindex;
16405 ipsq_t *ipsq = NULL;
16406 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
16407
16408 ASSERT(IAM_WRITER_IPIF(ipif));
16409 ASSERT(q->q_next == NULL);
16410 ASSERT(CONN_Q(q));
16411
16412 isv6 = (Q_TO_CONN(q))->conn_family == AF_INET6;
16413
16414 ifindex = lifr->lifr_index;
16415 if (ifindex == 0) {
16416 if (usesrc_cli_ill->ill_usesrc_grp_next == NULL) {
16417 /* non usesrc group interface, nothing to reset */
16418 return (0);
16419 }
16420 ifindex = usesrc_cli_ill->ill_usesrc_ifindex;
16421 /* valid reset request */
16422 reset_flg = B_TRUE;
16423 }
16424
16425 usesrc_ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
16426 if (usesrc_ill == NULL)
16427 return (ENXIO);
16428 if (usesrc_ill == ipif->ipif_ill) {
16429 ill_refrele(usesrc_ill);
16430 return (EINVAL);
16431 }
16432
16433 ipsq = ipsq_try_enter(NULL, usesrc_ill, q, mp, ip_process_ioctl,
16434 NEW_OP, B_TRUE);
16435 if (ipsq == NULL) {
16436 err = EINPROGRESS;
16437 /* Operation enqueued on the ipsq of the usesrc ILL */
16438 goto done;
16439 }
16440
16441 /* USESRC isn't currently supported with IPMP */
16442 if (IS_IPMP(usesrc_ill) || IS_UNDER_IPMP(usesrc_ill)) {
16443 err = ENOTSUP;
16444 goto done;
16445 }
16446
16447 /*
16448 * USESRC isn't compatible with the STANDBY flag. (STANDBY is only
16449 * used by IPMP underlying interfaces, but someone might think it's
16450 * more general and try to use it independently with VNI.)
16451 */
16452 if (usesrc_ill->ill_phyint->phyint_flags & PHYI_STANDBY) {
16453 err = ENOTSUP;
16454 goto done;
16455 }
16456
16457 /*
16458 * If the client is already in use as a usesrc_ill or a usesrc_ill is
16459 * already a client then return EINVAL
16460 */
16461 if (IS_USESRC_ILL(usesrc_cli_ill) || IS_USESRC_CLI_ILL(usesrc_ill)) {
16462 err = EINVAL;
16463 goto done;
16464 }
16465
16466 /*
16467 * If the ill_usesrc_ifindex field is already set to what it needs to
16468 * be then this is a duplicate operation.
16469 */
16470 if (!reset_flg && usesrc_cli_ill->ill_usesrc_ifindex == ifindex) {
16471 err = 0;
16472 goto done;
16473 }
16474
16475 ip1dbg(("ip_sioctl_slifusesrc: usesrc_cli_ill %s, usesrc_ill %s,"
16476 " v6 = %d", usesrc_cli_ill->ill_name, usesrc_ill->ill_name,
16477 usesrc_ill->ill_isv6));
16478
16479 /*
16480 * ill_g_usesrc_lock global lock protects the ill_usesrc_grp_next
16481 * and the ill_usesrc_ifindex fields
16482 */
16483 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_WRITER);
16484
16485 if (reset_flg) {
16486 ret = ill_relink_usesrc_ills(usesrc_cli_ill, usesrc_ill, 0);
16487 if (ret != 0) {
16488 err = EINVAL;
16489 }
16490 rw_exit(&ipst->ips_ill_g_usesrc_lock);
16491 goto done;
16492 }
16493
16494 /*
16495 * Four possibilities to consider:
16496 * 1. Both usesrc_ill and usesrc_cli_ill are not part of any usesrc grp
16497 * 2. usesrc_ill is part of a group but usesrc_cli_ill isn't
16498 * 3. usesrc_cli_ill is part of a group but usesrc_ill isn't
16499 * 4. Both are part of their respective usesrc groups
16500 */
16501 if ((usesrc_ill->ill_usesrc_grp_next == NULL) &&
16502 (usesrc_cli_ill->ill_usesrc_grp_next == NULL)) {
16503 ASSERT(usesrc_ill->ill_usesrc_ifindex == 0);
16504 usesrc_cli_ill->ill_usesrc_ifindex = ifindex;
16505 usesrc_ill->ill_usesrc_grp_next = usesrc_cli_ill;
16506 usesrc_cli_ill->ill_usesrc_grp_next = usesrc_ill;
16507 } else if ((usesrc_ill->ill_usesrc_grp_next != NULL) &&
16508 (usesrc_cli_ill->ill_usesrc_grp_next == NULL)) {
16509 usesrc_cli_ill->ill_usesrc_ifindex = ifindex;
16510 /* Insert at head of list */
16511 usesrc_cli_ill->ill_usesrc_grp_next =
16512 usesrc_ill->ill_usesrc_grp_next;
16513 usesrc_ill->ill_usesrc_grp_next = usesrc_cli_ill;
16514 } else {
16515 ret = ill_relink_usesrc_ills(usesrc_cli_ill, usesrc_ill,
16516 ifindex);
16517 if (ret != 0)
16518 err = EINVAL;
16519 }
16520 rw_exit(&ipst->ips_ill_g_usesrc_lock);
16521
16522 done:
16523 if (ipsq != NULL)
16524 ipsq_exit(ipsq);
16525 /* The refrele on the lifr_name ipif is done by ip_process_ioctl */
16526 ill_refrele(usesrc_ill);
16527
16528 /* Let conn_ixa caching know that source address selection changed */
16529 ip_update_source_selection(ipst);
16530
16531 return (err);
16532 }
16533
16534 /* ARGSUSED */
16535 int
16536 ip_sioctl_get_dadstate(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16537 ip_ioctl_cmd_t *ipip, void *if_req)
16538 {
16539 struct lifreq *lifr = (struct lifreq *)if_req;
16540 ill_t *ill = ipif->ipif_ill;
16541
16542 /*
16543 * Need a lock since IFF_UP can be set even when there are
16544 * references to the ipif.
16545 */
16546 mutex_enter(&ill->ill_lock);
16547 if ((ipif->ipif_flags & IPIF_UP) && ipif->ipif_addr_ready == 0)
16548 lifr->lifr_dadstate = DAD_IN_PROGRESS;
16549 else
16550 lifr->lifr_dadstate = DAD_DONE;
16551 mutex_exit(&ill->ill_lock);
16552 return (0);
16553 }
16554
16555 /*
16556 * comparison function used by avl.
16557 */
16558 static int
16559 ill_phyint_compare_index(const void *index_ptr, const void *phyip)
16560 {
16561
16562 uint_t index;
16563
16564 ASSERT(phyip != NULL && index_ptr != NULL);
16565
16566 index = *((uint_t *)index_ptr);
16567 /*
16568 * let the phyint with the lowest index be on top.
16569 */
16570 if (((phyint_t *)phyip)->phyint_ifindex < index)
16571 return (1);
16572 if (((phyint_t *)phyip)->phyint_ifindex > index)
16573 return (-1);
16574 return (0);
16575 }
16576
16577 /*
16578 * comparison function used by avl.
16579 */
16580 static int
16581 ill_phyint_compare_name(const void *name_ptr, const void *phyip)
16582 {
16583 ill_t *ill;
16584 int res = 0;
16585
16586 ASSERT(phyip != NULL && name_ptr != NULL);
16587
16588 if (((phyint_t *)phyip)->phyint_illv4)
16589 ill = ((phyint_t *)phyip)->phyint_illv4;
16590 else
16591 ill = ((phyint_t *)phyip)->phyint_illv6;
16592 ASSERT(ill != NULL);
16593
16594 res = strcmp(ill->ill_name, (char *)name_ptr);
16595 if (res > 0)
16596 return (1);
16597 else if (res < 0)
16598 return (-1);
16599 return (0);
16600 }
16601
16602 /*
16603 * This function is called on the unplumb path via ill_glist_delete() when
16604 * there are no ills left on the phyint and thus the phyint can be freed.
16605 */
16606 static void
16607 phyint_free(phyint_t *phyi)
16608 {
16609 ip_stack_t *ipst = PHYINT_TO_IPST(phyi);
16610
16611 ASSERT(phyi->phyint_illv4 == NULL && phyi->phyint_illv6 == NULL);
16612
16613 /*
16614 * If this phyint was an IPMP meta-interface, blow away the group.
16615 * This is safe to do because all of the illgrps have already been
16616 * removed by I_PUNLINK, and thus SIOCSLIFGROUPNAME cannot find us.
16617 * If we're cleaning up as a result of failed initialization,
16618 * phyint_grp may be NULL.
16619 */
16620 if ((phyi->phyint_flags & PHYI_IPMP) && (phyi->phyint_grp != NULL)) {
16621 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
16622 ipmp_grp_destroy(phyi->phyint_grp);
16623 phyi->phyint_grp = NULL;
16624 rw_exit(&ipst->ips_ipmp_lock);
16625 }
16626
16627 /*
16628 * If this interface was under IPMP, take it out of the group.
16629 */
16630 if (phyi->phyint_grp != NULL)
16631 ipmp_phyint_leave_grp(phyi);
16632
16633 /*
16634 * Delete the phyint and disassociate its ipsq. The ipsq itself
16635 * will be freed in ipsq_exit().
16636 */
16637 phyi->phyint_ipsq->ipsq_phyint = NULL;
16638 phyi->phyint_name[0] = '\0';
16639
16640 mi_free(phyi);
16641 }
16642
16643 /*
16644 * Attach the ill to the phyint structure which can be shared by both
16645 * IPv4 and IPv6 ill. ill_init allocates a phyint to just hold flags. This
16646 * function is called from ipif_set_values and ill_lookup_on_name (for
16647 * loopback) where we know the name of the ill. We lookup the ill and if
16648 * there is one present already with the name use that phyint. Otherwise
16649 * reuse the one allocated by ill_init.
16650 */
16651 static void
16652 ill_phyint_reinit(ill_t *ill)
16653 {
16654 boolean_t isv6 = ill->ill_isv6;
16655 phyint_t *phyi_old;
16656 phyint_t *phyi;
16657 avl_index_t where = 0;
16658 ill_t *ill_other = NULL;
16659 ip_stack_t *ipst = ill->ill_ipst;
16660
16661 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock));
16662
16663 phyi_old = ill->ill_phyint;
16664 ASSERT(isv6 || (phyi_old->phyint_illv4 == ill &&
16665 phyi_old->phyint_illv6 == NULL));
16666 ASSERT(!isv6 || (phyi_old->phyint_illv6 == ill &&
16667 phyi_old->phyint_illv4 == NULL));
16668 ASSERT(phyi_old->phyint_ifindex == 0);
16669
16670 /*
16671 * Now that our ill has a name, set it in the phyint.
16672 */
16673 (void) strlcpy(ill->ill_phyint->phyint_name, ill->ill_name, LIFNAMSIZ);
16674
16675 phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
16676 ill->ill_name, &where);
16677
16678 /*
16679 * 1. We grabbed the ill_g_lock before inserting this ill into
16680 * the global list of ills. So no other thread could have located
16681 * this ill and hence the ipsq of this ill is guaranteed to be empty.
16682 * 2. Now locate the other protocol instance of this ill.
16683 * 3. Now grab both ill locks in the right order, and the phyint lock of
16684 * the new ipsq. Holding ill locks + ill_g_lock ensures that the ipsq
16685 * of neither ill can change.
16686 * 4. Merge the phyint and thus the ipsq as well of this ill onto the
16687 * other ill.
16688 * 5. Release all locks.
16689 */
16690
16691 /*
16692 * Look for IPv4 if we are initializing IPv6 or look for IPv6 if
16693 * we are initializing IPv4.
16694 */
16695 if (phyi != NULL) {
16696 ill_other = (isv6) ? phyi->phyint_illv4 : phyi->phyint_illv6;
16697 ASSERT(ill_other->ill_phyint != NULL);
16698 ASSERT((isv6 && !ill_other->ill_isv6) ||
16699 (!isv6 && ill_other->ill_isv6));
16700 GRAB_ILL_LOCKS(ill, ill_other);
16701 /*
16702 * We are potentially throwing away phyint_flags which
16703 * could be different from the one that we obtain from
16704 * ill_other->ill_phyint. But it is okay as we are assuming
16705 * that the state maintained within IP is correct.
16706 */
16707 mutex_enter(&phyi->phyint_lock);
16708 if (isv6) {
16709 ASSERT(phyi->phyint_illv6 == NULL);
16710 phyi->phyint_illv6 = ill;
16711 } else {
16712 ASSERT(phyi->phyint_illv4 == NULL);
16713 phyi->phyint_illv4 = ill;
16714 }
16715
16716 /*
16717 * Delete the old phyint and make its ipsq eligible
16718 * to be freed in ipsq_exit().
16719 */
16720 phyi_old->phyint_illv4 = NULL;
16721 phyi_old->phyint_illv6 = NULL;
16722 phyi_old->phyint_ipsq->ipsq_phyint = NULL;
16723 phyi_old->phyint_name[0] = '\0';
16724 mi_free(phyi_old);
16725 } else {
16726 mutex_enter(&ill->ill_lock);
16727 /*
16728 * We don't need to acquire any lock, since
16729 * the ill is not yet visible globally and we
16730 * have not yet released the ill_g_lock.
16731 */
16732 phyi = phyi_old;
16733 mutex_enter(&phyi->phyint_lock);
16734 /* XXX We need a recovery strategy here. */
16735 if (!phyint_assign_ifindex(phyi, ipst))
16736 cmn_err(CE_PANIC, "phyint_assign_ifindex() failed");
16737
16738 avl_insert(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
16739 (void *)phyi, where);
16740
16741 (void) avl_find(&ipst->ips_phyint_g_list->
16742 phyint_list_avl_by_index,
16743 &phyi->phyint_ifindex, &where);
16744 avl_insert(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
16745 (void *)phyi, where);
16746 }
16747
16748 /*
16749 * Reassigning ill_phyint automatically reassigns the ipsq also.
16750 * pending mp is not affected because that is per ill basis.
16751 */
16752 ill->ill_phyint = phyi;
16753
16754 /*
16755 * Now that the phyint's ifindex has been assigned, complete the
16756 * remaining
16757 */
16758 ill->ill_ip_mib->ipIfStatsIfIndex = ill->ill_phyint->phyint_ifindex;
16759 if (ill->ill_isv6) {
16760 ill->ill_icmp6_mib->ipv6IfIcmpIfIndex =
16761 ill->ill_phyint->phyint_ifindex;
16762 ill->ill_mcast_type = ipst->ips_mld_max_version;
16763 } else {
16764 ill->ill_mcast_type = ipst->ips_igmp_max_version;
16765 }
16766
16767 /*
16768 * Generate an event within the hooks framework to indicate that
16769 * a new interface has just been added to IP. For this event to
16770 * be generated, the network interface must, at least, have an
16771 * ifindex assigned to it. (We don't generate the event for
16772 * loopback since ill_lookup_on_name() has its own NE_PLUMB event.)
16773 *
16774 * This needs to be run inside the ill_g_lock perimeter to ensure
16775 * that the ordering of delivered events to listeners matches the
16776 * order of them in the kernel.
16777 */
16778 if (!IS_LOOPBACK(ill)) {
16779 ill_nic_event_dispatch(ill, 0, NE_PLUMB, ill->ill_name,
16780 ill->ill_name_length);
16781 }
16782 RELEASE_ILL_LOCKS(ill, ill_other);
16783 mutex_exit(&phyi->phyint_lock);
16784 }
16785
16786 /*
16787 * Notify any downstream modules of the name of this interface.
16788 * An M_IOCTL is used even though we don't expect a successful reply.
16789 * Any reply message from the driver (presumably an M_IOCNAK) will
16790 * eventually get discarded somewhere upstream. The message format is
16791 * simply an SIOCSLIFNAME ioctl just as might be sent from ifconfig
16792 * to IP.
16793 */
16794 static void
16795 ip_ifname_notify(ill_t *ill, queue_t *q)
16796 {
16797 mblk_t *mp1, *mp2;
16798 struct iocblk *iocp;
16799 struct lifreq *lifr;
16800
16801 mp1 = mkiocb(SIOCSLIFNAME);
16802 if (mp1 == NULL)
16803 return;
16804 mp2 = allocb(sizeof (struct lifreq), BPRI_HI);
16805 if (mp2 == NULL) {
16806 freeb(mp1);
16807 return;
16808 }
16809
16810 mp1->b_cont = mp2;
16811 iocp = (struct iocblk *)mp1->b_rptr;
16812 iocp->ioc_count = sizeof (struct lifreq);
16813
16814 lifr = (struct lifreq *)mp2->b_rptr;
16815 mp2->b_wptr += sizeof (struct lifreq);
16816 bzero(lifr, sizeof (struct lifreq));
16817
16818 (void) strncpy(lifr->lifr_name, ill->ill_name, LIFNAMSIZ);
16819 lifr->lifr_ppa = ill->ill_ppa;
16820 lifr->lifr_flags = (ill->ill_flags & (ILLF_IPV4|ILLF_IPV6));
16821
16822 DTRACE_PROBE3(ill__dlpi, char *, "ip_ifname_notify",
16823 char *, "SIOCSLIFNAME", ill_t *, ill);
16824 putnext(q, mp1);
16825 }
16826
16827 static int
16828 ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
16829 {
16830 int err;
16831 ip_stack_t *ipst = ill->ill_ipst;
16832 phyint_t *phyi = ill->ill_phyint;
16833
16834 /*
16835 * Now that ill_name is set, the configuration for the IPMP
16836 * meta-interface can be performed.
16837 */
16838 if (IS_IPMP(ill)) {
16839 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
16840 /*
16841 * If phyi->phyint_grp is NULL, then this is the first IPMP
16842 * meta-interface and we need to create the IPMP group.
16843 */
16844 if (phyi->phyint_grp == NULL) {
16845 /*
16846 * If someone has renamed another IPMP group to have
16847 * the same name as our interface, bail.
16848 */
16849 if (ipmp_grp_lookup(ill->ill_name, ipst) != NULL) {
16850 rw_exit(&ipst->ips_ipmp_lock);
16851 return (EEXIST);
16852 }
16853 phyi->phyint_grp = ipmp_grp_create(ill->ill_name, phyi);
16854 if (phyi->phyint_grp == NULL) {
16855 rw_exit(&ipst->ips_ipmp_lock);
16856 return (ENOMEM);
16857 }
16858 }
16859 rw_exit(&ipst->ips_ipmp_lock);
16860 }
16861
16862 /* Tell downstream modules where they are. */
16863 ip_ifname_notify(ill, q);
16864
16865 /*
16866 * ill_dl_phys returns EINPROGRESS in the usual case.
16867 * Error cases are ENOMEM ...
16868 */
16869 err = ill_dl_phys(ill, ipif, mp, q);
16870
16871 if (ill->ill_isv6) {
16872 mutex_enter(&ipst->ips_mld_slowtimeout_lock);
16873 if (ipst->ips_mld_slowtimeout_id == 0) {
16874 ipst->ips_mld_slowtimeout_id = timeout(mld_slowtimo,
16875 (void *)ipst,
16876 MSEC_TO_TICK(MCAST_SLOWTIMO_INTERVAL));
16877 }
16878 mutex_exit(&ipst->ips_mld_slowtimeout_lock);
16879 } else {
16880 mutex_enter(&ipst->ips_igmp_slowtimeout_lock);
16881 if (ipst->ips_igmp_slowtimeout_id == 0) {
16882 ipst->ips_igmp_slowtimeout_id = timeout(igmp_slowtimo,
16883 (void *)ipst,
16884 MSEC_TO_TICK(MCAST_SLOWTIMO_INTERVAL));
16885 }
16886 mutex_exit(&ipst->ips_igmp_slowtimeout_lock);
16887 }
16888
16889 return (err);
16890 }
16891
16892 /*
16893 * Common routine for ppa and ifname setting. Should be called exclusive.
16894 *
16895 * Returns EINPROGRESS when mp has been consumed by queueing it on
16896 * ipx_pending_mp and the ioctl will complete in ip_rput.
16897 *
16898 * NOTE : If ppa is UNIT_MAX, we assign the next valid ppa and return
16899 * the new name and new ppa in lifr_name and lifr_ppa respectively.
16900 * For SLIFNAME, we pass these values back to the userland.
16901 */
16902 static int
16903 ipif_set_values(queue_t *q, mblk_t *mp, char *interf_name, uint_t *new_ppa_ptr)
16904 {
16905 ill_t *ill;
16906 ipif_t *ipif;
16907 ipsq_t *ipsq;
16908 char *ppa_ptr;
16909 char *old_ptr;
16910 char old_char;
16911 int error;
16912 ip_stack_t *ipst;
16913
16914 ip1dbg(("ipif_set_values: interface %s\n", interf_name));
16915 ASSERT(q->q_next != NULL);
16916 ASSERT(interf_name != NULL);
16917
16918 ill = (ill_t *)q->q_ptr;
16919 ipst = ill->ill_ipst;
16920
16921 ASSERT(ill->ill_ipst != NULL);
16922 ASSERT(ill->ill_name[0] == '\0');
16923 ASSERT(IAM_WRITER_ILL(ill));
16924 ASSERT((mi_strlen(interf_name) + 1) <= LIFNAMSIZ);
16925 ASSERT(ill->ill_ppa == UINT_MAX);
16926
16927 ill->ill_defend_start = ill->ill_defend_count = 0;
16928 /* The ppa is sent down by ifconfig or is chosen */
16929 if ((ppa_ptr = ill_get_ppa_ptr(interf_name)) == NULL) {
16930 return (EINVAL);
16931 }
16932
16933 /*
16934 * make sure ppa passed in is same as ppa in the name.
16935 * This check is not made when ppa == UINT_MAX in that case ppa
16936 * in the name could be anything. System will choose a ppa and
16937 * update new_ppa_ptr and inter_name to contain the choosen ppa.
16938 */
16939 if (*new_ppa_ptr != UINT_MAX) {
16940 /* stoi changes the pointer */
16941 old_ptr = ppa_ptr;
16942 /*
16943 * ifconfig passed in 0 for the ppa for DLPI 1 style devices
16944 * (they don't have an externally visible ppa). We assign one
16945 * here so that we can manage the interface. Note that in
16946 * the past this value was always 0 for DLPI 1 drivers.
16947 */
16948 if (*new_ppa_ptr == 0)
16949 *new_ppa_ptr = stoi(&old_ptr);
16950 else if (*new_ppa_ptr != (uint_t)stoi(&old_ptr))
16951 return (EINVAL);
16952 }
16953 /*
16954 * terminate string before ppa
16955 * save char at that location.
16956 */
16957 old_char = ppa_ptr[0];
16958 ppa_ptr[0] = '\0';
16959
16960 ill->ill_ppa = *new_ppa_ptr;
16961 /*
16962 * Finish as much work now as possible before calling ill_glist_insert
16963 * which makes the ill globally visible and also merges it with the
16964 * other protocol instance of this phyint. The remaining work is
16965 * done after entering the ipsq which may happen sometime later.
16966 */
16967 ipif = ill->ill_ipif;
16968
16969 /* We didn't do this when we allocated ipif in ip_ll_subnet_defaults */
16970 ipif_assign_seqid(ipif);
16971
16972 if (!(ill->ill_flags & (ILLF_IPV4|ILLF_IPV6)))
16973 ill->ill_flags |= ILLF_IPV4;
16974
16975 ASSERT(ipif->ipif_next == NULL); /* Only one ipif on ill */
16976 ASSERT((ipif->ipif_flags & IPIF_UP) == 0);
16977
16978 if (ill->ill_flags & ILLF_IPV6) {
16979
16980 ill->ill_isv6 = B_TRUE;
16981 ill_set_inputfn(ill);
16982 if (ill->ill_rq != NULL) {
16983 ill->ill_rq->q_qinfo = &iprinitv6;
16984 }
16985
16986 /* Keep the !IN6_IS_ADDR_V4MAPPED assertions happy */
16987 ipif->ipif_v6lcl_addr = ipv6_all_zeros;
16988 ipif->ipif_v6subnet = ipv6_all_zeros;
16989 ipif->ipif_v6net_mask = ipv6_all_zeros;
16990 ipif->ipif_v6brd_addr = ipv6_all_zeros;
16991 ipif->ipif_v6pp_dst_addr = ipv6_all_zeros;
16992 ill->ill_reachable_retrans_time = ND_RETRANS_TIMER;
16993 /*
16994 * point-to-point or Non-mulicast capable
16995 * interfaces won't do NUD unless explicitly
16996 * configured to do so.
16997 */
16998 if (ipif->ipif_flags & IPIF_POINTOPOINT ||
16999 !(ill->ill_flags & ILLF_MULTICAST)) {
17000 ill->ill_flags |= ILLF_NONUD;
17001 }
17002 /* Make sure IPv4 specific flag is not set on IPv6 if */
17003 if (ill->ill_flags & ILLF_NOARP) {
17004 /*
17005 * Note: xresolv interfaces will eventually need
17006 * NOARP set here as well, but that will require
17007 * those external resolvers to have some
17008 * knowledge of that flag and act appropriately.
17009 * Not to be changed at present.
17010 */
17011 ill->ill_flags &= ~ILLF_NOARP;
17012 }
17013 /*
17014 * Set the ILLF_ROUTER flag according to the global
17015 * IPv6 forwarding policy.
17016 */
17017 if (ipst->ips_ipv6_forwarding != 0)
17018 ill->ill_flags |= ILLF_ROUTER;
17019 } else if (ill->ill_flags & ILLF_IPV4) {
17020 ill->ill_isv6 = B_FALSE;
17021 ill_set_inputfn(ill);
17022 ill->ill_reachable_retrans_time = ARP_RETRANS_TIMER;
17023 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6lcl_addr);
17024 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6subnet);
17025 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6net_mask);
17026 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6brd_addr);
17027 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6pp_dst_addr);
17028 /*
17029 * Set the ILLF_ROUTER flag according to the global
17030 * IPv4 forwarding policy.
17031 */
17032 if (ipst->ips_ip_forwarding != 0)
17033 ill->ill_flags |= ILLF_ROUTER;
17034 }
17035
17036 ASSERT(ill->ill_phyint != NULL);
17037
17038 /*
17039 * The ipIfStatsIfindex and ipv6IfIcmpIfIndex assignments will
17040 * be completed in ill_glist_insert -> ill_phyint_reinit
17041 */
17042 if (!ill_allocate_mibs(ill))
17043 return (ENOMEM);
17044
17045 /*
17046 * Pick a default sap until we get the DL_INFO_ACK back from
17047 * the driver.
17048 */
17049 ill->ill_sap = (ill->ill_isv6) ? ill->ill_media->ip_m_ipv6sap :
17050 ill->ill_media->ip_m_ipv4sap;
17051
17052 ill->ill_ifname_pending = 1;
17053 ill->ill_ifname_pending_err = 0;
17054
17055 /*
17056 * When the first ipif comes up in ipif_up_done(), multicast groups
17057 * that were joined while this ill was not bound to the DLPI link need
17058 * to be recovered by ill_recover_multicast().
17059 */
17060 ill->ill_need_recover_multicast = 1;
17061
17062 ill_refhold(ill);
17063 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
17064 if ((error = ill_glist_insert(ill, interf_name,
17065 (ill->ill_flags & ILLF_IPV6) == ILLF_IPV6)) > 0) {
17066 ill->ill_ppa = UINT_MAX;
17067 ill->ill_name[0] = '\0';
17068 /*
17069 * undo null termination done above.
17070 */
17071 ppa_ptr[0] = old_char;
17072 rw_exit(&ipst->ips_ill_g_lock);
17073 ill_refrele(ill);
17074 return (error);
17075 }
17076
17077 ASSERT(ill->ill_name_length <= LIFNAMSIZ);
17078
17079 /*
17080 * When we return the buffer pointed to by interf_name should contain
17081 * the same name as in ill_name.
17082 * If a ppa was choosen by the system (ppa passed in was UINT_MAX)
17083 * the buffer pointed to by new_ppa_ptr would not contain the right ppa
17084 * so copy full name and update the ppa ptr.
17085 * When ppa passed in != UINT_MAX all values are correct just undo
17086 * null termination, this saves a bcopy.
17087 */
17088 if (*new_ppa_ptr == UINT_MAX) {
17089 bcopy(ill->ill_name, interf_name, ill->ill_name_length);
17090 *new_ppa_ptr = ill->ill_ppa;
17091 } else {
17092 /*
17093 * undo null termination done above.
17094 */
17095 ppa_ptr[0] = old_char;
17096 }
17097
17098 /* Let SCTP know about this ILL */
17099 sctp_update_ill(ill, SCTP_ILL_INSERT);
17100
17101 /*
17102 * ill_glist_insert has made the ill visible globally, and
17103 * ill_phyint_reinit could have changed the ipsq. At this point,
17104 * we need to hold the ips_ill_g_lock across the call to enter the
17105 * ipsq to enforce atomicity and prevent reordering. In the event
17106 * the ipsq has changed, and if the new ipsq is currently busy,
17107 * we need to make sure that this half-completed ioctl is ahead of
17108 * any subsequent ioctl. We achieve this by not dropping the
17109 * ips_ill_g_lock which prevents any ill lookup itself thereby
17110 * ensuring that new ioctls can't start.
17111 */
17112 ipsq = ipsq_try_enter_internal(ill, q, mp, ip_reprocess_ioctl, NEW_OP,
17113 B_TRUE);
17114
17115 rw_exit(&ipst->ips_ill_g_lock);
17116 ill_refrele(ill);
17117 if (ipsq == NULL)
17118 return (EINPROGRESS);
17119
17120 /*
17121 * If ill_phyint_reinit() changed our ipsq, then start on the new ipsq.
17122 */
17123 if (ipsq->ipsq_xop->ipx_current_ipif == NULL)
17124 ipsq_current_start(ipsq, ipif, SIOCSLIFNAME);
17125 else
17126 ASSERT(ipsq->ipsq_xop->ipx_current_ipif == ipif);
17127
17128 error = ipif_set_values_tail(ill, ipif, mp, q);
17129 ipsq_exit(ipsq);
17130 if (error != 0 && error != EINPROGRESS) {
17131 /*
17132 * restore previous values
17133 */
17134 ill->ill_isv6 = B_FALSE;
17135 ill_set_inputfn(ill);
17136 }
17137 return (error);
17138 }
17139
17140 void
17141 ipif_init(ip_stack_t *ipst)
17142 {
17143 int i;
17144
17145 for (i = 0; i < MAX_G_HEADS; i++) {
17146 ipst->ips_ill_g_heads[i].ill_g_list_head =
17147 (ill_if_t *)&ipst->ips_ill_g_heads[i];
17148 ipst->ips_ill_g_heads[i].ill_g_list_tail =
17149 (ill_if_t *)&ipst->ips_ill_g_heads[i];
17150 }
17151
17152 avl_create(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
17153 ill_phyint_compare_index,
17154 sizeof (phyint_t),
17155 offsetof(struct phyint, phyint_avl_by_index));
17156 avl_create(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
17157 ill_phyint_compare_name,
17158 sizeof (phyint_t),
17159 offsetof(struct phyint, phyint_avl_by_name));
17160 }
17161
17162 /*
17163 * Save enough information so that we can recreate the IRE if
17164 * the interface goes down and then up.
17165 */
17166 void
17167 ill_save_ire(ill_t *ill, ire_t *ire)
17168 {
17169 mblk_t *save_mp;
17170
17171 save_mp = allocb(sizeof (ifrt_t), BPRI_MED);
17172 if (save_mp != NULL) {
17173 ifrt_t *ifrt;
17174
17175 save_mp->b_wptr += sizeof (ifrt_t);
17176 ifrt = (ifrt_t *)save_mp->b_rptr;
17177 bzero(ifrt, sizeof (ifrt_t));
17178 ifrt->ifrt_type = ire->ire_type;
17179 if (ire->ire_ipversion == IPV4_VERSION) {
17180 ASSERT(!ill->ill_isv6);
17181 ifrt->ifrt_addr = ire->ire_addr;
17182 ifrt->ifrt_gateway_addr = ire->ire_gateway_addr;
17183 ifrt->ifrt_setsrc_addr = ire->ire_setsrc_addr;
17184 ifrt->ifrt_mask = ire->ire_mask;
17185 } else {
17186 ASSERT(ill->ill_isv6);
17187 ifrt->ifrt_v6addr = ire->ire_addr_v6;
17188 /* ire_gateway_addr_v6 can change due to RTM_CHANGE */
17189 mutex_enter(&ire->ire_lock);
17190 ifrt->ifrt_v6gateway_addr = ire->ire_gateway_addr_v6;
17191 mutex_exit(&ire->ire_lock);
17192 ifrt->ifrt_v6setsrc_addr = ire->ire_setsrc_addr_v6;
17193 ifrt->ifrt_v6mask = ire->ire_mask_v6;
17194 }
17195 ifrt->ifrt_flags = ire->ire_flags;
17196 ifrt->ifrt_zoneid = ire->ire_zoneid;
17197 mutex_enter(&ill->ill_saved_ire_lock);
17198 save_mp->b_cont = ill->ill_saved_ire_mp;
17199 ill->ill_saved_ire_mp = save_mp;
17200 ill->ill_saved_ire_cnt++;
17201 mutex_exit(&ill->ill_saved_ire_lock);
17202 }
17203 }
17204
17205 /*
17206 * Remove one entry from ill_saved_ire_mp.
17207 */
17208 void
17209 ill_remove_saved_ire(ill_t *ill, ire_t *ire)
17210 {
17211 mblk_t **mpp;
17212 mblk_t *mp;
17213 ifrt_t *ifrt;
17214
17215 /* Remove from ill_saved_ire_mp list if it is there */
17216 mutex_enter(&ill->ill_saved_ire_lock);
17217 for (mpp = &ill->ill_saved_ire_mp; *mpp != NULL;
17218 mpp = &(*mpp)->b_cont) {
17219 in6_addr_t gw_addr_v6;
17220
17221 /*
17222 * On a given ill, the tuple of address, gateway, mask,
17223 * ire_type, and zoneid is unique for each saved IRE.
17224 */
17225 mp = *mpp;
17226 ifrt = (ifrt_t *)mp->b_rptr;
17227 /* ire_gateway_addr_v6 can change - need lock */
17228 mutex_enter(&ire->ire_lock);
17229 gw_addr_v6 = ire->ire_gateway_addr_v6;
17230 mutex_exit(&ire->ire_lock);
17231
17232 if (ifrt->ifrt_zoneid != ire->ire_zoneid ||
17233 ifrt->ifrt_type != ire->ire_type)
17234 continue;
17235
17236 if (ill->ill_isv6 ?
17237 (IN6_ARE_ADDR_EQUAL(&ifrt->ifrt_v6addr,
17238 &ire->ire_addr_v6) &&
17239 IN6_ARE_ADDR_EQUAL(&ifrt->ifrt_v6gateway_addr,
17240 &gw_addr_v6) &&
17241 IN6_ARE_ADDR_EQUAL(&ifrt->ifrt_v6mask,
17242 &ire->ire_mask_v6)) :
17243 (ifrt->ifrt_addr == ire->ire_addr &&
17244 ifrt->ifrt_gateway_addr == ire->ire_gateway_addr &&
17245 ifrt->ifrt_mask == ire->ire_mask)) {
17246 *mpp = mp->b_cont;
17247 ill->ill_saved_ire_cnt--;
17248 freeb(mp);
17249 break;
17250 }
17251 }
17252 mutex_exit(&ill->ill_saved_ire_lock);
17253 }
17254
17255 /*
17256 * IP multirouting broadcast routes handling
17257 * Append CGTP broadcast IREs to regular ones created
17258 * at ifconfig time.
17259 * The usage is a route add <cgtp_bc> <nic_bc> -multirt i.e., both
17260 * the destination and the gateway are broadcast addresses.
17261 * The caller has verified that the destination is an IRE_BROADCAST and that
17262 * RTF_MULTIRT was set. Here if the gateway is a broadcast address, then
17263 * we create a MULTIRT IRE_BROADCAST.
17264 * Note that the IRE_HOST created by ire_rt_add doesn't get found by anything
17265 * since the IRE_BROADCAST takes precedence; ire_add_v4 does head insertion.
17266 */
17267 static void
17268 ip_cgtp_bcast_add(ire_t *ire, ip_stack_t *ipst)
17269 {
17270 ire_t *ire_prim;
17271
17272 ASSERT(ire != NULL);
17273
17274 ire_prim = ire_ftable_lookup_v4(ire->ire_gateway_addr, 0, 0,
17275 IRE_BROADCAST, NULL, ALL_ZONES, NULL, MATCH_IRE_TYPE, 0, ipst,
17276 NULL);
17277 if (ire_prim != NULL) {
17278 /*
17279 * We are in the special case of broadcasts for
17280 * CGTP. We add an IRE_BROADCAST that holds
17281 * the RTF_MULTIRT flag, the destination
17282 * address and the low level
17283 * info of ire_prim. In other words, CGTP
17284 * broadcast is added to the redundant ipif.
17285 */
17286 ill_t *ill_prim;
17287 ire_t *bcast_ire;
17288
17289 ill_prim = ire_prim->ire_ill;
17290
17291 ip2dbg(("ip_cgtp_filter_bcast_add: ire_prim %p, ill_prim %p\n",
17292 (void *)ire_prim, (void *)ill_prim));
17293
17294 bcast_ire = ire_create(
17295 (uchar_t *)&ire->ire_addr,
17296 (uchar_t *)&ip_g_all_ones,
17297 (uchar_t *)&ire->ire_gateway_addr,
17298 IRE_BROADCAST,
17299 ill_prim,
17300 GLOBAL_ZONEID, /* CGTP is only for the global zone */
17301 ire->ire_flags | RTF_KERNEL,
17302 NULL,
17303 ipst);
17304
17305 /*
17306 * Here we assume that ire_add does head insertion so that
17307 * the added IRE_BROADCAST comes before the existing IRE_HOST.
17308 */
17309 if (bcast_ire != NULL) {
17310 if (ire->ire_flags & RTF_SETSRC) {
17311 bcast_ire->ire_setsrc_addr =
17312 ire->ire_setsrc_addr;
17313 }
17314 bcast_ire = ire_add(bcast_ire);
17315 if (bcast_ire != NULL) {
17316 ip2dbg(("ip_cgtp_filter_bcast_add: "
17317 "added bcast_ire %p\n",
17318 (void *)bcast_ire));
17319
17320 ill_save_ire(ill_prim, bcast_ire);
17321 ire_refrele(bcast_ire);
17322 }
17323 }
17324 ire_refrele(ire_prim);
17325 }
17326 }
17327
17328 /*
17329 * IP multirouting broadcast routes handling
17330 * Remove the broadcast ire.
17331 * The usage is a route delete <cgtp_bc> <nic_bc> -multirt i.e., both
17332 * the destination and the gateway are broadcast addresses.
17333 * The caller has only verified that RTF_MULTIRT was set. We check
17334 * that the destination is broadcast and that the gateway is a broadcast
17335 * address, and if so delete the IRE added by ip_cgtp_bcast_add().
17336 */
17337 static void
17338 ip_cgtp_bcast_delete(ire_t *ire, ip_stack_t *ipst)
17339 {
17340 ASSERT(ire != NULL);
17341
17342 if (ip_type_v4(ire->ire_addr, ipst) == IRE_BROADCAST) {
17343 ire_t *ire_prim;
17344
17345 ire_prim = ire_ftable_lookup_v4(ire->ire_gateway_addr, 0, 0,
17346 IRE_BROADCAST, NULL, ALL_ZONES, NULL, MATCH_IRE_TYPE, 0,
17347 ipst, NULL);
17348 if (ire_prim != NULL) {
17349 ill_t *ill_prim;
17350 ire_t *bcast_ire;
17351
17352 ill_prim = ire_prim->ire_ill;
17353
17354 ip2dbg(("ip_cgtp_filter_bcast_delete: "
17355 "ire_prim %p, ill_prim %p\n",
17356 (void *)ire_prim, (void *)ill_prim));
17357
17358 bcast_ire = ire_ftable_lookup_v4(ire->ire_addr, 0,
17359 ire->ire_gateway_addr, IRE_BROADCAST,
17360 ill_prim, ALL_ZONES, NULL,
17361 MATCH_IRE_TYPE | MATCH_IRE_GW | MATCH_IRE_ILL |
17362 MATCH_IRE_MASK, 0, ipst, NULL);
17363
17364 if (bcast_ire != NULL) {
17365 ip2dbg(("ip_cgtp_filter_bcast_delete: "
17366 "looked up bcast_ire %p\n",
17367 (void *)bcast_ire));
17368 ill_remove_saved_ire(bcast_ire->ire_ill,
17369 bcast_ire);
17370 ire_delete(bcast_ire);
17371 ire_refrele(bcast_ire);
17372 }
17373 ire_refrele(ire_prim);
17374 }
17375 }
17376 }
17377
17378 /*
17379 * Derive an interface id from the link layer address.
17380 * Knows about IEEE 802 and IEEE EUI-64 mappings.
17381 */
17382 static void
17383 ip_ether_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17384 {
17385 char *addr;
17386
17387 /*
17388 * Note that some IPv6 interfaces get plumbed over links that claim to
17389 * be DL_ETHER, but don't actually have Ethernet MAC addresses (e.g.
17390 * PPP links). The ETHERADDRL check here ensures that we only set the
17391 * interface ID on IPv6 interfaces above links that actually have real
17392 * Ethernet addresses.
17393 */
17394 if (ill->ill_phys_addr_length == ETHERADDRL) {
17395 /* Form EUI-64 like address */
17396 addr = (char *)&v6addr->s6_addr32[2];
17397 bcopy(ill->ill_phys_addr, addr, 3);
17398 addr[0] ^= 0x2; /* Toggle Universal/Local bit */
17399 addr[3] = (char)0xff;
17400 addr[4] = (char)0xfe;
17401 bcopy(ill->ill_phys_addr + 3, addr + 5, 3);
17402 }
17403 }
17404
17405 /* ARGSUSED */
17406 static void
17407 ip_nodef_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17408 {
17409 }
17410
17411 typedef struct ipmp_ifcookie {
17412 uint32_t ic_hostid;
17413 char ic_ifname[LIFNAMSIZ];
17414 char ic_zonename[ZONENAME_MAX];
17415 } ipmp_ifcookie_t;
17416
17417 /*
17418 * Construct a pseudo-random interface ID for the IPMP interface that's both
17419 * predictable and (almost) guaranteed to be unique.
17420 */
17421 static void
17422 ip_ipmp_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17423 {
17424 zone_t *zp;
17425 uint8_t *addr;
17426 uchar_t hash[16];
17427 ulong_t hostid;
17428 MD5_CTX ctx;
17429 ipmp_ifcookie_t ic = { 0 };
17430
17431 ASSERT(IS_IPMP(ill));
17432
17433 (void) ddi_strtoul(hw_serial, NULL, 10, &hostid);
17434 ic.ic_hostid = htonl((uint32_t)hostid);
17435
17436 (void) strlcpy(ic.ic_ifname, ill->ill_name, LIFNAMSIZ);
17437
17438 if ((zp = zone_find_by_id(ill->ill_zoneid)) != NULL) {
17439 (void) strlcpy(ic.ic_zonename, zp->zone_name, ZONENAME_MAX);
17440 zone_rele(zp);
17441 }
17442
17443 MD5Init(&ctx);
17444 MD5Update(&ctx, &ic, sizeof (ic));
17445 MD5Final(hash, &ctx);
17446
17447 /*
17448 * Map the hash to an interface ID per the basic approach in RFC3041.
17449 */
17450 addr = &v6addr->s6_addr8[8];
17451 bcopy(hash + 8, addr, sizeof (uint64_t));
17452 addr[0] &= ~0x2; /* set local bit */
17453 }
17454
17455 /*
17456 * Map the multicast in6_addr_t in m_ip6addr to the physaddr for ethernet.
17457 */
17458 static void
17459 ip_ether_v6_mapping(ill_t *ill, uchar_t *m_ip6addr, uchar_t *m_physaddr)
17460 {
17461 phyint_t *phyi = ill->ill_phyint;
17462
17463 /*
17464 * Check PHYI_MULTI_BCAST and length of physical
17465 * address to determine if we use the mapping or the
17466 * broadcast address.
17467 */
17468 if ((phyi->phyint_flags & PHYI_MULTI_BCAST) != 0 ||
17469 ill->ill_phys_addr_length != ETHERADDRL) {
17470 ip_mbcast_mapping(ill, m_ip6addr, m_physaddr);
17471 return;
17472 }
17473 m_physaddr[0] = 0x33;
17474 m_physaddr[1] = 0x33;
17475 m_physaddr[2] = m_ip6addr[12];
17476 m_physaddr[3] = m_ip6addr[13];
17477 m_physaddr[4] = m_ip6addr[14];
17478 m_physaddr[5] = m_ip6addr[15];
17479 }
17480
17481 /*
17482 * Map the multicast ipaddr_t in m_ipaddr to the physaddr for ethernet.
17483 */
17484 static void
17485 ip_ether_v4_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17486 {
17487 phyint_t *phyi = ill->ill_phyint;
17488
17489 /*
17490 * Check PHYI_MULTI_BCAST and length of physical
17491 * address to determine if we use the mapping or the
17492 * broadcast address.
17493 */
17494 if ((phyi->phyint_flags & PHYI_MULTI_BCAST) != 0 ||
17495 ill->ill_phys_addr_length != ETHERADDRL) {
17496 ip_mbcast_mapping(ill, m_ipaddr, m_physaddr);
17497 return;
17498 }
17499 m_physaddr[0] = 0x01;
17500 m_physaddr[1] = 0x00;
17501 m_physaddr[2] = 0x5e;
17502 m_physaddr[3] = m_ipaddr[1] & 0x7f;
17503 m_physaddr[4] = m_ipaddr[2];
17504 m_physaddr[5] = m_ipaddr[3];
17505 }
17506
17507 /* ARGSUSED */
17508 static void
17509 ip_mbcast_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17510 {
17511 /*
17512 * for the MULTI_BCAST case and other cases when we want to
17513 * use the link-layer broadcast address for multicast.
17514 */
17515 uint8_t *bphys_addr;
17516 dl_unitdata_req_t *dlur;
17517
17518 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17519 if (ill->ill_sap_length < 0) {
17520 bphys_addr = (uchar_t *)dlur +
17521 dlur->dl_dest_addr_offset;
17522 } else {
17523 bphys_addr = (uchar_t *)dlur +
17524 dlur->dl_dest_addr_offset + ill->ill_sap_length;
17525 }
17526
17527 bcopy(bphys_addr, m_physaddr, ill->ill_phys_addr_length);
17528 }
17529
17530 /*
17531 * Derive IPoIB interface id from the link layer address.
17532 */
17533 static void
17534 ip_ib_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17535 {
17536 char *addr;
17537
17538 ASSERT(ill->ill_phys_addr_length == 20);
17539 addr = (char *)&v6addr->s6_addr32[2];
17540 bcopy(ill->ill_phys_addr + 12, addr, 8);
17541 /*
17542 * In IBA 1.1 timeframe, some vendors erroneously set the u/l bit
17543 * in the globally assigned EUI-64 GUID to 1, in violation of IEEE
17544 * rules. In these cases, the IBA considers these GUIDs to be in
17545 * "Modified EUI-64" format, and thus toggling the u/l bit is not
17546 * required; vendors are required not to assign global EUI-64's
17547 * that differ only in u/l bit values, thus guaranteeing uniqueness
17548 * of the interface identifier. Whether the GUID is in modified
17549 * or proper EUI-64 format, the ipv6 identifier must have the u/l
17550 * bit set to 1.
17551 */
17552 addr[0] |= 2; /* Set Universal/Local bit to 1 */
17553 }
17554
17555 /*
17556 * Map the multicast ipaddr_t in m_ipaddr to the physaddr for InfiniBand.
17557 * Note on mapping from multicast IP addresses to IPoIB multicast link
17558 * addresses. IPoIB multicast link addresses are based on IBA link addresses.
17559 * The format of an IPoIB multicast address is:
17560 *
17561 * 4 byte QPN Scope Sign. Pkey
17562 * +--------------------------------------------+
17563 * | 00FFFFFF | FF | 1X | X01B | Pkey | GroupID |
17564 * +--------------------------------------------+
17565 *
17566 * The Scope and Pkey components are properties of the IBA port and
17567 * network interface. They can be ascertained from the broadcast address.
17568 * The Sign. part is the signature, and is 401B for IPv4 and 601B for IPv6.
17569 */
17570 static void
17571 ip_ib_v4_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17572 {
17573 static uint8_t ipv4_g_phys_ibmulti_addr[] = { 0x00, 0xff, 0xff, 0xff,
17574 0xff, 0x10, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00,
17575 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
17576 uint8_t *bphys_addr;
17577 dl_unitdata_req_t *dlur;
17578
17579 bcopy(ipv4_g_phys_ibmulti_addr, m_physaddr, ill->ill_phys_addr_length);
17580
17581 /*
17582 * RFC 4391: IPv4 MGID is 28-bit long.
17583 */
17584 m_physaddr[16] = m_ipaddr[0] & 0x0f;
17585 m_physaddr[17] = m_ipaddr[1];
17586 m_physaddr[18] = m_ipaddr[2];
17587 m_physaddr[19] = m_ipaddr[3];
17588
17589
17590 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17591 if (ill->ill_sap_length < 0) {
17592 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset;
17593 } else {
17594 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset +
17595 ill->ill_sap_length;
17596 }
17597 /*
17598 * Now fill in the IBA scope/Pkey values from the broadcast address.
17599 */
17600 m_physaddr[5] = bphys_addr[5];
17601 m_physaddr[8] = bphys_addr[8];
17602 m_physaddr[9] = bphys_addr[9];
17603 }
17604
17605 static void
17606 ip_ib_v6_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17607 {
17608 static uint8_t ipv4_g_phys_ibmulti_addr[] = { 0x00, 0xff, 0xff, 0xff,
17609 0xff, 0x10, 0x60, 0x1b, 0x00, 0x00, 0x00, 0x00,
17610 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
17611 uint8_t *bphys_addr;
17612 dl_unitdata_req_t *dlur;
17613
17614 bcopy(ipv4_g_phys_ibmulti_addr, m_physaddr, ill->ill_phys_addr_length);
17615
17616 /*
17617 * RFC 4391: IPv4 MGID is 80-bit long.
17618 */
17619 bcopy(&m_ipaddr[6], &m_physaddr[10], 10);
17620
17621 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17622 if (ill->ill_sap_length < 0) {
17623 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset;
17624 } else {
17625 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset +
17626 ill->ill_sap_length;
17627 }
17628 /*
17629 * Now fill in the IBA scope/Pkey values from the broadcast address.
17630 */
17631 m_physaddr[5] = bphys_addr[5];
17632 m_physaddr[8] = bphys_addr[8];
17633 m_physaddr[9] = bphys_addr[9];
17634 }
17635
17636 /*
17637 * Derive IPv6 interface id from an IPv4 link-layer address (e.g. from an IPv4
17638 * tunnel). The IPv4 address simply get placed in the lower 4 bytes of the
17639 * IPv6 interface id. This is a suggested mechanism described in section 3.7
17640 * of RFC4213.
17641 */
17642 static void
17643 ip_ipv4_genv6intfid(ill_t *ill, uint8_t *physaddr, in6_addr_t *v6addr)
17644 {
17645 ASSERT(ill->ill_phys_addr_length == sizeof (ipaddr_t));
17646 v6addr->s6_addr32[2] = 0;
17647 bcopy(physaddr, &v6addr->s6_addr32[3], sizeof (ipaddr_t));
17648 }
17649
17650 /*
17651 * Derive IPv6 interface id from an IPv6 link-layer address (e.g. from an IPv6
17652 * tunnel). The lower 8 bytes of the IPv6 address simply become the interface
17653 * id.
17654 */
17655 static void
17656 ip_ipv6_genv6intfid(ill_t *ill, uint8_t *physaddr, in6_addr_t *v6addr)
17657 {
17658 in6_addr_t *v6lladdr = (in6_addr_t *)physaddr;
17659
17660 ASSERT(ill->ill_phys_addr_length == sizeof (in6_addr_t));
17661 bcopy(&v6lladdr->s6_addr32[2], &v6addr->s6_addr32[2], 8);
17662 }
17663
17664 static void
17665 ip_ipv6_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17666 {
17667 ip_ipv6_genv6intfid(ill, ill->ill_phys_addr, v6addr);
17668 }
17669
17670 static void
17671 ip_ipv6_v6destintfid(ill_t *ill, in6_addr_t *v6addr)
17672 {
17673 ip_ipv6_genv6intfid(ill, ill->ill_dest_addr, v6addr);
17674 }
17675
17676 static void
17677 ip_ipv4_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17678 {
17679 ip_ipv4_genv6intfid(ill, ill->ill_phys_addr, v6addr);
17680 }
17681
17682 static void
17683 ip_ipv4_v6destintfid(ill_t *ill, in6_addr_t *v6addr)
17684 {
17685 ip_ipv4_genv6intfid(ill, ill->ill_dest_addr, v6addr);
17686 }
17687
17688 /*
17689 * Lookup an ill and verify that the zoneid has an ipif on that ill.
17690 * Returns an held ill, or NULL.
17691 */
17692 ill_t *
17693 ill_lookup_on_ifindex_zoneid(uint_t index, zoneid_t zoneid, boolean_t isv6,
17694 ip_stack_t *ipst)
17695 {
17696 ill_t *ill;
17697 ipif_t *ipif;
17698
17699 ill = ill_lookup_on_ifindex(index, isv6, ipst);
17700 if (ill == NULL)
17701 return (NULL);
17702
17703 mutex_enter(&ill->ill_lock);
17704 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17705 if (IPIF_IS_CONDEMNED(ipif))
17706 continue;
17707 if (zoneid != ALL_ZONES && ipif->ipif_zoneid != zoneid &&
17708 ipif->ipif_zoneid != ALL_ZONES)
17709 continue;
17710
17711 mutex_exit(&ill->ill_lock);
17712 return (ill);
17713 }
17714 mutex_exit(&ill->ill_lock);
17715 ill_refrele(ill);
17716 return (NULL);
17717 }
17718
17719 /*
17720 * Return a pointer to an ipif_t given a combination of (ill_idx,ipif_id)
17721 * If a pointer to an ipif_t is returned then the caller will need to do
17722 * an ill_refrele().
17723 */
17724 ipif_t *
17725 ipif_getby_indexes(uint_t ifindex, uint_t lifidx, boolean_t isv6,
17726 ip_stack_t *ipst)
17727 {
17728 ipif_t *ipif;
17729 ill_t *ill;
17730
17731 ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
17732 if (ill == NULL)
17733 return (NULL);
17734
17735 mutex_enter(&ill->ill_lock);
17736 if (ill->ill_state_flags & ILL_CONDEMNED) {
17737 mutex_exit(&ill->ill_lock);
17738 ill_refrele(ill);
17739 return (NULL);
17740 }
17741
17742 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17743 if (!IPIF_CAN_LOOKUP(ipif))
17744 continue;
17745 if (lifidx == ipif->ipif_id) {
17746 ipif_refhold_locked(ipif);
17747 break;
17748 }
17749 }
17750
17751 mutex_exit(&ill->ill_lock);
17752 ill_refrele(ill);
17753 return (ipif);
17754 }
17755
17756 /*
17757 * Set ill_inputfn based on the current know state.
17758 * This needs to be called when any of the factors taken into
17759 * account changes.
17760 */
17761 void
17762 ill_set_inputfn(ill_t *ill)
17763 {
17764 ip_stack_t *ipst = ill->ill_ipst;
17765
17766 if (ill->ill_isv6) {
17767 if (is_system_labeled())
17768 ill->ill_inputfn = ill_input_full_v6;
17769 else
17770 ill->ill_inputfn = ill_input_short_v6;
17771 } else {
17772 if (is_system_labeled())
17773 ill->ill_inputfn = ill_input_full_v4;
17774 else if (ill->ill_dhcpinit != 0)
17775 ill->ill_inputfn = ill_input_full_v4;
17776 else if (ipst->ips_ipcl_proto_fanout_v4[IPPROTO_RSVP].connf_head
17777 != NULL)
17778 ill->ill_inputfn = ill_input_full_v4;
17779 else if (ipst->ips_ip_cgtp_filter &&
17780 ipst->ips_ip_cgtp_filter_ops != NULL)
17781 ill->ill_inputfn = ill_input_full_v4;
17782 else
17783 ill->ill_inputfn = ill_input_short_v4;
17784 }
17785 }
17786
17787 /*
17788 * Re-evaluate ill_inputfn for all the IPv4 ills.
17789 * Used when RSVP and CGTP comes and goes.
17790 */
17791 void
17792 ill_set_inputfn_all(ip_stack_t *ipst)
17793 {
17794 ill_walk_context_t ctx;
17795 ill_t *ill;
17796
17797 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
17798 ill = ILL_START_WALK_V4(&ctx, ipst);
17799 for (; ill != NULL; ill = ill_next(&ctx, ill))
17800 ill_set_inputfn(ill);
17801
17802 rw_exit(&ipst->ips_ill_g_lock);
17803 }
17804
17805 /*
17806 * Set the physical address information for `ill' to the contents of the
17807 * dl_notify_ind_t pointed to by `mp'. Must be called as writer, and will be
17808 * asynchronous if `ill' cannot immediately be quiesced -- in which case
17809 * EINPROGRESS will be returned.
17810 */
17811 int
17812 ill_set_phys_addr(ill_t *ill, mblk_t *mp)
17813 {
17814 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17815 dl_notify_ind_t *dlindp = (dl_notify_ind_t *)mp->b_rptr;
17816
17817 ASSERT(IAM_WRITER_IPSQ(ipsq));
17818
17819 if (dlindp->dl_data != DL_IPV6_LINK_LAYER_ADDR &&
17820 dlindp->dl_data != DL_CURR_DEST_ADDR &&
17821 dlindp->dl_data != DL_CURR_PHYS_ADDR) {
17822 /* Changing DL_IPV6_TOKEN is not yet supported */
17823 return (0);
17824 }
17825
17826 /*
17827 * We need to store up to two copies of `mp' in `ill'. Due to the
17828 * design of ipsq_pending_mp_add(), we can't pass them as separate
17829 * arguments to ill_set_phys_addr_tail(). Instead, chain them
17830 * together here, then pull 'em apart in ill_set_phys_addr_tail().
17831 */
17832 if ((mp = copyb(mp)) == NULL || (mp->b_cont = copyb(mp)) == NULL) {
17833 freemsg(mp);
17834 return (ENOMEM);
17835 }
17836
17837 ipsq_current_start(ipsq, ill->ill_ipif, 0);
17838
17839 /*
17840 * Since we'll only do a logical down, we can't rely on ipif_down
17841 * to turn on ILL_DOWN_IN_PROGRESS, or for the DL_BIND_ACK to reset
17842 * ILL_DOWN_IN_PROGRESS. We instead manage this separately for this
17843 * case, to quiesce ire's and nce's for ill_is_quiescent.
17844 */
17845 mutex_enter(&ill->ill_lock);
17846 ill->ill_state_flags |= ILL_DOWN_IN_PROGRESS;
17847 /* no more ire/nce addition allowed */
17848 mutex_exit(&ill->ill_lock);
17849
17850 /*
17851 * If we can quiesce the ill, then set the address. If not, then
17852 * ill_set_phys_addr_tail() will be called from ipif_ill_refrele_tail().
17853 */
17854 ill_down_ipifs(ill, B_TRUE);
17855 mutex_enter(&ill->ill_lock);
17856 if (!ill_is_quiescent(ill)) {
17857 /* call cannot fail since `conn_t *' argument is NULL */
17858 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
17859 mp, ILL_DOWN);
17860 mutex_exit(&ill->ill_lock);
17861 return (EINPROGRESS);
17862 }
17863 mutex_exit(&ill->ill_lock);
17864
17865 ill_set_phys_addr_tail(ipsq, ill->ill_rq, mp, NULL);
17866 return (0);
17867 }
17868
17869 /*
17870 * When the allowed-ips link property is set on the datalink, IP receives a
17871 * DL_NOTE_ALLOWED_IPS notification that is processed in ill_set_allowed_ips()
17872 * to initialize the ill_allowed_ips[] array in the ill_t. This array is then
17873 * used to vet addresses passed to ip_sioctl_addr() and to ensure that the
17874 * only IP addresses configured on the ill_t are those in the ill_allowed_ips[]
17875 * array.
17876 */
17877 void
17878 ill_set_allowed_ips(ill_t *ill, mblk_t *mp)
17879 {
17880 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17881 dl_notify_ind_t *dlip = (dl_notify_ind_t *)mp->b_rptr;
17882 mac_protect_t *mrp;
17883 int i;
17884
17885 ASSERT(IAM_WRITER_IPSQ(ipsq));
17886 mrp = (mac_protect_t *)&dlip[1];
17887
17888 if (mrp->mp_ipaddrcnt == 0) { /* reset allowed-ips */
17889 kmem_free(ill->ill_allowed_ips,
17890 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
17891 ill->ill_allowed_ips_cnt = 0;
17892 ill->ill_allowed_ips = NULL;
17893 mutex_enter(&ill->ill_phyint->phyint_lock);
17894 ill->ill_phyint->phyint_flags &= ~PHYI_L3PROTECT;
17895 mutex_exit(&ill->ill_phyint->phyint_lock);
17896 return;
17897 }
17898
17899 if (ill->ill_allowed_ips != NULL) {
17900 kmem_free(ill->ill_allowed_ips,
17901 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
17902 }
17903 ill->ill_allowed_ips_cnt = mrp->mp_ipaddrcnt;
17904 ill->ill_allowed_ips = kmem_alloc(
17905 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t), KM_SLEEP);
17906 for (i = 0; i < mrp->mp_ipaddrcnt; i++)
17907 ill->ill_allowed_ips[i] = mrp->mp_ipaddrs[i].ip_addr;
17908
17909 mutex_enter(&ill->ill_phyint->phyint_lock);
17910 ill->ill_phyint->phyint_flags |= PHYI_L3PROTECT;
17911 mutex_exit(&ill->ill_phyint->phyint_lock);
17912 }
17913
17914 /*
17915 * Once the ill associated with `q' has quiesced, set its physical address
17916 * information to the values in `addrmp'. Note that two copies of `addrmp'
17917 * are passed (linked by b_cont), since we sometimes need to save two distinct
17918 * copies in the ill_t, and our context doesn't permit sleeping or allocation
17919 * failure (we'll free the other copy if it's not needed). Since the ill_t
17920 * is quiesced, we know any stale nce's with the old address information have
17921 * already been removed, so we don't need to call nce_flush().
17922 */
17923 /* ARGSUSED */
17924 static void
17925 ill_set_phys_addr_tail(ipsq_t *ipsq, queue_t *q, mblk_t *addrmp, void *dummy)
17926 {
17927 ill_t *ill = q->q_ptr;
17928 mblk_t *addrmp2 = unlinkb(addrmp);
17929 dl_notify_ind_t *dlindp = (dl_notify_ind_t *)addrmp->b_rptr;
17930 uint_t addrlen, addroff;
17931 int status;
17932
17933 ASSERT(IAM_WRITER_IPSQ(ipsq));
17934
17935 addroff = dlindp->dl_addr_offset;
17936 addrlen = dlindp->dl_addr_length - ABS(ill->ill_sap_length);
17937
17938 switch (dlindp->dl_data) {
17939 case DL_IPV6_LINK_LAYER_ADDR:
17940 ill_set_ndmp(ill, addrmp, addroff, addrlen);
17941 freemsg(addrmp2);
17942 break;
17943
17944 case DL_CURR_DEST_ADDR:
17945 freemsg(ill->ill_dest_addr_mp);
17946 ill->ill_dest_addr = addrmp->b_rptr + addroff;
17947 ill->ill_dest_addr_mp = addrmp;
17948 if (ill->ill_isv6) {
17949 ill_setdesttoken(ill);
17950 ipif_setdestlinklocal(ill->ill_ipif);
17951 }
17952 freemsg(addrmp2);
17953 break;
17954
17955 case DL_CURR_PHYS_ADDR:
17956 freemsg(ill->ill_phys_addr_mp);
17957 ill->ill_phys_addr = addrmp->b_rptr + addroff;
17958 ill->ill_phys_addr_mp = addrmp;
17959 ill->ill_phys_addr_length = addrlen;
17960 if (ill->ill_isv6)
17961 ill_set_ndmp(ill, addrmp2, addroff, addrlen);
17962 else
17963 freemsg(addrmp2);
17964 if (ill->ill_isv6) {
17965 ill_setdefaulttoken(ill);
17966 ipif_setlinklocal(ill->ill_ipif);
17967 }
17968 break;
17969 default:
17970 ASSERT(0);
17971 }
17972
17973 /*
17974 * reset ILL_DOWN_IN_PROGRESS so that we can successfully add ires
17975 * as we bring the ipifs up again.
17976 */
17977 mutex_enter(&ill->ill_lock);
17978 ill->ill_state_flags &= ~ILL_DOWN_IN_PROGRESS;
17979 mutex_exit(&ill->ill_lock);
17980 /*
17981 * If there are ipifs to bring up, ill_up_ipifs() will return
17982 * EINPROGRESS, and ipsq_current_finish() will be called by
17983 * ip_rput_dlpi_writer() or arp_bringup_done() when the last ipif is
17984 * brought up.
17985 */
17986 status = ill_up_ipifs(ill, q, addrmp);
17987 if (status != EINPROGRESS)
17988 ipsq_current_finish(ipsq);
17989 }
17990
17991 /*
17992 * Helper routine for setting the ill_nd_lla fields.
17993 */
17994 void
17995 ill_set_ndmp(ill_t *ill, mblk_t *ndmp, uint_t addroff, uint_t addrlen)
17996 {
17997 freemsg(ill->ill_nd_lla_mp);
17998 ill->ill_nd_lla = ndmp->b_rptr + addroff;
17999 ill->ill_nd_lla_mp = ndmp;
18000 ill->ill_nd_lla_len = addrlen;
18001 }
18002
18003 /*
18004 * Replumb the ill.
18005 */
18006 int
18007 ill_replumb(ill_t *ill, mblk_t *mp)
18008 {
18009 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
18010
18011 ASSERT(IAM_WRITER_IPSQ(ipsq));
18012
18013 ipsq_current_start(ipsq, ill->ill_ipif, 0);
18014
18015 /*
18016 * If we can quiesce the ill, then continue. If not, then
18017 * ill_replumb_tail() will be called from ipif_ill_refrele_tail().
18018 */
18019 ill_down_ipifs(ill, B_FALSE);
18020
18021 mutex_enter(&ill->ill_lock);
18022 if (!ill_is_quiescent(ill)) {
18023 /* call cannot fail since `conn_t *' argument is NULL */
18024 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
18025 mp, ILL_DOWN);
18026 mutex_exit(&ill->ill_lock);
18027 return (EINPROGRESS);
18028 }
18029 mutex_exit(&ill->ill_lock);
18030
18031 ill_replumb_tail(ipsq, ill->ill_rq, mp, NULL);
18032 return (0);
18033 }
18034
18035 /* ARGSUSED */
18036 static void
18037 ill_replumb_tail(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy)
18038 {
18039 ill_t *ill = q->q_ptr;
18040 int err;
18041 conn_t *connp = NULL;
18042
18043 ASSERT(IAM_WRITER_IPSQ(ipsq));
18044 freemsg(ill->ill_replumb_mp);
18045 ill->ill_replumb_mp = copyb(mp);
18046
18047 if (ill->ill_replumb_mp == NULL) {
18048 /* out of memory */
18049 ipsq_current_finish(ipsq);
18050 return;
18051 }
18052
18053 mutex_enter(&ill->ill_lock);
18054 ill->ill_up_ipifs = ipsq_pending_mp_add(NULL, ill->ill_ipif,
18055 ill->ill_rq, ill->ill_replumb_mp, 0);
18056 mutex_exit(&ill->ill_lock);
18057
18058 if (!ill->ill_up_ipifs) {
18059 /* already closing */
18060 ipsq_current_finish(ipsq);
18061 return;
18062 }
18063 ill->ill_replumbing = 1;
18064 err = ill_down_ipifs_tail(ill);
18065
18066 /*
18067 * Successfully quiesced and brought down the interface, now we send
18068 * the DL_NOTE_REPLUMB_DONE message down to the driver. Reuse the
18069 * DL_NOTE_REPLUMB message.
18070 */
18071 mp = mexchange(NULL, mp, sizeof (dl_notify_conf_t), M_PROTO,
18072 DL_NOTIFY_CONF);
18073 ASSERT(mp != NULL);
18074 ((dl_notify_conf_t *)mp->b_rptr)->dl_notification =
18075 DL_NOTE_REPLUMB_DONE;
18076 ill_dlpi_send(ill, mp);
18077
18078 /*
18079 * For IPv4, we would usually get EINPROGRESS because the ETHERTYPE_ARP
18080 * streams have to be unbound. When all the DLPI exchanges are done,
18081 * ipsq_current_finish() will be called by arp_bringup_done(). The
18082 * remainder of ipif bringup via ill_up_ipifs() will also be done in
18083 * arp_bringup_done().
18084 */
18085 ASSERT(ill->ill_replumb_mp != NULL);
18086 if (err == EINPROGRESS)
18087 return;
18088 else
18089 ill->ill_replumb_mp = ipsq_pending_mp_get(ipsq, &connp);
18090 ASSERT(connp == NULL);
18091 if (err == 0 && ill->ill_replumb_mp != NULL &&
18092 ill_up_ipifs(ill, q, ill->ill_replumb_mp) == EINPROGRESS) {
18093 return;
18094 }
18095 ipsq_current_finish(ipsq);
18096 }
18097
18098 /*
18099 * Issue ioctl `cmd' on `lh'; caller provides the initial payload in `buf'
18100 * which is `bufsize' bytes. On success, zero is returned and `buf' updated
18101 * as per the ioctl. On failure, an errno is returned.
18102 */
18103 static int
18104 ip_ioctl(ldi_handle_t lh, int cmd, void *buf, uint_t bufsize, cred_t *cr)
18105 {
18106 int rval;
18107 struct strioctl iocb;
18108
18109 iocb.ic_cmd = cmd;
18110 iocb.ic_timout = 15;
18111 iocb.ic_len = bufsize;
18112 iocb.ic_dp = buf;
18113
18114 return (ldi_ioctl(lh, I_STR, (intptr_t)&iocb, FKIOCTL, cr, &rval));
18115 }
18116
18117 /*
18118 * Issue an SIOCGLIFCONF for address family `af' and store the result into a
18119 * dynamically-allocated `lifcp' that will be `bufsizep' bytes on success.
18120 */
18121 static int
18122 ip_lifconf_ioctl(ldi_handle_t lh, int af, struct lifconf *lifcp,
18123 uint_t *bufsizep, cred_t *cr)
18124 {
18125 int err;
18126 struct lifnum lifn;
18127
18128 bzero(&lifn, sizeof (lifn));
18129 lifn.lifn_family = af;
18130 lifn.lifn_flags = LIFC_UNDER_IPMP;
18131
18132 if ((err = ip_ioctl(lh, SIOCGLIFNUM, &lifn, sizeof (lifn), cr)) != 0)
18133 return (err);
18134
18135 /*
18136 * Pad the interface count to account for additional interfaces that
18137 * may have been configured between the SIOCGLIFNUM and SIOCGLIFCONF.
18138 */
18139 lifn.lifn_count += 4;
18140 bzero(lifcp, sizeof (*lifcp));
18141 lifcp->lifc_flags = LIFC_UNDER_IPMP;
18142 lifcp->lifc_family = af;
18143 lifcp->lifc_len = *bufsizep = lifn.lifn_count * sizeof (struct lifreq);
18144 lifcp->lifc_buf = kmem_zalloc(*bufsizep, KM_SLEEP);
18145
18146 err = ip_ioctl(lh, SIOCGLIFCONF, lifcp, sizeof (*lifcp), cr);
18147 if (err != 0) {
18148 kmem_free(lifcp->lifc_buf, *bufsizep);
18149 return (err);
18150 }
18151
18152 return (0);
18153 }
18154
18155 /*
18156 * Helper for ip_interface_cleanup() that removes the loopback interface.
18157 */
18158 static void
18159 ip_loopback_removeif(ldi_handle_t lh, boolean_t isv6, cred_t *cr)
18160 {
18161 int err;
18162 struct lifreq lifr;
18163
18164 bzero(&lifr, sizeof (lifr));
18165 (void) strcpy(lifr.lifr_name, ipif_loopback_name);
18166
18167 /*
18168 * Attempt to remove the interface. It may legitimately not exist
18169 * (e.g. the zone administrator unplumbed it), so ignore ENXIO.
18170 */
18171 err = ip_ioctl(lh, SIOCLIFREMOVEIF, &lifr, sizeof (lifr), cr);
18172 if (err != 0 && err != ENXIO) {
18173 ip0dbg(("ip_loopback_removeif: IP%s SIOCLIFREMOVEIF failed: "
18174 "error %d\n", isv6 ? "v6" : "v4", err));
18175 }
18176 }
18177
18178 /*
18179 * Helper for ip_interface_cleanup() that ensures no IP interfaces are in IPMP
18180 * groups and that IPMP data addresses are down. These conditions must be met
18181 * so that IPMP interfaces can be I_PUNLINK'd, as per ip_sioctl_plink_ipmp().
18182 */
18183 static void
18184 ip_ipmp_cleanup(ldi_handle_t lh, boolean_t isv6, cred_t *cr)
18185 {
18186 int af = isv6 ? AF_INET6 : AF_INET;
18187 int i, nifs;
18188 int err;
18189 uint_t bufsize;
18190 uint_t lifrsize = sizeof (struct lifreq);
18191 struct lifconf lifc;
18192 struct lifreq *lifrp;
18193
18194 if ((err = ip_lifconf_ioctl(lh, af, &lifc, &bufsize, cr)) != 0) {
18195 cmn_err(CE_WARN, "ip_ipmp_cleanup: cannot get interface list "
18196 "(error %d); any IPMP interfaces cannot be shutdown", err);
18197 return;
18198 }
18199
18200 nifs = lifc.lifc_len / lifrsize;
18201 for (lifrp = lifc.lifc_req, i = 0; i < nifs; i++, lifrp++) {
18202 err = ip_ioctl(lh, SIOCGLIFFLAGS, lifrp, lifrsize, cr);
18203 if (err != 0) {
18204 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot get "
18205 "flags: error %d", lifrp->lifr_name, err);
18206 continue;
18207 }
18208
18209 if (lifrp->lifr_flags & IFF_IPMP) {
18210 if ((lifrp->lifr_flags & (IFF_UP|IFF_DUPLICATE)) == 0)
18211 continue;
18212
18213 lifrp->lifr_flags &= ~IFF_UP;
18214 err = ip_ioctl(lh, SIOCSLIFFLAGS, lifrp, lifrsize, cr);
18215 if (err != 0) {
18216 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot "
18217 "bring down (error %d); IPMP interface may "
18218 "not be shutdown", lifrp->lifr_name, err);
18219 }
18220
18221 /*
18222 * Check if IFF_DUPLICATE is still set -- and if so,
18223 * reset the address to clear it.
18224 */
18225 err = ip_ioctl(lh, SIOCGLIFFLAGS, lifrp, lifrsize, cr);
18226 if (err != 0 || !(lifrp->lifr_flags & IFF_DUPLICATE))
18227 continue;
18228
18229 err = ip_ioctl(lh, SIOCGLIFADDR, lifrp, lifrsize, cr);
18230 if (err != 0 || (err = ip_ioctl(lh, SIOCGLIFADDR,
18231 lifrp, lifrsize, cr)) != 0) {
18232 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot "
18233 "reset DAD (error %d); IPMP interface may "
18234 "not be shutdown", lifrp->lifr_name, err);
18235 }
18236 continue;
18237 }
18238
18239 if (strchr(lifrp->lifr_name, IPIF_SEPARATOR_CHAR) == 0) {
18240 lifrp->lifr_groupname[0] = '\0';
18241 if ((err = ip_ioctl(lh, SIOCSLIFGROUPNAME, lifrp,
18242 lifrsize, cr)) != 0) {
18243 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot "
18244 "leave IPMP group (error %d); associated "
18245 "IPMP interface may not be shutdown",
18246 lifrp->lifr_name, err);
18247 continue;
18248 }
18249 }
18250 }
18251
18252 kmem_free(lifc.lifc_buf, bufsize);
18253 }
18254
18255 #define UDPDEV "/devices/pseudo/udp@0:udp"
18256 #define UDP6DEV "/devices/pseudo/udp6@0:udp6"
18257
18258 /*
18259 * Remove the loopback interfaces and prep the IPMP interfaces to be torn down.
18260 * Non-loopback interfaces are either I_LINK'd or I_PLINK'd; the former go away
18261 * when the user-level processes in the zone are killed and the latter are
18262 * cleaned up by str_stack_shutdown().
18263 */
18264 void
18265 ip_interface_cleanup(ip_stack_t *ipst)
18266 {
18267 ldi_handle_t lh;
18268 ldi_ident_t li;
18269 cred_t *cr;
18270 int err;
18271 int i;
18272 char *devs[] = { UDP6DEV, UDPDEV };
18273 netstackid_t stackid = ipst->ips_netstack->netstack_stackid;
18274
18275 if ((err = ldi_ident_from_major(ddi_name_to_major("ip"), &li)) != 0) {
18276 cmn_err(CE_WARN, "ip_interface_cleanup: cannot get ldi ident:"
18277 " error %d", err);
18278 return;
18279 }
18280
18281 cr = zone_get_kcred(netstackid_to_zoneid(stackid));
18282 ASSERT(cr != NULL);
18283
18284 /*
18285 * NOTE: loop executes exactly twice and is hardcoded to know that the
18286 * first iteration is IPv6. (Unrolling yields repetitious code, hence
18287 * the loop.)
18288 */
18289 for (i = 0; i < 2; i++) {
18290 err = ldi_open_by_name(devs[i], FREAD|FWRITE, cr, &lh, li);
18291 if (err != 0) {
18292 cmn_err(CE_WARN, "ip_interface_cleanup: cannot open %s:"
18293 " error %d", devs[i], err);
18294 continue;
18295 }
18296
18297 ip_loopback_removeif(lh, i == 0, cr);
18298 ip_ipmp_cleanup(lh, i == 0, cr);
18299
18300 (void) ldi_close(lh, FREAD|FWRITE, cr);
18301 }
18302
18303 ldi_ident_release(li);
18304 crfree(cr);
18305 }
18306
18307 /*
18308 * This needs to be in-sync with nic_event_t definition
18309 */
18310 static const char *
18311 ill_hook_event2str(nic_event_t event)
18312 {
18313 switch (event) {
18314 case NE_PLUMB:
18315 return ("PLUMB");
18316 case NE_UNPLUMB:
18317 return ("UNPLUMB");
18318 case NE_UP:
18319 return ("UP");
18320 case NE_DOWN:
18321 return ("DOWN");
18322 case NE_ADDRESS_CHANGE:
18323 return ("ADDRESS_CHANGE");
18324 case NE_LIF_UP:
18325 return ("LIF_UP");
18326 case NE_LIF_DOWN:
18327 return ("LIF_DOWN");
18328 case NE_IFINDEX_CHANGE:
18329 return ("IFINDEX_CHANGE");
18330 default:
18331 return ("UNKNOWN");
18332 }
18333 }
18334
18335 void
18336 ill_nic_event_dispatch(ill_t *ill, lif_if_t lif, nic_event_t event,
18337 nic_event_data_t data, size_t datalen)
18338 {
18339 ip_stack_t *ipst = ill->ill_ipst;
18340 hook_nic_event_int_t *info;
18341 const char *str = NULL;
18342
18343 /* create a new nic event info */
18344 if ((info = kmem_alloc(sizeof (*info), KM_NOSLEEP)) == NULL)
18345 goto fail;
18346
18347 info->hnei_event.hne_nic = ill->ill_phyint->phyint_ifindex;
18348 info->hnei_event.hne_lif = lif;
18349 info->hnei_event.hne_event = event;
18350 info->hnei_event.hne_protocol = ill->ill_isv6 ?
18351 ipst->ips_ipv6_net_data : ipst->ips_ipv4_net_data;
18352 info->hnei_event.hne_data = NULL;
18353 info->hnei_event.hne_datalen = 0;
18354 info->hnei_stackid = ipst->ips_netstack->netstack_stackid;
18355
18356 if (data != NULL && datalen != 0) {
18357 info->hnei_event.hne_data = kmem_alloc(datalen, KM_NOSLEEP);
18358 if (info->hnei_event.hne_data == NULL)
18359 goto fail;
18360 bcopy(data, info->hnei_event.hne_data, datalen);
18361 info->hnei_event.hne_datalen = datalen;
18362 }
18363
18364 if (ddi_taskq_dispatch(eventq_queue_nic, ip_ne_queue_func, info,
18365 DDI_NOSLEEP) == DDI_SUCCESS)
18366 return;
18367
18368 fail:
18369 if (info != NULL) {
18370 if (info->hnei_event.hne_data != NULL) {
18371 kmem_free(info->hnei_event.hne_data,
18372 info->hnei_event.hne_datalen);
18373 }
18374 kmem_free(info, sizeof (hook_nic_event_t));
18375 }
18376 str = ill_hook_event2str(event);
18377 ip2dbg(("ill_nic_event_dispatch: could not dispatch %s nic event "
18378 "information for %s (ENOMEM)\n", str, ill->ill_name));
18379 }
18380
18381 static int
18382 ipif_arp_up_done_tail(ipif_t *ipif, enum ip_resolver_action res_act)
18383 {
18384 int err = 0;
18385 const in_addr_t *addr = NULL;
18386 nce_t *nce = NULL;
18387 ill_t *ill = ipif->ipif_ill;
18388 ill_t *bound_ill;
18389 boolean_t added_ipif = B_FALSE;
18390 uint16_t state;
18391 uint16_t flags;
18392
18393 DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_up_done_tail",
18394 ill_t *, ill, ipif_t *, ipif);
18395 if (ipif->ipif_lcl_addr != INADDR_ANY) {
18396 addr = &ipif->ipif_lcl_addr;
18397 }
18398
18399 if ((ipif->ipif_flags & IPIF_UNNUMBERED) || addr == NULL) {
18400 if (res_act != Res_act_initial)
18401 return (EINVAL);
18402 }
18403
18404 if (addr != NULL) {
18405 ipmp_illgrp_t *illg = ill->ill_grp;
18406
18407 /* add unicast nce for the local addr */
18408
18409 if (IS_IPMP(ill)) {
18410 /*
18411 * If we're here via ipif_up(), then the ipif
18412 * won't be bound yet -- add it to the group,
18413 * which will bind it if possible. (We would
18414 * add it in ipif_up(), but deleting on failure
18415 * there is gruesome.) If we're here via
18416 * ipmp_ill_bind_ipif(), then the ipif has
18417 * already been added to the group and we
18418 * just need to use the binding.
18419 */
18420 if ((bound_ill = ipmp_ipif_bound_ill(ipif)) == NULL) {
18421 bound_ill = ipmp_illgrp_add_ipif(illg, ipif);
18422 if (bound_ill == NULL) {
18423 /*
18424 * We couldn't bind the ipif to an ill
18425 * yet, so we have nothing to publish.
18426 * Mark the address as ready and return.
18427 */
18428 ipif->ipif_addr_ready = 1;
18429 return (0);
18430 }
18431 added_ipif = B_TRUE;
18432 }
18433 } else {
18434 bound_ill = ill;
18435 }
18436
18437 flags = (NCE_F_MYADDR | NCE_F_PUBLISH | NCE_F_AUTHORITY |
18438 NCE_F_NONUD);
18439 /*
18440 * If this is an initial bring-up (or the ipif was never
18441 * completely brought up), do DAD. Otherwise, we're here
18442 * because IPMP has rebound an address to this ill: send
18443 * unsolicited advertisements (ARP announcements) to
18444 * inform others.
18445 */
18446 if (res_act == Res_act_initial || !ipif->ipif_addr_ready) {
18447 state = ND_UNCHANGED; /* compute in nce_add_common() */
18448 } else {
18449 state = ND_REACHABLE;
18450 flags |= NCE_F_UNSOL_ADV;
18451 }
18452
18453 retry:
18454 err = nce_lookup_then_add_v4(ill,
18455 bound_ill->ill_phys_addr, bound_ill->ill_phys_addr_length,
18456 addr, flags, state, &nce);
18457
18458 /*
18459 * note that we may encounter EEXIST if we are moving
18460 * the nce as a result of a rebind operation.
18461 */
18462 switch (err) {
18463 case 0:
18464 ipif->ipif_added_nce = 1;
18465 nce->nce_ipif_cnt++;
18466 break;
18467 case EEXIST:
18468 ip1dbg(("ipif_arp_up: NCE already exists for %s\n",
18469 ill->ill_name));
18470 if (!NCE_MYADDR(nce->nce_common)) {
18471 /*
18472 * A leftover nce from before this address
18473 * existed
18474 */
18475 ncec_delete(nce->nce_common);
18476 nce_refrele(nce);
18477 nce = NULL;
18478 goto retry;
18479 }
18480 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
18481 nce_refrele(nce);
18482 nce = NULL;
18483 ip1dbg(("ipif_arp_up: NCE already exists "
18484 "for %s:%u\n", ill->ill_name,
18485 ipif->ipif_id));
18486 goto arp_up_done;
18487 }
18488 /*
18489 * Duplicate local addresses are permissible for
18490 * IPIF_POINTOPOINT interfaces which will get marked
18491 * IPIF_UNNUMBERED later in
18492 * ip_addr_availability_check().
18493 *
18494 * The nce_ipif_cnt field tracks the number of
18495 * ipifs that have nce_addr as their local address.
18496 */
18497 ipif->ipif_addr_ready = 1;
18498 ipif->ipif_added_nce = 1;
18499 nce->nce_ipif_cnt++;
18500 err = 0;
18501 break;
18502 default:
18503 ASSERT(nce == NULL);
18504 goto arp_up_done;
18505 }
18506 if (arp_no_defense) {
18507 if ((ipif->ipif_flags & IPIF_UP) &&
18508 !ipif->ipif_addr_ready)
18509 ipif_up_notify(ipif);
18510 ipif->ipif_addr_ready = 1;
18511 }
18512 } else {
18513 /* zero address. nothing to publish */
18514 ipif->ipif_addr_ready = 1;
18515 }
18516 if (nce != NULL)
18517 nce_refrele(nce);
18518 arp_up_done:
18519 if (added_ipif && err != 0)
18520 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18521 return (err);
18522 }
18523
18524 int
18525 ipif_arp_up(ipif_t *ipif, enum ip_resolver_action res_act, boolean_t was_dup)
18526 {
18527 int err = 0;
18528 ill_t *ill = ipif->ipif_ill;
18529 boolean_t first_interface, wait_for_dlpi = B_FALSE;
18530
18531 DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_up",
18532 ill_t *, ill, ipif_t *, ipif);
18533
18534 /*
18535 * need to bring up ARP or setup mcast mapping only
18536 * when the first interface is coming UP.
18537 */
18538 first_interface = (ill->ill_ipif_up_count == 0 &&
18539 ill->ill_ipif_dup_count == 0 && !was_dup);
18540
18541 if (res_act == Res_act_initial && first_interface) {
18542 /*
18543 * Send ATTACH + BIND
18544 */
18545 err = arp_ll_up(ill);
18546 if (err != EINPROGRESS && err != 0)
18547 return (err);
18548
18549 /*
18550 * Add NCE for local address. Start DAD.
18551 * we'll wait to hear that DAD has finished
18552 * before using the interface.
18553 */
18554 if (err == EINPROGRESS)
18555 wait_for_dlpi = B_TRUE;
18556 }
18557
18558 if (!wait_for_dlpi)
18559 (void) ipif_arp_up_done_tail(ipif, res_act);
18560
18561 return (!wait_for_dlpi ? 0 : EINPROGRESS);
18562 }
18563
18564 /*
18565 * Finish processing of "arp_up" after all the DLPI message
18566 * exchanges have completed between arp and the driver.
18567 */
18568 void
18569 arp_bringup_done(ill_t *ill, int err)
18570 {
18571 mblk_t *mp1;
18572 ipif_t *ipif;
18573 conn_t *connp = NULL;
18574 ipsq_t *ipsq;
18575 queue_t *q;
18576
18577 ip1dbg(("arp_bringup_done(%s)\n", ill->ill_name));
18578
18579 ASSERT(IAM_WRITER_ILL(ill));
18580
18581 ipsq = ill->ill_phyint->phyint_ipsq;
18582 ipif = ipsq->ipsq_xop->ipx_pending_ipif;
18583 mp1 = ipsq_pending_mp_get(ipsq, &connp);
18584 ASSERT(!((mp1 != NULL) ^ (ipif != NULL)));
18585 if (mp1 == NULL) /* bringup was aborted by the user */
18586 return;
18587
18588 /*
18589 * If an IOCTL is waiting on this (ipsq_current_ioctl != 0), then we
18590 * must have an associated conn_t. Otherwise, we're bringing this
18591 * interface back up as part of handling an asynchronous event (e.g.,
18592 * physical address change).
18593 */
18594 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18595 ASSERT(connp != NULL);
18596 q = CONNP_TO_WQ(connp);
18597 } else {
18598 ASSERT(connp == NULL);
18599 q = ill->ill_rq;
18600 }
18601 if (err == 0) {
18602 if (ipif->ipif_isv6) {
18603 if ((err = ipif_up_done_v6(ipif)) != 0)
18604 ip0dbg(("arp_bringup_done: init failed\n"));
18605 } else {
18606 err = ipif_arp_up_done_tail(ipif, Res_act_initial);
18607 if (err != 0 ||
18608 (err = ipif_up_done(ipif)) != 0) {
18609 ip0dbg(("arp_bringup_done: "
18610 "init failed err %x\n", err));
18611 (void) ipif_arp_down(ipif);
18612 }
18613
18614 }
18615 } else {
18616 ip0dbg(("arp_bringup_done: DL_BIND_REQ failed\n"));
18617 }
18618
18619 if ((err == 0) && (ill->ill_up_ipifs)) {
18620 err = ill_up_ipifs(ill, q, mp1);
18621 if (err == EINPROGRESS)
18622 return;
18623 }
18624
18625 /*
18626 * If we have a moved ipif to bring up, and everything has succeeded
18627 * to this point, bring it up on the IPMP ill. Otherwise, leave it
18628 * down -- the admin can try to bring it up by hand if need be.
18629 */
18630 if (ill->ill_move_ipif != NULL) {
18631 ipif = ill->ill_move_ipif;
18632 ip1dbg(("bringing up ipif %p on ill %s\n", (void *)ipif,
18633 ipif->ipif_ill->ill_name));
18634 ill->ill_move_ipif = NULL;
18635 if (err == 0) {
18636 err = ipif_up(ipif, q, mp1);
18637 if (err == EINPROGRESS)
18638 return;
18639 }
18640 }
18641
18642 /*
18643 * The operation must complete without EINPROGRESS since
18644 * ipsq_pending_mp_get() has removed the mblk from ipsq_pending_mp.
18645 * Otherwise, the operation will be stuck forever in the ipsq.
18646 */
18647 ASSERT(err != EINPROGRESS);
18648 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18649 DTRACE_PROBE4(ipif__ioctl, char *, "arp_bringup_done finish",
18650 int, ipsq->ipsq_xop->ipx_current_ioctl,
18651 ill_t *, ill, ipif_t *, ipif);
18652 ip_ioctl_finish(q, mp1, err, NO_COPYOUT, ipsq);
18653 } else {
18654 ipsq_current_finish(ipsq);
18655 }
18656 }
18657
18658 /*
18659 * Finish processing of arp replumb after all the DLPI message
18660 * exchanges have completed between arp and the driver.
18661 */
18662 void
18663 arp_replumb_done(ill_t *ill, int err)
18664 {
18665 mblk_t *mp1;
18666 ipif_t *ipif;
18667 conn_t *connp = NULL;
18668 ipsq_t *ipsq;
18669 queue_t *q;
18670
18671 ASSERT(IAM_WRITER_ILL(ill));
18672
18673 ipsq = ill->ill_phyint->phyint_ipsq;
18674 ipif = ipsq->ipsq_xop->ipx_pending_ipif;
18675 mp1 = ipsq_pending_mp_get(ipsq, &connp);
18676 ASSERT(!((mp1 != NULL) ^ (ipif != NULL)));
18677 if (mp1 == NULL) {
18678 ip0dbg(("arp_replumb_done: bringup aborted ioctl %x\n",
18679 ipsq->ipsq_xop->ipx_current_ioctl));
18680 /* bringup was aborted by the user */
18681 return;
18682 }
18683 /*
18684 * If an IOCTL is waiting on this (ipsq_current_ioctl != 0), then we
18685 * must have an associated conn_t. Otherwise, we're bringing this
18686 * interface back up as part of handling an asynchronous event (e.g.,
18687 * physical address change).
18688 */
18689 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18690 ASSERT(connp != NULL);
18691 q = CONNP_TO_WQ(connp);
18692 } else {
18693 ASSERT(connp == NULL);
18694 q = ill->ill_rq;
18695 }
18696 if ((err == 0) && (ill->ill_up_ipifs)) {
18697 err = ill_up_ipifs(ill, q, mp1);
18698 if (err == EINPROGRESS)
18699 return;
18700 }
18701 /*
18702 * The operation must complete without EINPROGRESS since
18703 * ipsq_pending_mp_get() has removed the mblk from ipsq_pending_mp.
18704 * Otherwise, the operation will be stuck forever in the ipsq.
18705 */
18706 ASSERT(err != EINPROGRESS);
18707 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18708 DTRACE_PROBE4(ipif__ioctl, char *,
18709 "arp_replumb_done finish",
18710 int, ipsq->ipsq_xop->ipx_current_ioctl,
18711 ill_t *, ill, ipif_t *, ipif);
18712 ip_ioctl_finish(q, mp1, err, NO_COPYOUT, ipsq);
18713 } else {
18714 ipsq_current_finish(ipsq);
18715 }
18716 }
18717
18718 void
18719 ipif_up_notify(ipif_t *ipif)
18720 {
18721 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
18722 ip_rts_newaddrmsg(RTM_ADD, 0, ipif, RTSQ_DEFAULT);
18723 sctp_update_ipif(ipif, SCTP_IPIF_UP);
18724 ill_nic_event_dispatch(ipif->ipif_ill, MAP_IPIF_ID(ipif->ipif_id),
18725 NE_LIF_UP, NULL, 0);
18726 }
18727
18728 /*
18729 * ILB ioctl uses cv_wait (such as deleting a rule or adding a server) and
18730 * this assumes the context is cv_wait'able. Hence it shouldnt' be used on
18731 * TPI end points with STREAMS modules pushed above. This is assured by not
18732 * having the IPI_MODOK flag for the ioctl. And IP ensures the ILB ioctl
18733 * never ends up on an ipsq, otherwise we may end up processing the ioctl
18734 * while unwinding from the ispq and that could be a thread from the bottom.
18735 */
18736 /* ARGSUSED */
18737 int
18738 ip_sioctl_ilb_cmd(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
18739 ip_ioctl_cmd_t *ipip, void *arg)
18740 {
18741 mblk_t *cmd_mp = mp->b_cont->b_cont;
18742 ilb_cmd_t command = *((ilb_cmd_t *)cmd_mp->b_rptr);
18743 int ret = 0;
18744 int i;
18745 size_t size;
18746 ip_stack_t *ipst;
18747 zoneid_t zoneid;
18748 ilb_stack_t *ilbs;
18749
18750 ipst = CONNQ_TO_IPST(q);
18751 ilbs = ipst->ips_netstack->netstack_ilb;
18752 zoneid = Q_TO_CONN(q)->conn_zoneid;
18753
18754 switch (command) {
18755 case ILB_CREATE_RULE: {
18756 ilb_rule_cmd_t *cmd = (ilb_rule_cmd_t *)cmd_mp->b_rptr;
18757
18758 if (MBLKL(cmd_mp) != sizeof (ilb_rule_cmd_t)) {
18759 ret = EINVAL;
18760 break;
18761 }
18762
18763 ret = ilb_rule_add(ilbs, zoneid, cmd);
18764 break;
18765 }
18766 case ILB_DESTROY_RULE:
18767 case ILB_ENABLE_RULE:
18768 case ILB_DISABLE_RULE: {
18769 ilb_name_cmd_t *cmd = (ilb_name_cmd_t *)cmd_mp->b_rptr;
18770
18771 if (MBLKL(cmd_mp) != sizeof (ilb_name_cmd_t)) {
18772 ret = EINVAL;
18773 break;
18774 }
18775
18776 if (cmd->flags & ILB_RULE_ALLRULES) {
18777 if (command == ILB_DESTROY_RULE) {
18778 ilb_rule_del_all(ilbs, zoneid);
18779 break;
18780 } else if (command == ILB_ENABLE_RULE) {
18781 ilb_rule_enable_all(ilbs, zoneid);
18782 break;
18783 } else if (command == ILB_DISABLE_RULE) {
18784 ilb_rule_disable_all(ilbs, zoneid);
18785 break;
18786 }
18787 } else {
18788 if (command == ILB_DESTROY_RULE) {
18789 ret = ilb_rule_del(ilbs, zoneid, cmd->name);
18790 } else if (command == ILB_ENABLE_RULE) {
18791 ret = ilb_rule_enable(ilbs, zoneid, cmd->name,
18792 NULL);
18793 } else if (command == ILB_DISABLE_RULE) {
18794 ret = ilb_rule_disable(ilbs, zoneid, cmd->name,
18795 NULL);
18796 }
18797 }
18798 break;
18799 }
18800 case ILB_NUM_RULES: {
18801 ilb_num_rules_cmd_t *cmd;
18802
18803 if (MBLKL(cmd_mp) != sizeof (ilb_num_rules_cmd_t)) {
18804 ret = EINVAL;
18805 break;
18806 }
18807 cmd = (ilb_num_rules_cmd_t *)cmd_mp->b_rptr;
18808 ilb_get_num_rules(ilbs, zoneid, &(cmd->num));
18809 break;
18810 }
18811 case ILB_RULE_NAMES: {
18812 ilb_rule_names_cmd_t *cmd;
18813
18814 cmd = (ilb_rule_names_cmd_t *)cmd_mp->b_rptr;
18815 if (MBLKL(cmd_mp) < sizeof (ilb_rule_names_cmd_t) ||
18816 cmd->num_names == 0) {
18817 ret = EINVAL;
18818 break;
18819 }
18820 size = cmd->num_names * ILB_RULE_NAMESZ;
18821 if (cmd_mp->b_rptr + offsetof(ilb_rule_names_cmd_t, buf) +
18822 size != cmd_mp->b_wptr) {
18823 ret = EINVAL;
18824 break;
18825 }
18826 ilb_get_rulenames(ilbs, zoneid, &cmd->num_names, cmd->buf);
18827 break;
18828 }
18829 case ILB_NUM_SERVERS: {
18830 ilb_num_servers_cmd_t *cmd;
18831
18832 if (MBLKL(cmd_mp) != sizeof (ilb_num_servers_cmd_t)) {
18833 ret = EINVAL;
18834 break;
18835 }
18836 cmd = (ilb_num_servers_cmd_t *)cmd_mp->b_rptr;
18837 ret = ilb_get_num_servers(ilbs, zoneid, cmd->name,
18838 &(cmd->num));
18839 break;
18840 }
18841 case ILB_LIST_RULE: {
18842 ilb_rule_cmd_t *cmd = (ilb_rule_cmd_t *)cmd_mp->b_rptr;
18843
18844 if (MBLKL(cmd_mp) != sizeof (ilb_rule_cmd_t)) {
18845 ret = EINVAL;
18846 break;
18847 }
18848 ret = ilb_rule_list(ilbs, zoneid, cmd);
18849 break;
18850 }
18851 case ILB_LIST_SERVERS: {
18852 ilb_servers_info_cmd_t *cmd;
18853
18854 cmd = (ilb_servers_info_cmd_t *)cmd_mp->b_rptr;
18855 if (MBLKL(cmd_mp) < sizeof (ilb_servers_info_cmd_t) ||
18856 cmd->num_servers == 0) {
18857 ret = EINVAL;
18858 break;
18859 }
18860 size = cmd->num_servers * sizeof (ilb_server_info_t);
18861 if (cmd_mp->b_rptr + offsetof(ilb_servers_info_cmd_t, servers) +
18862 size != cmd_mp->b_wptr) {
18863 ret = EINVAL;
18864 break;
18865 }
18866
18867 ret = ilb_get_servers(ilbs, zoneid, cmd->name, cmd->servers,
18868 &cmd->num_servers);
18869 break;
18870 }
18871 case ILB_ADD_SERVERS: {
18872 ilb_servers_info_cmd_t *cmd;
18873 ilb_rule_t *rule;
18874
18875 cmd = (ilb_servers_info_cmd_t *)cmd_mp->b_rptr;
18876 if (MBLKL(cmd_mp) < sizeof (ilb_servers_info_cmd_t)) {
18877 ret = EINVAL;
18878 break;
18879 }
18880 size = cmd->num_servers * sizeof (ilb_server_info_t);
18881 if (cmd_mp->b_rptr + offsetof(ilb_servers_info_cmd_t, servers) +
18882 size != cmd_mp->b_wptr) {
18883 ret = EINVAL;
18884 break;
18885 }
18886 rule = ilb_find_rule(ilbs, zoneid, cmd->name, &ret);
18887 if (rule == NULL) {
18888 ASSERT(ret != 0);
18889 break;
18890 }
18891 for (i = 0; i < cmd->num_servers; i++) {
18892 ilb_server_info_t *s;
18893
18894 s = &cmd->servers[i];
18895 s->err = ilb_server_add(ilbs, rule, s);
18896 }
18897 ILB_RULE_REFRELE(rule);
18898 break;
18899 }
18900 case ILB_DEL_SERVERS:
18901 case ILB_ENABLE_SERVERS:
18902 case ILB_DISABLE_SERVERS: {
18903 ilb_servers_cmd_t *cmd;
18904 ilb_rule_t *rule;
18905 int (*f)();
18906
18907 cmd = (ilb_servers_cmd_t *)cmd_mp->b_rptr;
18908 if (MBLKL(cmd_mp) < sizeof (ilb_servers_cmd_t)) {
18909 ret = EINVAL;
18910 break;
18911 }
18912 size = cmd->num_servers * sizeof (ilb_server_arg_t);
18913 if (cmd_mp->b_rptr + offsetof(ilb_servers_cmd_t, servers) +
18914 size != cmd_mp->b_wptr) {
18915 ret = EINVAL;
18916 break;
18917 }
18918
18919 if (command == ILB_DEL_SERVERS)
18920 f = ilb_server_del;
18921 else if (command == ILB_ENABLE_SERVERS)
18922 f = ilb_server_enable;
18923 else if (command == ILB_DISABLE_SERVERS)
18924 f = ilb_server_disable;
18925
18926 rule = ilb_find_rule(ilbs, zoneid, cmd->name, &ret);
18927 if (rule == NULL) {
18928 ASSERT(ret != 0);
18929 break;
18930 }
18931
18932 for (i = 0; i < cmd->num_servers; i++) {
18933 ilb_server_arg_t *s;
18934
18935 s = &cmd->servers[i];
18936 s->err = f(ilbs, zoneid, NULL, rule, &s->addr);
18937 }
18938 ILB_RULE_REFRELE(rule);
18939 break;
18940 }
18941 case ILB_LIST_NAT_TABLE: {
18942 ilb_list_nat_cmd_t *cmd;
18943
18944 cmd = (ilb_list_nat_cmd_t *)cmd_mp->b_rptr;
18945 if (MBLKL(cmd_mp) < sizeof (ilb_list_nat_cmd_t)) {
18946 ret = EINVAL;
18947 break;
18948 }
18949 size = cmd->num_nat * sizeof (ilb_nat_entry_t);
18950 if (cmd_mp->b_rptr + offsetof(ilb_list_nat_cmd_t, entries) +
18951 size != cmd_mp->b_wptr) {
18952 ret = EINVAL;
18953 break;
18954 }
18955
18956 ret = ilb_list_nat(ilbs, zoneid, cmd->entries, &cmd->num_nat,
18957 &cmd->flags);
18958 break;
18959 }
18960 case ILB_LIST_STICKY_TABLE: {
18961 ilb_list_sticky_cmd_t *cmd;
18962
18963 cmd = (ilb_list_sticky_cmd_t *)cmd_mp->b_rptr;
18964 if (MBLKL(cmd_mp) < sizeof (ilb_list_sticky_cmd_t)) {
18965 ret = EINVAL;
18966 break;
18967 }
18968 size = cmd->num_sticky * sizeof (ilb_sticky_entry_t);
18969 if (cmd_mp->b_rptr + offsetof(ilb_list_sticky_cmd_t, entries) +
18970 size != cmd_mp->b_wptr) {
18971 ret = EINVAL;
18972 break;
18973 }
18974
18975 ret = ilb_list_sticky(ilbs, zoneid, cmd->entries,
18976 &cmd->num_sticky, &cmd->flags);
18977 break;
18978 }
18979 default:
18980 ret = EINVAL;
18981 break;
18982 }
18983 done:
18984 return (ret);
18985 }
18986
18987 /* Remove all cache entries for this logical interface */
18988 void
18989 ipif_nce_down(ipif_t *ipif)
18990 {
18991 ill_t *ill = ipif->ipif_ill;
18992 nce_t *nce;
18993
18994 DTRACE_PROBE3(ipif__downup, char *, "ipif_nce_down",
18995 ill_t *, ill, ipif_t *, ipif);
18996 if (ipif->ipif_added_nce) {
18997 if (ipif->ipif_isv6)
18998 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
18999 else
19000 nce = nce_lookup_v4(ill, &ipif->ipif_lcl_addr);
19001 if (nce != NULL) {
19002 if (--nce->nce_ipif_cnt == 0)
19003 ncec_delete(nce->nce_common);
19004 ipif->ipif_added_nce = 0;
19005 nce_refrele(nce);
19006 } else {
19007 /*
19008 * nce may already be NULL because it was already
19009 * flushed, e.g., due to a call to nce_flush
19010 */
19011 ipif->ipif_added_nce = 0;
19012 }
19013 }
19014 /*
19015 * Make IPMP aware of the deleted data address.
19016 */
19017 if (IS_IPMP(ill))
19018 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
19019
19020 /*
19021 * Remove all other nces dependent on this ill when the last ipif
19022 * is going away.
19023 */
19024 if (ill->ill_ipif_up_count == 0) {
19025 ncec_walk(ill, (pfi_t)ncec_delete_per_ill,
19026 (uchar_t *)ill, ill->ill_ipst);
19027 if (IS_UNDER_IPMP(ill))
19028 nce_flush(ill, B_TRUE);
19029 }
19030 }
19031
19032 /*
19033 * find the first interface that uses usill for its source address.
19034 */
19035 ill_t *
19036 ill_lookup_usesrc(ill_t *usill)
19037 {
19038 ip_stack_t *ipst = usill->ill_ipst;
19039 ill_t *ill;
19040
19041 ASSERT(usill != NULL);
19042
19043 /* ill_g_usesrc_lock protects ill_usesrc_grp_next */
19044 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_WRITER);
19045 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
19046 for (ill = usill->ill_usesrc_grp_next; ill != NULL && ill != usill;
19047 ill = ill->ill_usesrc_grp_next) {
19048 if (!IS_UNDER_IPMP(ill) && (ill->ill_flags & ILLF_MULTICAST) &&
19049 !ILL_IS_CONDEMNED(ill)) {
19050 ill_refhold(ill);
19051 break;
19052 }
19053 }
19054 rw_exit(&ipst->ips_ill_g_lock);
19055 rw_exit(&ipst->ips_ill_g_usesrc_lock);
19056 return (ill);
19057 }
19058
19059 /*
19060 * This comment applies to both ip_sioctl_get_ifhwaddr and
19061 * ip_sioctl_get_lifhwaddr as the basic function of these two functions
19062 * is the same.
19063 *
19064 * The goal here is to find an IP interface that corresponds to the name
19065 * provided by the caller in the ifreq/lifreq structure held in the mblk_t
19066 * chain and to fill out a sockaddr/sockaddr_storage structure with the
19067 * mac address.
19068 *
19069 * The SIOCGIFHWADDR/SIOCGLIFHWADDR ioctl may return an error for a number
19070 * of different reasons:
19071 * ENXIO - the device name is not known to IP.
19072 * EADDRNOTAVAIL - the device has no hardware address. This is indicated
19073 * by ill_phys_addr not pointing to an actual address.
19074 * EPFNOSUPPORT - this will indicate that a request is being made for a
19075 * mac address that will not fit in the data structure supplier (struct
19076 * sockaddr).
19077 *
19078 */
19079 /* ARGSUSED */
19080 int
19081 ip_sioctl_get_ifhwaddr(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
19082 ip_ioctl_cmd_t *ipip, void *if_req)
19083 {
19084 struct sockaddr *sock;
19085 struct ifreq *ifr;
19086 mblk_t *mp1;
19087 ill_t *ill;
19088
19089 ASSERT(ipif != NULL);
19090 ill = ipif->ipif_ill;
19091
19092 if (ill->ill_phys_addr == NULL) {
19093 return (EADDRNOTAVAIL);
19094 }
19095 if (ill->ill_phys_addr_length > sizeof (sock->sa_data)) {
19096 return (EPFNOSUPPORT);
19097 }
19098
19099 ip1dbg(("ip_sioctl_get_hwaddr(%s)\n", ill->ill_name));
19100
19101 /* Existence of mp1 has been checked in ip_wput_nondata */
19102 mp1 = mp->b_cont->b_cont;
19103 ifr = (struct ifreq *)mp1->b_rptr;
19104
19105 sock = &ifr->ifr_addr;
19106 /*
19107 * The "family" field in the returned structure is set to a value
19108 * that represents the type of device to which the address belongs.
19109 * The value returned may differ to that on Linux but it will still
19110 * represent the correct symbol on Solaris.
19111 */
19112 sock->sa_family = arp_hw_type(ill->ill_mactype);
19113 bcopy(ill->ill_phys_addr, &sock->sa_data, ill->ill_phys_addr_length);
19114
19115 return (0);
19116 }
19117
19118 /*
19119 * The expection of applications using SIOCGIFHWADDR is that data will
19120 * be returned in the sa_data field of the sockaddr structure. With
19121 * SIOCGLIFHWADDR, we're breaking new ground as there is no Linux
19122 * equivalent. In light of this, struct sockaddr_dl is used as it
19123 * offers more space for address storage in sll_data.
19124 */
19125 /* ARGSUSED */
19126 int
19127 ip_sioctl_get_lifhwaddr(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
19128 ip_ioctl_cmd_t *ipip, void *if_req)
19129 {
19130 struct sockaddr_dl *sock;
19131 struct lifreq *lifr;
19132 mblk_t *mp1;
19133 ill_t *ill;
19134
19135 ASSERT(ipif != NULL);
19136 ill = ipif->ipif_ill;
19137
19138 if (ill->ill_phys_addr == NULL) {
19139 return (EADDRNOTAVAIL);
19140 }
19141 if (ill->ill_phys_addr_length > sizeof (sock->sdl_data)) {
19142 return (EPFNOSUPPORT);
19143 }
19144
19145 ip1dbg(("ip_sioctl_get_lifhwaddr(%s)\n", ill->ill_name));
19146
19147 /* Existence of mp1 has been checked in ip_wput_nondata */
19148 mp1 = mp->b_cont->b_cont;
19149 lifr = (struct lifreq *)mp1->b_rptr;
19150
19151 /*
19152 * sockaddr_ll is used here because it is also the structure used in
19153 * responding to the same ioctl in sockpfp. The only other choice is
19154 * sockaddr_dl which contains fields that are not required here
19155 * because its purpose is different.
19156 */
19157 lifr->lifr_type = ill->ill_type;
19158 sock = (struct sockaddr_dl *)&lifr->lifr_addr;
19159 sock->sdl_family = AF_LINK;
19160 sock->sdl_index = ill->ill_phyint->phyint_ifindex;
19161 sock->sdl_type = ill->ill_mactype;
19162 sock->sdl_nlen = 0;
19163 sock->sdl_slen = 0;
19164 sock->sdl_alen = ill->ill_phys_addr_length;
19165 bcopy(ill->ill_phys_addr, sock->sdl_data, ill->ill_phys_addr_length);
19166
19167 return (0);
19168 }