Print this page
4510 Lose SIOC*IPSECONFIG ioctl definitions
Reviewed by: Robert Mustacchi <rm@joyent.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/inet/ip/ip_if.c
+++ new/usr/src/uts/common/inet/ip/ip_if.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
14 lines elided |
↑ open up ↑ |
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright (c) 1990 Mentat Inc.
24 24 * Copyright (c) 2013 by Delphix. All rights reserved.
25 + * Copyright (c) 2014, OmniTI Computer Consulting, Inc. All rights reserved.
25 26 */
26 27
27 28 /*
28 29 * This file contains the interface control functions for IP.
29 30 */
30 31
31 32 #include <sys/types.h>
32 33 #include <sys/stream.h>
33 34 #include <sys/dlpi.h>
34 35 #include <sys/stropts.h>
35 36 #include <sys/strsun.h>
36 37 #include <sys/sysmacros.h>
37 38 #include <sys/strsubr.h>
38 39 #include <sys/strlog.h>
39 40 #include <sys/ddi.h>
40 41 #include <sys/sunddi.h>
41 42 #include <sys/cmn_err.h>
42 43 #include <sys/kstat.h>
43 44 #include <sys/debug.h>
44 45 #include <sys/zone.h>
45 46 #include <sys/sunldi.h>
46 47 #include <sys/file.h>
47 48 #include <sys/bitmap.h>
48 49 #include <sys/cpuvar.h>
49 50 #include <sys/time.h>
50 51 #include <sys/ctype.h>
51 52 #include <sys/kmem.h>
52 53 #include <sys/systm.h>
53 54 #include <sys/param.h>
54 55 #include <sys/socket.h>
55 56 #include <sys/isa_defs.h>
56 57 #include <net/if.h>
57 58 #include <net/if_arp.h>
58 59 #include <net/if_types.h>
59 60 #include <net/if_dl.h>
60 61 #include <net/route.h>
61 62 #include <sys/sockio.h>
62 63 #include <netinet/in.h>
63 64 #include <netinet/ip6.h>
64 65 #include <netinet/icmp6.h>
65 66 #include <netinet/igmp_var.h>
66 67 #include <sys/policy.h>
67 68 #include <sys/ethernet.h>
68 69 #include <sys/callb.h>
69 70 #include <sys/md5.h>
70 71
71 72 #include <inet/common.h> /* for various inet/mi.h and inet/nd.h needs */
72 73 #include <inet/mi.h>
73 74 #include <inet/nd.h>
74 75 #include <inet/tunables.h>
75 76 #include <inet/arp.h>
76 77 #include <inet/ip_arp.h>
77 78 #include <inet/mib2.h>
78 79 #include <inet/ip.h>
79 80 #include <inet/ip6.h>
80 81 #include <inet/ip6_asp.h>
81 82 #include <inet/tcp.h>
82 83 #include <inet/ip_multi.h>
83 84 #include <inet/ip_ire.h>
84 85 #include <inet/ip_ftable.h>
85 86 #include <inet/ip_rts.h>
86 87 #include <inet/ip_ndp.h>
87 88 #include <inet/ip_if.h>
88 89 #include <inet/ip_impl.h>
89 90 #include <inet/sctp_ip.h>
90 91 #include <inet/ip_netinfo.h>
91 92 #include <inet/ilb_ip.h>
92 93
93 94 #include <netinet/igmp.h>
94 95 #include <inet/ip_listutils.h>
95 96 #include <inet/ipclassifier.h>
96 97 #include <sys/mac_client.h>
97 98 #include <sys/dld.h>
98 99 #include <sys/mac_flow.h>
99 100
100 101 #include <sys/systeminfo.h>
101 102 #include <sys/bootconf.h>
102 103
103 104 #include <sys/tsol/tndb.h>
104 105 #include <sys/tsol/tnet.h>
105 106
106 107 #include <inet/rawip_impl.h> /* needed for icmp_stack_t */
107 108 #include <inet/udp_impl.h> /* needed for udp_stack_t */
108 109
109 110 /* The character which tells where the ill_name ends */
110 111 #define IPIF_SEPARATOR_CHAR ':'
111 112
112 113 /* IP ioctl function table entry */
113 114 typedef struct ipft_s {
114 115 int ipft_cmd;
115 116 pfi_t ipft_pfi;
116 117 int ipft_min_size;
117 118 int ipft_flags;
118 119 } ipft_t;
119 120 #define IPFT_F_NO_REPLY 0x1 /* IP ioctl does not expect any reply */
120 121 #define IPFT_F_SELF_REPLY 0x2 /* ioctl callee does the ioctl reply */
121 122
122 123 static int nd_ill_forward_get(queue_t *, mblk_t *, caddr_t, cred_t *);
123 124 static int nd_ill_forward_set(queue_t *q, mblk_t *mp,
124 125 char *value, caddr_t cp, cred_t *ioc_cr);
125 126
126 127 static boolean_t ill_is_quiescent(ill_t *);
127 128 static boolean_t ip_addr_ok_v4(ipaddr_t addr, ipaddr_t subnet_mask);
128 129 static ip_m_t *ip_m_lookup(t_uscalar_t mac_type);
129 130 static int ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
130 131 mblk_t *mp, boolean_t need_up);
131 132 static int ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
132 133 mblk_t *mp, boolean_t need_up);
133 134 static int ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid,
134 135 queue_t *q, mblk_t *mp, boolean_t need_up);
135 136 static int ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q,
136 137 mblk_t *mp);
137 138 static int ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q,
138 139 mblk_t *mp);
139 140 static int ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t, in6_addr_t,
140 141 queue_t *q, mblk_t *mp, boolean_t need_up);
141 142 static int ip_sioctl_plink_ipmod(ipsq_t *ipsq, queue_t *q, mblk_t *mp,
142 143 int ioccmd, struct linkblk *li);
143 144 static ipaddr_t ip_subnet_mask(ipaddr_t addr, ipif_t **, ip_stack_t *);
144 145 static void ip_wput_ioctl(queue_t *q, mblk_t *mp);
145 146 static void ipsq_flush(ill_t *ill);
146 147
147 148 static int ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen,
148 149 queue_t *q, mblk_t *mp, boolean_t need_up);
149 150 static void ipsq_delete(ipsq_t *);
150 151
151 152 static ipif_t *ipif_allocate(ill_t *ill, int id, uint_t ire_type,
152 153 boolean_t initialize, boolean_t insert, int *errorp);
153 154 static ire_t **ipif_create_bcast_ires(ipif_t *ipif, ire_t **irep);
154 155 static void ipif_delete_bcast_ires(ipif_t *ipif);
155 156 static int ipif_add_ires_v4(ipif_t *, boolean_t);
156 157 static boolean_t ipif_comp_multi(ipif_t *old_ipif, ipif_t *new_ipif,
157 158 boolean_t isv6);
158 159 static int ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp);
159 160 static void ipif_free(ipif_t *ipif);
160 161 static void ipif_free_tail(ipif_t *ipif);
161 162 static void ipif_set_default(ipif_t *ipif);
162 163 static int ipif_set_values(queue_t *q, mblk_t *mp,
163 164 char *interf_name, uint_t *ppa);
164 165 static int ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp,
165 166 queue_t *q);
166 167 static ipif_t *ipif_lookup_on_name(char *name, size_t namelen,
167 168 boolean_t do_alloc, boolean_t *exists, boolean_t isv6, zoneid_t zoneid,
168 169 ip_stack_t *);
169 170 static ipif_t *ipif_lookup_on_name_async(char *name, size_t namelen,
170 171 boolean_t isv6, zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func,
171 172 int *error, ip_stack_t *);
172 173
173 174 static int ill_alloc_ppa(ill_if_t *, ill_t *);
174 175 static void ill_delete_interface_type(ill_if_t *);
175 176 static int ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q);
176 177 static void ill_dl_down(ill_t *ill);
177 178 static void ill_down(ill_t *ill);
178 179 static void ill_down_ipifs(ill_t *, boolean_t);
179 180 static void ill_free_mib(ill_t *ill);
180 181 static void ill_glist_delete(ill_t *);
181 182 static void ill_phyint_reinit(ill_t *ill);
182 183 static void ill_set_nce_router_flags(ill_t *, boolean_t);
183 184 static void ill_set_phys_addr_tail(ipsq_t *, queue_t *, mblk_t *, void *);
184 185 static void ill_replumb_tail(ipsq_t *, queue_t *, mblk_t *, void *);
185 186
186 187 static ip_v6intfid_func_t ip_ether_v6intfid, ip_ib_v6intfid;
187 188 static ip_v6intfid_func_t ip_ipv4_v6intfid, ip_ipv6_v6intfid;
188 189 static ip_v6intfid_func_t ip_ipmp_v6intfid, ip_nodef_v6intfid;
189 190 static ip_v6intfid_func_t ip_ipv4_v6destintfid, ip_ipv6_v6destintfid;
190 191 static ip_v4mapinfo_func_t ip_ether_v4_mapping;
191 192 static ip_v6mapinfo_func_t ip_ether_v6_mapping;
192 193 static ip_v4mapinfo_func_t ip_ib_v4_mapping;
193 194 static ip_v6mapinfo_func_t ip_ib_v6_mapping;
194 195 static ip_v4mapinfo_func_t ip_mbcast_mapping;
195 196 static void ip_cgtp_bcast_add(ire_t *, ip_stack_t *);
196 197 static void ip_cgtp_bcast_delete(ire_t *, ip_stack_t *);
197 198 static void phyint_free(phyint_t *);
198 199
199 200 static void ill_capability_dispatch(ill_t *, mblk_t *, dl_capability_sub_t *);
200 201 static void ill_capability_id_ack(ill_t *, mblk_t *, dl_capability_sub_t *);
201 202 static void ill_capability_vrrp_ack(ill_t *, mblk_t *, dl_capability_sub_t *);
202 203 static void ill_capability_hcksum_ack(ill_t *, mblk_t *, dl_capability_sub_t *);
203 204 static void ill_capability_hcksum_reset_fill(ill_t *, mblk_t *);
204 205 static void ill_capability_zerocopy_ack(ill_t *, mblk_t *,
205 206 dl_capability_sub_t *);
206 207 static void ill_capability_zerocopy_reset_fill(ill_t *, mblk_t *);
207 208 static void ill_capability_dld_reset_fill(ill_t *, mblk_t *);
208 209 static void ill_capability_dld_ack(ill_t *, mblk_t *,
209 210 dl_capability_sub_t *);
210 211 static void ill_capability_dld_enable(ill_t *);
211 212 static void ill_capability_ack_thr(void *);
212 213 static void ill_capability_lso_enable(ill_t *);
213 214
214 215 static ill_t *ill_prev_usesrc(ill_t *);
215 216 static int ill_relink_usesrc_ills(ill_t *, ill_t *, uint_t);
216 217 static void ill_disband_usesrc_group(ill_t *);
217 218 static void ip_sioctl_garp_reply(mblk_t *, ill_t *, void *, int);
218 219
219 220 #ifdef DEBUG
220 221 static void ill_trace_cleanup(const ill_t *);
221 222 static void ipif_trace_cleanup(const ipif_t *);
222 223 #endif
223 224
224 225 static void ill_dlpi_clear_deferred(ill_t *ill);
225 226
226 227 /*
227 228 * if we go over the memory footprint limit more than once in this msec
228 229 * interval, we'll start pruning aggressively.
229 230 */
230 231 int ip_min_frag_prune_time = 0;
231 232
232 233 static ipft_t ip_ioctl_ftbl[] = {
233 234 { IP_IOC_IRE_DELETE, ip_ire_delete, sizeof (ipid_t), 0 },
234 235 { IP_IOC_IRE_DELETE_NO_REPLY, ip_ire_delete, sizeof (ipid_t),
235 236 IPFT_F_NO_REPLY },
236 237 { IP_IOC_RTS_REQUEST, ip_rts_request, 0, IPFT_F_SELF_REPLY },
237 238 { 0 }
238 239 };
239 240
240 241 /* Simple ICMP IP Header Template */
241 242 static ipha_t icmp_ipha = {
242 243 IP_SIMPLE_HDR_VERSION, 0, 0, 0, 0, 0, IPPROTO_ICMP
243 244 };
244 245
245 246 static uchar_t ip_six_byte_all_ones[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
246 247
247 248 static ip_m_t ip_m_tbl[] = {
248 249 { DL_ETHER, IFT_ETHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
249 250 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_ether_v6intfid,
250 251 ip_nodef_v6intfid },
251 252 { DL_CSMACD, IFT_ISO88023, ETHERTYPE_IP, ETHERTYPE_IPV6,
252 253 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
253 254 ip_nodef_v6intfid },
254 255 { DL_TPB, IFT_ISO88024, ETHERTYPE_IP, ETHERTYPE_IPV6,
255 256 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
256 257 ip_nodef_v6intfid },
257 258 { DL_TPR, IFT_ISO88025, ETHERTYPE_IP, ETHERTYPE_IPV6,
258 259 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
259 260 ip_nodef_v6intfid },
260 261 { DL_FDDI, IFT_FDDI, ETHERTYPE_IP, ETHERTYPE_IPV6,
261 262 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_ether_v6intfid,
262 263 ip_nodef_v6intfid },
263 264 { DL_IB, IFT_IB, ETHERTYPE_IP, ETHERTYPE_IPV6,
264 265 ip_ib_v4_mapping, ip_ib_v6_mapping, ip_ib_v6intfid,
265 266 ip_nodef_v6intfid },
266 267 { DL_IPV4, IFT_IPV4, IPPROTO_ENCAP, IPPROTO_IPV6,
267 268 ip_mbcast_mapping, ip_mbcast_mapping, ip_ipv4_v6intfid,
268 269 ip_ipv4_v6destintfid },
269 270 { DL_IPV6, IFT_IPV6, IPPROTO_ENCAP, IPPROTO_IPV6,
270 271 ip_mbcast_mapping, ip_mbcast_mapping, ip_ipv6_v6intfid,
271 272 ip_ipv6_v6destintfid },
272 273 { DL_6TO4, IFT_6TO4, IPPROTO_ENCAP, IPPROTO_IPV6,
273 274 ip_mbcast_mapping, ip_mbcast_mapping, ip_ipv4_v6intfid,
274 275 ip_nodef_v6intfid },
275 276 { SUNW_DL_VNI, IFT_OTHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
276 277 NULL, NULL, ip_nodef_v6intfid, ip_nodef_v6intfid },
277 278 { SUNW_DL_IPMP, IFT_OTHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
278 279 NULL, NULL, ip_ipmp_v6intfid, ip_nodef_v6intfid },
279 280 { DL_OTHER, IFT_OTHER, ETHERTYPE_IP, ETHERTYPE_IPV6,
280 281 ip_ether_v4_mapping, ip_ether_v6_mapping, ip_nodef_v6intfid,
281 282 ip_nodef_v6intfid }
282 283 };
283 284
284 285 static ill_t ill_null; /* Empty ILL for init. */
285 286 char ipif_loopback_name[] = "lo0";
286 287
287 288 /* These are used by all IP network modules. */
288 289 sin6_t sin6_null; /* Zero address for quick clears */
289 290 sin_t sin_null; /* Zero address for quick clears */
290 291
291 292 /* When set search for unused ipif_seqid */
292 293 static ipif_t ipif_zero;
293 294
294 295 /*
295 296 * ppa arena is created after these many
296 297 * interfaces have been plumbed.
297 298 */
298 299 uint_t ill_no_arena = 12; /* Setable in /etc/system */
299 300
300 301 /*
301 302 * Allocate per-interface mibs.
302 303 * Returns true if ok. False otherwise.
303 304 * ipsq may not yet be allocated (loopback case ).
304 305 */
305 306 static boolean_t
306 307 ill_allocate_mibs(ill_t *ill)
307 308 {
308 309 /* Already allocated? */
309 310 if (ill->ill_ip_mib != NULL) {
310 311 if (ill->ill_isv6)
311 312 ASSERT(ill->ill_icmp6_mib != NULL);
312 313 return (B_TRUE);
313 314 }
314 315
315 316 ill->ill_ip_mib = kmem_zalloc(sizeof (*ill->ill_ip_mib),
316 317 KM_NOSLEEP);
317 318 if (ill->ill_ip_mib == NULL) {
318 319 return (B_FALSE);
319 320 }
320 321
321 322 /* Setup static information */
322 323 SET_MIB(ill->ill_ip_mib->ipIfStatsEntrySize,
323 324 sizeof (mib2_ipIfStatsEntry_t));
324 325 if (ill->ill_isv6) {
325 326 ill->ill_ip_mib->ipIfStatsIPVersion = MIB2_INETADDRESSTYPE_ipv6;
326 327 SET_MIB(ill->ill_ip_mib->ipIfStatsAddrEntrySize,
327 328 sizeof (mib2_ipv6AddrEntry_t));
328 329 SET_MIB(ill->ill_ip_mib->ipIfStatsRouteEntrySize,
329 330 sizeof (mib2_ipv6RouteEntry_t));
330 331 SET_MIB(ill->ill_ip_mib->ipIfStatsNetToMediaEntrySize,
331 332 sizeof (mib2_ipv6NetToMediaEntry_t));
332 333 SET_MIB(ill->ill_ip_mib->ipIfStatsMemberEntrySize,
333 334 sizeof (ipv6_member_t));
334 335 SET_MIB(ill->ill_ip_mib->ipIfStatsGroupSourceEntrySize,
335 336 sizeof (ipv6_grpsrc_t));
336 337 } else {
337 338 ill->ill_ip_mib->ipIfStatsIPVersion = MIB2_INETADDRESSTYPE_ipv4;
338 339 SET_MIB(ill->ill_ip_mib->ipIfStatsAddrEntrySize,
339 340 sizeof (mib2_ipAddrEntry_t));
340 341 SET_MIB(ill->ill_ip_mib->ipIfStatsRouteEntrySize,
341 342 sizeof (mib2_ipRouteEntry_t));
342 343 SET_MIB(ill->ill_ip_mib->ipIfStatsNetToMediaEntrySize,
343 344 sizeof (mib2_ipNetToMediaEntry_t));
344 345 SET_MIB(ill->ill_ip_mib->ipIfStatsMemberEntrySize,
345 346 sizeof (ip_member_t));
346 347 SET_MIB(ill->ill_ip_mib->ipIfStatsGroupSourceEntrySize,
347 348 sizeof (ip_grpsrc_t));
348 349
349 350 /*
350 351 * For a v4 ill, we are done at this point, because per ill
351 352 * icmp mibs are only used for v6.
352 353 */
353 354 return (B_TRUE);
354 355 }
355 356
356 357 ill->ill_icmp6_mib = kmem_zalloc(sizeof (*ill->ill_icmp6_mib),
357 358 KM_NOSLEEP);
358 359 if (ill->ill_icmp6_mib == NULL) {
359 360 kmem_free(ill->ill_ip_mib, sizeof (*ill->ill_ip_mib));
360 361 ill->ill_ip_mib = NULL;
361 362 return (B_FALSE);
362 363 }
363 364 /* static icmp info */
364 365 ill->ill_icmp6_mib->ipv6IfIcmpEntrySize =
365 366 sizeof (mib2_ipv6IfIcmpEntry_t);
366 367 /*
367 368 * The ipIfStatsIfindex and ipv6IfIcmpIndex will be assigned later
368 369 * after the phyint merge occurs in ipif_set_values -> ill_glist_insert
369 370 * -> ill_phyint_reinit
370 371 */
371 372 return (B_TRUE);
372 373 }
373 374
374 375 /*
375 376 * Completely vaporize a lower level tap and all associated interfaces.
376 377 * ill_delete is called only out of ip_close when the device control
377 378 * stream is being closed.
378 379 */
379 380 void
380 381 ill_delete(ill_t *ill)
381 382 {
382 383 ipif_t *ipif;
383 384 ill_t *prev_ill;
384 385 ip_stack_t *ipst = ill->ill_ipst;
385 386
386 387 /*
387 388 * ill_delete may be forcibly entering the ipsq. The previous
388 389 * ioctl may not have completed and may need to be aborted.
389 390 * ipsq_flush takes care of it. If we don't need to enter the
390 391 * the ipsq forcibly, the 2nd invocation of ipsq_flush in
391 392 * ill_delete_tail is sufficient.
392 393 */
393 394 ipsq_flush(ill);
394 395
395 396 /*
396 397 * Nuke all interfaces. ipif_free will take down the interface,
397 398 * remove it from the list, and free the data structure.
398 399 * Walk down the ipif list and remove the logical interfaces
399 400 * first before removing the main ipif. We can't unplumb
400 401 * zeroth interface first in the case of IPv6 as update_conn_ill
401 402 * -> ip_ll_multireq de-references ill_ipif for checking
402 403 * POINTOPOINT.
403 404 *
404 405 * If ill_ipif was not properly initialized (i.e low on memory),
405 406 * then no interfaces to clean up. In this case just clean up the
406 407 * ill.
407 408 */
408 409 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
409 410 ipif_free(ipif);
410 411
411 412 /*
412 413 * clean out all the nce_t entries that depend on this
413 414 * ill for the ill_phys_addr.
414 415 */
415 416 nce_flush(ill, B_TRUE);
416 417
417 418 /* Clean up msgs on pending upcalls for mrouted */
418 419 reset_mrt_ill(ill);
419 420
420 421 update_conn_ill(ill, ipst);
421 422
422 423 /*
423 424 * Remove multicast references added as a result of calls to
424 425 * ip_join_allmulti().
425 426 */
426 427 ip_purge_allmulti(ill);
427 428
428 429 /*
429 430 * If the ill being deleted is under IPMP, boot it out of the illgrp.
430 431 */
431 432 if (IS_UNDER_IPMP(ill))
432 433 ipmp_ill_leave_illgrp(ill);
433 434
434 435 /*
435 436 * ill_down will arrange to blow off any IRE's dependent on this
436 437 * ILL, and shut down fragmentation reassembly.
437 438 */
438 439 ill_down(ill);
439 440
440 441 /* Let SCTP know, so that it can remove this from its list. */
441 442 sctp_update_ill(ill, SCTP_ILL_REMOVE);
442 443
443 444 /*
444 445 * Walk all CONNs that can have a reference on an ire or nce for this
445 446 * ill (we actually walk all that now have stale references).
446 447 */
447 448 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ipst);
448 449
449 450 /* With IPv6 we have dce_ifindex. Cleanup for neatness */
450 451 if (ill->ill_isv6)
451 452 dce_cleanup(ill->ill_phyint->phyint_ifindex, ipst);
452 453
453 454 /*
454 455 * If an address on this ILL is being used as a source address then
455 456 * clear out the pointers in other ILLs that point to this ILL.
456 457 */
457 458 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_WRITER);
458 459 if (ill->ill_usesrc_grp_next != NULL) {
459 460 if (ill->ill_usesrc_ifindex == 0) { /* usesrc ILL ? */
460 461 ill_disband_usesrc_group(ill);
461 462 } else { /* consumer of the usesrc ILL */
462 463 prev_ill = ill_prev_usesrc(ill);
463 464 prev_ill->ill_usesrc_grp_next =
464 465 ill->ill_usesrc_grp_next;
465 466 }
466 467 }
467 468 rw_exit(&ipst->ips_ill_g_usesrc_lock);
468 469 }
469 470
470 471 static void
471 472 ipif_non_duplicate(ipif_t *ipif)
472 473 {
473 474 ill_t *ill = ipif->ipif_ill;
474 475 mutex_enter(&ill->ill_lock);
475 476 if (ipif->ipif_flags & IPIF_DUPLICATE) {
476 477 ipif->ipif_flags &= ~IPIF_DUPLICATE;
477 478 ASSERT(ill->ill_ipif_dup_count > 0);
478 479 ill->ill_ipif_dup_count--;
479 480 }
480 481 mutex_exit(&ill->ill_lock);
481 482 }
482 483
483 484 /*
484 485 * ill_delete_tail is called from ip_modclose after all references
485 486 * to the closing ill are gone. The wait is done in ip_modclose
486 487 */
487 488 void
488 489 ill_delete_tail(ill_t *ill)
489 490 {
490 491 mblk_t **mpp;
491 492 ipif_t *ipif;
492 493 ip_stack_t *ipst = ill->ill_ipst;
493 494
494 495 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
495 496 ipif_non_duplicate(ipif);
496 497 (void) ipif_down_tail(ipif);
497 498 }
498 499
499 500 ASSERT(ill->ill_ipif_dup_count == 0);
500 501
501 502 /*
502 503 * If polling capability is enabled (which signifies direct
503 504 * upcall into IP and driver has ill saved as a handle),
504 505 * we need to make sure that unbind has completed before we
505 506 * let the ill disappear and driver no longer has any reference
506 507 * to this ill.
507 508 */
508 509 mutex_enter(&ill->ill_lock);
509 510 while (ill->ill_state_flags & ILL_DL_UNBIND_IN_PROGRESS)
510 511 cv_wait(&ill->ill_cv, &ill->ill_lock);
511 512 mutex_exit(&ill->ill_lock);
512 513 ASSERT(!(ill->ill_capabilities &
513 514 (ILL_CAPAB_DLD | ILL_CAPAB_DLD_POLL | ILL_CAPAB_DLD_DIRECT)));
514 515
515 516 if (ill->ill_net_type != IRE_LOOPBACK)
516 517 qprocsoff(ill->ill_rq);
517 518
518 519 /*
519 520 * We do an ipsq_flush once again now. New messages could have
520 521 * landed up from below (M_ERROR or M_HANGUP). Similarly ioctls
521 522 * could also have landed up if an ioctl thread had looked up
522 523 * the ill before we set the ILL_CONDEMNED flag, but not yet
523 524 * enqueued the ioctl when we did the ipsq_flush last time.
524 525 */
525 526 ipsq_flush(ill);
526 527
527 528 /*
528 529 * Free capabilities.
529 530 */
530 531 if (ill->ill_hcksum_capab != NULL) {
531 532 kmem_free(ill->ill_hcksum_capab, sizeof (ill_hcksum_capab_t));
532 533 ill->ill_hcksum_capab = NULL;
533 534 }
534 535
535 536 if (ill->ill_zerocopy_capab != NULL) {
536 537 kmem_free(ill->ill_zerocopy_capab,
537 538 sizeof (ill_zerocopy_capab_t));
538 539 ill->ill_zerocopy_capab = NULL;
539 540 }
540 541
541 542 if (ill->ill_lso_capab != NULL) {
542 543 kmem_free(ill->ill_lso_capab, sizeof (ill_lso_capab_t));
543 544 ill->ill_lso_capab = NULL;
544 545 }
545 546
546 547 if (ill->ill_dld_capab != NULL) {
547 548 kmem_free(ill->ill_dld_capab, sizeof (ill_dld_capab_t));
548 549 ill->ill_dld_capab = NULL;
549 550 }
550 551
551 552 /* Clean up ill_allowed_ips* related state */
552 553 if (ill->ill_allowed_ips != NULL) {
553 554 ASSERT(ill->ill_allowed_ips_cnt > 0);
554 555 kmem_free(ill->ill_allowed_ips,
555 556 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
556 557 ill->ill_allowed_ips = NULL;
557 558 ill->ill_allowed_ips_cnt = 0;
558 559 }
559 560
560 561 while (ill->ill_ipif != NULL)
561 562 ipif_free_tail(ill->ill_ipif);
562 563
563 564 /*
564 565 * We have removed all references to ilm from conn and the ones joined
565 566 * within the kernel.
566 567 *
567 568 * We don't walk conns, mrts and ires because
568 569 *
569 570 * 1) update_conn_ill and reset_mrt_ill cleans up conns and mrts.
570 571 * 2) ill_down ->ill_downi walks all the ires and cleans up
571 572 * ill references.
572 573 */
573 574
574 575 /*
575 576 * If this ill is an IPMP meta-interface, blow away the illgrp. This
576 577 * is safe to do because the illgrp has already been unlinked from the
577 578 * group by I_PUNLINK, and thus SIOCSLIFGROUPNAME cannot find it.
578 579 */
579 580 if (IS_IPMP(ill)) {
580 581 ipmp_illgrp_destroy(ill->ill_grp);
581 582 ill->ill_grp = NULL;
582 583 }
583 584
584 585 if (ill->ill_mphysaddr_list != NULL) {
585 586 multiphysaddr_t *mpa, *tmpa;
586 587
587 588 mpa = ill->ill_mphysaddr_list;
588 589 ill->ill_mphysaddr_list = NULL;
589 590 while (mpa) {
590 591 tmpa = mpa->mpa_next;
591 592 kmem_free(mpa, sizeof (*mpa));
592 593 mpa = tmpa;
593 594 }
594 595 }
595 596 /*
596 597 * Take us out of the list of ILLs. ill_glist_delete -> phyint_free
597 598 * could free the phyint. No more reference to the phyint after this
598 599 * point.
599 600 */
600 601 (void) ill_glist_delete(ill);
601 602
602 603 if (ill->ill_frag_ptr != NULL) {
603 604 uint_t count;
604 605
605 606 for (count = 0; count < ILL_FRAG_HASH_TBL_COUNT; count++) {
606 607 mutex_destroy(&ill->ill_frag_hash_tbl[count].ipfb_lock);
607 608 }
608 609 mi_free(ill->ill_frag_ptr);
609 610 ill->ill_frag_ptr = NULL;
610 611 ill->ill_frag_hash_tbl = NULL;
611 612 }
612 613
613 614 freemsg(ill->ill_nd_lla_mp);
614 615 /* Free all retained control messages. */
615 616 mpp = &ill->ill_first_mp_to_free;
616 617 do {
617 618 while (mpp[0]) {
618 619 mblk_t *mp;
619 620 mblk_t *mp1;
620 621
621 622 mp = mpp[0];
622 623 mpp[0] = mp->b_next;
623 624 for (mp1 = mp; mp1 != NULL; mp1 = mp1->b_cont) {
624 625 mp1->b_next = NULL;
625 626 mp1->b_prev = NULL;
626 627 }
627 628 freemsg(mp);
628 629 }
629 630 } while (mpp++ != &ill->ill_last_mp_to_free);
630 631
631 632 ill_free_mib(ill);
632 633
633 634 #ifdef DEBUG
634 635 ill_trace_cleanup(ill);
635 636 #endif
636 637
637 638 /* The default multicast interface might have changed */
638 639 ire_increment_multicast_generation(ipst, ill->ill_isv6);
639 640
640 641 /* Drop refcnt here */
641 642 netstack_rele(ill->ill_ipst->ips_netstack);
642 643 ill->ill_ipst = NULL;
643 644 }
644 645
645 646 static void
646 647 ill_free_mib(ill_t *ill)
647 648 {
648 649 ip_stack_t *ipst = ill->ill_ipst;
649 650
650 651 /*
651 652 * MIB statistics must not be lost, so when an interface
652 653 * goes away the counter values will be added to the global
653 654 * MIBs.
654 655 */
655 656 if (ill->ill_ip_mib != NULL) {
656 657 if (ill->ill_isv6) {
657 658 ip_mib2_add_ip_stats(&ipst->ips_ip6_mib,
658 659 ill->ill_ip_mib);
659 660 } else {
660 661 ip_mib2_add_ip_stats(&ipst->ips_ip_mib,
661 662 ill->ill_ip_mib);
662 663 }
663 664
664 665 kmem_free(ill->ill_ip_mib, sizeof (*ill->ill_ip_mib));
665 666 ill->ill_ip_mib = NULL;
666 667 }
667 668 if (ill->ill_icmp6_mib != NULL) {
668 669 ip_mib2_add_icmp6_stats(&ipst->ips_icmp6_mib,
669 670 ill->ill_icmp6_mib);
670 671 kmem_free(ill->ill_icmp6_mib, sizeof (*ill->ill_icmp6_mib));
671 672 ill->ill_icmp6_mib = NULL;
672 673 }
673 674 }
674 675
675 676 /*
676 677 * Concatenate together a physical address and a sap.
677 678 *
678 679 * Sap_lengths are interpreted as follows:
679 680 * sap_length == 0 ==> no sap
680 681 * sap_length > 0 ==> sap is at the head of the dlpi address
681 682 * sap_length < 0 ==> sap is at the tail of the dlpi address
682 683 */
683 684 static void
684 685 ill_dlur_copy_address(uchar_t *phys_src, uint_t phys_length,
685 686 t_scalar_t sap_src, t_scalar_t sap_length, uchar_t *dst)
686 687 {
687 688 uint16_t sap_addr = (uint16_t)sap_src;
688 689
689 690 if (sap_length == 0) {
690 691 if (phys_src == NULL)
691 692 bzero(dst, phys_length);
692 693 else
693 694 bcopy(phys_src, dst, phys_length);
694 695 } else if (sap_length < 0) {
695 696 if (phys_src == NULL)
696 697 bzero(dst, phys_length);
697 698 else
698 699 bcopy(phys_src, dst, phys_length);
699 700 bcopy(&sap_addr, (char *)dst + phys_length, sizeof (sap_addr));
700 701 } else {
701 702 bcopy(&sap_addr, dst, sizeof (sap_addr));
702 703 if (phys_src == NULL)
703 704 bzero((char *)dst + sap_length, phys_length);
704 705 else
705 706 bcopy(phys_src, (char *)dst + sap_length, phys_length);
706 707 }
707 708 }
708 709
709 710 /*
710 711 * Generate a dl_unitdata_req mblk for the device and address given.
711 712 * addr_length is the length of the physical portion of the address.
712 713 * If addr is NULL include an all zero address of the specified length.
713 714 * TRUE? In any case, addr_length is taken to be the entire length of the
714 715 * dlpi address, including the absolute value of sap_length.
715 716 */
716 717 mblk_t *
717 718 ill_dlur_gen(uchar_t *addr, uint_t addr_length, t_uscalar_t sap,
718 719 t_scalar_t sap_length)
719 720 {
720 721 dl_unitdata_req_t *dlur;
721 722 mblk_t *mp;
722 723 t_scalar_t abs_sap_length; /* absolute value */
723 724
724 725 abs_sap_length = ABS(sap_length);
725 726 mp = ip_dlpi_alloc(sizeof (*dlur) + addr_length + abs_sap_length,
726 727 DL_UNITDATA_REQ);
727 728 if (mp == NULL)
728 729 return (NULL);
729 730 dlur = (dl_unitdata_req_t *)mp->b_rptr;
730 731 /* HACK: accomodate incompatible DLPI drivers */
731 732 if (addr_length == 8)
732 733 addr_length = 6;
733 734 dlur->dl_dest_addr_length = addr_length + abs_sap_length;
734 735 dlur->dl_dest_addr_offset = sizeof (*dlur);
735 736 dlur->dl_priority.dl_min = 0;
736 737 dlur->dl_priority.dl_max = 0;
737 738 ill_dlur_copy_address(addr, addr_length, sap, sap_length,
738 739 (uchar_t *)&dlur[1]);
739 740 return (mp);
740 741 }
741 742
742 743 /*
743 744 * Add the pending mp to the list. There can be only 1 pending mp
744 745 * in the list. Any exclusive ioctl that needs to wait for a response
745 746 * from another module or driver needs to use this function to set
746 747 * the ipx_pending_mp to the ioctl mblk and wait for the response from
747 748 * the other module/driver. This is also used while waiting for the
748 749 * ipif/ill/ire refcnts to drop to zero in bringing down an ipif.
749 750 */
750 751 boolean_t
751 752 ipsq_pending_mp_add(conn_t *connp, ipif_t *ipif, queue_t *q, mblk_t *add_mp,
752 753 int waitfor)
753 754 {
754 755 ipxop_t *ipx = ipif->ipif_ill->ill_phyint->phyint_ipsq->ipsq_xop;
755 756
756 757 ASSERT(IAM_WRITER_IPIF(ipif));
757 758 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
758 759 ASSERT((add_mp->b_next == NULL) && (add_mp->b_prev == NULL));
759 760 ASSERT(ipx->ipx_pending_mp == NULL);
760 761 /*
761 762 * The caller may be using a different ipif than the one passed into
762 763 * ipsq_current_start() (e.g., suppose an ioctl that came in on the V4
763 764 * ill needs to wait for the V6 ill to quiesce). So we can't ASSERT
764 765 * that `ipx_current_ipif == ipif'.
765 766 */
766 767 ASSERT(ipx->ipx_current_ipif != NULL);
767 768
768 769 /*
769 770 * M_IOCDATA from ioctls, M_ERROR/M_HANGUP/M_PROTO/M_PCPROTO from the
770 771 * driver.
771 772 */
772 773 ASSERT((DB_TYPE(add_mp) == M_IOCDATA) || (DB_TYPE(add_mp) == M_ERROR) ||
773 774 (DB_TYPE(add_mp) == M_HANGUP) || (DB_TYPE(add_mp) == M_PROTO) ||
774 775 (DB_TYPE(add_mp) == M_PCPROTO));
775 776
776 777 if (connp != NULL) {
777 778 ASSERT(MUTEX_HELD(&connp->conn_lock));
778 779 /*
779 780 * Return error if the conn has started closing. The conn
780 781 * could have finished cleaning up the pending mp list,
781 782 * If so we should not add another mp to the list negating
782 783 * the cleanup.
783 784 */
784 785 if (connp->conn_state_flags & CONN_CLOSING)
785 786 return (B_FALSE);
786 787 }
787 788 mutex_enter(&ipx->ipx_lock);
788 789 ipx->ipx_pending_ipif = ipif;
789 790 /*
790 791 * Note down the queue in b_queue. This will be returned by
791 792 * ipsq_pending_mp_get. Caller will then use these values to restart
792 793 * the processing
793 794 */
794 795 add_mp->b_next = NULL;
795 796 add_mp->b_queue = q;
796 797 ipx->ipx_pending_mp = add_mp;
797 798 ipx->ipx_waitfor = waitfor;
798 799 mutex_exit(&ipx->ipx_lock);
799 800
800 801 if (connp != NULL)
801 802 connp->conn_oper_pending_ill = ipif->ipif_ill;
802 803
803 804 return (B_TRUE);
804 805 }
805 806
806 807 /*
807 808 * Retrieve the ipx_pending_mp and return it. There can be only 1 mp
808 809 * queued in the list.
809 810 */
810 811 mblk_t *
811 812 ipsq_pending_mp_get(ipsq_t *ipsq, conn_t **connpp)
812 813 {
813 814 mblk_t *curr = NULL;
814 815 ipxop_t *ipx = ipsq->ipsq_xop;
815 816
816 817 *connpp = NULL;
817 818 mutex_enter(&ipx->ipx_lock);
818 819 if (ipx->ipx_pending_mp == NULL) {
819 820 mutex_exit(&ipx->ipx_lock);
820 821 return (NULL);
821 822 }
822 823
823 824 /* There can be only 1 such excl message */
824 825 curr = ipx->ipx_pending_mp;
825 826 ASSERT(curr->b_next == NULL);
826 827 ipx->ipx_pending_ipif = NULL;
827 828 ipx->ipx_pending_mp = NULL;
828 829 ipx->ipx_waitfor = 0;
829 830 mutex_exit(&ipx->ipx_lock);
830 831
831 832 if (CONN_Q(curr->b_queue)) {
832 833 /*
833 834 * This mp did a refhold on the conn, at the start of the ioctl.
834 835 * So we can safely return a pointer to the conn to the caller.
835 836 */
836 837 *connpp = Q_TO_CONN(curr->b_queue);
837 838 } else {
838 839 *connpp = NULL;
839 840 }
840 841 curr->b_next = NULL;
841 842 curr->b_prev = NULL;
842 843 return (curr);
843 844 }
844 845
845 846 /*
846 847 * Cleanup the ioctl mp queued in ipx_pending_mp
847 848 * - Called in the ill_delete path
848 849 * - Called in the M_ERROR or M_HANGUP path on the ill.
849 850 * - Called in the conn close path.
850 851 *
851 852 * Returns success on finding the pending mblk associated with the ioctl or
852 853 * exclusive operation in progress, failure otherwise.
853 854 */
854 855 boolean_t
855 856 ipsq_pending_mp_cleanup(ill_t *ill, conn_t *connp)
856 857 {
857 858 mblk_t *mp;
858 859 ipxop_t *ipx;
859 860 queue_t *q;
860 861 ipif_t *ipif;
861 862 int cmd;
862 863
863 864 ASSERT(IAM_WRITER_ILL(ill));
864 865 ipx = ill->ill_phyint->phyint_ipsq->ipsq_xop;
865 866
866 867 mutex_enter(&ipx->ipx_lock);
867 868 mp = ipx->ipx_pending_mp;
868 869 if (connp != NULL) {
869 870 if (mp == NULL || mp->b_queue != CONNP_TO_WQ(connp)) {
870 871 /*
871 872 * Nothing to clean since the conn that is closing
872 873 * does not have a matching pending mblk in
873 874 * ipx_pending_mp.
874 875 */
875 876 mutex_exit(&ipx->ipx_lock);
876 877 return (B_FALSE);
877 878 }
878 879 } else {
879 880 /*
880 881 * A non-zero ill_error signifies we are called in the
881 882 * M_ERROR or M_HANGUP path and we need to unconditionally
882 883 * abort any current ioctl and do the corresponding cleanup.
883 884 * A zero ill_error means we are in the ill_delete path and
884 885 * we do the cleanup only if there is a pending mp.
885 886 */
886 887 if (mp == NULL && ill->ill_error == 0) {
887 888 mutex_exit(&ipx->ipx_lock);
888 889 return (B_FALSE);
889 890 }
890 891 }
891 892
892 893 /* Now remove from the ipx_pending_mp */
893 894 ipx->ipx_pending_mp = NULL;
894 895 ipif = ipx->ipx_pending_ipif;
895 896 ipx->ipx_pending_ipif = NULL;
896 897 ipx->ipx_waitfor = 0;
897 898 ipx->ipx_current_ipif = NULL;
898 899 cmd = ipx->ipx_current_ioctl;
899 900 ipx->ipx_current_ioctl = 0;
900 901 ipx->ipx_current_done = B_TRUE;
901 902 mutex_exit(&ipx->ipx_lock);
902 903
903 904 if (mp == NULL)
904 905 return (B_FALSE);
905 906
906 907 q = mp->b_queue;
907 908 mp->b_next = NULL;
908 909 mp->b_prev = NULL;
909 910 mp->b_queue = NULL;
910 911
911 912 if (DB_TYPE(mp) == M_IOCTL || DB_TYPE(mp) == M_IOCDATA) {
912 913 DTRACE_PROBE4(ipif__ioctl,
913 914 char *, "ipsq_pending_mp_cleanup",
914 915 int, cmd, ill_t *, ipif == NULL ? NULL : ipif->ipif_ill,
915 916 ipif_t *, ipif);
916 917 if (connp == NULL) {
917 918 ip_ioctl_finish(q, mp, ENXIO, NO_COPYOUT, NULL);
918 919 } else {
919 920 ip_ioctl_finish(q, mp, ENXIO, CONN_CLOSE, NULL);
920 921 mutex_enter(&ipif->ipif_ill->ill_lock);
921 922 ipif->ipif_state_flags &= ~IPIF_CHANGING;
922 923 mutex_exit(&ipif->ipif_ill->ill_lock);
923 924 }
924 925 } else {
925 926 inet_freemsg(mp);
926 927 }
927 928 return (B_TRUE);
928 929 }
929 930
930 931 /*
931 932 * Called in the conn close path and ill delete path
932 933 */
933 934 static void
934 935 ipsq_xopq_mp_cleanup(ill_t *ill, conn_t *connp)
935 936 {
936 937 ipsq_t *ipsq;
937 938 mblk_t *prev;
938 939 mblk_t *curr;
939 940 mblk_t *next;
940 941 queue_t *wq, *rq = NULL;
941 942 mblk_t *tmp_list = NULL;
942 943
943 944 ASSERT(IAM_WRITER_ILL(ill));
944 945 if (connp != NULL)
945 946 wq = CONNP_TO_WQ(connp);
946 947 else
947 948 wq = ill->ill_wq;
948 949
949 950 /*
950 951 * In the case of lo0 being unplumbed, ill_wq will be NULL. Guard
951 952 * against this here.
952 953 */
953 954 if (wq != NULL)
954 955 rq = RD(wq);
955 956
956 957 ipsq = ill->ill_phyint->phyint_ipsq;
957 958 /*
958 959 * Cleanup the ioctl mp's queued in ipsq_xopq_pending_mp if any.
959 960 * In the case of ioctl from a conn, there can be only 1 mp
960 961 * queued on the ipsq. If an ill is being unplumbed flush all
961 962 * the messages.
962 963 */
963 964 mutex_enter(&ipsq->ipsq_lock);
964 965 for (prev = NULL, curr = ipsq->ipsq_xopq_mphead; curr != NULL;
965 966 curr = next) {
966 967 next = curr->b_next;
967 968 if (connp == NULL ||
968 969 (curr->b_queue == wq || curr->b_queue == rq)) {
969 970 /* Unlink the mblk from the pending mp list */
970 971 if (prev != NULL) {
971 972 prev->b_next = curr->b_next;
972 973 } else {
973 974 ASSERT(ipsq->ipsq_xopq_mphead == curr);
974 975 ipsq->ipsq_xopq_mphead = curr->b_next;
975 976 }
976 977 if (ipsq->ipsq_xopq_mptail == curr)
977 978 ipsq->ipsq_xopq_mptail = prev;
978 979 /*
979 980 * Create a temporary list and release the ipsq lock
980 981 * New elements are added to the head of the tmp_list
981 982 */
982 983 curr->b_next = tmp_list;
983 984 tmp_list = curr;
984 985 } else {
985 986 prev = curr;
986 987 }
987 988 }
988 989 mutex_exit(&ipsq->ipsq_lock);
989 990
990 991 while (tmp_list != NULL) {
991 992 curr = tmp_list;
992 993 tmp_list = curr->b_next;
993 994 curr->b_next = NULL;
994 995 curr->b_prev = NULL;
995 996 wq = curr->b_queue;
996 997 curr->b_queue = NULL;
997 998 if (DB_TYPE(curr) == M_IOCTL || DB_TYPE(curr) == M_IOCDATA) {
998 999 DTRACE_PROBE4(ipif__ioctl,
999 1000 char *, "ipsq_xopq_mp_cleanup",
1000 1001 int, 0, ill_t *, NULL, ipif_t *, NULL);
1001 1002 ip_ioctl_finish(wq, curr, ENXIO, connp != NULL ?
1002 1003 CONN_CLOSE : NO_COPYOUT, NULL);
1003 1004 } else {
1004 1005 /*
1005 1006 * IP-MT XXX In the case of TLI/XTI bind / optmgmt
1006 1007 * this can't be just inet_freemsg. we have to
1007 1008 * restart it otherwise the thread will be stuck.
1008 1009 */
1009 1010 inet_freemsg(curr);
1010 1011 }
1011 1012 }
1012 1013 }
1013 1014
1014 1015 /*
1015 1016 * This conn has started closing. Cleanup any pending ioctl from this conn.
1016 1017 * STREAMS ensures that there can be at most 1 active ioctl on a stream.
1017 1018 */
1018 1019 void
1019 1020 conn_ioctl_cleanup(conn_t *connp)
1020 1021 {
1021 1022 ipsq_t *ipsq;
1022 1023 ill_t *ill;
1023 1024 boolean_t refheld;
1024 1025
1025 1026 /*
1026 1027 * Check for a queued ioctl. If the ioctl has not yet started, the mp
1027 1028 * is pending in the list headed by ipsq_xopq_head. If the ioctl has
1028 1029 * started the mp could be present in ipx_pending_mp. Note that if
1029 1030 * conn_oper_pending_ill is NULL, the ioctl may still be in flight and
1030 1031 * not yet queued anywhere. In this case, the conn close code will wait
1031 1032 * until the conn_ref is dropped. If the stream was a tcp stream, then
1032 1033 * tcp_close will wait first until all ioctls have completed for this
1033 1034 * conn.
1034 1035 */
1035 1036 mutex_enter(&connp->conn_lock);
1036 1037 ill = connp->conn_oper_pending_ill;
1037 1038 if (ill == NULL) {
1038 1039 mutex_exit(&connp->conn_lock);
1039 1040 return;
1040 1041 }
1041 1042
1042 1043 /*
1043 1044 * We may not be able to refhold the ill if the ill/ipif
1044 1045 * is changing. But we need to make sure that the ill will
1045 1046 * not vanish. So we just bump up the ill_waiter count.
1046 1047 */
1047 1048 refheld = ill_waiter_inc(ill);
1048 1049 mutex_exit(&connp->conn_lock);
1049 1050 if (refheld) {
1050 1051 if (ipsq_enter(ill, B_TRUE, NEW_OP)) {
1051 1052 ill_waiter_dcr(ill);
1052 1053 /*
1053 1054 * Check whether this ioctl has started and is
1054 1055 * pending. If it is not found there then check
1055 1056 * whether this ioctl has not even started and is in
1056 1057 * the ipsq_xopq list.
1057 1058 */
1058 1059 if (!ipsq_pending_mp_cleanup(ill, connp))
1059 1060 ipsq_xopq_mp_cleanup(ill, connp);
1060 1061 ipsq = ill->ill_phyint->phyint_ipsq;
1061 1062 ipsq_exit(ipsq);
1062 1063 return;
1063 1064 }
1064 1065 }
1065 1066
1066 1067 /*
1067 1068 * The ill is also closing and we could not bump up the
1068 1069 * ill_waiter_count or we could not enter the ipsq. Leave
1069 1070 * the cleanup to ill_delete
1070 1071 */
1071 1072 mutex_enter(&connp->conn_lock);
1072 1073 while (connp->conn_oper_pending_ill != NULL)
1073 1074 cv_wait(&connp->conn_refcv, &connp->conn_lock);
1074 1075 mutex_exit(&connp->conn_lock);
1075 1076 if (refheld)
1076 1077 ill_waiter_dcr(ill);
1077 1078 }
1078 1079
1079 1080 /*
1080 1081 * ipcl_walk function for cleaning up conn_*_ill fields.
1081 1082 * Note that we leave ixa_multicast_ifindex, conn_incoming_ifindex, and
1082 1083 * conn_bound_if in place. We prefer dropping
1083 1084 * packets instead of sending them out the wrong interface, or accepting
1084 1085 * packets from the wrong ifindex.
1085 1086 */
1086 1087 static void
1087 1088 conn_cleanup_ill(conn_t *connp, caddr_t arg)
1088 1089 {
1089 1090 ill_t *ill = (ill_t *)arg;
1090 1091
1091 1092 mutex_enter(&connp->conn_lock);
1092 1093 if (connp->conn_dhcpinit_ill == ill) {
1093 1094 connp->conn_dhcpinit_ill = NULL;
1094 1095 ASSERT(ill->ill_dhcpinit != 0);
1095 1096 atomic_dec_32(&ill->ill_dhcpinit);
1096 1097 ill_set_inputfn(ill);
1097 1098 }
1098 1099 mutex_exit(&connp->conn_lock);
1099 1100 }
1100 1101
1101 1102 static int
1102 1103 ill_down_ipifs_tail(ill_t *ill)
1103 1104 {
1104 1105 ipif_t *ipif;
1105 1106 int err;
1106 1107
1107 1108 ASSERT(IAM_WRITER_ILL(ill));
1108 1109 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
1109 1110 ipif_non_duplicate(ipif);
1110 1111 /*
1111 1112 * ipif_down_tail will call arp_ll_down on the last ipif
1112 1113 * and typically return EINPROGRESS when the DL_UNBIND is sent.
1113 1114 */
1114 1115 if ((err = ipif_down_tail(ipif)) != 0)
1115 1116 return (err);
1116 1117 }
1117 1118 return (0);
1118 1119 }
1119 1120
1120 1121 /* ARGSUSED */
1121 1122 void
1122 1123 ipif_all_down_tail(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg)
1123 1124 {
1124 1125 ASSERT(IAM_WRITER_IPSQ(ipsq));
1125 1126 (void) ill_down_ipifs_tail(q->q_ptr);
1126 1127 freemsg(mp);
1127 1128 ipsq_current_finish(ipsq);
1128 1129 }
1129 1130
1130 1131 /*
1131 1132 * ill_down_start is called when we want to down this ill and bring it up again
1132 1133 * It is called when we receive an M_ERROR / M_HANGUP. In this case we shut down
1133 1134 * all interfaces, but don't tear down any plumbing.
1134 1135 */
1135 1136 boolean_t
1136 1137 ill_down_start(queue_t *q, mblk_t *mp)
1137 1138 {
1138 1139 ill_t *ill = q->q_ptr;
1139 1140 ipif_t *ipif;
1140 1141
1141 1142 ASSERT(IAM_WRITER_ILL(ill));
1142 1143 /*
1143 1144 * It is possible that some ioctl is already in progress while we
1144 1145 * received the M_ERROR / M_HANGUP in which case, we need to abort
1145 1146 * the ioctl. ill_down_start() is being processed as CUR_OP rather
1146 1147 * than as NEW_OP since the cause of the M_ERROR / M_HANGUP may prevent
1147 1148 * the in progress ioctl from ever completing.
1148 1149 *
1149 1150 * The thread that started the ioctl (if any) must have returned,
1150 1151 * since we are now executing as writer. After the 2 calls below,
1151 1152 * the state of the ipsq and the ill would reflect no trace of any
1152 1153 * pending operation. Subsequently if there is any response to the
1153 1154 * original ioctl from the driver, it would be discarded as an
1154 1155 * unsolicited message from the driver.
1155 1156 */
1156 1157 (void) ipsq_pending_mp_cleanup(ill, NULL);
1157 1158 ill_dlpi_clear_deferred(ill);
1158 1159
1159 1160 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
1160 1161 (void) ipif_down(ipif, NULL, NULL);
1161 1162
1162 1163 ill_down(ill);
1163 1164
1164 1165 /*
1165 1166 * Walk all CONNs that can have a reference on an ire or nce for this
1166 1167 * ill (we actually walk all that now have stale references).
1167 1168 */
1168 1169 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ill->ill_ipst);
1169 1170
1170 1171 /* With IPv6 we have dce_ifindex. Cleanup for neatness */
1171 1172 if (ill->ill_isv6)
1172 1173 dce_cleanup(ill->ill_phyint->phyint_ifindex, ill->ill_ipst);
1173 1174
1174 1175 ipsq_current_start(ill->ill_phyint->phyint_ipsq, ill->ill_ipif, 0);
1175 1176
1176 1177 /*
1177 1178 * Atomically test and add the pending mp if references are active.
1178 1179 */
1179 1180 mutex_enter(&ill->ill_lock);
1180 1181 if (!ill_is_quiescent(ill)) {
1181 1182 /* call cannot fail since `conn_t *' argument is NULL */
1182 1183 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
1183 1184 mp, ILL_DOWN);
1184 1185 mutex_exit(&ill->ill_lock);
1185 1186 return (B_FALSE);
1186 1187 }
1187 1188 mutex_exit(&ill->ill_lock);
1188 1189 return (B_TRUE);
1189 1190 }
1190 1191
1191 1192 static void
1192 1193 ill_down(ill_t *ill)
1193 1194 {
1194 1195 mblk_t *mp;
1195 1196 ip_stack_t *ipst = ill->ill_ipst;
1196 1197
1197 1198 /*
1198 1199 * Blow off any IREs dependent on this ILL.
1199 1200 * The caller needs to handle conn_ixa_cleanup
1200 1201 */
1201 1202 ill_delete_ires(ill);
1202 1203
1203 1204 ire_walk_ill(0, 0, ill_downi, ill, ill);
1204 1205
1205 1206 /* Remove any conn_*_ill depending on this ill */
1206 1207 ipcl_walk(conn_cleanup_ill, (caddr_t)ill, ipst);
1207 1208
1208 1209 /*
1209 1210 * Free state for additional IREs.
1210 1211 */
1211 1212 mutex_enter(&ill->ill_saved_ire_lock);
1212 1213 mp = ill->ill_saved_ire_mp;
1213 1214 ill->ill_saved_ire_mp = NULL;
1214 1215 ill->ill_saved_ire_cnt = 0;
1215 1216 mutex_exit(&ill->ill_saved_ire_lock);
1216 1217 freemsg(mp);
1217 1218 }
1218 1219
1219 1220 /*
1220 1221 * ire_walk routine used to delete every IRE that depends on
1221 1222 * 'ill'. (Always called as writer, and may only be called from ire_walk.)
1222 1223 *
1223 1224 * Note: since the routes added by the kernel are deleted separately,
1224 1225 * this will only be 1) IRE_IF_CLONE and 2) manually added IRE_INTERFACE.
1225 1226 *
1226 1227 * We also remove references on ire_nce_cache entries that refer to the ill.
1227 1228 */
1228 1229 void
1229 1230 ill_downi(ire_t *ire, char *ill_arg)
1230 1231 {
1231 1232 ill_t *ill = (ill_t *)ill_arg;
1232 1233 nce_t *nce;
1233 1234
1234 1235 mutex_enter(&ire->ire_lock);
1235 1236 nce = ire->ire_nce_cache;
1236 1237 if (nce != NULL && nce->nce_ill == ill)
1237 1238 ire->ire_nce_cache = NULL;
1238 1239 else
1239 1240 nce = NULL;
1240 1241 mutex_exit(&ire->ire_lock);
1241 1242 if (nce != NULL)
1242 1243 nce_refrele(nce);
1243 1244 if (ire->ire_ill == ill) {
1244 1245 /*
1245 1246 * The existing interface binding for ire must be
1246 1247 * deleted before trying to bind the route to another
1247 1248 * interface. However, since we are using the contents of the
1248 1249 * ire after ire_delete, the caller has to ensure that
1249 1250 * CONDEMNED (deleted) ire's are not removed from the list
1250 1251 * when ire_delete() returns. Currently ill_downi() is
1251 1252 * only called as part of ire_walk*() routines, so that
1252 1253 * the irb_refhold() done by ire_walk*() will ensure that
1253 1254 * ire_delete() does not lead to ire_inactive().
1254 1255 */
1255 1256 ASSERT(ire->ire_bucket->irb_refcnt > 0);
1256 1257 ire_delete(ire);
1257 1258 if (ire->ire_unbound)
1258 1259 ire_rebind(ire);
1259 1260 }
1260 1261 }
1261 1262
1262 1263 /* Remove IRE_IF_CLONE on this ill */
1263 1264 void
1264 1265 ill_downi_if_clone(ire_t *ire, char *ill_arg)
1265 1266 {
1266 1267 ill_t *ill = (ill_t *)ill_arg;
1267 1268
1268 1269 ASSERT(ire->ire_type & IRE_IF_CLONE);
1269 1270 if (ire->ire_ill == ill)
1270 1271 ire_delete(ire);
1271 1272 }
1272 1273
1273 1274 /* Consume an M_IOCACK of the fastpath probe. */
1274 1275 void
1275 1276 ill_fastpath_ack(ill_t *ill, mblk_t *mp)
1276 1277 {
1277 1278 mblk_t *mp1 = mp;
1278 1279
1279 1280 /*
1280 1281 * If this was the first attempt turn on the fastpath probing.
1281 1282 */
1282 1283 mutex_enter(&ill->ill_lock);
1283 1284 if (ill->ill_dlpi_fastpath_state == IDS_INPROGRESS)
1284 1285 ill->ill_dlpi_fastpath_state = IDS_OK;
1285 1286 mutex_exit(&ill->ill_lock);
1286 1287
1287 1288 /* Free the M_IOCACK mblk, hold on to the data */
1288 1289 mp = mp->b_cont;
1289 1290 freeb(mp1);
1290 1291 if (mp == NULL)
1291 1292 return;
1292 1293 if (mp->b_cont != NULL)
1293 1294 nce_fastpath_update(ill, mp);
1294 1295 else
1295 1296 ip0dbg(("ill_fastpath_ack: no b_cont\n"));
1296 1297 freemsg(mp);
1297 1298 }
1298 1299
1299 1300 /*
1300 1301 * Throw an M_IOCTL message downstream asking "do you know fastpath?"
1301 1302 * The data portion of the request is a dl_unitdata_req_t template for
1302 1303 * what we would send downstream in the absence of a fastpath confirmation.
1303 1304 */
1304 1305 int
1305 1306 ill_fastpath_probe(ill_t *ill, mblk_t *dlur_mp)
1306 1307 {
1307 1308 struct iocblk *ioc;
1308 1309 mblk_t *mp;
1309 1310
1310 1311 if (dlur_mp == NULL)
1311 1312 return (EINVAL);
1312 1313
1313 1314 mutex_enter(&ill->ill_lock);
1314 1315 switch (ill->ill_dlpi_fastpath_state) {
1315 1316 case IDS_FAILED:
1316 1317 /*
1317 1318 * Driver NAKed the first fastpath ioctl - assume it doesn't
1318 1319 * support it.
1319 1320 */
1320 1321 mutex_exit(&ill->ill_lock);
1321 1322 return (ENOTSUP);
1322 1323 case IDS_UNKNOWN:
1323 1324 /* This is the first probe */
1324 1325 ill->ill_dlpi_fastpath_state = IDS_INPROGRESS;
1325 1326 break;
1326 1327 default:
1327 1328 break;
1328 1329 }
1329 1330 mutex_exit(&ill->ill_lock);
1330 1331
1331 1332 if ((mp = mkiocb(DL_IOC_HDR_INFO)) == NULL)
1332 1333 return (EAGAIN);
1333 1334
1334 1335 mp->b_cont = copyb(dlur_mp);
1335 1336 if (mp->b_cont == NULL) {
1336 1337 freeb(mp);
1337 1338 return (EAGAIN);
1338 1339 }
1339 1340
1340 1341 ioc = (struct iocblk *)mp->b_rptr;
1341 1342 ioc->ioc_count = msgdsize(mp->b_cont);
1342 1343
1343 1344 DTRACE_PROBE3(ill__dlpi, char *, "ill_fastpath_probe",
1344 1345 char *, "DL_IOC_HDR_INFO", ill_t *, ill);
1345 1346 putnext(ill->ill_wq, mp);
1346 1347 return (0);
1347 1348 }
1348 1349
1349 1350 void
1350 1351 ill_capability_probe(ill_t *ill)
1351 1352 {
1352 1353 mblk_t *mp;
1353 1354
1354 1355 ASSERT(IAM_WRITER_ILL(ill));
1355 1356
1356 1357 if (ill->ill_dlpi_capab_state != IDCS_UNKNOWN &&
1357 1358 ill->ill_dlpi_capab_state != IDCS_FAILED)
1358 1359 return;
1359 1360
1360 1361 /*
1361 1362 * We are starting a new cycle of capability negotiation.
1362 1363 * Free up the capab reset messages of any previous incarnation.
1363 1364 * We will do a fresh allocation when we get the response to our probe
1364 1365 */
1365 1366 if (ill->ill_capab_reset_mp != NULL) {
1366 1367 freemsg(ill->ill_capab_reset_mp);
1367 1368 ill->ill_capab_reset_mp = NULL;
1368 1369 }
1369 1370
1370 1371 ip1dbg(("ill_capability_probe: starting capability negotiation\n"));
1371 1372
1372 1373 mp = ip_dlpi_alloc(sizeof (dl_capability_req_t), DL_CAPABILITY_REQ);
1373 1374 if (mp == NULL)
1374 1375 return;
1375 1376
1376 1377 ill_capability_send(ill, mp);
1377 1378 ill->ill_dlpi_capab_state = IDCS_PROBE_SENT;
1378 1379 }
1379 1380
1380 1381 void
1381 1382 ill_capability_reset(ill_t *ill, boolean_t reneg)
1382 1383 {
1383 1384 ASSERT(IAM_WRITER_ILL(ill));
1384 1385
1385 1386 if (ill->ill_dlpi_capab_state != IDCS_OK)
1386 1387 return;
1387 1388
1388 1389 ill->ill_dlpi_capab_state = reneg ? IDCS_RENEG : IDCS_RESET_SENT;
1389 1390
1390 1391 ill_capability_send(ill, ill->ill_capab_reset_mp);
1391 1392 ill->ill_capab_reset_mp = NULL;
1392 1393 /*
1393 1394 * We turn off all capabilities except those pertaining to
1394 1395 * direct function call capabilities viz. ILL_CAPAB_DLD*
1395 1396 * which will be turned off by the corresponding reset functions.
1396 1397 */
1397 1398 ill->ill_capabilities &= ~(ILL_CAPAB_HCKSUM | ILL_CAPAB_ZEROCOPY);
1398 1399 }
1399 1400
1400 1401 static void
1401 1402 ill_capability_reset_alloc(ill_t *ill)
1402 1403 {
1403 1404 mblk_t *mp;
1404 1405 size_t size = 0;
1405 1406 int err;
1406 1407 dl_capability_req_t *capb;
1407 1408
1408 1409 ASSERT(IAM_WRITER_ILL(ill));
1409 1410 ASSERT(ill->ill_capab_reset_mp == NULL);
1410 1411
1411 1412 if (ILL_HCKSUM_CAPABLE(ill)) {
1412 1413 size += sizeof (dl_capability_sub_t) +
1413 1414 sizeof (dl_capab_hcksum_t);
1414 1415 }
1415 1416
1416 1417 if (ill->ill_capabilities & ILL_CAPAB_ZEROCOPY) {
1417 1418 size += sizeof (dl_capability_sub_t) +
1418 1419 sizeof (dl_capab_zerocopy_t);
1419 1420 }
1420 1421
1421 1422 if (ill->ill_capabilities & ILL_CAPAB_DLD) {
1422 1423 size += sizeof (dl_capability_sub_t) +
1423 1424 sizeof (dl_capab_dld_t);
1424 1425 }
1425 1426
1426 1427 mp = allocb_wait(size + sizeof (dl_capability_req_t), BPRI_MED,
1427 1428 STR_NOSIG, &err);
1428 1429
1429 1430 mp->b_datap->db_type = M_PROTO;
1430 1431 bzero(mp->b_rptr, size + sizeof (dl_capability_req_t));
1431 1432
1432 1433 capb = (dl_capability_req_t *)mp->b_rptr;
1433 1434 capb->dl_primitive = DL_CAPABILITY_REQ;
1434 1435 capb->dl_sub_offset = sizeof (dl_capability_req_t);
1435 1436 capb->dl_sub_length = size;
1436 1437
1437 1438 mp->b_wptr += sizeof (dl_capability_req_t);
1438 1439
1439 1440 /*
1440 1441 * Each handler fills in the corresponding dl_capability_sub_t
1441 1442 * inside the mblk,
1442 1443 */
1443 1444 ill_capability_hcksum_reset_fill(ill, mp);
1444 1445 ill_capability_zerocopy_reset_fill(ill, mp);
1445 1446 ill_capability_dld_reset_fill(ill, mp);
1446 1447
1447 1448 ill->ill_capab_reset_mp = mp;
1448 1449 }
1449 1450
1450 1451 static void
1451 1452 ill_capability_id_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *outers)
1452 1453 {
1453 1454 dl_capab_id_t *id_ic;
1454 1455 uint_t sub_dl_cap = outers->dl_cap;
1455 1456 dl_capability_sub_t *inners;
1456 1457 uint8_t *capend;
1457 1458
1458 1459 ASSERT(sub_dl_cap == DL_CAPAB_ID_WRAPPER);
1459 1460
1460 1461 /*
1461 1462 * Note: range checks here are not absolutely sufficient to
1462 1463 * make us robust against malformed messages sent by drivers;
1463 1464 * this is in keeping with the rest of IP's dlpi handling.
1464 1465 * (Remember, it's coming from something else in the kernel
1465 1466 * address space)
1466 1467 */
1467 1468
1468 1469 capend = (uint8_t *)(outers + 1) + outers->dl_length;
1469 1470 if (capend > mp->b_wptr) {
1470 1471 cmn_err(CE_WARN, "ill_capability_id_ack: "
1471 1472 "malformed sub-capability too long for mblk");
1472 1473 return;
1473 1474 }
1474 1475
1475 1476 id_ic = (dl_capab_id_t *)(outers + 1);
1476 1477
1477 1478 if (outers->dl_length < sizeof (*id_ic) ||
1478 1479 (inners = &id_ic->id_subcap,
1479 1480 inners->dl_length > (outers->dl_length - sizeof (*inners)))) {
1480 1481 cmn_err(CE_WARN, "ill_capability_id_ack: malformed "
1481 1482 "encapsulated capab type %d too long for mblk",
1482 1483 inners->dl_cap);
1483 1484 return;
1484 1485 }
1485 1486
1486 1487 if (!dlcapabcheckqid(&id_ic->id_mid, ill->ill_lmod_rq)) {
1487 1488 ip1dbg(("ill_capability_id_ack: mid token for capab type %d "
1488 1489 "isn't as expected; pass-thru module(s) detected, "
1489 1490 "discarding capability\n", inners->dl_cap));
1490 1491 return;
1491 1492 }
1492 1493
1493 1494 /* Process the encapsulated sub-capability */
1494 1495 ill_capability_dispatch(ill, mp, inners);
1495 1496 }
1496 1497
1497 1498 static void
1498 1499 ill_capability_dld_reset_fill(ill_t *ill, mblk_t *mp)
1499 1500 {
1500 1501 dl_capability_sub_t *dl_subcap;
1501 1502
1502 1503 if (!(ill->ill_capabilities & ILL_CAPAB_DLD))
1503 1504 return;
1504 1505
1505 1506 /*
1506 1507 * The dl_capab_dld_t that follows the dl_capability_sub_t is not
1507 1508 * initialized below since it is not used by DLD.
1508 1509 */
1509 1510 dl_subcap = (dl_capability_sub_t *)mp->b_wptr;
1510 1511 dl_subcap->dl_cap = DL_CAPAB_DLD;
1511 1512 dl_subcap->dl_length = sizeof (dl_capab_dld_t);
1512 1513
1513 1514 mp->b_wptr += sizeof (dl_capability_sub_t) + sizeof (dl_capab_dld_t);
1514 1515 }
1515 1516
1516 1517 static void
1517 1518 ill_capability_dispatch(ill_t *ill, mblk_t *mp, dl_capability_sub_t *subp)
1518 1519 {
1519 1520 /*
1520 1521 * If no ipif was brought up over this ill, this DL_CAPABILITY_REQ/ACK
1521 1522 * is only to get the VRRP capability.
1522 1523 *
1523 1524 * Note that we cannot check ill_ipif_up_count here since
1524 1525 * ill_ipif_up_count is only incremented when the resolver is setup.
1525 1526 * That is done asynchronously, and can race with this function.
1526 1527 */
1527 1528 if (!ill->ill_dl_up) {
1528 1529 if (subp->dl_cap == DL_CAPAB_VRRP)
1529 1530 ill_capability_vrrp_ack(ill, mp, subp);
1530 1531 return;
1531 1532 }
1532 1533
1533 1534 switch (subp->dl_cap) {
1534 1535 case DL_CAPAB_HCKSUM:
1535 1536 ill_capability_hcksum_ack(ill, mp, subp);
1536 1537 break;
1537 1538 case DL_CAPAB_ZEROCOPY:
1538 1539 ill_capability_zerocopy_ack(ill, mp, subp);
1539 1540 break;
1540 1541 case DL_CAPAB_DLD:
1541 1542 ill_capability_dld_ack(ill, mp, subp);
1542 1543 break;
1543 1544 case DL_CAPAB_VRRP:
1544 1545 break;
1545 1546 default:
1546 1547 ip1dbg(("ill_capability_dispatch: unknown capab type %d\n",
1547 1548 subp->dl_cap));
1548 1549 }
1549 1550 }
1550 1551
1551 1552 /*
1552 1553 * Process the vrrp capability received from a DLS Provider. isub must point
1553 1554 * to the sub-capability (DL_CAPAB_VRRP) of a DL_CAPABILITY_ACK message.
1554 1555 */
1555 1556 static void
1556 1557 ill_capability_vrrp_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1557 1558 {
1558 1559 dl_capab_vrrp_t *vrrp;
1559 1560 uint_t sub_dl_cap = isub->dl_cap;
1560 1561 uint8_t *capend;
1561 1562
1562 1563 ASSERT(IAM_WRITER_ILL(ill));
1563 1564 ASSERT(sub_dl_cap == DL_CAPAB_VRRP);
1564 1565
1565 1566 /*
1566 1567 * Note: range checks here are not absolutely sufficient to
1567 1568 * make us robust against malformed messages sent by drivers;
1568 1569 * this is in keeping with the rest of IP's dlpi handling.
1569 1570 * (Remember, it's coming from something else in the kernel
1570 1571 * address space)
1571 1572 */
1572 1573 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1573 1574 if (capend > mp->b_wptr) {
1574 1575 cmn_err(CE_WARN, "ill_capability_vrrp_ack: "
1575 1576 "malformed sub-capability too long for mblk");
1576 1577 return;
1577 1578 }
1578 1579 vrrp = (dl_capab_vrrp_t *)(isub + 1);
1579 1580
1580 1581 /*
1581 1582 * Compare the IP address family and set ILLF_VRRP for the right ill.
1582 1583 */
1583 1584 if ((vrrp->vrrp_af == AF_INET6 && ill->ill_isv6) ||
1584 1585 (vrrp->vrrp_af == AF_INET && !ill->ill_isv6)) {
1585 1586 ill->ill_flags |= ILLF_VRRP;
1586 1587 }
1587 1588 }
1588 1589
1589 1590 /*
1590 1591 * Process a hardware checksum offload capability negotiation ack received
1591 1592 * from a DLS Provider.isub must point to the sub-capability (DL_CAPAB_HCKSUM)
1592 1593 * of a DL_CAPABILITY_ACK message.
1593 1594 */
1594 1595 static void
1595 1596 ill_capability_hcksum_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1596 1597 {
1597 1598 dl_capability_req_t *ocap;
1598 1599 dl_capab_hcksum_t *ihck, *ohck;
1599 1600 ill_hcksum_capab_t **ill_hcksum;
1600 1601 mblk_t *nmp = NULL;
1601 1602 uint_t sub_dl_cap = isub->dl_cap;
1602 1603 uint8_t *capend;
1603 1604
1604 1605 ASSERT(sub_dl_cap == DL_CAPAB_HCKSUM);
1605 1606
1606 1607 ill_hcksum = (ill_hcksum_capab_t **)&ill->ill_hcksum_capab;
1607 1608
1608 1609 /*
1609 1610 * Note: range checks here are not absolutely sufficient to
1610 1611 * make us robust against malformed messages sent by drivers;
1611 1612 * this is in keeping with the rest of IP's dlpi handling.
1612 1613 * (Remember, it's coming from something else in the kernel
1613 1614 * address space)
1614 1615 */
1615 1616 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1616 1617 if (capend > mp->b_wptr) {
1617 1618 cmn_err(CE_WARN, "ill_capability_hcksum_ack: "
1618 1619 "malformed sub-capability too long for mblk");
1619 1620 return;
1620 1621 }
1621 1622
1622 1623 /*
1623 1624 * There are two types of acks we process here:
1624 1625 * 1. acks in reply to a (first form) generic capability req
1625 1626 * (no ENABLE flag set)
1626 1627 * 2. acks in reply to a ENABLE capability req.
1627 1628 * (ENABLE flag set)
1628 1629 */
1629 1630 ihck = (dl_capab_hcksum_t *)(isub + 1);
1630 1631
1631 1632 if (ihck->hcksum_version != HCKSUM_VERSION_1) {
1632 1633 cmn_err(CE_CONT, "ill_capability_hcksum_ack: "
1633 1634 "unsupported hardware checksum "
1634 1635 "sub-capability (version %d, expected %d)",
1635 1636 ihck->hcksum_version, HCKSUM_VERSION_1);
1636 1637 return;
1637 1638 }
1638 1639
1639 1640 if (!dlcapabcheckqid(&ihck->hcksum_mid, ill->ill_lmod_rq)) {
1640 1641 ip1dbg(("ill_capability_hcksum_ack: mid token for hardware "
1641 1642 "checksum capability isn't as expected; pass-thru "
1642 1643 "module(s) detected, discarding capability\n"));
1643 1644 return;
1644 1645 }
1645 1646
1646 1647 #define CURR_HCKSUM_CAPAB \
1647 1648 (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 | \
1648 1649 HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM)
1649 1650
1650 1651 if ((ihck->hcksum_txflags & HCKSUM_ENABLE) &&
1651 1652 (ihck->hcksum_txflags & CURR_HCKSUM_CAPAB)) {
1652 1653 /* do ENABLE processing */
1653 1654 if (*ill_hcksum == NULL) {
1654 1655 *ill_hcksum = kmem_zalloc(sizeof (ill_hcksum_capab_t),
1655 1656 KM_NOSLEEP);
1656 1657
1657 1658 if (*ill_hcksum == NULL) {
1658 1659 cmn_err(CE_WARN, "ill_capability_hcksum_ack: "
1659 1660 "could not enable hcksum version %d "
1660 1661 "for %s (ENOMEM)\n", HCKSUM_CURRENT_VERSION,
1661 1662 ill->ill_name);
1662 1663 return;
1663 1664 }
1664 1665 }
1665 1666
1666 1667 (*ill_hcksum)->ill_hcksum_version = ihck->hcksum_version;
1667 1668 (*ill_hcksum)->ill_hcksum_txflags = ihck->hcksum_txflags;
1668 1669 ill->ill_capabilities |= ILL_CAPAB_HCKSUM;
1669 1670 ip1dbg(("ill_capability_hcksum_ack: interface %s "
1670 1671 "has enabled hardware checksumming\n ",
1671 1672 ill->ill_name));
1672 1673 } else if (ihck->hcksum_txflags & CURR_HCKSUM_CAPAB) {
1673 1674 /*
1674 1675 * Enabling hardware checksum offload
1675 1676 * Currently IP supports {TCP,UDP}/IPv4
1676 1677 * partial and full cksum offload and
1677 1678 * IPv4 header checksum offload.
1678 1679 * Allocate new mblk which will
1679 1680 * contain a new capability request
1680 1681 * to enable hardware checksum offload.
1681 1682 */
1682 1683 uint_t size;
1683 1684 uchar_t *rptr;
1684 1685
1685 1686 size = sizeof (dl_capability_req_t) +
1686 1687 sizeof (dl_capability_sub_t) + isub->dl_length;
1687 1688
1688 1689 if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) {
1689 1690 cmn_err(CE_WARN, "ill_capability_hcksum_ack: "
1690 1691 "could not enable hardware cksum for %s (ENOMEM)\n",
1691 1692 ill->ill_name);
1692 1693 return;
1693 1694 }
1694 1695
1695 1696 rptr = nmp->b_rptr;
1696 1697 /* initialize dl_capability_req_t */
1697 1698 ocap = (dl_capability_req_t *)nmp->b_rptr;
1698 1699 ocap->dl_sub_offset =
1699 1700 sizeof (dl_capability_req_t);
1700 1701 ocap->dl_sub_length =
1701 1702 sizeof (dl_capability_sub_t) +
1702 1703 isub->dl_length;
1703 1704 nmp->b_rptr += sizeof (dl_capability_req_t);
1704 1705
1705 1706 /* initialize dl_capability_sub_t */
1706 1707 bcopy(isub, nmp->b_rptr, sizeof (*isub));
1707 1708 nmp->b_rptr += sizeof (*isub);
1708 1709
1709 1710 /* initialize dl_capab_hcksum_t */
1710 1711 ohck = (dl_capab_hcksum_t *)nmp->b_rptr;
1711 1712 bcopy(ihck, ohck, sizeof (*ihck));
1712 1713
1713 1714 nmp->b_rptr = rptr;
1714 1715 ASSERT(nmp->b_wptr == (nmp->b_rptr + size));
1715 1716
1716 1717 /* Set ENABLE flag */
1717 1718 ohck->hcksum_txflags &= CURR_HCKSUM_CAPAB;
1718 1719 ohck->hcksum_txflags |= HCKSUM_ENABLE;
1719 1720
1720 1721 /*
1721 1722 * nmp points to a DL_CAPABILITY_REQ message to enable
1722 1723 * hardware checksum acceleration.
1723 1724 */
1724 1725 ill_capability_send(ill, nmp);
1725 1726 } else {
1726 1727 ip1dbg(("ill_capability_hcksum_ack: interface %s has "
1727 1728 "advertised %x hardware checksum capability flags\n",
1728 1729 ill->ill_name, ihck->hcksum_txflags));
1729 1730 }
1730 1731 }
1731 1732
1732 1733 static void
1733 1734 ill_capability_hcksum_reset_fill(ill_t *ill, mblk_t *mp)
1734 1735 {
1735 1736 dl_capab_hcksum_t *hck_subcap;
1736 1737 dl_capability_sub_t *dl_subcap;
1737 1738
1738 1739 if (!ILL_HCKSUM_CAPABLE(ill))
1739 1740 return;
1740 1741
1741 1742 ASSERT(ill->ill_hcksum_capab != NULL);
1742 1743
1743 1744 dl_subcap = (dl_capability_sub_t *)mp->b_wptr;
1744 1745 dl_subcap->dl_cap = DL_CAPAB_HCKSUM;
1745 1746 dl_subcap->dl_length = sizeof (*hck_subcap);
1746 1747
1747 1748 hck_subcap = (dl_capab_hcksum_t *)(dl_subcap + 1);
1748 1749 hck_subcap->hcksum_version = ill->ill_hcksum_capab->ill_hcksum_version;
1749 1750 hck_subcap->hcksum_txflags = 0;
1750 1751
1751 1752 mp->b_wptr += sizeof (*dl_subcap) + sizeof (*hck_subcap);
1752 1753 }
1753 1754
1754 1755 static void
1755 1756 ill_capability_zerocopy_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1756 1757 {
1757 1758 mblk_t *nmp = NULL;
1758 1759 dl_capability_req_t *oc;
1759 1760 dl_capab_zerocopy_t *zc_ic, *zc_oc;
1760 1761 ill_zerocopy_capab_t **ill_zerocopy_capab;
1761 1762 uint_t sub_dl_cap = isub->dl_cap;
1762 1763 uint8_t *capend;
1763 1764
1764 1765 ASSERT(sub_dl_cap == DL_CAPAB_ZEROCOPY);
1765 1766
1766 1767 ill_zerocopy_capab = (ill_zerocopy_capab_t **)&ill->ill_zerocopy_capab;
1767 1768
1768 1769 /*
1769 1770 * Note: range checks here are not absolutely sufficient to
1770 1771 * make us robust against malformed messages sent by drivers;
1771 1772 * this is in keeping with the rest of IP's dlpi handling.
1772 1773 * (Remember, it's coming from something else in the kernel
1773 1774 * address space)
1774 1775 */
1775 1776 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1776 1777 if (capend > mp->b_wptr) {
1777 1778 cmn_err(CE_WARN, "ill_capability_zerocopy_ack: "
1778 1779 "malformed sub-capability too long for mblk");
1779 1780 return;
1780 1781 }
1781 1782
1782 1783 zc_ic = (dl_capab_zerocopy_t *)(isub + 1);
1783 1784 if (zc_ic->zerocopy_version != ZEROCOPY_VERSION_1) {
1784 1785 cmn_err(CE_CONT, "ill_capability_zerocopy_ack: "
1785 1786 "unsupported ZEROCOPY sub-capability (version %d, "
1786 1787 "expected %d)", zc_ic->zerocopy_version,
1787 1788 ZEROCOPY_VERSION_1);
1788 1789 return;
1789 1790 }
1790 1791
1791 1792 if (!dlcapabcheckqid(&zc_ic->zerocopy_mid, ill->ill_lmod_rq)) {
1792 1793 ip1dbg(("ill_capability_zerocopy_ack: mid token for zerocopy "
1793 1794 "capability isn't as expected; pass-thru module(s) "
1794 1795 "detected, discarding capability\n"));
1795 1796 return;
1796 1797 }
1797 1798
1798 1799 if ((zc_ic->zerocopy_flags & DL_CAPAB_VMSAFE_MEM) != 0) {
1799 1800 if (*ill_zerocopy_capab == NULL) {
1800 1801 *ill_zerocopy_capab =
1801 1802 kmem_zalloc(sizeof (ill_zerocopy_capab_t),
1802 1803 KM_NOSLEEP);
1803 1804
1804 1805 if (*ill_zerocopy_capab == NULL) {
1805 1806 cmn_err(CE_WARN, "ill_capability_zerocopy_ack: "
1806 1807 "could not enable Zero-copy version %d "
1807 1808 "for %s (ENOMEM)\n", ZEROCOPY_VERSION_1,
1808 1809 ill->ill_name);
1809 1810 return;
1810 1811 }
1811 1812 }
1812 1813
1813 1814 ip1dbg(("ill_capability_zerocopy_ack: interface %s "
1814 1815 "supports Zero-copy version %d\n", ill->ill_name,
1815 1816 ZEROCOPY_VERSION_1));
1816 1817
1817 1818 (*ill_zerocopy_capab)->ill_zerocopy_version =
1818 1819 zc_ic->zerocopy_version;
1819 1820 (*ill_zerocopy_capab)->ill_zerocopy_flags =
1820 1821 zc_ic->zerocopy_flags;
1821 1822
1822 1823 ill->ill_capabilities |= ILL_CAPAB_ZEROCOPY;
1823 1824 } else {
1824 1825 uint_t size;
1825 1826 uchar_t *rptr;
1826 1827
1827 1828 size = sizeof (dl_capability_req_t) +
1828 1829 sizeof (dl_capability_sub_t) +
1829 1830 sizeof (dl_capab_zerocopy_t);
1830 1831
1831 1832 if ((nmp = ip_dlpi_alloc(size, DL_CAPABILITY_REQ)) == NULL) {
1832 1833 cmn_err(CE_WARN, "ill_capability_zerocopy_ack: "
1833 1834 "could not enable zerocopy for %s (ENOMEM)\n",
1834 1835 ill->ill_name);
1835 1836 return;
1836 1837 }
1837 1838
1838 1839 rptr = nmp->b_rptr;
1839 1840 /* initialize dl_capability_req_t */
1840 1841 oc = (dl_capability_req_t *)rptr;
1841 1842 oc->dl_sub_offset = sizeof (dl_capability_req_t);
1842 1843 oc->dl_sub_length = sizeof (dl_capability_sub_t) +
1843 1844 sizeof (dl_capab_zerocopy_t);
1844 1845 rptr += sizeof (dl_capability_req_t);
1845 1846
1846 1847 /* initialize dl_capability_sub_t */
1847 1848 bcopy(isub, rptr, sizeof (*isub));
1848 1849 rptr += sizeof (*isub);
1849 1850
1850 1851 /* initialize dl_capab_zerocopy_t */
1851 1852 zc_oc = (dl_capab_zerocopy_t *)rptr;
1852 1853 *zc_oc = *zc_ic;
1853 1854
1854 1855 ip1dbg(("ill_capability_zerocopy_ack: asking interface %s "
1855 1856 "to enable zero-copy version %d\n", ill->ill_name,
1856 1857 ZEROCOPY_VERSION_1));
1857 1858
1858 1859 /* set VMSAFE_MEM flag */
1859 1860 zc_oc->zerocopy_flags |= DL_CAPAB_VMSAFE_MEM;
1860 1861
1861 1862 /* nmp points to a DL_CAPABILITY_REQ message to enable zcopy */
1862 1863 ill_capability_send(ill, nmp);
1863 1864 }
1864 1865 }
1865 1866
1866 1867 static void
1867 1868 ill_capability_zerocopy_reset_fill(ill_t *ill, mblk_t *mp)
1868 1869 {
1869 1870 dl_capab_zerocopy_t *zerocopy_subcap;
1870 1871 dl_capability_sub_t *dl_subcap;
1871 1872
1872 1873 if (!(ill->ill_capabilities & ILL_CAPAB_ZEROCOPY))
1873 1874 return;
1874 1875
1875 1876 ASSERT(ill->ill_zerocopy_capab != NULL);
1876 1877
1877 1878 dl_subcap = (dl_capability_sub_t *)mp->b_wptr;
1878 1879 dl_subcap->dl_cap = DL_CAPAB_ZEROCOPY;
1879 1880 dl_subcap->dl_length = sizeof (*zerocopy_subcap);
1880 1881
1881 1882 zerocopy_subcap = (dl_capab_zerocopy_t *)(dl_subcap + 1);
1882 1883 zerocopy_subcap->zerocopy_version =
1883 1884 ill->ill_zerocopy_capab->ill_zerocopy_version;
1884 1885 zerocopy_subcap->zerocopy_flags = 0;
1885 1886
1886 1887 mp->b_wptr += sizeof (*dl_subcap) + sizeof (*zerocopy_subcap);
1887 1888 }
1888 1889
1889 1890 /*
1890 1891 * DLD capability
1891 1892 * Refer to dld.h for more information regarding the purpose and usage
1892 1893 * of this capability.
1893 1894 */
1894 1895 static void
1895 1896 ill_capability_dld_ack(ill_t *ill, mblk_t *mp, dl_capability_sub_t *isub)
1896 1897 {
1897 1898 dl_capab_dld_t *dld_ic, dld;
1898 1899 uint_t sub_dl_cap = isub->dl_cap;
1899 1900 uint8_t *capend;
1900 1901 ill_dld_capab_t *idc;
1901 1902
1902 1903 ASSERT(IAM_WRITER_ILL(ill));
1903 1904 ASSERT(sub_dl_cap == DL_CAPAB_DLD);
1904 1905
1905 1906 /*
1906 1907 * Note: range checks here are not absolutely sufficient to
1907 1908 * make us robust against malformed messages sent by drivers;
1908 1909 * this is in keeping with the rest of IP's dlpi handling.
1909 1910 * (Remember, it's coming from something else in the kernel
1910 1911 * address space)
1911 1912 */
1912 1913 capend = (uint8_t *)(isub + 1) + isub->dl_length;
1913 1914 if (capend > mp->b_wptr) {
1914 1915 cmn_err(CE_WARN, "ill_capability_dld_ack: "
1915 1916 "malformed sub-capability too long for mblk");
1916 1917 return;
1917 1918 }
1918 1919 dld_ic = (dl_capab_dld_t *)(isub + 1);
1919 1920 if (dld_ic->dld_version != DLD_CURRENT_VERSION) {
1920 1921 cmn_err(CE_CONT, "ill_capability_dld_ack: "
1921 1922 "unsupported DLD sub-capability (version %d, "
1922 1923 "expected %d)", dld_ic->dld_version,
1923 1924 DLD_CURRENT_VERSION);
1924 1925 return;
1925 1926 }
1926 1927 if (!dlcapabcheckqid(&dld_ic->dld_mid, ill->ill_lmod_rq)) {
1927 1928 ip1dbg(("ill_capability_dld_ack: mid token for dld "
1928 1929 "capability isn't as expected; pass-thru module(s) "
1929 1930 "detected, discarding capability\n"));
1930 1931 return;
1931 1932 }
1932 1933
1933 1934 /*
1934 1935 * Copy locally to ensure alignment.
1935 1936 */
1936 1937 bcopy(dld_ic, &dld, sizeof (dl_capab_dld_t));
1937 1938
1938 1939 if ((idc = ill->ill_dld_capab) == NULL) {
1939 1940 idc = kmem_zalloc(sizeof (ill_dld_capab_t), KM_NOSLEEP);
1940 1941 if (idc == NULL) {
1941 1942 cmn_err(CE_WARN, "ill_capability_dld_ack: "
1942 1943 "could not enable DLD version %d "
1943 1944 "for %s (ENOMEM)\n", DLD_CURRENT_VERSION,
1944 1945 ill->ill_name);
1945 1946 return;
1946 1947 }
1947 1948 ill->ill_dld_capab = idc;
1948 1949 }
1949 1950 idc->idc_capab_df = (ip_capab_func_t)dld.dld_capab;
1950 1951 idc->idc_capab_dh = (void *)dld.dld_capab_handle;
1951 1952 ip1dbg(("ill_capability_dld_ack: interface %s "
1952 1953 "supports DLD version %d\n", ill->ill_name, DLD_CURRENT_VERSION));
1953 1954
1954 1955 ill_capability_dld_enable(ill);
1955 1956 }
1956 1957
1957 1958 /*
1958 1959 * Typically capability negotiation between IP and the driver happens via
1959 1960 * DLPI message exchange. However GLD also offers a direct function call
1960 1961 * mechanism to exchange the DLD_DIRECT_CAPAB and DLD_POLL_CAPAB capabilities,
1961 1962 * But arbitrary function calls into IP or GLD are not permitted, since both
1962 1963 * of them are protected by their own perimeter mechanism. The perimeter can
1963 1964 * be viewed as a coarse lock or serialization mechanism. The hierarchy of
1964 1965 * these perimeters is IP -> MAC. Thus for example to enable the squeue
1965 1966 * polling, IP needs to enter its perimeter, then call ill_mac_perim_enter
1966 1967 * to enter the mac perimeter and then do the direct function calls into
1967 1968 * GLD to enable squeue polling. The ring related callbacks from the mac into
1968 1969 * the stack to add, bind, quiesce, restart or cleanup a ring are all
1969 1970 * protected by the mac perimeter.
1970 1971 */
1971 1972 static void
1972 1973 ill_mac_perim_enter(ill_t *ill, mac_perim_handle_t *mphp)
1973 1974 {
1974 1975 ill_dld_capab_t *idc = ill->ill_dld_capab;
1975 1976 int err;
1976 1977
1977 1978 err = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_PERIM, mphp,
1978 1979 DLD_ENABLE);
1979 1980 ASSERT(err == 0);
1980 1981 }
1981 1982
1982 1983 static void
1983 1984 ill_mac_perim_exit(ill_t *ill, mac_perim_handle_t mph)
1984 1985 {
1985 1986 ill_dld_capab_t *idc = ill->ill_dld_capab;
1986 1987 int err;
1987 1988
1988 1989 err = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_PERIM, mph,
1989 1990 DLD_DISABLE);
1990 1991 ASSERT(err == 0);
1991 1992 }
1992 1993
1993 1994 boolean_t
1994 1995 ill_mac_perim_held(ill_t *ill)
1995 1996 {
1996 1997 ill_dld_capab_t *idc = ill->ill_dld_capab;
1997 1998
1998 1999 return (idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_PERIM, NULL,
1999 2000 DLD_QUERY));
2000 2001 }
2001 2002
2002 2003 static void
2003 2004 ill_capability_direct_enable(ill_t *ill)
2004 2005 {
2005 2006 ill_dld_capab_t *idc = ill->ill_dld_capab;
2006 2007 ill_dld_direct_t *idd = &idc->idc_direct;
2007 2008 dld_capab_direct_t direct;
2008 2009 int rc;
2009 2010
2010 2011 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2011 2012
2012 2013 bzero(&direct, sizeof (direct));
2013 2014 direct.di_rx_cf = (uintptr_t)ip_input;
2014 2015 direct.di_rx_ch = ill;
2015 2016
2016 2017 rc = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_DIRECT, &direct,
2017 2018 DLD_ENABLE);
2018 2019 if (rc == 0) {
2019 2020 idd->idd_tx_df = (ip_dld_tx_t)direct.di_tx_df;
2020 2021 idd->idd_tx_dh = direct.di_tx_dh;
2021 2022 idd->idd_tx_cb_df = (ip_dld_callb_t)direct.di_tx_cb_df;
2022 2023 idd->idd_tx_cb_dh = direct.di_tx_cb_dh;
2023 2024 idd->idd_tx_fctl_df = (ip_dld_fctl_t)direct.di_tx_fctl_df;
2024 2025 idd->idd_tx_fctl_dh = direct.di_tx_fctl_dh;
2025 2026 ASSERT(idd->idd_tx_cb_df != NULL);
2026 2027 ASSERT(idd->idd_tx_fctl_df != NULL);
2027 2028 ASSERT(idd->idd_tx_df != NULL);
2028 2029 /*
2029 2030 * One time registration of flow enable callback function
2030 2031 */
2031 2032 ill->ill_flownotify_mh = idd->idd_tx_cb_df(idd->idd_tx_cb_dh,
2032 2033 ill_flow_enable, ill);
2033 2034 ill->ill_capabilities |= ILL_CAPAB_DLD_DIRECT;
2034 2035 DTRACE_PROBE1(direct_on, (ill_t *), ill);
2035 2036 } else {
2036 2037 cmn_err(CE_WARN, "warning: could not enable DIRECT "
2037 2038 "capability, rc = %d\n", rc);
2038 2039 DTRACE_PROBE2(direct_off, (ill_t *), ill, (int), rc);
2039 2040 }
2040 2041 }
2041 2042
2042 2043 static void
2043 2044 ill_capability_poll_enable(ill_t *ill)
2044 2045 {
2045 2046 ill_dld_capab_t *idc = ill->ill_dld_capab;
2046 2047 dld_capab_poll_t poll;
2047 2048 int rc;
2048 2049
2049 2050 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2050 2051
2051 2052 bzero(&poll, sizeof (poll));
2052 2053 poll.poll_ring_add_cf = (uintptr_t)ip_squeue_add_ring;
2053 2054 poll.poll_ring_remove_cf = (uintptr_t)ip_squeue_clean_ring;
2054 2055 poll.poll_ring_quiesce_cf = (uintptr_t)ip_squeue_quiesce_ring;
2055 2056 poll.poll_ring_restart_cf = (uintptr_t)ip_squeue_restart_ring;
2056 2057 poll.poll_ring_bind_cf = (uintptr_t)ip_squeue_bind_ring;
2057 2058 poll.poll_ring_ch = ill;
2058 2059 rc = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_POLL, &poll,
2059 2060 DLD_ENABLE);
2060 2061 if (rc == 0) {
2061 2062 ill->ill_capabilities |= ILL_CAPAB_DLD_POLL;
2062 2063 DTRACE_PROBE1(poll_on, (ill_t *), ill);
2063 2064 } else {
2064 2065 ip1dbg(("warning: could not enable POLL "
2065 2066 "capability, rc = %d\n", rc));
2066 2067 DTRACE_PROBE2(poll_off, (ill_t *), ill, (int), rc);
2067 2068 }
2068 2069 }
2069 2070
2070 2071 /*
2071 2072 * Enable the LSO capability.
2072 2073 */
2073 2074 static void
2074 2075 ill_capability_lso_enable(ill_t *ill)
2075 2076 {
2076 2077 ill_dld_capab_t *idc = ill->ill_dld_capab;
2077 2078 dld_capab_lso_t lso;
2078 2079 int rc;
2079 2080
2080 2081 ASSERT(!ill->ill_isv6 && IAM_WRITER_ILL(ill));
2081 2082
2082 2083 if (ill->ill_lso_capab == NULL) {
2083 2084 ill->ill_lso_capab = kmem_zalloc(sizeof (ill_lso_capab_t),
2084 2085 KM_NOSLEEP);
2085 2086 if (ill->ill_lso_capab == NULL) {
2086 2087 cmn_err(CE_WARN, "ill_capability_lso_enable: "
2087 2088 "could not enable LSO for %s (ENOMEM)\n",
2088 2089 ill->ill_name);
2089 2090 return;
2090 2091 }
2091 2092 }
2092 2093
2093 2094 bzero(&lso, sizeof (lso));
2094 2095 if ((rc = idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_LSO, &lso,
2095 2096 DLD_ENABLE)) == 0) {
2096 2097 ill->ill_lso_capab->ill_lso_flags = lso.lso_flags;
2097 2098 ill->ill_lso_capab->ill_lso_max = lso.lso_max;
2098 2099 ill->ill_capabilities |= ILL_CAPAB_LSO;
2099 2100 ip1dbg(("ill_capability_lso_enable: interface %s "
2100 2101 "has enabled LSO\n ", ill->ill_name));
2101 2102 } else {
2102 2103 kmem_free(ill->ill_lso_capab, sizeof (ill_lso_capab_t));
2103 2104 ill->ill_lso_capab = NULL;
2104 2105 DTRACE_PROBE2(lso_off, (ill_t *), ill, (int), rc);
2105 2106 }
2106 2107 }
2107 2108
2108 2109 static void
2109 2110 ill_capability_dld_enable(ill_t *ill)
2110 2111 {
2111 2112 mac_perim_handle_t mph;
2112 2113
2113 2114 ASSERT(IAM_WRITER_ILL(ill));
2114 2115
2115 2116 if (ill->ill_isv6)
2116 2117 return;
2117 2118
2118 2119 ill_mac_perim_enter(ill, &mph);
2119 2120 if (!ill->ill_isv6) {
2120 2121 ill_capability_direct_enable(ill);
2121 2122 ill_capability_poll_enable(ill);
2122 2123 ill_capability_lso_enable(ill);
2123 2124 }
2124 2125 ill->ill_capabilities |= ILL_CAPAB_DLD;
2125 2126 ill_mac_perim_exit(ill, mph);
2126 2127 }
2127 2128
2128 2129 static void
2129 2130 ill_capability_dld_disable(ill_t *ill)
2130 2131 {
2131 2132 ill_dld_capab_t *idc;
2132 2133 ill_dld_direct_t *idd;
2133 2134 mac_perim_handle_t mph;
2134 2135
2135 2136 ASSERT(IAM_WRITER_ILL(ill));
2136 2137
2137 2138 if (!(ill->ill_capabilities & ILL_CAPAB_DLD))
2138 2139 return;
2139 2140
2140 2141 ill_mac_perim_enter(ill, &mph);
2141 2142
2142 2143 idc = ill->ill_dld_capab;
2143 2144 if ((ill->ill_capabilities & ILL_CAPAB_DLD_DIRECT) != 0) {
2144 2145 /*
2145 2146 * For performance we avoid locks in the transmit data path
2146 2147 * and don't maintain a count of the number of threads using
2147 2148 * direct calls. Thus some threads could be using direct
2148 2149 * transmit calls to GLD, even after the capability mechanism
2149 2150 * turns it off. This is still safe since the handles used in
2150 2151 * the direct calls continue to be valid until the unplumb is
2151 2152 * completed. Remove the callback that was added (1-time) at
2152 2153 * capab enable time.
2153 2154 */
2154 2155 mutex_enter(&ill->ill_lock);
2155 2156 ill->ill_capabilities &= ~ILL_CAPAB_DLD_DIRECT;
2156 2157 mutex_exit(&ill->ill_lock);
2157 2158 if (ill->ill_flownotify_mh != NULL) {
2158 2159 idd = &idc->idc_direct;
2159 2160 idd->idd_tx_cb_df(idd->idd_tx_cb_dh, NULL,
2160 2161 ill->ill_flownotify_mh);
2161 2162 ill->ill_flownotify_mh = NULL;
2162 2163 }
2163 2164 (void) idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_DIRECT,
2164 2165 NULL, DLD_DISABLE);
2165 2166 }
2166 2167
2167 2168 if ((ill->ill_capabilities & ILL_CAPAB_DLD_POLL) != 0) {
2168 2169 ill->ill_capabilities &= ~ILL_CAPAB_DLD_POLL;
2169 2170 ip_squeue_clean_all(ill);
2170 2171 (void) idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_POLL,
2171 2172 NULL, DLD_DISABLE);
2172 2173 }
2173 2174
2174 2175 if ((ill->ill_capabilities & ILL_CAPAB_LSO) != 0) {
2175 2176 ASSERT(ill->ill_lso_capab != NULL);
2176 2177 /*
2177 2178 * Clear the capability flag for LSO but retain the
2178 2179 * ill_lso_capab structure since it's possible that another
2179 2180 * thread is still referring to it. The structure only gets
2180 2181 * deallocated when we destroy the ill.
2181 2182 */
2182 2183
2183 2184 ill->ill_capabilities &= ~ILL_CAPAB_LSO;
2184 2185 (void) idc->idc_capab_df(idc->idc_capab_dh, DLD_CAPAB_LSO,
2185 2186 NULL, DLD_DISABLE);
2186 2187 }
2187 2188
2188 2189 ill->ill_capabilities &= ~ILL_CAPAB_DLD;
2189 2190 ill_mac_perim_exit(ill, mph);
2190 2191 }
2191 2192
2192 2193 /*
2193 2194 * Capability Negotiation protocol
2194 2195 *
2195 2196 * We don't wait for DLPI capability operations to finish during interface
2196 2197 * bringup or teardown. Doing so would introduce more asynchrony and the
2197 2198 * interface up/down operations will need multiple return and restarts.
2198 2199 * Instead the 'ipsq_current_ipif' of the ipsq is not cleared as long as
2199 2200 * the 'ill_dlpi_deferred' chain is non-empty. This ensures that the next
2200 2201 * exclusive operation won't start until the DLPI operations of the previous
2201 2202 * exclusive operation complete.
2202 2203 *
2203 2204 * The capability state machine is shown below.
2204 2205 *
2205 2206 * state next state event, action
2206 2207 *
2207 2208 * IDCS_UNKNOWN IDCS_PROBE_SENT ill_capability_probe
2208 2209 * IDCS_PROBE_SENT IDCS_OK ill_capability_ack
2209 2210 * IDCS_PROBE_SENT IDCS_FAILED ip_rput_dlpi_writer (nack)
2210 2211 * IDCS_OK IDCS_RENEG Receipt of DL_NOTE_CAPAB_RENEG
2211 2212 * IDCS_OK IDCS_RESET_SENT ill_capability_reset
2212 2213 * IDCS_RESET_SENT IDCS_UNKNOWN ill_capability_ack_thr
2213 2214 * IDCS_RENEG IDCS_PROBE_SENT ill_capability_ack_thr ->
2214 2215 * ill_capability_probe.
2215 2216 */
2216 2217
2217 2218 /*
2218 2219 * Dedicated thread started from ip_stack_init that handles capability
2219 2220 * disable. This thread ensures the taskq dispatch does not fail by waiting
2220 2221 * for resources using TQ_SLEEP. The taskq mechanism is used to ensure
2221 2222 * that direct calls to DLD are done in a cv_waitable context.
2222 2223 */
2223 2224 void
2224 2225 ill_taskq_dispatch(ip_stack_t *ipst)
2225 2226 {
2226 2227 callb_cpr_t cprinfo;
2227 2228 char name[64];
2228 2229 mblk_t *mp;
2229 2230
2230 2231 (void) snprintf(name, sizeof (name), "ill_taskq_dispatch_%d",
2231 2232 ipst->ips_netstack->netstack_stackid);
2232 2233 CALLB_CPR_INIT(&cprinfo, &ipst->ips_capab_taskq_lock, callb_generic_cpr,
2233 2234 name);
2234 2235 mutex_enter(&ipst->ips_capab_taskq_lock);
2235 2236
2236 2237 for (;;) {
2237 2238 mp = ipst->ips_capab_taskq_head;
2238 2239 while (mp != NULL) {
2239 2240 ipst->ips_capab_taskq_head = mp->b_next;
2240 2241 if (ipst->ips_capab_taskq_head == NULL)
2241 2242 ipst->ips_capab_taskq_tail = NULL;
2242 2243 mutex_exit(&ipst->ips_capab_taskq_lock);
2243 2244 mp->b_next = NULL;
2244 2245
2245 2246 VERIFY(taskq_dispatch(system_taskq,
2246 2247 ill_capability_ack_thr, mp, TQ_SLEEP) != 0);
2247 2248 mutex_enter(&ipst->ips_capab_taskq_lock);
2248 2249 mp = ipst->ips_capab_taskq_head;
2249 2250 }
2250 2251
2251 2252 if (ipst->ips_capab_taskq_quit)
2252 2253 break;
2253 2254 CALLB_CPR_SAFE_BEGIN(&cprinfo);
2254 2255 cv_wait(&ipst->ips_capab_taskq_cv, &ipst->ips_capab_taskq_lock);
2255 2256 CALLB_CPR_SAFE_END(&cprinfo, &ipst->ips_capab_taskq_lock);
2256 2257 }
2257 2258 VERIFY(ipst->ips_capab_taskq_head == NULL);
2258 2259 VERIFY(ipst->ips_capab_taskq_tail == NULL);
2259 2260 CALLB_CPR_EXIT(&cprinfo);
2260 2261 thread_exit();
2261 2262 }
2262 2263
2263 2264 /*
2264 2265 * Consume a new-style hardware capabilities negotiation ack.
2265 2266 * Called via taskq on receipt of DL_CAPABILITY_ACK.
2266 2267 */
2267 2268 static void
2268 2269 ill_capability_ack_thr(void *arg)
2269 2270 {
2270 2271 mblk_t *mp = arg;
2271 2272 dl_capability_ack_t *capp;
2272 2273 dl_capability_sub_t *subp, *endp;
2273 2274 ill_t *ill;
2274 2275 boolean_t reneg;
2275 2276
2276 2277 ill = (ill_t *)mp->b_prev;
2277 2278 mp->b_prev = NULL;
2278 2279
2279 2280 VERIFY(ipsq_enter(ill, B_FALSE, CUR_OP) == B_TRUE);
2280 2281
2281 2282 if (ill->ill_dlpi_capab_state == IDCS_RESET_SENT ||
2282 2283 ill->ill_dlpi_capab_state == IDCS_RENEG) {
2283 2284 /*
2284 2285 * We have received the ack for our DL_CAPAB reset request.
2285 2286 * There isnt' anything in the message that needs processing.
2286 2287 * All message based capabilities have been disabled, now
2287 2288 * do the function call based capability disable.
2288 2289 */
2289 2290 reneg = ill->ill_dlpi_capab_state == IDCS_RENEG;
2290 2291 ill_capability_dld_disable(ill);
2291 2292 ill->ill_dlpi_capab_state = IDCS_UNKNOWN;
2292 2293 if (reneg)
2293 2294 ill_capability_probe(ill);
2294 2295 goto done;
2295 2296 }
2296 2297
2297 2298 if (ill->ill_dlpi_capab_state == IDCS_PROBE_SENT)
2298 2299 ill->ill_dlpi_capab_state = IDCS_OK;
2299 2300
2300 2301 capp = (dl_capability_ack_t *)mp->b_rptr;
2301 2302
2302 2303 if (capp->dl_sub_length == 0) {
2303 2304 /* no new-style capabilities */
2304 2305 goto done;
2305 2306 }
2306 2307
2307 2308 /* make sure the driver supplied correct dl_sub_length */
2308 2309 if ((sizeof (*capp) + capp->dl_sub_length) > MBLKL(mp)) {
2309 2310 ip0dbg(("ill_capability_ack: bad DL_CAPABILITY_ACK, "
2310 2311 "invalid dl_sub_length (%d)\n", capp->dl_sub_length));
2311 2312 goto done;
2312 2313 }
2313 2314
2314 2315 #define SC(base, offset) (dl_capability_sub_t *)(((uchar_t *)(base))+(offset))
2315 2316 /*
2316 2317 * There are sub-capabilities. Process the ones we know about.
2317 2318 * Loop until we don't have room for another sub-cap header..
2318 2319 */
2319 2320 for (subp = SC(capp, capp->dl_sub_offset),
2320 2321 endp = SC(subp, capp->dl_sub_length - sizeof (*subp));
2321 2322 subp <= endp;
2322 2323 subp = SC(subp, sizeof (dl_capability_sub_t) + subp->dl_length)) {
2323 2324
2324 2325 switch (subp->dl_cap) {
2325 2326 case DL_CAPAB_ID_WRAPPER:
2326 2327 ill_capability_id_ack(ill, mp, subp);
2327 2328 break;
2328 2329 default:
2329 2330 ill_capability_dispatch(ill, mp, subp);
2330 2331 break;
2331 2332 }
2332 2333 }
2333 2334 #undef SC
2334 2335 done:
2335 2336 inet_freemsg(mp);
2336 2337 ill_capability_done(ill);
2337 2338 ipsq_exit(ill->ill_phyint->phyint_ipsq);
2338 2339 }
2339 2340
2340 2341 /*
2341 2342 * This needs to be started in a taskq thread to provide a cv_waitable
2342 2343 * context.
2343 2344 */
2344 2345 void
2345 2346 ill_capability_ack(ill_t *ill, mblk_t *mp)
2346 2347 {
2347 2348 ip_stack_t *ipst = ill->ill_ipst;
2348 2349
2349 2350 mp->b_prev = (mblk_t *)ill;
2350 2351 ASSERT(mp->b_next == NULL);
2351 2352
2352 2353 if (taskq_dispatch(system_taskq, ill_capability_ack_thr, mp,
2353 2354 TQ_NOSLEEP) != 0)
2354 2355 return;
2355 2356
2356 2357 /*
2357 2358 * The taskq dispatch failed. Signal the ill_taskq_dispatch thread
2358 2359 * which will do the dispatch using TQ_SLEEP to guarantee success.
2359 2360 */
2360 2361 mutex_enter(&ipst->ips_capab_taskq_lock);
2361 2362 if (ipst->ips_capab_taskq_head == NULL) {
2362 2363 ASSERT(ipst->ips_capab_taskq_tail == NULL);
2363 2364 ipst->ips_capab_taskq_head = mp;
2364 2365 } else {
2365 2366 ipst->ips_capab_taskq_tail->b_next = mp;
2366 2367 }
2367 2368 ipst->ips_capab_taskq_tail = mp;
2368 2369
2369 2370 cv_signal(&ipst->ips_capab_taskq_cv);
2370 2371 mutex_exit(&ipst->ips_capab_taskq_lock);
2371 2372 }
2372 2373
2373 2374 /*
2374 2375 * This routine is called to scan the fragmentation reassembly table for
2375 2376 * the specified ILL for any packets that are starting to smell.
2376 2377 * dead_interval is the maximum time in seconds that will be tolerated. It
2377 2378 * will either be the value specified in ip_g_frag_timeout, or zero if the
2378 2379 * ILL is shutting down and it is time to blow everything off.
2379 2380 *
2380 2381 * It returns the number of seconds (as a time_t) that the next frag timer
2381 2382 * should be scheduled for, 0 meaning that the timer doesn't need to be
2382 2383 * re-started. Note that the method of calculating next_timeout isn't
2383 2384 * entirely accurate since time will flow between the time we grab
2384 2385 * current_time and the time we schedule the next timeout. This isn't a
2385 2386 * big problem since this is the timer for sending an ICMP reassembly time
2386 2387 * exceeded messages, and it doesn't have to be exactly accurate.
2387 2388 *
2388 2389 * This function is
2389 2390 * sometimes called as writer, although this is not required.
2390 2391 */
2391 2392 time_t
2392 2393 ill_frag_timeout(ill_t *ill, time_t dead_interval)
2393 2394 {
2394 2395 ipfb_t *ipfb;
2395 2396 ipfb_t *endp;
2396 2397 ipf_t *ipf;
2397 2398 ipf_t *ipfnext;
2398 2399 mblk_t *mp;
2399 2400 time_t current_time = gethrestime_sec();
2400 2401 time_t next_timeout = 0;
2401 2402 uint32_t hdr_length;
2402 2403 mblk_t *send_icmp_head;
2403 2404 mblk_t *send_icmp_head_v6;
2404 2405 ip_stack_t *ipst = ill->ill_ipst;
2405 2406 ip_recv_attr_t iras;
2406 2407
2407 2408 bzero(&iras, sizeof (iras));
2408 2409 iras.ira_flags = 0;
2409 2410 iras.ira_ill = iras.ira_rill = ill;
2410 2411 iras.ira_ruifindex = ill->ill_phyint->phyint_ifindex;
2411 2412 iras.ira_rifindex = iras.ira_ruifindex;
2412 2413
2413 2414 ipfb = ill->ill_frag_hash_tbl;
2414 2415 if (ipfb == NULL)
2415 2416 return (B_FALSE);
2416 2417 endp = &ipfb[ILL_FRAG_HASH_TBL_COUNT];
2417 2418 /* Walk the frag hash table. */
2418 2419 for (; ipfb < endp; ipfb++) {
2419 2420 send_icmp_head = NULL;
2420 2421 send_icmp_head_v6 = NULL;
2421 2422 mutex_enter(&ipfb->ipfb_lock);
2422 2423 while ((ipf = ipfb->ipfb_ipf) != 0) {
2423 2424 time_t frag_time = current_time - ipf->ipf_timestamp;
2424 2425 time_t frag_timeout;
2425 2426
2426 2427 if (frag_time < dead_interval) {
2427 2428 /*
2428 2429 * There are some outstanding fragments
2429 2430 * that will timeout later. Make note of
2430 2431 * the time so that we can reschedule the
2431 2432 * next timeout appropriately.
2432 2433 */
2433 2434 frag_timeout = dead_interval - frag_time;
2434 2435 if (next_timeout == 0 ||
2435 2436 frag_timeout < next_timeout) {
2436 2437 next_timeout = frag_timeout;
2437 2438 }
2438 2439 break;
2439 2440 }
2440 2441 /* Time's up. Get it out of here. */
2441 2442 hdr_length = ipf->ipf_nf_hdr_len;
2442 2443 ipfnext = ipf->ipf_hash_next;
2443 2444 if (ipfnext)
2444 2445 ipfnext->ipf_ptphn = ipf->ipf_ptphn;
2445 2446 *ipf->ipf_ptphn = ipfnext;
2446 2447 mp = ipf->ipf_mp->b_cont;
2447 2448 for (; mp; mp = mp->b_cont) {
2448 2449 /* Extra points for neatness. */
2449 2450 IP_REASS_SET_START(mp, 0);
2450 2451 IP_REASS_SET_END(mp, 0);
2451 2452 }
2452 2453 mp = ipf->ipf_mp->b_cont;
2453 2454 atomic_add_32(&ill->ill_frag_count, -ipf->ipf_count);
2454 2455 ASSERT(ipfb->ipfb_count >= ipf->ipf_count);
2455 2456 ipfb->ipfb_count -= ipf->ipf_count;
2456 2457 ASSERT(ipfb->ipfb_frag_pkts > 0);
2457 2458 ipfb->ipfb_frag_pkts--;
2458 2459 /*
2459 2460 * We do not send any icmp message from here because
2460 2461 * we currently are holding the ipfb_lock for this
2461 2462 * hash chain. If we try and send any icmp messages
2462 2463 * from here we may end up via a put back into ip
2463 2464 * trying to get the same lock, causing a recursive
2464 2465 * mutex panic. Instead we build a list and send all
2465 2466 * the icmp messages after we have dropped the lock.
2466 2467 */
2467 2468 if (ill->ill_isv6) {
2468 2469 if (hdr_length != 0) {
2469 2470 mp->b_next = send_icmp_head_v6;
2470 2471 send_icmp_head_v6 = mp;
2471 2472 } else {
2472 2473 freemsg(mp);
2473 2474 }
2474 2475 } else {
2475 2476 if (hdr_length != 0) {
2476 2477 mp->b_next = send_icmp_head;
2477 2478 send_icmp_head = mp;
2478 2479 } else {
2479 2480 freemsg(mp);
2480 2481 }
2481 2482 }
2482 2483 BUMP_MIB(ill->ill_ip_mib, ipIfStatsReasmFails);
2483 2484 ip_drop_input("ipIfStatsReasmFails", ipf->ipf_mp, ill);
2484 2485 freeb(ipf->ipf_mp);
2485 2486 }
2486 2487 mutex_exit(&ipfb->ipfb_lock);
2487 2488 /*
2488 2489 * Now need to send any icmp messages that we delayed from
2489 2490 * above.
2490 2491 */
2491 2492 while (send_icmp_head_v6 != NULL) {
2492 2493 ip6_t *ip6h;
2493 2494
2494 2495 mp = send_icmp_head_v6;
2495 2496 send_icmp_head_v6 = send_icmp_head_v6->b_next;
2496 2497 mp->b_next = NULL;
2497 2498 ip6h = (ip6_t *)mp->b_rptr;
2498 2499 iras.ira_flags = 0;
2499 2500 /*
2500 2501 * This will result in an incorrect ALL_ZONES zoneid
2501 2502 * for multicast packets, but we
2502 2503 * don't send ICMP errors for those in any case.
2503 2504 */
2504 2505 iras.ira_zoneid =
2505 2506 ipif_lookup_addr_zoneid_v6(&ip6h->ip6_dst,
2506 2507 ill, ipst);
2507 2508 ip_drop_input("ICMP_TIME_EXCEEDED reass", mp, ill);
2508 2509 icmp_time_exceeded_v6(mp,
2509 2510 ICMP_REASSEMBLY_TIME_EXCEEDED, B_FALSE,
2510 2511 &iras);
2511 2512 ASSERT(!(iras.ira_flags & IRAF_IPSEC_SECURE));
2512 2513 }
2513 2514 while (send_icmp_head != NULL) {
2514 2515 ipaddr_t dst;
2515 2516
2516 2517 mp = send_icmp_head;
2517 2518 send_icmp_head = send_icmp_head->b_next;
2518 2519 mp->b_next = NULL;
2519 2520
2520 2521 dst = ((ipha_t *)mp->b_rptr)->ipha_dst;
2521 2522
2522 2523 iras.ira_flags = IRAF_IS_IPV4;
2523 2524 /*
2524 2525 * This will result in an incorrect ALL_ZONES zoneid
2525 2526 * for broadcast and multicast packets, but we
2526 2527 * don't send ICMP errors for those in any case.
2527 2528 */
2528 2529 iras.ira_zoneid = ipif_lookup_addr_zoneid(dst,
2529 2530 ill, ipst);
2530 2531 ip_drop_input("ICMP_TIME_EXCEEDED reass", mp, ill);
2531 2532 icmp_time_exceeded(mp,
2532 2533 ICMP_REASSEMBLY_TIME_EXCEEDED, &iras);
2533 2534 ASSERT(!(iras.ira_flags & IRAF_IPSEC_SECURE));
2534 2535 }
2535 2536 }
2536 2537 /*
2537 2538 * A non-dying ILL will use the return value to decide whether to
2538 2539 * restart the frag timer, and for how long.
2539 2540 */
2540 2541 return (next_timeout);
2541 2542 }
2542 2543
2543 2544 /*
2544 2545 * This routine is called when the approximate count of mblk memory used
2545 2546 * for the specified ILL has exceeded max_count.
2546 2547 */
2547 2548 void
2548 2549 ill_frag_prune(ill_t *ill, uint_t max_count)
2549 2550 {
2550 2551 ipfb_t *ipfb;
2551 2552 ipf_t *ipf;
2552 2553 size_t count;
2553 2554 clock_t now;
2554 2555
2555 2556 /*
2556 2557 * If we are here within ip_min_frag_prune_time msecs remove
2557 2558 * ill_frag_free_num_pkts oldest packets from each bucket and increment
2558 2559 * ill_frag_free_num_pkts.
2559 2560 */
2560 2561 mutex_enter(&ill->ill_lock);
2561 2562 now = ddi_get_lbolt();
2562 2563 if (TICK_TO_MSEC(now - ill->ill_last_frag_clean_time) <=
2563 2564 (ip_min_frag_prune_time != 0 ?
2564 2565 ip_min_frag_prune_time : msec_per_tick)) {
2565 2566
2566 2567 ill->ill_frag_free_num_pkts++;
2567 2568
2568 2569 } else {
2569 2570 ill->ill_frag_free_num_pkts = 0;
2570 2571 }
2571 2572 ill->ill_last_frag_clean_time = now;
2572 2573 mutex_exit(&ill->ill_lock);
2573 2574
2574 2575 /*
2575 2576 * free ill_frag_free_num_pkts oldest packets from each bucket.
2576 2577 */
2577 2578 if (ill->ill_frag_free_num_pkts != 0) {
2578 2579 int ix;
2579 2580
2580 2581 for (ix = 0; ix < ILL_FRAG_HASH_TBL_COUNT; ix++) {
2581 2582 ipfb = &ill->ill_frag_hash_tbl[ix];
2582 2583 mutex_enter(&ipfb->ipfb_lock);
2583 2584 if (ipfb->ipfb_ipf != NULL) {
2584 2585 ill_frag_free_pkts(ill, ipfb, ipfb->ipfb_ipf,
2585 2586 ill->ill_frag_free_num_pkts);
2586 2587 }
2587 2588 mutex_exit(&ipfb->ipfb_lock);
2588 2589 }
2589 2590 }
2590 2591 /*
2591 2592 * While the reassembly list for this ILL is too big, prune a fragment
2592 2593 * queue by age, oldest first.
2593 2594 */
2594 2595 while (ill->ill_frag_count > max_count) {
2595 2596 int ix;
2596 2597 ipfb_t *oipfb = NULL;
2597 2598 uint_t oldest = UINT_MAX;
2598 2599
2599 2600 count = 0;
2600 2601 for (ix = 0; ix < ILL_FRAG_HASH_TBL_COUNT; ix++) {
2601 2602 ipfb = &ill->ill_frag_hash_tbl[ix];
2602 2603 mutex_enter(&ipfb->ipfb_lock);
2603 2604 ipf = ipfb->ipfb_ipf;
2604 2605 if (ipf != NULL && ipf->ipf_gen < oldest) {
2605 2606 oldest = ipf->ipf_gen;
2606 2607 oipfb = ipfb;
2607 2608 }
2608 2609 count += ipfb->ipfb_count;
2609 2610 mutex_exit(&ipfb->ipfb_lock);
2610 2611 }
2611 2612 if (oipfb == NULL)
2612 2613 break;
2613 2614
2614 2615 if (count <= max_count)
2615 2616 return; /* Somebody beat us to it, nothing to do */
2616 2617 mutex_enter(&oipfb->ipfb_lock);
2617 2618 ipf = oipfb->ipfb_ipf;
2618 2619 if (ipf != NULL) {
2619 2620 ill_frag_free_pkts(ill, oipfb, ipf, 1);
2620 2621 }
2621 2622 mutex_exit(&oipfb->ipfb_lock);
2622 2623 }
2623 2624 }
2624 2625
2625 2626 /*
2626 2627 * free 'free_cnt' fragmented packets starting at ipf.
2627 2628 */
2628 2629 void
2629 2630 ill_frag_free_pkts(ill_t *ill, ipfb_t *ipfb, ipf_t *ipf, int free_cnt)
2630 2631 {
2631 2632 size_t count;
2632 2633 mblk_t *mp;
2633 2634 mblk_t *tmp;
2634 2635 ipf_t **ipfp = ipf->ipf_ptphn;
2635 2636
2636 2637 ASSERT(MUTEX_HELD(&ipfb->ipfb_lock));
2637 2638 ASSERT(ipfp != NULL);
2638 2639 ASSERT(ipf != NULL);
2639 2640
2640 2641 while (ipf != NULL && free_cnt-- > 0) {
2641 2642 count = ipf->ipf_count;
2642 2643 mp = ipf->ipf_mp;
2643 2644 ipf = ipf->ipf_hash_next;
2644 2645 for (tmp = mp; tmp; tmp = tmp->b_cont) {
2645 2646 IP_REASS_SET_START(tmp, 0);
2646 2647 IP_REASS_SET_END(tmp, 0);
2647 2648 }
2648 2649 atomic_add_32(&ill->ill_frag_count, -count);
2649 2650 ASSERT(ipfb->ipfb_count >= count);
2650 2651 ipfb->ipfb_count -= count;
2651 2652 ASSERT(ipfb->ipfb_frag_pkts > 0);
2652 2653 ipfb->ipfb_frag_pkts--;
2653 2654 BUMP_MIB(ill->ill_ip_mib, ipIfStatsReasmFails);
2654 2655 ip_drop_input("ipIfStatsReasmFails", mp, ill);
2655 2656 freemsg(mp);
2656 2657 }
2657 2658
2658 2659 if (ipf)
2659 2660 ipf->ipf_ptphn = ipfp;
2660 2661 ipfp[0] = ipf;
2661 2662 }
2662 2663
2663 2664 /*
2664 2665 * Helper function for ill_forward_set().
2665 2666 */
2666 2667 static void
2667 2668 ill_forward_set_on_ill(ill_t *ill, boolean_t enable)
2668 2669 {
2669 2670 ip_stack_t *ipst = ill->ill_ipst;
2670 2671
2671 2672 ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ipst->ips_ill_g_lock));
2672 2673
2673 2674 ip1dbg(("ill_forward_set: %s %s forwarding on %s",
2674 2675 (enable ? "Enabling" : "Disabling"),
2675 2676 (ill->ill_isv6 ? "IPv6" : "IPv4"), ill->ill_name));
2676 2677 mutex_enter(&ill->ill_lock);
2677 2678 if (enable)
2678 2679 ill->ill_flags |= ILLF_ROUTER;
2679 2680 else
2680 2681 ill->ill_flags &= ~ILLF_ROUTER;
2681 2682 mutex_exit(&ill->ill_lock);
2682 2683 if (ill->ill_isv6)
2683 2684 ill_set_nce_router_flags(ill, enable);
2684 2685 /* Notify routing socket listeners of this change. */
2685 2686 if (ill->ill_ipif != NULL)
2686 2687 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
2687 2688 }
2688 2689
2689 2690 /*
2690 2691 * Set an ill's ILLF_ROUTER flag appropriately. Send up RTS_IFINFO routing
2691 2692 * socket messages for each interface whose flags we change.
2692 2693 */
2693 2694 int
2694 2695 ill_forward_set(ill_t *ill, boolean_t enable)
2695 2696 {
2696 2697 ipmp_illgrp_t *illg;
2697 2698 ip_stack_t *ipst = ill->ill_ipst;
2698 2699
2699 2700 ASSERT(IAM_WRITER_ILL(ill) || RW_READ_HELD(&ipst->ips_ill_g_lock));
2700 2701
2701 2702 if ((enable && (ill->ill_flags & ILLF_ROUTER)) ||
2702 2703 (!enable && !(ill->ill_flags & ILLF_ROUTER)))
2703 2704 return (0);
2704 2705
2705 2706 if (IS_LOOPBACK(ill))
2706 2707 return (EINVAL);
2707 2708
2708 2709 if (enable && ill->ill_allowed_ips_cnt > 0)
2709 2710 return (EPERM);
2710 2711
2711 2712 if (IS_IPMP(ill) || IS_UNDER_IPMP(ill)) {
2712 2713 /*
2713 2714 * Update all of the interfaces in the group.
2714 2715 */
2715 2716 illg = ill->ill_grp;
2716 2717 ill = list_head(&illg->ig_if);
2717 2718 for (; ill != NULL; ill = list_next(&illg->ig_if, ill))
2718 2719 ill_forward_set_on_ill(ill, enable);
2719 2720
2720 2721 /*
2721 2722 * Update the IPMP meta-interface.
2722 2723 */
2723 2724 ill_forward_set_on_ill(ipmp_illgrp_ipmp_ill(illg), enable);
2724 2725 return (0);
2725 2726 }
2726 2727
2727 2728 ill_forward_set_on_ill(ill, enable);
2728 2729 return (0);
2729 2730 }
2730 2731
2731 2732 /*
2732 2733 * Based on the ILLF_ROUTER flag of an ill, make sure all local nce's for
2733 2734 * addresses assigned to the ill have the NCE_F_ISROUTER flag appropriately
2734 2735 * set or clear.
2735 2736 */
2736 2737 static void
2737 2738 ill_set_nce_router_flags(ill_t *ill, boolean_t enable)
2738 2739 {
2739 2740 ipif_t *ipif;
2740 2741 ncec_t *ncec;
2741 2742 nce_t *nce;
2742 2743
2743 2744 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
2744 2745 /*
2745 2746 * NOTE: we match across the illgrp because nce's for
2746 2747 * addresses on IPMP interfaces have an nce_ill that points to
2747 2748 * the bound underlying ill.
2748 2749 */
2749 2750 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
2750 2751 if (nce != NULL) {
2751 2752 ncec = nce->nce_common;
2752 2753 mutex_enter(&ncec->ncec_lock);
2753 2754 if (enable)
2754 2755 ncec->ncec_flags |= NCE_F_ISROUTER;
2755 2756 else
2756 2757 ncec->ncec_flags &= ~NCE_F_ISROUTER;
2757 2758 mutex_exit(&ncec->ncec_lock);
2758 2759 nce_refrele(nce);
2759 2760 }
2760 2761 }
2761 2762 }
2762 2763
2763 2764 /*
2764 2765 * Intializes the context structure and returns the first ill in the list
2765 2766 * cuurently start_list and end_list can have values:
2766 2767 * MAX_G_HEADS Traverse both IPV4 and IPV6 lists.
2767 2768 * IP_V4_G_HEAD Traverse IPV4 list only.
2768 2769 * IP_V6_G_HEAD Traverse IPV6 list only.
2769 2770 */
2770 2771
2771 2772 /*
2772 2773 * We don't check for CONDEMNED ills here. Caller must do that if
2773 2774 * necessary under the ill lock.
2774 2775 */
2775 2776 ill_t *
2776 2777 ill_first(int start_list, int end_list, ill_walk_context_t *ctx,
2777 2778 ip_stack_t *ipst)
2778 2779 {
2779 2780 ill_if_t *ifp;
2780 2781 ill_t *ill;
2781 2782 avl_tree_t *avl_tree;
2782 2783
2783 2784 ASSERT(RW_LOCK_HELD(&ipst->ips_ill_g_lock));
2784 2785 ASSERT(end_list <= MAX_G_HEADS && start_list >= 0);
2785 2786
2786 2787 /*
2787 2788 * setup the lists to search
2788 2789 */
2789 2790 if (end_list != MAX_G_HEADS) {
2790 2791 ctx->ctx_current_list = start_list;
2791 2792 ctx->ctx_last_list = end_list;
2792 2793 } else {
2793 2794 ctx->ctx_last_list = MAX_G_HEADS - 1;
2794 2795 ctx->ctx_current_list = 0;
2795 2796 }
2796 2797
2797 2798 while (ctx->ctx_current_list <= ctx->ctx_last_list) {
2798 2799 ifp = IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst);
2799 2800 if (ifp != (ill_if_t *)
2800 2801 &IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst)) {
2801 2802 avl_tree = &ifp->illif_avl_by_ppa;
2802 2803 ill = avl_first(avl_tree);
2803 2804 /*
2804 2805 * ill is guaranteed to be non NULL or ifp should have
2805 2806 * not existed.
2806 2807 */
2807 2808 ASSERT(ill != NULL);
2808 2809 return (ill);
2809 2810 }
2810 2811 ctx->ctx_current_list++;
2811 2812 }
2812 2813
2813 2814 return (NULL);
2814 2815 }
2815 2816
2816 2817 /*
2817 2818 * returns the next ill in the list. ill_first() must have been called
2818 2819 * before calling ill_next() or bad things will happen.
2819 2820 */
2820 2821
2821 2822 /*
2822 2823 * We don't check for CONDEMNED ills here. Caller must do that if
2823 2824 * necessary under the ill lock.
2824 2825 */
2825 2826 ill_t *
2826 2827 ill_next(ill_walk_context_t *ctx, ill_t *lastill)
2827 2828 {
2828 2829 ill_if_t *ifp;
2829 2830 ill_t *ill;
2830 2831 ip_stack_t *ipst = lastill->ill_ipst;
2831 2832
2832 2833 ASSERT(lastill->ill_ifptr != (ill_if_t *)
2833 2834 &IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst));
2834 2835 if ((ill = avl_walk(&lastill->ill_ifptr->illif_avl_by_ppa, lastill,
2835 2836 AVL_AFTER)) != NULL) {
2836 2837 return (ill);
2837 2838 }
2838 2839
2839 2840 /* goto next ill_ifp in the list. */
2840 2841 ifp = lastill->ill_ifptr->illif_next;
2841 2842
2842 2843 /* make sure not at end of circular list */
2843 2844 while (ifp ==
2844 2845 (ill_if_t *)&IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst)) {
2845 2846 if (++ctx->ctx_current_list > ctx->ctx_last_list)
2846 2847 return (NULL);
2847 2848 ifp = IP_VX_ILL_G_LIST(ctx->ctx_current_list, ipst);
2848 2849 }
2849 2850
2850 2851 return (avl_first(&ifp->illif_avl_by_ppa));
2851 2852 }
2852 2853
2853 2854 /*
2854 2855 * Check interface name for correct format: [a-zA-Z]+[a-zA-Z0-9._]*[0-9]+
2855 2856 * The final number (PPA) must not have any leading zeros. Upon success, a
2856 2857 * pointer to the start of the PPA is returned; otherwise NULL is returned.
2857 2858 */
2858 2859 static char *
2859 2860 ill_get_ppa_ptr(char *name)
2860 2861 {
2861 2862 int namelen = strlen(name);
2862 2863 int end_ndx = namelen - 1;
2863 2864 int ppa_ndx, i;
2864 2865
2865 2866 /*
2866 2867 * Check that the first character is [a-zA-Z], and that the last
2867 2868 * character is [0-9].
2868 2869 */
2869 2870 if (namelen == 0 || !isalpha(name[0]) || !isdigit(name[end_ndx]))
2870 2871 return (NULL);
2871 2872
2872 2873 /*
2873 2874 * Set `ppa_ndx' to the PPA start, and check for leading zeroes.
2874 2875 */
2875 2876 for (ppa_ndx = end_ndx; ppa_ndx > 0; ppa_ndx--)
2876 2877 if (!isdigit(name[ppa_ndx - 1]))
2877 2878 break;
2878 2879
2879 2880 if (name[ppa_ndx] == '0' && ppa_ndx < end_ndx)
2880 2881 return (NULL);
2881 2882
2882 2883 /*
2883 2884 * Check that the intermediate characters are [a-z0-9.]
2884 2885 */
2885 2886 for (i = 1; i < ppa_ndx; i++) {
2886 2887 if (!isalpha(name[i]) && !isdigit(name[i]) &&
2887 2888 name[i] != '.' && name[i] != '_') {
2888 2889 return (NULL);
2889 2890 }
2890 2891 }
2891 2892
2892 2893 return (name + ppa_ndx);
2893 2894 }
2894 2895
2895 2896 /*
2896 2897 * use avl tree to locate the ill.
2897 2898 */
2898 2899 static ill_t *
2899 2900 ill_find_by_name(char *name, boolean_t isv6, ip_stack_t *ipst)
2900 2901 {
2901 2902 char *ppa_ptr = NULL;
2902 2903 int len;
2903 2904 uint_t ppa;
2904 2905 ill_t *ill = NULL;
2905 2906 ill_if_t *ifp;
2906 2907 int list;
2907 2908
2908 2909 /*
2909 2910 * get ppa ptr
2910 2911 */
2911 2912 if (isv6)
2912 2913 list = IP_V6_G_HEAD;
2913 2914 else
2914 2915 list = IP_V4_G_HEAD;
2915 2916
2916 2917 if ((ppa_ptr = ill_get_ppa_ptr(name)) == NULL) {
2917 2918 return (NULL);
2918 2919 }
2919 2920
2920 2921 len = ppa_ptr - name + 1;
2921 2922
2922 2923 ppa = stoi(&ppa_ptr);
2923 2924
2924 2925 ifp = IP_VX_ILL_G_LIST(list, ipst);
2925 2926
2926 2927 while (ifp != (ill_if_t *)&IP_VX_ILL_G_LIST(list, ipst)) {
2927 2928 /*
2928 2929 * match is done on len - 1 as the name is not null
2929 2930 * terminated it contains ppa in addition to the interface
2930 2931 * name.
2931 2932 */
2932 2933 if ((ifp->illif_name_len == len) &&
2933 2934 bcmp(ifp->illif_name, name, len - 1) == 0) {
2934 2935 break;
2935 2936 } else {
2936 2937 ifp = ifp->illif_next;
2937 2938 }
2938 2939 }
2939 2940
2940 2941 if (ifp == (ill_if_t *)&IP_VX_ILL_G_LIST(list, ipst)) {
2941 2942 /*
2942 2943 * Even the interface type does not exist.
2943 2944 */
2944 2945 return (NULL);
2945 2946 }
2946 2947
2947 2948 ill = avl_find(&ifp->illif_avl_by_ppa, (void *) &ppa, NULL);
2948 2949 if (ill != NULL) {
2949 2950 mutex_enter(&ill->ill_lock);
2950 2951 if (ILL_CAN_LOOKUP(ill)) {
2951 2952 ill_refhold_locked(ill);
2952 2953 mutex_exit(&ill->ill_lock);
2953 2954 return (ill);
2954 2955 }
2955 2956 mutex_exit(&ill->ill_lock);
2956 2957 }
2957 2958 return (NULL);
2958 2959 }
2959 2960
2960 2961 /*
2961 2962 * comparison function for use with avl.
2962 2963 */
2963 2964 static int
2964 2965 ill_compare_ppa(const void *ppa_ptr, const void *ill_ptr)
2965 2966 {
2966 2967 uint_t ppa;
2967 2968 uint_t ill_ppa;
2968 2969
2969 2970 ASSERT(ppa_ptr != NULL && ill_ptr != NULL);
2970 2971
2971 2972 ppa = *((uint_t *)ppa_ptr);
2972 2973 ill_ppa = ((const ill_t *)ill_ptr)->ill_ppa;
2973 2974 /*
2974 2975 * We want the ill with the lowest ppa to be on the
2975 2976 * top.
2976 2977 */
2977 2978 if (ill_ppa < ppa)
2978 2979 return (1);
2979 2980 if (ill_ppa > ppa)
2980 2981 return (-1);
2981 2982 return (0);
2982 2983 }
2983 2984
2984 2985 /*
2985 2986 * remove an interface type from the global list.
2986 2987 */
2987 2988 static void
2988 2989 ill_delete_interface_type(ill_if_t *interface)
2989 2990 {
2990 2991 ASSERT(interface != NULL);
2991 2992 ASSERT(avl_numnodes(&interface->illif_avl_by_ppa) == 0);
2992 2993
2993 2994 avl_destroy(&interface->illif_avl_by_ppa);
2994 2995 if (interface->illif_ppa_arena != NULL)
2995 2996 vmem_destroy(interface->illif_ppa_arena);
2996 2997
2997 2998 remque(interface);
2998 2999
2999 3000 mi_free(interface);
3000 3001 }
3001 3002
3002 3003 /*
3003 3004 * remove ill from the global list.
3004 3005 */
3005 3006 static void
3006 3007 ill_glist_delete(ill_t *ill)
3007 3008 {
3008 3009 ip_stack_t *ipst;
3009 3010 phyint_t *phyi;
3010 3011
3011 3012 if (ill == NULL)
3012 3013 return;
3013 3014 ipst = ill->ill_ipst;
3014 3015 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
3015 3016
3016 3017 /*
3017 3018 * If the ill was never inserted into the AVL tree
3018 3019 * we skip the if branch.
3019 3020 */
3020 3021 if (ill->ill_ifptr != NULL) {
3021 3022 /*
3022 3023 * remove from AVL tree and free ppa number
3023 3024 */
3024 3025 avl_remove(&ill->ill_ifptr->illif_avl_by_ppa, ill);
3025 3026
3026 3027 if (ill->ill_ifptr->illif_ppa_arena != NULL) {
3027 3028 vmem_free(ill->ill_ifptr->illif_ppa_arena,
3028 3029 (void *)(uintptr_t)(ill->ill_ppa+1), 1);
3029 3030 }
3030 3031 if (avl_numnodes(&ill->ill_ifptr->illif_avl_by_ppa) == 0) {
3031 3032 ill_delete_interface_type(ill->ill_ifptr);
3032 3033 }
3033 3034
3034 3035 /*
3035 3036 * Indicate ill is no longer in the list.
3036 3037 */
3037 3038 ill->ill_ifptr = NULL;
3038 3039 ill->ill_name_length = 0;
3039 3040 ill->ill_name[0] = '\0';
3040 3041 ill->ill_ppa = UINT_MAX;
3041 3042 }
3042 3043
3043 3044 /* Generate one last event for this ill. */
3044 3045 ill_nic_event_dispatch(ill, 0, NE_UNPLUMB, ill->ill_name,
3045 3046 ill->ill_name_length);
3046 3047
3047 3048 ASSERT(ill->ill_phyint != NULL);
3048 3049 phyi = ill->ill_phyint;
3049 3050 ill->ill_phyint = NULL;
3050 3051
3051 3052 /*
3052 3053 * ill_init allocates a phyint always to store the copy
3053 3054 * of flags relevant to phyint. At that point in time, we could
3054 3055 * not assign the name and hence phyint_illv4/v6 could not be
3055 3056 * initialized. Later in ipif_set_values, we assign the name to
3056 3057 * the ill, at which point in time we assign phyint_illv4/v6.
3057 3058 * Thus we don't rely on phyint_illv6 to be initialized always.
3058 3059 */
3059 3060 if (ill->ill_flags & ILLF_IPV6)
3060 3061 phyi->phyint_illv6 = NULL;
3061 3062 else
3062 3063 phyi->phyint_illv4 = NULL;
3063 3064
3064 3065 if (phyi->phyint_illv4 != NULL || phyi->phyint_illv6 != NULL) {
3065 3066 rw_exit(&ipst->ips_ill_g_lock);
3066 3067 return;
3067 3068 }
3068 3069
3069 3070 /*
3070 3071 * There are no ills left on this phyint; pull it out of the phyint
3071 3072 * avl trees, and free it.
3072 3073 */
3073 3074 if (phyi->phyint_ifindex > 0) {
3074 3075 avl_remove(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3075 3076 phyi);
3076 3077 avl_remove(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
3077 3078 phyi);
3078 3079 }
3079 3080 rw_exit(&ipst->ips_ill_g_lock);
3080 3081
3081 3082 phyint_free(phyi);
3082 3083 }
3083 3084
3084 3085 /*
3085 3086 * allocate a ppa, if the number of plumbed interfaces of this type are
3086 3087 * less than ill_no_arena do a linear search to find a unused ppa.
3087 3088 * When the number goes beyond ill_no_arena switch to using an arena.
3088 3089 * Note: ppa value of zero cannot be allocated from vmem_arena as it
3089 3090 * is the return value for an error condition, so allocation starts at one
3090 3091 * and is decremented by one.
3091 3092 */
3092 3093 static int
3093 3094 ill_alloc_ppa(ill_if_t *ifp, ill_t *ill)
3094 3095 {
3095 3096 ill_t *tmp_ill;
3096 3097 uint_t start, end;
3097 3098 int ppa;
3098 3099
3099 3100 if (ifp->illif_ppa_arena == NULL &&
3100 3101 (avl_numnodes(&ifp->illif_avl_by_ppa) + 1 > ill_no_arena)) {
3101 3102 /*
3102 3103 * Create an arena.
3103 3104 */
3104 3105 ifp->illif_ppa_arena = vmem_create(ifp->illif_name,
3105 3106 (void *)1, UINT_MAX - 1, 1, NULL, NULL,
3106 3107 NULL, 0, VM_SLEEP | VMC_IDENTIFIER);
3107 3108 /* allocate what has already been assigned */
3108 3109 for (tmp_ill = avl_first(&ifp->illif_avl_by_ppa);
3109 3110 tmp_ill != NULL; tmp_ill = avl_walk(&ifp->illif_avl_by_ppa,
3110 3111 tmp_ill, AVL_AFTER)) {
3111 3112 ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena,
3112 3113 1, /* size */
3113 3114 1, /* align/quantum */
3114 3115 0, /* phase */
3115 3116 0, /* nocross */
3116 3117 /* minaddr */
3117 3118 (void *)((uintptr_t)tmp_ill->ill_ppa + 1),
3118 3119 /* maxaddr */
3119 3120 (void *)((uintptr_t)tmp_ill->ill_ppa + 2),
3120 3121 VM_NOSLEEP|VM_FIRSTFIT);
3121 3122 if (ppa == 0) {
3122 3123 ip1dbg(("ill_alloc_ppa: ppa allocation"
3123 3124 " failed while switching"));
3124 3125 vmem_destroy(ifp->illif_ppa_arena);
3125 3126 ifp->illif_ppa_arena = NULL;
3126 3127 break;
3127 3128 }
3128 3129 }
3129 3130 }
3130 3131
3131 3132 if (ifp->illif_ppa_arena != NULL) {
3132 3133 if (ill->ill_ppa == UINT_MAX) {
3133 3134 ppa = (int)(uintptr_t)vmem_alloc(ifp->illif_ppa_arena,
3134 3135 1, VM_NOSLEEP|VM_FIRSTFIT);
3135 3136 if (ppa == 0)
3136 3137 return (EAGAIN);
3137 3138 ill->ill_ppa = --ppa;
3138 3139 } else {
3139 3140 ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena,
3140 3141 1, /* size */
3141 3142 1, /* align/quantum */
3142 3143 0, /* phase */
3143 3144 0, /* nocross */
3144 3145 (void *)(uintptr_t)(ill->ill_ppa + 1), /* minaddr */
3145 3146 (void *)(uintptr_t)(ill->ill_ppa + 2), /* maxaddr */
3146 3147 VM_NOSLEEP|VM_FIRSTFIT);
3147 3148 /*
3148 3149 * Most likely the allocation failed because
3149 3150 * the requested ppa was in use.
3150 3151 */
3151 3152 if (ppa == 0)
3152 3153 return (EEXIST);
3153 3154 }
3154 3155 return (0);
3155 3156 }
3156 3157
3157 3158 /*
3158 3159 * No arena is in use and not enough (>ill_no_arena) interfaces have
3159 3160 * been plumbed to create one. Do a linear search to get a unused ppa.
3160 3161 */
3161 3162 if (ill->ill_ppa == UINT_MAX) {
3162 3163 end = UINT_MAX - 1;
3163 3164 start = 0;
3164 3165 } else {
3165 3166 end = start = ill->ill_ppa;
3166 3167 }
3167 3168
3168 3169 tmp_ill = avl_find(&ifp->illif_avl_by_ppa, (void *)&start, NULL);
3169 3170 while (tmp_ill != NULL && tmp_ill->ill_ppa == start) {
3170 3171 if (start++ >= end) {
3171 3172 if (ill->ill_ppa == UINT_MAX)
3172 3173 return (EAGAIN);
3173 3174 else
3174 3175 return (EEXIST);
3175 3176 }
3176 3177 tmp_ill = avl_walk(&ifp->illif_avl_by_ppa, tmp_ill, AVL_AFTER);
3177 3178 }
3178 3179 ill->ill_ppa = start;
3179 3180 return (0);
3180 3181 }
3181 3182
3182 3183 /*
3183 3184 * Insert ill into the list of configured ill's. Once this function completes,
3184 3185 * the ill is globally visible and is available through lookups. More precisely
3185 3186 * this happens after the caller drops the ill_g_lock.
3186 3187 */
3187 3188 static int
3188 3189 ill_glist_insert(ill_t *ill, char *name, boolean_t isv6)
3189 3190 {
3190 3191 ill_if_t *ill_interface;
3191 3192 avl_index_t where = 0;
3192 3193 int error;
3193 3194 int name_length;
3194 3195 int index;
3195 3196 boolean_t check_length = B_FALSE;
3196 3197 ip_stack_t *ipst = ill->ill_ipst;
3197 3198
3198 3199 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock));
3199 3200
3200 3201 name_length = mi_strlen(name) + 1;
3201 3202
3202 3203 if (isv6)
3203 3204 index = IP_V6_G_HEAD;
3204 3205 else
3205 3206 index = IP_V4_G_HEAD;
3206 3207
3207 3208 ill_interface = IP_VX_ILL_G_LIST(index, ipst);
3208 3209 /*
3209 3210 * Search for interface type based on name
3210 3211 */
3211 3212 while (ill_interface != (ill_if_t *)&IP_VX_ILL_G_LIST(index, ipst)) {
3212 3213 if ((ill_interface->illif_name_len == name_length) &&
3213 3214 (strcmp(ill_interface->illif_name, name) == 0)) {
3214 3215 break;
3215 3216 }
3216 3217 ill_interface = ill_interface->illif_next;
3217 3218 }
3218 3219
3219 3220 /*
3220 3221 * Interface type not found, create one.
3221 3222 */
3222 3223 if (ill_interface == (ill_if_t *)&IP_VX_ILL_G_LIST(index, ipst)) {
3223 3224 ill_g_head_t ghead;
3224 3225
3225 3226 /*
3226 3227 * allocate ill_if_t structure
3227 3228 */
3228 3229 ill_interface = (ill_if_t *)mi_zalloc(sizeof (ill_if_t));
3229 3230 if (ill_interface == NULL) {
3230 3231 return (ENOMEM);
3231 3232 }
3232 3233
3233 3234 (void) strcpy(ill_interface->illif_name, name);
3234 3235 ill_interface->illif_name_len = name_length;
3235 3236
3236 3237 avl_create(&ill_interface->illif_avl_by_ppa,
3237 3238 ill_compare_ppa, sizeof (ill_t),
3238 3239 offsetof(struct ill_s, ill_avl_byppa));
3239 3240
3240 3241 /*
3241 3242 * link the structure in the back to maintain order
3242 3243 * of configuration for ifconfig output.
3243 3244 */
3244 3245 ghead = ipst->ips_ill_g_heads[index];
3245 3246 insque(ill_interface, ghead.ill_g_list_tail);
3246 3247 }
3247 3248
3248 3249 if (ill->ill_ppa == UINT_MAX)
3249 3250 check_length = B_TRUE;
3250 3251
3251 3252 error = ill_alloc_ppa(ill_interface, ill);
3252 3253 if (error != 0) {
3253 3254 if (avl_numnodes(&ill_interface->illif_avl_by_ppa) == 0)
3254 3255 ill_delete_interface_type(ill->ill_ifptr);
3255 3256 return (error);
3256 3257 }
3257 3258
3258 3259 /*
3259 3260 * When the ppa is choosen by the system, check that there is
3260 3261 * enough space to insert ppa. if a specific ppa was passed in this
3261 3262 * check is not required as the interface name passed in will have
3262 3263 * the right ppa in it.
3263 3264 */
3264 3265 if (check_length) {
3265 3266 /*
3266 3267 * UINT_MAX - 1 should fit in 10 chars, alloc 12 chars.
3267 3268 */
3268 3269 char buf[sizeof (uint_t) * 3];
3269 3270
3270 3271 /*
3271 3272 * convert ppa to string to calculate the amount of space
3272 3273 * required for it in the name.
3273 3274 */
3274 3275 numtos(ill->ill_ppa, buf);
3275 3276
3276 3277 /* Do we have enough space to insert ppa ? */
3277 3278
3278 3279 if ((mi_strlen(name) + mi_strlen(buf) + 1) > LIFNAMSIZ) {
3279 3280 /* Free ppa and interface type struct */
3280 3281 if (ill_interface->illif_ppa_arena != NULL) {
3281 3282 vmem_free(ill_interface->illif_ppa_arena,
3282 3283 (void *)(uintptr_t)(ill->ill_ppa+1), 1);
3283 3284 }
3284 3285 if (avl_numnodes(&ill_interface->illif_avl_by_ppa) == 0)
3285 3286 ill_delete_interface_type(ill->ill_ifptr);
3286 3287
3287 3288 return (EINVAL);
3288 3289 }
3289 3290 }
3290 3291
3291 3292 (void) sprintf(ill->ill_name, "%s%u", name, ill->ill_ppa);
3292 3293 ill->ill_name_length = mi_strlen(ill->ill_name) + 1;
3293 3294
3294 3295 (void) avl_find(&ill_interface->illif_avl_by_ppa, &ill->ill_ppa,
3295 3296 &where);
3296 3297 ill->ill_ifptr = ill_interface;
3297 3298 avl_insert(&ill_interface->illif_avl_by_ppa, ill, where);
3298 3299
3299 3300 ill_phyint_reinit(ill);
3300 3301 return (0);
3301 3302 }
3302 3303
3303 3304 /* Initialize the per phyint ipsq used for serialization */
3304 3305 static boolean_t
3305 3306 ipsq_init(ill_t *ill, boolean_t enter)
3306 3307 {
3307 3308 ipsq_t *ipsq;
3308 3309 ipxop_t *ipx;
3309 3310
3310 3311 if ((ipsq = kmem_zalloc(sizeof (ipsq_t), KM_NOSLEEP)) == NULL)
3311 3312 return (B_FALSE);
3312 3313
3313 3314 ill->ill_phyint->phyint_ipsq = ipsq;
3314 3315 ipx = ipsq->ipsq_xop = &ipsq->ipsq_ownxop;
3315 3316 ipx->ipx_ipsq = ipsq;
3316 3317 ipsq->ipsq_next = ipsq;
3317 3318 ipsq->ipsq_phyint = ill->ill_phyint;
3318 3319 mutex_init(&ipsq->ipsq_lock, NULL, MUTEX_DEFAULT, 0);
3319 3320 mutex_init(&ipx->ipx_lock, NULL, MUTEX_DEFAULT, 0);
3320 3321 ipsq->ipsq_ipst = ill->ill_ipst; /* No netstack_hold */
3321 3322 if (enter) {
3322 3323 ipx->ipx_writer = curthread;
3323 3324 ipx->ipx_forced = B_FALSE;
3324 3325 ipx->ipx_reentry_cnt = 1;
3325 3326 #ifdef DEBUG
3326 3327 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
3327 3328 #endif
3328 3329 }
3329 3330 return (B_TRUE);
3330 3331 }
3331 3332
3332 3333 /*
3333 3334 * ill_init is called by ip_open when a device control stream is opened.
3334 3335 * It does a few initializations, and shoots a DL_INFO_REQ message down
3335 3336 * to the driver. The response is later picked up in ip_rput_dlpi and
3336 3337 * used to set up default mechanisms for talking to the driver. (Always
3337 3338 * called as writer.)
3338 3339 *
3339 3340 * If this function returns error, ip_open will call ip_close which in
3340 3341 * turn will call ill_delete to clean up any memory allocated here that
3341 3342 * is not yet freed.
3342 3343 */
3343 3344 int
3344 3345 ill_init(queue_t *q, ill_t *ill)
3345 3346 {
3346 3347 int count;
3347 3348 dl_info_req_t *dlir;
3348 3349 mblk_t *info_mp;
3349 3350 uchar_t *frag_ptr;
3350 3351
3351 3352 /*
3352 3353 * The ill is initialized to zero by mi_alloc*(). In addition
3353 3354 * some fields already contain valid values, initialized in
3354 3355 * ip_open(), before we reach here.
3355 3356 */
3356 3357 mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, 0);
3357 3358 mutex_init(&ill->ill_saved_ire_lock, NULL, MUTEX_DEFAULT, NULL);
3358 3359 ill->ill_saved_ire_cnt = 0;
3359 3360
3360 3361 ill->ill_rq = q;
3361 3362 ill->ill_wq = WR(q);
3362 3363
3363 3364 info_mp = allocb(MAX(sizeof (dl_info_req_t), sizeof (dl_info_ack_t)),
3364 3365 BPRI_HI);
3365 3366 if (info_mp == NULL)
3366 3367 return (ENOMEM);
3367 3368
3368 3369 /*
3369 3370 * Allocate sufficient space to contain our fragment hash table and
3370 3371 * the device name.
3371 3372 */
3372 3373 frag_ptr = (uchar_t *)mi_zalloc(ILL_FRAG_HASH_TBL_SIZE + 2 * LIFNAMSIZ);
3373 3374 if (frag_ptr == NULL) {
3374 3375 freemsg(info_mp);
3375 3376 return (ENOMEM);
3376 3377 }
3377 3378 ill->ill_frag_ptr = frag_ptr;
3378 3379 ill->ill_frag_free_num_pkts = 0;
3379 3380 ill->ill_last_frag_clean_time = 0;
3380 3381 ill->ill_frag_hash_tbl = (ipfb_t *)frag_ptr;
3381 3382 ill->ill_name = (char *)(frag_ptr + ILL_FRAG_HASH_TBL_SIZE);
3382 3383 for (count = 0; count < ILL_FRAG_HASH_TBL_COUNT; count++) {
3383 3384 mutex_init(&ill->ill_frag_hash_tbl[count].ipfb_lock,
3384 3385 NULL, MUTEX_DEFAULT, NULL);
3385 3386 }
3386 3387
3387 3388 ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t));
3388 3389 if (ill->ill_phyint == NULL) {
3389 3390 freemsg(info_mp);
3390 3391 mi_free(frag_ptr);
3391 3392 return (ENOMEM);
3392 3393 }
3393 3394
3394 3395 mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0);
3395 3396 /*
3396 3397 * For now pretend this is a v4 ill. We need to set phyint_ill*
3397 3398 * at this point because of the following reason. If we can't
3398 3399 * enter the ipsq at some point and cv_wait, the writer that
3399 3400 * wakes us up tries to locate us using the list of all phyints
3400 3401 * in an ipsq and the ills from the phyint thru the phyint_ill*.
3401 3402 * If we don't set it now, we risk a missed wakeup.
3402 3403 */
3403 3404 ill->ill_phyint->phyint_illv4 = ill;
3404 3405 ill->ill_ppa = UINT_MAX;
3405 3406 list_create(&ill->ill_nce, sizeof (nce_t), offsetof(nce_t, nce_node));
3406 3407
3407 3408 ill_set_inputfn(ill);
3408 3409
3409 3410 if (!ipsq_init(ill, B_TRUE)) {
3410 3411 freemsg(info_mp);
3411 3412 mi_free(frag_ptr);
3412 3413 mi_free(ill->ill_phyint);
3413 3414 return (ENOMEM);
3414 3415 }
3415 3416
3416 3417 ill->ill_state_flags |= ILL_LL_SUBNET_PENDING;
3417 3418
3418 3419 /* Frag queue limit stuff */
3419 3420 ill->ill_frag_count = 0;
3420 3421 ill->ill_ipf_gen = 0;
3421 3422
3422 3423 rw_init(&ill->ill_mcast_lock, NULL, RW_DEFAULT, NULL);
3423 3424 mutex_init(&ill->ill_mcast_serializer, NULL, MUTEX_DEFAULT, NULL);
3424 3425 ill->ill_global_timer = INFINITY;
3425 3426 ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0;
3426 3427 ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0;
3427 3428 ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS;
3428 3429 ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL;
3429 3430
3430 3431 /*
3431 3432 * Initialize IPv6 configuration variables. The IP module is always
3432 3433 * opened as an IPv4 module. Instead tracking down the cases where
3433 3434 * it switches to do ipv6, we'll just initialize the IPv6 configuration
3434 3435 * here for convenience, this has no effect until the ill is set to do
3435 3436 * IPv6.
3436 3437 */
3437 3438 ill->ill_reachable_time = ND_REACHABLE_TIME;
3438 3439 ill->ill_xmit_count = ND_MAX_MULTICAST_SOLICIT;
3439 3440 ill->ill_max_buf = ND_MAX_Q;
3440 3441 ill->ill_refcnt = 0;
3441 3442
3442 3443 /* Send down the Info Request to the driver. */
3443 3444 info_mp->b_datap->db_type = M_PCPROTO;
3444 3445 dlir = (dl_info_req_t *)info_mp->b_rptr;
3445 3446 info_mp->b_wptr = (uchar_t *)&dlir[1];
3446 3447 dlir->dl_primitive = DL_INFO_REQ;
3447 3448
3448 3449 ill->ill_dlpi_pending = DL_PRIM_INVAL;
3449 3450
3450 3451 qprocson(q);
3451 3452 ill_dlpi_send(ill, info_mp);
3452 3453
3453 3454 return (0);
3454 3455 }
3455 3456
3456 3457 /*
3457 3458 * ill_dls_info
3458 3459 * creates datalink socket info from the device.
3459 3460 */
3460 3461 int
3461 3462 ill_dls_info(struct sockaddr_dl *sdl, const ill_t *ill)
3462 3463 {
3463 3464 size_t len;
3464 3465
3465 3466 sdl->sdl_family = AF_LINK;
3466 3467 sdl->sdl_index = ill_get_upper_ifindex(ill);
3467 3468 sdl->sdl_type = ill->ill_type;
3468 3469 ill_get_name(ill, sdl->sdl_data, sizeof (sdl->sdl_data));
3469 3470 len = strlen(sdl->sdl_data);
3470 3471 ASSERT(len < 256);
3471 3472 sdl->sdl_nlen = (uchar_t)len;
3472 3473 sdl->sdl_alen = ill->ill_phys_addr_length;
3473 3474 sdl->sdl_slen = 0;
3474 3475 if (ill->ill_phys_addr_length != 0 && ill->ill_phys_addr != NULL)
3475 3476 bcopy(ill->ill_phys_addr, &sdl->sdl_data[len], sdl->sdl_alen);
3476 3477
3477 3478 return (sizeof (struct sockaddr_dl));
3478 3479 }
3479 3480
3480 3481 /*
3481 3482 * ill_xarp_info
3482 3483 * creates xarp info from the device.
3483 3484 */
3484 3485 static int
3485 3486 ill_xarp_info(struct sockaddr_dl *sdl, ill_t *ill)
3486 3487 {
3487 3488 sdl->sdl_family = AF_LINK;
3488 3489 sdl->sdl_index = ill->ill_phyint->phyint_ifindex;
3489 3490 sdl->sdl_type = ill->ill_type;
3490 3491 ill_get_name(ill, sdl->sdl_data, sizeof (sdl->sdl_data));
3491 3492 sdl->sdl_nlen = (uchar_t)mi_strlen(sdl->sdl_data);
3492 3493 sdl->sdl_alen = ill->ill_phys_addr_length;
3493 3494 sdl->sdl_slen = 0;
3494 3495 return (sdl->sdl_nlen);
3495 3496 }
3496 3497
3497 3498 static int
3498 3499 loopback_kstat_update(kstat_t *ksp, int rw)
3499 3500 {
3500 3501 kstat_named_t *kn;
3501 3502 netstackid_t stackid;
3502 3503 netstack_t *ns;
3503 3504 ip_stack_t *ipst;
3504 3505
3505 3506 if (ksp == NULL || ksp->ks_data == NULL)
3506 3507 return (EIO);
3507 3508
3508 3509 if (rw == KSTAT_WRITE)
3509 3510 return (EACCES);
3510 3511
3511 3512 kn = KSTAT_NAMED_PTR(ksp);
3512 3513 stackid = (zoneid_t)(uintptr_t)ksp->ks_private;
3513 3514
3514 3515 ns = netstack_find_by_stackid(stackid);
3515 3516 if (ns == NULL)
3516 3517 return (-1);
3517 3518
3518 3519 ipst = ns->netstack_ip;
3519 3520 if (ipst == NULL) {
3520 3521 netstack_rele(ns);
3521 3522 return (-1);
3522 3523 }
3523 3524 kn[0].value.ui32 = ipst->ips_loopback_packets;
3524 3525 kn[1].value.ui32 = ipst->ips_loopback_packets;
3525 3526 netstack_rele(ns);
3526 3527 return (0);
3527 3528 }
3528 3529
3529 3530 /*
3530 3531 * Has ifindex been plumbed already?
3531 3532 */
3532 3533 static boolean_t
3533 3534 phyint_exists(uint_t index, ip_stack_t *ipst)
3534 3535 {
3535 3536 ASSERT(index != 0);
3536 3537 ASSERT(RW_LOCK_HELD(&ipst->ips_ill_g_lock));
3537 3538
3538 3539 return (avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3539 3540 &index, NULL) != NULL);
3540 3541 }
3541 3542
3542 3543 /*
3543 3544 * Pick a unique ifindex.
3544 3545 * When the index counter passes IF_INDEX_MAX for the first time, the wrap
3545 3546 * flag is set so that next time time ip_assign_ifindex() is called, it
3546 3547 * falls through and resets the index counter back to 1, the minimum value
3547 3548 * for the interface index. The logic below assumes that ips_ill_index
3548 3549 * can hold a value of IF_INDEX_MAX+1 without there being any loss
3549 3550 * (i.e. reset back to 0.)
3550 3551 */
3551 3552 boolean_t
3552 3553 ip_assign_ifindex(uint_t *indexp, ip_stack_t *ipst)
3553 3554 {
3554 3555 uint_t loops;
3555 3556
3556 3557 if (!ipst->ips_ill_index_wrap) {
3557 3558 *indexp = ipst->ips_ill_index++;
3558 3559 if (ipst->ips_ill_index > IF_INDEX_MAX) {
3559 3560 /*
3560 3561 * Reached the maximum ifindex value, set the wrap
3561 3562 * flag to indicate that it is no longer possible
3562 3563 * to assume that a given index is unallocated.
3563 3564 */
3564 3565 ipst->ips_ill_index_wrap = B_TRUE;
3565 3566 }
3566 3567 return (B_TRUE);
3567 3568 }
3568 3569
3569 3570 if (ipst->ips_ill_index > IF_INDEX_MAX)
3570 3571 ipst->ips_ill_index = 1;
3571 3572
3572 3573 /*
3573 3574 * Start reusing unused indexes. Note that we hold the ill_g_lock
3574 3575 * at this point and don't want to call any function that attempts
3575 3576 * to get the lock again.
3576 3577 */
3577 3578 for (loops = IF_INDEX_MAX; loops > 0; loops--) {
3578 3579 if (!phyint_exists(ipst->ips_ill_index, ipst)) {
3579 3580 /* found unused index - use it */
3580 3581 *indexp = ipst->ips_ill_index;
3581 3582 return (B_TRUE);
3582 3583 }
3583 3584
3584 3585 ipst->ips_ill_index++;
3585 3586 if (ipst->ips_ill_index > IF_INDEX_MAX)
3586 3587 ipst->ips_ill_index = 1;
3587 3588 }
3588 3589
3589 3590 /*
3590 3591 * all interface indicies are inuse.
3591 3592 */
3592 3593 return (B_FALSE);
3593 3594 }
3594 3595
3595 3596 /*
3596 3597 * Assign a unique interface index for the phyint.
3597 3598 */
3598 3599 static boolean_t
3599 3600 phyint_assign_ifindex(phyint_t *phyi, ip_stack_t *ipst)
3600 3601 {
3601 3602 ASSERT(phyi->phyint_ifindex == 0);
3602 3603 return (ip_assign_ifindex(&phyi->phyint_ifindex, ipst));
3603 3604 }
3604 3605
3605 3606 /*
3606 3607 * Initialize the flags on `phyi' as per the provided mactype.
3607 3608 */
3608 3609 static void
3609 3610 phyint_flags_init(phyint_t *phyi, t_uscalar_t mactype)
3610 3611 {
3611 3612 uint64_t flags = 0;
3612 3613
3613 3614 /*
3614 3615 * Initialize PHYI_RUNNING and PHYI_FAILED. For non-IPMP interfaces,
3615 3616 * we always presume the underlying hardware is working and set
3616 3617 * PHYI_RUNNING (if it's not, the driver will subsequently send a
3617 3618 * DL_NOTE_LINK_DOWN message). For IPMP interfaces, at initialization
3618 3619 * there are no active interfaces in the group so we set PHYI_FAILED.
3619 3620 */
3620 3621 if (mactype == SUNW_DL_IPMP)
3621 3622 flags |= PHYI_FAILED;
3622 3623 else
3623 3624 flags |= PHYI_RUNNING;
3624 3625
3625 3626 switch (mactype) {
3626 3627 case SUNW_DL_VNI:
3627 3628 flags |= PHYI_VIRTUAL;
3628 3629 break;
3629 3630 case SUNW_DL_IPMP:
3630 3631 flags |= PHYI_IPMP;
3631 3632 break;
3632 3633 case DL_LOOP:
3633 3634 flags |= (PHYI_LOOPBACK | PHYI_VIRTUAL);
3634 3635 break;
3635 3636 }
3636 3637
3637 3638 mutex_enter(&phyi->phyint_lock);
3638 3639 phyi->phyint_flags |= flags;
3639 3640 mutex_exit(&phyi->phyint_lock);
3640 3641 }
3641 3642
3642 3643 /*
3643 3644 * Return a pointer to the ill which matches the supplied name. Note that
3644 3645 * the ill name length includes the null termination character. (May be
3645 3646 * called as writer.)
3646 3647 * If do_alloc and the interface is "lo0" it will be automatically created.
3647 3648 * Cannot bump up reference on condemned ills. So dup detect can't be done
3648 3649 * using this func.
3649 3650 */
3650 3651 ill_t *
3651 3652 ill_lookup_on_name(char *name, boolean_t do_alloc, boolean_t isv6,
3652 3653 boolean_t *did_alloc, ip_stack_t *ipst)
3653 3654 {
3654 3655 ill_t *ill;
3655 3656 ipif_t *ipif;
3656 3657 ipsq_t *ipsq;
3657 3658 kstat_named_t *kn;
3658 3659 boolean_t isloopback;
3659 3660 in6_addr_t ov6addr;
3660 3661
3661 3662 isloopback = mi_strcmp(name, ipif_loopback_name) == 0;
3662 3663
3663 3664 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
3664 3665 ill = ill_find_by_name(name, isv6, ipst);
3665 3666 rw_exit(&ipst->ips_ill_g_lock);
3666 3667 if (ill != NULL)
3667 3668 return (ill);
3668 3669
3669 3670 /*
3670 3671 * Couldn't find it. Does this happen to be a lookup for the
3671 3672 * loopback device and are we allowed to allocate it?
3672 3673 */
3673 3674 if (!isloopback || !do_alloc)
3674 3675 return (NULL);
3675 3676
3676 3677 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
3677 3678 ill = ill_find_by_name(name, isv6, ipst);
3678 3679 if (ill != NULL) {
3679 3680 rw_exit(&ipst->ips_ill_g_lock);
3680 3681 return (ill);
3681 3682 }
3682 3683
3683 3684 /* Create the loopback device on demand */
3684 3685 ill = (ill_t *)(mi_alloc(sizeof (ill_t) +
3685 3686 sizeof (ipif_loopback_name), BPRI_MED));
3686 3687 if (ill == NULL)
3687 3688 goto done;
3688 3689
3689 3690 *ill = ill_null;
3690 3691 mutex_init(&ill->ill_lock, NULL, MUTEX_DEFAULT, NULL);
3691 3692 ill->ill_ipst = ipst;
3692 3693 list_create(&ill->ill_nce, sizeof (nce_t), offsetof(nce_t, nce_node));
3693 3694 netstack_hold(ipst->ips_netstack);
3694 3695 /*
3695 3696 * For exclusive stacks we set the zoneid to zero
3696 3697 * to make IP operate as if in the global zone.
3697 3698 */
3698 3699 ill->ill_zoneid = GLOBAL_ZONEID;
3699 3700
3700 3701 ill->ill_phyint = (phyint_t *)mi_zalloc(sizeof (phyint_t));
3701 3702 if (ill->ill_phyint == NULL)
3702 3703 goto done;
3703 3704
3704 3705 if (isv6)
3705 3706 ill->ill_phyint->phyint_illv6 = ill;
3706 3707 else
3707 3708 ill->ill_phyint->phyint_illv4 = ill;
3708 3709 mutex_init(&ill->ill_phyint->phyint_lock, NULL, MUTEX_DEFAULT, 0);
3709 3710 phyint_flags_init(ill->ill_phyint, DL_LOOP);
3710 3711
3711 3712 if (isv6) {
3712 3713 ill->ill_isv6 = B_TRUE;
3713 3714 ill->ill_max_frag = ip_loopback_mtu_v6plus;
3714 3715 } else {
3715 3716 ill->ill_max_frag = ip_loopback_mtuplus;
3716 3717 }
3717 3718 if (!ill_allocate_mibs(ill))
3718 3719 goto done;
3719 3720 ill->ill_current_frag = ill->ill_max_frag;
3720 3721 ill->ill_mtu = ill->ill_max_frag; /* Initial value */
3721 3722 ill->ill_mc_mtu = ill->ill_mtu;
3722 3723 /*
3723 3724 * ipif_loopback_name can't be pointed at directly because its used
3724 3725 * by both the ipv4 and ipv6 interfaces. When the ill is removed
3725 3726 * from the glist, ill_glist_delete() sets the first character of
3726 3727 * ill_name to '\0'.
3727 3728 */
3728 3729 ill->ill_name = (char *)ill + sizeof (*ill);
3729 3730 (void) strcpy(ill->ill_name, ipif_loopback_name);
3730 3731 ill->ill_name_length = sizeof (ipif_loopback_name);
3731 3732 /* Set ill_dlpi_pending for ipsq_current_finish() to work properly */
3732 3733 ill->ill_dlpi_pending = DL_PRIM_INVAL;
3733 3734
3734 3735 rw_init(&ill->ill_mcast_lock, NULL, RW_DEFAULT, NULL);
3735 3736 mutex_init(&ill->ill_mcast_serializer, NULL, MUTEX_DEFAULT, NULL);
3736 3737 ill->ill_global_timer = INFINITY;
3737 3738 ill->ill_mcast_v1_time = ill->ill_mcast_v2_time = 0;
3738 3739 ill->ill_mcast_v1_tset = ill->ill_mcast_v2_tset = 0;
3739 3740 ill->ill_mcast_rv = MCAST_DEF_ROBUSTNESS;
3740 3741 ill->ill_mcast_qi = MCAST_DEF_QUERY_INTERVAL;
3741 3742
3742 3743 /* No resolver here. */
3743 3744 ill->ill_net_type = IRE_LOOPBACK;
3744 3745
3745 3746 /* Initialize the ipsq */
3746 3747 if (!ipsq_init(ill, B_FALSE))
3747 3748 goto done;
3748 3749
3749 3750 ipif = ipif_allocate(ill, 0L, IRE_LOOPBACK, B_TRUE, B_TRUE, NULL);
3750 3751 if (ipif == NULL)
3751 3752 goto done;
3752 3753
3753 3754 ill->ill_flags = ILLF_MULTICAST;
3754 3755
3755 3756 ov6addr = ipif->ipif_v6lcl_addr;
3756 3757 /* Set up default loopback address and mask. */
3757 3758 if (!isv6) {
3758 3759 ipaddr_t inaddr_loopback = htonl(INADDR_LOOPBACK);
3759 3760
3760 3761 IN6_IPADDR_TO_V4MAPPED(inaddr_loopback, &ipif->ipif_v6lcl_addr);
3761 3762 V4MASK_TO_V6(htonl(IN_CLASSA_NET), ipif->ipif_v6net_mask);
3762 3763 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
3763 3764 ipif->ipif_v6subnet);
3764 3765 ill->ill_flags |= ILLF_IPV4;
3765 3766 } else {
3766 3767 ipif->ipif_v6lcl_addr = ipv6_loopback;
3767 3768 ipif->ipif_v6net_mask = ipv6_all_ones;
3768 3769 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
3769 3770 ipif->ipif_v6subnet);
3770 3771 ill->ill_flags |= ILLF_IPV6;
3771 3772 }
3772 3773
3773 3774 /*
3774 3775 * Chain us in at the end of the ill list. hold the ill
3775 3776 * before we make it globally visible. 1 for the lookup.
3776 3777 */
3777 3778 ill->ill_refcnt = 0;
3778 3779 ill_refhold(ill);
3779 3780
3780 3781 ill->ill_frag_count = 0;
3781 3782 ill->ill_frag_free_num_pkts = 0;
3782 3783 ill->ill_last_frag_clean_time = 0;
3783 3784
3784 3785 ipsq = ill->ill_phyint->phyint_ipsq;
3785 3786
3786 3787 ill_set_inputfn(ill);
3787 3788
3788 3789 if (ill_glist_insert(ill, "lo", isv6) != 0)
3789 3790 cmn_err(CE_PANIC, "cannot insert loopback interface");
3790 3791
3791 3792 /* Let SCTP know so that it can add this to its list */
3792 3793 sctp_update_ill(ill, SCTP_ILL_INSERT);
3793 3794
3794 3795 /*
3795 3796 * We have already assigned ipif_v6lcl_addr above, but we need to
3796 3797 * call sctp_update_ipif_addr() after SCTP_ILL_INSERT, which
3797 3798 * requires to be after ill_glist_insert() since we need the
3798 3799 * ill_index set. Pass on ipv6_loopback as the old address.
3799 3800 */
3800 3801 sctp_update_ipif_addr(ipif, ov6addr);
3801 3802
3802 3803 ip_rts_newaddrmsg(RTM_CHGADDR, 0, ipif, RTSQ_DEFAULT);
3803 3804
3804 3805 /*
3805 3806 * ill_glist_insert() -> ill_phyint_reinit() may have merged IPSQs.
3806 3807 * If so, free our original one.
3807 3808 */
3808 3809 if (ipsq != ill->ill_phyint->phyint_ipsq)
3809 3810 ipsq_delete(ipsq);
3810 3811
3811 3812 if (ipst->ips_loopback_ksp == NULL) {
3812 3813 /* Export loopback interface statistics */
3813 3814 ipst->ips_loopback_ksp = kstat_create_netstack("lo", 0,
3814 3815 ipif_loopback_name, "net",
3815 3816 KSTAT_TYPE_NAMED, 2, 0,
3816 3817 ipst->ips_netstack->netstack_stackid);
3817 3818 if (ipst->ips_loopback_ksp != NULL) {
3818 3819 ipst->ips_loopback_ksp->ks_update =
3819 3820 loopback_kstat_update;
3820 3821 kn = KSTAT_NAMED_PTR(ipst->ips_loopback_ksp);
3821 3822 kstat_named_init(&kn[0], "ipackets", KSTAT_DATA_UINT32);
3822 3823 kstat_named_init(&kn[1], "opackets", KSTAT_DATA_UINT32);
3823 3824 ipst->ips_loopback_ksp->ks_private =
3824 3825 (void *)(uintptr_t)ipst->ips_netstack->
3825 3826 netstack_stackid;
3826 3827 kstat_install(ipst->ips_loopback_ksp);
3827 3828 }
3828 3829 }
3829 3830
3830 3831 *did_alloc = B_TRUE;
3831 3832 rw_exit(&ipst->ips_ill_g_lock);
3832 3833 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ill->ill_ipif->ipif_id),
3833 3834 NE_PLUMB, ill->ill_name, ill->ill_name_length);
3834 3835 return (ill);
3835 3836 done:
3836 3837 if (ill != NULL) {
3837 3838 if (ill->ill_phyint != NULL) {
3838 3839 ipsq = ill->ill_phyint->phyint_ipsq;
3839 3840 if (ipsq != NULL) {
3840 3841 ipsq->ipsq_phyint = NULL;
3841 3842 ipsq_delete(ipsq);
3842 3843 }
3843 3844 mi_free(ill->ill_phyint);
3844 3845 }
3845 3846 ill_free_mib(ill);
3846 3847 if (ill->ill_ipst != NULL)
3847 3848 netstack_rele(ill->ill_ipst->ips_netstack);
3848 3849 mi_free(ill);
3849 3850 }
3850 3851 rw_exit(&ipst->ips_ill_g_lock);
3851 3852 return (NULL);
3852 3853 }
3853 3854
3854 3855 /*
3855 3856 * For IPP calls - use the ip_stack_t for global stack.
3856 3857 */
3857 3858 ill_t *
3858 3859 ill_lookup_on_ifindex_global_instance(uint_t index, boolean_t isv6)
3859 3860 {
3860 3861 ip_stack_t *ipst;
3861 3862 ill_t *ill;
3862 3863
3863 3864 ipst = netstack_find_by_stackid(GLOBAL_NETSTACKID)->netstack_ip;
3864 3865 if (ipst == NULL) {
3865 3866 cmn_err(CE_WARN, "No ip_stack_t for zoneid zero!\n");
3866 3867 return (NULL);
3867 3868 }
3868 3869
3869 3870 ill = ill_lookup_on_ifindex(index, isv6, ipst);
3870 3871 netstack_rele(ipst->ips_netstack);
3871 3872 return (ill);
3872 3873 }
3873 3874
3874 3875 /*
3875 3876 * Return a pointer to the ill which matches the index and IP version type.
3876 3877 */
3877 3878 ill_t *
3878 3879 ill_lookup_on_ifindex(uint_t index, boolean_t isv6, ip_stack_t *ipst)
3879 3880 {
3880 3881 ill_t *ill;
3881 3882 phyint_t *phyi;
3882 3883
3883 3884 /*
3884 3885 * Indexes are stored in the phyint - a common structure
3885 3886 * to both IPv4 and IPv6.
3886 3887 */
3887 3888 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
3888 3889 phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3889 3890 (void *) &index, NULL);
3890 3891 if (phyi != NULL) {
3891 3892 ill = isv6 ? phyi->phyint_illv6: phyi->phyint_illv4;
3892 3893 if (ill != NULL) {
3893 3894 mutex_enter(&ill->ill_lock);
3894 3895 if (!ILL_IS_CONDEMNED(ill)) {
3895 3896 ill_refhold_locked(ill);
3896 3897 mutex_exit(&ill->ill_lock);
3897 3898 rw_exit(&ipst->ips_ill_g_lock);
3898 3899 return (ill);
3899 3900 }
3900 3901 mutex_exit(&ill->ill_lock);
3901 3902 }
3902 3903 }
3903 3904 rw_exit(&ipst->ips_ill_g_lock);
3904 3905 return (NULL);
3905 3906 }
3906 3907
3907 3908 /*
3908 3909 * Verify whether or not an interface index is valid for the specified zoneid
3909 3910 * to transmit packets.
3910 3911 * It can be zero (meaning "reset") or an interface index assigned
3911 3912 * to a non-VNI interface. (We don't use VNI interface to send packets.)
3912 3913 */
3913 3914 boolean_t
3914 3915 ip_xmit_ifindex_valid(uint_t ifindex, zoneid_t zoneid, boolean_t isv6,
3915 3916 ip_stack_t *ipst)
3916 3917 {
3917 3918 ill_t *ill;
3918 3919
3919 3920 if (ifindex == 0)
3920 3921 return (B_TRUE);
3921 3922
3922 3923 ill = ill_lookup_on_ifindex_zoneid(ifindex, zoneid, isv6, ipst);
3923 3924 if (ill == NULL)
3924 3925 return (B_FALSE);
3925 3926 if (IS_VNI(ill)) {
3926 3927 ill_refrele(ill);
3927 3928 return (B_FALSE);
3928 3929 }
3929 3930 ill_refrele(ill);
3930 3931 return (B_TRUE);
3931 3932 }
3932 3933
3933 3934 /*
3934 3935 * Return the ifindex next in sequence after the passed in ifindex.
3935 3936 * If there is no next ifindex for the given protocol, return 0.
3936 3937 */
3937 3938 uint_t
3938 3939 ill_get_next_ifindex(uint_t index, boolean_t isv6, ip_stack_t *ipst)
3939 3940 {
3940 3941 phyint_t *phyi;
3941 3942 phyint_t *phyi_initial;
3942 3943 uint_t ifindex;
3943 3944
3944 3945 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
3945 3946
3946 3947 if (index == 0) {
3947 3948 phyi = avl_first(
3948 3949 &ipst->ips_phyint_g_list->phyint_list_avl_by_index);
3949 3950 } else {
3950 3951 phyi = phyi_initial = avl_find(
3951 3952 &ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3952 3953 (void *) &index, NULL);
3953 3954 }
3954 3955
3955 3956 for (; phyi != NULL;
3956 3957 phyi = avl_walk(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
3957 3958 phyi, AVL_AFTER)) {
3958 3959 /*
3959 3960 * If we're not returning the first interface in the tree
3960 3961 * and we still haven't moved past the phyint_t that
3961 3962 * corresponds to index, avl_walk needs to be called again
3962 3963 */
3963 3964 if (!((index != 0) && (phyi == phyi_initial))) {
3964 3965 if (isv6) {
3965 3966 if ((phyi->phyint_illv6) &&
3966 3967 ILL_CAN_LOOKUP(phyi->phyint_illv6) &&
3967 3968 (phyi->phyint_illv6->ill_isv6 == 1))
3968 3969 break;
3969 3970 } else {
3970 3971 if ((phyi->phyint_illv4) &&
3971 3972 ILL_CAN_LOOKUP(phyi->phyint_illv4) &&
3972 3973 (phyi->phyint_illv4->ill_isv6 == 0))
3973 3974 break;
3974 3975 }
3975 3976 }
3976 3977 }
3977 3978
3978 3979 rw_exit(&ipst->ips_ill_g_lock);
3979 3980
3980 3981 if (phyi != NULL)
3981 3982 ifindex = phyi->phyint_ifindex;
3982 3983 else
3983 3984 ifindex = 0;
3984 3985
3985 3986 return (ifindex);
3986 3987 }
3987 3988
3988 3989 /*
3989 3990 * Return the ifindex for the named interface.
3990 3991 * If there is no next ifindex for the interface, return 0.
3991 3992 */
3992 3993 uint_t
3993 3994 ill_get_ifindex_by_name(char *name, ip_stack_t *ipst)
3994 3995 {
3995 3996 phyint_t *phyi;
3996 3997 avl_index_t where = 0;
3997 3998 uint_t ifindex;
3998 3999
3999 4000 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4000 4001
4001 4002 if ((phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
4002 4003 name, &where)) == NULL) {
4003 4004 rw_exit(&ipst->ips_ill_g_lock);
4004 4005 return (0);
4005 4006 }
4006 4007
4007 4008 ifindex = phyi->phyint_ifindex;
4008 4009
4009 4010 rw_exit(&ipst->ips_ill_g_lock);
4010 4011
4011 4012 return (ifindex);
4012 4013 }
4013 4014
4014 4015 /*
4015 4016 * Return the ifindex to be used by upper layer protocols for instance
4016 4017 * for IPV6_RECVPKTINFO. If IPMP this is the one for the upper ill.
4017 4018 */
4018 4019 uint_t
4019 4020 ill_get_upper_ifindex(const ill_t *ill)
4020 4021 {
4021 4022 if (IS_UNDER_IPMP(ill))
4022 4023 return (ipmp_ill_get_ipmp_ifindex(ill));
4023 4024 else
4024 4025 return (ill->ill_phyint->phyint_ifindex);
4025 4026 }
4026 4027
4027 4028
4028 4029 /*
4029 4030 * Obtain a reference to the ill. The ill_refcnt is a dynamic refcnt
4030 4031 * that gives a running thread a reference to the ill. This reference must be
4031 4032 * released by the thread when it is done accessing the ill and related
4032 4033 * objects. ill_refcnt can not be used to account for static references
4033 4034 * such as other structures pointing to an ill. Callers must generally
4034 4035 * check whether an ill can be refheld by using ILL_CAN_LOOKUP macros
4035 4036 * or be sure that the ill is not being deleted or changing state before
4036 4037 * calling the refhold functions. A non-zero ill_refcnt ensures that the
4037 4038 * ill won't change any of its critical state such as address, netmask etc.
4038 4039 */
4039 4040 void
4040 4041 ill_refhold(ill_t *ill)
4041 4042 {
4042 4043 mutex_enter(&ill->ill_lock);
4043 4044 ill->ill_refcnt++;
4044 4045 ILL_TRACE_REF(ill);
4045 4046 mutex_exit(&ill->ill_lock);
4046 4047 }
4047 4048
4048 4049 void
4049 4050 ill_refhold_locked(ill_t *ill)
4050 4051 {
4051 4052 ASSERT(MUTEX_HELD(&ill->ill_lock));
4052 4053 ill->ill_refcnt++;
4053 4054 ILL_TRACE_REF(ill);
4054 4055 }
4055 4056
4056 4057 /* Returns true if we managed to get a refhold */
4057 4058 boolean_t
4058 4059 ill_check_and_refhold(ill_t *ill)
4059 4060 {
4060 4061 mutex_enter(&ill->ill_lock);
4061 4062 if (!ILL_IS_CONDEMNED(ill)) {
4062 4063 ill_refhold_locked(ill);
4063 4064 mutex_exit(&ill->ill_lock);
4064 4065 return (B_TRUE);
4065 4066 }
4066 4067 mutex_exit(&ill->ill_lock);
4067 4068 return (B_FALSE);
4068 4069 }
4069 4070
4070 4071 /*
4071 4072 * Must not be called while holding any locks. Otherwise if this is
4072 4073 * the last reference to be released, there is a chance of recursive mutex
4073 4074 * panic due to ill_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
4074 4075 * to restart an ioctl.
4075 4076 */
4076 4077 void
4077 4078 ill_refrele(ill_t *ill)
4078 4079 {
4079 4080 mutex_enter(&ill->ill_lock);
4080 4081 ASSERT(ill->ill_refcnt != 0);
4081 4082 ill->ill_refcnt--;
4082 4083 ILL_UNTRACE_REF(ill);
4083 4084 if (ill->ill_refcnt != 0) {
4084 4085 /* Every ire pointing to the ill adds 1 to ill_refcnt */
4085 4086 mutex_exit(&ill->ill_lock);
4086 4087 return;
4087 4088 }
4088 4089
4089 4090 /* Drops the ill_lock */
4090 4091 ipif_ill_refrele_tail(ill);
4091 4092 }
4092 4093
4093 4094 /*
4094 4095 * Obtain a weak reference count on the ill. This reference ensures the
4095 4096 * ill won't be freed, but the ill may change any of its critical state
4096 4097 * such as netmask, address etc. Returns an error if the ill has started
4097 4098 * closing.
4098 4099 */
4099 4100 boolean_t
4100 4101 ill_waiter_inc(ill_t *ill)
4101 4102 {
4102 4103 mutex_enter(&ill->ill_lock);
4103 4104 if (ill->ill_state_flags & ILL_CONDEMNED) {
4104 4105 mutex_exit(&ill->ill_lock);
4105 4106 return (B_FALSE);
4106 4107 }
4107 4108 ill->ill_waiters++;
4108 4109 mutex_exit(&ill->ill_lock);
4109 4110 return (B_TRUE);
4110 4111 }
4111 4112
4112 4113 void
4113 4114 ill_waiter_dcr(ill_t *ill)
4114 4115 {
4115 4116 mutex_enter(&ill->ill_lock);
4116 4117 ill->ill_waiters--;
4117 4118 if (ill->ill_waiters == 0)
4118 4119 cv_broadcast(&ill->ill_cv);
4119 4120 mutex_exit(&ill->ill_lock);
4120 4121 }
4121 4122
4122 4123 /*
4123 4124 * ip_ll_subnet_defaults is called when we get the DL_INFO_ACK back from the
4124 4125 * driver. We construct best guess defaults for lower level information that
4125 4126 * we need. If an interface is brought up without injection of any overriding
4126 4127 * information from outside, we have to be ready to go with these defaults.
4127 4128 * When we get the first DL_INFO_ACK (from ip_open() sending a DL_INFO_REQ)
4128 4129 * we primarely want the dl_provider_style.
4129 4130 * The subsequent DL_INFO_ACK is received after doing a DL_ATTACH and DL_BIND
4130 4131 * at which point we assume the other part of the information is valid.
4131 4132 */
4132 4133 void
4133 4134 ip_ll_subnet_defaults(ill_t *ill, mblk_t *mp)
4134 4135 {
4135 4136 uchar_t *brdcst_addr;
4136 4137 uint_t brdcst_addr_length, phys_addr_length;
4137 4138 t_scalar_t sap_length;
4138 4139 dl_info_ack_t *dlia;
4139 4140 ip_m_t *ipm;
4140 4141 dl_qos_cl_sel1_t *sel1;
4141 4142 int min_mtu;
4142 4143
4143 4144 ASSERT(IAM_WRITER_ILL(ill));
4144 4145
4145 4146 /*
4146 4147 * Till the ill is fully up the ill is not globally visible.
4147 4148 * So no need for a lock.
4148 4149 */
4149 4150 dlia = (dl_info_ack_t *)mp->b_rptr;
4150 4151 ill->ill_mactype = dlia->dl_mac_type;
4151 4152
4152 4153 ipm = ip_m_lookup(dlia->dl_mac_type);
4153 4154 if (ipm == NULL) {
4154 4155 ipm = ip_m_lookup(DL_OTHER);
4155 4156 ASSERT(ipm != NULL);
4156 4157 }
4157 4158 ill->ill_media = ipm;
4158 4159
4159 4160 /*
4160 4161 * When the new DLPI stuff is ready we'll pull lengths
4161 4162 * from dlia.
4162 4163 */
4163 4164 if (dlia->dl_version == DL_VERSION_2) {
4164 4165 brdcst_addr_length = dlia->dl_brdcst_addr_length;
4165 4166 brdcst_addr = mi_offset_param(mp, dlia->dl_brdcst_addr_offset,
4166 4167 brdcst_addr_length);
4167 4168 if (brdcst_addr == NULL) {
4168 4169 brdcst_addr_length = 0;
4169 4170 }
4170 4171 sap_length = dlia->dl_sap_length;
4171 4172 phys_addr_length = dlia->dl_addr_length - ABS(sap_length);
4172 4173 ip1dbg(("ip: bcast_len %d, sap_len %d, phys_len %d\n",
4173 4174 brdcst_addr_length, sap_length, phys_addr_length));
4174 4175 } else {
4175 4176 brdcst_addr_length = 6;
4176 4177 brdcst_addr = ip_six_byte_all_ones;
4177 4178 sap_length = -2;
4178 4179 phys_addr_length = brdcst_addr_length;
4179 4180 }
4180 4181
4181 4182 ill->ill_bcast_addr_length = brdcst_addr_length;
4182 4183 ill->ill_phys_addr_length = phys_addr_length;
4183 4184 ill->ill_sap_length = sap_length;
4184 4185
4185 4186 /*
4186 4187 * Synthetic DLPI types such as SUNW_DL_IPMP specify a zero SDU,
4187 4188 * but we must ensure a minimum IP MTU is used since other bits of
4188 4189 * IP will fly apart otherwise.
4189 4190 */
4190 4191 min_mtu = ill->ill_isv6 ? IPV6_MIN_MTU : IP_MIN_MTU;
4191 4192 ill->ill_max_frag = MAX(min_mtu, dlia->dl_max_sdu);
4192 4193 ill->ill_current_frag = ill->ill_max_frag;
4193 4194 ill->ill_mtu = ill->ill_max_frag;
4194 4195 ill->ill_mc_mtu = ill->ill_mtu; /* Overridden by DL_NOTE_SDU_SIZE2 */
4195 4196
4196 4197 ill->ill_type = ipm->ip_m_type;
4197 4198
4198 4199 if (!ill->ill_dlpi_style_set) {
4199 4200 if (dlia->dl_provider_style == DL_STYLE2)
4200 4201 ill->ill_needs_attach = 1;
4201 4202
4202 4203 phyint_flags_init(ill->ill_phyint, ill->ill_mactype);
4203 4204
4204 4205 /*
4205 4206 * Allocate the first ipif on this ill. We don't delay it
4206 4207 * further as ioctl handling assumes at least one ipif exists.
4207 4208 *
4208 4209 * At this point we don't know whether the ill is v4 or v6.
4209 4210 * We will know this whan the SIOCSLIFNAME happens and
4210 4211 * the correct value for ill_isv6 will be assigned in
4211 4212 * ipif_set_values(). We need to hold the ill lock and
4212 4213 * clear the ILL_LL_SUBNET_PENDING flag and atomically do
4213 4214 * the wakeup.
4214 4215 */
4215 4216 (void) ipif_allocate(ill, 0, IRE_LOCAL,
4216 4217 dlia->dl_provider_style != DL_STYLE2, B_TRUE, NULL);
4217 4218 mutex_enter(&ill->ill_lock);
4218 4219 ASSERT(ill->ill_dlpi_style_set == 0);
4219 4220 ill->ill_dlpi_style_set = 1;
4220 4221 ill->ill_state_flags &= ~ILL_LL_SUBNET_PENDING;
4221 4222 cv_broadcast(&ill->ill_cv);
4222 4223 mutex_exit(&ill->ill_lock);
4223 4224 freemsg(mp);
4224 4225 return;
4225 4226 }
4226 4227 ASSERT(ill->ill_ipif != NULL);
4227 4228 /*
4228 4229 * We know whether it is IPv4 or IPv6 now, as this is the
4229 4230 * second DL_INFO_ACK we are recieving in response to the
4230 4231 * DL_INFO_REQ sent in ipif_set_values.
4231 4232 */
4232 4233 ill->ill_sap = (ill->ill_isv6) ? ipm->ip_m_ipv6sap : ipm->ip_m_ipv4sap;
4233 4234 /*
4234 4235 * Clear all the flags that were set based on ill_bcast_addr_length
4235 4236 * and ill_phys_addr_length (in ipif_set_values) as these could have
4236 4237 * changed now and we need to re-evaluate.
4237 4238 */
4238 4239 ill->ill_flags &= ~(ILLF_MULTICAST | ILLF_NONUD | ILLF_NOARP);
4239 4240 ill->ill_ipif->ipif_flags &= ~(IPIF_BROADCAST | IPIF_POINTOPOINT);
4240 4241
4241 4242 /*
4242 4243 * Free ill_bcast_mp as things could have changed now.
4243 4244 *
4244 4245 * NOTE: The IPMP meta-interface is special-cased because it starts
4245 4246 * with no underlying interfaces (and thus an unknown broadcast
4246 4247 * address length), but we enforce that an interface is broadcast-
4247 4248 * capable as part of allowing it to join a group.
4248 4249 */
4249 4250 if (ill->ill_bcast_addr_length == 0 && !IS_IPMP(ill)) {
4250 4251 if (ill->ill_bcast_mp != NULL)
4251 4252 freemsg(ill->ill_bcast_mp);
4252 4253 ill->ill_net_type = IRE_IF_NORESOLVER;
4253 4254
4254 4255 ill->ill_bcast_mp = ill_dlur_gen(NULL,
4255 4256 ill->ill_phys_addr_length,
4256 4257 ill->ill_sap,
4257 4258 ill->ill_sap_length);
4258 4259
4259 4260 if (ill->ill_isv6)
4260 4261 /*
4261 4262 * Note: xresolv interfaces will eventually need NOARP
4262 4263 * set here as well, but that will require those
4263 4264 * external resolvers to have some knowledge of
4264 4265 * that flag and act appropriately. Not to be changed
4265 4266 * at present.
4266 4267 */
4267 4268 ill->ill_flags |= ILLF_NONUD;
4268 4269 else
4269 4270 ill->ill_flags |= ILLF_NOARP;
4270 4271
4271 4272 if (ill->ill_mactype == SUNW_DL_VNI) {
4272 4273 ill->ill_ipif->ipif_flags |= IPIF_NOXMIT;
4273 4274 } else if (ill->ill_phys_addr_length == 0 ||
4274 4275 ill->ill_mactype == DL_IPV4 ||
4275 4276 ill->ill_mactype == DL_IPV6) {
4276 4277 /*
4277 4278 * The underying link is point-to-point, so mark the
4278 4279 * interface as such. We can do IP multicast over
4279 4280 * such a link since it transmits all network-layer
4280 4281 * packets to the remote side the same way.
4281 4282 */
4282 4283 ill->ill_flags |= ILLF_MULTICAST;
4283 4284 ill->ill_ipif->ipif_flags |= IPIF_POINTOPOINT;
4284 4285 }
4285 4286 } else {
4286 4287 ill->ill_net_type = IRE_IF_RESOLVER;
4287 4288 if (ill->ill_bcast_mp != NULL)
4288 4289 freemsg(ill->ill_bcast_mp);
4289 4290 ill->ill_bcast_mp = ill_dlur_gen(brdcst_addr,
4290 4291 ill->ill_bcast_addr_length, ill->ill_sap,
4291 4292 ill->ill_sap_length);
4292 4293 /*
4293 4294 * Later detect lack of DLPI driver multicast
4294 4295 * capability by catching DL_ENABMULTI errors in
4295 4296 * ip_rput_dlpi.
4296 4297 */
4297 4298 ill->ill_flags |= ILLF_MULTICAST;
4298 4299 if (!ill->ill_isv6)
4299 4300 ill->ill_ipif->ipif_flags |= IPIF_BROADCAST;
4300 4301 }
4301 4302
4302 4303 /* For IPMP, PHYI_IPMP should already be set by phyint_flags_init() */
4303 4304 if (ill->ill_mactype == SUNW_DL_IPMP)
4304 4305 ASSERT(ill->ill_phyint->phyint_flags & PHYI_IPMP);
4305 4306
4306 4307 /* By default an interface does not support any CoS marking */
4307 4308 ill->ill_flags &= ~ILLF_COS_ENABLED;
4308 4309
4309 4310 /*
4310 4311 * If we get QoS information in DL_INFO_ACK, the device supports
4311 4312 * some form of CoS marking, set ILLF_COS_ENABLED.
4312 4313 */
4313 4314 sel1 = (dl_qos_cl_sel1_t *)mi_offset_param(mp, dlia->dl_qos_offset,
4314 4315 dlia->dl_qos_length);
4315 4316 if ((sel1 != NULL) && (sel1->dl_qos_type == DL_QOS_CL_SEL1)) {
4316 4317 ill->ill_flags |= ILLF_COS_ENABLED;
4317 4318 }
4318 4319
4319 4320 /* Clear any previous error indication. */
4320 4321 ill->ill_error = 0;
4321 4322 freemsg(mp);
4322 4323 }
4323 4324
4324 4325 /*
4325 4326 * Perform various checks to verify that an address would make sense as a
4326 4327 * local, remote, or subnet interface address.
4327 4328 */
4328 4329 static boolean_t
4329 4330 ip_addr_ok_v4(ipaddr_t addr, ipaddr_t subnet_mask)
4330 4331 {
4331 4332 ipaddr_t net_mask;
4332 4333
4333 4334 /*
4334 4335 * Don't allow all zeroes, or all ones, but allow
4335 4336 * all ones netmask.
4336 4337 */
4337 4338 if ((net_mask = ip_net_mask(addr)) == 0)
4338 4339 return (B_FALSE);
4339 4340 /* A given netmask overrides the "guess" netmask */
4340 4341 if (subnet_mask != 0)
4341 4342 net_mask = subnet_mask;
4342 4343 if ((net_mask != ~(ipaddr_t)0) && ((addr == (addr & net_mask)) ||
4343 4344 (addr == (addr | ~net_mask)))) {
4344 4345 return (B_FALSE);
4345 4346 }
4346 4347
4347 4348 /*
4348 4349 * Even if the netmask is all ones, we do not allow address to be
4349 4350 * 255.255.255.255
4350 4351 */
4351 4352 if (addr == INADDR_BROADCAST)
4352 4353 return (B_FALSE);
4353 4354
4354 4355 if (CLASSD(addr))
4355 4356 return (B_FALSE);
4356 4357
4357 4358 return (B_TRUE);
4358 4359 }
4359 4360
4360 4361 #define V6_IPIF_LINKLOCAL(p) \
4361 4362 IN6_IS_ADDR_LINKLOCAL(&(p)->ipif_v6lcl_addr)
4362 4363
4363 4364 /*
4364 4365 * Compare two given ipifs and check if the second one is better than
4365 4366 * the first one using the order of preference (not taking deprecated
4366 4367 * into acount) specified in ipif_lookup_multicast().
4367 4368 */
4368 4369 static boolean_t
4369 4370 ipif_comp_multi(ipif_t *old_ipif, ipif_t *new_ipif, boolean_t isv6)
4370 4371 {
4371 4372 /* Check the least preferred first. */
4372 4373 if (IS_LOOPBACK(old_ipif->ipif_ill)) {
4373 4374 /* If both ipifs are the same, use the first one. */
4374 4375 if (IS_LOOPBACK(new_ipif->ipif_ill))
4375 4376 return (B_FALSE);
4376 4377 else
4377 4378 return (B_TRUE);
4378 4379 }
4379 4380
4380 4381 /* For IPv6, check for link local address. */
4381 4382 if (isv6 && V6_IPIF_LINKLOCAL(old_ipif)) {
4382 4383 if (IS_LOOPBACK(new_ipif->ipif_ill) ||
4383 4384 V6_IPIF_LINKLOCAL(new_ipif)) {
4384 4385 /* The second one is equal or less preferred. */
4385 4386 return (B_FALSE);
4386 4387 } else {
4387 4388 return (B_TRUE);
4388 4389 }
4389 4390 }
4390 4391
4391 4392 /* Then check for point to point interface. */
4392 4393 if (old_ipif->ipif_flags & IPIF_POINTOPOINT) {
4393 4394 if (IS_LOOPBACK(new_ipif->ipif_ill) ||
4394 4395 (isv6 && V6_IPIF_LINKLOCAL(new_ipif)) ||
4395 4396 (new_ipif->ipif_flags & IPIF_POINTOPOINT)) {
4396 4397 return (B_FALSE);
4397 4398 } else {
4398 4399 return (B_TRUE);
4399 4400 }
4400 4401 }
4401 4402
4402 4403 /* old_ipif is a normal interface, so no need to use the new one. */
4403 4404 return (B_FALSE);
4404 4405 }
4405 4406
4406 4407 /*
4407 4408 * Find a mulitcast-capable ipif given an IP instance and zoneid.
4408 4409 * The ipif must be up, and its ill must multicast-capable, not
4409 4410 * condemned, not an underlying interface in an IPMP group, and
4410 4411 * not a VNI interface. Order of preference:
4411 4412 *
4412 4413 * 1a. normal
4413 4414 * 1b. normal, but deprecated
4414 4415 * 2a. point to point
4415 4416 * 2b. point to point, but deprecated
4416 4417 * 3a. link local
4417 4418 * 3b. link local, but deprecated
4418 4419 * 4. loopback.
4419 4420 */
4420 4421 static ipif_t *
4421 4422 ipif_lookup_multicast(ip_stack_t *ipst, zoneid_t zoneid, boolean_t isv6)
4422 4423 {
4423 4424 ill_t *ill;
4424 4425 ill_walk_context_t ctx;
4425 4426 ipif_t *ipif;
4426 4427 ipif_t *saved_ipif = NULL;
4427 4428 ipif_t *dep_ipif = NULL;
4428 4429
4429 4430 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4430 4431 if (isv6)
4431 4432 ill = ILL_START_WALK_V6(&ctx, ipst);
4432 4433 else
4433 4434 ill = ILL_START_WALK_V4(&ctx, ipst);
4434 4435
4435 4436 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4436 4437 mutex_enter(&ill->ill_lock);
4437 4438 if (IS_VNI(ill) || IS_UNDER_IPMP(ill) ||
4438 4439 ILL_IS_CONDEMNED(ill) ||
4439 4440 !(ill->ill_flags & ILLF_MULTICAST)) {
4440 4441 mutex_exit(&ill->ill_lock);
4441 4442 continue;
4442 4443 }
4443 4444 for (ipif = ill->ill_ipif; ipif != NULL;
4444 4445 ipif = ipif->ipif_next) {
4445 4446 if (zoneid != ipif->ipif_zoneid &&
4446 4447 zoneid != ALL_ZONES &&
4447 4448 ipif->ipif_zoneid != ALL_ZONES) {
4448 4449 continue;
4449 4450 }
4450 4451 if (!(ipif->ipif_flags & IPIF_UP) ||
4451 4452 IPIF_IS_CONDEMNED(ipif)) {
4452 4453 continue;
4453 4454 }
4454 4455
4455 4456 /*
4456 4457 * Found one candidate. If it is deprecated,
4457 4458 * remember it in dep_ipif. If it is not deprecated,
4458 4459 * remember it in saved_ipif.
4459 4460 */
4460 4461 if (ipif->ipif_flags & IPIF_DEPRECATED) {
4461 4462 if (dep_ipif == NULL) {
4462 4463 dep_ipif = ipif;
4463 4464 } else if (ipif_comp_multi(dep_ipif, ipif,
4464 4465 isv6)) {
4465 4466 /*
4466 4467 * If the previous dep_ipif does not
4467 4468 * belong to the same ill, we've done
4468 4469 * a ipif_refhold() on it. So we need
4469 4470 * to release it.
4470 4471 */
4471 4472 if (dep_ipif->ipif_ill != ill)
4472 4473 ipif_refrele(dep_ipif);
4473 4474 dep_ipif = ipif;
4474 4475 }
4475 4476 continue;
4476 4477 }
4477 4478 if (saved_ipif == NULL) {
4478 4479 saved_ipif = ipif;
4479 4480 } else {
4480 4481 if (ipif_comp_multi(saved_ipif, ipif, isv6)) {
4481 4482 if (saved_ipif->ipif_ill != ill)
4482 4483 ipif_refrele(saved_ipif);
4483 4484 saved_ipif = ipif;
4484 4485 }
4485 4486 }
4486 4487 }
4487 4488 /*
4488 4489 * Before going to the next ill, do a ipif_refhold() on the
4489 4490 * saved ones.
4490 4491 */
4491 4492 if (saved_ipif != NULL && saved_ipif->ipif_ill == ill)
4492 4493 ipif_refhold_locked(saved_ipif);
4493 4494 if (dep_ipif != NULL && dep_ipif->ipif_ill == ill)
4494 4495 ipif_refhold_locked(dep_ipif);
4495 4496 mutex_exit(&ill->ill_lock);
4496 4497 }
4497 4498 rw_exit(&ipst->ips_ill_g_lock);
4498 4499
4499 4500 /*
4500 4501 * If we have only the saved_ipif, return it. But if we have both
4501 4502 * saved_ipif and dep_ipif, check to see which one is better.
4502 4503 */
4503 4504 if (saved_ipif != NULL) {
4504 4505 if (dep_ipif != NULL) {
4505 4506 if (ipif_comp_multi(saved_ipif, dep_ipif, isv6)) {
4506 4507 ipif_refrele(saved_ipif);
4507 4508 return (dep_ipif);
4508 4509 } else {
4509 4510 ipif_refrele(dep_ipif);
4510 4511 return (saved_ipif);
4511 4512 }
4512 4513 }
4513 4514 return (saved_ipif);
4514 4515 } else {
4515 4516 return (dep_ipif);
4516 4517 }
4517 4518 }
4518 4519
4519 4520 ill_t *
4520 4521 ill_lookup_multicast(ip_stack_t *ipst, zoneid_t zoneid, boolean_t isv6)
4521 4522 {
4522 4523 ipif_t *ipif;
4523 4524 ill_t *ill;
4524 4525
4525 4526 ipif = ipif_lookup_multicast(ipst, zoneid, isv6);
4526 4527 if (ipif == NULL)
4527 4528 return (NULL);
4528 4529
4529 4530 ill = ipif->ipif_ill;
4530 4531 ill_refhold(ill);
4531 4532 ipif_refrele(ipif);
4532 4533 return (ill);
4533 4534 }
4534 4535
4535 4536 /*
4536 4537 * This function is called when an application does not specify an interface
4537 4538 * to be used for multicast traffic (joining a group/sending data). It
4538 4539 * calls ire_lookup_multi() to look for an interface route for the
4539 4540 * specified multicast group. Doing this allows the administrator to add
4540 4541 * prefix routes for multicast to indicate which interface to be used for
4541 4542 * multicast traffic in the above scenario. The route could be for all
4542 4543 * multicast (224.0/4), for a single multicast group (a /32 route) or
4543 4544 * anything in between. If there is no such multicast route, we just find
4544 4545 * any multicast capable interface and return it. The returned ipif
4545 4546 * is refhold'ed.
4546 4547 *
4547 4548 * We support MULTIRT and RTF_SETSRC on the multicast routes added to the
4548 4549 * unicast table. This is used by CGTP.
4549 4550 */
4550 4551 ill_t *
4551 4552 ill_lookup_group_v4(ipaddr_t group, zoneid_t zoneid, ip_stack_t *ipst,
4552 4553 boolean_t *multirtp, ipaddr_t *setsrcp)
4553 4554 {
4554 4555 ill_t *ill;
4555 4556
4556 4557 ill = ire_lookup_multi_ill_v4(group, zoneid, ipst, multirtp, setsrcp);
4557 4558 if (ill != NULL)
4558 4559 return (ill);
4559 4560
4560 4561 return (ill_lookup_multicast(ipst, zoneid, B_FALSE));
4561 4562 }
4562 4563
4563 4564 /*
4564 4565 * Look for an ipif with the specified interface address and destination.
4565 4566 * The destination address is used only for matching point-to-point interfaces.
4566 4567 */
4567 4568 ipif_t *
4568 4569 ipif_lookup_interface(ipaddr_t if_addr, ipaddr_t dst, ip_stack_t *ipst)
4569 4570 {
4570 4571 ipif_t *ipif;
4571 4572 ill_t *ill;
4572 4573 ill_walk_context_t ctx;
4573 4574
4574 4575 /*
4575 4576 * First match all the point-to-point interfaces
4576 4577 * before looking at non-point-to-point interfaces.
4577 4578 * This is done to avoid returning non-point-to-point
4578 4579 * ipif instead of unnumbered point-to-point ipif.
4579 4580 */
4580 4581 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4581 4582 ill = ILL_START_WALK_V4(&ctx, ipst);
4582 4583 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4583 4584 mutex_enter(&ill->ill_lock);
4584 4585 for (ipif = ill->ill_ipif; ipif != NULL;
4585 4586 ipif = ipif->ipif_next) {
4586 4587 /* Allow the ipif to be down */
4587 4588 if ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
4588 4589 (ipif->ipif_lcl_addr == if_addr) &&
4589 4590 (ipif->ipif_pp_dst_addr == dst)) {
4590 4591 if (!IPIF_IS_CONDEMNED(ipif)) {
4591 4592 ipif_refhold_locked(ipif);
4592 4593 mutex_exit(&ill->ill_lock);
4593 4594 rw_exit(&ipst->ips_ill_g_lock);
4594 4595 return (ipif);
4595 4596 }
4596 4597 }
4597 4598 }
4598 4599 mutex_exit(&ill->ill_lock);
4599 4600 }
4600 4601 rw_exit(&ipst->ips_ill_g_lock);
4601 4602
4602 4603 /* lookup the ipif based on interface address */
4603 4604 ipif = ipif_lookup_addr(if_addr, NULL, ALL_ZONES, ipst);
4604 4605 ASSERT(ipif == NULL || !ipif->ipif_isv6);
4605 4606 return (ipif);
4606 4607 }
4607 4608
4608 4609 /*
4609 4610 * Common function for ipif_lookup_addr() and ipif_lookup_addr_exact().
4610 4611 */
4611 4612 static ipif_t *
4612 4613 ipif_lookup_addr_common(ipaddr_t addr, ill_t *match_ill, uint32_t match_flags,
4613 4614 zoneid_t zoneid, ip_stack_t *ipst)
4614 4615 {
4615 4616 ipif_t *ipif;
4616 4617 ill_t *ill;
4617 4618 boolean_t ptp = B_FALSE;
4618 4619 ill_walk_context_t ctx;
4619 4620 boolean_t match_illgrp = (match_flags & IPIF_MATCH_ILLGRP);
4620 4621 boolean_t no_duplicate = (match_flags & IPIF_MATCH_NONDUP);
4621 4622
4622 4623 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4623 4624 /*
4624 4625 * Repeat twice, first based on local addresses and
4625 4626 * next time for pointopoint.
4626 4627 */
4627 4628 repeat:
4628 4629 ill = ILL_START_WALK_V4(&ctx, ipst);
4629 4630 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4630 4631 if (match_ill != NULL && ill != match_ill &&
4631 4632 (!match_illgrp || !IS_IN_SAME_ILLGRP(ill, match_ill))) {
4632 4633 continue;
4633 4634 }
4634 4635 mutex_enter(&ill->ill_lock);
4635 4636 for (ipif = ill->ill_ipif; ipif != NULL;
4636 4637 ipif = ipif->ipif_next) {
4637 4638 if (zoneid != ALL_ZONES &&
4638 4639 zoneid != ipif->ipif_zoneid &&
4639 4640 ipif->ipif_zoneid != ALL_ZONES)
4640 4641 continue;
4641 4642
4642 4643 if (no_duplicate && !(ipif->ipif_flags & IPIF_UP))
4643 4644 continue;
4644 4645
4645 4646 /* Allow the ipif to be down */
4646 4647 if ((!ptp && (ipif->ipif_lcl_addr == addr) &&
4647 4648 ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) ||
4648 4649 (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) &&
4649 4650 (ipif->ipif_pp_dst_addr == addr))) {
4650 4651 if (!IPIF_IS_CONDEMNED(ipif)) {
4651 4652 ipif_refhold_locked(ipif);
4652 4653 mutex_exit(&ill->ill_lock);
4653 4654 rw_exit(&ipst->ips_ill_g_lock);
4654 4655 return (ipif);
4655 4656 }
4656 4657 }
4657 4658 }
4658 4659 mutex_exit(&ill->ill_lock);
4659 4660 }
4660 4661
4661 4662 /* If we already did the ptp case, then we are done */
4662 4663 if (ptp) {
4663 4664 rw_exit(&ipst->ips_ill_g_lock);
4664 4665 return (NULL);
4665 4666 }
4666 4667 ptp = B_TRUE;
4667 4668 goto repeat;
4668 4669 }
4669 4670
4670 4671 /*
4671 4672 * Lookup an ipif with the specified address. For point-to-point links we
4672 4673 * look for matches on either the destination address or the local address,
4673 4674 * but we skip the local address check if IPIF_UNNUMBERED is set. If the
4674 4675 * `match_ill' argument is non-NULL, the lookup is restricted to that ill
4675 4676 * (or illgrp if `match_ill' is in an IPMP group).
4676 4677 */
4677 4678 ipif_t *
4678 4679 ipif_lookup_addr(ipaddr_t addr, ill_t *match_ill, zoneid_t zoneid,
4679 4680 ip_stack_t *ipst)
4680 4681 {
4681 4682 return (ipif_lookup_addr_common(addr, match_ill, IPIF_MATCH_ILLGRP,
4682 4683 zoneid, ipst));
4683 4684 }
4684 4685
4685 4686 /*
4686 4687 * Lookup an ipif with the specified address. Similar to ipif_lookup_addr,
4687 4688 * except that we will only return an address if it is not marked as
4688 4689 * IPIF_DUPLICATE
4689 4690 */
4690 4691 ipif_t *
4691 4692 ipif_lookup_addr_nondup(ipaddr_t addr, ill_t *match_ill, zoneid_t zoneid,
4692 4693 ip_stack_t *ipst)
4693 4694 {
4694 4695 return (ipif_lookup_addr_common(addr, match_ill,
4695 4696 (IPIF_MATCH_ILLGRP | IPIF_MATCH_NONDUP),
4696 4697 zoneid, ipst));
4697 4698 }
4698 4699
4699 4700 /*
4700 4701 * Special abbreviated version of ipif_lookup_addr() that doesn't match
4701 4702 * `match_ill' across the IPMP group. This function is only needed in some
4702 4703 * corner-cases; almost everything should use ipif_lookup_addr().
4703 4704 */
4704 4705 ipif_t *
4705 4706 ipif_lookup_addr_exact(ipaddr_t addr, ill_t *match_ill, ip_stack_t *ipst)
4706 4707 {
4707 4708 ASSERT(match_ill != NULL);
4708 4709 return (ipif_lookup_addr_common(addr, match_ill, 0, ALL_ZONES,
4709 4710 ipst));
4710 4711 }
4711 4712
4712 4713 /*
4713 4714 * Look for an ipif with the specified address. For point-point links
4714 4715 * we look for matches on either the destination address and the local
4715 4716 * address, but we ignore the check on the local address if IPIF_UNNUMBERED
4716 4717 * is set.
4717 4718 * If the `match_ill' argument is non-NULL, the lookup is restricted to that
4718 4719 * ill (or illgrp if `match_ill' is in an IPMP group).
4719 4720 * Return the zoneid for the ipif which matches. ALL_ZONES if no match.
4720 4721 */
4721 4722 zoneid_t
4722 4723 ipif_lookup_addr_zoneid(ipaddr_t addr, ill_t *match_ill, ip_stack_t *ipst)
4723 4724 {
4724 4725 zoneid_t zoneid;
4725 4726 ipif_t *ipif;
4726 4727 ill_t *ill;
4727 4728 boolean_t ptp = B_FALSE;
4728 4729 ill_walk_context_t ctx;
4729 4730
4730 4731 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
4731 4732 /*
4732 4733 * Repeat twice, first based on local addresses and
4733 4734 * next time for pointopoint.
4734 4735 */
4735 4736 repeat:
4736 4737 ill = ILL_START_WALK_V4(&ctx, ipst);
4737 4738 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
4738 4739 if (match_ill != NULL && ill != match_ill &&
4739 4740 !IS_IN_SAME_ILLGRP(ill, match_ill)) {
4740 4741 continue;
4741 4742 }
4742 4743 mutex_enter(&ill->ill_lock);
4743 4744 for (ipif = ill->ill_ipif; ipif != NULL;
4744 4745 ipif = ipif->ipif_next) {
4745 4746 /* Allow the ipif to be down */
4746 4747 if ((!ptp && (ipif->ipif_lcl_addr == addr) &&
4747 4748 ((ipif->ipif_flags & IPIF_UNNUMBERED) == 0)) ||
4748 4749 (ptp && (ipif->ipif_flags & IPIF_POINTOPOINT) &&
4749 4750 (ipif->ipif_pp_dst_addr == addr)) &&
4750 4751 !(ipif->ipif_state_flags & IPIF_CONDEMNED)) {
4751 4752 zoneid = ipif->ipif_zoneid;
4752 4753 mutex_exit(&ill->ill_lock);
4753 4754 rw_exit(&ipst->ips_ill_g_lock);
4754 4755 /*
4755 4756 * If ipif_zoneid was ALL_ZONES then we have
4756 4757 * a trusted extensions shared IP address.
4757 4758 * In that case GLOBAL_ZONEID works to send.
4758 4759 */
4759 4760 if (zoneid == ALL_ZONES)
4760 4761 zoneid = GLOBAL_ZONEID;
4761 4762 return (zoneid);
4762 4763 }
4763 4764 }
4764 4765 mutex_exit(&ill->ill_lock);
4765 4766 }
4766 4767
4767 4768 /* If we already did the ptp case, then we are done */
4768 4769 if (ptp) {
4769 4770 rw_exit(&ipst->ips_ill_g_lock);
4770 4771 return (ALL_ZONES);
4771 4772 }
4772 4773 ptp = B_TRUE;
4773 4774 goto repeat;
4774 4775 }
4775 4776
4776 4777 /*
4777 4778 * Look for an ipif that matches the specified remote address i.e. the
4778 4779 * ipif that would receive the specified packet.
4779 4780 * First look for directly connected interfaces and then do a recursive
4780 4781 * IRE lookup and pick the first ipif corresponding to the source address in the
4781 4782 * ire.
4782 4783 * Returns: held ipif
4783 4784 *
4784 4785 * This is only used for ICMP_ADDRESS_MASK_REQUESTs
4785 4786 */
4786 4787 ipif_t *
4787 4788 ipif_lookup_remote(ill_t *ill, ipaddr_t addr, zoneid_t zoneid)
4788 4789 {
4789 4790 ipif_t *ipif;
4790 4791
4791 4792 ASSERT(!ill->ill_isv6);
4792 4793
4793 4794 /*
4794 4795 * Someone could be changing this ipif currently or change it
4795 4796 * after we return this. Thus a few packets could use the old
4796 4797 * old values. However structure updates/creates (ire, ilg, ilm etc)
4797 4798 * will atomically be updated or cleaned up with the new value
4798 4799 * Thus we don't need a lock to check the flags or other attrs below.
4799 4800 */
4800 4801 mutex_enter(&ill->ill_lock);
4801 4802 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4802 4803 if (IPIF_IS_CONDEMNED(ipif))
4803 4804 continue;
4804 4805 if (zoneid != ALL_ZONES && zoneid != ipif->ipif_zoneid &&
4805 4806 ipif->ipif_zoneid != ALL_ZONES)
4806 4807 continue;
4807 4808 /* Allow the ipif to be down */
4808 4809 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
4809 4810 if ((ipif->ipif_pp_dst_addr == addr) ||
4810 4811 (!(ipif->ipif_flags & IPIF_UNNUMBERED) &&
4811 4812 ipif->ipif_lcl_addr == addr)) {
4812 4813 ipif_refhold_locked(ipif);
4813 4814 mutex_exit(&ill->ill_lock);
4814 4815 return (ipif);
4815 4816 }
4816 4817 } else if (ipif->ipif_subnet == (addr & ipif->ipif_net_mask)) {
4817 4818 ipif_refhold_locked(ipif);
4818 4819 mutex_exit(&ill->ill_lock);
4819 4820 return (ipif);
4820 4821 }
4821 4822 }
4822 4823 mutex_exit(&ill->ill_lock);
4823 4824 /*
4824 4825 * For a remote destination it isn't possible to nail down a particular
4825 4826 * ipif.
4826 4827 */
4827 4828
4828 4829 /* Pick the first interface */
4829 4830 ipif = ipif_get_next_ipif(NULL, ill);
4830 4831 return (ipif);
4831 4832 }
4832 4833
4833 4834 /*
4834 4835 * This func does not prevent refcnt from increasing. But if
4835 4836 * the caller has taken steps to that effect, then this func
4836 4837 * can be used to determine whether the ill has become quiescent
4837 4838 */
4838 4839 static boolean_t
4839 4840 ill_is_quiescent(ill_t *ill)
4840 4841 {
4841 4842 ipif_t *ipif;
4842 4843
4843 4844 ASSERT(MUTEX_HELD(&ill->ill_lock));
4844 4845
4845 4846 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4846 4847 if (ipif->ipif_refcnt != 0)
4847 4848 return (B_FALSE);
4848 4849 }
4849 4850 if (!ILL_DOWN_OK(ill) || ill->ill_refcnt != 0) {
4850 4851 return (B_FALSE);
4851 4852 }
4852 4853 return (B_TRUE);
4853 4854 }
4854 4855
4855 4856 boolean_t
4856 4857 ill_is_freeable(ill_t *ill)
4857 4858 {
4858 4859 ipif_t *ipif;
4859 4860
4860 4861 ASSERT(MUTEX_HELD(&ill->ill_lock));
4861 4862
4862 4863 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
4863 4864 if (ipif->ipif_refcnt != 0) {
4864 4865 return (B_FALSE);
4865 4866 }
4866 4867 }
4867 4868 if (!ILL_FREE_OK(ill) || ill->ill_refcnt != 0) {
4868 4869 return (B_FALSE);
4869 4870 }
4870 4871 return (B_TRUE);
4871 4872 }
4872 4873
4873 4874 /*
4874 4875 * This func does not prevent refcnt from increasing. But if
4875 4876 * the caller has taken steps to that effect, then this func
4876 4877 * can be used to determine whether the ipif has become quiescent
4877 4878 */
4878 4879 static boolean_t
4879 4880 ipif_is_quiescent(ipif_t *ipif)
4880 4881 {
4881 4882 ill_t *ill;
4882 4883
4883 4884 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
4884 4885
4885 4886 if (ipif->ipif_refcnt != 0)
4886 4887 return (B_FALSE);
4887 4888
4888 4889 ill = ipif->ipif_ill;
4889 4890 if (ill->ill_ipif_up_count != 0 || ill->ill_ipif_dup_count != 0 ||
4890 4891 ill->ill_logical_down) {
4891 4892 return (B_TRUE);
4892 4893 }
4893 4894
4894 4895 /* This is the last ipif going down or being deleted on this ill */
4895 4896 if (ill->ill_ire_cnt != 0 || ill->ill_refcnt != 0) {
4896 4897 return (B_FALSE);
4897 4898 }
4898 4899
4899 4900 return (B_TRUE);
4900 4901 }
4901 4902
4902 4903 /*
4903 4904 * return true if the ipif can be destroyed: the ipif has to be quiescent
4904 4905 * with zero references from ire/ilm to it.
4905 4906 */
4906 4907 static boolean_t
4907 4908 ipif_is_freeable(ipif_t *ipif)
4908 4909 {
4909 4910 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
4910 4911 ASSERT(ipif->ipif_id != 0);
4911 4912 return (ipif->ipif_refcnt == 0);
4912 4913 }
4913 4914
4914 4915 /*
4915 4916 * The ipif/ill/ire has been refreled. Do the tail processing.
4916 4917 * Determine if the ipif or ill in question has become quiescent and if so
4917 4918 * wakeup close and/or restart any queued pending ioctl that is waiting
4918 4919 * for the ipif_down (or ill_down)
4919 4920 */
4920 4921 void
4921 4922 ipif_ill_refrele_tail(ill_t *ill)
4922 4923 {
4923 4924 mblk_t *mp;
4924 4925 conn_t *connp;
4925 4926 ipsq_t *ipsq;
4926 4927 ipxop_t *ipx;
4927 4928 ipif_t *ipif;
4928 4929 dl_notify_ind_t *dlindp;
4929 4930
4930 4931 ASSERT(MUTEX_HELD(&ill->ill_lock));
4931 4932
4932 4933 if ((ill->ill_state_flags & ILL_CONDEMNED) && ill_is_freeable(ill)) {
4933 4934 /* ip_modclose() may be waiting */
4934 4935 cv_broadcast(&ill->ill_cv);
4935 4936 }
4936 4937
4937 4938 ipsq = ill->ill_phyint->phyint_ipsq;
4938 4939 mutex_enter(&ipsq->ipsq_lock);
4939 4940 ipx = ipsq->ipsq_xop;
4940 4941 mutex_enter(&ipx->ipx_lock);
4941 4942 if (ipx->ipx_waitfor == 0) /* no one's waiting; bail */
4942 4943 goto unlock;
4943 4944
4944 4945 ASSERT(ipx->ipx_pending_mp != NULL && ipx->ipx_pending_ipif != NULL);
4945 4946
4946 4947 ipif = ipx->ipx_pending_ipif;
4947 4948 if (ipif->ipif_ill != ill) /* wait is for another ill; bail */
4948 4949 goto unlock;
4949 4950
4950 4951 switch (ipx->ipx_waitfor) {
4951 4952 case IPIF_DOWN:
4952 4953 if (!ipif_is_quiescent(ipif))
4953 4954 goto unlock;
4954 4955 break;
4955 4956 case IPIF_FREE:
4956 4957 if (!ipif_is_freeable(ipif))
4957 4958 goto unlock;
4958 4959 break;
4959 4960 case ILL_DOWN:
4960 4961 if (!ill_is_quiescent(ill))
4961 4962 goto unlock;
4962 4963 break;
4963 4964 case ILL_FREE:
4964 4965 /*
4965 4966 * ILL_FREE is only for loopback; normal ill teardown waits
4966 4967 * synchronously in ip_modclose() without using ipx_waitfor,
4967 4968 * handled by the cv_broadcast() at the top of this function.
4968 4969 */
4969 4970 if (!ill_is_freeable(ill))
4970 4971 goto unlock;
4971 4972 break;
4972 4973 default:
4973 4974 cmn_err(CE_PANIC, "ipsq: %p unknown ipx_waitfor %d\n",
4974 4975 (void *)ipsq, ipx->ipx_waitfor);
4975 4976 }
4976 4977
4977 4978 ill_refhold_locked(ill); /* for qwriter_ip() call below */
4978 4979 mutex_exit(&ipx->ipx_lock);
4979 4980 mp = ipsq_pending_mp_get(ipsq, &connp);
4980 4981 mutex_exit(&ipsq->ipsq_lock);
4981 4982 mutex_exit(&ill->ill_lock);
4982 4983
4983 4984 ASSERT(mp != NULL);
4984 4985 /*
4985 4986 * NOTE: all of the qwriter_ip() calls below use CUR_OP since
4986 4987 * we can only get here when the current operation decides it
4987 4988 * it needs to quiesce via ipsq_pending_mp_add().
4988 4989 */
4989 4990 switch (mp->b_datap->db_type) {
4990 4991 case M_PCPROTO:
4991 4992 case M_PROTO:
4992 4993 /*
4993 4994 * For now, only DL_NOTIFY_IND messages can use this facility.
4994 4995 */
4995 4996 dlindp = (dl_notify_ind_t *)mp->b_rptr;
4996 4997 ASSERT(dlindp->dl_primitive == DL_NOTIFY_IND);
4997 4998
4998 4999 switch (dlindp->dl_notification) {
4999 5000 case DL_NOTE_PHYS_ADDR:
5000 5001 qwriter_ip(ill, ill->ill_rq, mp,
5001 5002 ill_set_phys_addr_tail, CUR_OP, B_TRUE);
5002 5003 return;
5003 5004 case DL_NOTE_REPLUMB:
5004 5005 qwriter_ip(ill, ill->ill_rq, mp,
5005 5006 ill_replumb_tail, CUR_OP, B_TRUE);
5006 5007 return;
5007 5008 default:
5008 5009 ASSERT(0);
5009 5010 ill_refrele(ill);
5010 5011 }
5011 5012 break;
5012 5013
5013 5014 case M_ERROR:
5014 5015 case M_HANGUP:
5015 5016 qwriter_ip(ill, ill->ill_rq, mp, ipif_all_down_tail, CUR_OP,
5016 5017 B_TRUE);
5017 5018 return;
5018 5019
5019 5020 case M_IOCTL:
5020 5021 case M_IOCDATA:
5021 5022 qwriter_ip(ill, (connp != NULL ? CONNP_TO_WQ(connp) :
5022 5023 ill->ill_wq), mp, ip_reprocess_ioctl, CUR_OP, B_TRUE);
5023 5024 return;
5024 5025
5025 5026 default:
5026 5027 cmn_err(CE_PANIC, "ipif_ill_refrele_tail mp %p "
5027 5028 "db_type %d\n", (void *)mp, mp->b_datap->db_type);
5028 5029 }
5029 5030 return;
5030 5031 unlock:
5031 5032 mutex_exit(&ipsq->ipsq_lock);
5032 5033 mutex_exit(&ipx->ipx_lock);
5033 5034 mutex_exit(&ill->ill_lock);
5034 5035 }
5035 5036
5036 5037 #ifdef DEBUG
5037 5038 /* Reuse trace buffer from beginning (if reached the end) and record trace */
5038 5039 static void
5039 5040 th_trace_rrecord(th_trace_t *th_trace)
5040 5041 {
5041 5042 tr_buf_t *tr_buf;
5042 5043 uint_t lastref;
5043 5044
5044 5045 lastref = th_trace->th_trace_lastref;
5045 5046 lastref++;
5046 5047 if (lastref == TR_BUF_MAX)
5047 5048 lastref = 0;
5048 5049 th_trace->th_trace_lastref = lastref;
5049 5050 tr_buf = &th_trace->th_trbuf[lastref];
5050 5051 tr_buf->tr_time = ddi_get_lbolt();
5051 5052 tr_buf->tr_depth = getpcstack(tr_buf->tr_stack, TR_STACK_DEPTH);
5052 5053 }
5053 5054
5054 5055 static void
5055 5056 th_trace_free(void *value)
5056 5057 {
5057 5058 th_trace_t *th_trace = value;
5058 5059
5059 5060 ASSERT(th_trace->th_refcnt == 0);
5060 5061 kmem_free(th_trace, sizeof (*th_trace));
5061 5062 }
5062 5063
5063 5064 /*
5064 5065 * Find or create the per-thread hash table used to track object references.
5065 5066 * The ipst argument is NULL if we shouldn't allocate.
5066 5067 *
5067 5068 * Accesses per-thread data, so there's no need to lock here.
5068 5069 */
5069 5070 static mod_hash_t *
5070 5071 th_trace_gethash(ip_stack_t *ipst)
5071 5072 {
5072 5073 th_hash_t *thh;
5073 5074
5074 5075 if ((thh = tsd_get(ip_thread_data)) == NULL && ipst != NULL) {
5075 5076 mod_hash_t *mh;
5076 5077 char name[256];
5077 5078 size_t objsize, rshift;
5078 5079 int retv;
5079 5080
5080 5081 if ((thh = kmem_alloc(sizeof (*thh), KM_NOSLEEP)) == NULL)
5081 5082 return (NULL);
5082 5083 (void) snprintf(name, sizeof (name), "th_trace_%p",
5083 5084 (void *)curthread);
5084 5085
5085 5086 /*
5086 5087 * We use mod_hash_create_extended here rather than the more
5087 5088 * obvious mod_hash_create_ptrhash because the latter has a
5088 5089 * hard-coded KM_SLEEP, and we'd prefer to fail rather than
5089 5090 * block.
5090 5091 */
5091 5092 objsize = MAX(MAX(sizeof (ill_t), sizeof (ipif_t)),
5092 5093 MAX(sizeof (ire_t), sizeof (ncec_t)));
5093 5094 rshift = highbit(objsize);
5094 5095 mh = mod_hash_create_extended(name, 64, mod_hash_null_keydtor,
5095 5096 th_trace_free, mod_hash_byptr, (void *)rshift,
5096 5097 mod_hash_ptrkey_cmp, KM_NOSLEEP);
5097 5098 if (mh == NULL) {
5098 5099 kmem_free(thh, sizeof (*thh));
5099 5100 return (NULL);
5100 5101 }
5101 5102 thh->thh_hash = mh;
5102 5103 thh->thh_ipst = ipst;
5103 5104 /*
5104 5105 * We trace ills, ipifs, ires, and nces. All of these are
5105 5106 * per-IP-stack, so the lock on the thread list is as well.
5106 5107 */
5107 5108 rw_enter(&ip_thread_rwlock, RW_WRITER);
5108 5109 list_insert_tail(&ip_thread_list, thh);
5109 5110 rw_exit(&ip_thread_rwlock);
5110 5111 retv = tsd_set(ip_thread_data, thh);
5111 5112 ASSERT(retv == 0);
5112 5113 }
5113 5114 return (thh != NULL ? thh->thh_hash : NULL);
5114 5115 }
5115 5116
5116 5117 boolean_t
5117 5118 th_trace_ref(const void *obj, ip_stack_t *ipst)
5118 5119 {
5119 5120 th_trace_t *th_trace;
5120 5121 mod_hash_t *mh;
5121 5122 mod_hash_val_t val;
5122 5123
5123 5124 if ((mh = th_trace_gethash(ipst)) == NULL)
5124 5125 return (B_FALSE);
5125 5126
5126 5127 /*
5127 5128 * Attempt to locate the trace buffer for this obj and thread.
5128 5129 * If it does not exist, then allocate a new trace buffer and
5129 5130 * insert into the hash.
5130 5131 */
5131 5132 if (mod_hash_find(mh, (mod_hash_key_t)obj, &val) == MH_ERR_NOTFOUND) {
5132 5133 th_trace = kmem_zalloc(sizeof (th_trace_t), KM_NOSLEEP);
5133 5134 if (th_trace == NULL)
5134 5135 return (B_FALSE);
5135 5136
5136 5137 th_trace->th_id = curthread;
5137 5138 if (mod_hash_insert(mh, (mod_hash_key_t)obj,
5138 5139 (mod_hash_val_t)th_trace) != 0) {
5139 5140 kmem_free(th_trace, sizeof (th_trace_t));
5140 5141 return (B_FALSE);
5141 5142 }
5142 5143 } else {
5143 5144 th_trace = (th_trace_t *)val;
5144 5145 }
5145 5146
5146 5147 ASSERT(th_trace->th_refcnt >= 0 &&
5147 5148 th_trace->th_refcnt < TR_BUF_MAX - 1);
5148 5149
5149 5150 th_trace->th_refcnt++;
5150 5151 th_trace_rrecord(th_trace);
5151 5152 return (B_TRUE);
5152 5153 }
5153 5154
5154 5155 /*
5155 5156 * For the purpose of tracing a reference release, we assume that global
5156 5157 * tracing is always on and that the same thread initiated the reference hold
5157 5158 * is releasing.
5158 5159 */
5159 5160 void
5160 5161 th_trace_unref(const void *obj)
5161 5162 {
5162 5163 int retv;
5163 5164 mod_hash_t *mh;
5164 5165 th_trace_t *th_trace;
5165 5166 mod_hash_val_t val;
5166 5167
5167 5168 mh = th_trace_gethash(NULL);
5168 5169 retv = mod_hash_find(mh, (mod_hash_key_t)obj, &val);
5169 5170 ASSERT(retv == 0);
5170 5171 th_trace = (th_trace_t *)val;
5171 5172
5172 5173 ASSERT(th_trace->th_refcnt > 0);
5173 5174 th_trace->th_refcnt--;
5174 5175 th_trace_rrecord(th_trace);
5175 5176 }
5176 5177
5177 5178 /*
5178 5179 * If tracing has been disabled, then we assume that the reference counts are
5179 5180 * now useless, and we clear them out before destroying the entries.
5180 5181 */
5181 5182 void
5182 5183 th_trace_cleanup(const void *obj, boolean_t trace_disable)
5183 5184 {
5184 5185 th_hash_t *thh;
5185 5186 mod_hash_t *mh;
5186 5187 mod_hash_val_t val;
5187 5188 th_trace_t *th_trace;
5188 5189 int retv;
5189 5190
5190 5191 rw_enter(&ip_thread_rwlock, RW_READER);
5191 5192 for (thh = list_head(&ip_thread_list); thh != NULL;
5192 5193 thh = list_next(&ip_thread_list, thh)) {
5193 5194 if (mod_hash_find(mh = thh->thh_hash, (mod_hash_key_t)obj,
5194 5195 &val) == 0) {
5195 5196 th_trace = (th_trace_t *)val;
5196 5197 if (trace_disable)
5197 5198 th_trace->th_refcnt = 0;
5198 5199 retv = mod_hash_destroy(mh, (mod_hash_key_t)obj);
5199 5200 ASSERT(retv == 0);
5200 5201 }
5201 5202 }
5202 5203 rw_exit(&ip_thread_rwlock);
5203 5204 }
5204 5205
5205 5206 void
5206 5207 ipif_trace_ref(ipif_t *ipif)
5207 5208 {
5208 5209 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5209 5210
5210 5211 if (ipif->ipif_trace_disable)
5211 5212 return;
5212 5213
5213 5214 if (!th_trace_ref(ipif, ipif->ipif_ill->ill_ipst)) {
5214 5215 ipif->ipif_trace_disable = B_TRUE;
5215 5216 ipif_trace_cleanup(ipif);
5216 5217 }
5217 5218 }
5218 5219
5219 5220 void
5220 5221 ipif_untrace_ref(ipif_t *ipif)
5221 5222 {
5222 5223 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5223 5224
5224 5225 if (!ipif->ipif_trace_disable)
5225 5226 th_trace_unref(ipif);
5226 5227 }
5227 5228
5228 5229 void
5229 5230 ill_trace_ref(ill_t *ill)
5230 5231 {
5231 5232 ASSERT(MUTEX_HELD(&ill->ill_lock));
5232 5233
5233 5234 if (ill->ill_trace_disable)
5234 5235 return;
5235 5236
5236 5237 if (!th_trace_ref(ill, ill->ill_ipst)) {
5237 5238 ill->ill_trace_disable = B_TRUE;
5238 5239 ill_trace_cleanup(ill);
5239 5240 }
5240 5241 }
5241 5242
5242 5243 void
5243 5244 ill_untrace_ref(ill_t *ill)
5244 5245 {
5245 5246 ASSERT(MUTEX_HELD(&ill->ill_lock));
5246 5247
5247 5248 if (!ill->ill_trace_disable)
5248 5249 th_trace_unref(ill);
5249 5250 }
5250 5251
5251 5252 /*
5252 5253 * Called when ipif is unplumbed or when memory alloc fails. Note that on
5253 5254 * failure, ipif_trace_disable is set.
5254 5255 */
5255 5256 static void
5256 5257 ipif_trace_cleanup(const ipif_t *ipif)
5257 5258 {
5258 5259 th_trace_cleanup(ipif, ipif->ipif_trace_disable);
5259 5260 }
5260 5261
5261 5262 /*
5262 5263 * Called when ill is unplumbed or when memory alloc fails. Note that on
5263 5264 * failure, ill_trace_disable is set.
5264 5265 */
5265 5266 static void
5266 5267 ill_trace_cleanup(const ill_t *ill)
5267 5268 {
5268 5269 th_trace_cleanup(ill, ill->ill_trace_disable);
5269 5270 }
5270 5271 #endif /* DEBUG */
5271 5272
5272 5273 void
5273 5274 ipif_refhold_locked(ipif_t *ipif)
5274 5275 {
5275 5276 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
5276 5277 ipif->ipif_refcnt++;
5277 5278 IPIF_TRACE_REF(ipif);
5278 5279 }
5279 5280
5280 5281 void
5281 5282 ipif_refhold(ipif_t *ipif)
5282 5283 {
5283 5284 ill_t *ill;
5284 5285
5285 5286 ill = ipif->ipif_ill;
5286 5287 mutex_enter(&ill->ill_lock);
5287 5288 ipif->ipif_refcnt++;
5288 5289 IPIF_TRACE_REF(ipif);
5289 5290 mutex_exit(&ill->ill_lock);
5290 5291 }
5291 5292
5292 5293 /*
5293 5294 * Must not be called while holding any locks. Otherwise if this is
5294 5295 * the last reference to be released there is a chance of recursive mutex
5295 5296 * panic due to ipif_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
5296 5297 * to restart an ioctl.
5297 5298 */
5298 5299 void
5299 5300 ipif_refrele(ipif_t *ipif)
5300 5301 {
5301 5302 ill_t *ill;
5302 5303
5303 5304 ill = ipif->ipif_ill;
5304 5305
5305 5306 mutex_enter(&ill->ill_lock);
5306 5307 ASSERT(ipif->ipif_refcnt != 0);
5307 5308 ipif->ipif_refcnt--;
5308 5309 IPIF_UNTRACE_REF(ipif);
5309 5310 if (ipif->ipif_refcnt != 0) {
5310 5311 mutex_exit(&ill->ill_lock);
5311 5312 return;
5312 5313 }
5313 5314
5314 5315 /* Drops the ill_lock */
5315 5316 ipif_ill_refrele_tail(ill);
5316 5317 }
5317 5318
5318 5319 ipif_t *
5319 5320 ipif_get_next_ipif(ipif_t *curr, ill_t *ill)
5320 5321 {
5321 5322 ipif_t *ipif;
5322 5323
5323 5324 mutex_enter(&ill->ill_lock);
5324 5325 for (ipif = (curr == NULL ? ill->ill_ipif : curr->ipif_next);
5325 5326 ipif != NULL; ipif = ipif->ipif_next) {
5326 5327 if (IPIF_IS_CONDEMNED(ipif))
5327 5328 continue;
5328 5329 ipif_refhold_locked(ipif);
5329 5330 mutex_exit(&ill->ill_lock);
5330 5331 return (ipif);
5331 5332 }
5332 5333 mutex_exit(&ill->ill_lock);
5333 5334 return (NULL);
5334 5335 }
5335 5336
5336 5337 /*
5337 5338 * TODO: make this table extendible at run time
5338 5339 * Return a pointer to the mac type info for 'mac_type'
5339 5340 */
5340 5341 static ip_m_t *
5341 5342 ip_m_lookup(t_uscalar_t mac_type)
5342 5343 {
5343 5344 ip_m_t *ipm;
5344 5345
5345 5346 for (ipm = ip_m_tbl; ipm < A_END(ip_m_tbl); ipm++)
5346 5347 if (ipm->ip_m_mac_type == mac_type)
5347 5348 return (ipm);
5348 5349 return (NULL);
5349 5350 }
5350 5351
5351 5352 /*
5352 5353 * Make a link layer address from the multicast IP address *addr.
5353 5354 * To form the link layer address, invoke the ip_m_v*mapping function
5354 5355 * associated with the link-layer type.
5355 5356 */
5356 5357 void
5357 5358 ip_mcast_mapping(ill_t *ill, uchar_t *addr, uchar_t *hwaddr)
5358 5359 {
5359 5360 ip_m_t *ipm;
5360 5361
5361 5362 if (ill->ill_net_type == IRE_IF_NORESOLVER)
5362 5363 return;
5363 5364
5364 5365 ASSERT(addr != NULL);
5365 5366
5366 5367 ipm = ip_m_lookup(ill->ill_mactype);
5367 5368 if (ipm == NULL ||
5368 5369 (ill->ill_isv6 && ipm->ip_m_v6mapping == NULL) ||
5369 5370 (!ill->ill_isv6 && ipm->ip_m_v4mapping == NULL)) {
5370 5371 ip0dbg(("no mapping for ill %s mactype 0x%x\n",
5371 5372 ill->ill_name, ill->ill_mactype));
5372 5373 return;
5373 5374 }
5374 5375 if (ill->ill_isv6)
5375 5376 (*ipm->ip_m_v6mapping)(ill, addr, hwaddr);
5376 5377 else
5377 5378 (*ipm->ip_m_v4mapping)(ill, addr, hwaddr);
5378 5379 }
5379 5380
5380 5381 /*
5381 5382 * Returns B_FALSE if the IPv4 netmask pointed by `mask' is non-contiguous.
5382 5383 * Otherwise returns B_TRUE.
5383 5384 *
5384 5385 * The netmask can be verified to be contiguous with 32 shifts and or
5385 5386 * operations. Take the contiguous mask (in host byte order) and compute
5386 5387 * mask | mask << 1 | mask << 2 | ... | mask << 31
5387 5388 * the result will be the same as the 'mask' for contiguous mask.
5388 5389 */
5389 5390 static boolean_t
5390 5391 ip_contiguous_mask(uint32_t mask)
5391 5392 {
5392 5393 uint32_t m = mask;
5393 5394 int i;
5394 5395
5395 5396 for (i = 1; i < 32; i++)
5396 5397 m |= (mask << i);
5397 5398
5398 5399 return (m == mask);
5399 5400 }
5400 5401
5401 5402 /*
5402 5403 * ip_rt_add is called to add an IPv4 route to the forwarding table.
5403 5404 * ill is passed in to associate it with the correct interface.
5404 5405 * If ire_arg is set, then we return the held IRE in that location.
5405 5406 */
5406 5407 int
5407 5408 ip_rt_add(ipaddr_t dst_addr, ipaddr_t mask, ipaddr_t gw_addr,
5408 5409 ipaddr_t src_addr, int flags, ill_t *ill, ire_t **ire_arg,
5409 5410 boolean_t ioctl_msg, struct rtsa_s *sp, ip_stack_t *ipst, zoneid_t zoneid)
5410 5411 {
5411 5412 ire_t *ire, *nire;
5412 5413 ire_t *gw_ire = NULL;
5413 5414 ipif_t *ipif = NULL;
5414 5415 uint_t type;
5415 5416 int match_flags = MATCH_IRE_TYPE;
5416 5417 tsol_gc_t *gc = NULL;
5417 5418 tsol_gcgrp_t *gcgrp = NULL;
5418 5419 boolean_t gcgrp_xtraref = B_FALSE;
5419 5420 boolean_t cgtp_broadcast;
5420 5421 boolean_t unbound = B_FALSE;
5421 5422
5422 5423 ip1dbg(("ip_rt_add:"));
5423 5424
5424 5425 if (ire_arg != NULL)
5425 5426 *ire_arg = NULL;
5426 5427
5427 5428 /* disallow non-contiguous netmasks */
5428 5429 if (!ip_contiguous_mask(ntohl(mask)))
5429 5430 return (ENOTSUP);
5430 5431
5431 5432 /*
5432 5433 * If this is the case of RTF_HOST being set, then we set the netmask
5433 5434 * to all ones (regardless if one was supplied).
5434 5435 */
5435 5436 if (flags & RTF_HOST)
5436 5437 mask = IP_HOST_MASK;
5437 5438
5438 5439 /*
5439 5440 * Prevent routes with a zero gateway from being created (since
5440 5441 * interfaces can currently be plumbed and brought up no assigned
5441 5442 * address).
5442 5443 */
5443 5444 if (gw_addr == 0)
5444 5445 return (ENETUNREACH);
5445 5446 /*
5446 5447 * Get the ipif, if any, corresponding to the gw_addr
5447 5448 * If -ifp was specified we restrict ourselves to the ill, otherwise
5448 5449 * we match on the gatway and destination to handle unnumbered pt-pt
5449 5450 * interfaces.
5450 5451 */
5451 5452 if (ill != NULL)
5452 5453 ipif = ipif_lookup_addr(gw_addr, ill, ALL_ZONES, ipst);
5453 5454 else
5454 5455 ipif = ipif_lookup_interface(gw_addr, dst_addr, ipst);
5455 5456 if (ipif != NULL) {
5456 5457 if (IS_VNI(ipif->ipif_ill)) {
5457 5458 ipif_refrele(ipif);
5458 5459 return (EINVAL);
5459 5460 }
5460 5461 }
5461 5462
5462 5463 /*
5463 5464 * GateD will attempt to create routes with a loopback interface
5464 5465 * address as the gateway and with RTF_GATEWAY set. We allow
5465 5466 * these routes to be added, but create them as interface routes
5466 5467 * since the gateway is an interface address.
5467 5468 */
5468 5469 if ((ipif != NULL) && (ipif->ipif_ire_type == IRE_LOOPBACK)) {
5469 5470 flags &= ~RTF_GATEWAY;
5470 5471 if (gw_addr == INADDR_LOOPBACK && dst_addr == INADDR_LOOPBACK &&
5471 5472 mask == IP_HOST_MASK) {
5472 5473 ire = ire_ftable_lookup_v4(dst_addr, 0, 0, IRE_LOOPBACK,
5473 5474 NULL, ALL_ZONES, NULL, MATCH_IRE_TYPE, 0, ipst,
5474 5475 NULL);
5475 5476 if (ire != NULL) {
5476 5477 ire_refrele(ire);
5477 5478 ipif_refrele(ipif);
5478 5479 return (EEXIST);
5479 5480 }
5480 5481 ip1dbg(("ip_rt_add: 0x%p creating IRE 0x%x"
5481 5482 "for 0x%x\n", (void *)ipif,
5482 5483 ipif->ipif_ire_type,
5483 5484 ntohl(ipif->ipif_lcl_addr)));
5484 5485 ire = ire_create(
5485 5486 (uchar_t *)&dst_addr, /* dest address */
5486 5487 (uchar_t *)&mask, /* mask */
5487 5488 NULL, /* no gateway */
5488 5489 ipif->ipif_ire_type, /* LOOPBACK */
5489 5490 ipif->ipif_ill,
5490 5491 zoneid,
5491 5492 (ipif->ipif_flags & IPIF_PRIVATE) ? RTF_PRIVATE : 0,
5492 5493 NULL,
5493 5494 ipst);
5494 5495
5495 5496 if (ire == NULL) {
5496 5497 ipif_refrele(ipif);
5497 5498 return (ENOMEM);
5498 5499 }
5499 5500 /* src address assigned by the caller? */
5500 5501 if ((src_addr != INADDR_ANY) && (flags & RTF_SETSRC))
5501 5502 ire->ire_setsrc_addr = src_addr;
5502 5503
5503 5504 nire = ire_add(ire);
5504 5505 if (nire == NULL) {
5505 5506 /*
5506 5507 * In the result of failure, ire_add() will have
5507 5508 * already deleted the ire in question, so there
5508 5509 * is no need to do that here.
5509 5510 */
5510 5511 ipif_refrele(ipif);
5511 5512 return (ENOMEM);
5512 5513 }
5513 5514 /*
5514 5515 * Check if it was a duplicate entry. This handles
5515 5516 * the case of two racing route adds for the same route
5516 5517 */
5517 5518 if (nire != ire) {
5518 5519 ASSERT(nire->ire_identical_ref > 1);
5519 5520 ire_delete(nire);
5520 5521 ire_refrele(nire);
5521 5522 ipif_refrele(ipif);
5522 5523 return (EEXIST);
5523 5524 }
5524 5525 ire = nire;
5525 5526 goto save_ire;
5526 5527 }
5527 5528 }
5528 5529
5529 5530 /*
5530 5531 * The routes for multicast with CGTP are quite special in that
5531 5532 * the gateway is the local interface address, yet RTF_GATEWAY
5532 5533 * is set. We turn off RTF_GATEWAY to provide compatibility with
5533 5534 * this undocumented and unusual use of multicast routes.
5534 5535 */
5535 5536 if ((flags & RTF_MULTIRT) && ipif != NULL)
5536 5537 flags &= ~RTF_GATEWAY;
5537 5538
5538 5539 /*
5539 5540 * Traditionally, interface routes are ones where RTF_GATEWAY isn't set
5540 5541 * and the gateway address provided is one of the system's interface
5541 5542 * addresses. By using the routing socket interface and supplying an
5542 5543 * RTA_IFP sockaddr with an interface index, an alternate method of
5543 5544 * specifying an interface route to be created is available which uses
5544 5545 * the interface index that specifies the outgoing interface rather than
5545 5546 * the address of an outgoing interface (which may not be able to
5546 5547 * uniquely identify an interface). When coupled with the RTF_GATEWAY
5547 5548 * flag, routes can be specified which not only specify the next-hop to
5548 5549 * be used when routing to a certain prefix, but also which outgoing
5549 5550 * interface should be used.
5550 5551 *
5551 5552 * Previously, interfaces would have unique addresses assigned to them
5552 5553 * and so the address assigned to a particular interface could be used
5553 5554 * to identify a particular interface. One exception to this was the
5554 5555 * case of an unnumbered interface (where IPIF_UNNUMBERED was set).
5555 5556 *
5556 5557 * With the advent of IPv6 and its link-local addresses, this
5557 5558 * restriction was relaxed and interfaces could share addresses between
5558 5559 * themselves. In fact, typically all of the link-local interfaces on
5559 5560 * an IPv6 node or router will have the same link-local address. In
5560 5561 * order to differentiate between these interfaces, the use of an
5561 5562 * interface index is necessary and this index can be carried inside a
5562 5563 * RTA_IFP sockaddr (which is actually a sockaddr_dl). One restriction
5563 5564 * of using the interface index, however, is that all of the ipif's that
5564 5565 * are part of an ill have the same index and so the RTA_IFP sockaddr
5565 5566 * cannot be used to differentiate between ipif's (or logical
5566 5567 * interfaces) that belong to the same ill (physical interface).
5567 5568 *
5568 5569 * For example, in the following case involving IPv4 interfaces and
5569 5570 * logical interfaces
5570 5571 *
5571 5572 * 192.0.2.32 255.255.255.224 192.0.2.33 U if0
5572 5573 * 192.0.2.32 255.255.255.224 192.0.2.34 U if0
5573 5574 * 192.0.2.32 255.255.255.224 192.0.2.35 U if0
5574 5575 *
5575 5576 * the ipif's corresponding to each of these interface routes can be
5576 5577 * uniquely identified by the "gateway" (actually interface address).
5577 5578 *
5578 5579 * In this case involving multiple IPv6 default routes to a particular
5579 5580 * link-local gateway, the use of RTA_IFP is necessary to specify which
5580 5581 * default route is of interest:
5581 5582 *
5582 5583 * default fe80::123:4567:89ab:cdef U if0
5583 5584 * default fe80::123:4567:89ab:cdef U if1
5584 5585 */
5585 5586
5586 5587 /* RTF_GATEWAY not set */
5587 5588 if (!(flags & RTF_GATEWAY)) {
5588 5589 if (sp != NULL) {
5589 5590 ip2dbg(("ip_rt_add: gateway security attributes "
5590 5591 "cannot be set with interface route\n"));
5591 5592 if (ipif != NULL)
5592 5593 ipif_refrele(ipif);
5593 5594 return (EINVAL);
5594 5595 }
5595 5596
5596 5597 /*
5597 5598 * Whether or not ill (RTA_IFP) is set, we require that
5598 5599 * the gateway is one of our local addresses.
5599 5600 */
5600 5601 if (ipif == NULL)
5601 5602 return (ENETUNREACH);
5602 5603
5603 5604 /*
5604 5605 * We use MATCH_IRE_ILL here. If the caller specified an
5605 5606 * interface (from the RTA_IFP sockaddr) we use it, otherwise
5606 5607 * we use the ill derived from the gateway address.
5607 5608 * We can always match the gateway address since we record it
5608 5609 * in ire_gateway_addr.
5609 5610 * We don't allow RTA_IFP to specify a different ill than the
5610 5611 * one matching the ipif to make sure we can delete the route.
5611 5612 */
5612 5613 match_flags |= MATCH_IRE_GW | MATCH_IRE_ILL;
5613 5614 if (ill == NULL) {
5614 5615 ill = ipif->ipif_ill;
5615 5616 } else if (ill != ipif->ipif_ill) {
5616 5617 ipif_refrele(ipif);
5617 5618 return (EINVAL);
5618 5619 }
5619 5620
5620 5621 /*
5621 5622 * We check for an existing entry at this point.
5622 5623 *
5623 5624 * Since a netmask isn't passed in via the ioctl interface
5624 5625 * (SIOCADDRT), we don't check for a matching netmask in that
5625 5626 * case.
5626 5627 */
5627 5628 if (!ioctl_msg)
5628 5629 match_flags |= MATCH_IRE_MASK;
5629 5630 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr,
5630 5631 IRE_INTERFACE, ill, ALL_ZONES, NULL, match_flags, 0, ipst,
5631 5632 NULL);
5632 5633 if (ire != NULL) {
5633 5634 ire_refrele(ire);
5634 5635 ipif_refrele(ipif);
5635 5636 return (EEXIST);
5636 5637 }
5637 5638
5638 5639 /*
5639 5640 * Some software (for example, GateD and Sun Cluster) attempts
5640 5641 * to create (what amount to) IRE_PREFIX routes with the
5641 5642 * loopback address as the gateway. This is primarily done to
5642 5643 * set up prefixes with the RTF_REJECT flag set (for example,
5643 5644 * when generating aggregate routes.)
5644 5645 *
5645 5646 * If the IRE type (as defined by ill->ill_net_type) would be
5646 5647 * IRE_LOOPBACK, then we map the request into a
5647 5648 * IRE_IF_NORESOLVER. We also OR in the RTF_BLACKHOLE flag as
5648 5649 * these interface routes, by definition, can only be that.
5649 5650 *
5650 5651 * Needless to say, the real IRE_LOOPBACK is NOT created by this
5651 5652 * routine, but rather using ire_create() directly.
5652 5653 *
5653 5654 */
5654 5655 type = ill->ill_net_type;
5655 5656 if (type == IRE_LOOPBACK) {
5656 5657 type = IRE_IF_NORESOLVER;
5657 5658 flags |= RTF_BLACKHOLE;
5658 5659 }
5659 5660
5660 5661 /*
5661 5662 * Create a copy of the IRE_IF_NORESOLVER or
5662 5663 * IRE_IF_RESOLVER with the modified address, netmask, and
5663 5664 * gateway.
5664 5665 */
5665 5666 ire = ire_create(
5666 5667 (uchar_t *)&dst_addr,
5667 5668 (uint8_t *)&mask,
5668 5669 (uint8_t *)&gw_addr,
5669 5670 type,
5670 5671 ill,
5671 5672 zoneid,
5672 5673 flags,
5673 5674 NULL,
5674 5675 ipst);
5675 5676 if (ire == NULL) {
5676 5677 ipif_refrele(ipif);
5677 5678 return (ENOMEM);
5678 5679 }
5679 5680
5680 5681 /* src address assigned by the caller? */
5681 5682 if ((src_addr != INADDR_ANY) && (flags & RTF_SETSRC))
5682 5683 ire->ire_setsrc_addr = src_addr;
5683 5684
5684 5685 nire = ire_add(ire);
5685 5686 if (nire == NULL) {
5686 5687 /*
5687 5688 * In the result of failure, ire_add() will have
5688 5689 * already deleted the ire in question, so there
5689 5690 * is no need to do that here.
5690 5691 */
5691 5692 ipif_refrele(ipif);
5692 5693 return (ENOMEM);
5693 5694 }
5694 5695 /*
5695 5696 * Check if it was a duplicate entry. This handles
5696 5697 * the case of two racing route adds for the same route
5697 5698 */
5698 5699 if (nire != ire) {
5699 5700 ire_delete(nire);
5700 5701 ire_refrele(nire);
5701 5702 ipif_refrele(ipif);
5702 5703 return (EEXIST);
5703 5704 }
5704 5705 ire = nire;
5705 5706 goto save_ire;
5706 5707 }
5707 5708
5708 5709 /*
5709 5710 * Get an interface IRE for the specified gateway.
5710 5711 * If we don't have an IRE_IF_NORESOLVER or IRE_IF_RESOLVER for the
5711 5712 * gateway, it is currently unreachable and we fail the request
5712 5713 * accordingly. We reject any RTF_GATEWAY routes where the gateway
5713 5714 * is an IRE_LOCAL or IRE_LOOPBACK.
5714 5715 * If RTA_IFP was specified we look on that particular ill.
5715 5716 */
5716 5717 if (ill != NULL)
5717 5718 match_flags |= MATCH_IRE_ILL;
5718 5719
5719 5720 /* Check whether the gateway is reachable. */
5720 5721 again:
5721 5722 type = IRE_INTERFACE | IRE_LOCAL | IRE_LOOPBACK;
5722 5723 if (flags & RTF_INDIRECT)
5723 5724 type |= IRE_OFFLINK;
5724 5725
5725 5726 gw_ire = ire_ftable_lookup_v4(gw_addr, 0, 0, type, ill,
5726 5727 ALL_ZONES, NULL, match_flags, 0, ipst, NULL);
5727 5728 if (gw_ire == NULL) {
5728 5729 /*
5729 5730 * With IPMP, we allow host routes to influence in.mpathd's
5730 5731 * target selection. However, if the test addresses are on
5731 5732 * their own network, the above lookup will fail since the
5732 5733 * underlying IRE_INTERFACEs are marked hidden. So allow
5733 5734 * hidden test IREs to be found and try again.
5734 5735 */
5735 5736 if (!(match_flags & MATCH_IRE_TESTHIDDEN)) {
5736 5737 match_flags |= MATCH_IRE_TESTHIDDEN;
5737 5738 goto again;
5738 5739 }
5739 5740 if (ipif != NULL)
5740 5741 ipif_refrele(ipif);
5741 5742 return (ENETUNREACH);
5742 5743 }
5743 5744 if (gw_ire->ire_type & (IRE_LOCAL|IRE_LOOPBACK)) {
5744 5745 ire_refrele(gw_ire);
5745 5746 if (ipif != NULL)
5746 5747 ipif_refrele(ipif);
5747 5748 return (ENETUNREACH);
5748 5749 }
5749 5750
5750 5751 if (ill == NULL && !(flags & RTF_INDIRECT)) {
5751 5752 unbound = B_TRUE;
5752 5753 if (ipst->ips_ip_strict_src_multihoming > 0)
5753 5754 ill = gw_ire->ire_ill;
5754 5755 }
5755 5756
5756 5757 /*
5757 5758 * We create one of three types of IREs as a result of this request
5758 5759 * based on the netmask. A netmask of all ones (which is automatically
5759 5760 * assumed when RTF_HOST is set) results in an IRE_HOST being created.
5760 5761 * An all zeroes netmask implies a default route so an IRE_DEFAULT is
5761 5762 * created. Otherwise, an IRE_PREFIX route is created for the
5762 5763 * destination prefix.
5763 5764 */
5764 5765 if (mask == IP_HOST_MASK)
5765 5766 type = IRE_HOST;
5766 5767 else if (mask == 0)
5767 5768 type = IRE_DEFAULT;
5768 5769 else
5769 5770 type = IRE_PREFIX;
5770 5771
5771 5772 /* check for a duplicate entry */
5772 5773 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr, type, ill,
5773 5774 ALL_ZONES, NULL, match_flags | MATCH_IRE_MASK | MATCH_IRE_GW,
5774 5775 0, ipst, NULL);
5775 5776 if (ire != NULL) {
5776 5777 if (ipif != NULL)
5777 5778 ipif_refrele(ipif);
5778 5779 ire_refrele(gw_ire);
5779 5780 ire_refrele(ire);
5780 5781 return (EEXIST);
5781 5782 }
5782 5783
5783 5784 /* Security attribute exists */
5784 5785 if (sp != NULL) {
5785 5786 tsol_gcgrp_addr_t ga;
5786 5787
5787 5788 /* find or create the gateway credentials group */
5788 5789 ga.ga_af = AF_INET;
5789 5790 IN6_IPADDR_TO_V4MAPPED(gw_addr, &ga.ga_addr);
5790 5791
5791 5792 /* we hold reference to it upon success */
5792 5793 gcgrp = gcgrp_lookup(&ga, B_TRUE);
5793 5794 if (gcgrp == NULL) {
5794 5795 if (ipif != NULL)
5795 5796 ipif_refrele(ipif);
5796 5797 ire_refrele(gw_ire);
5797 5798 return (ENOMEM);
5798 5799 }
5799 5800
5800 5801 /*
5801 5802 * Create and add the security attribute to the group; a
5802 5803 * reference to the group is made upon allocating a new
5803 5804 * entry successfully. If it finds an already-existing
5804 5805 * entry for the security attribute in the group, it simply
5805 5806 * returns it and no new reference is made to the group.
5806 5807 */
5807 5808 gc = gc_create(sp, gcgrp, &gcgrp_xtraref);
5808 5809 if (gc == NULL) {
5809 5810 if (ipif != NULL)
5810 5811 ipif_refrele(ipif);
5811 5812 /* release reference held by gcgrp_lookup */
5812 5813 GCGRP_REFRELE(gcgrp);
5813 5814 ire_refrele(gw_ire);
5814 5815 return (ENOMEM);
5815 5816 }
5816 5817 }
5817 5818
5818 5819 /* Create the IRE. */
5819 5820 ire = ire_create(
5820 5821 (uchar_t *)&dst_addr, /* dest address */
5821 5822 (uchar_t *)&mask, /* mask */
5822 5823 (uchar_t *)&gw_addr, /* gateway address */
5823 5824 (ushort_t)type, /* IRE type */
5824 5825 ill,
5825 5826 zoneid,
5826 5827 flags,
5827 5828 gc, /* security attribute */
5828 5829 ipst);
5829 5830
5830 5831 /*
5831 5832 * The ire holds a reference to the 'gc' and the 'gc' holds a
5832 5833 * reference to the 'gcgrp'. We can now release the extra reference
5833 5834 * the 'gcgrp' acquired in the gcgrp_lookup, if it was not used.
5834 5835 */
5835 5836 if (gcgrp_xtraref)
5836 5837 GCGRP_REFRELE(gcgrp);
5837 5838 if (ire == NULL) {
5838 5839 if (gc != NULL)
5839 5840 GC_REFRELE(gc);
5840 5841 if (ipif != NULL)
5841 5842 ipif_refrele(ipif);
5842 5843 ire_refrele(gw_ire);
5843 5844 return (ENOMEM);
5844 5845 }
5845 5846
5846 5847 /* Before we add, check if an extra CGTP broadcast is needed */
5847 5848 cgtp_broadcast = ((flags & RTF_MULTIRT) &&
5848 5849 ip_type_v4(ire->ire_addr, ipst) == IRE_BROADCAST);
5849 5850
5850 5851 /* src address assigned by the caller? */
5851 5852 if ((src_addr != INADDR_ANY) && (flags & RTF_SETSRC))
5852 5853 ire->ire_setsrc_addr = src_addr;
5853 5854
5854 5855 ire->ire_unbound = unbound;
5855 5856
5856 5857 /*
5857 5858 * POLICY: should we allow an RTF_HOST with address INADDR_ANY?
5858 5859 * SUN/OS socket stuff does but do we really want to allow 0.0.0.0?
5859 5860 */
5860 5861
5861 5862 /* Add the new IRE. */
5862 5863 nire = ire_add(ire);
5863 5864 if (nire == NULL) {
5864 5865 /*
5865 5866 * In the result of failure, ire_add() will have
5866 5867 * already deleted the ire in question, so there
5867 5868 * is no need to do that here.
5868 5869 */
5869 5870 if (ipif != NULL)
5870 5871 ipif_refrele(ipif);
5871 5872 ire_refrele(gw_ire);
5872 5873 return (ENOMEM);
5873 5874 }
5874 5875 /*
5875 5876 * Check if it was a duplicate entry. This handles
5876 5877 * the case of two racing route adds for the same route
5877 5878 */
5878 5879 if (nire != ire) {
5879 5880 ire_delete(nire);
5880 5881 ire_refrele(nire);
5881 5882 if (ipif != NULL)
5882 5883 ipif_refrele(ipif);
5883 5884 ire_refrele(gw_ire);
5884 5885 return (EEXIST);
5885 5886 }
5886 5887 ire = nire;
5887 5888
5888 5889 if (flags & RTF_MULTIRT) {
5889 5890 /*
5890 5891 * Invoke the CGTP (multirouting) filtering module
5891 5892 * to add the dst address in the filtering database.
5892 5893 * Replicated inbound packets coming from that address
5893 5894 * will be filtered to discard the duplicates.
5894 5895 * It is not necessary to call the CGTP filter hook
5895 5896 * when the dst address is a broadcast or multicast,
5896 5897 * because an IP source address cannot be a broadcast
5897 5898 * or a multicast.
5898 5899 */
5899 5900 if (cgtp_broadcast) {
5900 5901 ip_cgtp_bcast_add(ire, ipst);
5901 5902 goto save_ire;
5902 5903 }
5903 5904 if (ipst->ips_ip_cgtp_filter_ops != NULL &&
5904 5905 !CLASSD(ire->ire_addr)) {
5905 5906 int res;
5906 5907 ipif_t *src_ipif;
5907 5908
5908 5909 /* Find the source address corresponding to gw_ire */
5909 5910 src_ipif = ipif_lookup_addr(gw_ire->ire_gateway_addr,
5910 5911 NULL, zoneid, ipst);
5911 5912 if (src_ipif != NULL) {
5912 5913 res = ipst->ips_ip_cgtp_filter_ops->
5913 5914 cfo_add_dest_v4(
5914 5915 ipst->ips_netstack->netstack_stackid,
5915 5916 ire->ire_addr,
5916 5917 ire->ire_gateway_addr,
5917 5918 ire->ire_setsrc_addr,
5918 5919 src_ipif->ipif_lcl_addr);
5919 5920 ipif_refrele(src_ipif);
5920 5921 } else {
5921 5922 res = EADDRNOTAVAIL;
5922 5923 }
5923 5924 if (res != 0) {
5924 5925 if (ipif != NULL)
5925 5926 ipif_refrele(ipif);
5926 5927 ire_refrele(gw_ire);
5927 5928 ire_delete(ire);
5928 5929 ire_refrele(ire); /* Held in ire_add */
5929 5930 return (res);
5930 5931 }
5931 5932 }
5932 5933 }
5933 5934
5934 5935 save_ire:
5935 5936 if (gw_ire != NULL) {
5936 5937 ire_refrele(gw_ire);
5937 5938 gw_ire = NULL;
5938 5939 }
5939 5940 if (ill != NULL) {
5940 5941 /*
5941 5942 * Save enough information so that we can recreate the IRE if
5942 5943 * the interface goes down and then up. The metrics associated
5943 5944 * with the route will be saved as well when rts_setmetrics() is
5944 5945 * called after the IRE has been created. In the case where
5945 5946 * memory cannot be allocated, none of this information will be
5946 5947 * saved.
5947 5948 */
5948 5949 ill_save_ire(ill, ire);
5949 5950 }
5950 5951 if (ioctl_msg)
5951 5952 ip_rts_rtmsg(RTM_OLDADD, ire, 0, ipst);
5952 5953 if (ire_arg != NULL) {
5953 5954 /*
5954 5955 * Store the ire that was successfully added into where ire_arg
5955 5956 * points to so that callers don't have to look it up
5956 5957 * themselves (but they are responsible for ire_refrele()ing
5957 5958 * the ire when they are finished with it).
5958 5959 */
5959 5960 *ire_arg = ire;
5960 5961 } else {
5961 5962 ire_refrele(ire); /* Held in ire_add */
5962 5963 }
5963 5964 if (ipif != NULL)
5964 5965 ipif_refrele(ipif);
5965 5966 return (0);
5966 5967 }
5967 5968
5968 5969 /*
5969 5970 * ip_rt_delete is called to delete an IPv4 route.
5970 5971 * ill is passed in to associate it with the correct interface.
5971 5972 */
5972 5973 /* ARGSUSED4 */
5973 5974 int
5974 5975 ip_rt_delete(ipaddr_t dst_addr, ipaddr_t mask, ipaddr_t gw_addr,
5975 5976 uint_t rtm_addrs, int flags, ill_t *ill, boolean_t ioctl_msg,
5976 5977 ip_stack_t *ipst, zoneid_t zoneid)
5977 5978 {
5978 5979 ire_t *ire = NULL;
5979 5980 ipif_t *ipif;
5980 5981 uint_t type;
5981 5982 uint_t match_flags = MATCH_IRE_TYPE;
5982 5983 int err = 0;
5983 5984
5984 5985 ip1dbg(("ip_rt_delete:"));
5985 5986 /*
5986 5987 * If this is the case of RTF_HOST being set, then we set the netmask
5987 5988 * to all ones. Otherwise, we use the netmask if one was supplied.
5988 5989 */
5989 5990 if (flags & RTF_HOST) {
5990 5991 mask = IP_HOST_MASK;
5991 5992 match_flags |= MATCH_IRE_MASK;
5992 5993 } else if (rtm_addrs & RTA_NETMASK) {
5993 5994 match_flags |= MATCH_IRE_MASK;
5994 5995 }
5995 5996
5996 5997 /*
5997 5998 * Note that RTF_GATEWAY is never set on a delete, therefore
5998 5999 * we check if the gateway address is one of our interfaces first,
5999 6000 * and fall back on RTF_GATEWAY routes.
6000 6001 *
6001 6002 * This makes it possible to delete an original
6002 6003 * IRE_IF_NORESOLVER/IRE_IF_RESOLVER - consistent with SunOS 4.1.
6003 6004 * However, we have RTF_KERNEL set on the ones created by ipif_up
6004 6005 * and those can not be deleted here.
6005 6006 *
6006 6007 * We use MATCH_IRE_ILL if we know the interface. If the caller
6007 6008 * specified an interface (from the RTA_IFP sockaddr) we use it,
6008 6009 * otherwise we use the ill derived from the gateway address.
6009 6010 * We can always match the gateway address since we record it
6010 6011 * in ire_gateway_addr.
6011 6012 *
6012 6013 * For more detail on specifying routes by gateway address and by
6013 6014 * interface index, see the comments in ip_rt_add().
6014 6015 */
6015 6016 ipif = ipif_lookup_interface(gw_addr, dst_addr, ipst);
6016 6017 if (ipif != NULL) {
6017 6018 ill_t *ill_match;
6018 6019
6019 6020 if (ill != NULL)
6020 6021 ill_match = ill;
6021 6022 else
6022 6023 ill_match = ipif->ipif_ill;
6023 6024
6024 6025 match_flags |= MATCH_IRE_ILL;
6025 6026 if (ipif->ipif_ire_type == IRE_LOOPBACK) {
6026 6027 ire = ire_ftable_lookup_v4(dst_addr, mask, 0,
6027 6028 IRE_LOOPBACK, ill_match, ALL_ZONES, NULL,
6028 6029 match_flags, 0, ipst, NULL);
6029 6030 }
6030 6031 if (ire == NULL) {
6031 6032 match_flags |= MATCH_IRE_GW;
6032 6033 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr,
6033 6034 IRE_INTERFACE, ill_match, ALL_ZONES, NULL,
6034 6035 match_flags, 0, ipst, NULL);
6035 6036 }
6036 6037 /* Avoid deleting routes created by kernel from an ipif */
6037 6038 if (ire != NULL && (ire->ire_flags & RTF_KERNEL)) {
6038 6039 ire_refrele(ire);
6039 6040 ire = NULL;
6040 6041 }
6041 6042
6042 6043 /* Restore in case we didn't find a match */
6043 6044 match_flags &= ~(MATCH_IRE_GW|MATCH_IRE_ILL);
6044 6045 }
6045 6046
6046 6047 if (ire == NULL) {
6047 6048 /*
6048 6049 * At this point, the gateway address is not one of our own
6049 6050 * addresses or a matching interface route was not found. We
6050 6051 * set the IRE type to lookup based on whether
6051 6052 * this is a host route, a default route or just a prefix.
6052 6053 *
6053 6054 * If an ill was passed in, then the lookup is based on an
6054 6055 * interface index so MATCH_IRE_ILL is added to match_flags.
6055 6056 */
6056 6057 match_flags |= MATCH_IRE_GW;
6057 6058 if (ill != NULL)
6058 6059 match_flags |= MATCH_IRE_ILL;
6059 6060 if (mask == IP_HOST_MASK)
6060 6061 type = IRE_HOST;
6061 6062 else if (mask == 0)
6062 6063 type = IRE_DEFAULT;
6063 6064 else
6064 6065 type = IRE_PREFIX;
6065 6066 ire = ire_ftable_lookup_v4(dst_addr, mask, gw_addr, type, ill,
6066 6067 ALL_ZONES, NULL, match_flags, 0, ipst, NULL);
6067 6068 }
6068 6069
6069 6070 if (ipif != NULL) {
6070 6071 ipif_refrele(ipif);
6071 6072 ipif = NULL;
6072 6073 }
6073 6074
6074 6075 if (ire == NULL)
6075 6076 return (ESRCH);
6076 6077
6077 6078 if (ire->ire_flags & RTF_MULTIRT) {
6078 6079 /*
6079 6080 * Invoke the CGTP (multirouting) filtering module
6080 6081 * to remove the dst address from the filtering database.
6081 6082 * Packets coming from that address will no longer be
6082 6083 * filtered to remove duplicates.
6083 6084 */
6084 6085 if (ipst->ips_ip_cgtp_filter_ops != NULL) {
6085 6086 err = ipst->ips_ip_cgtp_filter_ops->cfo_del_dest_v4(
6086 6087 ipst->ips_netstack->netstack_stackid,
6087 6088 ire->ire_addr, ire->ire_gateway_addr);
6088 6089 }
6089 6090 ip_cgtp_bcast_delete(ire, ipst);
6090 6091 }
6091 6092
6092 6093 ill = ire->ire_ill;
6093 6094 if (ill != NULL)
6094 6095 ill_remove_saved_ire(ill, ire);
6095 6096 if (ioctl_msg)
6096 6097 ip_rts_rtmsg(RTM_OLDDEL, ire, 0, ipst);
6097 6098 ire_delete(ire);
6098 6099 ire_refrele(ire);
6099 6100 return (err);
6100 6101 }
6101 6102
6102 6103 /*
6103 6104 * ip_siocaddrt is called to complete processing of an SIOCADDRT IOCTL.
6104 6105 */
6105 6106 /* ARGSUSED */
6106 6107 int
6107 6108 ip_siocaddrt(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
6108 6109 ip_ioctl_cmd_t *ipip, void *dummy_if_req)
6109 6110 {
6110 6111 ipaddr_t dst_addr;
6111 6112 ipaddr_t gw_addr;
6112 6113 ipaddr_t mask;
6113 6114 int error = 0;
6114 6115 mblk_t *mp1;
6115 6116 struct rtentry *rt;
6116 6117 ipif_t *ipif = NULL;
6117 6118 ip_stack_t *ipst;
6118 6119
6119 6120 ASSERT(q->q_next == NULL);
6120 6121 ipst = CONNQ_TO_IPST(q);
6121 6122
6122 6123 ip1dbg(("ip_siocaddrt:"));
6123 6124 /* Existence of mp1 verified in ip_wput_nondata */
6124 6125 mp1 = mp->b_cont->b_cont;
6125 6126 rt = (struct rtentry *)mp1->b_rptr;
6126 6127
6127 6128 dst_addr = ((sin_t *)&rt->rt_dst)->sin_addr.s_addr;
6128 6129 gw_addr = ((sin_t *)&rt->rt_gateway)->sin_addr.s_addr;
6129 6130
6130 6131 /*
6131 6132 * If the RTF_HOST flag is on, this is a request to assign a gateway
6132 6133 * to a particular host address. In this case, we set the netmask to
6133 6134 * all ones for the particular destination address. Otherwise,
6134 6135 * determine the netmask to be used based on dst_addr and the interfaces
6135 6136 * in use.
6136 6137 */
6137 6138 if (rt->rt_flags & RTF_HOST) {
6138 6139 mask = IP_HOST_MASK;
6139 6140 } else {
6140 6141 /*
6141 6142 * Note that ip_subnet_mask returns a zero mask in the case of
6142 6143 * default (an all-zeroes address).
6143 6144 */
6144 6145 mask = ip_subnet_mask(dst_addr, &ipif, ipst);
6145 6146 }
6146 6147
6147 6148 error = ip_rt_add(dst_addr, mask, gw_addr, 0, rt->rt_flags, NULL, NULL,
6148 6149 B_TRUE, NULL, ipst, ALL_ZONES);
6149 6150 if (ipif != NULL)
6150 6151 ipif_refrele(ipif);
6151 6152 return (error);
6152 6153 }
6153 6154
6154 6155 /*
6155 6156 * ip_siocdelrt is called to complete processing of an SIOCDELRT IOCTL.
6156 6157 */
6157 6158 /* ARGSUSED */
6158 6159 int
6159 6160 ip_siocdelrt(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
6160 6161 ip_ioctl_cmd_t *ipip, void *dummy_if_req)
6161 6162 {
6162 6163 ipaddr_t dst_addr;
6163 6164 ipaddr_t gw_addr;
6164 6165 ipaddr_t mask;
6165 6166 int error;
6166 6167 mblk_t *mp1;
6167 6168 struct rtentry *rt;
6168 6169 ipif_t *ipif = NULL;
6169 6170 ip_stack_t *ipst;
6170 6171
6171 6172 ASSERT(q->q_next == NULL);
6172 6173 ipst = CONNQ_TO_IPST(q);
6173 6174
6174 6175 ip1dbg(("ip_siocdelrt:"));
6175 6176 /* Existence of mp1 verified in ip_wput_nondata */
6176 6177 mp1 = mp->b_cont->b_cont;
6177 6178 rt = (struct rtentry *)mp1->b_rptr;
6178 6179
6179 6180 dst_addr = ((sin_t *)&rt->rt_dst)->sin_addr.s_addr;
6180 6181 gw_addr = ((sin_t *)&rt->rt_gateway)->sin_addr.s_addr;
6181 6182
6182 6183 /*
6183 6184 * If the RTF_HOST flag is on, this is a request to delete a gateway
6184 6185 * to a particular host address. In this case, we set the netmask to
6185 6186 * all ones for the particular destination address. Otherwise,
6186 6187 * determine the netmask to be used based on dst_addr and the interfaces
6187 6188 * in use.
6188 6189 */
6189 6190 if (rt->rt_flags & RTF_HOST) {
6190 6191 mask = IP_HOST_MASK;
6191 6192 } else {
6192 6193 /*
6193 6194 * Note that ip_subnet_mask returns a zero mask in the case of
6194 6195 * default (an all-zeroes address).
6195 6196 */
6196 6197 mask = ip_subnet_mask(dst_addr, &ipif, ipst);
6197 6198 }
6198 6199
6199 6200 error = ip_rt_delete(dst_addr, mask, gw_addr,
6200 6201 RTA_DST | RTA_GATEWAY | RTA_NETMASK, rt->rt_flags, NULL, B_TRUE,
6201 6202 ipst, ALL_ZONES);
6202 6203 if (ipif != NULL)
6203 6204 ipif_refrele(ipif);
6204 6205 return (error);
6205 6206 }
6206 6207
6207 6208 /*
6208 6209 * Enqueue the mp onto the ipsq, chained by b_next.
6209 6210 * b_prev stores the function to be executed later, and b_queue the queue
6210 6211 * where this mp originated.
6211 6212 */
6212 6213 void
6213 6214 ipsq_enq(ipsq_t *ipsq, queue_t *q, mblk_t *mp, ipsq_func_t func, int type,
6214 6215 ill_t *pending_ill)
6215 6216 {
6216 6217 conn_t *connp;
6217 6218 ipxop_t *ipx = ipsq->ipsq_xop;
6218 6219
6219 6220 ASSERT(MUTEX_HELD(&ipsq->ipsq_lock));
6220 6221 ASSERT(MUTEX_HELD(&ipx->ipx_lock));
6221 6222 ASSERT(func != NULL);
6222 6223
6223 6224 mp->b_queue = q;
6224 6225 mp->b_prev = (void *)func;
6225 6226 mp->b_next = NULL;
6226 6227
6227 6228 switch (type) {
6228 6229 case CUR_OP:
6229 6230 if (ipx->ipx_mptail != NULL) {
6230 6231 ASSERT(ipx->ipx_mphead != NULL);
6231 6232 ipx->ipx_mptail->b_next = mp;
6232 6233 } else {
6233 6234 ASSERT(ipx->ipx_mphead == NULL);
6234 6235 ipx->ipx_mphead = mp;
6235 6236 }
6236 6237 ipx->ipx_mptail = mp;
6237 6238 break;
6238 6239
6239 6240 case NEW_OP:
6240 6241 if (ipsq->ipsq_xopq_mptail != NULL) {
6241 6242 ASSERT(ipsq->ipsq_xopq_mphead != NULL);
6242 6243 ipsq->ipsq_xopq_mptail->b_next = mp;
6243 6244 } else {
6244 6245 ASSERT(ipsq->ipsq_xopq_mphead == NULL);
6245 6246 ipsq->ipsq_xopq_mphead = mp;
6246 6247 }
6247 6248 ipsq->ipsq_xopq_mptail = mp;
6248 6249 ipx->ipx_ipsq_queued = B_TRUE;
6249 6250 break;
6250 6251
6251 6252 case SWITCH_OP:
6252 6253 ASSERT(ipsq->ipsq_swxop != NULL);
6253 6254 /* only one switch operation is currently allowed */
6254 6255 ASSERT(ipsq->ipsq_switch_mp == NULL);
6255 6256 ipsq->ipsq_switch_mp = mp;
6256 6257 ipx->ipx_ipsq_queued = B_TRUE;
6257 6258 break;
6258 6259 default:
6259 6260 cmn_err(CE_PANIC, "ipsq_enq %d type \n", type);
6260 6261 }
6261 6262
6262 6263 if (CONN_Q(q) && pending_ill != NULL) {
6263 6264 connp = Q_TO_CONN(q);
6264 6265 ASSERT(MUTEX_HELD(&connp->conn_lock));
6265 6266 connp->conn_oper_pending_ill = pending_ill;
6266 6267 }
6267 6268 }
6268 6269
6269 6270 /*
6270 6271 * Dequeue the next message that requested exclusive access to this IPSQ's
6271 6272 * xop. Specifically:
6272 6273 *
6273 6274 * 1. If we're still processing the current operation on `ipsq', then
6274 6275 * dequeue the next message for the operation (from ipx_mphead), or
6275 6276 * return NULL if there are no queued messages for the operation.
6276 6277 * These messages are queued via CUR_OP to qwriter_ip() and friends.
6277 6278 *
6278 6279 * 2. If the current operation on `ipsq' has completed (ipx_current_ipif is
6279 6280 * not set) see if the ipsq has requested an xop switch. If so, switch
6280 6281 * `ipsq' to a different xop. Xop switches only happen when joining or
6281 6282 * leaving IPMP groups and require a careful dance -- see the comments
6282 6283 * in-line below for details. If we're leaving a group xop or if we're
6283 6284 * joining a group xop and become writer on it, then we proceed to (3).
6284 6285 * Otherwise, we return NULL and exit the xop.
6285 6286 *
6286 6287 * 3. For each IPSQ in the xop, return any switch operation stored on
6287 6288 * ipsq_switch_mp (set via SWITCH_OP); these must be processed before
6288 6289 * any other messages queued on the IPSQ. Otherwise, dequeue the next
6289 6290 * exclusive operation (queued via NEW_OP) stored on ipsq_xopq_mphead.
6290 6291 * Note that if the phyint tied to `ipsq' is not using IPMP there will
6291 6292 * only be one IPSQ in the xop. Otherwise, there will be one IPSQ for
6292 6293 * each phyint in the group, including the IPMP meta-interface phyint.
6293 6294 */
6294 6295 static mblk_t *
6295 6296 ipsq_dq(ipsq_t *ipsq)
6296 6297 {
6297 6298 ill_t *illv4, *illv6;
6298 6299 mblk_t *mp;
6299 6300 ipsq_t *xopipsq;
6300 6301 ipsq_t *leftipsq = NULL;
6301 6302 ipxop_t *ipx;
6302 6303 phyint_t *phyi = ipsq->ipsq_phyint;
6303 6304 ip_stack_t *ipst = ipsq->ipsq_ipst;
6304 6305 boolean_t emptied = B_FALSE;
6305 6306
6306 6307 /*
6307 6308 * Grab all the locks we need in the defined order (ill_g_lock ->
6308 6309 * ipsq_lock -> ipx_lock); ill_g_lock is needed to use ipsq_next.
6309 6310 */
6310 6311 rw_enter(&ipst->ips_ill_g_lock,
6311 6312 ipsq->ipsq_swxop != NULL ? RW_WRITER : RW_READER);
6312 6313 mutex_enter(&ipsq->ipsq_lock);
6313 6314 ipx = ipsq->ipsq_xop;
6314 6315 mutex_enter(&ipx->ipx_lock);
6315 6316
6316 6317 /*
6317 6318 * Dequeue the next message associated with the current exclusive
6318 6319 * operation, if any.
6319 6320 */
6320 6321 if ((mp = ipx->ipx_mphead) != NULL) {
6321 6322 ipx->ipx_mphead = mp->b_next;
6322 6323 if (ipx->ipx_mphead == NULL)
6323 6324 ipx->ipx_mptail = NULL;
6324 6325 mp->b_next = (void *)ipsq;
6325 6326 goto out;
6326 6327 }
6327 6328
6328 6329 if (ipx->ipx_current_ipif != NULL)
6329 6330 goto empty;
6330 6331
6331 6332 if (ipsq->ipsq_swxop != NULL) {
6332 6333 /*
6333 6334 * The exclusive operation that is now being completed has
6334 6335 * requested a switch to a different xop. This happens
6335 6336 * when an interface joins or leaves an IPMP group. Joins
6336 6337 * happen through SIOCSLIFGROUPNAME (ip_sioctl_groupname()).
6337 6338 * Leaves happen via SIOCSLIFGROUPNAME, interface unplumb
6338 6339 * (phyint_free()), or interface plumb for an ill type
6339 6340 * not in the IPMP group (ip_rput_dlpi_writer()).
6340 6341 *
6341 6342 * Xop switches are not allowed on the IPMP meta-interface.
6342 6343 */
6343 6344 ASSERT(phyi == NULL || !(phyi->phyint_flags & PHYI_IPMP));
6344 6345 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock));
6345 6346 DTRACE_PROBE1(ipsq__switch, (ipsq_t *), ipsq);
6346 6347
6347 6348 if (ipsq->ipsq_swxop == &ipsq->ipsq_ownxop) {
6348 6349 /*
6349 6350 * We're switching back to our own xop, so we have two
6350 6351 * xop's to drain/exit: our own, and the group xop
6351 6352 * that we are leaving.
6352 6353 *
6353 6354 * First, pull ourselves out of the group ipsq list.
6354 6355 * This is safe since we're writer on ill_g_lock.
6355 6356 */
6356 6357 ASSERT(ipsq->ipsq_xop != &ipsq->ipsq_ownxop);
6357 6358
6358 6359 xopipsq = ipx->ipx_ipsq;
6359 6360 while (xopipsq->ipsq_next != ipsq)
6360 6361 xopipsq = xopipsq->ipsq_next;
6361 6362
6362 6363 xopipsq->ipsq_next = ipsq->ipsq_next;
6363 6364 ipsq->ipsq_next = ipsq;
6364 6365 ipsq->ipsq_xop = ipsq->ipsq_swxop;
6365 6366 ipsq->ipsq_swxop = NULL;
6366 6367
6367 6368 /*
6368 6369 * Second, prepare to exit the group xop. The actual
6369 6370 * ipsq_exit() is done at the end of this function
6370 6371 * since we cannot hold any locks across ipsq_exit().
6371 6372 * Note that although we drop the group's ipx_lock, no
6372 6373 * threads can proceed since we're still ipx_writer.
6373 6374 */
6374 6375 leftipsq = xopipsq;
6375 6376 mutex_exit(&ipx->ipx_lock);
6376 6377
6377 6378 /*
6378 6379 * Third, set ipx to point to our own xop (which was
6379 6380 * inactive and therefore can be entered).
6380 6381 */
6381 6382 ipx = ipsq->ipsq_xop;
6382 6383 mutex_enter(&ipx->ipx_lock);
6383 6384 ASSERT(ipx->ipx_writer == NULL);
6384 6385 ASSERT(ipx->ipx_current_ipif == NULL);
6385 6386 } else {
6386 6387 /*
6387 6388 * We're switching from our own xop to a group xop.
6388 6389 * The requestor of the switch must ensure that the
6389 6390 * group xop cannot go away (e.g. by ensuring the
6390 6391 * phyint associated with the xop cannot go away).
6391 6392 *
6392 6393 * If we can become writer on our new xop, then we'll
6393 6394 * do the drain. Otherwise, the current writer of our
6394 6395 * new xop will do the drain when it exits.
6395 6396 *
6396 6397 * First, splice ourselves into the group IPSQ list.
6397 6398 * This is safe since we're writer on ill_g_lock.
6398 6399 */
6399 6400 ASSERT(ipsq->ipsq_xop == &ipsq->ipsq_ownxop);
6400 6401
6401 6402 xopipsq = ipsq->ipsq_swxop->ipx_ipsq;
6402 6403 while (xopipsq->ipsq_next != ipsq->ipsq_swxop->ipx_ipsq)
6403 6404 xopipsq = xopipsq->ipsq_next;
6404 6405
6405 6406 xopipsq->ipsq_next = ipsq;
6406 6407 ipsq->ipsq_next = ipsq->ipsq_swxop->ipx_ipsq;
6407 6408 ipsq->ipsq_xop = ipsq->ipsq_swxop;
6408 6409 ipsq->ipsq_swxop = NULL;
6409 6410
6410 6411 /*
6411 6412 * Second, exit our own xop, since it's now unused.
6412 6413 * This is safe since we've got the only reference.
6413 6414 */
6414 6415 ASSERT(ipx->ipx_writer == curthread);
6415 6416 ipx->ipx_writer = NULL;
6416 6417 VERIFY(--ipx->ipx_reentry_cnt == 0);
6417 6418 ipx->ipx_ipsq_queued = B_FALSE;
6418 6419 mutex_exit(&ipx->ipx_lock);
6419 6420
6420 6421 /*
6421 6422 * Third, set ipx to point to our new xop, and check
6422 6423 * if we can become writer on it. If we cannot, then
6423 6424 * the current writer will drain the IPSQ group when
6424 6425 * it exits. Our ipsq_xop is guaranteed to be stable
6425 6426 * because we're still holding ipsq_lock.
6426 6427 */
6427 6428 ipx = ipsq->ipsq_xop;
6428 6429 mutex_enter(&ipx->ipx_lock);
6429 6430 if (ipx->ipx_writer != NULL ||
6430 6431 ipx->ipx_current_ipif != NULL) {
6431 6432 goto out;
6432 6433 }
6433 6434 }
6434 6435
6435 6436 /*
6436 6437 * Fourth, become writer on our new ipx before we continue
6437 6438 * with the drain. Note that we never dropped ipsq_lock
6438 6439 * above, so no other thread could've raced with us to
6439 6440 * become writer first. Also, we're holding ipx_lock, so
6440 6441 * no other thread can examine the ipx right now.
6441 6442 */
6442 6443 ASSERT(ipx->ipx_current_ipif == NULL);
6443 6444 ASSERT(ipx->ipx_mphead == NULL && ipx->ipx_mptail == NULL);
6444 6445 VERIFY(ipx->ipx_reentry_cnt++ == 0);
6445 6446 ipx->ipx_writer = curthread;
6446 6447 ipx->ipx_forced = B_FALSE;
6447 6448 #ifdef DEBUG
6448 6449 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
6449 6450 #endif
6450 6451 }
6451 6452
6452 6453 xopipsq = ipsq;
6453 6454 do {
6454 6455 /*
6455 6456 * So that other operations operate on a consistent and
6456 6457 * complete phyint, a switch message on an IPSQ must be
6457 6458 * handled prior to any other operations on that IPSQ.
6458 6459 */
6459 6460 if ((mp = xopipsq->ipsq_switch_mp) != NULL) {
6460 6461 xopipsq->ipsq_switch_mp = NULL;
6461 6462 ASSERT(mp->b_next == NULL);
6462 6463 mp->b_next = (void *)xopipsq;
6463 6464 goto out;
6464 6465 }
6465 6466
6466 6467 if ((mp = xopipsq->ipsq_xopq_mphead) != NULL) {
6467 6468 xopipsq->ipsq_xopq_mphead = mp->b_next;
6468 6469 if (xopipsq->ipsq_xopq_mphead == NULL)
6469 6470 xopipsq->ipsq_xopq_mptail = NULL;
6470 6471 mp->b_next = (void *)xopipsq;
6471 6472 goto out;
6472 6473 }
6473 6474 } while ((xopipsq = xopipsq->ipsq_next) != ipsq);
6474 6475 empty:
6475 6476 /*
6476 6477 * There are no messages. Further, we are holding ipx_lock, hence no
6477 6478 * new messages can end up on any IPSQ in the xop.
6478 6479 */
6479 6480 ipx->ipx_writer = NULL;
6480 6481 ipx->ipx_forced = B_FALSE;
6481 6482 VERIFY(--ipx->ipx_reentry_cnt == 0);
6482 6483 ipx->ipx_ipsq_queued = B_FALSE;
6483 6484 emptied = B_TRUE;
6484 6485 #ifdef DEBUG
6485 6486 ipx->ipx_depth = 0;
6486 6487 #endif
6487 6488 out:
6488 6489 mutex_exit(&ipx->ipx_lock);
6489 6490 mutex_exit(&ipsq->ipsq_lock);
6490 6491
6491 6492 /*
6492 6493 * If we completely emptied the xop, then wake up any threads waiting
6493 6494 * to enter any of the IPSQ's associated with it.
6494 6495 */
6495 6496 if (emptied) {
6496 6497 xopipsq = ipsq;
6497 6498 do {
6498 6499 if ((phyi = xopipsq->ipsq_phyint) == NULL)
6499 6500 continue;
6500 6501
6501 6502 illv4 = phyi->phyint_illv4;
6502 6503 illv6 = phyi->phyint_illv6;
6503 6504
6504 6505 GRAB_ILL_LOCKS(illv4, illv6);
6505 6506 if (illv4 != NULL)
6506 6507 cv_broadcast(&illv4->ill_cv);
6507 6508 if (illv6 != NULL)
6508 6509 cv_broadcast(&illv6->ill_cv);
6509 6510 RELEASE_ILL_LOCKS(illv4, illv6);
6510 6511 } while ((xopipsq = xopipsq->ipsq_next) != ipsq);
6511 6512 }
6512 6513 rw_exit(&ipst->ips_ill_g_lock);
6513 6514
6514 6515 /*
6515 6516 * Now that all locks are dropped, exit the IPSQ we left.
6516 6517 */
6517 6518 if (leftipsq != NULL)
6518 6519 ipsq_exit(leftipsq);
6519 6520
6520 6521 return (mp);
6521 6522 }
6522 6523
6523 6524 /*
6524 6525 * Return completion status of previously initiated DLPI operations on
6525 6526 * ills in the purview of an ipsq.
6526 6527 */
6527 6528 static boolean_t
6528 6529 ipsq_dlpi_done(ipsq_t *ipsq)
6529 6530 {
6530 6531 ipsq_t *ipsq_start;
6531 6532 phyint_t *phyi;
6532 6533 ill_t *ill;
6533 6534
6534 6535 ASSERT(RW_LOCK_HELD(&ipsq->ipsq_ipst->ips_ill_g_lock));
6535 6536 ipsq_start = ipsq;
6536 6537
6537 6538 do {
6538 6539 /*
6539 6540 * The only current users of this function are ipsq_try_enter
6540 6541 * and ipsq_enter which have made sure that ipsq_writer is
6541 6542 * NULL before we reach here. ill_dlpi_pending is modified
6542 6543 * only by an ipsq writer
6543 6544 */
6544 6545 ASSERT(ipsq->ipsq_xop->ipx_writer == NULL);
6545 6546 phyi = ipsq->ipsq_phyint;
6546 6547 /*
6547 6548 * phyi could be NULL if a phyint that is part of an
6548 6549 * IPMP group is being unplumbed. A more detailed
6549 6550 * comment is in ipmp_grp_update_kstats()
6550 6551 */
6551 6552 if (phyi != NULL) {
6552 6553 ill = phyi->phyint_illv4;
6553 6554 if (ill != NULL &&
6554 6555 (ill->ill_dlpi_pending != DL_PRIM_INVAL ||
6555 6556 ill->ill_arl_dlpi_pending))
6556 6557 return (B_FALSE);
6557 6558
6558 6559 ill = phyi->phyint_illv6;
6559 6560 if (ill != NULL &&
6560 6561 ill->ill_dlpi_pending != DL_PRIM_INVAL)
6561 6562 return (B_FALSE);
6562 6563 }
6563 6564
6564 6565 } while ((ipsq = ipsq->ipsq_next) != ipsq_start);
6565 6566
6566 6567 return (B_TRUE);
6567 6568 }
6568 6569
6569 6570 /*
6570 6571 * Enter the ipsq corresponding to ill, by waiting synchronously till
6571 6572 * we can enter the ipsq exclusively. Unless 'force' is used, the ipsq
6572 6573 * will have to drain completely before ipsq_enter returns success.
6573 6574 * ipx_current_ipif will be set if some exclusive op is in progress,
6574 6575 * and the ipsq_exit logic will start the next enqueued op after
6575 6576 * completion of the current op. If 'force' is used, we don't wait
6576 6577 * for the enqueued ops. This is needed when a conn_close wants to
6577 6578 * enter the ipsq and abort an ioctl that is somehow stuck. Unplumb
6578 6579 * of an ill can also use this option. But we dont' use it currently.
6579 6580 */
6580 6581 #define ENTER_SQ_WAIT_TICKS 100
6581 6582 boolean_t
6582 6583 ipsq_enter(ill_t *ill, boolean_t force, int type)
6583 6584 {
6584 6585 ipsq_t *ipsq;
6585 6586 ipxop_t *ipx;
6586 6587 boolean_t waited_enough = B_FALSE;
6587 6588 ip_stack_t *ipst = ill->ill_ipst;
6588 6589
6589 6590 /*
6590 6591 * Note that the relationship between ill and ipsq is fixed as long as
6591 6592 * the ill is not ILL_CONDEMNED. Holding ipsq_lock ensures the
6592 6593 * relationship between the IPSQ and xop cannot change. However,
6593 6594 * since we cannot hold ipsq_lock across the cv_wait(), it may change
6594 6595 * while we're waiting. We wait on ill_cv and rely on ipsq_exit()
6595 6596 * waking up all ills in the xop when it becomes available.
6596 6597 */
6597 6598 for (;;) {
6598 6599 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
6599 6600 mutex_enter(&ill->ill_lock);
6600 6601 if (ill->ill_state_flags & ILL_CONDEMNED) {
6601 6602 mutex_exit(&ill->ill_lock);
6602 6603 rw_exit(&ipst->ips_ill_g_lock);
6603 6604 return (B_FALSE);
6604 6605 }
6605 6606
6606 6607 ipsq = ill->ill_phyint->phyint_ipsq;
6607 6608 mutex_enter(&ipsq->ipsq_lock);
6608 6609 ipx = ipsq->ipsq_xop;
6609 6610 mutex_enter(&ipx->ipx_lock);
6610 6611
6611 6612 if (ipx->ipx_writer == NULL && (type == CUR_OP ||
6612 6613 (ipx->ipx_current_ipif == NULL && ipsq_dlpi_done(ipsq)) ||
6613 6614 waited_enough))
6614 6615 break;
6615 6616
6616 6617 rw_exit(&ipst->ips_ill_g_lock);
6617 6618
6618 6619 if (!force || ipx->ipx_writer != NULL) {
6619 6620 mutex_exit(&ipx->ipx_lock);
6620 6621 mutex_exit(&ipsq->ipsq_lock);
6621 6622 cv_wait(&ill->ill_cv, &ill->ill_lock);
6622 6623 } else {
6623 6624 mutex_exit(&ipx->ipx_lock);
6624 6625 mutex_exit(&ipsq->ipsq_lock);
6625 6626 (void) cv_reltimedwait(&ill->ill_cv,
6626 6627 &ill->ill_lock, ENTER_SQ_WAIT_TICKS, TR_CLOCK_TICK);
6627 6628 waited_enough = B_TRUE;
6628 6629 }
6629 6630 mutex_exit(&ill->ill_lock);
6630 6631 }
6631 6632
6632 6633 ASSERT(ipx->ipx_mphead == NULL && ipx->ipx_mptail == NULL);
6633 6634 ASSERT(ipx->ipx_reentry_cnt == 0);
6634 6635 ipx->ipx_writer = curthread;
6635 6636 ipx->ipx_forced = (ipx->ipx_current_ipif != NULL);
6636 6637 ipx->ipx_reentry_cnt++;
6637 6638 #ifdef DEBUG
6638 6639 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
6639 6640 #endif
6640 6641 mutex_exit(&ipx->ipx_lock);
6641 6642 mutex_exit(&ipsq->ipsq_lock);
6642 6643 mutex_exit(&ill->ill_lock);
6643 6644 rw_exit(&ipst->ips_ill_g_lock);
6644 6645
6645 6646 return (B_TRUE);
6646 6647 }
6647 6648
6648 6649 /*
6649 6650 * ipif_set_values() has a constraint that it cannot drop the ips_ill_g_lock
6650 6651 * across the call to the core interface ipsq_try_enter() and hence calls this
6651 6652 * function directly. This is explained more fully in ipif_set_values().
6652 6653 * In order to support the above constraint, ipsq_try_enter is implemented as
6653 6654 * a wrapper that grabs the ips_ill_g_lock and calls this function subsequently
6654 6655 */
6655 6656 static ipsq_t *
6656 6657 ipsq_try_enter_internal(ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func,
6657 6658 int type, boolean_t reentry_ok)
6658 6659 {
6659 6660 ipsq_t *ipsq;
6660 6661 ipxop_t *ipx;
6661 6662 ip_stack_t *ipst = ill->ill_ipst;
6662 6663
6663 6664 /*
6664 6665 * lock ordering:
6665 6666 * ill_g_lock -> conn_lock -> ill_lock -> ipsq_lock -> ipx_lock.
6666 6667 *
6667 6668 * ipx of an ipsq can't change when ipsq_lock is held.
6668 6669 */
6669 6670 ASSERT(RW_LOCK_HELD(&ipst->ips_ill_g_lock));
6670 6671 GRAB_CONN_LOCK(q);
6671 6672 mutex_enter(&ill->ill_lock);
6672 6673 ipsq = ill->ill_phyint->phyint_ipsq;
6673 6674 mutex_enter(&ipsq->ipsq_lock);
6674 6675 ipx = ipsq->ipsq_xop;
6675 6676 mutex_enter(&ipx->ipx_lock);
6676 6677
6677 6678 /*
6678 6679 * 1. Enter the ipsq if we are already writer and reentry is ok.
6679 6680 * (Note: If the caller does not specify reentry_ok then neither
6680 6681 * 'func' nor any of its callees must ever attempt to enter the ipsq
6681 6682 * again. Otherwise it can lead to an infinite loop
6682 6683 * 2. Enter the ipsq if there is no current writer and this attempted
6683 6684 * entry is part of the current operation
6684 6685 * 3. Enter the ipsq if there is no current writer and this is a new
6685 6686 * operation and the operation queue is empty and there is no
6686 6687 * operation currently in progress and if all previously initiated
6687 6688 * DLPI operations have completed.
6688 6689 */
6689 6690 if ((ipx->ipx_writer == curthread && reentry_ok) ||
6690 6691 (ipx->ipx_writer == NULL && (type == CUR_OP || (type == NEW_OP &&
6691 6692 !ipx->ipx_ipsq_queued && ipx->ipx_current_ipif == NULL &&
6692 6693 ipsq_dlpi_done(ipsq))))) {
6693 6694 /* Success. */
6694 6695 ipx->ipx_reentry_cnt++;
6695 6696 ipx->ipx_writer = curthread;
6696 6697 ipx->ipx_forced = B_FALSE;
6697 6698 mutex_exit(&ipx->ipx_lock);
6698 6699 mutex_exit(&ipsq->ipsq_lock);
6699 6700 mutex_exit(&ill->ill_lock);
6700 6701 RELEASE_CONN_LOCK(q);
6701 6702 #ifdef DEBUG
6702 6703 ipx->ipx_depth = getpcstack(ipx->ipx_stack, IPX_STACK_DEPTH);
6703 6704 #endif
6704 6705 return (ipsq);
6705 6706 }
6706 6707
6707 6708 if (func != NULL)
6708 6709 ipsq_enq(ipsq, q, mp, func, type, ill);
6709 6710
6710 6711 mutex_exit(&ipx->ipx_lock);
6711 6712 mutex_exit(&ipsq->ipsq_lock);
6712 6713 mutex_exit(&ill->ill_lock);
6713 6714 RELEASE_CONN_LOCK(q);
6714 6715 return (NULL);
6715 6716 }
6716 6717
6717 6718 /*
6718 6719 * The ipsq_t (ipsq) is the synchronization data structure used to serialize
6719 6720 * certain critical operations like plumbing (i.e. most set ioctls), etc.
6720 6721 * There is one ipsq per phyint. The ipsq
6721 6722 * serializes exclusive ioctls issued by applications on a per ipsq basis in
6722 6723 * ipsq_xopq_mphead. It also protects against multiple threads executing in
6723 6724 * the ipsq. Responses from the driver pertain to the current ioctl (say a
6724 6725 * DL_BIND_ACK in response to a DL_BIND_REQ initiated as part of bringing
6725 6726 * up the interface) and are enqueued in ipx_mphead.
6726 6727 *
6727 6728 * If a thread does not want to reenter the ipsq when it is already writer,
6728 6729 * it must make sure that the specified reentry point to be called later
6729 6730 * when the ipsq is empty, nor any code path starting from the specified reentry
6730 6731 * point must never ever try to enter the ipsq again. Otherwise it can lead
6731 6732 * to an infinite loop. The reentry point ip_rput_dlpi_writer is an example.
6732 6733 * When the thread that is currently exclusive finishes, it (ipsq_exit)
6733 6734 * dequeues the requests waiting to become exclusive in ipx_mphead and calls
6734 6735 * the reentry point. When the list at ipx_mphead becomes empty ipsq_exit
6735 6736 * proceeds to dequeue the next ioctl in ipsq_xopq_mphead and start the next
6736 6737 * ioctl if the current ioctl has completed. If the current ioctl is still
6737 6738 * in progress it simply returns. The current ioctl could be waiting for
6738 6739 * a response from another module (the driver or could be waiting for
6739 6740 * the ipif/ill/ire refcnts to drop to zero. In such a case the ipx_pending_mp
6740 6741 * and ipx_pending_ipif are set. ipx_current_ipif is set throughout the
6741 6742 * execution of the ioctl and ipsq_exit does not start the next ioctl unless
6742 6743 * ipx_current_ipif is NULL which happens only once the ioctl is complete and
6743 6744 * all associated DLPI operations have completed.
6744 6745 */
6745 6746
6746 6747 /*
6747 6748 * Try to enter the IPSQ corresponding to `ipif' or `ill' exclusively (`ipif'
6748 6749 * and `ill' cannot both be specified). Returns a pointer to the entered IPSQ
6749 6750 * on success, or NULL on failure. The caller ensures ipif/ill is valid by
6750 6751 * refholding it as necessary. If the IPSQ cannot be entered and `func' is
6751 6752 * non-NULL, then `func' will be called back with `q' and `mp' once the IPSQ
6752 6753 * can be entered. If `func' is NULL, then `q' and `mp' are ignored.
6753 6754 */
6754 6755 ipsq_t *
6755 6756 ipsq_try_enter(ipif_t *ipif, ill_t *ill, queue_t *q, mblk_t *mp,
6756 6757 ipsq_func_t func, int type, boolean_t reentry_ok)
6757 6758 {
6758 6759 ip_stack_t *ipst;
6759 6760 ipsq_t *ipsq;
6760 6761
6761 6762 /* Only 1 of ipif or ill can be specified */
6762 6763 ASSERT((ipif != NULL) ^ (ill != NULL));
6763 6764
6764 6765 if (ipif != NULL)
6765 6766 ill = ipif->ipif_ill;
6766 6767 ipst = ill->ill_ipst;
6767 6768
6768 6769 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
6769 6770 ipsq = ipsq_try_enter_internal(ill, q, mp, func, type, reentry_ok);
6770 6771 rw_exit(&ipst->ips_ill_g_lock);
6771 6772
6772 6773 return (ipsq);
6773 6774 }
6774 6775
6775 6776 /*
6776 6777 * Try to enter the IPSQ corresponding to `ill' as writer. The caller ensures
6777 6778 * ill is valid by refholding it if necessary; we will refrele. If the IPSQ
6778 6779 * cannot be entered, the mp is queued for completion.
6779 6780 */
6780 6781 void
6781 6782 qwriter_ip(ill_t *ill, queue_t *q, mblk_t *mp, ipsq_func_t func, int type,
6782 6783 boolean_t reentry_ok)
6783 6784 {
6784 6785 ipsq_t *ipsq;
6785 6786
6786 6787 ipsq = ipsq_try_enter(NULL, ill, q, mp, func, type, reentry_ok);
6787 6788
6788 6789 /*
6789 6790 * Drop the caller's refhold on the ill. This is safe since we either
6790 6791 * entered the IPSQ (and thus are exclusive), or failed to enter the
6791 6792 * IPSQ, in which case we return without accessing ill anymore. This
6792 6793 * is needed because func needs to see the correct refcount.
6793 6794 * e.g. removeif can work only then.
6794 6795 */
6795 6796 ill_refrele(ill);
6796 6797 if (ipsq != NULL) {
6797 6798 (*func)(ipsq, q, mp, NULL);
6798 6799 ipsq_exit(ipsq);
6799 6800 }
6800 6801 }
6801 6802
6802 6803 /*
6803 6804 * Exit the specified IPSQ. If this is the final exit on it then drain it
6804 6805 * prior to exiting. Caller must be writer on the specified IPSQ.
6805 6806 */
6806 6807 void
6807 6808 ipsq_exit(ipsq_t *ipsq)
6808 6809 {
6809 6810 mblk_t *mp;
6810 6811 ipsq_t *mp_ipsq;
6811 6812 queue_t *q;
6812 6813 phyint_t *phyi;
6813 6814 ipsq_func_t func;
6814 6815
6815 6816 ASSERT(IAM_WRITER_IPSQ(ipsq));
6816 6817
6817 6818 ASSERT(ipsq->ipsq_xop->ipx_reentry_cnt >= 1);
6818 6819 if (ipsq->ipsq_xop->ipx_reentry_cnt != 1) {
6819 6820 ipsq->ipsq_xop->ipx_reentry_cnt--;
6820 6821 return;
6821 6822 }
6822 6823
6823 6824 for (;;) {
6824 6825 phyi = ipsq->ipsq_phyint;
6825 6826 mp = ipsq_dq(ipsq);
6826 6827 mp_ipsq = (mp == NULL) ? NULL : (ipsq_t *)mp->b_next;
6827 6828
6828 6829 /*
6829 6830 * If we've changed to a new IPSQ, and the phyint associated
6830 6831 * with the old one has gone away, free the old IPSQ. Note
6831 6832 * that this cannot happen while the IPSQ is in a group.
6832 6833 */
6833 6834 if (mp_ipsq != ipsq && phyi == NULL) {
6834 6835 ASSERT(ipsq->ipsq_next == ipsq);
6835 6836 ASSERT(ipsq->ipsq_xop == &ipsq->ipsq_ownxop);
6836 6837 ipsq_delete(ipsq);
6837 6838 }
6838 6839
6839 6840 if (mp == NULL)
6840 6841 break;
6841 6842
6842 6843 q = mp->b_queue;
6843 6844 func = (ipsq_func_t)mp->b_prev;
6844 6845 ipsq = mp_ipsq;
6845 6846 mp->b_next = mp->b_prev = NULL;
6846 6847 mp->b_queue = NULL;
6847 6848
6848 6849 /*
6849 6850 * If 'q' is an conn queue, it is valid, since we did a
6850 6851 * a refhold on the conn at the start of the ioctl.
6851 6852 * If 'q' is an ill queue, it is valid, since close of an
6852 6853 * ill will clean up its IPSQ.
6853 6854 */
6854 6855 (*func)(ipsq, q, mp, NULL);
6855 6856 }
6856 6857 }
6857 6858
6858 6859 /*
6859 6860 * Used to start any igmp or mld timers that could not be started
6860 6861 * while holding ill_mcast_lock. The timers can't be started while holding
6861 6862 * the lock, since mld/igmp_start_timers may need to call untimeout()
6862 6863 * which can't be done while holding the lock which the timeout handler
6863 6864 * acquires. Otherwise
6864 6865 * there could be a deadlock since the timeout handlers
6865 6866 * mld_timeout_handler_per_ill/igmp_timeout_handler_per_ill also acquire
6866 6867 * ill_mcast_lock.
6867 6868 */
6868 6869 void
6869 6870 ill_mcast_timer_start(ip_stack_t *ipst)
6870 6871 {
6871 6872 int next;
6872 6873
6873 6874 mutex_enter(&ipst->ips_igmp_timer_lock);
6874 6875 next = ipst->ips_igmp_deferred_next;
6875 6876 ipst->ips_igmp_deferred_next = INFINITY;
6876 6877 mutex_exit(&ipst->ips_igmp_timer_lock);
6877 6878
6878 6879 if (next != INFINITY)
6879 6880 igmp_start_timers(next, ipst);
6880 6881
6881 6882 mutex_enter(&ipst->ips_mld_timer_lock);
6882 6883 next = ipst->ips_mld_deferred_next;
6883 6884 ipst->ips_mld_deferred_next = INFINITY;
6884 6885 mutex_exit(&ipst->ips_mld_timer_lock);
6885 6886
6886 6887 if (next != INFINITY)
6887 6888 mld_start_timers(next, ipst);
6888 6889 }
6889 6890
6890 6891 /*
6891 6892 * Start the current exclusive operation on `ipsq'; associate it with `ipif'
6892 6893 * and `ioccmd'.
6893 6894 */
6894 6895 void
6895 6896 ipsq_current_start(ipsq_t *ipsq, ipif_t *ipif, int ioccmd)
6896 6897 {
6897 6898 ill_t *ill = ipif->ipif_ill;
6898 6899 ipxop_t *ipx = ipsq->ipsq_xop;
6899 6900
6900 6901 ASSERT(IAM_WRITER_IPSQ(ipsq));
6901 6902 ASSERT(ipx->ipx_current_ipif == NULL);
6902 6903 ASSERT(ipx->ipx_current_ioctl == 0);
6903 6904
6904 6905 ipx->ipx_current_done = B_FALSE;
6905 6906 ipx->ipx_current_ioctl = ioccmd;
6906 6907 mutex_enter(&ipx->ipx_lock);
6907 6908 ipx->ipx_current_ipif = ipif;
6908 6909 mutex_exit(&ipx->ipx_lock);
6909 6910
6910 6911 /*
6911 6912 * Set IPIF_CHANGING on one or more ipifs associated with the
6912 6913 * current exclusive operation. IPIF_CHANGING prevents any new
6913 6914 * references to the ipif (so that the references will eventually
6914 6915 * drop to zero) and also prevents any "get" operations (e.g.,
6915 6916 * SIOCGLIFFLAGS) from being able to access the ipif until the
6916 6917 * operation has completed and the ipif is again in a stable state.
6917 6918 *
6918 6919 * For ioctls, IPIF_CHANGING is set on the ipif associated with the
6919 6920 * ioctl. For internal operations (where ioccmd is zero), all ipifs
6920 6921 * on the ill are marked with IPIF_CHANGING since it's unclear which
6921 6922 * ipifs will be affected.
6922 6923 *
6923 6924 * Note that SIOCLIFREMOVEIF is a special case as it sets
6924 6925 * IPIF_CONDEMNED internally after identifying the right ipif to
6925 6926 * operate on.
6926 6927 */
6927 6928 switch (ioccmd) {
6928 6929 case SIOCLIFREMOVEIF:
6929 6930 break;
6930 6931 case 0:
6931 6932 mutex_enter(&ill->ill_lock);
6932 6933 ipif = ipif->ipif_ill->ill_ipif;
6933 6934 for (; ipif != NULL; ipif = ipif->ipif_next)
6934 6935 ipif->ipif_state_flags |= IPIF_CHANGING;
6935 6936 mutex_exit(&ill->ill_lock);
6936 6937 break;
6937 6938 default:
6938 6939 mutex_enter(&ill->ill_lock);
6939 6940 ipif->ipif_state_flags |= IPIF_CHANGING;
6940 6941 mutex_exit(&ill->ill_lock);
6941 6942 }
6942 6943 }
6943 6944
6944 6945 /*
6945 6946 * Finish the current exclusive operation on `ipsq'. Usually, this will allow
6946 6947 * the next exclusive operation to begin once we ipsq_exit(). However, if
6947 6948 * pending DLPI operations remain, then we will wait for the queue to drain
6948 6949 * before allowing the next exclusive operation to begin. This ensures that
6949 6950 * DLPI operations from one exclusive operation are never improperly processed
6950 6951 * as part of a subsequent exclusive operation.
6951 6952 */
6952 6953 void
6953 6954 ipsq_current_finish(ipsq_t *ipsq)
6954 6955 {
6955 6956 ipxop_t *ipx = ipsq->ipsq_xop;
6956 6957 t_uscalar_t dlpi_pending = DL_PRIM_INVAL;
6957 6958 ipif_t *ipif = ipx->ipx_current_ipif;
6958 6959
6959 6960 ASSERT(IAM_WRITER_IPSQ(ipsq));
6960 6961
6961 6962 /*
6962 6963 * For SIOCLIFREMOVEIF, the ipif has been already been blown away
6963 6964 * (but in that case, IPIF_CHANGING will already be clear and no
6964 6965 * pending DLPI messages can remain).
6965 6966 */
6966 6967 if (ipx->ipx_current_ioctl != SIOCLIFREMOVEIF) {
6967 6968 ill_t *ill = ipif->ipif_ill;
6968 6969
6969 6970 mutex_enter(&ill->ill_lock);
6970 6971 dlpi_pending = ill->ill_dlpi_pending;
6971 6972 if (ipx->ipx_current_ioctl == 0) {
6972 6973 ipif = ill->ill_ipif;
6973 6974 for (; ipif != NULL; ipif = ipif->ipif_next)
6974 6975 ipif->ipif_state_flags &= ~IPIF_CHANGING;
6975 6976 } else {
6976 6977 ipif->ipif_state_flags &= ~IPIF_CHANGING;
6977 6978 }
6978 6979 mutex_exit(&ill->ill_lock);
6979 6980 }
6980 6981
6981 6982 ASSERT(!ipx->ipx_current_done);
6982 6983 ipx->ipx_current_done = B_TRUE;
6983 6984 ipx->ipx_current_ioctl = 0;
6984 6985 if (dlpi_pending == DL_PRIM_INVAL) {
6985 6986 mutex_enter(&ipx->ipx_lock);
6986 6987 ipx->ipx_current_ipif = NULL;
6987 6988 mutex_exit(&ipx->ipx_lock);
6988 6989 }
6989 6990 }
6990 6991
6991 6992 /*
6992 6993 * The ill is closing. Flush all messages on the ipsq that originated
6993 6994 * from this ill. Usually there wont' be any messages on the ipsq_xopq_mphead
6994 6995 * for this ill since ipsq_enter could not have entered until then.
6995 6996 * New messages can't be queued since the CONDEMNED flag is set.
6996 6997 */
6997 6998 static void
6998 6999 ipsq_flush(ill_t *ill)
6999 7000 {
7000 7001 queue_t *q;
7001 7002 mblk_t *prev;
7002 7003 mblk_t *mp;
7003 7004 mblk_t *mp_next;
7004 7005 ipxop_t *ipx = ill->ill_phyint->phyint_ipsq->ipsq_xop;
7005 7006
7006 7007 ASSERT(IAM_WRITER_ILL(ill));
7007 7008
7008 7009 /*
7009 7010 * Flush any messages sent up by the driver.
7010 7011 */
7011 7012 mutex_enter(&ipx->ipx_lock);
7012 7013 for (prev = NULL, mp = ipx->ipx_mphead; mp != NULL; mp = mp_next) {
7013 7014 mp_next = mp->b_next;
7014 7015 q = mp->b_queue;
7015 7016 if (q == ill->ill_rq || q == ill->ill_wq) {
7016 7017 /* dequeue mp */
7017 7018 if (prev == NULL)
7018 7019 ipx->ipx_mphead = mp->b_next;
7019 7020 else
7020 7021 prev->b_next = mp->b_next;
7021 7022 if (ipx->ipx_mptail == mp) {
7022 7023 ASSERT(mp_next == NULL);
7023 7024 ipx->ipx_mptail = prev;
7024 7025 }
7025 7026 inet_freemsg(mp);
7026 7027 } else {
7027 7028 prev = mp;
7028 7029 }
7029 7030 }
7030 7031 mutex_exit(&ipx->ipx_lock);
7031 7032 (void) ipsq_pending_mp_cleanup(ill, NULL);
7032 7033 ipsq_xopq_mp_cleanup(ill, NULL);
7033 7034 }
7034 7035
7035 7036 /*
7036 7037 * Parse an ifreq or lifreq struct coming down ioctls and refhold
7037 7038 * and return the associated ipif.
7038 7039 * Return value:
7039 7040 * Non zero: An error has occurred. ci may not be filled out.
7040 7041 * zero : ci is filled out with the ioctl cmd in ci.ci_name, and
7041 7042 * a held ipif in ci.ci_ipif.
7042 7043 */
7043 7044 int
7044 7045 ip_extract_lifreq(queue_t *q, mblk_t *mp, const ip_ioctl_cmd_t *ipip,
7045 7046 cmd_info_t *ci)
7046 7047 {
7047 7048 char *name;
7048 7049 struct ifreq *ifr;
7049 7050 struct lifreq *lifr;
7050 7051 ipif_t *ipif = NULL;
7051 7052 ill_t *ill;
7052 7053 conn_t *connp;
7053 7054 boolean_t isv6;
7054 7055 int err;
7055 7056 mblk_t *mp1;
7056 7057 zoneid_t zoneid;
7057 7058 ip_stack_t *ipst;
7058 7059
7059 7060 if (q->q_next != NULL) {
7060 7061 ill = (ill_t *)q->q_ptr;
7061 7062 isv6 = ill->ill_isv6;
7062 7063 connp = NULL;
7063 7064 zoneid = ALL_ZONES;
7064 7065 ipst = ill->ill_ipst;
7065 7066 } else {
7066 7067 ill = NULL;
7067 7068 connp = Q_TO_CONN(q);
7068 7069 isv6 = (connp->conn_family == AF_INET6);
7069 7070 zoneid = connp->conn_zoneid;
7070 7071 if (zoneid == GLOBAL_ZONEID) {
7071 7072 /* global zone can access ipifs in all zones */
7072 7073 zoneid = ALL_ZONES;
7073 7074 }
7074 7075 ipst = connp->conn_netstack->netstack_ip;
7075 7076 }
7076 7077
7077 7078 /* Has been checked in ip_wput_nondata */
7078 7079 mp1 = mp->b_cont->b_cont;
7079 7080
7080 7081 if (ipip->ipi_cmd_type == IF_CMD) {
7081 7082 /* This a old style SIOC[GS]IF* command */
7082 7083 ifr = (struct ifreq *)mp1->b_rptr;
7083 7084 /*
7084 7085 * Null terminate the string to protect against buffer
7085 7086 * overrun. String was generated by user code and may not
7086 7087 * be trusted.
7087 7088 */
7088 7089 ifr->ifr_name[IFNAMSIZ - 1] = '\0';
7089 7090 name = ifr->ifr_name;
7090 7091 ci->ci_sin = (sin_t *)&ifr->ifr_addr;
7091 7092 ci->ci_sin6 = NULL;
7092 7093 ci->ci_lifr = (struct lifreq *)ifr;
7093 7094 } else {
7094 7095 /* This a new style SIOC[GS]LIF* command */
7095 7096 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
7096 7097 lifr = (struct lifreq *)mp1->b_rptr;
7097 7098 /*
7098 7099 * Null terminate the string to protect against buffer
7099 7100 * overrun. String was generated by user code and may not
7100 7101 * be trusted.
7101 7102 */
7102 7103 lifr->lifr_name[LIFNAMSIZ - 1] = '\0';
7103 7104 name = lifr->lifr_name;
7104 7105 ci->ci_sin = (sin_t *)&lifr->lifr_addr;
7105 7106 ci->ci_sin6 = (sin6_t *)&lifr->lifr_addr;
7106 7107 ci->ci_lifr = lifr;
7107 7108 }
7108 7109
7109 7110 if (ipip->ipi_cmd == SIOCSLIFNAME) {
7110 7111 /*
7111 7112 * The ioctl will be failed if the ioctl comes down
7112 7113 * an conn stream
7113 7114 */
7114 7115 if (ill == NULL) {
7115 7116 /*
7116 7117 * Not an ill queue, return EINVAL same as the
7117 7118 * old error code.
7118 7119 */
7119 7120 return (ENXIO);
7120 7121 }
7121 7122 ipif = ill->ill_ipif;
7122 7123 ipif_refhold(ipif);
7123 7124 } else {
7124 7125 /*
7125 7126 * Ensure that ioctls don't see any internal state changes
7126 7127 * caused by set ioctls by deferring them if IPIF_CHANGING is
7127 7128 * set.
7128 7129 */
7129 7130 ipif = ipif_lookup_on_name_async(name, mi_strlen(name),
7130 7131 isv6, zoneid, q, mp, ip_process_ioctl, &err, ipst);
7131 7132 if (ipif == NULL) {
7132 7133 if (err == EINPROGRESS)
7133 7134 return (err);
7134 7135 err = 0; /* Ensure we don't use it below */
7135 7136 }
7136 7137 }
7137 7138
7138 7139 /*
7139 7140 * Old style [GS]IFCMD does not admit IPv6 ipif
7140 7141 */
7141 7142 if (ipif != NULL && ipif->ipif_isv6 && ipip->ipi_cmd_type == IF_CMD) {
7142 7143 ipif_refrele(ipif);
7143 7144 return (ENXIO);
7144 7145 }
7145 7146
7146 7147 if (ipif == NULL && ill != NULL && ill->ill_ipif != NULL &&
7147 7148 name[0] == '\0') {
7148 7149 /*
7149 7150 * Handle a or a SIOC?IF* with a null name
7150 7151 * during plumb (on the ill queue before the I_PLINK).
7151 7152 */
7152 7153 ipif = ill->ill_ipif;
7153 7154 ipif_refhold(ipif);
7154 7155 }
7155 7156
7156 7157 if (ipif == NULL)
7157 7158 return (ENXIO);
7158 7159
7159 7160 DTRACE_PROBE4(ipif__ioctl, char *, "ip_extract_lifreq",
7160 7161 int, ipip->ipi_cmd, ill_t *, ipif->ipif_ill, ipif_t *, ipif);
7161 7162
7162 7163 ci->ci_ipif = ipif;
7163 7164 return (0);
7164 7165 }
7165 7166
7166 7167 /*
7167 7168 * Return the total number of ipifs.
7168 7169 */
7169 7170 static uint_t
7170 7171 ip_get_numifs(zoneid_t zoneid, ip_stack_t *ipst)
7171 7172 {
7172 7173 uint_t numifs = 0;
7173 7174 ill_t *ill;
7174 7175 ill_walk_context_t ctx;
7175 7176 ipif_t *ipif;
7176 7177
7177 7178 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7178 7179 ill = ILL_START_WALK_V4(&ctx, ipst);
7179 7180 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7180 7181 if (IS_UNDER_IPMP(ill))
7181 7182 continue;
7182 7183 for (ipif = ill->ill_ipif; ipif != NULL;
7183 7184 ipif = ipif->ipif_next) {
7184 7185 if (ipif->ipif_zoneid == zoneid ||
7185 7186 ipif->ipif_zoneid == ALL_ZONES)
7186 7187 numifs++;
7187 7188 }
7188 7189 }
7189 7190 rw_exit(&ipst->ips_ill_g_lock);
7190 7191 return (numifs);
7191 7192 }
7192 7193
7193 7194 /*
7194 7195 * Return the total number of ipifs.
7195 7196 */
7196 7197 static uint_t
7197 7198 ip_get_numlifs(int family, int lifn_flags, zoneid_t zoneid, ip_stack_t *ipst)
7198 7199 {
7199 7200 uint_t numifs = 0;
7200 7201 ill_t *ill;
7201 7202 ipif_t *ipif;
7202 7203 ill_walk_context_t ctx;
7203 7204
7204 7205 ip1dbg(("ip_get_numlifs(%d %u %d)\n", family, lifn_flags, (int)zoneid));
7205 7206
7206 7207 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7207 7208 if (family == AF_INET)
7208 7209 ill = ILL_START_WALK_V4(&ctx, ipst);
7209 7210 else if (family == AF_INET6)
7210 7211 ill = ILL_START_WALK_V6(&ctx, ipst);
7211 7212 else
7212 7213 ill = ILL_START_WALK_ALL(&ctx, ipst);
7213 7214
7214 7215 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7215 7216 if (IS_UNDER_IPMP(ill) && !(lifn_flags & LIFC_UNDER_IPMP))
7216 7217 continue;
7217 7218
7218 7219 for (ipif = ill->ill_ipif; ipif != NULL;
7219 7220 ipif = ipif->ipif_next) {
7220 7221 if ((ipif->ipif_flags & IPIF_NOXMIT) &&
7221 7222 !(lifn_flags & LIFC_NOXMIT))
7222 7223 continue;
7223 7224 if ((ipif->ipif_flags & IPIF_TEMPORARY) &&
7224 7225 !(lifn_flags & LIFC_TEMPORARY))
7225 7226 continue;
7226 7227 if (((ipif->ipif_flags &
7227 7228 (IPIF_NOXMIT|IPIF_NOLOCAL|
7228 7229 IPIF_DEPRECATED)) ||
7229 7230 IS_LOOPBACK(ill) ||
7230 7231 !(ipif->ipif_flags & IPIF_UP)) &&
7231 7232 (lifn_flags & LIFC_EXTERNAL_SOURCE))
7232 7233 continue;
7233 7234
7234 7235 if (zoneid != ipif->ipif_zoneid &&
7235 7236 ipif->ipif_zoneid != ALL_ZONES &&
7236 7237 (zoneid != GLOBAL_ZONEID ||
7237 7238 !(lifn_flags & LIFC_ALLZONES)))
7238 7239 continue;
7239 7240
7240 7241 numifs++;
7241 7242 }
7242 7243 }
7243 7244 rw_exit(&ipst->ips_ill_g_lock);
7244 7245 return (numifs);
7245 7246 }
7246 7247
7247 7248 uint_t
7248 7249 ip_get_lifsrcofnum(ill_t *ill)
7249 7250 {
7250 7251 uint_t numifs = 0;
7251 7252 ill_t *ill_head = ill;
7252 7253 ip_stack_t *ipst = ill->ill_ipst;
7253 7254
7254 7255 /*
7255 7256 * ill_g_usesrc_lock protects ill_usesrc_grp_next, for example, some
7256 7257 * other thread may be trying to relink the ILLs in this usesrc group
7257 7258 * and adjusting the ill_usesrc_grp_next pointers
7258 7259 */
7259 7260 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_READER);
7260 7261 if ((ill->ill_usesrc_ifindex == 0) &&
7261 7262 (ill->ill_usesrc_grp_next != NULL)) {
7262 7263 for (; (ill != NULL) && (ill->ill_usesrc_grp_next != ill_head);
7263 7264 ill = ill->ill_usesrc_grp_next)
7264 7265 numifs++;
7265 7266 }
7266 7267 rw_exit(&ipst->ips_ill_g_usesrc_lock);
7267 7268
7268 7269 return (numifs);
7269 7270 }
7270 7271
7271 7272 /* Null values are passed in for ipif, sin, and ifreq */
7272 7273 /* ARGSUSED */
7273 7274 int
7274 7275 ip_sioctl_get_ifnum(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7275 7276 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7276 7277 {
7277 7278 int *nump;
7278 7279 conn_t *connp = Q_TO_CONN(q);
7279 7280
7280 7281 ASSERT(q->q_next == NULL); /* not a valid ioctl for ip as a module */
7281 7282
7282 7283 /* Existence of b_cont->b_cont checked in ip_wput_nondata */
7283 7284 nump = (int *)mp->b_cont->b_cont->b_rptr;
7284 7285
7285 7286 *nump = ip_get_numifs(connp->conn_zoneid,
7286 7287 connp->conn_netstack->netstack_ip);
7287 7288 ip1dbg(("ip_sioctl_get_ifnum numifs %d", *nump));
7288 7289 return (0);
7289 7290 }
7290 7291
7291 7292 /* Null values are passed in for ipif, sin, and ifreq */
7292 7293 /* ARGSUSED */
7293 7294 int
7294 7295 ip_sioctl_get_lifnum(ipif_t *dummy_ipif, sin_t *dummy_sin,
7295 7296 queue_t *q, mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7296 7297 {
7297 7298 struct lifnum *lifn;
7298 7299 mblk_t *mp1;
7299 7300 conn_t *connp = Q_TO_CONN(q);
7300 7301
7301 7302 ASSERT(q->q_next == NULL); /* not a valid ioctl for ip as a module */
7302 7303
7303 7304 /* Existence checked in ip_wput_nondata */
7304 7305 mp1 = mp->b_cont->b_cont;
7305 7306
7306 7307 lifn = (struct lifnum *)mp1->b_rptr;
7307 7308 switch (lifn->lifn_family) {
7308 7309 case AF_UNSPEC:
7309 7310 case AF_INET:
7310 7311 case AF_INET6:
7311 7312 break;
7312 7313 default:
7313 7314 return (EAFNOSUPPORT);
7314 7315 }
7315 7316
7316 7317 lifn->lifn_count = ip_get_numlifs(lifn->lifn_family, lifn->lifn_flags,
7317 7318 connp->conn_zoneid, connp->conn_netstack->netstack_ip);
7318 7319 ip1dbg(("ip_sioctl_get_lifnum numifs %d", lifn->lifn_count));
7319 7320 return (0);
7320 7321 }
7321 7322
7322 7323 /* ARGSUSED */
7323 7324 int
7324 7325 ip_sioctl_get_ifconf(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7325 7326 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7326 7327 {
7327 7328 STRUCT_HANDLE(ifconf, ifc);
7328 7329 mblk_t *mp1;
7329 7330 struct iocblk *iocp;
7330 7331 struct ifreq *ifr;
7331 7332 ill_walk_context_t ctx;
7332 7333 ill_t *ill;
7333 7334 ipif_t *ipif;
7334 7335 struct sockaddr_in *sin;
7335 7336 int32_t ifclen;
7336 7337 zoneid_t zoneid;
7337 7338 ip_stack_t *ipst = CONNQ_TO_IPST(q);
7338 7339
7339 7340 ASSERT(q->q_next == NULL); /* not valid ioctls for ip as a module */
7340 7341
7341 7342 ip1dbg(("ip_sioctl_get_ifconf"));
7342 7343 /* Existence verified in ip_wput_nondata */
7343 7344 mp1 = mp->b_cont->b_cont;
7344 7345 iocp = (struct iocblk *)mp->b_rptr;
7345 7346 zoneid = Q_TO_CONN(q)->conn_zoneid;
7346 7347
7347 7348 /*
7348 7349 * The original SIOCGIFCONF passed in a struct ifconf which specified
7349 7350 * the user buffer address and length into which the list of struct
7350 7351 * ifreqs was to be copied. Since AT&T Streams does not seem to
7351 7352 * allow M_COPYOUT to be used in conjunction with I_STR IOCTLS,
7352 7353 * the SIOCGIFCONF operation was redefined to simply provide
7353 7354 * a large output buffer into which we are supposed to jam the ifreq
7354 7355 * array. The same ioctl command code was used, despite the fact that
7355 7356 * both the applications and the kernel code had to change, thus making
7356 7357 * it impossible to support both interfaces.
7357 7358 *
7358 7359 * For reasons not good enough to try to explain, the following
7359 7360 * algorithm is used for deciding what to do with one of these:
7360 7361 * If the IOCTL comes in as an I_STR, it is assumed to be of the new
7361 7362 * form with the output buffer coming down as the continuation message.
7362 7363 * If it arrives as a TRANSPARENT IOCTL, it is assumed to be old style,
7363 7364 * and we have to copy in the ifconf structure to find out how big the
7364 7365 * output buffer is and where to copy out to. Sure no problem...
7365 7366 *
7366 7367 */
7367 7368 STRUCT_SET_HANDLE(ifc, iocp->ioc_flag, NULL);
7368 7369 if ((mp1->b_wptr - mp1->b_rptr) == STRUCT_SIZE(ifc)) {
7369 7370 int numifs = 0;
7370 7371 size_t ifc_bufsize;
7371 7372
7372 7373 /*
7373 7374 * Must be (better be!) continuation of a TRANSPARENT
7374 7375 * IOCTL. We just copied in the ifconf structure.
7375 7376 */
7376 7377 STRUCT_SET_HANDLE(ifc, iocp->ioc_flag,
7377 7378 (struct ifconf *)mp1->b_rptr);
7378 7379
7379 7380 /*
7380 7381 * Allocate a buffer to hold requested information.
7381 7382 *
7382 7383 * If ifc_len is larger than what is needed, we only
7383 7384 * allocate what we will use.
7384 7385 *
7385 7386 * If ifc_len is smaller than what is needed, return
7386 7387 * EINVAL.
7387 7388 *
7388 7389 * XXX: the ill_t structure can hava 2 counters, for
7389 7390 * v4 and v6 (not just ill_ipif_up_count) to store the
7390 7391 * number of interfaces for a device, so we don't need
7391 7392 * to count them here...
7392 7393 */
7393 7394 numifs = ip_get_numifs(zoneid, ipst);
7394 7395
7395 7396 ifclen = STRUCT_FGET(ifc, ifc_len);
7396 7397 ifc_bufsize = numifs * sizeof (struct ifreq);
7397 7398 if (ifc_bufsize > ifclen) {
7398 7399 if (iocp->ioc_cmd == O_SIOCGIFCONF) {
7399 7400 /* old behaviour */
7400 7401 return (EINVAL);
7401 7402 } else {
7402 7403 ifc_bufsize = ifclen;
7403 7404 }
7404 7405 }
7405 7406
7406 7407 mp1 = mi_copyout_alloc(q, mp,
7407 7408 STRUCT_FGETP(ifc, ifc_buf), ifc_bufsize, B_FALSE);
7408 7409 if (mp1 == NULL)
7409 7410 return (ENOMEM);
7410 7411
7411 7412 mp1->b_wptr = mp1->b_rptr + ifc_bufsize;
7412 7413 }
7413 7414 bzero(mp1->b_rptr, mp1->b_wptr - mp1->b_rptr);
7414 7415 /*
7415 7416 * the SIOCGIFCONF ioctl only knows about
7416 7417 * IPv4 addresses, so don't try to tell
7417 7418 * it about interfaces with IPv6-only
7418 7419 * addresses. (Last parm 'isv6' is B_FALSE)
7419 7420 */
7420 7421
7421 7422 ifr = (struct ifreq *)mp1->b_rptr;
7422 7423
7423 7424 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7424 7425 ill = ILL_START_WALK_V4(&ctx, ipst);
7425 7426 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7426 7427 if (IS_UNDER_IPMP(ill))
7427 7428 continue;
7428 7429 for (ipif = ill->ill_ipif; ipif != NULL;
7429 7430 ipif = ipif->ipif_next) {
7430 7431 if (zoneid != ipif->ipif_zoneid &&
7431 7432 ipif->ipif_zoneid != ALL_ZONES)
7432 7433 continue;
7433 7434 if ((uchar_t *)&ifr[1] > mp1->b_wptr) {
7434 7435 if (iocp->ioc_cmd == O_SIOCGIFCONF) {
7435 7436 /* old behaviour */
7436 7437 rw_exit(&ipst->ips_ill_g_lock);
7437 7438 return (EINVAL);
7438 7439 } else {
7439 7440 goto if_copydone;
7440 7441 }
7441 7442 }
7442 7443 ipif_get_name(ipif, ifr->ifr_name,
7443 7444 sizeof (ifr->ifr_name));
7444 7445 sin = (sin_t *)&ifr->ifr_addr;
7445 7446 *sin = sin_null;
7446 7447 sin->sin_family = AF_INET;
7447 7448 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
7448 7449 ifr++;
7449 7450 }
7450 7451 }
7451 7452 if_copydone:
7452 7453 rw_exit(&ipst->ips_ill_g_lock);
7453 7454 mp1->b_wptr = (uchar_t *)ifr;
7454 7455
7455 7456 if (STRUCT_BUF(ifc) != NULL) {
7456 7457 STRUCT_FSET(ifc, ifc_len,
7457 7458 (int)((uchar_t *)ifr - mp1->b_rptr));
7458 7459 }
7459 7460 return (0);
7460 7461 }
7461 7462
7462 7463 /*
7463 7464 * Get the interfaces using the address hosted on the interface passed in,
7464 7465 * as a source adddress
7465 7466 */
7466 7467 /* ARGSUSED */
7467 7468 int
7468 7469 ip_sioctl_get_lifsrcof(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7469 7470 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7470 7471 {
7471 7472 mblk_t *mp1;
7472 7473 ill_t *ill, *ill_head;
7473 7474 ipif_t *ipif, *orig_ipif;
7474 7475 int numlifs = 0;
7475 7476 size_t lifs_bufsize, lifsmaxlen;
7476 7477 struct lifreq *lifr;
7477 7478 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7478 7479 uint_t ifindex;
7479 7480 zoneid_t zoneid;
7480 7481 boolean_t isv6 = B_FALSE;
7481 7482 struct sockaddr_in *sin;
7482 7483 struct sockaddr_in6 *sin6;
7483 7484 STRUCT_HANDLE(lifsrcof, lifs);
7484 7485 ip_stack_t *ipst;
7485 7486
7486 7487 ipst = CONNQ_TO_IPST(q);
7487 7488
7488 7489 ASSERT(q->q_next == NULL);
7489 7490
7490 7491 zoneid = Q_TO_CONN(q)->conn_zoneid;
7491 7492
7492 7493 /* Existence verified in ip_wput_nondata */
7493 7494 mp1 = mp->b_cont->b_cont;
7494 7495
7495 7496 /*
7496 7497 * Must be (better be!) continuation of a TRANSPARENT
7497 7498 * IOCTL. We just copied in the lifsrcof structure.
7498 7499 */
7499 7500 STRUCT_SET_HANDLE(lifs, iocp->ioc_flag,
7500 7501 (struct lifsrcof *)mp1->b_rptr);
7501 7502
7502 7503 if (MBLKL(mp1) != STRUCT_SIZE(lifs))
7503 7504 return (EINVAL);
7504 7505
7505 7506 ifindex = STRUCT_FGET(lifs, lifs_ifindex);
7506 7507 isv6 = (Q_TO_CONN(q))->conn_family == AF_INET6;
7507 7508 ipif = ipif_lookup_on_ifindex(ifindex, isv6, zoneid, ipst);
7508 7509 if (ipif == NULL) {
7509 7510 ip1dbg(("ip_sioctl_get_lifsrcof: no ipif for ifindex %d\n",
7510 7511 ifindex));
7511 7512 return (ENXIO);
7512 7513 }
7513 7514
7514 7515 /* Allocate a buffer to hold requested information */
7515 7516 numlifs = ip_get_lifsrcofnum(ipif->ipif_ill);
7516 7517 lifs_bufsize = numlifs * sizeof (struct lifreq);
7517 7518 lifsmaxlen = STRUCT_FGET(lifs, lifs_maxlen);
7518 7519 /* The actual size needed is always returned in lifs_len */
7519 7520 STRUCT_FSET(lifs, lifs_len, lifs_bufsize);
7520 7521
7521 7522 /* If the amount we need is more than what is passed in, abort */
7522 7523 if (lifs_bufsize > lifsmaxlen || lifs_bufsize == 0) {
7523 7524 ipif_refrele(ipif);
7524 7525 return (0);
7525 7526 }
7526 7527
7527 7528 mp1 = mi_copyout_alloc(q, mp,
7528 7529 STRUCT_FGETP(lifs, lifs_buf), lifs_bufsize, B_FALSE);
7529 7530 if (mp1 == NULL) {
7530 7531 ipif_refrele(ipif);
7531 7532 return (ENOMEM);
7532 7533 }
7533 7534
7534 7535 mp1->b_wptr = mp1->b_rptr + lifs_bufsize;
7535 7536 bzero(mp1->b_rptr, lifs_bufsize);
7536 7537
7537 7538 lifr = (struct lifreq *)mp1->b_rptr;
7538 7539
7539 7540 ill = ill_head = ipif->ipif_ill;
7540 7541 orig_ipif = ipif;
7541 7542
7542 7543 /* ill_g_usesrc_lock protects ill_usesrc_grp_next */
7543 7544 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_READER);
7544 7545 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7545 7546
7546 7547 ill = ill->ill_usesrc_grp_next; /* start from next ill */
7547 7548 for (; (ill != NULL) && (ill != ill_head);
7548 7549 ill = ill->ill_usesrc_grp_next) {
7549 7550
7550 7551 if ((uchar_t *)&lifr[1] > mp1->b_wptr)
7551 7552 break;
7552 7553
7553 7554 ipif = ill->ill_ipif;
7554 7555 ipif_get_name(ipif, lifr->lifr_name, sizeof (lifr->lifr_name));
7555 7556 if (ipif->ipif_isv6) {
7556 7557 sin6 = (sin6_t *)&lifr->lifr_addr;
7557 7558 *sin6 = sin6_null;
7558 7559 sin6->sin6_family = AF_INET6;
7559 7560 sin6->sin6_addr = ipif->ipif_v6lcl_addr;
7560 7561 lifr->lifr_addrlen = ip_mask_to_plen_v6(
7561 7562 &ipif->ipif_v6net_mask);
7562 7563 } else {
7563 7564 sin = (sin_t *)&lifr->lifr_addr;
7564 7565 *sin = sin_null;
7565 7566 sin->sin_family = AF_INET;
7566 7567 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
7567 7568 lifr->lifr_addrlen = ip_mask_to_plen(
7568 7569 ipif->ipif_net_mask);
7569 7570 }
7570 7571 lifr++;
7571 7572 }
7572 7573 rw_exit(&ipst->ips_ill_g_lock);
7573 7574 rw_exit(&ipst->ips_ill_g_usesrc_lock);
7574 7575 ipif_refrele(orig_ipif);
7575 7576 mp1->b_wptr = (uchar_t *)lifr;
7576 7577 STRUCT_FSET(lifs, lifs_len, (int)((uchar_t *)lifr - mp1->b_rptr));
7577 7578
7578 7579 return (0);
7579 7580 }
7580 7581
7581 7582 /* ARGSUSED */
7582 7583 int
7583 7584 ip_sioctl_get_lifconf(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q,
7584 7585 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *ifreq)
7585 7586 {
7586 7587 mblk_t *mp1;
7587 7588 int list;
7588 7589 ill_t *ill;
7589 7590 ipif_t *ipif;
7590 7591 int flags;
7591 7592 int numlifs = 0;
7592 7593 size_t lifc_bufsize;
7593 7594 struct lifreq *lifr;
7594 7595 sa_family_t family;
7595 7596 struct sockaddr_in *sin;
7596 7597 struct sockaddr_in6 *sin6;
7597 7598 ill_walk_context_t ctx;
7598 7599 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7599 7600 int32_t lifclen;
7600 7601 zoneid_t zoneid;
7601 7602 STRUCT_HANDLE(lifconf, lifc);
7602 7603 ip_stack_t *ipst = CONNQ_TO_IPST(q);
7603 7604
7604 7605 ip1dbg(("ip_sioctl_get_lifconf"));
7605 7606
7606 7607 ASSERT(q->q_next == NULL);
7607 7608
7608 7609 zoneid = Q_TO_CONN(q)->conn_zoneid;
7609 7610
7610 7611 /* Existence verified in ip_wput_nondata */
7611 7612 mp1 = mp->b_cont->b_cont;
7612 7613
7613 7614 /*
7614 7615 * An extended version of SIOCGIFCONF that takes an
7615 7616 * additional address family and flags field.
7616 7617 * AF_UNSPEC retrieve both IPv4 and IPv6.
7617 7618 * Unless LIFC_NOXMIT is specified the IPIF_NOXMIT
7618 7619 * interfaces are omitted.
7619 7620 * Similarly, IPIF_TEMPORARY interfaces are omitted
7620 7621 * unless LIFC_TEMPORARY is specified.
7621 7622 * If LIFC_EXTERNAL_SOURCE is specified, IPIF_NOXMIT,
7622 7623 * IPIF_NOLOCAL, PHYI_LOOPBACK, IPIF_DEPRECATED and
7623 7624 * not IPIF_UP interfaces are omitted. LIFC_EXTERNAL_SOURCE
7624 7625 * has priority over LIFC_NOXMIT.
7625 7626 */
7626 7627 STRUCT_SET_HANDLE(lifc, iocp->ioc_flag, NULL);
7627 7628
7628 7629 if ((mp1->b_wptr - mp1->b_rptr) != STRUCT_SIZE(lifc))
7629 7630 return (EINVAL);
7630 7631
7631 7632 /*
7632 7633 * Must be (better be!) continuation of a TRANSPARENT
7633 7634 * IOCTL. We just copied in the lifconf structure.
7634 7635 */
7635 7636 STRUCT_SET_HANDLE(lifc, iocp->ioc_flag, (struct lifconf *)mp1->b_rptr);
7636 7637
7637 7638 family = STRUCT_FGET(lifc, lifc_family);
7638 7639 flags = STRUCT_FGET(lifc, lifc_flags);
7639 7640
7640 7641 switch (family) {
7641 7642 case AF_UNSPEC:
7642 7643 /*
7643 7644 * walk all ILL's.
7644 7645 */
7645 7646 list = MAX_G_HEADS;
7646 7647 break;
7647 7648 case AF_INET:
7648 7649 /*
7649 7650 * walk only IPV4 ILL's.
7650 7651 */
7651 7652 list = IP_V4_G_HEAD;
7652 7653 break;
7653 7654 case AF_INET6:
7654 7655 /*
7655 7656 * walk only IPV6 ILL's.
7656 7657 */
7657 7658 list = IP_V6_G_HEAD;
7658 7659 break;
7659 7660 default:
7660 7661 return (EAFNOSUPPORT);
7661 7662 }
7662 7663
7663 7664 /*
7664 7665 * Allocate a buffer to hold requested information.
7665 7666 *
7666 7667 * If lifc_len is larger than what is needed, we only
7667 7668 * allocate what we will use.
7668 7669 *
7669 7670 * If lifc_len is smaller than what is needed, return
7670 7671 * EINVAL.
7671 7672 */
7672 7673 numlifs = ip_get_numlifs(family, flags, zoneid, ipst);
7673 7674 lifc_bufsize = numlifs * sizeof (struct lifreq);
7674 7675 lifclen = STRUCT_FGET(lifc, lifc_len);
7675 7676 if (lifc_bufsize > lifclen) {
7676 7677 if (iocp->ioc_cmd == O_SIOCGLIFCONF)
7677 7678 return (EINVAL);
7678 7679 else
7679 7680 lifc_bufsize = lifclen;
7680 7681 }
7681 7682
7682 7683 mp1 = mi_copyout_alloc(q, mp,
7683 7684 STRUCT_FGETP(lifc, lifc_buf), lifc_bufsize, B_FALSE);
7684 7685 if (mp1 == NULL)
7685 7686 return (ENOMEM);
7686 7687
7687 7688 mp1->b_wptr = mp1->b_rptr + lifc_bufsize;
7688 7689 bzero(mp1->b_rptr, mp1->b_wptr - mp1->b_rptr);
7689 7690
7690 7691 lifr = (struct lifreq *)mp1->b_rptr;
7691 7692
7692 7693 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
7693 7694 ill = ill_first(list, list, &ctx, ipst);
7694 7695 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
7695 7696 if (IS_UNDER_IPMP(ill) && !(flags & LIFC_UNDER_IPMP))
7696 7697 continue;
7697 7698
7698 7699 for (ipif = ill->ill_ipif; ipif != NULL;
7699 7700 ipif = ipif->ipif_next) {
7700 7701 if ((ipif->ipif_flags & IPIF_NOXMIT) &&
7701 7702 !(flags & LIFC_NOXMIT))
7702 7703 continue;
7703 7704
7704 7705 if ((ipif->ipif_flags & IPIF_TEMPORARY) &&
7705 7706 !(flags & LIFC_TEMPORARY))
7706 7707 continue;
7707 7708
7708 7709 if (((ipif->ipif_flags &
7709 7710 (IPIF_NOXMIT|IPIF_NOLOCAL|
7710 7711 IPIF_DEPRECATED)) ||
7711 7712 IS_LOOPBACK(ill) ||
7712 7713 !(ipif->ipif_flags & IPIF_UP)) &&
7713 7714 (flags & LIFC_EXTERNAL_SOURCE))
7714 7715 continue;
7715 7716
7716 7717 if (zoneid != ipif->ipif_zoneid &&
7717 7718 ipif->ipif_zoneid != ALL_ZONES &&
7718 7719 (zoneid != GLOBAL_ZONEID ||
7719 7720 !(flags & LIFC_ALLZONES)))
7720 7721 continue;
7721 7722
7722 7723 if ((uchar_t *)&lifr[1] > mp1->b_wptr) {
7723 7724 if (iocp->ioc_cmd == O_SIOCGLIFCONF) {
7724 7725 rw_exit(&ipst->ips_ill_g_lock);
7725 7726 return (EINVAL);
7726 7727 } else {
7727 7728 goto lif_copydone;
7728 7729 }
7729 7730 }
7730 7731
7731 7732 ipif_get_name(ipif, lifr->lifr_name,
7732 7733 sizeof (lifr->lifr_name));
7733 7734 lifr->lifr_type = ill->ill_type;
7734 7735 if (ipif->ipif_isv6) {
7735 7736 sin6 = (sin6_t *)&lifr->lifr_addr;
7736 7737 *sin6 = sin6_null;
7737 7738 sin6->sin6_family = AF_INET6;
7738 7739 sin6->sin6_addr =
7739 7740 ipif->ipif_v6lcl_addr;
7740 7741 lifr->lifr_addrlen =
7741 7742 ip_mask_to_plen_v6(
7742 7743 &ipif->ipif_v6net_mask);
7743 7744 } else {
7744 7745 sin = (sin_t *)&lifr->lifr_addr;
7745 7746 *sin = sin_null;
7746 7747 sin->sin_family = AF_INET;
7747 7748 sin->sin_addr.s_addr =
7748 7749 ipif->ipif_lcl_addr;
7749 7750 lifr->lifr_addrlen =
7750 7751 ip_mask_to_plen(
7751 7752 ipif->ipif_net_mask);
7752 7753 }
7753 7754 lifr++;
7754 7755 }
7755 7756 }
7756 7757 lif_copydone:
7757 7758 rw_exit(&ipst->ips_ill_g_lock);
7758 7759
7759 7760 mp1->b_wptr = (uchar_t *)lifr;
7760 7761 if (STRUCT_BUF(lifc) != NULL) {
7761 7762 STRUCT_FSET(lifc, lifc_len,
7762 7763 (int)((uchar_t *)lifr - mp1->b_rptr));
7763 7764 }
7764 7765 return (0);
7765 7766 }
7766 7767
7767 7768 static void
7768 7769 ip_sioctl_ip6addrpolicy(queue_t *q, mblk_t *mp)
7769 7770 {
7770 7771 ip6_asp_t *table;
7771 7772 size_t table_size;
7772 7773 mblk_t *data_mp;
7773 7774 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7774 7775 ip_stack_t *ipst;
7775 7776
7776 7777 if (q->q_next == NULL)
7777 7778 ipst = CONNQ_TO_IPST(q);
7778 7779 else
7779 7780 ipst = ILLQ_TO_IPST(q);
7780 7781
7781 7782 /* These two ioctls are I_STR only */
7782 7783 if (iocp->ioc_count == TRANSPARENT) {
7783 7784 miocnak(q, mp, 0, EINVAL);
7784 7785 return;
7785 7786 }
7786 7787
7787 7788 data_mp = mp->b_cont;
7788 7789 if (data_mp == NULL) {
7789 7790 /* The user passed us a NULL argument */
7790 7791 table = NULL;
7791 7792 table_size = iocp->ioc_count;
7792 7793 } else {
7793 7794 /*
7794 7795 * The user provided a table. The stream head
7795 7796 * may have copied in the user data in chunks,
7796 7797 * so make sure everything is pulled up
7797 7798 * properly.
7798 7799 */
7799 7800 if (MBLKL(data_mp) < iocp->ioc_count) {
7800 7801 mblk_t *new_data_mp;
7801 7802 if ((new_data_mp = msgpullup(data_mp, -1)) ==
7802 7803 NULL) {
7803 7804 miocnak(q, mp, 0, ENOMEM);
7804 7805 return;
7805 7806 }
7806 7807 freemsg(data_mp);
7807 7808 data_mp = new_data_mp;
7808 7809 mp->b_cont = data_mp;
7809 7810 }
7810 7811 table = (ip6_asp_t *)data_mp->b_rptr;
7811 7812 table_size = iocp->ioc_count;
7812 7813 }
7813 7814
7814 7815 switch (iocp->ioc_cmd) {
7815 7816 case SIOCGIP6ADDRPOLICY:
7816 7817 iocp->ioc_rval = ip6_asp_get(table, table_size, ipst);
7817 7818 if (iocp->ioc_rval == -1)
7818 7819 iocp->ioc_error = EINVAL;
7819 7820 #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4
7820 7821 else if (table != NULL &&
7821 7822 (iocp->ioc_flag & IOC_MODELS) == IOC_ILP32) {
7822 7823 ip6_asp_t *src = table;
7823 7824 ip6_asp32_t *dst = (void *)table;
7824 7825 int count = table_size / sizeof (ip6_asp_t);
7825 7826 int i;
7826 7827
7827 7828 /*
7828 7829 * We need to do an in-place shrink of the array
7829 7830 * to match the alignment attributes of the
7830 7831 * 32-bit ABI looking at it.
7831 7832 */
7832 7833 /* LINTED: logical expression always true: op "||" */
7833 7834 ASSERT(sizeof (*src) > sizeof (*dst));
7834 7835 for (i = 1; i < count; i++)
7835 7836 bcopy(src + i, dst + i, sizeof (*dst));
7836 7837 }
7837 7838 #endif
7838 7839 break;
7839 7840
7840 7841 case SIOCSIP6ADDRPOLICY:
7841 7842 ASSERT(mp->b_prev == NULL);
7842 7843 mp->b_prev = (void *)q;
7843 7844 #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4
7844 7845 /*
7845 7846 * We pass in the datamodel here so that the ip6_asp_replace()
7846 7847 * routine can handle converting from 32-bit to native formats
7847 7848 * where necessary.
7848 7849 *
7849 7850 * A better way to handle this might be to convert the inbound
7850 7851 * data structure here, and hang it off a new 'mp'; thus the
7851 7852 * ip6_asp_replace() logic would always be dealing with native
7852 7853 * format data structures..
7853 7854 *
7854 7855 * (An even simpler way to handle these ioctls is to just
7855 7856 * add a 32-bit trailing 'pad' field to the ip6_asp_t structure
7856 7857 * and just recompile everything that depends on it.)
7857 7858 */
7858 7859 #endif
7859 7860 ip6_asp_replace(mp, table, table_size, B_FALSE, ipst,
7860 7861 iocp->ioc_flag & IOC_MODELS);
7861 7862 return;
7862 7863 }
7863 7864
7864 7865 DB_TYPE(mp) = (iocp->ioc_error == 0) ? M_IOCACK : M_IOCNAK;
7865 7866 qreply(q, mp);
7866 7867 }
7867 7868
7868 7869 static void
7869 7870 ip_sioctl_dstinfo(queue_t *q, mblk_t *mp)
7870 7871 {
7871 7872 mblk_t *data_mp;
7872 7873 struct dstinforeq *dir;
7873 7874 uint8_t *end, *cur;
7874 7875 in6_addr_t *daddr, *saddr;
7875 7876 ipaddr_t v4daddr;
7876 7877 ire_t *ire;
7877 7878 ipaddr_t v4setsrc;
7878 7879 in6_addr_t v6setsrc;
7879 7880 char *slabel, *dlabel;
7880 7881 boolean_t isipv4;
7881 7882 int match_ire;
7882 7883 ill_t *dst_ill;
7883 7884 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
7884 7885 conn_t *connp = Q_TO_CONN(q);
7885 7886 zoneid_t zoneid = IPCL_ZONEID(connp);
7886 7887 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
7887 7888 uint64_t ipif_flags;
7888 7889
7889 7890 ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */
7890 7891
7891 7892 /*
7892 7893 * This ioctl is I_STR only, and must have a
7893 7894 * data mblk following the M_IOCTL mblk.
7894 7895 */
7895 7896 data_mp = mp->b_cont;
7896 7897 if (iocp->ioc_count == TRANSPARENT || data_mp == NULL) {
7897 7898 miocnak(q, mp, 0, EINVAL);
7898 7899 return;
7899 7900 }
7900 7901
7901 7902 if (MBLKL(data_mp) < iocp->ioc_count) {
7902 7903 mblk_t *new_data_mp;
7903 7904
7904 7905 if ((new_data_mp = msgpullup(data_mp, -1)) == NULL) {
7905 7906 miocnak(q, mp, 0, ENOMEM);
7906 7907 return;
7907 7908 }
7908 7909 freemsg(data_mp);
7909 7910 data_mp = new_data_mp;
7910 7911 mp->b_cont = data_mp;
7911 7912 }
7912 7913 match_ire = MATCH_IRE_DSTONLY;
7913 7914
7914 7915 for (cur = data_mp->b_rptr, end = data_mp->b_wptr;
7915 7916 end - cur >= sizeof (struct dstinforeq);
7916 7917 cur += sizeof (struct dstinforeq)) {
7917 7918 dir = (struct dstinforeq *)cur;
7918 7919 daddr = &dir->dir_daddr;
7919 7920 saddr = &dir->dir_saddr;
7920 7921
7921 7922 /*
7922 7923 * ip_addr_scope_v6() and ip6_asp_lookup() handle
7923 7924 * v4 mapped addresses; ire_ftable_lookup_v6()
7924 7925 * and ip_select_source_v6() do not.
7925 7926 */
7926 7927 dir->dir_dscope = ip_addr_scope_v6(daddr);
7927 7928 dlabel = ip6_asp_lookup(daddr, &dir->dir_precedence, ipst);
7928 7929
7929 7930 isipv4 = IN6_IS_ADDR_V4MAPPED(daddr);
7930 7931 if (isipv4) {
7931 7932 IN6_V4MAPPED_TO_IPADDR(daddr, v4daddr);
7932 7933 v4setsrc = INADDR_ANY;
7933 7934 ire = ire_route_recursive_v4(v4daddr, 0, NULL, zoneid,
7934 7935 NULL, match_ire, IRR_ALLOCATE, 0, ipst, &v4setsrc,
7935 7936 NULL, NULL);
7936 7937 } else {
7937 7938 v6setsrc = ipv6_all_zeros;
7938 7939 ire = ire_route_recursive_v6(daddr, 0, NULL, zoneid,
7939 7940 NULL, match_ire, IRR_ALLOCATE, 0, ipst, &v6setsrc,
7940 7941 NULL, NULL);
7941 7942 }
7942 7943 ASSERT(ire != NULL);
7943 7944 if (ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) {
7944 7945 ire_refrele(ire);
7945 7946 dir->dir_dreachable = 0;
7946 7947
7947 7948 /* move on to next dst addr */
7948 7949 continue;
7949 7950 }
7950 7951 dir->dir_dreachable = 1;
7951 7952
7952 7953 dst_ill = ire_nexthop_ill(ire);
7953 7954 if (dst_ill == NULL) {
7954 7955 ire_refrele(ire);
7955 7956 continue;
7956 7957 }
7957 7958
7958 7959 /* With ipmp we most likely look at the ipmp ill here */
7959 7960 dir->dir_dmactype = dst_ill->ill_mactype;
7960 7961
7961 7962 if (isipv4) {
7962 7963 ipaddr_t v4saddr;
7963 7964
7964 7965 if (ip_select_source_v4(dst_ill, v4setsrc, v4daddr,
7965 7966 connp->conn_ixa->ixa_multicast_ifaddr, zoneid, ipst,
7966 7967 &v4saddr, NULL, &ipif_flags) != 0) {
7967 7968 v4saddr = INADDR_ANY;
7968 7969 ipif_flags = 0;
7969 7970 }
7970 7971 IN6_IPADDR_TO_V4MAPPED(v4saddr, saddr);
7971 7972 } else {
7972 7973 if (ip_select_source_v6(dst_ill, &v6setsrc, daddr,
7973 7974 zoneid, ipst, B_FALSE, IPV6_PREFER_SRC_DEFAULT,
7974 7975 saddr, NULL, &ipif_flags) != 0) {
7975 7976 *saddr = ipv6_all_zeros;
7976 7977 ipif_flags = 0;
7977 7978 }
7978 7979 }
7979 7980
7980 7981 dir->dir_sscope = ip_addr_scope_v6(saddr);
7981 7982 slabel = ip6_asp_lookup(saddr, NULL, ipst);
7982 7983 dir->dir_labelmatch = ip6_asp_labelcmp(dlabel, slabel);
7983 7984 dir->dir_sdeprecated = (ipif_flags & IPIF_DEPRECATED) ? 1 : 0;
7984 7985 ire_refrele(ire);
7985 7986 ill_refrele(dst_ill);
7986 7987 }
7987 7988 miocack(q, mp, iocp->ioc_count, 0);
7988 7989 }
7989 7990
7990 7991 /*
7991 7992 * Check if this is an address assigned to this machine.
7992 7993 * Skips interfaces that are down by using ire checks.
7993 7994 * Translates mapped addresses to v4 addresses and then
7994 7995 * treats them as such, returning true if the v4 address
7995 7996 * associated with this mapped address is configured.
7996 7997 * Note: Applications will have to be careful what they do
7997 7998 * with the response; use of mapped addresses limits
7998 7999 * what can be done with the socket, especially with
7999 8000 * respect to socket options and ioctls - neither IPv4
8000 8001 * options nor IPv6 sticky options/ancillary data options
8001 8002 * may be used.
8002 8003 */
8003 8004 /* ARGSUSED */
8004 8005 int
8005 8006 ip_sioctl_tmyaddr(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
8006 8007 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
8007 8008 {
8008 8009 struct sioc_addrreq *sia;
8009 8010 sin_t *sin;
8010 8011 ire_t *ire;
8011 8012 mblk_t *mp1;
8012 8013 zoneid_t zoneid;
8013 8014 ip_stack_t *ipst;
8014 8015
8015 8016 ip1dbg(("ip_sioctl_tmyaddr"));
8016 8017
8017 8018 ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */
8018 8019 zoneid = Q_TO_CONN(q)->conn_zoneid;
8019 8020 ipst = CONNQ_TO_IPST(q);
8020 8021
8021 8022 /* Existence verified in ip_wput_nondata */
8022 8023 mp1 = mp->b_cont->b_cont;
8023 8024 sia = (struct sioc_addrreq *)mp1->b_rptr;
8024 8025 sin = (sin_t *)&sia->sa_addr;
8025 8026 switch (sin->sin_family) {
8026 8027 case AF_INET6: {
8027 8028 sin6_t *sin6 = (sin6_t *)sin;
8028 8029
8029 8030 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
8030 8031 ipaddr_t v4_addr;
8031 8032
8032 8033 IN6_V4MAPPED_TO_IPADDR(&sin6->sin6_addr,
8033 8034 v4_addr);
8034 8035 ire = ire_ftable_lookup_v4(v4_addr, 0, 0,
8035 8036 IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, NULL,
8036 8037 MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY, 0, ipst, NULL);
8037 8038 } else {
8038 8039 in6_addr_t v6addr;
8039 8040
8040 8041 v6addr = sin6->sin6_addr;
8041 8042 ire = ire_ftable_lookup_v6(&v6addr, 0, 0,
8042 8043 IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid, NULL,
8043 8044 MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY, 0, ipst, NULL);
8044 8045 }
8045 8046 break;
8046 8047 }
8047 8048 case AF_INET: {
8048 8049 ipaddr_t v4addr;
8049 8050
8050 8051 v4addr = sin->sin_addr.s_addr;
8051 8052 ire = ire_ftable_lookup_v4(v4addr, 0, 0,
8052 8053 IRE_LOCAL|IRE_LOOPBACK, NULL, zoneid,
8053 8054 NULL, MATCH_IRE_TYPE | MATCH_IRE_ZONEONLY, 0, ipst, NULL);
8054 8055 break;
8055 8056 }
8056 8057 default:
8057 8058 return (EAFNOSUPPORT);
8058 8059 }
8059 8060 if (ire != NULL) {
8060 8061 sia->sa_res = 1;
8061 8062 ire_refrele(ire);
8062 8063 } else {
8063 8064 sia->sa_res = 0;
8064 8065 }
8065 8066 return (0);
8066 8067 }
8067 8068
8068 8069 /*
8069 8070 * Check if this is an address assigned on-link i.e. neighbor,
8070 8071 * and makes sure it's reachable from the current zone.
8071 8072 * Returns true for my addresses as well.
8072 8073 * Translates mapped addresses to v4 addresses and then
8073 8074 * treats them as such, returning true if the v4 address
8074 8075 * associated with this mapped address is configured.
8075 8076 * Note: Applications will have to be careful what they do
8076 8077 * with the response; use of mapped addresses limits
8077 8078 * what can be done with the socket, especially with
8078 8079 * respect to socket options and ioctls - neither IPv4
8079 8080 * options nor IPv6 sticky options/ancillary data options
8080 8081 * may be used.
8081 8082 */
8082 8083 /* ARGSUSED */
8083 8084 int
8084 8085 ip_sioctl_tonlink(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
8085 8086 ip_ioctl_cmd_t *ipip, void *duymmy_ifreq)
8086 8087 {
8087 8088 struct sioc_addrreq *sia;
8088 8089 sin_t *sin;
8089 8090 mblk_t *mp1;
8090 8091 ire_t *ire = NULL;
8091 8092 zoneid_t zoneid;
8092 8093 ip_stack_t *ipst;
8093 8094
8094 8095 ip1dbg(("ip_sioctl_tonlink"));
8095 8096
8096 8097 ASSERT(q->q_next == NULL); /* this ioctl not allowed if ip is module */
8097 8098 zoneid = Q_TO_CONN(q)->conn_zoneid;
8098 8099 ipst = CONNQ_TO_IPST(q);
8099 8100
8100 8101 /* Existence verified in ip_wput_nondata */
8101 8102 mp1 = mp->b_cont->b_cont;
8102 8103 sia = (struct sioc_addrreq *)mp1->b_rptr;
8103 8104 sin = (sin_t *)&sia->sa_addr;
8104 8105
8105 8106 /*
8106 8107 * We check for IRE_ONLINK and exclude IRE_BROADCAST|IRE_MULTICAST
8107 8108 * to make sure we only look at on-link unicast address.
8108 8109 */
8109 8110 switch (sin->sin_family) {
8110 8111 case AF_INET6: {
8111 8112 sin6_t *sin6 = (sin6_t *)sin;
8112 8113
8113 8114 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
8114 8115 ipaddr_t v4_addr;
8115 8116
8116 8117 IN6_V4MAPPED_TO_IPADDR(&sin6->sin6_addr,
8117 8118 v4_addr);
8118 8119 if (!CLASSD(v4_addr)) {
8119 8120 ire = ire_ftable_lookup_v4(v4_addr, 0, 0, 0,
8120 8121 NULL, zoneid, NULL, MATCH_IRE_DSTONLY,
8121 8122 0, ipst, NULL);
8122 8123 }
8123 8124 } else {
8124 8125 in6_addr_t v6addr;
8125 8126
8126 8127 v6addr = sin6->sin6_addr;
8127 8128 if (!IN6_IS_ADDR_MULTICAST(&v6addr)) {
8128 8129 ire = ire_ftable_lookup_v6(&v6addr, 0, 0, 0,
8129 8130 NULL, zoneid, NULL, MATCH_IRE_DSTONLY, 0,
8130 8131 ipst, NULL);
8131 8132 }
8132 8133 }
8133 8134 break;
8134 8135 }
8135 8136 case AF_INET: {
8136 8137 ipaddr_t v4addr;
8137 8138
8138 8139 v4addr = sin->sin_addr.s_addr;
8139 8140 if (!CLASSD(v4addr)) {
8140 8141 ire = ire_ftable_lookup_v4(v4addr, 0, 0, 0, NULL,
8141 8142 zoneid, NULL, MATCH_IRE_DSTONLY, 0, ipst, NULL);
8142 8143 }
8143 8144 break;
8144 8145 }
8145 8146 default:
8146 8147 return (EAFNOSUPPORT);
8147 8148 }
8148 8149 sia->sa_res = 0;
8149 8150 if (ire != NULL) {
8150 8151 ASSERT(!(ire->ire_type & IRE_MULTICAST));
8151 8152
8152 8153 if ((ire->ire_type & IRE_ONLINK) &&
8153 8154 !(ire->ire_type & IRE_BROADCAST))
8154 8155 sia->sa_res = 1;
8155 8156 ire_refrele(ire);
8156 8157 }
8157 8158 return (0);
8158 8159 }
8159 8160
8160 8161 /*
8161 8162 * TBD: implement when kernel maintaines a list of site prefixes.
8162 8163 */
8163 8164 /* ARGSUSED */
8164 8165 int
8165 8166 ip_sioctl_tmysite(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
8166 8167 ip_ioctl_cmd_t *ipip, void *ifreq)
8167 8168 {
8168 8169 return (ENXIO);
8169 8170 }
8170 8171
8171 8172 /* ARP IOCTLs. */
8172 8173 /* ARGSUSED */
8173 8174 int
8174 8175 ip_sioctl_arp(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
8175 8176 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
8176 8177 {
8177 8178 int err;
8178 8179 ipaddr_t ipaddr;
8179 8180 struct iocblk *iocp;
8180 8181 conn_t *connp;
8181 8182 struct arpreq *ar;
8182 8183 struct xarpreq *xar;
8183 8184 int arp_flags, flags, alength;
8184 8185 uchar_t *lladdr;
8185 8186 ip_stack_t *ipst;
8186 8187 ill_t *ill = ipif->ipif_ill;
8187 8188 ill_t *proxy_ill = NULL;
8188 8189 ipmp_arpent_t *entp = NULL;
8189 8190 boolean_t proxyarp = B_FALSE;
8190 8191 boolean_t if_arp_ioctl = B_FALSE;
8191 8192 ncec_t *ncec = NULL;
8192 8193 nce_t *nce;
8193 8194
8194 8195 ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL);
8195 8196 connp = Q_TO_CONN(q);
8196 8197 ipst = connp->conn_netstack->netstack_ip;
8197 8198 iocp = (struct iocblk *)mp->b_rptr;
8198 8199
8199 8200 if (ipip->ipi_cmd_type == XARP_CMD) {
8200 8201 /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->XARPREQ_MBLK */
8201 8202 xar = (struct xarpreq *)mp->b_cont->b_cont->b_rptr;
8202 8203 ar = NULL;
8203 8204
8204 8205 arp_flags = xar->xarp_flags;
8205 8206 lladdr = (uchar_t *)LLADDR(&xar->xarp_ha);
8206 8207 if_arp_ioctl = (xar->xarp_ha.sdl_nlen != 0);
8207 8208 /*
8208 8209 * Validate against user's link layer address length
8209 8210 * input and name and addr length limits.
8210 8211 */
8211 8212 alength = ill->ill_phys_addr_length;
8212 8213 if (ipip->ipi_cmd == SIOCSXARP) {
8213 8214 if (alength != xar->xarp_ha.sdl_alen ||
8214 8215 (alength + xar->xarp_ha.sdl_nlen >
8215 8216 sizeof (xar->xarp_ha.sdl_data)))
8216 8217 return (EINVAL);
8217 8218 }
8218 8219 } else {
8219 8220 /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->ARPREQ_MBLK */
8220 8221 ar = (struct arpreq *)mp->b_cont->b_cont->b_rptr;
8221 8222 xar = NULL;
8222 8223
8223 8224 arp_flags = ar->arp_flags;
8224 8225 lladdr = (uchar_t *)ar->arp_ha.sa_data;
8225 8226 /*
8226 8227 * Theoretically, the sa_family could tell us what link
8227 8228 * layer type this operation is trying to deal with. By
8228 8229 * common usage AF_UNSPEC means ethernet. We'll assume
8229 8230 * any attempt to use the SIOC?ARP ioctls is for ethernet,
8230 8231 * for now. Our new SIOC*XARP ioctls can be used more
8231 8232 * generally.
8232 8233 *
8233 8234 * If the underlying media happens to have a non 6 byte
8234 8235 * address, arp module will fail set/get, but the del
8235 8236 * operation will succeed.
8236 8237 */
8237 8238 alength = 6;
8238 8239 if ((ipip->ipi_cmd != SIOCDARP) &&
8239 8240 (alength != ill->ill_phys_addr_length)) {
8240 8241 return (EINVAL);
8241 8242 }
8242 8243 }
8243 8244
8244 8245 /* Translate ATF* flags to NCE* flags */
8245 8246 flags = 0;
8246 8247 if (arp_flags & ATF_AUTHORITY)
8247 8248 flags |= NCE_F_AUTHORITY;
8248 8249 if (arp_flags & ATF_PERM)
8249 8250 flags |= NCE_F_NONUD; /* not subject to aging */
8250 8251 if (arp_flags & ATF_PUBL)
8251 8252 flags |= NCE_F_PUBLISH;
8252 8253
8253 8254 /*
8254 8255 * IPMP ARP special handling:
8255 8256 *
8256 8257 * 1. Since ARP mappings must appear consistent across the group,
8257 8258 * prohibit changing ARP mappings on the underlying interfaces.
8258 8259 *
8259 8260 * 2. Since ARP mappings for IPMP data addresses are maintained by
8260 8261 * IP itself, prohibit changing them.
8261 8262 *
8262 8263 * 3. For proxy ARP, use a functioning hardware address in the group,
8263 8264 * provided one exists. If one doesn't, just add the entry as-is;
8264 8265 * ipmp_illgrp_refresh_arpent() will refresh it if things change.
8265 8266 */
8266 8267 if (IS_UNDER_IPMP(ill)) {
8267 8268 if (ipip->ipi_cmd != SIOCGARP && ipip->ipi_cmd != SIOCGXARP)
8268 8269 return (EPERM);
8269 8270 }
8270 8271 if (IS_IPMP(ill)) {
8271 8272 ipmp_illgrp_t *illg = ill->ill_grp;
8272 8273
8273 8274 switch (ipip->ipi_cmd) {
8274 8275 case SIOCSARP:
8275 8276 case SIOCSXARP:
8276 8277 proxy_ill = ipmp_illgrp_find_ill(illg, lladdr, alength);
8277 8278 if (proxy_ill != NULL) {
8278 8279 proxyarp = B_TRUE;
8279 8280 if (!ipmp_ill_is_active(proxy_ill))
8280 8281 proxy_ill = ipmp_illgrp_next_ill(illg);
8281 8282 if (proxy_ill != NULL)
8282 8283 lladdr = proxy_ill->ill_phys_addr;
8283 8284 }
8284 8285 /* FALLTHRU */
8285 8286 }
8286 8287 }
8287 8288
8288 8289 ipaddr = sin->sin_addr.s_addr;
8289 8290 /*
8290 8291 * don't match across illgrp per case (1) and (2).
8291 8292 * XXX use IS_IPMP(ill) like ndp_sioc_update?
8292 8293 */
8293 8294 nce = nce_lookup_v4(ill, &ipaddr);
8294 8295 if (nce != NULL)
8295 8296 ncec = nce->nce_common;
8296 8297
8297 8298 switch (iocp->ioc_cmd) {
8298 8299 case SIOCDARP:
8299 8300 case SIOCDXARP: {
8300 8301 /*
8301 8302 * Delete the NCE if any.
8302 8303 */
8303 8304 if (ncec == NULL) {
8304 8305 iocp->ioc_error = ENXIO;
8305 8306 break;
8306 8307 }
8307 8308 /* Don't allow changes to arp mappings of local addresses. */
8308 8309 if (NCE_MYADDR(ncec)) {
8309 8310 nce_refrele(nce);
8310 8311 return (ENOTSUP);
8311 8312 }
8312 8313 iocp->ioc_error = 0;
8313 8314
8314 8315 /*
8315 8316 * Delete the nce_common which has ncec_ill set to ipmp_ill.
8316 8317 * This will delete all the nce entries on the under_ills.
8317 8318 */
8318 8319 ncec_delete(ncec);
8319 8320 /*
8320 8321 * Once the NCE has been deleted, then the ire_dep* consistency
8321 8322 * mechanism will find any IRE which depended on the now
8322 8323 * condemned NCE (as part of sending packets).
8323 8324 * That mechanism handles redirects by deleting redirects
8324 8325 * that refer to UNREACHABLE nces.
8325 8326 */
8326 8327 break;
8327 8328 }
8328 8329 case SIOCGARP:
8329 8330 case SIOCGXARP:
8330 8331 if (ncec != NULL) {
8331 8332 lladdr = ncec->ncec_lladdr;
8332 8333 flags = ncec->ncec_flags;
8333 8334 iocp->ioc_error = 0;
8334 8335 ip_sioctl_garp_reply(mp, ncec->ncec_ill, lladdr, flags);
8335 8336 } else {
8336 8337 iocp->ioc_error = ENXIO;
8337 8338 }
8338 8339 break;
8339 8340 case SIOCSARP:
8340 8341 case SIOCSXARP:
8341 8342 /* Don't allow changes to arp mappings of local addresses. */
8342 8343 if (ncec != NULL && NCE_MYADDR(ncec)) {
8343 8344 nce_refrele(nce);
8344 8345 return (ENOTSUP);
8345 8346 }
8346 8347
8347 8348 /* static arp entries will undergo NUD if ATF_PERM is not set */
8348 8349 flags |= NCE_F_STATIC;
8349 8350 if (!if_arp_ioctl) {
8350 8351 ip_nce_lookup_and_update(&ipaddr, NULL, ipst,
8351 8352 lladdr, alength, flags);
8352 8353 } else {
8353 8354 ipif_t *ipif = ipif_get_next_ipif(NULL, ill);
8354 8355 if (ipif != NULL) {
8355 8356 ip_nce_lookup_and_update(&ipaddr, ipif, ipst,
8356 8357 lladdr, alength, flags);
8357 8358 ipif_refrele(ipif);
8358 8359 }
8359 8360 }
8360 8361 if (nce != NULL) {
8361 8362 nce_refrele(nce);
8362 8363 nce = NULL;
8363 8364 }
8364 8365 /*
8365 8366 * NCE_F_STATIC entries will be added in state ND_REACHABLE
8366 8367 * by nce_add_common()
8367 8368 */
8368 8369 err = nce_lookup_then_add_v4(ill, lladdr,
8369 8370 ill->ill_phys_addr_length, &ipaddr, flags, ND_UNCHANGED,
8370 8371 &nce);
8371 8372 if (err == EEXIST) {
8372 8373 ncec = nce->nce_common;
8373 8374 mutex_enter(&ncec->ncec_lock);
8374 8375 ncec->ncec_state = ND_REACHABLE;
8375 8376 ncec->ncec_flags = flags;
8376 8377 nce_update(ncec, ND_UNCHANGED, lladdr);
8377 8378 mutex_exit(&ncec->ncec_lock);
8378 8379 err = 0;
8379 8380 }
8380 8381 if (nce != NULL) {
8381 8382 nce_refrele(nce);
8382 8383 nce = NULL;
8383 8384 }
8384 8385 if (IS_IPMP(ill) && err == 0) {
8385 8386 entp = ipmp_illgrp_create_arpent(ill->ill_grp,
8386 8387 proxyarp, ipaddr, lladdr, ill->ill_phys_addr_length,
8387 8388 flags);
8388 8389 if (entp == NULL || (proxyarp && proxy_ill == NULL)) {
8389 8390 iocp->ioc_error = (entp == NULL ? ENOMEM : 0);
8390 8391 break;
8391 8392 }
8392 8393 }
8393 8394 iocp->ioc_error = err;
8394 8395 }
8395 8396
8396 8397 if (nce != NULL) {
8397 8398 nce_refrele(nce);
8398 8399 }
8399 8400
8400 8401 /*
8401 8402 * If we created an IPMP ARP entry, mark that we've notified ARP.
8402 8403 */
8403 8404 if (entp != NULL)
8404 8405 ipmp_illgrp_mark_arpent(ill->ill_grp, entp);
8405 8406
8406 8407 return (iocp->ioc_error);
8407 8408 }
8408 8409
8409 8410 /*
8410 8411 * Parse an [x]arpreq structure coming down SIOC[GSD][X]ARP ioctls, identify
8411 8412 * the associated sin and refhold and return the associated ipif via `ci'.
8412 8413 */
8413 8414 int
8414 8415 ip_extract_arpreq(queue_t *q, mblk_t *mp, const ip_ioctl_cmd_t *ipip,
8415 8416 cmd_info_t *ci)
8416 8417 {
8417 8418 mblk_t *mp1;
8418 8419 sin_t *sin;
8419 8420 conn_t *connp;
8420 8421 ipif_t *ipif;
8421 8422 ire_t *ire = NULL;
8422 8423 ill_t *ill = NULL;
8423 8424 boolean_t exists;
8424 8425 ip_stack_t *ipst;
8425 8426 struct arpreq *ar;
8426 8427 struct xarpreq *xar;
8427 8428 struct sockaddr_dl *sdl;
8428 8429
8429 8430 /* ioctl comes down on a conn */
8430 8431 ASSERT(!(q->q_flag & QREADR) && q->q_next == NULL);
8431 8432 connp = Q_TO_CONN(q);
8432 8433 if (connp->conn_family == AF_INET6)
8433 8434 return (ENXIO);
8434 8435
8435 8436 ipst = connp->conn_netstack->netstack_ip;
8436 8437
8437 8438 /* Verified in ip_wput_nondata */
8438 8439 mp1 = mp->b_cont->b_cont;
8439 8440
8440 8441 if (ipip->ipi_cmd_type == XARP_CMD) {
8441 8442 ASSERT(MBLKL(mp1) >= sizeof (struct xarpreq));
8442 8443 xar = (struct xarpreq *)mp1->b_rptr;
8443 8444 sin = (sin_t *)&xar->xarp_pa;
8444 8445 sdl = &xar->xarp_ha;
8445 8446
8446 8447 if (sdl->sdl_family != AF_LINK || sin->sin_family != AF_INET)
8447 8448 return (ENXIO);
8448 8449 if (sdl->sdl_nlen >= LIFNAMSIZ)
8449 8450 return (EINVAL);
8450 8451 } else {
8451 8452 ASSERT(ipip->ipi_cmd_type == ARP_CMD);
8452 8453 ASSERT(MBLKL(mp1) >= sizeof (struct arpreq));
8453 8454 ar = (struct arpreq *)mp1->b_rptr;
8454 8455 sin = (sin_t *)&ar->arp_pa;
8455 8456 }
8456 8457
8457 8458 if (ipip->ipi_cmd_type == XARP_CMD && sdl->sdl_nlen != 0) {
8458 8459 ipif = ipif_lookup_on_name(sdl->sdl_data, sdl->sdl_nlen,
8459 8460 B_FALSE, &exists, B_FALSE, ALL_ZONES, ipst);
8460 8461 if (ipif == NULL)
8461 8462 return (ENXIO);
8462 8463 if (ipif->ipif_id != 0) {
8463 8464 ipif_refrele(ipif);
8464 8465 return (ENXIO);
8465 8466 }
8466 8467 } else {
8467 8468 /*
8468 8469 * Either an SIOC[DGS]ARP or an SIOC[DGS]XARP with an sdl_nlen
8469 8470 * of 0: use the IP address to find the ipif. If the IP
8470 8471 * address is an IPMP test address, ire_ftable_lookup() will
8471 8472 * find the wrong ill, so we first do an ipif_lookup_addr().
8472 8473 */
8473 8474 ipif = ipif_lookup_addr(sin->sin_addr.s_addr, NULL, ALL_ZONES,
8474 8475 ipst);
8475 8476 if (ipif == NULL) {
8476 8477 ire = ire_ftable_lookup_v4(sin->sin_addr.s_addr,
8477 8478 0, 0, IRE_IF_RESOLVER, NULL, ALL_ZONES,
8478 8479 NULL, MATCH_IRE_TYPE, 0, ipst, NULL);
8479 8480 if (ire == NULL || ((ill = ire->ire_ill) == NULL)) {
8480 8481 if (ire != NULL)
8481 8482 ire_refrele(ire);
8482 8483 return (ENXIO);
8483 8484 }
8484 8485 ASSERT(ire != NULL && ill != NULL);
8485 8486 ipif = ill->ill_ipif;
8486 8487 ipif_refhold(ipif);
8487 8488 ire_refrele(ire);
8488 8489 }
8489 8490 }
8490 8491
8491 8492 if (ipif->ipif_ill->ill_net_type != IRE_IF_RESOLVER) {
8492 8493 ipif_refrele(ipif);
8493 8494 return (ENXIO);
8494 8495 }
8495 8496
8496 8497 ci->ci_sin = sin;
8497 8498 ci->ci_ipif = ipif;
8498 8499 return (0);
8499 8500 }
8500 8501
8501 8502 /*
8502 8503 * Link or unlink the illgrp on IPMP meta-interface `ill' depending on the
8503 8504 * value of `ioccmd'. While an illgrp is linked to an ipmp_grp_t, it is
8504 8505 * accessible from that ipmp_grp_t, which means SIOCSLIFGROUPNAME can look it
8505 8506 * up and thus an ill can join that illgrp.
8506 8507 *
8507 8508 * We use I_PLINK/I_PUNLINK to do the link/unlink operations rather than
8508 8509 * open()/close() primarily because close() is not allowed to fail or block
8509 8510 * forever. On the other hand, I_PUNLINK *can* fail, and there's no reason
8510 8511 * why anyone should ever need to I_PUNLINK an in-use IPMP stream. To ensure
8511 8512 * symmetric behavior (e.g., doing an I_PLINK after and I_PUNLINK undoes the
8512 8513 * I_PUNLINK) we defer linking to I_PLINK. Separately, we also fail attempts
8513 8514 * to I_LINK since I_UNLINK is optional and we'd end up in an inconsistent
8514 8515 * state if I_UNLINK didn't occur.
8515 8516 *
8516 8517 * Note that for each plumb/unplumb operation, we may end up here more than
8517 8518 * once because of the way ifconfig works. However, it's OK to link the same
8518 8519 * illgrp more than once, or unlink an illgrp that's already unlinked.
8519 8520 */
8520 8521 static int
8521 8522 ip_sioctl_plink_ipmp(ill_t *ill, int ioccmd)
8522 8523 {
8523 8524 int err;
8524 8525 ip_stack_t *ipst = ill->ill_ipst;
8525 8526
8526 8527 ASSERT(IS_IPMP(ill));
8527 8528 ASSERT(IAM_WRITER_ILL(ill));
8528 8529
8529 8530 switch (ioccmd) {
8530 8531 case I_LINK:
8531 8532 return (ENOTSUP);
8532 8533
8533 8534 case I_PLINK:
8534 8535 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
8535 8536 ipmp_illgrp_link_grp(ill->ill_grp, ill->ill_phyint->phyint_grp);
8536 8537 rw_exit(&ipst->ips_ipmp_lock);
8537 8538 break;
8538 8539
8539 8540 case I_PUNLINK:
8540 8541 /*
8541 8542 * Require all UP ipifs be brought down prior to unlinking the
8542 8543 * illgrp so any associated IREs (and other state) is torched.
8543 8544 */
8544 8545 if (ill->ill_ipif_up_count + ill->ill_ipif_dup_count > 0)
8545 8546 return (EBUSY);
8546 8547
8547 8548 /*
8548 8549 * NOTE: We hold ipmp_lock across the unlink to prevent a race
8549 8550 * with an SIOCSLIFGROUPNAME request from an ill trying to
8550 8551 * join this group. Specifically: ills trying to join grab
8551 8552 * ipmp_lock and bump a "pending join" counter checked by
8552 8553 * ipmp_illgrp_unlink_grp(). During the unlink no new pending
8553 8554 * joins can occur (since we have ipmp_lock). Once we drop
8554 8555 * ipmp_lock, subsequent SIOCSLIFGROUPNAME requests will not
8555 8556 * find the illgrp (since we unlinked it) and will return
8556 8557 * EAFNOSUPPORT. This will then take them back through the
8557 8558 * IPMP meta-interface plumbing logic in ifconfig, and thus
8558 8559 * back through I_PLINK above.
8559 8560 */
8560 8561 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
8561 8562 err = ipmp_illgrp_unlink_grp(ill->ill_grp);
8562 8563 rw_exit(&ipst->ips_ipmp_lock);
8563 8564 return (err);
8564 8565 default:
8565 8566 break;
8566 8567 }
8567 8568 return (0);
8568 8569 }
8569 8570
8570 8571 /*
8571 8572 * Do I_PLINK/I_LINK or I_PUNLINK/I_UNLINK with consistency checks and also
8572 8573 * atomically set/clear the muxids. Also complete the ioctl by acking or
8573 8574 * naking it. Note that the code is structured such that the link type,
8574 8575 * whether it's persistent or not, is treated equally. ifconfig(1M) and
8575 8576 * its clones use the persistent link, while pppd(1M) and perhaps many
8576 8577 * other daemons may use non-persistent link. When combined with some
8577 8578 * ill_t states, linking and unlinking lower streams may be used as
8578 8579 * indicators of dynamic re-plumbing events [see PSARC/1999/348].
8579 8580 */
8580 8581 /* ARGSUSED */
8581 8582 void
8582 8583 ip_sioctl_plink(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg)
8583 8584 {
8584 8585 mblk_t *mp1;
8585 8586 struct linkblk *li;
8586 8587 int ioccmd = ((struct iocblk *)mp->b_rptr)->ioc_cmd;
8587 8588 int err = 0;
8588 8589
8589 8590 ASSERT(ioccmd == I_PLINK || ioccmd == I_PUNLINK ||
8590 8591 ioccmd == I_LINK || ioccmd == I_UNLINK);
8591 8592
8592 8593 mp1 = mp->b_cont; /* This is the linkblk info */
8593 8594 li = (struct linkblk *)mp1->b_rptr;
8594 8595
8595 8596 err = ip_sioctl_plink_ipmod(ipsq, q, mp, ioccmd, li);
8596 8597 if (err == EINPROGRESS)
8597 8598 return;
8598 8599 if (err == 0)
8599 8600 miocack(q, mp, 0, 0);
8600 8601 else
8601 8602 miocnak(q, mp, 0, err);
8602 8603
8603 8604 /* Conn was refheld in ip_sioctl_copyin_setup */
8604 8605 if (CONN_Q(q)) {
8605 8606 CONN_DEC_IOCTLREF(Q_TO_CONN(q));
8606 8607 CONN_OPER_PENDING_DONE(Q_TO_CONN(q));
8607 8608 }
8608 8609 }
8609 8610
8610 8611 /*
8611 8612 * Process I_{P}LINK and I_{P}UNLINK requests named by `ioccmd' and pointed to
8612 8613 * by `mp' and `li' for the IP module stream (if li->q_bot is in fact an IP
8613 8614 * module stream).
8614 8615 * Returns zero on success, EINPROGRESS if the operation is still pending, or
8615 8616 * an error code on failure.
8616 8617 */
8617 8618 static int
8618 8619 ip_sioctl_plink_ipmod(ipsq_t *ipsq, queue_t *q, mblk_t *mp, int ioccmd,
8619 8620 struct linkblk *li)
8620 8621 {
8621 8622 int err = 0;
8622 8623 ill_t *ill;
8623 8624 queue_t *ipwq, *dwq;
8624 8625 const char *name;
8625 8626 struct qinit *qinfo;
8626 8627 boolean_t islink = (ioccmd == I_PLINK || ioccmd == I_LINK);
8627 8628 boolean_t entered_ipsq = B_FALSE;
8628 8629 boolean_t is_ip = B_FALSE;
8629 8630 arl_t *arl;
8630 8631
8631 8632 /*
8632 8633 * Walk the lower stream to verify it's the IP module stream.
8633 8634 * The IP module is identified by its name, wput function,
8634 8635 * and non-NULL q_next. STREAMS ensures that the lower stream
8635 8636 * (li->l_qbot) will not vanish until this ioctl completes.
8636 8637 */
8637 8638 for (ipwq = li->l_qbot; ipwq != NULL; ipwq = ipwq->q_next) {
8638 8639 qinfo = ipwq->q_qinfo;
8639 8640 name = qinfo->qi_minfo->mi_idname;
8640 8641 if (name != NULL && strcmp(name, ip_mod_info.mi_idname) == 0 &&
8641 8642 qinfo->qi_putp != (pfi_t)ip_lwput && ipwq->q_next != NULL) {
8642 8643 is_ip = B_TRUE;
8643 8644 break;
8644 8645 }
8645 8646 if (name != NULL && strcmp(name, arp_mod_info.mi_idname) == 0 &&
8646 8647 qinfo->qi_putp != (pfi_t)ip_lwput && ipwq->q_next != NULL) {
8647 8648 break;
8648 8649 }
8649 8650 }
8650 8651
8651 8652 /*
8652 8653 * If this isn't an IP module stream, bail.
8653 8654 */
8654 8655 if (ipwq == NULL)
8655 8656 return (0);
8656 8657
8657 8658 if (!is_ip) {
8658 8659 arl = (arl_t *)ipwq->q_ptr;
8659 8660 ill = arl_to_ill(arl);
8660 8661 if (ill == NULL)
8661 8662 return (0);
8662 8663 } else {
8663 8664 ill = ipwq->q_ptr;
8664 8665 }
8665 8666 ASSERT(ill != NULL);
8666 8667
8667 8668 if (ipsq == NULL) {
8668 8669 ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_sioctl_plink,
8669 8670 NEW_OP, B_FALSE);
8670 8671 if (ipsq == NULL) {
8671 8672 if (!is_ip)
8672 8673 ill_refrele(ill);
8673 8674 return (EINPROGRESS);
8674 8675 }
8675 8676 entered_ipsq = B_TRUE;
8676 8677 }
8677 8678 ASSERT(IAM_WRITER_ILL(ill));
8678 8679 mutex_enter(&ill->ill_lock);
8679 8680 if (!is_ip) {
8680 8681 if (islink && ill->ill_muxid == 0) {
8681 8682 /*
8682 8683 * Plumbing has to be done with IP plumbed first, arp
8683 8684 * second, but here we have arp being plumbed first.
8684 8685 */
8685 8686 mutex_exit(&ill->ill_lock);
8686 8687 if (entered_ipsq)
8687 8688 ipsq_exit(ipsq);
8688 8689 ill_refrele(ill);
8689 8690 return (EINVAL);
8690 8691 }
8691 8692 }
8692 8693 mutex_exit(&ill->ill_lock);
8693 8694 if (!is_ip) {
8694 8695 arl->arl_muxid = islink ? li->l_index : 0;
8695 8696 ill_refrele(ill);
8696 8697 goto done;
8697 8698 }
8698 8699
8699 8700 if (IS_IPMP(ill) && (err = ip_sioctl_plink_ipmp(ill, ioccmd)) != 0)
8700 8701 goto done;
8701 8702
8702 8703 /*
8703 8704 * As part of I_{P}LINKing, stash the number of downstream modules and
8704 8705 * the read queue of the module immediately below IP in the ill.
8705 8706 * These are used during the capability negotiation below.
8706 8707 */
8707 8708 ill->ill_lmod_rq = NULL;
8708 8709 ill->ill_lmod_cnt = 0;
8709 8710 if (islink && ((dwq = ipwq->q_next) != NULL)) {
8710 8711 ill->ill_lmod_rq = RD(dwq);
8711 8712 for (; dwq != NULL; dwq = dwq->q_next)
8712 8713 ill->ill_lmod_cnt++;
8713 8714 }
8714 8715
8715 8716 ill->ill_muxid = islink ? li->l_index : 0;
8716 8717
8717 8718 /*
8718 8719 * Mark the ipsq busy until the capability operations initiated below
8719 8720 * complete. The PLINK/UNLINK ioctl itself completes when our caller
8720 8721 * returns, but the capability operation may complete asynchronously
8721 8722 * much later.
8722 8723 */
8723 8724 ipsq_current_start(ipsq, ill->ill_ipif, ioccmd);
8724 8725 /*
8725 8726 * If there's at least one up ipif on this ill, then we're bound to
8726 8727 * the underlying driver via DLPI. In that case, renegotiate
8727 8728 * capabilities to account for any possible change in modules
8728 8729 * interposed between IP and the driver.
8729 8730 */
8730 8731 if (ill->ill_ipif_up_count > 0) {
8731 8732 if (islink)
8732 8733 ill_capability_probe(ill);
8733 8734 else
8734 8735 ill_capability_reset(ill, B_FALSE);
8735 8736 }
8736 8737 ipsq_current_finish(ipsq);
8737 8738 done:
8738 8739 if (entered_ipsq)
8739 8740 ipsq_exit(ipsq);
8740 8741
8741 8742 return (err);
8742 8743 }
8743 8744
8744 8745 /*
8745 8746 * Search the ioctl command in the ioctl tables and return a pointer
8746 8747 * to the ioctl command information. The ioctl command tables are
8747 8748 * static and fully populated at compile time.
8748 8749 */
8749 8750 ip_ioctl_cmd_t *
8750 8751 ip_sioctl_lookup(int ioc_cmd)
8751 8752 {
8752 8753 int index;
8753 8754 ip_ioctl_cmd_t *ipip;
8754 8755 ip_ioctl_cmd_t *ipip_end;
8755 8756
8756 8757 if (ioc_cmd == IPI_DONTCARE)
8757 8758 return (NULL);
8758 8759
8759 8760 /*
8760 8761 * Do a 2 step search. First search the indexed table
8761 8762 * based on the least significant byte of the ioctl cmd.
8762 8763 * If we don't find a match, then search the misc table
8763 8764 * serially.
8764 8765 */
8765 8766 index = ioc_cmd & 0xFF;
8766 8767 if (index < ip_ndx_ioctl_count) {
8767 8768 ipip = &ip_ndx_ioctl_table[index];
8768 8769 if (ipip->ipi_cmd == ioc_cmd) {
8769 8770 /* Found a match in the ndx table */
8770 8771 return (ipip);
8771 8772 }
8772 8773 }
8773 8774
8774 8775 /* Search the misc table */
8775 8776 ipip_end = &ip_misc_ioctl_table[ip_misc_ioctl_count];
8776 8777 for (ipip = ip_misc_ioctl_table; ipip < ipip_end; ipip++) {
8777 8778 if (ipip->ipi_cmd == ioc_cmd)
8778 8779 /* Found a match in the misc table */
8779 8780 return (ipip);
8780 8781 }
8781 8782
8782 8783 return (NULL);
8783 8784 }
8784 8785
8785 8786 /*
8786 8787 * helper function for ip_sioctl_getsetprop(), which does some sanity checks
8787 8788 */
8788 8789 static boolean_t
8789 8790 getset_ioctl_checks(mblk_t *mp)
8790 8791 {
8791 8792 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
8792 8793 mblk_t *mp1 = mp->b_cont;
8793 8794 mod_ioc_prop_t *pioc;
8794 8795 uint_t flags;
8795 8796 uint_t pioc_size;
8796 8797
8797 8798 /* do sanity checks on various arguments */
8798 8799 if (mp1 == NULL || iocp->ioc_count == 0 ||
8799 8800 iocp->ioc_count == TRANSPARENT) {
8800 8801 return (B_FALSE);
8801 8802 }
8802 8803 if (msgdsize(mp1) < iocp->ioc_count) {
8803 8804 if (!pullupmsg(mp1, iocp->ioc_count))
8804 8805 return (B_FALSE);
8805 8806 }
8806 8807
8807 8808 pioc = (mod_ioc_prop_t *)mp1->b_rptr;
8808 8809
8809 8810 /* sanity checks on mpr_valsize */
8810 8811 pioc_size = sizeof (mod_ioc_prop_t);
8811 8812 if (pioc->mpr_valsize != 0)
8812 8813 pioc_size += pioc->mpr_valsize - 1;
8813 8814
8814 8815 if (iocp->ioc_count != pioc_size)
8815 8816 return (B_FALSE);
8816 8817
8817 8818 flags = pioc->mpr_flags;
8818 8819 if (iocp->ioc_cmd == SIOCSETPROP) {
8819 8820 /*
8820 8821 * One can either reset the value to it's default value or
8821 8822 * change the current value or append/remove the value from
8822 8823 * a multi-valued properties.
8823 8824 */
8824 8825 if ((flags & MOD_PROP_DEFAULT) != MOD_PROP_DEFAULT &&
8825 8826 flags != MOD_PROP_ACTIVE &&
8826 8827 flags != (MOD_PROP_ACTIVE|MOD_PROP_APPEND) &&
8827 8828 flags != (MOD_PROP_ACTIVE|MOD_PROP_REMOVE))
8828 8829 return (B_FALSE);
8829 8830 } else {
8830 8831 ASSERT(iocp->ioc_cmd == SIOCGETPROP);
8831 8832
8832 8833 /*
8833 8834 * One can retrieve only one kind of property information
8834 8835 * at a time.
8835 8836 */
8836 8837 if ((flags & MOD_PROP_ACTIVE) != MOD_PROP_ACTIVE &&
8837 8838 (flags & MOD_PROP_DEFAULT) != MOD_PROP_DEFAULT &&
8838 8839 (flags & MOD_PROP_POSSIBLE) != MOD_PROP_POSSIBLE &&
8839 8840 (flags & MOD_PROP_PERM) != MOD_PROP_PERM)
8840 8841 return (B_FALSE);
8841 8842 }
8842 8843
8843 8844 return (B_TRUE);
8844 8845 }
8845 8846
8846 8847 /*
8847 8848 * process the SIOC{SET|GET}PROP ioctl's
8848 8849 */
8849 8850 /* ARGSUSED */
8850 8851 static void
8851 8852 ip_sioctl_getsetprop(queue_t *q, mblk_t *mp)
8852 8853 {
8853 8854 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
8854 8855 mblk_t *mp1 = mp->b_cont;
8855 8856 mod_ioc_prop_t *pioc;
8856 8857 mod_prop_info_t *ptbl = NULL, *pinfo = NULL;
8857 8858 ip_stack_t *ipst;
8858 8859 netstack_t *stack;
8859 8860 cred_t *cr;
8860 8861 boolean_t set;
8861 8862 int err;
8862 8863
8863 8864 ASSERT(q->q_next == NULL);
8864 8865 ASSERT(CONN_Q(q));
8865 8866
8866 8867 if (!getset_ioctl_checks(mp)) {
8867 8868 miocnak(q, mp, 0, EINVAL);
8868 8869 return;
8869 8870 }
8870 8871 ipst = CONNQ_TO_IPST(q);
8871 8872 stack = ipst->ips_netstack;
8872 8873 pioc = (mod_ioc_prop_t *)mp1->b_rptr;
8873 8874
8874 8875 switch (pioc->mpr_proto) {
8875 8876 case MOD_PROTO_IP:
8876 8877 case MOD_PROTO_IPV4:
8877 8878 case MOD_PROTO_IPV6:
8878 8879 ptbl = ipst->ips_propinfo_tbl;
8879 8880 break;
8880 8881 case MOD_PROTO_RAWIP:
8881 8882 ptbl = stack->netstack_icmp->is_propinfo_tbl;
8882 8883 break;
8883 8884 case MOD_PROTO_TCP:
8884 8885 ptbl = stack->netstack_tcp->tcps_propinfo_tbl;
8885 8886 break;
8886 8887 case MOD_PROTO_UDP:
8887 8888 ptbl = stack->netstack_udp->us_propinfo_tbl;
8888 8889 break;
8889 8890 case MOD_PROTO_SCTP:
8890 8891 ptbl = stack->netstack_sctp->sctps_propinfo_tbl;
8891 8892 break;
8892 8893 default:
8893 8894 miocnak(q, mp, 0, EINVAL);
8894 8895 return;
8895 8896 }
8896 8897
8897 8898 pinfo = mod_prop_lookup(ptbl, pioc->mpr_name, pioc->mpr_proto);
8898 8899 if (pinfo == NULL) {
8899 8900 miocnak(q, mp, 0, ENOENT);
8900 8901 return;
8901 8902 }
8902 8903
8903 8904 set = (iocp->ioc_cmd == SIOCSETPROP) ? B_TRUE : B_FALSE;
8904 8905 if (set && pinfo->mpi_setf != NULL) {
8905 8906 cr = msg_getcred(mp, NULL);
8906 8907 if (cr == NULL)
8907 8908 cr = iocp->ioc_cr;
8908 8909 err = pinfo->mpi_setf(stack, cr, pinfo, pioc->mpr_ifname,
8909 8910 pioc->mpr_val, pioc->mpr_flags);
8910 8911 } else if (!set && pinfo->mpi_getf != NULL) {
8911 8912 err = pinfo->mpi_getf(stack, pinfo, pioc->mpr_ifname,
8912 8913 pioc->mpr_val, pioc->mpr_valsize, pioc->mpr_flags);
8913 8914 } else {
8914 8915 err = EPERM;
8915 8916 }
8916 8917
8917 8918 if (err != 0) {
8918 8919 miocnak(q, mp, 0, err);
8919 8920 } else {
8920 8921 if (set)
8921 8922 miocack(q, mp, 0, 0);
8922 8923 else /* For get, we need to return back the data */
8923 8924 miocack(q, mp, iocp->ioc_count, 0);
8924 8925 }
8925 8926 }
8926 8927
8927 8928 /*
8928 8929 * process the legacy ND_GET, ND_SET ioctl just for {ip|ip6}_forwarding
8929 8930 * as several routing daemons have unfortunately used this 'unpublished'
8930 8931 * but well-known ioctls.
8931 8932 */
8932 8933 /* ARGSUSED */
8933 8934 static void
8934 8935 ip_process_legacy_nddprop(queue_t *q, mblk_t *mp)
8935 8936 {
8936 8937 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
8937 8938 mblk_t *mp1 = mp->b_cont;
8938 8939 char *pname, *pval, *buf;
8939 8940 uint_t bufsize, proto;
8940 8941 mod_prop_info_t *pinfo = NULL;
8941 8942 ip_stack_t *ipst;
8942 8943 int err = 0;
8943 8944
8944 8945 ASSERT(CONN_Q(q));
8945 8946 ipst = CONNQ_TO_IPST(q);
8946 8947
8947 8948 if (iocp->ioc_count == 0 || mp1 == NULL) {
8948 8949 miocnak(q, mp, 0, EINVAL);
8949 8950 return;
8950 8951 }
8951 8952
8952 8953 mp1->b_datap->db_lim[-1] = '\0'; /* Force null termination */
8953 8954 pval = buf = pname = (char *)mp1->b_rptr;
8954 8955 bufsize = MBLKL(mp1);
8955 8956
8956 8957 if (strcmp(pname, "ip_forwarding") == 0) {
8957 8958 pname = "forwarding";
8958 8959 proto = MOD_PROTO_IPV4;
8959 8960 } else if (strcmp(pname, "ip6_forwarding") == 0) {
8960 8961 pname = "forwarding";
8961 8962 proto = MOD_PROTO_IPV6;
8962 8963 } else {
8963 8964 miocnak(q, mp, 0, EINVAL);
8964 8965 return;
8965 8966 }
8966 8967
8967 8968 pinfo = mod_prop_lookup(ipst->ips_propinfo_tbl, pname, proto);
8968 8969
8969 8970 switch (iocp->ioc_cmd) {
8970 8971 case ND_GET:
8971 8972 if ((err = pinfo->mpi_getf(ipst->ips_netstack, pinfo, NULL, buf,
8972 8973 bufsize, 0)) == 0) {
8973 8974 miocack(q, mp, iocp->ioc_count, 0);
8974 8975 return;
8975 8976 }
8976 8977 break;
8977 8978 case ND_SET:
8978 8979 /*
8979 8980 * buffer will have property name and value in the following
8980 8981 * format,
8981 8982 * <property name>'\0'<property value>'\0', extract them;
8982 8983 */
8983 8984 while (*pval++)
8984 8985 noop;
8985 8986
8986 8987 if (!*pval || pval >= (char *)mp1->b_wptr) {
8987 8988 err = EINVAL;
8988 8989 } else if ((err = pinfo->mpi_setf(ipst->ips_netstack, NULL,
8989 8990 pinfo, NULL, pval, 0)) == 0) {
8990 8991 miocack(q, mp, 0, 0);
8991 8992 return;
8992 8993 }
8993 8994 break;
8994 8995 default:
8995 8996 err = EINVAL;
8996 8997 break;
8997 8998 }
8998 8999 miocnak(q, mp, 0, err);
8999 9000 }
9000 9001
9001 9002 /*
9002 9003 * Wrapper function for resuming deferred ioctl processing
9003 9004 * Used for SIOCGDSTINFO, SIOCGIP6ADDRPOLICY, SIOCGMSFILTER,
9004 9005 * SIOCSMSFILTER, SIOCGIPMSFILTER, and SIOCSIPMSFILTER currently.
9005 9006 */
9006 9007 /* ARGSUSED */
9007 9008 void
9008 9009 ip_sioctl_copyin_resume(ipsq_t *dummy_ipsq, queue_t *q, mblk_t *mp,
9009 9010 void *dummy_arg)
9010 9011 {
9011 9012 ip_sioctl_copyin_setup(q, mp);
9012 9013 }
9013 9014
9014 9015 /*
9015 9016 * ip_sioctl_copyin_setup is called by ip_wput_nondata with any M_IOCTL message
9016 9017 * that arrives. Most of the IOCTLs are "socket" IOCTLs which we handle
9017 9018 * in either I_STR or TRANSPARENT form, using the mi_copy facility.
9018 9019 * We establish here the size of the block to be copied in. mi_copyin
9019 9020 * arranges for this to happen, an processing continues in ip_wput_nondata with
9020 9021 * an M_IOCDATA message.
9021 9022 */
9022 9023 void
9023 9024 ip_sioctl_copyin_setup(queue_t *q, mblk_t *mp)
9024 9025 {
9025 9026 int copyin_size;
9026 9027 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
9027 9028 ip_ioctl_cmd_t *ipip;
9028 9029 cred_t *cr;
9029 9030 ip_stack_t *ipst;
9030 9031
9031 9032 if (CONN_Q(q))
9032 9033 ipst = CONNQ_TO_IPST(q);
9033 9034 else
9034 9035 ipst = ILLQ_TO_IPST(q);
9035 9036
9036 9037 ipip = ip_sioctl_lookup(iocp->ioc_cmd);
9037 9038 if (ipip == NULL) {
9038 9039 /*
9039 9040 * The ioctl is not one we understand or own.
9040 9041 * Pass it along to be processed down stream,
9041 9042 * if this is a module instance of IP, else nak
9042 9043 * the ioctl.
9043 9044 */
9044 9045 if (q->q_next == NULL) {
9045 9046 goto nak;
9046 9047 } else {
9047 9048 putnext(q, mp);
9048 9049 return;
9049 9050 }
9050 9051 }
9051 9052
9052 9053 /*
9053 9054 * If this is deferred, then we will do all the checks when we
9054 9055 * come back.
9055 9056 */
9056 9057 if ((iocp->ioc_cmd == SIOCGDSTINFO ||
9057 9058 iocp->ioc_cmd == SIOCGIP6ADDRPOLICY) && !ip6_asp_can_lookup(ipst)) {
9058 9059 ip6_asp_pending_op(q, mp, ip_sioctl_copyin_resume);
9059 9060 return;
9060 9061 }
9061 9062
9062 9063 /*
9063 9064 * Only allow a very small subset of IP ioctls on this stream if
9064 9065 * IP is a module and not a driver. Allowing ioctls to be processed
9065 9066 * in this case may cause assert failures or data corruption.
9066 9067 * Typically G[L]IFFLAGS, SLIFNAME/IF_UNITSEL are the only few
9067 9068 * ioctls allowed on an IP module stream, after which this stream
9068 9069 * normally becomes a multiplexor (at which time the stream head
9069 9070 * will fail all ioctls).
9070 9071 */
9071 9072 if ((q->q_next != NULL) && !(ipip->ipi_flags & IPI_MODOK)) {
9072 9073 goto nak;
9073 9074 }
9074 9075
9075 9076 /* Make sure we have ioctl data to process. */
9076 9077 if (mp->b_cont == NULL && !(ipip->ipi_flags & IPI_NULL_BCONT))
9077 9078 goto nak;
9078 9079
9079 9080 /*
9080 9081 * Prefer dblk credential over ioctl credential; some synthesized
9081 9082 * ioctls have kcred set because there's no way to crhold()
9082 9083 * a credential in some contexts. (ioc_cr is not crfree() by
9083 9084 * the framework; the caller of ioctl needs to hold the reference
9084 9085 * for the duration of the call).
9085 9086 */
9086 9087 cr = msg_getcred(mp, NULL);
9087 9088 if (cr == NULL)
9088 9089 cr = iocp->ioc_cr;
9089 9090
9090 9091 /* Make sure normal users don't send down privileged ioctls */
9091 9092 if ((ipip->ipi_flags & IPI_PRIV) &&
9092 9093 (cr != NULL) && secpolicy_ip_config(cr, B_TRUE) != 0) {
9093 9094 /* We checked the privilege earlier but log it here */
9094 9095 miocnak(q, mp, 0, secpolicy_ip_config(cr, B_FALSE));
9095 9096 return;
9096 9097 }
9097 9098
9098 9099 /*
9099 9100 * The ioctl command tables can only encode fixed length
9100 9101 * ioctl data. If the length is variable, the table will
9101 9102 * encode the length as zero. Such special cases are handled
9102 9103 * below in the switch.
9103 9104 */
9104 9105 if (ipip->ipi_copyin_size != 0) {
9105 9106 mi_copyin(q, mp, NULL, ipip->ipi_copyin_size);
9106 9107 return;
9107 9108 }
9108 9109
9109 9110 switch (iocp->ioc_cmd) {
9110 9111 case O_SIOCGIFCONF:
9111 9112 case SIOCGIFCONF:
9112 9113 /*
9113 9114 * This IOCTL is hilarious. See comments in
9114 9115 * ip_sioctl_get_ifconf for the story.
9115 9116 */
9116 9117 if (iocp->ioc_count == TRANSPARENT)
9117 9118 copyin_size = SIZEOF_STRUCT(ifconf,
9118 9119 iocp->ioc_flag);
9119 9120 else
9120 9121 copyin_size = iocp->ioc_count;
9121 9122 mi_copyin(q, mp, NULL, copyin_size);
9122 9123 return;
9123 9124
9124 9125 case O_SIOCGLIFCONF:
9125 9126 case SIOCGLIFCONF:
9126 9127 copyin_size = SIZEOF_STRUCT(lifconf, iocp->ioc_flag);
9127 9128 mi_copyin(q, mp, NULL, copyin_size);
9128 9129 return;
9129 9130
9130 9131 case SIOCGLIFSRCOF:
9131 9132 copyin_size = SIZEOF_STRUCT(lifsrcof, iocp->ioc_flag);
9132 9133 mi_copyin(q, mp, NULL, copyin_size);
9133 9134 return;
9134 9135
9135 9136 case SIOCGIP6ADDRPOLICY:
9136 9137 ip_sioctl_ip6addrpolicy(q, mp);
9137 9138 ip6_asp_table_refrele(ipst);
9138 9139 return;
9139 9140
9140 9141 case SIOCSIP6ADDRPOLICY:
9141 9142 ip_sioctl_ip6addrpolicy(q, mp);
9142 9143 return;
9143 9144
9144 9145 case SIOCGDSTINFO:
9145 9146 ip_sioctl_dstinfo(q, mp);
9146 9147 ip6_asp_table_refrele(ipst);
9147 9148 return;
9148 9149
9149 9150 case ND_SET:
9150 9151 case ND_GET:
9151 9152 ip_process_legacy_nddprop(q, mp);
9152 9153 return;
9153 9154
9154 9155 case SIOCSETPROP:
9155 9156 case SIOCGETPROP:
9156 9157 ip_sioctl_getsetprop(q, mp);
9157 9158 return;
9158 9159
9159 9160 case I_PLINK:
9160 9161 case I_PUNLINK:
9161 9162 case I_LINK:
9162 9163 case I_UNLINK:
9163 9164 /*
9164 9165 * We treat non-persistent link similarly as the persistent
9165 9166 * link case, in terms of plumbing/unplumbing, as well as
9166 9167 * dynamic re-plumbing events indicator. See comments
9167 9168 * in ip_sioctl_plink() for more.
9168 9169 *
9169 9170 * Request can be enqueued in the 'ipsq' while waiting
9170 9171 * to become exclusive. So bump up the conn ref.
9171 9172 */
9172 9173 if (CONN_Q(q)) {
9173 9174 CONN_INC_REF(Q_TO_CONN(q));
9174 9175 CONN_INC_IOCTLREF(Q_TO_CONN(q))
9175 9176 }
9176 9177 ip_sioctl_plink(NULL, q, mp, NULL);
9177 9178 return;
9178 9179
9179 9180 case IP_IOCTL:
9180 9181 ip_wput_ioctl(q, mp);
9181 9182 return;
|
↓ open down ↓ |
9147 lines elided |
↑ open up ↑ |
9182 9183
9183 9184 case SIOCILB:
9184 9185 /* The ioctl length varies depending on the ILB command. */
9185 9186 copyin_size = iocp->ioc_count;
9186 9187 if (copyin_size < sizeof (ilb_cmd_t))
9187 9188 goto nak;
9188 9189 mi_copyin(q, mp, NULL, copyin_size);
9189 9190 return;
9190 9191
9191 9192 default:
9192 - cmn_err(CE_PANIC, "should not happen ");
9193 + cmn_err(CE_WARN, "Unknown ioctl %d/0x%x slipped through.",
9194 + iocp->ioc_cmd, iocp->ioc_cmd);
9195 + /* FALLTHRU */
9193 9196 }
9194 9197 nak:
9195 9198 if (mp->b_cont != NULL) {
9196 9199 freemsg(mp->b_cont);
9197 9200 mp->b_cont = NULL;
9198 9201 }
9199 9202 iocp->ioc_error = EINVAL;
9200 9203 mp->b_datap->db_type = M_IOCNAK;
9201 9204 iocp->ioc_count = 0;
9202 9205 qreply(q, mp);
9203 9206 }
9204 9207
9205 9208 static void
9206 9209 ip_sioctl_garp_reply(mblk_t *mp, ill_t *ill, void *hwaddr, int flags)
9207 9210 {
9208 9211 struct arpreq *ar;
9209 9212 struct xarpreq *xar;
9210 9213 mblk_t *tmp;
9211 9214 struct iocblk *iocp;
9212 9215 int x_arp_ioctl = B_FALSE;
9213 9216 int *flagsp;
9214 9217 char *storage = NULL;
9215 9218
9216 9219 ASSERT(ill != NULL);
9217 9220
9218 9221 iocp = (struct iocblk *)mp->b_rptr;
9219 9222 ASSERT(iocp->ioc_cmd == SIOCGXARP || iocp->ioc_cmd == SIOCGARP);
9220 9223
9221 9224 tmp = (mp->b_cont)->b_cont; /* xarpreq/arpreq */
9222 9225 if ((iocp->ioc_cmd == SIOCGXARP) ||
9223 9226 (iocp->ioc_cmd == SIOCSXARP)) {
9224 9227 x_arp_ioctl = B_TRUE;
9225 9228 xar = (struct xarpreq *)tmp->b_rptr;
9226 9229 flagsp = &xar->xarp_flags;
9227 9230 storage = xar->xarp_ha.sdl_data;
9228 9231 } else {
9229 9232 ar = (struct arpreq *)tmp->b_rptr;
9230 9233 flagsp = &ar->arp_flags;
9231 9234 storage = ar->arp_ha.sa_data;
9232 9235 }
9233 9236
9234 9237 /*
9235 9238 * We're done if this is not an SIOCG{X}ARP
9236 9239 */
9237 9240 if (x_arp_ioctl) {
9238 9241 storage += ill_xarp_info(&xar->xarp_ha, ill);
9239 9242 if ((ill->ill_phys_addr_length + ill->ill_name_length) >
9240 9243 sizeof (xar->xarp_ha.sdl_data)) {
9241 9244 iocp->ioc_error = EINVAL;
9242 9245 return;
9243 9246 }
9244 9247 }
9245 9248 *flagsp = ATF_INUSE;
9246 9249 /*
9247 9250 * If /sbin/arp told us we are the authority using the "permanent"
9248 9251 * flag, or if this is one of my addresses print "permanent"
9249 9252 * in the /sbin/arp output.
9250 9253 */
9251 9254 if ((flags & NCE_F_MYADDR) || (flags & NCE_F_AUTHORITY))
9252 9255 *flagsp |= ATF_AUTHORITY;
9253 9256 if (flags & NCE_F_NONUD)
9254 9257 *flagsp |= ATF_PERM; /* not subject to aging */
9255 9258 if (flags & NCE_F_PUBLISH)
9256 9259 *flagsp |= ATF_PUBL;
9257 9260 if (hwaddr != NULL) {
9258 9261 *flagsp |= ATF_COM;
9259 9262 bcopy((char *)hwaddr, storage, ill->ill_phys_addr_length);
9260 9263 }
9261 9264 }
9262 9265
9263 9266 /*
9264 9267 * Create a new logical interface. If ipif_id is zero (i.e. not a logical
9265 9268 * interface) create the next available logical interface for this
9266 9269 * physical interface.
9267 9270 * If ipif is NULL (i.e. the lookup didn't find one) attempt to create an
9268 9271 * ipif with the specified name.
9269 9272 *
9270 9273 * If the address family is not AF_UNSPEC then set the address as well.
9271 9274 *
9272 9275 * If ip_sioctl_addr returns EINPROGRESS then the ioctl (the copyout)
9273 9276 * is completed when the DL_BIND_ACK arrive in ip_rput_dlpi_writer.
9274 9277 *
9275 9278 * Executed as a writer on the ill.
9276 9279 * So no lock is needed to traverse the ipif chain, or examine the
9277 9280 * phyint flags.
9278 9281 */
9279 9282 /* ARGSUSED */
9280 9283 int
9281 9284 ip_sioctl_addif(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
9282 9285 ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq)
9283 9286 {
9284 9287 mblk_t *mp1;
9285 9288 struct lifreq *lifr;
9286 9289 boolean_t isv6;
9287 9290 boolean_t exists;
9288 9291 char *name;
9289 9292 char *endp;
9290 9293 char *cp;
9291 9294 int namelen;
9292 9295 ipif_t *ipif;
9293 9296 long id;
9294 9297 ipsq_t *ipsq;
9295 9298 ill_t *ill;
9296 9299 sin_t *sin;
9297 9300 int err = 0;
9298 9301 boolean_t found_sep = B_FALSE;
9299 9302 conn_t *connp;
9300 9303 zoneid_t zoneid;
9301 9304 ip_stack_t *ipst = CONNQ_TO_IPST(q);
9302 9305
9303 9306 ASSERT(q->q_next == NULL);
9304 9307 ip1dbg(("ip_sioctl_addif\n"));
9305 9308 /* Existence of mp1 has been checked in ip_wput_nondata */
9306 9309 mp1 = mp->b_cont->b_cont;
9307 9310 /*
9308 9311 * Null terminate the string to protect against buffer
9309 9312 * overrun. String was generated by user code and may not
9310 9313 * be trusted.
9311 9314 */
9312 9315 lifr = (struct lifreq *)mp1->b_rptr;
9313 9316 lifr->lifr_name[LIFNAMSIZ - 1] = '\0';
9314 9317 name = lifr->lifr_name;
9315 9318 ASSERT(CONN_Q(q));
9316 9319 connp = Q_TO_CONN(q);
9317 9320 isv6 = (connp->conn_family == AF_INET6);
9318 9321 zoneid = connp->conn_zoneid;
9319 9322 namelen = mi_strlen(name);
9320 9323 if (namelen == 0)
9321 9324 return (EINVAL);
9322 9325
9323 9326 exists = B_FALSE;
9324 9327 if ((namelen + 1 == sizeof (ipif_loopback_name)) &&
9325 9328 (mi_strcmp(name, ipif_loopback_name) == 0)) {
9326 9329 /*
9327 9330 * Allow creating lo0 using SIOCLIFADDIF.
9328 9331 * can't be any other writer thread. So can pass null below
9329 9332 * for the last 4 args to ipif_lookup_name.
9330 9333 */
9331 9334 ipif = ipif_lookup_on_name(lifr->lifr_name, namelen, B_TRUE,
9332 9335 &exists, isv6, zoneid, ipst);
9333 9336 /* Prevent any further action */
9334 9337 if (ipif == NULL) {
9335 9338 return (ENOBUFS);
9336 9339 } else if (!exists) {
9337 9340 /* We created the ipif now and as writer */
9338 9341 ipif_refrele(ipif);
9339 9342 return (0);
9340 9343 } else {
9341 9344 ill = ipif->ipif_ill;
9342 9345 ill_refhold(ill);
9343 9346 ipif_refrele(ipif);
9344 9347 }
9345 9348 } else {
9346 9349 /* Look for a colon in the name. */
9347 9350 endp = &name[namelen];
9348 9351 for (cp = endp; --cp > name; ) {
9349 9352 if (*cp == IPIF_SEPARATOR_CHAR) {
9350 9353 found_sep = B_TRUE;
9351 9354 /*
9352 9355 * Reject any non-decimal aliases for plumbing
9353 9356 * of logical interfaces. Aliases with leading
9354 9357 * zeroes are also rejected as they introduce
9355 9358 * ambiguity in the naming of the interfaces.
9356 9359 * Comparing with "0" takes care of all such
9357 9360 * cases.
9358 9361 */
9359 9362 if ((strncmp("0", cp+1, 1)) == 0)
9360 9363 return (EINVAL);
9361 9364
9362 9365 if (ddi_strtol(cp+1, &endp, 10, &id) != 0 ||
9363 9366 id <= 0 || *endp != '\0') {
9364 9367 return (EINVAL);
9365 9368 }
9366 9369 *cp = '\0';
9367 9370 break;
9368 9371 }
9369 9372 }
9370 9373 ill = ill_lookup_on_name(name, B_FALSE, isv6, NULL, ipst);
9371 9374 if (found_sep)
9372 9375 *cp = IPIF_SEPARATOR_CHAR;
9373 9376 if (ill == NULL)
9374 9377 return (ENXIO);
9375 9378 }
9376 9379
9377 9380 ipsq = ipsq_try_enter(NULL, ill, q, mp, ip_process_ioctl, NEW_OP,
9378 9381 B_TRUE);
9379 9382
9380 9383 /*
9381 9384 * Release the refhold due to the lookup, now that we are excl
9382 9385 * or we are just returning
9383 9386 */
9384 9387 ill_refrele(ill);
9385 9388
9386 9389 if (ipsq == NULL)
9387 9390 return (EINPROGRESS);
9388 9391
9389 9392 /* We are now exclusive on the IPSQ */
9390 9393 ASSERT(IAM_WRITER_ILL(ill));
9391 9394
9392 9395 if (found_sep) {
9393 9396 /* Now see if there is an IPIF with this unit number. */
9394 9397 for (ipif = ill->ill_ipif; ipif != NULL;
9395 9398 ipif = ipif->ipif_next) {
9396 9399 if (ipif->ipif_id == id) {
9397 9400 err = EEXIST;
9398 9401 goto done;
9399 9402 }
9400 9403 }
9401 9404 }
9402 9405
9403 9406 /*
9404 9407 * We use IRE_LOCAL for lo0:1 etc. for "receive only" use
9405 9408 * of lo0. Plumbing for lo0:0 happens in ipif_lookup_on_name()
9406 9409 * instead.
9407 9410 */
9408 9411 if ((ipif = ipif_allocate(ill, found_sep ? id : -1, IRE_LOCAL,
9409 9412 B_TRUE, B_TRUE, &err)) == NULL) {
9410 9413 goto done;
9411 9414 }
9412 9415
9413 9416 /* Return created name with ioctl */
9414 9417 (void) sprintf(lifr->lifr_name, "%s%c%d", ill->ill_name,
9415 9418 IPIF_SEPARATOR_CHAR, ipif->ipif_id);
9416 9419 ip1dbg(("created %s\n", lifr->lifr_name));
9417 9420
9418 9421 /* Set address */
9419 9422 sin = (sin_t *)&lifr->lifr_addr;
9420 9423 if (sin->sin_family != AF_UNSPEC) {
9421 9424 err = ip_sioctl_addr(ipif, sin, q, mp,
9422 9425 &ip_ndx_ioctl_table[SIOCLIFADDR_NDX], lifr);
9423 9426 }
9424 9427
9425 9428 done:
9426 9429 ipsq_exit(ipsq);
9427 9430 return (err);
9428 9431 }
9429 9432
9430 9433 /*
9431 9434 * Remove an existing logical interface. If ipif_id is zero (i.e. not a logical
9432 9435 * interface) delete it based on the IP address (on this physical interface).
9433 9436 * Otherwise delete it based on the ipif_id.
9434 9437 * Also, special handling to allow a removeif of lo0.
9435 9438 */
9436 9439 /* ARGSUSED */
9437 9440 int
9438 9441 ip_sioctl_removeif(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9439 9442 ip_ioctl_cmd_t *ipip, void *dummy_if_req)
9440 9443 {
9441 9444 conn_t *connp;
9442 9445 ill_t *ill = ipif->ipif_ill;
9443 9446 boolean_t success;
9444 9447 ip_stack_t *ipst;
9445 9448
9446 9449 ipst = CONNQ_TO_IPST(q);
9447 9450
9448 9451 ASSERT(q->q_next == NULL);
9449 9452 ip1dbg(("ip_sioctl_remove_if(%s:%u %p)\n",
9450 9453 ill->ill_name, ipif->ipif_id, (void *)ipif));
9451 9454 ASSERT(IAM_WRITER_IPIF(ipif));
9452 9455
9453 9456 connp = Q_TO_CONN(q);
9454 9457 /*
9455 9458 * Special case for unplumbing lo0 (the loopback physical interface).
9456 9459 * If unplumbing lo0, the incoming address structure has been
9457 9460 * initialized to all zeros. When unplumbing lo0, all its logical
9458 9461 * interfaces must be removed too.
9459 9462 *
9460 9463 * Note that this interface may be called to remove a specific
9461 9464 * loopback logical interface (eg, lo0:1). But in that case
9462 9465 * ipif->ipif_id != 0 so that the code path for that case is the
9463 9466 * same as any other interface (meaning it skips the code directly
9464 9467 * below).
9465 9468 */
9466 9469 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9467 9470 if (sin->sin_family == AF_UNSPEC &&
9468 9471 (IN6_IS_ADDR_UNSPECIFIED(&((sin6_t *)sin)->sin6_addr))) {
9469 9472 /*
9470 9473 * Mark it condemned. No new ref. will be made to ill.
9471 9474 */
9472 9475 mutex_enter(&ill->ill_lock);
9473 9476 ill->ill_state_flags |= ILL_CONDEMNED;
9474 9477 for (ipif = ill->ill_ipif; ipif != NULL;
9475 9478 ipif = ipif->ipif_next) {
9476 9479 ipif->ipif_state_flags |= IPIF_CONDEMNED;
9477 9480 }
9478 9481 mutex_exit(&ill->ill_lock);
9479 9482
9480 9483 ipif = ill->ill_ipif;
9481 9484 /* unplumb the loopback interface */
9482 9485 ill_delete(ill);
9483 9486 mutex_enter(&connp->conn_lock);
9484 9487 mutex_enter(&ill->ill_lock);
9485 9488
9486 9489 /* Are any references to this ill active */
9487 9490 if (ill_is_freeable(ill)) {
9488 9491 mutex_exit(&ill->ill_lock);
9489 9492 mutex_exit(&connp->conn_lock);
9490 9493 ill_delete_tail(ill);
9491 9494 mi_free(ill);
9492 9495 return (0);
9493 9496 }
9494 9497 success = ipsq_pending_mp_add(connp, ipif,
9495 9498 CONNP_TO_WQ(connp), mp, ILL_FREE);
9496 9499 mutex_exit(&connp->conn_lock);
9497 9500 mutex_exit(&ill->ill_lock);
9498 9501 if (success)
9499 9502 return (EINPROGRESS);
9500 9503 else
9501 9504 return (EINTR);
9502 9505 }
9503 9506 }
9504 9507
9505 9508 if (ipif->ipif_id == 0) {
9506 9509 ipsq_t *ipsq;
9507 9510
9508 9511 /* Find based on address */
9509 9512 if (ipif->ipif_isv6) {
9510 9513 sin6_t *sin6;
9511 9514
9512 9515 if (sin->sin_family != AF_INET6)
9513 9516 return (EAFNOSUPPORT);
9514 9517
9515 9518 sin6 = (sin6_t *)sin;
9516 9519 /* We are a writer, so we should be able to lookup */
9517 9520 ipif = ipif_lookup_addr_exact_v6(&sin6->sin6_addr, ill,
9518 9521 ipst);
9519 9522 } else {
9520 9523 if (sin->sin_family != AF_INET)
9521 9524 return (EAFNOSUPPORT);
9522 9525
9523 9526 /* We are a writer, so we should be able to lookup */
9524 9527 ipif = ipif_lookup_addr_exact(sin->sin_addr.s_addr, ill,
9525 9528 ipst);
9526 9529 }
9527 9530 if (ipif == NULL) {
9528 9531 return (EADDRNOTAVAIL);
9529 9532 }
9530 9533
9531 9534 /*
9532 9535 * It is possible for a user to send an SIOCLIFREMOVEIF with
9533 9536 * lifr_name of the physical interface but with an ip address
9534 9537 * lifr_addr of a logical interface plumbed over it.
9535 9538 * So update ipx_current_ipif now that ipif points to the
9536 9539 * correct one.
9537 9540 */
9538 9541 ipsq = ipif->ipif_ill->ill_phyint->phyint_ipsq;
9539 9542 ipsq->ipsq_xop->ipx_current_ipif = ipif;
9540 9543
9541 9544 /* This is a writer */
9542 9545 ipif_refrele(ipif);
9543 9546 }
9544 9547
9545 9548 /*
9546 9549 * Can not delete instance zero since it is tied to the ill.
9547 9550 */
9548 9551 if (ipif->ipif_id == 0)
9549 9552 return (EBUSY);
9550 9553
9551 9554 mutex_enter(&ill->ill_lock);
9552 9555 ipif->ipif_state_flags |= IPIF_CONDEMNED;
9553 9556 mutex_exit(&ill->ill_lock);
9554 9557
9555 9558 ipif_free(ipif);
9556 9559
9557 9560 mutex_enter(&connp->conn_lock);
9558 9561 mutex_enter(&ill->ill_lock);
9559 9562
9560 9563 /* Are any references to this ipif active */
9561 9564 if (ipif_is_freeable(ipif)) {
9562 9565 mutex_exit(&ill->ill_lock);
9563 9566 mutex_exit(&connp->conn_lock);
9564 9567 ipif_non_duplicate(ipif);
9565 9568 (void) ipif_down_tail(ipif);
9566 9569 ipif_free_tail(ipif); /* frees ipif */
9567 9570 return (0);
9568 9571 }
9569 9572 success = ipsq_pending_mp_add(connp, ipif, CONNP_TO_WQ(connp), mp,
9570 9573 IPIF_FREE);
9571 9574 mutex_exit(&ill->ill_lock);
9572 9575 mutex_exit(&connp->conn_lock);
9573 9576 if (success)
9574 9577 return (EINPROGRESS);
9575 9578 else
9576 9579 return (EINTR);
9577 9580 }
9578 9581
9579 9582 /*
9580 9583 * Restart the removeif ioctl. The refcnt has gone down to 0.
9581 9584 * The ipif is already condemned. So can't find it thru lookups.
9582 9585 */
9583 9586 /* ARGSUSED */
9584 9587 int
9585 9588 ip_sioctl_removeif_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q,
9586 9589 mblk_t *mp, ip_ioctl_cmd_t *ipip, void *dummy_if_req)
9587 9590 {
9588 9591 ill_t *ill = ipif->ipif_ill;
9589 9592
9590 9593 ASSERT(IAM_WRITER_IPIF(ipif));
9591 9594 ASSERT(ipif->ipif_state_flags & IPIF_CONDEMNED);
9592 9595
9593 9596 ip1dbg(("ip_sioctl_removeif_restart(%s:%u %p)\n",
9594 9597 ill->ill_name, ipif->ipif_id, (void *)ipif));
9595 9598
9596 9599 if (ipif->ipif_id == 0 && ill->ill_net_type == IRE_LOOPBACK) {
9597 9600 ASSERT(ill->ill_state_flags & ILL_CONDEMNED);
9598 9601 ill_delete_tail(ill);
9599 9602 mi_free(ill);
9600 9603 return (0);
9601 9604 }
9602 9605
9603 9606 ipif_non_duplicate(ipif);
9604 9607 (void) ipif_down_tail(ipif);
9605 9608 ipif_free_tail(ipif);
9606 9609
9607 9610 return (0);
9608 9611 }
9609 9612
9610 9613 /*
9611 9614 * Set the local interface address using the given prefix and ill_token.
9612 9615 */
9613 9616 /* ARGSUSED */
9614 9617 int
9615 9618 ip_sioctl_prefix(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9616 9619 ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq)
9617 9620 {
9618 9621 int err;
9619 9622 in6_addr_t v6addr;
9620 9623 sin6_t *sin6;
9621 9624 ill_t *ill;
9622 9625 int i;
9623 9626
9624 9627 ip1dbg(("ip_sioctl_prefix(%s:%u %p)\n",
9625 9628 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9626 9629
9627 9630 ASSERT(IAM_WRITER_IPIF(ipif));
9628 9631
9629 9632 if (!ipif->ipif_isv6)
9630 9633 return (EINVAL);
9631 9634
9632 9635 if (sin->sin_family != AF_INET6)
9633 9636 return (EAFNOSUPPORT);
9634 9637
9635 9638 sin6 = (sin6_t *)sin;
9636 9639 v6addr = sin6->sin6_addr;
9637 9640 ill = ipif->ipif_ill;
9638 9641
9639 9642 if (IN6_IS_ADDR_UNSPECIFIED(&v6addr) ||
9640 9643 IN6_IS_ADDR_UNSPECIFIED(&ill->ill_token))
9641 9644 return (EADDRNOTAVAIL);
9642 9645
9643 9646 for (i = 0; i < 4; i++)
9644 9647 sin6->sin6_addr.s6_addr32[i] |= ill->ill_token.s6_addr32[i];
9645 9648
9646 9649 err = ip_sioctl_addr(ipif, sin, q, mp,
9647 9650 &ip_ndx_ioctl_table[SIOCLIFADDR_NDX], dummy_ifreq);
9648 9651 return (err);
9649 9652 }
9650 9653
9651 9654 /*
9652 9655 * Restart entry point to restart the address set operation after the
9653 9656 * refcounts have dropped to zero.
9654 9657 */
9655 9658 /* ARGSUSED */
9656 9659 int
9657 9660 ip_sioctl_prefix_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9658 9661 ip_ioctl_cmd_t *ipip, void *ifreq)
9659 9662 {
9660 9663 ip1dbg(("ip_sioctl_prefix_restart(%s:%u %p)\n",
9661 9664 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9662 9665 return (ip_sioctl_addr_restart(ipif, sin, q, mp, ipip, ifreq));
9663 9666 }
9664 9667
9665 9668 /*
9666 9669 * Set the local interface address.
9667 9670 * Allow an address of all zero when the interface is down.
9668 9671 */
9669 9672 /* ARGSUSED */
9670 9673 int
9671 9674 ip_sioctl_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9672 9675 ip_ioctl_cmd_t *dummy_ipip, void *dummy_ifreq)
9673 9676 {
9674 9677 int err = 0;
9675 9678 in6_addr_t v6addr;
9676 9679 boolean_t need_up = B_FALSE;
9677 9680 ill_t *ill;
9678 9681 int i;
9679 9682
9680 9683 ip1dbg(("ip_sioctl_addr(%s:%u %p)\n",
9681 9684 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9682 9685
9683 9686 ASSERT(IAM_WRITER_IPIF(ipif));
9684 9687
9685 9688 ill = ipif->ipif_ill;
9686 9689 if (ipif->ipif_isv6) {
9687 9690 sin6_t *sin6;
9688 9691 phyint_t *phyi;
9689 9692
9690 9693 if (sin->sin_family != AF_INET6)
9691 9694 return (EAFNOSUPPORT);
9692 9695
9693 9696 sin6 = (sin6_t *)sin;
9694 9697 v6addr = sin6->sin6_addr;
9695 9698 phyi = ill->ill_phyint;
9696 9699
9697 9700 /*
9698 9701 * Enforce that true multicast interfaces have a link-local
9699 9702 * address for logical unit 0.
9700 9703 *
9701 9704 * However for those ipif's for which link-local address was
9702 9705 * not created by default, also allow setting :: as the address.
9703 9706 * This scenario would arise, when we delete an address on ipif
9704 9707 * with logical unit 0, we would want to set :: as the address.
9705 9708 */
9706 9709 if (ipif->ipif_id == 0 &&
9707 9710 (ill->ill_flags & ILLF_MULTICAST) &&
9708 9711 !(ipif->ipif_flags & (IPIF_POINTOPOINT)) &&
9709 9712 !(phyi->phyint_flags & (PHYI_LOOPBACK)) &&
9710 9713 !IN6_IS_ADDR_LINKLOCAL(&v6addr)) {
9711 9714
9712 9715 /*
9713 9716 * if default link-local was not created by kernel for
9714 9717 * this ill, allow setting :: as the address on ipif:0.
9715 9718 */
9716 9719 if (ill->ill_flags & ILLF_NOLINKLOCAL) {
9717 9720 if (!IN6_IS_ADDR_UNSPECIFIED(&v6addr))
9718 9721 return (EADDRNOTAVAIL);
9719 9722 } else {
9720 9723 return (EADDRNOTAVAIL);
9721 9724 }
9722 9725 }
9723 9726
9724 9727 /*
9725 9728 * up interfaces shouldn't have the unspecified address
9726 9729 * unless they also have the IPIF_NOLOCAL flags set and
9727 9730 * have a subnet assigned.
9728 9731 */
9729 9732 if ((ipif->ipif_flags & IPIF_UP) &&
9730 9733 IN6_IS_ADDR_UNSPECIFIED(&v6addr) &&
9731 9734 (!(ipif->ipif_flags & IPIF_NOLOCAL) ||
9732 9735 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) {
9733 9736 return (EADDRNOTAVAIL);
9734 9737 }
9735 9738
9736 9739 if (!ip_local_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask))
9737 9740 return (EADDRNOTAVAIL);
9738 9741 } else {
9739 9742 ipaddr_t addr;
9740 9743
9741 9744 if (sin->sin_family != AF_INET)
9742 9745 return (EAFNOSUPPORT);
9743 9746
9744 9747 addr = sin->sin_addr.s_addr;
9745 9748
9746 9749 /* Allow INADDR_ANY as the local address. */
9747 9750 if (addr != INADDR_ANY &&
9748 9751 !ip_addr_ok_v4(addr, ipif->ipif_net_mask))
9749 9752 return (EADDRNOTAVAIL);
9750 9753
9751 9754 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
9752 9755 }
9753 9756 /*
9754 9757 * verify that the address being configured is permitted by the
9755 9758 * ill_allowed_ips[] for the interface.
9756 9759 */
9757 9760 if (ill->ill_allowed_ips_cnt > 0) {
9758 9761 for (i = 0; i < ill->ill_allowed_ips_cnt; i++) {
9759 9762 if (IN6_ARE_ADDR_EQUAL(&ill->ill_allowed_ips[i],
9760 9763 &v6addr))
9761 9764 break;
9762 9765 }
9763 9766 if (i == ill->ill_allowed_ips_cnt) {
9764 9767 pr_addr_dbg("!allowed addr %s\n", AF_INET6, &v6addr);
9765 9768 return (EPERM);
9766 9769 }
9767 9770 }
9768 9771 /*
9769 9772 * Even if there is no change we redo things just to rerun
9770 9773 * ipif_set_default.
9771 9774 */
9772 9775 if (ipif->ipif_flags & IPIF_UP) {
9773 9776 /*
9774 9777 * Setting a new local address, make sure
9775 9778 * we have net and subnet bcast ire's for
9776 9779 * the old address if we need them.
9777 9780 */
9778 9781 /*
9779 9782 * If the interface is already marked up,
9780 9783 * we call ipif_down which will take care
9781 9784 * of ditching any IREs that have been set
9782 9785 * up based on the old interface address.
9783 9786 */
9784 9787 err = ipif_logical_down(ipif, q, mp);
9785 9788 if (err == EINPROGRESS)
9786 9789 return (err);
9787 9790 (void) ipif_down_tail(ipif);
9788 9791 need_up = 1;
9789 9792 }
9790 9793
9791 9794 err = ip_sioctl_addr_tail(ipif, sin, q, mp, need_up);
9792 9795 return (err);
9793 9796 }
9794 9797
9795 9798 int
9796 9799 ip_sioctl_addr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9797 9800 boolean_t need_up)
9798 9801 {
9799 9802 in6_addr_t v6addr;
9800 9803 in6_addr_t ov6addr;
9801 9804 ipaddr_t addr;
9802 9805 sin6_t *sin6;
9803 9806 int sinlen;
9804 9807 int err = 0;
9805 9808 ill_t *ill = ipif->ipif_ill;
9806 9809 boolean_t need_dl_down;
9807 9810 boolean_t need_arp_down;
9808 9811 struct iocblk *iocp;
9809 9812
9810 9813 iocp = (mp != NULL) ? (struct iocblk *)mp->b_rptr : NULL;
9811 9814
9812 9815 ip1dbg(("ip_sioctl_addr_tail(%s:%u %p)\n",
9813 9816 ill->ill_name, ipif->ipif_id, (void *)ipif));
9814 9817 ASSERT(IAM_WRITER_IPIF(ipif));
9815 9818
9816 9819 /* Must cancel any pending timer before taking the ill_lock */
9817 9820 if (ipif->ipif_recovery_id != 0)
9818 9821 (void) untimeout(ipif->ipif_recovery_id);
9819 9822 ipif->ipif_recovery_id = 0;
9820 9823
9821 9824 if (ipif->ipif_isv6) {
9822 9825 sin6 = (sin6_t *)sin;
9823 9826 v6addr = sin6->sin6_addr;
9824 9827 sinlen = sizeof (struct sockaddr_in6);
9825 9828 } else {
9826 9829 addr = sin->sin_addr.s_addr;
9827 9830 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
9828 9831 sinlen = sizeof (struct sockaddr_in);
9829 9832 }
9830 9833 mutex_enter(&ill->ill_lock);
9831 9834 ov6addr = ipif->ipif_v6lcl_addr;
9832 9835 ipif->ipif_v6lcl_addr = v6addr;
9833 9836 sctp_update_ipif_addr(ipif, ov6addr);
9834 9837 ipif->ipif_addr_ready = 0;
9835 9838
9836 9839 ip_rts_newaddrmsg(RTM_CHGADDR, 0, ipif, RTSQ_DEFAULT);
9837 9840
9838 9841 /*
9839 9842 * If the interface was previously marked as a duplicate, then since
9840 9843 * we've now got a "new" address, it should no longer be considered a
9841 9844 * duplicate -- even if the "new" address is the same as the old one.
9842 9845 * Note that if all ipifs are down, we may have a pending ARP down
9843 9846 * event to handle. This is because we want to recover from duplicates
9844 9847 * and thus delay tearing down ARP until the duplicates have been
9845 9848 * removed or disabled.
9846 9849 */
9847 9850 need_dl_down = need_arp_down = B_FALSE;
9848 9851 if (ipif->ipif_flags & IPIF_DUPLICATE) {
9849 9852 need_arp_down = !need_up;
9850 9853 ipif->ipif_flags &= ~IPIF_DUPLICATE;
9851 9854 if (--ill->ill_ipif_dup_count == 0 && !need_up &&
9852 9855 ill->ill_ipif_up_count == 0 && ill->ill_dl_up) {
9853 9856 need_dl_down = B_TRUE;
9854 9857 }
9855 9858 }
9856 9859
9857 9860 ipif_set_default(ipif);
9858 9861
9859 9862 /*
9860 9863 * If we've just manually set the IPv6 link-local address (0th ipif),
9861 9864 * tag the ill so that future updates to the interface ID don't result
9862 9865 * in this address getting automatically reconfigured from under the
9863 9866 * administrator.
9864 9867 */
9865 9868 if (ipif->ipif_isv6 && ipif->ipif_id == 0) {
9866 9869 if (iocp == NULL || (iocp->ioc_cmd == SIOCSLIFADDR &&
9867 9870 !IN6_IS_ADDR_UNSPECIFIED(&v6addr)))
9868 9871 ill->ill_manual_linklocal = 1;
9869 9872 }
9870 9873
9871 9874 /*
9872 9875 * When publishing an interface address change event, we only notify
9873 9876 * the event listeners of the new address. It is assumed that if they
9874 9877 * actively care about the addresses assigned that they will have
9875 9878 * already discovered the previous address assigned (if there was one.)
9876 9879 *
9877 9880 * Don't attach nic event message for SIOCLIFADDIF ioctl.
9878 9881 */
9879 9882 if (iocp != NULL && iocp->ioc_cmd != SIOCLIFADDIF) {
9880 9883 ill_nic_event_dispatch(ill, MAP_IPIF_ID(ipif->ipif_id),
9881 9884 NE_ADDRESS_CHANGE, sin, sinlen);
9882 9885 }
9883 9886
9884 9887 mutex_exit(&ill->ill_lock);
9885 9888
9886 9889 if (need_up) {
9887 9890 /*
9888 9891 * Now bring the interface back up. If this
9889 9892 * is the only IPIF for the ILL, ipif_up
9890 9893 * will have to re-bind to the device, so
9891 9894 * we may get back EINPROGRESS, in which
9892 9895 * case, this IOCTL will get completed in
9893 9896 * ip_rput_dlpi when we see the DL_BIND_ACK.
9894 9897 */
9895 9898 err = ipif_up(ipif, q, mp);
9896 9899 } else {
9897 9900 /* Perhaps ilgs should use this ill */
9898 9901 update_conn_ill(NULL, ill->ill_ipst);
9899 9902 }
9900 9903
9901 9904 if (need_dl_down)
9902 9905 ill_dl_down(ill);
9903 9906
9904 9907 if (need_arp_down && !ill->ill_isv6)
9905 9908 (void) ipif_arp_down(ipif);
9906 9909
9907 9910 /*
9908 9911 * The default multicast interface might have changed (for
9909 9912 * instance if the IPv6 scope of the address changed)
9910 9913 */
9911 9914 ire_increment_multicast_generation(ill->ill_ipst, ill->ill_isv6);
9912 9915
9913 9916 return (err);
9914 9917 }
9915 9918
9916 9919 /*
9917 9920 * Restart entry point to restart the address set operation after the
9918 9921 * refcounts have dropped to zero.
9919 9922 */
9920 9923 /* ARGSUSED */
9921 9924 int
9922 9925 ip_sioctl_addr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9923 9926 ip_ioctl_cmd_t *ipip, void *ifreq)
9924 9927 {
9925 9928 ip1dbg(("ip_sioctl_addr_restart(%s:%u %p)\n",
9926 9929 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9927 9930 ASSERT(IAM_WRITER_IPIF(ipif));
9928 9931 (void) ipif_down_tail(ipif);
9929 9932 return (ip_sioctl_addr_tail(ipif, sin, q, mp, B_TRUE));
9930 9933 }
9931 9934
9932 9935 /* ARGSUSED */
9933 9936 int
9934 9937 ip_sioctl_get_addr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9935 9938 ip_ioctl_cmd_t *ipip, void *if_req)
9936 9939 {
9937 9940 sin6_t *sin6 = (struct sockaddr_in6 *)sin;
9938 9941 struct lifreq *lifr = (struct lifreq *)if_req;
9939 9942
9940 9943 ip1dbg(("ip_sioctl_get_addr(%s:%u %p)\n",
9941 9944 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9942 9945 /*
9943 9946 * The net mask and address can't change since we have a
9944 9947 * reference to the ipif. So no lock is necessary.
9945 9948 */
9946 9949 if (ipif->ipif_isv6) {
9947 9950 *sin6 = sin6_null;
9948 9951 sin6->sin6_family = AF_INET6;
9949 9952 sin6->sin6_addr = ipif->ipif_v6lcl_addr;
9950 9953 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
9951 9954 lifr->lifr_addrlen =
9952 9955 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
9953 9956 } else {
9954 9957 *sin = sin_null;
9955 9958 sin->sin_family = AF_INET;
9956 9959 sin->sin_addr.s_addr = ipif->ipif_lcl_addr;
9957 9960 if (ipip->ipi_cmd_type == LIF_CMD) {
9958 9961 lifr->lifr_addrlen =
9959 9962 ip_mask_to_plen(ipif->ipif_net_mask);
9960 9963 }
9961 9964 }
9962 9965 return (0);
9963 9966 }
9964 9967
9965 9968 /*
9966 9969 * Set the destination address for a pt-pt interface.
9967 9970 */
9968 9971 /* ARGSUSED */
9969 9972 int
9970 9973 ip_sioctl_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
9971 9974 ip_ioctl_cmd_t *ipip, void *if_req)
9972 9975 {
9973 9976 int err = 0;
9974 9977 in6_addr_t v6addr;
9975 9978 boolean_t need_up = B_FALSE;
9976 9979
9977 9980 ip1dbg(("ip_sioctl_dstaddr(%s:%u %p)\n",
9978 9981 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
9979 9982 ASSERT(IAM_WRITER_IPIF(ipif));
9980 9983
9981 9984 if (ipif->ipif_isv6) {
9982 9985 sin6_t *sin6;
9983 9986
9984 9987 if (sin->sin_family != AF_INET6)
9985 9988 return (EAFNOSUPPORT);
9986 9989
9987 9990 sin6 = (sin6_t *)sin;
9988 9991 v6addr = sin6->sin6_addr;
9989 9992
9990 9993 if (!ip_remote_addr_ok_v6(&v6addr, &ipif->ipif_v6net_mask))
9991 9994 return (EADDRNOTAVAIL);
9992 9995 } else {
9993 9996 ipaddr_t addr;
9994 9997
9995 9998 if (sin->sin_family != AF_INET)
9996 9999 return (EAFNOSUPPORT);
9997 10000
9998 10001 addr = sin->sin_addr.s_addr;
9999 10002 if (addr != INADDR_ANY &&
10000 10003 !ip_addr_ok_v4(addr, ipif->ipif_net_mask)) {
10001 10004 return (EADDRNOTAVAIL);
10002 10005 }
10003 10006
10004 10007 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
10005 10008 }
10006 10009
10007 10010 if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6pp_dst_addr, &v6addr))
10008 10011 return (0); /* No change */
10009 10012
10010 10013 if (ipif->ipif_flags & IPIF_UP) {
10011 10014 /*
10012 10015 * If the interface is already marked up,
10013 10016 * we call ipif_down which will take care
10014 10017 * of ditching any IREs that have been set
10015 10018 * up based on the old pp dst address.
10016 10019 */
10017 10020 err = ipif_logical_down(ipif, q, mp);
10018 10021 if (err == EINPROGRESS)
10019 10022 return (err);
10020 10023 (void) ipif_down_tail(ipif);
10021 10024 need_up = B_TRUE;
10022 10025 }
10023 10026 /*
10024 10027 * could return EINPROGRESS. If so ioctl will complete in
10025 10028 * ip_rput_dlpi_writer
10026 10029 */
10027 10030 err = ip_sioctl_dstaddr_tail(ipif, sin, q, mp, need_up);
10028 10031 return (err);
10029 10032 }
10030 10033
10031 10034 static int
10032 10035 ip_sioctl_dstaddr_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10033 10036 boolean_t need_up)
10034 10037 {
10035 10038 in6_addr_t v6addr;
10036 10039 ill_t *ill = ipif->ipif_ill;
10037 10040 int err = 0;
10038 10041 boolean_t need_dl_down;
10039 10042 boolean_t need_arp_down;
10040 10043
10041 10044 ip1dbg(("ip_sioctl_dstaddr_tail(%s:%u %p)\n", ill->ill_name,
10042 10045 ipif->ipif_id, (void *)ipif));
10043 10046
10044 10047 /* Must cancel any pending timer before taking the ill_lock */
10045 10048 if (ipif->ipif_recovery_id != 0)
10046 10049 (void) untimeout(ipif->ipif_recovery_id);
10047 10050 ipif->ipif_recovery_id = 0;
10048 10051
10049 10052 if (ipif->ipif_isv6) {
10050 10053 sin6_t *sin6;
10051 10054
10052 10055 sin6 = (sin6_t *)sin;
10053 10056 v6addr = sin6->sin6_addr;
10054 10057 } else {
10055 10058 ipaddr_t addr;
10056 10059
10057 10060 addr = sin->sin_addr.s_addr;
10058 10061 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
10059 10062 }
10060 10063 mutex_enter(&ill->ill_lock);
10061 10064 /* Set point to point destination address. */
10062 10065 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
10063 10066 /*
10064 10067 * Allow this as a means of creating logical
10065 10068 * pt-pt interfaces on top of e.g. an Ethernet.
10066 10069 * XXX Undocumented HACK for testing.
10067 10070 * pt-pt interfaces are created with NUD disabled.
10068 10071 */
10069 10072 ipif->ipif_flags |= IPIF_POINTOPOINT;
10070 10073 ipif->ipif_flags &= ~IPIF_BROADCAST;
10071 10074 if (ipif->ipif_isv6)
10072 10075 ill->ill_flags |= ILLF_NONUD;
10073 10076 }
10074 10077
10075 10078 /*
10076 10079 * If the interface was previously marked as a duplicate, then since
10077 10080 * we've now got a "new" address, it should no longer be considered a
10078 10081 * duplicate -- even if the "new" address is the same as the old one.
10079 10082 * Note that if all ipifs are down, we may have a pending ARP down
10080 10083 * event to handle.
10081 10084 */
10082 10085 need_dl_down = need_arp_down = B_FALSE;
10083 10086 if (ipif->ipif_flags & IPIF_DUPLICATE) {
10084 10087 need_arp_down = !need_up;
10085 10088 ipif->ipif_flags &= ~IPIF_DUPLICATE;
10086 10089 if (--ill->ill_ipif_dup_count == 0 && !need_up &&
10087 10090 ill->ill_ipif_up_count == 0 && ill->ill_dl_up) {
10088 10091 need_dl_down = B_TRUE;
10089 10092 }
10090 10093 }
10091 10094
10092 10095 /*
10093 10096 * If we've just manually set the IPv6 destination link-local address
10094 10097 * (0th ipif), tag the ill so that future updates to the destination
10095 10098 * interface ID (as can happen with interfaces over IP tunnels) don't
10096 10099 * result in this address getting automatically reconfigured from
10097 10100 * under the administrator.
10098 10101 */
10099 10102 if (ipif->ipif_isv6 && ipif->ipif_id == 0)
10100 10103 ill->ill_manual_dst_linklocal = 1;
10101 10104
10102 10105 /* Set the new address. */
10103 10106 ipif->ipif_v6pp_dst_addr = v6addr;
10104 10107 /* Make sure subnet tracks pp_dst */
10105 10108 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
10106 10109 mutex_exit(&ill->ill_lock);
10107 10110
10108 10111 if (need_up) {
10109 10112 /*
10110 10113 * Now bring the interface back up. If this
10111 10114 * is the only IPIF for the ILL, ipif_up
10112 10115 * will have to re-bind to the device, so
10113 10116 * we may get back EINPROGRESS, in which
10114 10117 * case, this IOCTL will get completed in
10115 10118 * ip_rput_dlpi when we see the DL_BIND_ACK.
10116 10119 */
10117 10120 err = ipif_up(ipif, q, mp);
10118 10121 }
10119 10122
10120 10123 if (need_dl_down)
10121 10124 ill_dl_down(ill);
10122 10125 if (need_arp_down && !ipif->ipif_isv6)
10123 10126 (void) ipif_arp_down(ipif);
10124 10127
10125 10128 return (err);
10126 10129 }
10127 10130
10128 10131 /*
10129 10132 * Restart entry point to restart the dstaddress set operation after the
10130 10133 * refcounts have dropped to zero.
10131 10134 */
10132 10135 /* ARGSUSED */
10133 10136 int
10134 10137 ip_sioctl_dstaddr_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10135 10138 ip_ioctl_cmd_t *ipip, void *ifreq)
10136 10139 {
10137 10140 ip1dbg(("ip_sioctl_dstaddr_restart(%s:%u %p)\n",
10138 10141 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10139 10142 (void) ipif_down_tail(ipif);
10140 10143 return (ip_sioctl_dstaddr_tail(ipif, sin, q, mp, B_TRUE));
10141 10144 }
10142 10145
10143 10146 /* ARGSUSED */
10144 10147 int
10145 10148 ip_sioctl_get_dstaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10146 10149 ip_ioctl_cmd_t *ipip, void *if_req)
10147 10150 {
10148 10151 sin6_t *sin6 = (struct sockaddr_in6 *)sin;
10149 10152
10150 10153 ip1dbg(("ip_sioctl_get_dstaddr(%s:%u %p)\n",
10151 10154 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10152 10155 /*
10153 10156 * Get point to point destination address. The addresses can't
10154 10157 * change since we hold a reference to the ipif.
10155 10158 */
10156 10159 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0)
10157 10160 return (EADDRNOTAVAIL);
10158 10161
10159 10162 if (ipif->ipif_isv6) {
10160 10163 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
10161 10164 *sin6 = sin6_null;
10162 10165 sin6->sin6_family = AF_INET6;
10163 10166 sin6->sin6_addr = ipif->ipif_v6pp_dst_addr;
10164 10167 } else {
10165 10168 *sin = sin_null;
10166 10169 sin->sin_family = AF_INET;
10167 10170 sin->sin_addr.s_addr = ipif->ipif_pp_dst_addr;
10168 10171 }
10169 10172 return (0);
10170 10173 }
10171 10174
10172 10175 /*
10173 10176 * Check which flags will change by the given flags being set
10174 10177 * silently ignore flags which userland is not allowed to control.
10175 10178 * (Because these flags may change between SIOCGLIFFLAGS and
10176 10179 * SIOCSLIFFLAGS, and that's outside of userland's control,
10177 10180 * we need to silently ignore them rather than fail.)
10178 10181 */
10179 10182 static void
10180 10183 ip_sioctl_flags_onoff(ipif_t *ipif, uint64_t flags, uint64_t *onp,
10181 10184 uint64_t *offp)
10182 10185 {
10183 10186 ill_t *ill = ipif->ipif_ill;
10184 10187 phyint_t *phyi = ill->ill_phyint;
10185 10188 uint64_t cantchange_flags, intf_flags;
10186 10189 uint64_t turn_on, turn_off;
10187 10190
10188 10191 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10189 10192 cantchange_flags = IFF_CANTCHANGE;
10190 10193 if (IS_IPMP(ill))
10191 10194 cantchange_flags |= IFF_IPMP_CANTCHANGE;
10192 10195 turn_on = (flags ^ intf_flags) & ~cantchange_flags;
10193 10196 turn_off = intf_flags & turn_on;
10194 10197 turn_on ^= turn_off;
10195 10198 *onp = turn_on;
10196 10199 *offp = turn_off;
10197 10200 }
10198 10201
10199 10202 /*
10200 10203 * Set interface flags. Many flags require special handling (e.g.,
10201 10204 * bringing the interface down); see below for details.
10202 10205 *
10203 10206 * NOTE : We really don't enforce that ipif_id zero should be used
10204 10207 * for setting any flags other than IFF_LOGINT_FLAGS. This
10205 10208 * is because applications generally does SICGLIFFLAGS and
10206 10209 * ORs in the new flags (that affects the logical) and does a
10207 10210 * SIOCSLIFFLAGS. Thus, "flags" below could contain bits other
10208 10211 * than IFF_LOGINT_FLAGS. One could check whether "turn_on" - the
10209 10212 * flags that will be turned on is correct with respect to
10210 10213 * ipif_id 0. For backward compatibility reasons, it is not done.
10211 10214 */
10212 10215 /* ARGSUSED */
10213 10216 int
10214 10217 ip_sioctl_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10215 10218 ip_ioctl_cmd_t *ipip, void *if_req)
10216 10219 {
10217 10220 uint64_t turn_on;
10218 10221 uint64_t turn_off;
10219 10222 int err = 0;
10220 10223 phyint_t *phyi;
10221 10224 ill_t *ill;
10222 10225 conn_t *connp;
10223 10226 uint64_t intf_flags;
10224 10227 boolean_t phyint_flags_modified = B_FALSE;
10225 10228 uint64_t flags;
10226 10229 struct ifreq *ifr;
10227 10230 struct lifreq *lifr;
10228 10231 boolean_t set_linklocal = B_FALSE;
10229 10232
10230 10233 ip1dbg(("ip_sioctl_flags(%s:%u %p)\n",
10231 10234 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10232 10235
10233 10236 ASSERT(IAM_WRITER_IPIF(ipif));
10234 10237
10235 10238 ill = ipif->ipif_ill;
10236 10239 phyi = ill->ill_phyint;
10237 10240
10238 10241 if (ipip->ipi_cmd_type == IF_CMD) {
10239 10242 ifr = (struct ifreq *)if_req;
10240 10243 flags = (uint64_t)(ifr->ifr_flags & 0x0000ffff);
10241 10244 } else {
10242 10245 lifr = (struct lifreq *)if_req;
10243 10246 flags = lifr->lifr_flags;
10244 10247 }
10245 10248
10246 10249 intf_flags = ipif->ipif_flags | ill->ill_flags | phyi->phyint_flags;
10247 10250
10248 10251 /*
10249 10252 * Have the flags been set correctly until now?
10250 10253 */
10251 10254 ASSERT((phyi->phyint_flags & ~(IFF_PHYINT_FLAGS)) == 0);
10252 10255 ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0);
10253 10256 ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0);
10254 10257 /*
10255 10258 * Compare the new flags to the old, and partition
10256 10259 * into those coming on and those going off.
10257 10260 * For the 16 bit command keep the bits above bit 16 unchanged.
10258 10261 */
10259 10262 if (ipip->ipi_cmd == SIOCSIFFLAGS)
10260 10263 flags |= intf_flags & ~0xFFFF;
10261 10264
10262 10265 /*
10263 10266 * Explicitly fail attempts to change flags that are always invalid on
10264 10267 * an IPMP meta-interface.
10265 10268 */
10266 10269 if (IS_IPMP(ill) && ((flags ^ intf_flags) & IFF_IPMP_INVALID))
10267 10270 return (EINVAL);
10268 10271
10269 10272 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10270 10273 if ((turn_on|turn_off) == 0)
10271 10274 return (0); /* No change */
10272 10275
10273 10276 /*
10274 10277 * All test addresses must be IFF_DEPRECATED (to ensure source address
10275 10278 * selection avoids them) -- so force IFF_DEPRECATED on, and do not
10276 10279 * allow it to be turned off.
10277 10280 */
10278 10281 if ((turn_off & (IFF_DEPRECATED|IFF_NOFAILOVER)) == IFF_DEPRECATED &&
10279 10282 (turn_on|intf_flags) & IFF_NOFAILOVER)
10280 10283 return (EINVAL);
10281 10284
10282 10285 if ((connp = Q_TO_CONN(q)) == NULL)
10283 10286 return (EINVAL);
10284 10287
10285 10288 /*
10286 10289 * Only vrrp control socket is allowed to change IFF_UP and
10287 10290 * IFF_NOACCEPT flags when IFF_VRRP is set.
10288 10291 */
10289 10292 if ((intf_flags & IFF_VRRP) && ((turn_off | turn_on) & IFF_UP)) {
10290 10293 if (!connp->conn_isvrrp)
10291 10294 return (EINVAL);
10292 10295 }
10293 10296
10294 10297 /*
10295 10298 * The IFF_NOACCEPT flag can only be set on an IFF_VRRP IP address by
10296 10299 * VRRP control socket.
10297 10300 */
10298 10301 if ((turn_off | turn_on) & IFF_NOACCEPT) {
10299 10302 if (!connp->conn_isvrrp || !(intf_flags & IFF_VRRP))
10300 10303 return (EINVAL);
10301 10304 }
10302 10305
10303 10306 if (turn_on & IFF_NOFAILOVER) {
10304 10307 turn_on |= IFF_DEPRECATED;
10305 10308 flags |= IFF_DEPRECATED;
10306 10309 }
10307 10310
10308 10311 /*
10309 10312 * On underlying interfaces, only allow applications to manage test
10310 10313 * addresses -- otherwise, they may get confused when the address
10311 10314 * moves as part of being brought up. Likewise, prevent an
10312 10315 * application-managed test address from being converted to a data
10313 10316 * address. To prevent migration of administratively up addresses in
10314 10317 * the kernel, we don't allow them to be converted either.
10315 10318 */
10316 10319 if (IS_UNDER_IPMP(ill)) {
10317 10320 const uint64_t appflags = IFF_DHCPRUNNING | IFF_ADDRCONF;
10318 10321
10319 10322 if ((turn_on & appflags) && !(flags & IFF_NOFAILOVER))
10320 10323 return (EINVAL);
10321 10324
10322 10325 if ((turn_off & IFF_NOFAILOVER) &&
10323 10326 (flags & (appflags | IFF_UP | IFF_DUPLICATE)))
10324 10327 return (EINVAL);
10325 10328 }
10326 10329
10327 10330 /*
10328 10331 * Only allow IFF_TEMPORARY flag to be set on
10329 10332 * IPv6 interfaces.
10330 10333 */
10331 10334 if ((turn_on & IFF_TEMPORARY) && !(ipif->ipif_isv6))
10332 10335 return (EINVAL);
10333 10336
10334 10337 /*
10335 10338 * cannot turn off IFF_NOXMIT on VNI interfaces.
10336 10339 */
10337 10340 if ((turn_off & IFF_NOXMIT) && IS_VNI(ipif->ipif_ill))
10338 10341 return (EINVAL);
10339 10342
10340 10343 /*
10341 10344 * Don't allow the IFF_ROUTER flag to be turned on on loopback
10342 10345 * interfaces. It makes no sense in that context.
10343 10346 */
10344 10347 if ((turn_on & IFF_ROUTER) && (phyi->phyint_flags & PHYI_LOOPBACK))
10345 10348 return (EINVAL);
10346 10349
10347 10350 /*
10348 10351 * For IPv6 ipif_id 0, don't allow the interface to be up without
10349 10352 * a link local address if IFF_NOLOCAL or IFF_ANYCAST are not set.
10350 10353 * If the link local address isn't set, and can be set, it will get
10351 10354 * set later on in this function.
10352 10355 */
10353 10356 if (ipif->ipif_id == 0 && ipif->ipif_isv6 &&
10354 10357 (flags & IFF_UP) && !(flags & (IFF_NOLOCAL|IFF_ANYCAST)) &&
10355 10358 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr)) {
10356 10359 if (ipif_cant_setlinklocal(ipif))
10357 10360 return (EINVAL);
10358 10361 set_linklocal = B_TRUE;
10359 10362 }
10360 10363
10361 10364 /*
10362 10365 * If we modify physical interface flags, we'll potentially need to
10363 10366 * send up two routing socket messages for the changes (one for the
10364 10367 * IPv4 ill, and another for the IPv6 ill). Note that here.
10365 10368 */
10366 10369 if ((turn_on|turn_off) & IFF_PHYINT_FLAGS)
10367 10370 phyint_flags_modified = B_TRUE;
10368 10371
10369 10372 /*
10370 10373 * All functioning PHYI_STANDBY interfaces start life PHYI_INACTIVE
10371 10374 * (otherwise, we'd immediately use them, defeating standby). Also,
10372 10375 * since PHYI_INACTIVE has a separate meaning when PHYI_STANDBY is not
10373 10376 * set, don't allow PHYI_STANDBY to be set if PHYI_INACTIVE is already
10374 10377 * set, and clear PHYI_INACTIVE if PHYI_STANDBY is being cleared. We
10375 10378 * also don't allow PHYI_STANDBY if VNI is enabled since its semantics
10376 10379 * will not be honored.
10377 10380 */
10378 10381 if (turn_on & PHYI_STANDBY) {
10379 10382 /*
10380 10383 * No need to grab ill_g_usesrc_lock here; see the
10381 10384 * synchronization notes in ip.c.
10382 10385 */
10383 10386 if (ill->ill_usesrc_grp_next != NULL ||
10384 10387 intf_flags & PHYI_INACTIVE)
10385 10388 return (EINVAL);
10386 10389 if (!(flags & PHYI_FAILED)) {
10387 10390 flags |= PHYI_INACTIVE;
10388 10391 turn_on |= PHYI_INACTIVE;
10389 10392 }
10390 10393 }
10391 10394
10392 10395 if (turn_off & PHYI_STANDBY) {
10393 10396 flags &= ~PHYI_INACTIVE;
10394 10397 turn_off |= PHYI_INACTIVE;
10395 10398 }
10396 10399
10397 10400 /*
10398 10401 * PHYI_FAILED and PHYI_INACTIVE are mutually exclusive; fail if both
10399 10402 * would end up on.
10400 10403 */
10401 10404 if ((flags & (PHYI_FAILED | PHYI_INACTIVE)) ==
10402 10405 (PHYI_FAILED | PHYI_INACTIVE))
10403 10406 return (EINVAL);
10404 10407
10405 10408 /*
10406 10409 * If ILLF_ROUTER changes, we need to change the ip forwarding
10407 10410 * status of the interface.
10408 10411 */
10409 10412 if ((turn_on | turn_off) & ILLF_ROUTER) {
10410 10413 err = ill_forward_set(ill, ((turn_on & ILLF_ROUTER) != 0));
10411 10414 if (err != 0)
10412 10415 return (err);
10413 10416 }
10414 10417
10415 10418 /*
10416 10419 * If the interface is not UP and we are not going to
10417 10420 * bring it UP, record the flags and return. When the
10418 10421 * interface comes UP later, the right actions will be
10419 10422 * taken.
10420 10423 */
10421 10424 if (!(ipif->ipif_flags & IPIF_UP) &&
10422 10425 !(turn_on & IPIF_UP)) {
10423 10426 /* Record new flags in their respective places. */
10424 10427 mutex_enter(&ill->ill_lock);
10425 10428 mutex_enter(&ill->ill_phyint->phyint_lock);
10426 10429 ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS);
10427 10430 ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS);
10428 10431 ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS);
10429 10432 ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS);
10430 10433 phyi->phyint_flags |= (turn_on & IFF_PHYINT_FLAGS);
10431 10434 phyi->phyint_flags &= (~turn_off & IFF_PHYINT_FLAGS);
10432 10435 mutex_exit(&ill->ill_lock);
10433 10436 mutex_exit(&ill->ill_phyint->phyint_lock);
10434 10437
10435 10438 /*
10436 10439 * PHYI_FAILED, PHYI_INACTIVE, and PHYI_OFFLINE are all the
10437 10440 * same to the kernel: if any of them has been set by
10438 10441 * userland, the interface cannot be used for data traffic.
10439 10442 */
10440 10443 if ((turn_on|turn_off) &
10441 10444 (PHYI_FAILED | PHYI_INACTIVE | PHYI_OFFLINE)) {
10442 10445 ASSERT(!IS_IPMP(ill));
10443 10446 /*
10444 10447 * It's possible the ill is part of an "anonymous"
10445 10448 * IPMP group rather than a real group. In that case,
10446 10449 * there are no other interfaces in the group and thus
10447 10450 * no need to call ipmp_phyint_refresh_active().
10448 10451 */
10449 10452 if (IS_UNDER_IPMP(ill))
10450 10453 ipmp_phyint_refresh_active(phyi);
10451 10454 }
10452 10455
10453 10456 if (phyint_flags_modified) {
10454 10457 if (phyi->phyint_illv4 != NULL) {
10455 10458 ip_rts_ifmsg(phyi->phyint_illv4->
10456 10459 ill_ipif, RTSQ_DEFAULT);
10457 10460 }
10458 10461 if (phyi->phyint_illv6 != NULL) {
10459 10462 ip_rts_ifmsg(phyi->phyint_illv6->
10460 10463 ill_ipif, RTSQ_DEFAULT);
10461 10464 }
10462 10465 }
10463 10466 /* The default multicast interface might have changed */
10464 10467 ire_increment_multicast_generation(ill->ill_ipst,
10465 10468 ill->ill_isv6);
10466 10469
10467 10470 return (0);
10468 10471 } else if (set_linklocal) {
10469 10472 mutex_enter(&ill->ill_lock);
10470 10473 if (set_linklocal)
10471 10474 ipif->ipif_state_flags |= IPIF_SET_LINKLOCAL;
10472 10475 mutex_exit(&ill->ill_lock);
10473 10476 }
10474 10477
10475 10478 /*
10476 10479 * Disallow IPv6 interfaces coming up that have the unspecified address,
10477 10480 * or point-to-point interfaces with an unspecified destination. We do
10478 10481 * allow the address to be unspecified for IPIF_NOLOCAL interfaces that
10479 10482 * have a subnet assigned, which is how in.ndpd currently manages its
10480 10483 * onlink prefix list when no addresses are configured with those
10481 10484 * prefixes.
10482 10485 */
10483 10486 if (ipif->ipif_isv6 &&
10484 10487 ((IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) &&
10485 10488 (!(ipif->ipif_flags & IPIF_NOLOCAL) && !(turn_on & IPIF_NOLOCAL) ||
10486 10489 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6subnet))) ||
10487 10490 ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
10488 10491 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6pp_dst_addr)))) {
10489 10492 return (EINVAL);
10490 10493 }
10491 10494
10492 10495 /*
10493 10496 * Prevent IPv4 point-to-point interfaces with a 0.0.0.0 destination
10494 10497 * from being brought up.
10495 10498 */
10496 10499 if (!ipif->ipif_isv6 &&
10497 10500 ((ipif->ipif_flags & IPIF_POINTOPOINT) &&
10498 10501 ipif->ipif_pp_dst_addr == INADDR_ANY)) {
10499 10502 return (EINVAL);
10500 10503 }
10501 10504
10502 10505 /*
10503 10506 * If we are going to change one or more of the flags that are
10504 10507 * IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT, IPIF_NOLOCAL, ILLF_NOARP,
10505 10508 * ILLF_NONUD, IPIF_PRIVATE, IPIF_ANYCAST, IPIF_PREFERRED, and
10506 10509 * IPIF_NOFAILOVER, we will take special action. This is
10507 10510 * done by bring the ipif down, changing the flags and bringing
10508 10511 * it back up again. For IPIF_NOFAILOVER, the act of bringing it
10509 10512 * back up will trigger the address to be moved.
10510 10513 *
10511 10514 * If we are going to change IFF_NOACCEPT, we need to bring
10512 10515 * all the ipifs down then bring them up again. The act of
10513 10516 * bringing all the ipifs back up will trigger the local
10514 10517 * ires being recreated with "no_accept" set/cleared.
10515 10518 *
10516 10519 * Note that ILLF_NOACCEPT is always set separately from the
10517 10520 * other flags.
10518 10521 */
10519 10522 if ((turn_on|turn_off) &
10520 10523 (IPIF_UP|IPIF_DEPRECATED|IPIF_NOXMIT|IPIF_NOLOCAL|ILLF_NOARP|
10521 10524 ILLF_NONUD|IPIF_PRIVATE|IPIF_ANYCAST|IPIF_PREFERRED|
10522 10525 IPIF_NOFAILOVER)) {
10523 10526 /*
10524 10527 * ipif_down() will ire_delete bcast ire's for the subnet,
10525 10528 * while the ire_identical_ref tracks the case of IRE_BROADCAST
10526 10529 * entries shared between multiple ipifs on the same subnet.
10527 10530 */
10528 10531 if (((ipif->ipif_flags | turn_on) & IPIF_UP) &&
10529 10532 !(turn_off & IPIF_UP)) {
10530 10533 if (ipif->ipif_flags & IPIF_UP)
10531 10534 ill->ill_logical_down = 1;
10532 10535 turn_on &= ~IPIF_UP;
10533 10536 }
10534 10537 err = ipif_down(ipif, q, mp);
10535 10538 ip1dbg(("ipif_down returns %d err ", err));
10536 10539 if (err == EINPROGRESS)
10537 10540 return (err);
10538 10541 (void) ipif_down_tail(ipif);
10539 10542 } else if ((turn_on|turn_off) & ILLF_NOACCEPT) {
10540 10543 /*
10541 10544 * If we can quiesce the ill, then continue. If not, then
10542 10545 * ip_sioctl_flags_tail() will be called from
10543 10546 * ipif_ill_refrele_tail().
10544 10547 */
10545 10548 ill_down_ipifs(ill, B_TRUE);
10546 10549
10547 10550 mutex_enter(&connp->conn_lock);
10548 10551 mutex_enter(&ill->ill_lock);
10549 10552 if (!ill_is_quiescent(ill)) {
10550 10553 boolean_t success;
10551 10554
10552 10555 success = ipsq_pending_mp_add(connp, ill->ill_ipif,
10553 10556 q, mp, ILL_DOWN);
10554 10557 mutex_exit(&ill->ill_lock);
10555 10558 mutex_exit(&connp->conn_lock);
10556 10559 return (success ? EINPROGRESS : EINTR);
10557 10560 }
10558 10561 mutex_exit(&ill->ill_lock);
10559 10562 mutex_exit(&connp->conn_lock);
10560 10563 }
10561 10564 return (ip_sioctl_flags_tail(ipif, flags, q, mp));
10562 10565 }
10563 10566
10564 10567 static int
10565 10568 ip_sioctl_flags_tail(ipif_t *ipif, uint64_t flags, queue_t *q, mblk_t *mp)
10566 10569 {
10567 10570 ill_t *ill;
10568 10571 phyint_t *phyi;
10569 10572 uint64_t turn_on, turn_off;
10570 10573 boolean_t phyint_flags_modified = B_FALSE;
10571 10574 int err = 0;
10572 10575 boolean_t set_linklocal = B_FALSE;
10573 10576
10574 10577 ip1dbg(("ip_sioctl_flags_tail(%s:%u)\n",
10575 10578 ipif->ipif_ill->ill_name, ipif->ipif_id));
10576 10579
10577 10580 ASSERT(IAM_WRITER_IPIF(ipif));
10578 10581
10579 10582 ill = ipif->ipif_ill;
10580 10583 phyi = ill->ill_phyint;
10581 10584
10582 10585 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10583 10586
10584 10587 /*
10585 10588 * IFF_UP is handled separately.
10586 10589 */
10587 10590 turn_on &= ~IFF_UP;
10588 10591 turn_off &= ~IFF_UP;
10589 10592
10590 10593 if ((turn_on|turn_off) & IFF_PHYINT_FLAGS)
10591 10594 phyint_flags_modified = B_TRUE;
10592 10595
10593 10596 /*
10594 10597 * Now we change the flags. Track current value of
10595 10598 * other flags in their respective places.
10596 10599 */
10597 10600 mutex_enter(&ill->ill_lock);
10598 10601 mutex_enter(&phyi->phyint_lock);
10599 10602 ipif->ipif_flags |= (turn_on & IFF_LOGINT_FLAGS);
10600 10603 ipif->ipif_flags &= (~turn_off & IFF_LOGINT_FLAGS);
10601 10604 ill->ill_flags |= (turn_on & IFF_PHYINTINST_FLAGS);
10602 10605 ill->ill_flags &= (~turn_off & IFF_PHYINTINST_FLAGS);
10603 10606 phyi->phyint_flags |= (turn_on & IFF_PHYINT_FLAGS);
10604 10607 phyi->phyint_flags &= (~turn_off & IFF_PHYINT_FLAGS);
10605 10608 if (ipif->ipif_state_flags & IPIF_SET_LINKLOCAL) {
10606 10609 set_linklocal = B_TRUE;
10607 10610 ipif->ipif_state_flags &= ~IPIF_SET_LINKLOCAL;
10608 10611 }
10609 10612
10610 10613 mutex_exit(&ill->ill_lock);
10611 10614 mutex_exit(&phyi->phyint_lock);
10612 10615
10613 10616 if (set_linklocal)
10614 10617 (void) ipif_setlinklocal(ipif);
10615 10618
10616 10619 /*
10617 10620 * PHYI_FAILED, PHYI_INACTIVE, and PHYI_OFFLINE are all the same to
10618 10621 * the kernel: if any of them has been set by userland, the interface
10619 10622 * cannot be used for data traffic.
10620 10623 */
10621 10624 if ((turn_on|turn_off) & (PHYI_FAILED | PHYI_INACTIVE | PHYI_OFFLINE)) {
10622 10625 ASSERT(!IS_IPMP(ill));
10623 10626 /*
10624 10627 * It's possible the ill is part of an "anonymous" IPMP group
10625 10628 * rather than a real group. In that case, there are no other
10626 10629 * interfaces in the group and thus no need for us to call
10627 10630 * ipmp_phyint_refresh_active().
10628 10631 */
10629 10632 if (IS_UNDER_IPMP(ill))
10630 10633 ipmp_phyint_refresh_active(phyi);
10631 10634 }
10632 10635
10633 10636 if ((turn_on|turn_off) & ILLF_NOACCEPT) {
10634 10637 /*
10635 10638 * If the ILLF_NOACCEPT flag is changed, bring up all the
10636 10639 * ipifs that were brought down.
10637 10640 *
10638 10641 * The routing sockets messages are sent as the result
10639 10642 * of ill_up_ipifs(), further, SCTP's IPIF list was updated
10640 10643 * as well.
10641 10644 */
10642 10645 err = ill_up_ipifs(ill, q, mp);
10643 10646 } else if ((flags & IFF_UP) && !(ipif->ipif_flags & IPIF_UP)) {
10644 10647 /*
10645 10648 * XXX ipif_up really does not know whether a phyint flags
10646 10649 * was modified or not. So, it sends up information on
10647 10650 * only one routing sockets message. As we don't bring up
10648 10651 * the interface and also set PHYI_ flags simultaneously
10649 10652 * it should be okay.
10650 10653 */
10651 10654 err = ipif_up(ipif, q, mp);
10652 10655 } else {
10653 10656 /*
10654 10657 * Make sure routing socket sees all changes to the flags.
10655 10658 * ipif_up_done* handles this when we use ipif_up.
10656 10659 */
10657 10660 if (phyint_flags_modified) {
10658 10661 if (phyi->phyint_illv4 != NULL) {
10659 10662 ip_rts_ifmsg(phyi->phyint_illv4->
10660 10663 ill_ipif, RTSQ_DEFAULT);
10661 10664 }
10662 10665 if (phyi->phyint_illv6 != NULL) {
10663 10666 ip_rts_ifmsg(phyi->phyint_illv6->
10664 10667 ill_ipif, RTSQ_DEFAULT);
10665 10668 }
10666 10669 } else {
10667 10670 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
10668 10671 }
10669 10672 /*
10670 10673 * Update the flags in SCTP's IPIF list, ipif_up() will do
10671 10674 * this in need_up case.
10672 10675 */
10673 10676 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
10674 10677 }
10675 10678
10676 10679 /* The default multicast interface might have changed */
10677 10680 ire_increment_multicast_generation(ill->ill_ipst, ill->ill_isv6);
10678 10681 return (err);
10679 10682 }
10680 10683
10681 10684 /*
10682 10685 * Restart the flags operation now that the refcounts have dropped to zero.
10683 10686 */
10684 10687 /* ARGSUSED */
10685 10688 int
10686 10689 ip_sioctl_flags_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10687 10690 ip_ioctl_cmd_t *ipip, void *if_req)
10688 10691 {
10689 10692 uint64_t flags;
10690 10693 struct ifreq *ifr = if_req;
10691 10694 struct lifreq *lifr = if_req;
10692 10695 uint64_t turn_on, turn_off;
10693 10696
10694 10697 ip1dbg(("ip_sioctl_flags_restart(%s:%u %p)\n",
10695 10698 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10696 10699
10697 10700 if (ipip->ipi_cmd_type == IF_CMD) {
10698 10701 /* cast to uint16_t prevents unwanted sign extension */
10699 10702 flags = (uint16_t)ifr->ifr_flags;
10700 10703 } else {
10701 10704 flags = lifr->lifr_flags;
10702 10705 }
10703 10706
10704 10707 /*
10705 10708 * If this function call is a result of the ILLF_NOACCEPT flag
10706 10709 * change, do not call ipif_down_tail(). See ip_sioctl_flags().
10707 10710 */
10708 10711 ip_sioctl_flags_onoff(ipif, flags, &turn_on, &turn_off);
10709 10712 if (!((turn_on|turn_off) & ILLF_NOACCEPT))
10710 10713 (void) ipif_down_tail(ipif);
10711 10714
10712 10715 return (ip_sioctl_flags_tail(ipif, flags, q, mp));
10713 10716 }
10714 10717
10715 10718 /*
10716 10719 * Can operate on either a module or a driver queue.
10717 10720 */
10718 10721 /* ARGSUSED */
10719 10722 int
10720 10723 ip_sioctl_get_flags(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10721 10724 ip_ioctl_cmd_t *ipip, void *if_req)
10722 10725 {
10723 10726 /*
10724 10727 * Has the flags been set correctly till now ?
10725 10728 */
10726 10729 ill_t *ill = ipif->ipif_ill;
10727 10730 phyint_t *phyi = ill->ill_phyint;
10728 10731
10729 10732 ip1dbg(("ip_sioctl_get_flags(%s:%u %p)\n",
10730 10733 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10731 10734 ASSERT((phyi->phyint_flags & ~(IFF_PHYINT_FLAGS)) == 0);
10732 10735 ASSERT((ill->ill_flags & ~(IFF_PHYINTINST_FLAGS)) == 0);
10733 10736 ASSERT((ipif->ipif_flags & ~(IFF_LOGINT_FLAGS)) == 0);
10734 10737
10735 10738 /*
10736 10739 * Need a lock since some flags can be set even when there are
10737 10740 * references to the ipif.
10738 10741 */
10739 10742 mutex_enter(&ill->ill_lock);
10740 10743 if (ipip->ipi_cmd_type == IF_CMD) {
10741 10744 struct ifreq *ifr = (struct ifreq *)if_req;
10742 10745
10743 10746 /* Get interface flags (low 16 only). */
10744 10747 ifr->ifr_flags = ((ipif->ipif_flags |
10745 10748 ill->ill_flags | phyi->phyint_flags) & 0xffff);
10746 10749 } else {
10747 10750 struct lifreq *lifr = (struct lifreq *)if_req;
10748 10751
10749 10752 /* Get interface flags. */
10750 10753 lifr->lifr_flags = ipif->ipif_flags |
10751 10754 ill->ill_flags | phyi->phyint_flags;
10752 10755 }
10753 10756 mutex_exit(&ill->ill_lock);
10754 10757 return (0);
10755 10758 }
10756 10759
10757 10760 /*
10758 10761 * We allow the MTU to be set on an ILL, but not have it be different
10759 10762 * for different IPIFs since we don't actually send packets on IPIFs.
10760 10763 */
10761 10764 /* ARGSUSED */
10762 10765 int
10763 10766 ip_sioctl_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10764 10767 ip_ioctl_cmd_t *ipip, void *if_req)
10765 10768 {
10766 10769 int mtu;
10767 10770 int ip_min_mtu;
10768 10771 struct ifreq *ifr;
10769 10772 struct lifreq *lifr;
10770 10773 ill_t *ill;
10771 10774
10772 10775 ip1dbg(("ip_sioctl_mtu(%s:%u %p)\n", ipif->ipif_ill->ill_name,
10773 10776 ipif->ipif_id, (void *)ipif));
10774 10777 if (ipip->ipi_cmd_type == IF_CMD) {
10775 10778 ifr = (struct ifreq *)if_req;
10776 10779 mtu = ifr->ifr_metric;
10777 10780 } else {
10778 10781 lifr = (struct lifreq *)if_req;
10779 10782 mtu = lifr->lifr_mtu;
10780 10783 }
10781 10784 /* Only allow for logical unit zero i.e. not on "bge0:17" */
10782 10785 if (ipif->ipif_id != 0)
10783 10786 return (EINVAL);
10784 10787
10785 10788 ill = ipif->ipif_ill;
10786 10789 if (ipif->ipif_isv6)
10787 10790 ip_min_mtu = IPV6_MIN_MTU;
10788 10791 else
10789 10792 ip_min_mtu = IP_MIN_MTU;
10790 10793
10791 10794 mutex_enter(&ill->ill_lock);
10792 10795 if (mtu > ill->ill_max_frag || mtu < ip_min_mtu) {
10793 10796 mutex_exit(&ill->ill_lock);
10794 10797 return (EINVAL);
10795 10798 }
10796 10799 /* Avoid increasing ill_mc_mtu */
10797 10800 if (ill->ill_mc_mtu > mtu)
10798 10801 ill->ill_mc_mtu = mtu;
10799 10802
10800 10803 /*
10801 10804 * The dce and fragmentation code can handle changes to ill_mtu
10802 10805 * concurrent with sending/fragmenting packets.
10803 10806 */
10804 10807 ill->ill_mtu = mtu;
10805 10808 ill->ill_flags |= ILLF_FIXEDMTU;
10806 10809 mutex_exit(&ill->ill_lock);
10807 10810
10808 10811 /*
10809 10812 * Make sure all dce_generation checks find out
10810 10813 * that ill_mtu/ill_mc_mtu has changed.
10811 10814 */
10812 10815 dce_increment_all_generations(ill->ill_isv6, ill->ill_ipst);
10813 10816
10814 10817 /*
10815 10818 * Refresh IPMP meta-interface MTU if necessary.
10816 10819 */
10817 10820 if (IS_UNDER_IPMP(ill))
10818 10821 ipmp_illgrp_refresh_mtu(ill->ill_grp);
10819 10822
10820 10823 /* Update the MTU in SCTP's list */
10821 10824 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
10822 10825 return (0);
10823 10826 }
10824 10827
10825 10828 /* Get interface MTU. */
10826 10829 /* ARGSUSED */
10827 10830 int
10828 10831 ip_sioctl_get_mtu(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10829 10832 ip_ioctl_cmd_t *ipip, void *if_req)
10830 10833 {
10831 10834 struct ifreq *ifr;
10832 10835 struct lifreq *lifr;
10833 10836
10834 10837 ip1dbg(("ip_sioctl_get_mtu(%s:%u %p)\n",
10835 10838 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10836 10839
10837 10840 /*
10838 10841 * We allow a get on any logical interface even though the set
10839 10842 * can only be done on logical unit 0.
10840 10843 */
10841 10844 if (ipip->ipi_cmd_type == IF_CMD) {
10842 10845 ifr = (struct ifreq *)if_req;
10843 10846 ifr->ifr_metric = ipif->ipif_ill->ill_mtu;
10844 10847 } else {
10845 10848 lifr = (struct lifreq *)if_req;
10846 10849 lifr->lifr_mtu = ipif->ipif_ill->ill_mtu;
10847 10850 }
10848 10851 return (0);
10849 10852 }
10850 10853
10851 10854 /* Set interface broadcast address. */
10852 10855 /* ARGSUSED2 */
10853 10856 int
10854 10857 ip_sioctl_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10855 10858 ip_ioctl_cmd_t *ipip, void *if_req)
10856 10859 {
10857 10860 ipaddr_t addr;
10858 10861 ire_t *ire;
10859 10862 ill_t *ill = ipif->ipif_ill;
10860 10863 ip_stack_t *ipst = ill->ill_ipst;
10861 10864
10862 10865 ip1dbg(("ip_sioctl_brdaddr(%s:%u)\n", ill->ill_name,
10863 10866 ipif->ipif_id));
10864 10867
10865 10868 ASSERT(IAM_WRITER_IPIF(ipif));
10866 10869 if (!(ipif->ipif_flags & IPIF_BROADCAST))
10867 10870 return (EADDRNOTAVAIL);
10868 10871
10869 10872 ASSERT(!(ipif->ipif_isv6)); /* No IPv6 broadcast */
10870 10873
10871 10874 if (sin->sin_family != AF_INET)
10872 10875 return (EAFNOSUPPORT);
10873 10876
10874 10877 addr = sin->sin_addr.s_addr;
10875 10878
10876 10879 if (ipif->ipif_flags & IPIF_UP) {
10877 10880 /*
10878 10881 * If we are already up, make sure the new
10879 10882 * broadcast address makes sense. If it does,
10880 10883 * there should be an IRE for it already.
10881 10884 */
10882 10885 ire = ire_ftable_lookup_v4(addr, 0, 0, IRE_BROADCAST,
10883 10886 ill, ipif->ipif_zoneid, NULL,
10884 10887 (MATCH_IRE_ILL | MATCH_IRE_TYPE), 0, ipst, NULL);
10885 10888 if (ire == NULL) {
10886 10889 return (EINVAL);
10887 10890 } else {
10888 10891 ire_refrele(ire);
10889 10892 }
10890 10893 }
10891 10894 /*
10892 10895 * Changing the broadcast addr for this ipif. Since the IRE_BROADCAST
10893 10896 * needs to already exist we never need to change the set of
10894 10897 * IRE_BROADCASTs when we are UP.
10895 10898 */
10896 10899 if (addr != ipif->ipif_brd_addr)
10897 10900 IN6_IPADDR_TO_V4MAPPED(addr, &ipif->ipif_v6brd_addr);
10898 10901
10899 10902 return (0);
10900 10903 }
10901 10904
10902 10905 /* Get interface broadcast address. */
10903 10906 /* ARGSUSED */
10904 10907 int
10905 10908 ip_sioctl_get_brdaddr(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10906 10909 ip_ioctl_cmd_t *ipip, void *if_req)
10907 10910 {
10908 10911 ip1dbg(("ip_sioctl_get_brdaddr(%s:%u %p)\n",
10909 10912 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10910 10913 if (!(ipif->ipif_flags & IPIF_BROADCAST))
10911 10914 return (EADDRNOTAVAIL);
10912 10915
10913 10916 /* IPIF_BROADCAST not possible with IPv6 */
10914 10917 ASSERT(!ipif->ipif_isv6);
10915 10918 *sin = sin_null;
10916 10919 sin->sin_family = AF_INET;
10917 10920 sin->sin_addr.s_addr = ipif->ipif_brd_addr;
10918 10921 return (0);
10919 10922 }
10920 10923
10921 10924 /*
10922 10925 * This routine is called to handle the SIOCS*IFNETMASK IOCTL.
10923 10926 */
10924 10927 /* ARGSUSED */
10925 10928 int
10926 10929 ip_sioctl_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
10927 10930 ip_ioctl_cmd_t *ipip, void *if_req)
10928 10931 {
10929 10932 int err = 0;
10930 10933 in6_addr_t v6mask;
10931 10934
10932 10935 ip1dbg(("ip_sioctl_netmask(%s:%u %p)\n",
10933 10936 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10934 10937
10935 10938 ASSERT(IAM_WRITER_IPIF(ipif));
10936 10939
10937 10940 if (ipif->ipif_isv6) {
10938 10941 sin6_t *sin6;
10939 10942
10940 10943 if (sin->sin_family != AF_INET6)
10941 10944 return (EAFNOSUPPORT);
10942 10945
10943 10946 sin6 = (sin6_t *)sin;
10944 10947 v6mask = sin6->sin6_addr;
10945 10948 } else {
10946 10949 ipaddr_t mask;
10947 10950
10948 10951 if (sin->sin_family != AF_INET)
10949 10952 return (EAFNOSUPPORT);
10950 10953
10951 10954 mask = sin->sin_addr.s_addr;
10952 10955 if (!ip_contiguous_mask(ntohl(mask)))
10953 10956 return (ENOTSUP);
10954 10957 V4MASK_TO_V6(mask, v6mask);
10955 10958 }
10956 10959
10957 10960 /*
10958 10961 * No big deal if the interface isn't already up, or the mask
10959 10962 * isn't really changing, or this is pt-pt.
10960 10963 */
10961 10964 if (!(ipif->ipif_flags & IPIF_UP) ||
10962 10965 IN6_ARE_ADDR_EQUAL(&v6mask, &ipif->ipif_v6net_mask) ||
10963 10966 (ipif->ipif_flags & IPIF_POINTOPOINT)) {
10964 10967 ipif->ipif_v6net_mask = v6mask;
10965 10968 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
10966 10969 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
10967 10970 ipif->ipif_v6net_mask,
10968 10971 ipif->ipif_v6subnet);
10969 10972 }
10970 10973 return (0);
10971 10974 }
10972 10975 /*
10973 10976 * Make sure we have valid net and subnet broadcast ire's
10974 10977 * for the old netmask, if needed by other logical interfaces.
10975 10978 */
10976 10979 err = ipif_logical_down(ipif, q, mp);
10977 10980 if (err == EINPROGRESS)
10978 10981 return (err);
10979 10982 (void) ipif_down_tail(ipif);
10980 10983 err = ip_sioctl_netmask_tail(ipif, sin, q, mp);
10981 10984 return (err);
10982 10985 }
10983 10986
10984 10987 static int
10985 10988 ip_sioctl_netmask_tail(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp)
10986 10989 {
10987 10990 in6_addr_t v6mask;
10988 10991 int err = 0;
10989 10992
10990 10993 ip1dbg(("ip_sioctl_netmask_tail(%s:%u %p)\n",
10991 10994 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
10992 10995
10993 10996 if (ipif->ipif_isv6) {
10994 10997 sin6_t *sin6;
10995 10998
10996 10999 sin6 = (sin6_t *)sin;
10997 11000 v6mask = sin6->sin6_addr;
10998 11001 } else {
10999 11002 ipaddr_t mask;
11000 11003
11001 11004 mask = sin->sin_addr.s_addr;
11002 11005 V4MASK_TO_V6(mask, v6mask);
11003 11006 }
11004 11007
11005 11008 ipif->ipif_v6net_mask = v6mask;
11006 11009 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
11007 11010 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
11008 11011 ipif->ipif_v6subnet);
11009 11012 }
11010 11013 err = ipif_up(ipif, q, mp);
11011 11014
11012 11015 if (err == 0 || err == EINPROGRESS) {
11013 11016 /*
11014 11017 * The interface must be DL_BOUND if this packet has to
11015 11018 * go out on the wire. Since we only go through a logical
11016 11019 * down and are bound with the driver during an internal
11017 11020 * down/up that is satisfied.
11018 11021 */
11019 11022 if (!ipif->ipif_isv6 && ipif->ipif_ill->ill_wq != NULL) {
11020 11023 /* Potentially broadcast an address mask reply. */
11021 11024 ipif_mask_reply(ipif);
11022 11025 }
11023 11026 }
11024 11027 return (err);
11025 11028 }
11026 11029
11027 11030 /* ARGSUSED */
11028 11031 int
11029 11032 ip_sioctl_netmask_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11030 11033 ip_ioctl_cmd_t *ipip, void *if_req)
11031 11034 {
11032 11035 ip1dbg(("ip_sioctl_netmask_restart(%s:%u %p)\n",
11033 11036 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11034 11037 (void) ipif_down_tail(ipif);
11035 11038 return (ip_sioctl_netmask_tail(ipif, sin, q, mp));
11036 11039 }
11037 11040
11038 11041 /* Get interface net mask. */
11039 11042 /* ARGSUSED */
11040 11043 int
11041 11044 ip_sioctl_get_netmask(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11042 11045 ip_ioctl_cmd_t *ipip, void *if_req)
11043 11046 {
11044 11047 struct lifreq *lifr = (struct lifreq *)if_req;
11045 11048 struct sockaddr_in6 *sin6 = (sin6_t *)sin;
11046 11049
11047 11050 ip1dbg(("ip_sioctl_get_netmask(%s:%u %p)\n",
11048 11051 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11049 11052
11050 11053 /*
11051 11054 * net mask can't change since we have a reference to the ipif.
11052 11055 */
11053 11056 if (ipif->ipif_isv6) {
11054 11057 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
11055 11058 *sin6 = sin6_null;
11056 11059 sin6->sin6_family = AF_INET6;
11057 11060 sin6->sin6_addr = ipif->ipif_v6net_mask;
11058 11061 lifr->lifr_addrlen =
11059 11062 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
11060 11063 } else {
11061 11064 *sin = sin_null;
11062 11065 sin->sin_family = AF_INET;
11063 11066 sin->sin_addr.s_addr = ipif->ipif_net_mask;
11064 11067 if (ipip->ipi_cmd_type == LIF_CMD) {
11065 11068 lifr->lifr_addrlen =
11066 11069 ip_mask_to_plen(ipif->ipif_net_mask);
11067 11070 }
11068 11071 }
11069 11072 return (0);
11070 11073 }
11071 11074
11072 11075 /* ARGSUSED */
11073 11076 int
11074 11077 ip_sioctl_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11075 11078 ip_ioctl_cmd_t *ipip, void *if_req)
11076 11079 {
11077 11080 ip1dbg(("ip_sioctl_metric(%s:%u %p)\n",
11078 11081 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11079 11082
11080 11083 /*
11081 11084 * Since no applications should ever be setting metrics on underlying
11082 11085 * interfaces, we explicitly fail to smoke 'em out.
11083 11086 */
11084 11087 if (IS_UNDER_IPMP(ipif->ipif_ill))
11085 11088 return (EINVAL);
11086 11089
11087 11090 /*
11088 11091 * Set interface metric. We don't use this for
11089 11092 * anything but we keep track of it in case it is
11090 11093 * important to routing applications or such.
11091 11094 */
11092 11095 if (ipip->ipi_cmd_type == IF_CMD) {
11093 11096 struct ifreq *ifr;
11094 11097
11095 11098 ifr = (struct ifreq *)if_req;
11096 11099 ipif->ipif_ill->ill_metric = ifr->ifr_metric;
11097 11100 } else {
11098 11101 struct lifreq *lifr;
11099 11102
11100 11103 lifr = (struct lifreq *)if_req;
11101 11104 ipif->ipif_ill->ill_metric = lifr->lifr_metric;
11102 11105 }
11103 11106 return (0);
11104 11107 }
11105 11108
11106 11109 /* ARGSUSED */
11107 11110 int
11108 11111 ip_sioctl_get_metric(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11109 11112 ip_ioctl_cmd_t *ipip, void *if_req)
11110 11113 {
11111 11114 /* Get interface metric. */
11112 11115 ip1dbg(("ip_sioctl_get_metric(%s:%u %p)\n",
11113 11116 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11114 11117
11115 11118 if (ipip->ipi_cmd_type == IF_CMD) {
11116 11119 struct ifreq *ifr;
11117 11120
11118 11121 ifr = (struct ifreq *)if_req;
11119 11122 ifr->ifr_metric = ipif->ipif_ill->ill_metric;
11120 11123 } else {
11121 11124 struct lifreq *lifr;
11122 11125
11123 11126 lifr = (struct lifreq *)if_req;
11124 11127 lifr->lifr_metric = ipif->ipif_ill->ill_metric;
11125 11128 }
11126 11129
11127 11130 return (0);
11128 11131 }
11129 11132
11130 11133 /* ARGSUSED */
11131 11134 int
11132 11135 ip_sioctl_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11133 11136 ip_ioctl_cmd_t *ipip, void *if_req)
11134 11137 {
11135 11138 int arp_muxid;
11136 11139
11137 11140 ip1dbg(("ip_sioctl_muxid(%s:%u %p)\n",
11138 11141 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11139 11142 /*
11140 11143 * Set the muxid returned from I_PLINK.
11141 11144 */
11142 11145 if (ipip->ipi_cmd_type == IF_CMD) {
11143 11146 struct ifreq *ifr = (struct ifreq *)if_req;
11144 11147
11145 11148 ipif->ipif_ill->ill_muxid = ifr->ifr_ip_muxid;
11146 11149 arp_muxid = ifr->ifr_arp_muxid;
11147 11150 } else {
11148 11151 struct lifreq *lifr = (struct lifreq *)if_req;
11149 11152
11150 11153 ipif->ipif_ill->ill_muxid = lifr->lifr_ip_muxid;
11151 11154 arp_muxid = lifr->lifr_arp_muxid;
11152 11155 }
11153 11156 arl_set_muxid(ipif->ipif_ill, arp_muxid);
11154 11157 return (0);
11155 11158 }
11156 11159
11157 11160 /* ARGSUSED */
11158 11161 int
11159 11162 ip_sioctl_get_muxid(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11160 11163 ip_ioctl_cmd_t *ipip, void *if_req)
11161 11164 {
11162 11165 int arp_muxid = 0;
11163 11166
11164 11167 ip1dbg(("ip_sioctl_get_muxid(%s:%u %p)\n",
11165 11168 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11166 11169 /*
11167 11170 * Get the muxid saved in ill for I_PUNLINK.
11168 11171 */
11169 11172 arp_muxid = arl_get_muxid(ipif->ipif_ill);
11170 11173 if (ipip->ipi_cmd_type == IF_CMD) {
11171 11174 struct ifreq *ifr = (struct ifreq *)if_req;
11172 11175
11173 11176 ifr->ifr_ip_muxid = ipif->ipif_ill->ill_muxid;
11174 11177 ifr->ifr_arp_muxid = arp_muxid;
11175 11178 } else {
11176 11179 struct lifreq *lifr = (struct lifreq *)if_req;
11177 11180
11178 11181 lifr->lifr_ip_muxid = ipif->ipif_ill->ill_muxid;
11179 11182 lifr->lifr_arp_muxid = arp_muxid;
11180 11183 }
11181 11184 return (0);
11182 11185 }
11183 11186
11184 11187 /*
11185 11188 * Set the subnet prefix. Does not modify the broadcast address.
11186 11189 */
11187 11190 /* ARGSUSED */
11188 11191 int
11189 11192 ip_sioctl_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11190 11193 ip_ioctl_cmd_t *ipip, void *if_req)
11191 11194 {
11192 11195 int err = 0;
11193 11196 in6_addr_t v6addr;
11194 11197 in6_addr_t v6mask;
11195 11198 boolean_t need_up = B_FALSE;
11196 11199 int addrlen;
11197 11200
11198 11201 ip1dbg(("ip_sioctl_subnet(%s:%u %p)\n",
11199 11202 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11200 11203
11201 11204 ASSERT(IAM_WRITER_IPIF(ipif));
11202 11205 addrlen = ((struct lifreq *)if_req)->lifr_addrlen;
11203 11206
11204 11207 if (ipif->ipif_isv6) {
11205 11208 sin6_t *sin6;
11206 11209
11207 11210 if (sin->sin_family != AF_INET6)
11208 11211 return (EAFNOSUPPORT);
11209 11212
11210 11213 sin6 = (sin6_t *)sin;
11211 11214 v6addr = sin6->sin6_addr;
11212 11215 if (!ip_remote_addr_ok_v6(&v6addr, &ipv6_all_ones))
11213 11216 return (EADDRNOTAVAIL);
11214 11217 } else {
11215 11218 ipaddr_t addr;
11216 11219
11217 11220 if (sin->sin_family != AF_INET)
11218 11221 return (EAFNOSUPPORT);
11219 11222
11220 11223 addr = sin->sin_addr.s_addr;
11221 11224 if (!ip_addr_ok_v4(addr, 0xFFFFFFFF))
11222 11225 return (EADDRNOTAVAIL);
11223 11226 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
11224 11227 /* Add 96 bits */
11225 11228 addrlen += IPV6_ABITS - IP_ABITS;
11226 11229 }
11227 11230
11228 11231 if (ip_plen_to_mask_v6(addrlen, &v6mask) == NULL)
11229 11232 return (EINVAL);
11230 11233
11231 11234 /* Check if bits in the address is set past the mask */
11232 11235 if (!V6_MASK_EQ(v6addr, v6mask, v6addr))
11233 11236 return (EINVAL);
11234 11237
11235 11238 if (IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6subnet, &v6addr) &&
11236 11239 IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6net_mask, &v6mask))
11237 11240 return (0); /* No change */
11238 11241
11239 11242 if (ipif->ipif_flags & IPIF_UP) {
11240 11243 /*
11241 11244 * If the interface is already marked up,
11242 11245 * we call ipif_down which will take care
11243 11246 * of ditching any IREs that have been set
11244 11247 * up based on the old interface address.
11245 11248 */
11246 11249 err = ipif_logical_down(ipif, q, mp);
11247 11250 if (err == EINPROGRESS)
11248 11251 return (err);
11249 11252 (void) ipif_down_tail(ipif);
11250 11253 need_up = B_TRUE;
11251 11254 }
11252 11255
11253 11256 err = ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, need_up);
11254 11257 return (err);
11255 11258 }
11256 11259
11257 11260 static int
11258 11261 ip_sioctl_subnet_tail(ipif_t *ipif, in6_addr_t v6addr, in6_addr_t v6mask,
11259 11262 queue_t *q, mblk_t *mp, boolean_t need_up)
11260 11263 {
11261 11264 ill_t *ill = ipif->ipif_ill;
11262 11265 int err = 0;
11263 11266
11264 11267 ip1dbg(("ip_sioctl_subnet_tail(%s:%u %p)\n",
11265 11268 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11266 11269
11267 11270 /* Set the new address. */
11268 11271 mutex_enter(&ill->ill_lock);
11269 11272 ipif->ipif_v6net_mask = v6mask;
11270 11273 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
11271 11274 V6_MASK_COPY(v6addr, ipif->ipif_v6net_mask,
11272 11275 ipif->ipif_v6subnet);
11273 11276 }
11274 11277 mutex_exit(&ill->ill_lock);
11275 11278
11276 11279 if (need_up) {
11277 11280 /*
11278 11281 * Now bring the interface back up. If this
11279 11282 * is the only IPIF for the ILL, ipif_up
11280 11283 * will have to re-bind to the device, so
11281 11284 * we may get back EINPROGRESS, in which
11282 11285 * case, this IOCTL will get completed in
11283 11286 * ip_rput_dlpi when we see the DL_BIND_ACK.
11284 11287 */
11285 11288 err = ipif_up(ipif, q, mp);
11286 11289 if (err == EINPROGRESS)
11287 11290 return (err);
11288 11291 }
11289 11292 return (err);
11290 11293 }
11291 11294
11292 11295 /* ARGSUSED */
11293 11296 int
11294 11297 ip_sioctl_subnet_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11295 11298 ip_ioctl_cmd_t *ipip, void *if_req)
11296 11299 {
11297 11300 int addrlen;
11298 11301 in6_addr_t v6addr;
11299 11302 in6_addr_t v6mask;
11300 11303 struct lifreq *lifr = (struct lifreq *)if_req;
11301 11304
11302 11305 ip1dbg(("ip_sioctl_subnet_restart(%s:%u %p)\n",
11303 11306 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11304 11307 (void) ipif_down_tail(ipif);
11305 11308
11306 11309 addrlen = lifr->lifr_addrlen;
11307 11310 if (ipif->ipif_isv6) {
11308 11311 sin6_t *sin6;
11309 11312
11310 11313 sin6 = (sin6_t *)sin;
11311 11314 v6addr = sin6->sin6_addr;
11312 11315 } else {
11313 11316 ipaddr_t addr;
11314 11317
11315 11318 addr = sin->sin_addr.s_addr;
11316 11319 IN6_IPADDR_TO_V4MAPPED(addr, &v6addr);
11317 11320 addrlen += IPV6_ABITS - IP_ABITS;
11318 11321 }
11319 11322 (void) ip_plen_to_mask_v6(addrlen, &v6mask);
11320 11323
11321 11324 return (ip_sioctl_subnet_tail(ipif, v6addr, v6mask, q, mp, B_TRUE));
11322 11325 }
11323 11326
11324 11327 /* ARGSUSED */
11325 11328 int
11326 11329 ip_sioctl_get_subnet(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11327 11330 ip_ioctl_cmd_t *ipip, void *if_req)
11328 11331 {
11329 11332 struct lifreq *lifr = (struct lifreq *)if_req;
11330 11333 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sin;
11331 11334
11332 11335 ip1dbg(("ip_sioctl_get_subnet(%s:%u %p)\n",
11333 11336 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11334 11337 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
11335 11338
11336 11339 if (ipif->ipif_isv6) {
11337 11340 *sin6 = sin6_null;
11338 11341 sin6->sin6_family = AF_INET6;
11339 11342 sin6->sin6_addr = ipif->ipif_v6subnet;
11340 11343 lifr->lifr_addrlen =
11341 11344 ip_mask_to_plen_v6(&ipif->ipif_v6net_mask);
11342 11345 } else {
11343 11346 *sin = sin_null;
11344 11347 sin->sin_family = AF_INET;
11345 11348 sin->sin_addr.s_addr = ipif->ipif_subnet;
11346 11349 lifr->lifr_addrlen = ip_mask_to_plen(ipif->ipif_net_mask);
11347 11350 }
11348 11351 return (0);
11349 11352 }
11350 11353
11351 11354 /*
11352 11355 * Set the IPv6 address token.
11353 11356 */
11354 11357 /* ARGSUSED */
11355 11358 int
11356 11359 ip_sioctl_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11357 11360 ip_ioctl_cmd_t *ipi, void *if_req)
11358 11361 {
11359 11362 ill_t *ill = ipif->ipif_ill;
11360 11363 int err;
11361 11364 in6_addr_t v6addr;
11362 11365 in6_addr_t v6mask;
11363 11366 boolean_t need_up = B_FALSE;
11364 11367 int i;
11365 11368 sin6_t *sin6 = (sin6_t *)sin;
11366 11369 struct lifreq *lifr = (struct lifreq *)if_req;
11367 11370 int addrlen;
11368 11371
11369 11372 ip1dbg(("ip_sioctl_token(%s:%u %p)\n",
11370 11373 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11371 11374 ASSERT(IAM_WRITER_IPIF(ipif));
11372 11375
11373 11376 addrlen = lifr->lifr_addrlen;
11374 11377 /* Only allow for logical unit zero i.e. not on "le0:17" */
11375 11378 if (ipif->ipif_id != 0)
11376 11379 return (EINVAL);
11377 11380
11378 11381 if (!ipif->ipif_isv6)
11379 11382 return (EINVAL);
11380 11383
11381 11384 if (addrlen > IPV6_ABITS)
11382 11385 return (EINVAL);
11383 11386
11384 11387 v6addr = sin6->sin6_addr;
11385 11388
11386 11389 /*
11387 11390 * The length of the token is the length from the end. To get
11388 11391 * the proper mask for this, compute the mask of the bits not
11389 11392 * in the token; ie. the prefix, and then xor to get the mask.
11390 11393 */
11391 11394 if (ip_plen_to_mask_v6(IPV6_ABITS - addrlen, &v6mask) == NULL)
11392 11395 return (EINVAL);
11393 11396 for (i = 0; i < 4; i++) {
11394 11397 v6mask.s6_addr32[i] ^= (uint32_t)0xffffffff;
11395 11398 }
11396 11399
11397 11400 if (V6_MASK_EQ(v6addr, v6mask, ill->ill_token) &&
11398 11401 ill->ill_token_length == addrlen)
11399 11402 return (0); /* No change */
11400 11403
11401 11404 if (ipif->ipif_flags & IPIF_UP) {
11402 11405 err = ipif_logical_down(ipif, q, mp);
11403 11406 if (err == EINPROGRESS)
11404 11407 return (err);
11405 11408 (void) ipif_down_tail(ipif);
11406 11409 need_up = B_TRUE;
11407 11410 }
11408 11411 err = ip_sioctl_token_tail(ipif, sin6, addrlen, q, mp, need_up);
11409 11412 return (err);
11410 11413 }
11411 11414
11412 11415 static int
11413 11416 ip_sioctl_token_tail(ipif_t *ipif, sin6_t *sin6, int addrlen, queue_t *q,
11414 11417 mblk_t *mp, boolean_t need_up)
11415 11418 {
11416 11419 in6_addr_t v6addr;
11417 11420 in6_addr_t v6mask;
11418 11421 ill_t *ill = ipif->ipif_ill;
11419 11422 int i;
11420 11423 int err = 0;
11421 11424
11422 11425 ip1dbg(("ip_sioctl_token_tail(%s:%u %p)\n",
11423 11426 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11424 11427 v6addr = sin6->sin6_addr;
11425 11428 /*
11426 11429 * The length of the token is the length from the end. To get
11427 11430 * the proper mask for this, compute the mask of the bits not
11428 11431 * in the token; ie. the prefix, and then xor to get the mask.
11429 11432 */
11430 11433 (void) ip_plen_to_mask_v6(IPV6_ABITS - addrlen, &v6mask);
11431 11434 for (i = 0; i < 4; i++)
11432 11435 v6mask.s6_addr32[i] ^= (uint32_t)0xffffffff;
11433 11436
11434 11437 mutex_enter(&ill->ill_lock);
11435 11438 V6_MASK_COPY(v6addr, v6mask, ill->ill_token);
11436 11439 ill->ill_token_length = addrlen;
11437 11440 ill->ill_manual_token = 1;
11438 11441
11439 11442 /* Reconfigure the link-local address based on this new token */
11440 11443 ipif_setlinklocal(ill->ill_ipif);
11441 11444
11442 11445 mutex_exit(&ill->ill_lock);
11443 11446
11444 11447 if (need_up) {
11445 11448 /*
11446 11449 * Now bring the interface back up. If this
11447 11450 * is the only IPIF for the ILL, ipif_up
11448 11451 * will have to re-bind to the device, so
11449 11452 * we may get back EINPROGRESS, in which
11450 11453 * case, this IOCTL will get completed in
11451 11454 * ip_rput_dlpi when we see the DL_BIND_ACK.
11452 11455 */
11453 11456 err = ipif_up(ipif, q, mp);
11454 11457 if (err == EINPROGRESS)
11455 11458 return (err);
11456 11459 }
11457 11460 return (err);
11458 11461 }
11459 11462
11460 11463 /* ARGSUSED */
11461 11464 int
11462 11465 ip_sioctl_get_token(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11463 11466 ip_ioctl_cmd_t *ipi, void *if_req)
11464 11467 {
11465 11468 ill_t *ill;
11466 11469 sin6_t *sin6 = (sin6_t *)sin;
11467 11470 struct lifreq *lifr = (struct lifreq *)if_req;
11468 11471
11469 11472 ip1dbg(("ip_sioctl_get_token(%s:%u %p)\n",
11470 11473 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11471 11474 if (ipif->ipif_id != 0)
11472 11475 return (EINVAL);
11473 11476
11474 11477 ill = ipif->ipif_ill;
11475 11478 if (!ill->ill_isv6)
11476 11479 return (ENXIO);
11477 11480
11478 11481 *sin6 = sin6_null;
11479 11482 sin6->sin6_family = AF_INET6;
11480 11483 ASSERT(!IN6_IS_ADDR_V4MAPPED(&ill->ill_token));
11481 11484 sin6->sin6_addr = ill->ill_token;
11482 11485 lifr->lifr_addrlen = ill->ill_token_length;
11483 11486 return (0);
11484 11487 }
11485 11488
11486 11489 /*
11487 11490 * Set (hardware) link specific information that might override
11488 11491 * what was acquired through the DL_INFO_ACK.
11489 11492 */
11490 11493 /* ARGSUSED */
11491 11494 int
11492 11495 ip_sioctl_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11493 11496 ip_ioctl_cmd_t *ipi, void *if_req)
11494 11497 {
11495 11498 ill_t *ill = ipif->ipif_ill;
11496 11499 int ip_min_mtu;
11497 11500 struct lifreq *lifr = (struct lifreq *)if_req;
11498 11501 lif_ifinfo_req_t *lir;
11499 11502
11500 11503 ip1dbg(("ip_sioctl_lnkinfo(%s:%u %p)\n",
11501 11504 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11502 11505 lir = &lifr->lifr_ifinfo;
11503 11506 ASSERT(IAM_WRITER_IPIF(ipif));
11504 11507
11505 11508 /* Only allow for logical unit zero i.e. not on "bge0:17" */
11506 11509 if (ipif->ipif_id != 0)
11507 11510 return (EINVAL);
11508 11511
11509 11512 /* Set interface MTU. */
11510 11513 if (ipif->ipif_isv6)
11511 11514 ip_min_mtu = IPV6_MIN_MTU;
11512 11515 else
11513 11516 ip_min_mtu = IP_MIN_MTU;
11514 11517
11515 11518 /*
11516 11519 * Verify values before we set anything. Allow zero to
11517 11520 * mean unspecified.
11518 11521 *
11519 11522 * XXX We should be able to set the user-defined lir_mtu to some value
11520 11523 * that is greater than ill_current_frag but less than ill_max_frag- the
11521 11524 * ill_max_frag value tells us the max MTU that can be handled by the
11522 11525 * datalink, whereas the ill_current_frag is dynamically computed for
11523 11526 * some link-types like tunnels, based on the tunnel PMTU. However,
11524 11527 * since there is currently no way of distinguishing between
11525 11528 * administratively fixed link mtu values (e.g., those set via
11526 11529 * /sbin/dladm) and dynamically discovered MTUs (e.g., those discovered
11527 11530 * for tunnels) we conservatively choose the ill_current_frag as the
11528 11531 * upper-bound.
11529 11532 */
11530 11533 if (lir->lir_maxmtu != 0 &&
11531 11534 (lir->lir_maxmtu > ill->ill_current_frag ||
11532 11535 lir->lir_maxmtu < ip_min_mtu))
11533 11536 return (EINVAL);
11534 11537 if (lir->lir_reachtime != 0 &&
11535 11538 lir->lir_reachtime > ND_MAX_REACHTIME)
11536 11539 return (EINVAL);
11537 11540 if (lir->lir_reachretrans != 0 &&
11538 11541 lir->lir_reachretrans > ND_MAX_REACHRETRANSTIME)
11539 11542 return (EINVAL);
11540 11543
11541 11544 mutex_enter(&ill->ill_lock);
11542 11545 /*
11543 11546 * The dce and fragmentation code can handle changes to ill_mtu
11544 11547 * concurrent with sending/fragmenting packets.
11545 11548 */
11546 11549 if (lir->lir_maxmtu != 0)
11547 11550 ill->ill_user_mtu = lir->lir_maxmtu;
11548 11551
11549 11552 if (lir->lir_reachtime != 0)
11550 11553 ill->ill_reachable_time = lir->lir_reachtime;
11551 11554
11552 11555 if (lir->lir_reachretrans != 0)
11553 11556 ill->ill_reachable_retrans_time = lir->lir_reachretrans;
11554 11557
11555 11558 ill->ill_max_hops = lir->lir_maxhops;
11556 11559 ill->ill_max_buf = ND_MAX_Q;
11557 11560 if (!(ill->ill_flags & ILLF_FIXEDMTU) && ill->ill_user_mtu != 0) {
11558 11561 /*
11559 11562 * ill_mtu is the actual interface MTU, obtained as the min
11560 11563 * of user-configured mtu and the value announced by the
11561 11564 * driver (via DL_NOTE_SDU_SIZE/DL_INFO_ACK). Note that since
11562 11565 * we have already made the choice of requiring
11563 11566 * ill_user_mtu < ill_current_frag by the time we get here,
11564 11567 * the ill_mtu effectively gets assigned to the ill_user_mtu
11565 11568 * here.
11566 11569 */
11567 11570 ill->ill_mtu = MIN(ill->ill_current_frag, ill->ill_user_mtu);
11568 11571 ill->ill_mc_mtu = MIN(ill->ill_mc_mtu, ill->ill_user_mtu);
11569 11572 }
11570 11573 mutex_exit(&ill->ill_lock);
11571 11574
11572 11575 /*
11573 11576 * Make sure all dce_generation checks find out
11574 11577 * that ill_mtu/ill_mc_mtu has changed.
11575 11578 */
11576 11579 if (!(ill->ill_flags & ILLF_FIXEDMTU) && (lir->lir_maxmtu != 0))
11577 11580 dce_increment_all_generations(ill->ill_isv6, ill->ill_ipst);
11578 11581
11579 11582 /*
11580 11583 * Refresh IPMP meta-interface MTU if necessary.
11581 11584 */
11582 11585 if (IS_UNDER_IPMP(ill))
11583 11586 ipmp_illgrp_refresh_mtu(ill->ill_grp);
11584 11587
11585 11588 return (0);
11586 11589 }
11587 11590
11588 11591 /* ARGSUSED */
11589 11592 int
11590 11593 ip_sioctl_get_lnkinfo(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
11591 11594 ip_ioctl_cmd_t *ipi, void *if_req)
11592 11595 {
11593 11596 struct lif_ifinfo_req *lir;
11594 11597 ill_t *ill = ipif->ipif_ill;
11595 11598
11596 11599 ip1dbg(("ip_sioctl_get_lnkinfo(%s:%u %p)\n",
11597 11600 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
11598 11601 if (ipif->ipif_id != 0)
11599 11602 return (EINVAL);
11600 11603
11601 11604 lir = &((struct lifreq *)if_req)->lifr_ifinfo;
11602 11605 lir->lir_maxhops = ill->ill_max_hops;
11603 11606 lir->lir_reachtime = ill->ill_reachable_time;
11604 11607 lir->lir_reachretrans = ill->ill_reachable_retrans_time;
11605 11608 lir->lir_maxmtu = ill->ill_mtu;
11606 11609
11607 11610 return (0);
11608 11611 }
11609 11612
11610 11613 /*
11611 11614 * Return best guess as to the subnet mask for the specified address.
11612 11615 * Based on the subnet masks for all the configured interfaces.
11613 11616 *
11614 11617 * We end up returning a zero mask in the case of default, multicast or
11615 11618 * experimental.
11616 11619 */
11617 11620 static ipaddr_t
11618 11621 ip_subnet_mask(ipaddr_t addr, ipif_t **ipifp, ip_stack_t *ipst)
11619 11622 {
11620 11623 ipaddr_t net_mask;
11621 11624 ill_t *ill;
11622 11625 ipif_t *ipif;
11623 11626 ill_walk_context_t ctx;
11624 11627 ipif_t *fallback_ipif = NULL;
11625 11628
11626 11629 net_mask = ip_net_mask(addr);
11627 11630 if (net_mask == 0) {
11628 11631 *ipifp = NULL;
11629 11632 return (0);
11630 11633 }
11631 11634
11632 11635 /* Let's check to see if this is maybe a local subnet route. */
11633 11636 /* this function only applies to IPv4 interfaces */
11634 11637 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
11635 11638 ill = ILL_START_WALK_V4(&ctx, ipst);
11636 11639 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
11637 11640 mutex_enter(&ill->ill_lock);
11638 11641 for (ipif = ill->ill_ipif; ipif != NULL;
11639 11642 ipif = ipif->ipif_next) {
11640 11643 if (IPIF_IS_CONDEMNED(ipif))
11641 11644 continue;
11642 11645 if (!(ipif->ipif_flags & IPIF_UP))
11643 11646 continue;
11644 11647 if ((ipif->ipif_subnet & net_mask) ==
11645 11648 (addr & net_mask)) {
11646 11649 /*
11647 11650 * Don't trust pt-pt interfaces if there are
11648 11651 * other interfaces.
11649 11652 */
11650 11653 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
11651 11654 if (fallback_ipif == NULL) {
11652 11655 ipif_refhold_locked(ipif);
11653 11656 fallback_ipif = ipif;
11654 11657 }
11655 11658 continue;
11656 11659 }
11657 11660
11658 11661 /*
11659 11662 * Fine. Just assume the same net mask as the
11660 11663 * directly attached subnet interface is using.
11661 11664 */
11662 11665 ipif_refhold_locked(ipif);
11663 11666 mutex_exit(&ill->ill_lock);
11664 11667 rw_exit(&ipst->ips_ill_g_lock);
11665 11668 if (fallback_ipif != NULL)
11666 11669 ipif_refrele(fallback_ipif);
11667 11670 *ipifp = ipif;
11668 11671 return (ipif->ipif_net_mask);
11669 11672 }
11670 11673 }
11671 11674 mutex_exit(&ill->ill_lock);
11672 11675 }
11673 11676 rw_exit(&ipst->ips_ill_g_lock);
11674 11677
11675 11678 *ipifp = fallback_ipif;
11676 11679 return ((fallback_ipif != NULL) ?
11677 11680 fallback_ipif->ipif_net_mask : net_mask);
11678 11681 }
11679 11682
11680 11683 /*
11681 11684 * ip_sioctl_copyin_setup calls ip_wput_ioctl to process the IP_IOCTL ioctl.
11682 11685 */
11683 11686 static void
11684 11687 ip_wput_ioctl(queue_t *q, mblk_t *mp)
11685 11688 {
11686 11689 IOCP iocp;
11687 11690 ipft_t *ipft;
11688 11691 ipllc_t *ipllc;
11689 11692 mblk_t *mp1;
11690 11693 cred_t *cr;
11691 11694 int error = 0;
11692 11695 conn_t *connp;
11693 11696
11694 11697 ip1dbg(("ip_wput_ioctl"));
11695 11698 iocp = (IOCP)mp->b_rptr;
11696 11699 mp1 = mp->b_cont;
11697 11700 if (mp1 == NULL) {
11698 11701 iocp->ioc_error = EINVAL;
11699 11702 mp->b_datap->db_type = M_IOCNAK;
11700 11703 iocp->ioc_count = 0;
11701 11704 qreply(q, mp);
11702 11705 return;
11703 11706 }
11704 11707
11705 11708 /*
11706 11709 * These IOCTLs provide various control capabilities to
11707 11710 * upstream agents such as ULPs and processes. There
11708 11711 * are currently two such IOCTLs implemented. They
11709 11712 * are used by TCP to provide update information for
11710 11713 * existing IREs and to forcibly delete an IRE for a
11711 11714 * host that is not responding, thereby forcing an
11712 11715 * attempt at a new route.
11713 11716 */
11714 11717 iocp->ioc_error = EINVAL;
11715 11718 if (!pullupmsg(mp1, sizeof (ipllc->ipllc_cmd)))
11716 11719 goto done;
11717 11720
11718 11721 ipllc = (ipllc_t *)mp1->b_rptr;
11719 11722 for (ipft = ip_ioctl_ftbl; ipft->ipft_pfi; ipft++) {
11720 11723 if (ipllc->ipllc_cmd == ipft->ipft_cmd)
11721 11724 break;
11722 11725 }
11723 11726 /*
11724 11727 * prefer credential from mblk over ioctl;
11725 11728 * see ip_sioctl_copyin_setup
11726 11729 */
11727 11730 cr = msg_getcred(mp, NULL);
11728 11731 if (cr == NULL)
11729 11732 cr = iocp->ioc_cr;
11730 11733
11731 11734 /*
11732 11735 * Refhold the conn in case the request gets queued up in some lookup
11733 11736 */
11734 11737 ASSERT(CONN_Q(q));
11735 11738 connp = Q_TO_CONN(q);
11736 11739 CONN_INC_REF(connp);
11737 11740 CONN_INC_IOCTLREF(connp);
11738 11741 if (ipft->ipft_pfi &&
11739 11742 ((mp1->b_wptr - mp1->b_rptr) >= ipft->ipft_min_size ||
11740 11743 pullupmsg(mp1, ipft->ipft_min_size))) {
11741 11744 error = (*ipft->ipft_pfi)(q,
11742 11745 (ipft->ipft_flags & IPFT_F_SELF_REPLY) ? mp : mp1, cr);
11743 11746 }
11744 11747 if (ipft->ipft_flags & IPFT_F_SELF_REPLY) {
11745 11748 /*
11746 11749 * CONN_OPER_PENDING_DONE happens in the function called
11747 11750 * through ipft_pfi above.
11748 11751 */
11749 11752 return;
11750 11753 }
11751 11754
11752 11755 CONN_DEC_IOCTLREF(connp);
11753 11756 CONN_OPER_PENDING_DONE(connp);
11754 11757 if (ipft->ipft_flags & IPFT_F_NO_REPLY) {
11755 11758 freemsg(mp);
11756 11759 return;
11757 11760 }
11758 11761 iocp->ioc_error = error;
11759 11762
11760 11763 done:
11761 11764 mp->b_datap->db_type = M_IOCACK;
11762 11765 if (iocp->ioc_error)
11763 11766 iocp->ioc_count = 0;
11764 11767 qreply(q, mp);
11765 11768 }
11766 11769
11767 11770 /*
11768 11771 * Assign a unique id for the ipif. This is used by sctp_addr.c
11769 11772 * Note: remove if sctp_addr.c is redone to not shadow ill/ipif data structures.
11770 11773 */
11771 11774 static void
11772 11775 ipif_assign_seqid(ipif_t *ipif)
11773 11776 {
11774 11777 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
11775 11778
11776 11779 ipif->ipif_seqid = atomic_add_64_nv(&ipst->ips_ipif_g_seqid, 1);
11777 11780 }
11778 11781
11779 11782 /*
11780 11783 * Clone the contents of `sipif' to `dipif'. Requires that both ipifs are
11781 11784 * administratively down (i.e., no DAD), of the same type, and locked. Note
11782 11785 * that the clone is complete -- including the seqid -- and the expectation is
11783 11786 * that the caller will either free or overwrite `sipif' before it's unlocked.
11784 11787 */
11785 11788 static void
11786 11789 ipif_clone(const ipif_t *sipif, ipif_t *dipif)
11787 11790 {
11788 11791 ASSERT(MUTEX_HELD(&sipif->ipif_ill->ill_lock));
11789 11792 ASSERT(MUTEX_HELD(&dipif->ipif_ill->ill_lock));
11790 11793 ASSERT(!(sipif->ipif_flags & (IPIF_UP|IPIF_DUPLICATE)));
11791 11794 ASSERT(!(dipif->ipif_flags & (IPIF_UP|IPIF_DUPLICATE)));
11792 11795 ASSERT(sipif->ipif_ire_type == dipif->ipif_ire_type);
11793 11796
11794 11797 dipif->ipif_flags = sipif->ipif_flags;
11795 11798 dipif->ipif_zoneid = sipif->ipif_zoneid;
11796 11799 dipif->ipif_v6subnet = sipif->ipif_v6subnet;
11797 11800 dipif->ipif_v6lcl_addr = sipif->ipif_v6lcl_addr;
11798 11801 dipif->ipif_v6net_mask = sipif->ipif_v6net_mask;
11799 11802 dipif->ipif_v6brd_addr = sipif->ipif_v6brd_addr;
11800 11803 dipif->ipif_v6pp_dst_addr = sipif->ipif_v6pp_dst_addr;
11801 11804
11802 11805 /*
11803 11806 * As per the comment atop the function, we assume that these sipif
11804 11807 * fields will be changed before sipif is unlocked.
11805 11808 */
11806 11809 dipif->ipif_seqid = sipif->ipif_seqid;
11807 11810 dipif->ipif_state_flags = sipif->ipif_state_flags;
11808 11811 }
11809 11812
11810 11813 /*
11811 11814 * Transfer the contents of `sipif' to `dipif', and then free (if `virgipif'
11812 11815 * is NULL) or overwrite `sipif' with `virgipif', which must be a virgin
11813 11816 * (unreferenced) ipif. Also, if `sipif' is used by the current xop, then
11814 11817 * transfer the xop to `dipif'. Requires that all ipifs are administratively
11815 11818 * down (i.e., no DAD), of the same type, and unlocked.
11816 11819 */
11817 11820 static void
11818 11821 ipif_transfer(ipif_t *sipif, ipif_t *dipif, ipif_t *virgipif)
11819 11822 {
11820 11823 ipsq_t *ipsq = sipif->ipif_ill->ill_phyint->phyint_ipsq;
11821 11824 ipxop_t *ipx = ipsq->ipsq_xop;
11822 11825
11823 11826 ASSERT(sipif != dipif);
11824 11827 ASSERT(sipif != virgipif);
11825 11828
11826 11829 /*
11827 11830 * Grab all of the locks that protect the ipif in a defined order.
11828 11831 */
11829 11832 GRAB_ILL_LOCKS(sipif->ipif_ill, dipif->ipif_ill);
11830 11833
11831 11834 ipif_clone(sipif, dipif);
11832 11835 if (virgipif != NULL) {
11833 11836 ipif_clone(virgipif, sipif);
11834 11837 mi_free(virgipif);
11835 11838 }
11836 11839
11837 11840 RELEASE_ILL_LOCKS(sipif->ipif_ill, dipif->ipif_ill);
11838 11841
11839 11842 /*
11840 11843 * Transfer ownership of the current xop, if necessary.
11841 11844 */
11842 11845 if (ipx->ipx_current_ipif == sipif) {
11843 11846 ASSERT(ipx->ipx_pending_ipif == NULL);
11844 11847 mutex_enter(&ipx->ipx_lock);
11845 11848 ipx->ipx_current_ipif = dipif;
11846 11849 mutex_exit(&ipx->ipx_lock);
11847 11850 }
11848 11851
11849 11852 if (virgipif == NULL)
11850 11853 mi_free(sipif);
11851 11854 }
11852 11855
11853 11856 /*
11854 11857 * checks if:
11855 11858 * - <ill_name>:<ipif_id> is at most LIFNAMSIZ - 1 and
11856 11859 * - logical interface is within the allowed range
11857 11860 */
11858 11861 static int
11859 11862 is_lifname_valid(ill_t *ill, unsigned int ipif_id)
11860 11863 {
11861 11864 if (snprintf(NULL, 0, "%s:%d", ill->ill_name, ipif_id) >= LIFNAMSIZ)
11862 11865 return (ENAMETOOLONG);
11863 11866
11864 11867 if (ipif_id >= ill->ill_ipst->ips_ip_addrs_per_if)
11865 11868 return (ERANGE);
11866 11869 return (0);
11867 11870 }
11868 11871
11869 11872 /*
11870 11873 * Insert the ipif, so that the list of ipifs on the ill will be sorted
11871 11874 * with respect to ipif_id. Note that an ipif with an ipif_id of -1 will
11872 11875 * be inserted into the first space available in the list. The value of
11873 11876 * ipif_id will then be set to the appropriate value for its position.
11874 11877 */
11875 11878 static int
11876 11879 ipif_insert(ipif_t *ipif, boolean_t acquire_g_lock)
11877 11880 {
11878 11881 ill_t *ill;
11879 11882 ipif_t *tipif;
11880 11883 ipif_t **tipifp;
11881 11884 int id, err;
11882 11885 ip_stack_t *ipst;
11883 11886
11884 11887 ASSERT(ipif->ipif_ill->ill_net_type == IRE_LOOPBACK ||
11885 11888 IAM_WRITER_IPIF(ipif));
11886 11889
11887 11890 ill = ipif->ipif_ill;
11888 11891 ASSERT(ill != NULL);
11889 11892 ipst = ill->ill_ipst;
11890 11893
11891 11894 /*
11892 11895 * In the case of lo0:0 we already hold the ill_g_lock.
11893 11896 * ill_lookup_on_name (acquires ill_g_lock) -> ipif_allocate ->
11894 11897 * ipif_insert.
11895 11898 */
11896 11899 if (acquire_g_lock)
11897 11900 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
11898 11901 mutex_enter(&ill->ill_lock);
11899 11902 id = ipif->ipif_id;
11900 11903 tipifp = &(ill->ill_ipif);
11901 11904 if (id == -1) { /* need to find a real id */
11902 11905 id = 0;
11903 11906 while ((tipif = *tipifp) != NULL) {
11904 11907 ASSERT(tipif->ipif_id >= id);
11905 11908 if (tipif->ipif_id != id)
11906 11909 break; /* non-consecutive id */
11907 11910 id++;
11908 11911 tipifp = &(tipif->ipif_next);
11909 11912 }
11910 11913 if ((err = is_lifname_valid(ill, id)) != 0) {
11911 11914 mutex_exit(&ill->ill_lock);
11912 11915 if (acquire_g_lock)
11913 11916 rw_exit(&ipst->ips_ill_g_lock);
11914 11917 return (err);
11915 11918 }
11916 11919 ipif->ipif_id = id; /* assign new id */
11917 11920 } else if ((err = is_lifname_valid(ill, id)) == 0) {
11918 11921 /* we have a real id; insert ipif in the right place */
11919 11922 while ((tipif = *tipifp) != NULL) {
11920 11923 ASSERT(tipif->ipif_id != id);
11921 11924 if (tipif->ipif_id > id)
11922 11925 break; /* found correct location */
11923 11926 tipifp = &(tipif->ipif_next);
11924 11927 }
11925 11928 } else {
11926 11929 mutex_exit(&ill->ill_lock);
11927 11930 if (acquire_g_lock)
11928 11931 rw_exit(&ipst->ips_ill_g_lock);
11929 11932 return (err);
11930 11933 }
11931 11934
11932 11935 ASSERT(tipifp != &(ill->ill_ipif) || id == 0);
11933 11936
11934 11937 ipif->ipif_next = tipif;
11935 11938 *tipifp = ipif;
11936 11939 mutex_exit(&ill->ill_lock);
11937 11940 if (acquire_g_lock)
11938 11941 rw_exit(&ipst->ips_ill_g_lock);
11939 11942
11940 11943 return (0);
11941 11944 }
11942 11945
11943 11946 static void
11944 11947 ipif_remove(ipif_t *ipif)
11945 11948 {
11946 11949 ipif_t **ipifp;
11947 11950 ill_t *ill = ipif->ipif_ill;
11948 11951
11949 11952 ASSERT(RW_WRITE_HELD(&ill->ill_ipst->ips_ill_g_lock));
11950 11953
11951 11954 mutex_enter(&ill->ill_lock);
11952 11955 ipifp = &ill->ill_ipif;
11953 11956 for (; *ipifp != NULL; ipifp = &ipifp[0]->ipif_next) {
11954 11957 if (*ipifp == ipif) {
11955 11958 *ipifp = ipif->ipif_next;
11956 11959 break;
11957 11960 }
11958 11961 }
11959 11962 mutex_exit(&ill->ill_lock);
11960 11963 }
11961 11964
11962 11965 /*
11963 11966 * Allocate and initialize a new interface control structure. (Always
11964 11967 * called as writer.)
11965 11968 * When ipif_allocate() is called from ip_ll_subnet_defaults, the ill
11966 11969 * is not part of the global linked list of ills. ipif_seqid is unique
11967 11970 * in the system and to preserve the uniqueness, it is assigned only
11968 11971 * when ill becomes part of the global list. At that point ill will
11969 11972 * have a name. If it doesn't get assigned here, it will get assigned
11970 11973 * in ipif_set_values() as part of SIOCSLIFNAME processing.
11971 11974 * Aditionally, if we come here from ip_ll_subnet_defaults, we don't set
11972 11975 * the interface flags or any other information from the DL_INFO_ACK for
11973 11976 * DL_STYLE2 drivers (initialize == B_FALSE), since we won't have them at
11974 11977 * this point. The flags etc. will be set in ip_ll_subnet_defaults when the
11975 11978 * second DL_INFO_ACK comes in from the driver.
11976 11979 */
11977 11980 static ipif_t *
11978 11981 ipif_allocate(ill_t *ill, int id, uint_t ire_type, boolean_t initialize,
11979 11982 boolean_t insert, int *errorp)
11980 11983 {
11981 11984 int err;
11982 11985 ipif_t *ipif;
11983 11986 ip_stack_t *ipst = ill->ill_ipst;
11984 11987
11985 11988 ip1dbg(("ipif_allocate(%s:%d ill %p)\n",
11986 11989 ill->ill_name, id, (void *)ill));
11987 11990 ASSERT(ire_type == IRE_LOOPBACK || IAM_WRITER_ILL(ill));
11988 11991
11989 11992 if (errorp != NULL)
11990 11993 *errorp = 0;
11991 11994
11992 11995 if ((ipif = mi_alloc(sizeof (ipif_t), BPRI_MED)) == NULL) {
11993 11996 if (errorp != NULL)
11994 11997 *errorp = ENOMEM;
11995 11998 return (NULL);
11996 11999 }
11997 12000 *ipif = ipif_zero; /* start clean */
11998 12001
11999 12002 ipif->ipif_ill = ill;
12000 12003 ipif->ipif_id = id; /* could be -1 */
12001 12004 /*
12002 12005 * Inherit the zoneid from the ill; for the shared stack instance
12003 12006 * this is always the global zone
12004 12007 */
12005 12008 ipif->ipif_zoneid = ill->ill_zoneid;
12006 12009
12007 12010 ipif->ipif_refcnt = 0;
12008 12011
12009 12012 if (insert) {
12010 12013 if ((err = ipif_insert(ipif, ire_type != IRE_LOOPBACK)) != 0) {
12011 12014 mi_free(ipif);
12012 12015 if (errorp != NULL)
12013 12016 *errorp = err;
12014 12017 return (NULL);
12015 12018 }
12016 12019 /* -1 id should have been replaced by real id */
12017 12020 id = ipif->ipif_id;
12018 12021 ASSERT(id >= 0);
12019 12022 }
12020 12023
12021 12024 if (ill->ill_name[0] != '\0')
12022 12025 ipif_assign_seqid(ipif);
12023 12026
12024 12027 /*
12025 12028 * If this is the zeroth ipif on the IPMP ill, create the illgrp
12026 12029 * (which must not exist yet because the zeroth ipif is created once
12027 12030 * per ill). However, do not not link it to the ipmp_grp_t until
12028 12031 * I_PLINK is called; see ip_sioctl_plink_ipmp() for details.
12029 12032 */
12030 12033 if (id == 0 && IS_IPMP(ill)) {
12031 12034 if (ipmp_illgrp_create(ill) == NULL) {
12032 12035 if (insert) {
12033 12036 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
12034 12037 ipif_remove(ipif);
12035 12038 rw_exit(&ipst->ips_ill_g_lock);
12036 12039 }
12037 12040 mi_free(ipif);
12038 12041 if (errorp != NULL)
12039 12042 *errorp = ENOMEM;
12040 12043 return (NULL);
12041 12044 }
12042 12045 }
12043 12046
12044 12047 /*
12045 12048 * We grab ill_lock to protect the flag changes. The ipif is still
12046 12049 * not up and can't be looked up until the ioctl completes and the
12047 12050 * IPIF_CHANGING flag is cleared.
12048 12051 */
12049 12052 mutex_enter(&ill->ill_lock);
12050 12053
12051 12054 ipif->ipif_ire_type = ire_type;
12052 12055
12053 12056 if (ipif->ipif_isv6) {
12054 12057 ill->ill_flags |= ILLF_IPV6;
12055 12058 } else {
12056 12059 ipaddr_t inaddr_any = INADDR_ANY;
12057 12060
12058 12061 ill->ill_flags |= ILLF_IPV4;
12059 12062
12060 12063 /* Keep the IN6_IS_ADDR_V4MAPPED assertions happy */
12061 12064 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12062 12065 &ipif->ipif_v6lcl_addr);
12063 12066 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12064 12067 &ipif->ipif_v6subnet);
12065 12068 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12066 12069 &ipif->ipif_v6net_mask);
12067 12070 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12068 12071 &ipif->ipif_v6brd_addr);
12069 12072 IN6_IPADDR_TO_V4MAPPED(inaddr_any,
12070 12073 &ipif->ipif_v6pp_dst_addr);
12071 12074 }
12072 12075
12073 12076 /*
12074 12077 * Don't set the interface flags etc. now, will do it in
12075 12078 * ip_ll_subnet_defaults.
12076 12079 */
12077 12080 if (!initialize)
12078 12081 goto out;
12079 12082
12080 12083 /*
12081 12084 * NOTE: The IPMP meta-interface is special-cased because it starts
12082 12085 * with no underlying interfaces (and thus an unknown broadcast
12083 12086 * address length), but all interfaces that can be placed into an IPMP
12084 12087 * group are required to be broadcast-capable.
12085 12088 */
12086 12089 if (ill->ill_bcast_addr_length != 0 || IS_IPMP(ill)) {
12087 12090 /*
12088 12091 * Later detect lack of DLPI driver multicast capability by
12089 12092 * catching DL_ENABMULTI_REQ errors in ip_rput_dlpi().
12090 12093 */
12091 12094 ill->ill_flags |= ILLF_MULTICAST;
12092 12095 if (!ipif->ipif_isv6)
12093 12096 ipif->ipif_flags |= IPIF_BROADCAST;
12094 12097 } else {
12095 12098 if (ill->ill_net_type != IRE_LOOPBACK) {
12096 12099 if (ipif->ipif_isv6)
12097 12100 /*
12098 12101 * Note: xresolv interfaces will eventually need
12099 12102 * NOARP set here as well, but that will require
12100 12103 * those external resolvers to have some
12101 12104 * knowledge of that flag and act appropriately.
12102 12105 * Not to be changed at present.
12103 12106 */
12104 12107 ill->ill_flags |= ILLF_NONUD;
12105 12108 else
12106 12109 ill->ill_flags |= ILLF_NOARP;
12107 12110 }
12108 12111 if (ill->ill_phys_addr_length == 0) {
12109 12112 if (IS_VNI(ill)) {
12110 12113 ipif->ipif_flags |= IPIF_NOXMIT;
12111 12114 } else {
12112 12115 /* pt-pt supports multicast. */
12113 12116 ill->ill_flags |= ILLF_MULTICAST;
12114 12117 if (ill->ill_net_type != IRE_LOOPBACK)
12115 12118 ipif->ipif_flags |= IPIF_POINTOPOINT;
12116 12119 }
12117 12120 }
12118 12121 }
12119 12122 out:
12120 12123 mutex_exit(&ill->ill_lock);
12121 12124 return (ipif);
12122 12125 }
12123 12126
12124 12127 /*
12125 12128 * Remove the neighbor cache entries associated with this logical
12126 12129 * interface.
12127 12130 */
12128 12131 int
12129 12132 ipif_arp_down(ipif_t *ipif)
12130 12133 {
12131 12134 ill_t *ill = ipif->ipif_ill;
12132 12135 int err = 0;
12133 12136
12134 12137 ip1dbg(("ipif_arp_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
12135 12138 ASSERT(IAM_WRITER_IPIF(ipif));
12136 12139
12137 12140 DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_down",
12138 12141 ill_t *, ill, ipif_t *, ipif);
12139 12142 ipif_nce_down(ipif);
12140 12143
12141 12144 /*
12142 12145 * If this is the last ipif that is going down and there are no
12143 12146 * duplicate addresses we may yet attempt to re-probe, then we need to
12144 12147 * clean up ARP completely.
12145 12148 */
12146 12149 if (ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
12147 12150 !ill->ill_logical_down && ill->ill_net_type == IRE_IF_RESOLVER) {
12148 12151 /*
12149 12152 * If this was the last ipif on an IPMP interface, purge any
12150 12153 * static ARP entries associated with it.
12151 12154 */
12152 12155 if (IS_IPMP(ill))
12153 12156 ipmp_illgrp_refresh_arpent(ill->ill_grp);
12154 12157
12155 12158 /* UNBIND, DETACH */
12156 12159 err = arp_ll_down(ill);
12157 12160 }
12158 12161
12159 12162 return (err);
12160 12163 }
12161 12164
12162 12165 /*
12163 12166 * Get the resolver set up for a new IP address. (Always called as writer.)
12164 12167 * Called both for IPv4 and IPv6 interfaces, though it only does some
12165 12168 * basic DAD related initialization for IPv6. Honors ILLF_NOARP.
12166 12169 *
12167 12170 * The enumerated value res_act tunes the behavior:
12168 12171 * * Res_act_initial: set up all the resolver structures for a new
12169 12172 * IP address.
12170 12173 * * Res_act_defend: tell ARP that it needs to send a single gratuitous
12171 12174 * ARP message in defense of the address.
12172 12175 * * Res_act_rebind: tell ARP to change the hardware address for an IP
12173 12176 * address (and issue gratuitous ARPs). Used by ipmp_ill_bind_ipif().
12174 12177 *
12175 12178 * Returns zero on success, or an errno upon failure.
12176 12179 */
12177 12180 int
12178 12181 ipif_resolver_up(ipif_t *ipif, enum ip_resolver_action res_act)
12179 12182 {
12180 12183 ill_t *ill = ipif->ipif_ill;
12181 12184 int err;
12182 12185 boolean_t was_dup;
12183 12186
12184 12187 ip1dbg(("ipif_resolver_up(%s:%u) flags 0x%x\n",
12185 12188 ill->ill_name, ipif->ipif_id, (uint_t)ipif->ipif_flags));
12186 12189 ASSERT(IAM_WRITER_IPIF(ipif));
12187 12190
12188 12191 was_dup = B_FALSE;
12189 12192 if (res_act == Res_act_initial) {
12190 12193 ipif->ipif_addr_ready = 0;
12191 12194 /*
12192 12195 * We're bringing an interface up here. There's no way that we
12193 12196 * should need to shut down ARP now.
12194 12197 */
12195 12198 mutex_enter(&ill->ill_lock);
12196 12199 if (ipif->ipif_flags & IPIF_DUPLICATE) {
12197 12200 ipif->ipif_flags &= ~IPIF_DUPLICATE;
12198 12201 ill->ill_ipif_dup_count--;
12199 12202 was_dup = B_TRUE;
12200 12203 }
12201 12204 mutex_exit(&ill->ill_lock);
12202 12205 }
12203 12206 if (ipif->ipif_recovery_id != 0)
12204 12207 (void) untimeout(ipif->ipif_recovery_id);
12205 12208 ipif->ipif_recovery_id = 0;
12206 12209 if (ill->ill_net_type != IRE_IF_RESOLVER) {
12207 12210 ipif->ipif_addr_ready = 1;
12208 12211 return (0);
12209 12212 }
12210 12213 /* NDP will set the ipif_addr_ready flag when it's ready */
12211 12214 if (ill->ill_isv6)
12212 12215 return (0);
12213 12216
12214 12217 err = ipif_arp_up(ipif, res_act, was_dup);
12215 12218 return (err);
12216 12219 }
12217 12220
12218 12221 /*
12219 12222 * This routine restarts IPv4/IPv6 duplicate address detection (DAD)
12220 12223 * when a link has just gone back up.
12221 12224 */
12222 12225 static void
12223 12226 ipif_nce_start_dad(ipif_t *ipif)
12224 12227 {
12225 12228 ncec_t *ncec;
12226 12229 ill_t *ill = ipif->ipif_ill;
12227 12230 boolean_t isv6 = ill->ill_isv6;
12228 12231
12229 12232 if (isv6) {
12230 12233 ncec = ncec_lookup_illgrp_v6(ipif->ipif_ill,
12231 12234 &ipif->ipif_v6lcl_addr);
12232 12235 } else {
12233 12236 ipaddr_t v4addr;
12234 12237
12235 12238 if (ill->ill_net_type != IRE_IF_RESOLVER ||
12236 12239 (ipif->ipif_flags & IPIF_UNNUMBERED) ||
12237 12240 ipif->ipif_lcl_addr == INADDR_ANY) {
12238 12241 /*
12239 12242 * If we can't contact ARP for some reason,
12240 12243 * that's not really a problem. Just send
12241 12244 * out the routing socket notification that
12242 12245 * DAD completion would have done, and continue.
12243 12246 */
12244 12247 ipif_mask_reply(ipif);
12245 12248 ipif_up_notify(ipif);
12246 12249 ipif->ipif_addr_ready = 1;
12247 12250 return;
12248 12251 }
12249 12252
12250 12253 IN6_V4MAPPED_TO_IPADDR(&ipif->ipif_v6lcl_addr, v4addr);
12251 12254 ncec = ncec_lookup_illgrp_v4(ipif->ipif_ill, &v4addr);
12252 12255 }
12253 12256
12254 12257 if (ncec == NULL) {
12255 12258 ip1dbg(("couldn't find ncec for ipif %p leaving !ready\n",
12256 12259 (void *)ipif));
12257 12260 return;
12258 12261 }
12259 12262 if (!nce_restart_dad(ncec)) {
12260 12263 /*
12261 12264 * If we can't restart DAD for some reason, that's not really a
12262 12265 * problem. Just send out the routing socket notification that
12263 12266 * DAD completion would have done, and continue.
12264 12267 */
12265 12268 ipif_up_notify(ipif);
12266 12269 ipif->ipif_addr_ready = 1;
12267 12270 }
12268 12271 ncec_refrele(ncec);
12269 12272 }
12270 12273
12271 12274 /*
12272 12275 * Restart duplicate address detection on all interfaces on the given ill.
12273 12276 *
12274 12277 * This is called when an interface transitions from down to up
12275 12278 * (DL_NOTE_LINK_UP) or up to down (DL_NOTE_LINK_DOWN).
12276 12279 *
12277 12280 * Note that since the underlying physical link has transitioned, we must cause
12278 12281 * at least one routing socket message to be sent here, either via DAD
12279 12282 * completion or just by default on the first ipif. (If we don't do this, then
12280 12283 * in.mpathd will see long delays when doing link-based failure recovery.)
12281 12284 */
12282 12285 void
12283 12286 ill_restart_dad(ill_t *ill, boolean_t went_up)
12284 12287 {
12285 12288 ipif_t *ipif;
12286 12289
12287 12290 if (ill == NULL)
12288 12291 return;
12289 12292
12290 12293 /*
12291 12294 * If layer two doesn't support duplicate address detection, then just
12292 12295 * send the routing socket message now and be done with it.
12293 12296 */
12294 12297 if (!ill->ill_isv6 && arp_no_defense) {
12295 12298 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
12296 12299 return;
12297 12300 }
12298 12301
12299 12302 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12300 12303 if (went_up) {
12301 12304
12302 12305 if (ipif->ipif_flags & IPIF_UP) {
12303 12306 ipif_nce_start_dad(ipif);
12304 12307 } else if (ipif->ipif_flags & IPIF_DUPLICATE) {
12305 12308 /*
12306 12309 * kick off the bring-up process now.
12307 12310 */
12308 12311 ipif_do_recovery(ipif);
12309 12312 } else {
12310 12313 /*
12311 12314 * Unfortunately, the first ipif is "special"
12312 12315 * and represents the underlying ill in the
12313 12316 * routing socket messages. Thus, when this
12314 12317 * one ipif is down, we must still notify so
12315 12318 * that the user knows the IFF_RUNNING status
12316 12319 * change. (If the first ipif is up, then
12317 12320 * we'll handle eventual routing socket
12318 12321 * notification via DAD completion.)
12319 12322 */
12320 12323 if (ipif == ill->ill_ipif) {
12321 12324 ip_rts_ifmsg(ill->ill_ipif,
12322 12325 RTSQ_DEFAULT);
12323 12326 }
12324 12327 }
12325 12328 } else {
12326 12329 /*
12327 12330 * After link down, we'll need to send a new routing
12328 12331 * message when the link comes back, so clear
12329 12332 * ipif_addr_ready.
12330 12333 */
12331 12334 ipif->ipif_addr_ready = 0;
12332 12335 }
12333 12336 }
12334 12337
12335 12338 /*
12336 12339 * If we've torn down links, then notify the user right away.
12337 12340 */
12338 12341 if (!went_up)
12339 12342 ip_rts_ifmsg(ill->ill_ipif, RTSQ_DEFAULT);
12340 12343 }
12341 12344
12342 12345 static void
12343 12346 ipsq_delete(ipsq_t *ipsq)
12344 12347 {
12345 12348 ipxop_t *ipx = ipsq->ipsq_xop;
12346 12349
12347 12350 ipsq->ipsq_ipst = NULL;
12348 12351 ASSERT(ipsq->ipsq_phyint == NULL);
12349 12352 ASSERT(ipsq->ipsq_xop != NULL);
12350 12353 ASSERT(ipsq->ipsq_xopq_mphead == NULL && ipx->ipx_mphead == NULL);
12351 12354 ASSERT(ipx->ipx_pending_mp == NULL);
12352 12355 kmem_free(ipsq, sizeof (ipsq_t));
12353 12356 }
12354 12357
12355 12358 static int
12356 12359 ill_up_ipifs_on_ill(ill_t *ill, queue_t *q, mblk_t *mp)
12357 12360 {
12358 12361 int err = 0;
12359 12362 ipif_t *ipif;
12360 12363
12361 12364 if (ill == NULL)
12362 12365 return (0);
12363 12366
12364 12367 ASSERT(IAM_WRITER_ILL(ill));
12365 12368 ill->ill_up_ipifs = B_TRUE;
12366 12369 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12367 12370 if (ipif->ipif_was_up) {
12368 12371 if (!(ipif->ipif_flags & IPIF_UP))
12369 12372 err = ipif_up(ipif, q, mp);
12370 12373 ipif->ipif_was_up = B_FALSE;
12371 12374 if (err != 0) {
12372 12375 ASSERT(err == EINPROGRESS);
12373 12376 return (err);
12374 12377 }
12375 12378 }
12376 12379 }
12377 12380 ill->ill_up_ipifs = B_FALSE;
12378 12381 return (0);
12379 12382 }
12380 12383
12381 12384 /*
12382 12385 * This function is called to bring up all the ipifs that were up before
12383 12386 * bringing the ill down via ill_down_ipifs().
12384 12387 */
12385 12388 int
12386 12389 ill_up_ipifs(ill_t *ill, queue_t *q, mblk_t *mp)
12387 12390 {
12388 12391 int err;
12389 12392
12390 12393 ASSERT(IAM_WRITER_ILL(ill));
12391 12394
12392 12395 if (ill->ill_replumbing) {
12393 12396 ill->ill_replumbing = 0;
12394 12397 /*
12395 12398 * Send down REPLUMB_DONE notification followed by the
12396 12399 * BIND_REQ on the arp stream.
12397 12400 */
12398 12401 if (!ill->ill_isv6)
12399 12402 arp_send_replumb_conf(ill);
12400 12403 }
12401 12404 err = ill_up_ipifs_on_ill(ill->ill_phyint->phyint_illv4, q, mp);
12402 12405 if (err != 0)
12403 12406 return (err);
12404 12407
12405 12408 return (ill_up_ipifs_on_ill(ill->ill_phyint->phyint_illv6, q, mp));
12406 12409 }
12407 12410
12408 12411 /*
12409 12412 * Bring down any IPIF_UP ipifs on ill. If "logical" is B_TRUE, we bring
12410 12413 * down the ipifs without sending DL_UNBIND_REQ to the driver.
12411 12414 */
12412 12415 static void
12413 12416 ill_down_ipifs(ill_t *ill, boolean_t logical)
12414 12417 {
12415 12418 ipif_t *ipif;
12416 12419
12417 12420 ASSERT(IAM_WRITER_ILL(ill));
12418 12421
12419 12422 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
12420 12423 /*
12421 12424 * We go through the ipif_down logic even if the ipif
12422 12425 * is already down, since routes can be added based
12423 12426 * on down ipifs. Going through ipif_down once again
12424 12427 * will delete any IREs created based on these routes.
12425 12428 */
12426 12429 if (ipif->ipif_flags & IPIF_UP)
12427 12430 ipif->ipif_was_up = B_TRUE;
12428 12431
12429 12432 if (logical) {
12430 12433 (void) ipif_logical_down(ipif, NULL, NULL);
12431 12434 ipif_non_duplicate(ipif);
12432 12435 (void) ipif_down_tail(ipif);
12433 12436 } else {
12434 12437 (void) ipif_down(ipif, NULL, NULL);
12435 12438 }
12436 12439 }
12437 12440 }
12438 12441
12439 12442 /*
12440 12443 * Redo source address selection. This makes IXAF_VERIFY_SOURCE take
12441 12444 * a look again at valid source addresses.
12442 12445 * This should be called each time after the set of source addresses has been
12443 12446 * changed.
12444 12447 */
12445 12448 void
12446 12449 ip_update_source_selection(ip_stack_t *ipst)
12447 12450 {
12448 12451 /* We skip past SRC_GENERATION_VERIFY */
12449 12452 if (atomic_add_32_nv(&ipst->ips_src_generation, 1) ==
12450 12453 SRC_GENERATION_VERIFY)
12451 12454 atomic_add_32(&ipst->ips_src_generation, 1);
12452 12455 }
12453 12456
12454 12457 /*
12455 12458 * Finish the group join started in ip_sioctl_groupname().
12456 12459 */
12457 12460 /* ARGSUSED */
12458 12461 static void
12459 12462 ip_join_illgrps(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy)
12460 12463 {
12461 12464 ill_t *ill = q->q_ptr;
12462 12465 phyint_t *phyi = ill->ill_phyint;
12463 12466 ipmp_grp_t *grp = phyi->phyint_grp;
12464 12467 ip_stack_t *ipst = ill->ill_ipst;
12465 12468
12466 12469 /* IS_UNDER_IPMP() won't work until ipmp_ill_join_illgrp() is called */
12467 12470 ASSERT(!IS_IPMP(ill) && grp != NULL);
12468 12471 ASSERT(IAM_WRITER_IPSQ(ipsq));
12469 12472
12470 12473 if (phyi->phyint_illv4 != NULL) {
12471 12474 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
12472 12475 VERIFY(grp->gr_pendv4-- > 0);
12473 12476 rw_exit(&ipst->ips_ipmp_lock);
12474 12477 ipmp_ill_join_illgrp(phyi->phyint_illv4, grp->gr_v4);
12475 12478 }
12476 12479 if (phyi->phyint_illv6 != NULL) {
12477 12480 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
12478 12481 VERIFY(grp->gr_pendv6-- > 0);
12479 12482 rw_exit(&ipst->ips_ipmp_lock);
12480 12483 ipmp_ill_join_illgrp(phyi->phyint_illv6, grp->gr_v6);
12481 12484 }
12482 12485 freemsg(mp);
12483 12486 }
12484 12487
12485 12488 /*
12486 12489 * Process an SIOCSLIFGROUPNAME request.
12487 12490 */
12488 12491 /* ARGSUSED */
12489 12492 int
12490 12493 ip_sioctl_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12491 12494 ip_ioctl_cmd_t *ipip, void *ifreq)
12492 12495 {
12493 12496 struct lifreq *lifr = ifreq;
12494 12497 ill_t *ill = ipif->ipif_ill;
12495 12498 ip_stack_t *ipst = ill->ill_ipst;
12496 12499 phyint_t *phyi = ill->ill_phyint;
12497 12500 ipmp_grp_t *grp = phyi->phyint_grp;
12498 12501 mblk_t *ipsq_mp;
12499 12502 int err = 0;
12500 12503
12501 12504 /*
12502 12505 * Note that phyint_grp can only change here, where we're exclusive.
12503 12506 */
12504 12507 ASSERT(IAM_WRITER_ILL(ill));
12505 12508
12506 12509 if (ipif->ipif_id != 0 || ill->ill_usesrc_grp_next != NULL ||
12507 12510 (phyi->phyint_flags & PHYI_VIRTUAL))
12508 12511 return (EINVAL);
12509 12512
12510 12513 lifr->lifr_groupname[LIFGRNAMSIZ - 1] = '\0';
12511 12514
12512 12515 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
12513 12516
12514 12517 /*
12515 12518 * If the name hasn't changed, there's nothing to do.
12516 12519 */
12517 12520 if (grp != NULL && strcmp(grp->gr_name, lifr->lifr_groupname) == 0)
12518 12521 goto unlock;
12519 12522
12520 12523 /*
12521 12524 * Handle requests to rename an IPMP meta-interface.
12522 12525 *
12523 12526 * Note that creation of the IPMP meta-interface is handled in
12524 12527 * userland through the standard plumbing sequence. As part of the
12525 12528 * plumbing the IPMP meta-interface, its initial groupname is set to
12526 12529 * the name of the interface (see ipif_set_values_tail()).
12527 12530 */
12528 12531 if (IS_IPMP(ill)) {
12529 12532 err = ipmp_grp_rename(grp, lifr->lifr_groupname);
12530 12533 goto unlock;
12531 12534 }
12532 12535
12533 12536 /*
12534 12537 * Handle requests to add or remove an IP interface from a group.
12535 12538 */
12536 12539 if (lifr->lifr_groupname[0] != '\0') { /* add */
12537 12540 /*
12538 12541 * Moves are handled by first removing the interface from
12539 12542 * its existing group, and then adding it to another group.
12540 12543 * So, fail if it's already in a group.
12541 12544 */
12542 12545 if (IS_UNDER_IPMP(ill)) {
12543 12546 err = EALREADY;
12544 12547 goto unlock;
12545 12548 }
12546 12549
12547 12550 grp = ipmp_grp_lookup(lifr->lifr_groupname, ipst);
12548 12551 if (grp == NULL) {
12549 12552 err = ENOENT;
12550 12553 goto unlock;
12551 12554 }
12552 12555
12553 12556 /*
12554 12557 * Check if the phyint and its ills are suitable for
12555 12558 * inclusion into the group.
12556 12559 */
12557 12560 if ((err = ipmp_grp_vet_phyint(grp, phyi)) != 0)
12558 12561 goto unlock;
12559 12562
12560 12563 /*
12561 12564 * Checks pass; join the group, and enqueue the remaining
12562 12565 * illgrp joins for when we've become part of the group xop
12563 12566 * and are exclusive across its IPSQs. Since qwriter_ip()
12564 12567 * requires an mblk_t to scribble on, and since `mp' will be
12565 12568 * freed as part of completing the ioctl, allocate another.
12566 12569 */
12567 12570 if ((ipsq_mp = allocb(0, BPRI_MED)) == NULL) {
12568 12571 err = ENOMEM;
12569 12572 goto unlock;
12570 12573 }
12571 12574
12572 12575 /*
12573 12576 * Before we drop ipmp_lock, bump gr_pend* to ensure that the
12574 12577 * IPMP meta-interface ills needed by `phyi' cannot go away
12575 12578 * before ip_join_illgrps() is called back. See the comments
12576 12579 * in ip_sioctl_plink_ipmp() for more.
12577 12580 */
12578 12581 if (phyi->phyint_illv4 != NULL)
12579 12582 grp->gr_pendv4++;
12580 12583 if (phyi->phyint_illv6 != NULL)
12581 12584 grp->gr_pendv6++;
12582 12585
12583 12586 rw_exit(&ipst->ips_ipmp_lock);
12584 12587
12585 12588 ipmp_phyint_join_grp(phyi, grp);
12586 12589 ill_refhold(ill);
12587 12590 qwriter_ip(ill, ill->ill_rq, ipsq_mp, ip_join_illgrps,
12588 12591 SWITCH_OP, B_FALSE);
12589 12592 return (0);
12590 12593 } else {
12591 12594 /*
12592 12595 * Request to remove the interface from a group. If the
12593 12596 * interface is not in a group, this trivially succeeds.
12594 12597 */
12595 12598 rw_exit(&ipst->ips_ipmp_lock);
12596 12599 if (IS_UNDER_IPMP(ill))
12597 12600 ipmp_phyint_leave_grp(phyi);
12598 12601 return (0);
12599 12602 }
12600 12603 unlock:
12601 12604 rw_exit(&ipst->ips_ipmp_lock);
12602 12605 return (err);
12603 12606 }
12604 12607
12605 12608 /*
12606 12609 * Process an SIOCGLIFBINDING request.
12607 12610 */
12608 12611 /* ARGSUSED */
12609 12612 int
12610 12613 ip_sioctl_get_binding(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12611 12614 ip_ioctl_cmd_t *ipip, void *ifreq)
12612 12615 {
12613 12616 ill_t *ill;
12614 12617 struct lifreq *lifr = ifreq;
12615 12618 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
12616 12619
12617 12620 if (!IS_IPMP(ipif->ipif_ill))
12618 12621 return (EINVAL);
12619 12622
12620 12623 rw_enter(&ipst->ips_ipmp_lock, RW_READER);
12621 12624 if ((ill = ipif->ipif_bound_ill) == NULL)
12622 12625 lifr->lifr_binding[0] = '\0';
12623 12626 else
12624 12627 (void) strlcpy(lifr->lifr_binding, ill->ill_name, LIFNAMSIZ);
12625 12628 rw_exit(&ipst->ips_ipmp_lock);
12626 12629 return (0);
12627 12630 }
12628 12631
12629 12632 /*
12630 12633 * Process an SIOCGLIFGROUPNAME request.
12631 12634 */
12632 12635 /* ARGSUSED */
12633 12636 int
12634 12637 ip_sioctl_get_groupname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12635 12638 ip_ioctl_cmd_t *ipip, void *ifreq)
12636 12639 {
12637 12640 ipmp_grp_t *grp;
12638 12641 struct lifreq *lifr = ifreq;
12639 12642 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
12640 12643
12641 12644 rw_enter(&ipst->ips_ipmp_lock, RW_READER);
12642 12645 if ((grp = ipif->ipif_ill->ill_phyint->phyint_grp) == NULL)
12643 12646 lifr->lifr_groupname[0] = '\0';
12644 12647 else
12645 12648 (void) strlcpy(lifr->lifr_groupname, grp->gr_name, LIFGRNAMSIZ);
12646 12649 rw_exit(&ipst->ips_ipmp_lock);
12647 12650 return (0);
12648 12651 }
12649 12652
12650 12653 /*
12651 12654 * Process an SIOCGLIFGROUPINFO request.
12652 12655 */
12653 12656 /* ARGSUSED */
12654 12657 int
12655 12658 ip_sioctl_groupinfo(ipif_t *dummy_ipif, sin_t *sin, queue_t *q, mblk_t *mp,
12656 12659 ip_ioctl_cmd_t *ipip, void *dummy)
12657 12660 {
12658 12661 ipmp_grp_t *grp;
12659 12662 lifgroupinfo_t *lifgr;
12660 12663 ip_stack_t *ipst = CONNQ_TO_IPST(q);
12661 12664
12662 12665 /* ip_wput_nondata() verified mp->b_cont->b_cont */
12663 12666 lifgr = (lifgroupinfo_t *)mp->b_cont->b_cont->b_rptr;
12664 12667 lifgr->gi_grname[LIFGRNAMSIZ - 1] = '\0';
12665 12668
12666 12669 rw_enter(&ipst->ips_ipmp_lock, RW_READER);
12667 12670 if ((grp = ipmp_grp_lookup(lifgr->gi_grname, ipst)) == NULL) {
12668 12671 rw_exit(&ipst->ips_ipmp_lock);
12669 12672 return (ENOENT);
12670 12673 }
12671 12674 ipmp_grp_info(grp, lifgr);
12672 12675 rw_exit(&ipst->ips_ipmp_lock);
12673 12676 return (0);
12674 12677 }
12675 12678
12676 12679 static void
12677 12680 ill_dl_down(ill_t *ill)
12678 12681 {
12679 12682 DTRACE_PROBE2(ill__downup, char *, "ill_dl_down", ill_t *, ill);
12680 12683
12681 12684 /*
12682 12685 * The ill is down; unbind but stay attached since we're still
12683 12686 * associated with a PPA. If we have negotiated DLPI capabilites
12684 12687 * with the data link service provider (IDS_OK) then reset them.
12685 12688 * The interval between unbinding and rebinding is potentially
12686 12689 * unbounded hence we cannot assume things will be the same.
12687 12690 * The DLPI capabilities will be probed again when the data link
12688 12691 * is brought up.
12689 12692 */
12690 12693 mblk_t *mp = ill->ill_unbind_mp;
12691 12694
12692 12695 ip1dbg(("ill_dl_down(%s)\n", ill->ill_name));
12693 12696
12694 12697 if (!ill->ill_replumbing) {
12695 12698 /* Free all ilms for this ill */
12696 12699 update_conn_ill(ill, ill->ill_ipst);
12697 12700 } else {
12698 12701 ill_leave_multicast(ill);
12699 12702 }
12700 12703
12701 12704 ill->ill_unbind_mp = NULL;
12702 12705 if (mp != NULL) {
12703 12706 ip1dbg(("ill_dl_down: %s (%u) for %s\n",
12704 12707 dl_primstr(*(int *)mp->b_rptr), *(int *)mp->b_rptr,
12705 12708 ill->ill_name));
12706 12709 mutex_enter(&ill->ill_lock);
12707 12710 ill->ill_state_flags |= ILL_DL_UNBIND_IN_PROGRESS;
12708 12711 mutex_exit(&ill->ill_lock);
12709 12712 /*
12710 12713 * ip_rput does not pass up normal (M_PROTO) DLPI messages
12711 12714 * after ILL_CONDEMNED is set. So in the unplumb case, we call
12712 12715 * ill_capability_dld_disable disable rightaway. If this is not
12713 12716 * an unplumb operation then the disable happens on receipt of
12714 12717 * the capab ack via ip_rput_dlpi_writer ->
12715 12718 * ill_capability_ack_thr. In both cases the order of
12716 12719 * the operations seen by DLD is capability disable followed
12717 12720 * by DL_UNBIND. Also the DLD capability disable needs a
12718 12721 * cv_wait'able context.
12719 12722 */
12720 12723 if (ill->ill_state_flags & ILL_CONDEMNED)
12721 12724 ill_capability_dld_disable(ill);
12722 12725 ill_capability_reset(ill, B_FALSE);
12723 12726 ill_dlpi_send(ill, mp);
12724 12727 }
12725 12728 mutex_enter(&ill->ill_lock);
12726 12729 ill->ill_dl_up = 0;
12727 12730 ill_nic_event_dispatch(ill, 0, NE_DOWN, NULL, 0);
12728 12731 mutex_exit(&ill->ill_lock);
12729 12732 }
12730 12733
12731 12734 void
12732 12735 ill_dlpi_dispatch(ill_t *ill, mblk_t *mp)
12733 12736 {
12734 12737 union DL_primitives *dlp;
12735 12738 t_uscalar_t prim;
12736 12739 boolean_t waitack = B_FALSE;
12737 12740
12738 12741 ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO);
12739 12742
12740 12743 dlp = (union DL_primitives *)mp->b_rptr;
12741 12744 prim = dlp->dl_primitive;
12742 12745
12743 12746 ip1dbg(("ill_dlpi_dispatch: sending %s (%u) to %s\n",
12744 12747 dl_primstr(prim), prim, ill->ill_name));
12745 12748
12746 12749 switch (prim) {
12747 12750 case DL_PHYS_ADDR_REQ:
12748 12751 {
12749 12752 dl_phys_addr_req_t *dlpap = (dl_phys_addr_req_t *)mp->b_rptr;
12750 12753 ill->ill_phys_addr_pend = dlpap->dl_addr_type;
12751 12754 break;
12752 12755 }
12753 12756 case DL_BIND_REQ:
12754 12757 mutex_enter(&ill->ill_lock);
12755 12758 ill->ill_state_flags &= ~ILL_DL_UNBIND_IN_PROGRESS;
12756 12759 mutex_exit(&ill->ill_lock);
12757 12760 break;
12758 12761 }
12759 12762
12760 12763 /*
12761 12764 * Except for the ACKs for the M_PCPROTO messages, all other ACKs
12762 12765 * are dropped by ip_rput() if ILL_CONDEMNED is set. Therefore
12763 12766 * we only wait for the ACK of the DL_UNBIND_REQ.
12764 12767 */
12765 12768 mutex_enter(&ill->ill_lock);
12766 12769 if (!(ill->ill_state_flags & ILL_CONDEMNED) ||
12767 12770 (prim == DL_UNBIND_REQ)) {
12768 12771 ill->ill_dlpi_pending = prim;
12769 12772 waitack = B_TRUE;
12770 12773 }
12771 12774
12772 12775 mutex_exit(&ill->ill_lock);
12773 12776 DTRACE_PROBE3(ill__dlpi, char *, "ill_dlpi_dispatch",
12774 12777 char *, dl_primstr(prim), ill_t *, ill);
12775 12778 putnext(ill->ill_wq, mp);
12776 12779
12777 12780 /*
12778 12781 * There is no ack for DL_NOTIFY_CONF messages
12779 12782 */
12780 12783 if (waitack && prim == DL_NOTIFY_CONF)
12781 12784 ill_dlpi_done(ill, prim);
12782 12785 }
12783 12786
12784 12787 /*
12785 12788 * Helper function for ill_dlpi_send().
12786 12789 */
12787 12790 /* ARGSUSED */
12788 12791 static void
12789 12792 ill_dlpi_send_writer(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *arg)
12790 12793 {
12791 12794 ill_dlpi_send(q->q_ptr, mp);
12792 12795 }
12793 12796
12794 12797 /*
12795 12798 * Send a DLPI control message to the driver but make sure there
12796 12799 * is only one outstanding message. Uses ill_dlpi_pending to tell
12797 12800 * when it must queue. ip_rput_dlpi_writer calls ill_dlpi_done()
12798 12801 * when an ACK or a NAK is received to process the next queued message.
12799 12802 */
12800 12803 void
12801 12804 ill_dlpi_send(ill_t *ill, mblk_t *mp)
12802 12805 {
12803 12806 mblk_t **mpp;
12804 12807
12805 12808 ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO);
12806 12809
12807 12810 /*
12808 12811 * To ensure that any DLPI requests for current exclusive operation
12809 12812 * are always completely sent before any DLPI messages for other
12810 12813 * operations, require writer access before enqueuing.
12811 12814 */
12812 12815 if (!IAM_WRITER_ILL(ill)) {
12813 12816 ill_refhold(ill);
12814 12817 /* qwriter_ip() does the ill_refrele() */
12815 12818 qwriter_ip(ill, ill->ill_wq, mp, ill_dlpi_send_writer,
12816 12819 NEW_OP, B_TRUE);
12817 12820 return;
12818 12821 }
12819 12822
12820 12823 mutex_enter(&ill->ill_lock);
12821 12824 if (ill->ill_dlpi_pending != DL_PRIM_INVAL) {
12822 12825 /* Must queue message. Tail insertion */
12823 12826 mpp = &ill->ill_dlpi_deferred;
12824 12827 while (*mpp != NULL)
12825 12828 mpp = &((*mpp)->b_next);
12826 12829
12827 12830 ip1dbg(("ill_dlpi_send: deferring request for %s "
12828 12831 "while %s pending\n", ill->ill_name,
12829 12832 dl_primstr(ill->ill_dlpi_pending)));
12830 12833
12831 12834 *mpp = mp;
12832 12835 mutex_exit(&ill->ill_lock);
12833 12836 return;
12834 12837 }
12835 12838 mutex_exit(&ill->ill_lock);
12836 12839 ill_dlpi_dispatch(ill, mp);
12837 12840 }
12838 12841
12839 12842 void
12840 12843 ill_capability_send(ill_t *ill, mblk_t *mp)
12841 12844 {
12842 12845 ill->ill_capab_pending_cnt++;
12843 12846 ill_dlpi_send(ill, mp);
12844 12847 }
12845 12848
12846 12849 void
12847 12850 ill_capability_done(ill_t *ill)
12848 12851 {
12849 12852 ASSERT(ill->ill_capab_pending_cnt != 0);
12850 12853
12851 12854 ill_dlpi_done(ill, DL_CAPABILITY_REQ);
12852 12855
12853 12856 ill->ill_capab_pending_cnt--;
12854 12857 if (ill->ill_capab_pending_cnt == 0 &&
12855 12858 ill->ill_dlpi_capab_state == IDCS_OK)
12856 12859 ill_capability_reset_alloc(ill);
12857 12860 }
12858 12861
12859 12862 /*
12860 12863 * Send all deferred DLPI messages without waiting for their ACKs.
12861 12864 */
12862 12865 void
12863 12866 ill_dlpi_send_deferred(ill_t *ill)
12864 12867 {
12865 12868 mblk_t *mp, *nextmp;
12866 12869
12867 12870 /*
12868 12871 * Clear ill_dlpi_pending so that the message is not queued in
12869 12872 * ill_dlpi_send().
12870 12873 */
12871 12874 mutex_enter(&ill->ill_lock);
12872 12875 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12873 12876 mp = ill->ill_dlpi_deferred;
12874 12877 ill->ill_dlpi_deferred = NULL;
12875 12878 mutex_exit(&ill->ill_lock);
12876 12879
12877 12880 for (; mp != NULL; mp = nextmp) {
12878 12881 nextmp = mp->b_next;
12879 12882 mp->b_next = NULL;
12880 12883 ill_dlpi_send(ill, mp);
12881 12884 }
12882 12885 }
12883 12886
12884 12887 /*
12885 12888 * Clear all the deferred DLPI messages. Called on receiving an M_ERROR
12886 12889 * or M_HANGUP
12887 12890 */
12888 12891 static void
12889 12892 ill_dlpi_clear_deferred(ill_t *ill)
12890 12893 {
12891 12894 mblk_t *mp, *nextmp;
12892 12895
12893 12896 mutex_enter(&ill->ill_lock);
12894 12897 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12895 12898 mp = ill->ill_dlpi_deferred;
12896 12899 ill->ill_dlpi_deferred = NULL;
12897 12900 mutex_exit(&ill->ill_lock);
12898 12901
12899 12902 for (; mp != NULL; mp = nextmp) {
12900 12903 nextmp = mp->b_next;
12901 12904 inet_freemsg(mp);
12902 12905 }
12903 12906 }
12904 12907
12905 12908 /*
12906 12909 * Check if the DLPI primitive `prim' is pending; print a warning if not.
12907 12910 */
12908 12911 boolean_t
12909 12912 ill_dlpi_pending(ill_t *ill, t_uscalar_t prim)
12910 12913 {
12911 12914 t_uscalar_t pending;
12912 12915
12913 12916 mutex_enter(&ill->ill_lock);
12914 12917 if (ill->ill_dlpi_pending == prim) {
12915 12918 mutex_exit(&ill->ill_lock);
12916 12919 return (B_TRUE);
12917 12920 }
12918 12921
12919 12922 /*
12920 12923 * During teardown, ill_dlpi_dispatch() will send DLPI requests
12921 12924 * without waiting, so don't print any warnings in that case.
12922 12925 */
12923 12926 if (ill->ill_state_flags & ILL_CONDEMNED) {
12924 12927 mutex_exit(&ill->ill_lock);
12925 12928 return (B_FALSE);
12926 12929 }
12927 12930 pending = ill->ill_dlpi_pending;
12928 12931 mutex_exit(&ill->ill_lock);
12929 12932
12930 12933 if (pending == DL_PRIM_INVAL) {
12931 12934 (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE,
12932 12935 "received unsolicited ack for %s on %s\n",
12933 12936 dl_primstr(prim), ill->ill_name);
12934 12937 } else {
12935 12938 (void) mi_strlog(ill->ill_rq, 1, SL_CONSOLE|SL_ERROR|SL_TRACE,
12936 12939 "received unexpected ack for %s on %s (expecting %s)\n",
12937 12940 dl_primstr(prim), ill->ill_name, dl_primstr(pending));
12938 12941 }
12939 12942 return (B_FALSE);
12940 12943 }
12941 12944
12942 12945 /*
12943 12946 * Complete the current DLPI operation associated with `prim' on `ill' and
12944 12947 * start the next queued DLPI operation (if any). If there are no queued DLPI
12945 12948 * operations and the ill's current exclusive IPSQ operation has finished
12946 12949 * (i.e., ipsq_current_finish() was called), then clear ipsq_current_ipif to
12947 12950 * allow the next exclusive IPSQ operation to begin upon ipsq_exit(). See
12948 12951 * the comments above ipsq_current_finish() for details.
12949 12952 */
12950 12953 void
12951 12954 ill_dlpi_done(ill_t *ill, t_uscalar_t prim)
12952 12955 {
12953 12956 mblk_t *mp;
12954 12957 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
12955 12958 ipxop_t *ipx = ipsq->ipsq_xop;
12956 12959
12957 12960 ASSERT(IAM_WRITER_IPSQ(ipsq));
12958 12961 mutex_enter(&ill->ill_lock);
12959 12962
12960 12963 ASSERT(prim != DL_PRIM_INVAL);
12961 12964 ASSERT(ill->ill_dlpi_pending == prim);
12962 12965
12963 12966 ip1dbg(("ill_dlpi_done: %s has completed %s (%u)\n", ill->ill_name,
12964 12967 dl_primstr(ill->ill_dlpi_pending), ill->ill_dlpi_pending));
12965 12968
12966 12969 if ((mp = ill->ill_dlpi_deferred) == NULL) {
12967 12970 ill->ill_dlpi_pending = DL_PRIM_INVAL;
12968 12971 if (ipx->ipx_current_done) {
12969 12972 mutex_enter(&ipx->ipx_lock);
12970 12973 ipx->ipx_current_ipif = NULL;
12971 12974 mutex_exit(&ipx->ipx_lock);
12972 12975 }
12973 12976 cv_signal(&ill->ill_cv);
12974 12977 mutex_exit(&ill->ill_lock);
12975 12978 return;
12976 12979 }
12977 12980
12978 12981 ill->ill_dlpi_deferred = mp->b_next;
12979 12982 mp->b_next = NULL;
12980 12983 mutex_exit(&ill->ill_lock);
12981 12984
12982 12985 ill_dlpi_dispatch(ill, mp);
12983 12986 }
12984 12987
12985 12988 /*
12986 12989 * Queue a (multicast) DLPI control message to be sent to the driver by
12987 12990 * later calling ill_dlpi_send_queued.
12988 12991 * We queue them while holding a lock (ill_mcast_lock) to ensure that they
12989 12992 * are sent in order i.e., prevent a DL_DISABMULTI_REQ and DL_ENABMULTI_REQ
12990 12993 * for the same group to race.
12991 12994 * We send DLPI control messages in order using ill_lock.
12992 12995 * For IPMP we should be called on the cast_ill.
12993 12996 */
12994 12997 void
12995 12998 ill_dlpi_queue(ill_t *ill, mblk_t *mp)
12996 12999 {
12997 13000 mblk_t **mpp;
12998 13001
12999 13002 ASSERT(DB_TYPE(mp) == M_PROTO || DB_TYPE(mp) == M_PCPROTO);
13000 13003
13001 13004 mutex_enter(&ill->ill_lock);
13002 13005 /* Must queue message. Tail insertion */
13003 13006 mpp = &ill->ill_dlpi_deferred;
13004 13007 while (*mpp != NULL)
13005 13008 mpp = &((*mpp)->b_next);
13006 13009
13007 13010 *mpp = mp;
13008 13011 mutex_exit(&ill->ill_lock);
13009 13012 }
13010 13013
13011 13014 /*
13012 13015 * Send the messages that were queued. Make sure there is only
13013 13016 * one outstanding message. ip_rput_dlpi_writer calls ill_dlpi_done()
13014 13017 * when an ACK or a NAK is received to process the next queued message.
13015 13018 * For IPMP we are called on the upper ill, but when send what is queued
13016 13019 * on the cast_ill.
13017 13020 */
13018 13021 void
13019 13022 ill_dlpi_send_queued(ill_t *ill)
13020 13023 {
13021 13024 mblk_t *mp;
13022 13025 union DL_primitives *dlp;
13023 13026 t_uscalar_t prim;
13024 13027 ill_t *release_ill = NULL;
13025 13028
13026 13029 if (IS_IPMP(ill)) {
13027 13030 /* On the upper IPMP ill. */
13028 13031 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13029 13032 if (release_ill == NULL) {
13030 13033 /* Avoid ever sending anything down to the ipmpstub */
13031 13034 return;
13032 13035 }
13033 13036 ill = release_ill;
13034 13037 }
13035 13038 mutex_enter(&ill->ill_lock);
13036 13039 while ((mp = ill->ill_dlpi_deferred) != NULL) {
13037 13040 if (ill->ill_dlpi_pending != DL_PRIM_INVAL) {
13038 13041 /* Can't send. Somebody else will send it */
13039 13042 mutex_exit(&ill->ill_lock);
13040 13043 goto done;
13041 13044 }
13042 13045 ill->ill_dlpi_deferred = mp->b_next;
13043 13046 mp->b_next = NULL;
13044 13047 if (!ill->ill_dl_up) {
13045 13048 /*
13046 13049 * Nobody there. All multicast addresses will be
13047 13050 * re-joined when we get the DL_BIND_ACK bringing the
13048 13051 * interface up.
13049 13052 */
13050 13053 freemsg(mp);
13051 13054 continue;
13052 13055 }
13053 13056 dlp = (union DL_primitives *)mp->b_rptr;
13054 13057 prim = dlp->dl_primitive;
13055 13058
13056 13059 if (!(ill->ill_state_flags & ILL_CONDEMNED) ||
13057 13060 (prim == DL_UNBIND_REQ)) {
13058 13061 ill->ill_dlpi_pending = prim;
13059 13062 }
13060 13063 mutex_exit(&ill->ill_lock);
13061 13064
13062 13065 DTRACE_PROBE3(ill__dlpi, char *, "ill_dlpi_send_queued",
13063 13066 char *, dl_primstr(prim), ill_t *, ill);
13064 13067 putnext(ill->ill_wq, mp);
13065 13068 mutex_enter(&ill->ill_lock);
13066 13069 }
13067 13070 mutex_exit(&ill->ill_lock);
13068 13071 done:
13069 13072 if (release_ill != NULL)
13070 13073 ill_refrele(release_ill);
13071 13074 }
13072 13075
13073 13076 /*
13074 13077 * Queue an IP (IGMP/MLD) message to be sent by IP from
13075 13078 * ill_mcast_send_queued
13076 13079 * We queue them while holding a lock (ill_mcast_lock) to ensure that they
13077 13080 * are sent in order i.e., prevent a IGMP leave and IGMP join for the same
13078 13081 * group to race.
13079 13082 * We send them in order using ill_lock.
13080 13083 * For IPMP we are called on the upper ill, but we queue on the cast_ill.
13081 13084 */
13082 13085 void
13083 13086 ill_mcast_queue(ill_t *ill, mblk_t *mp)
13084 13087 {
13085 13088 mblk_t **mpp;
13086 13089 ill_t *release_ill = NULL;
13087 13090
13088 13091 ASSERT(RW_LOCK_HELD(&ill->ill_mcast_lock));
13089 13092
13090 13093 if (IS_IPMP(ill)) {
13091 13094 /* On the upper IPMP ill. */
13092 13095 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13093 13096 if (release_ill == NULL) {
13094 13097 /* Discard instead of queuing for the ipmp interface */
13095 13098 BUMP_MIB(ill->ill_ip_mib, ipIfStatsOutDiscards);
13096 13099 ip_drop_output("ipIfStatsOutDiscards - no cast_ill",
13097 13100 mp, ill);
13098 13101 freemsg(mp);
13099 13102 return;
13100 13103 }
13101 13104 ill = release_ill;
13102 13105 }
13103 13106
13104 13107 mutex_enter(&ill->ill_lock);
13105 13108 /* Must queue message. Tail insertion */
13106 13109 mpp = &ill->ill_mcast_deferred;
13107 13110 while (*mpp != NULL)
13108 13111 mpp = &((*mpp)->b_next);
13109 13112
13110 13113 *mpp = mp;
13111 13114 mutex_exit(&ill->ill_lock);
13112 13115 if (release_ill != NULL)
13113 13116 ill_refrele(release_ill);
13114 13117 }
13115 13118
13116 13119 /*
13117 13120 * Send the IP packets that were queued by ill_mcast_queue.
13118 13121 * These are IGMP/MLD packets.
13119 13122 *
13120 13123 * For IPMP we are called on the upper ill, but when send what is queued
13121 13124 * on the cast_ill.
13122 13125 *
13123 13126 * Request loopback of the report if we are acting as a multicast
13124 13127 * router, so that the process-level routing demon can hear it.
13125 13128 * This will run multiple times for the same group if there are members
13126 13129 * on the same group for multiple ipif's on the same ill. The
13127 13130 * igmp_input/mld_input code will suppress this due to the loopback thus we
13128 13131 * always loopback membership report.
13129 13132 *
13130 13133 * We also need to make sure that this does not get load balanced
13131 13134 * by IPMP. We do this by passing an ill to ip_output_simple.
13132 13135 */
13133 13136 void
13134 13137 ill_mcast_send_queued(ill_t *ill)
13135 13138 {
13136 13139 mblk_t *mp;
13137 13140 ip_xmit_attr_t ixas;
13138 13141 ill_t *release_ill = NULL;
13139 13142
13140 13143 if (IS_IPMP(ill)) {
13141 13144 /* On the upper IPMP ill. */
13142 13145 release_ill = ipmp_illgrp_hold_cast_ill(ill->ill_grp);
13143 13146 if (release_ill == NULL) {
13144 13147 /*
13145 13148 * We should have no messages on the ipmp interface
13146 13149 * but no point in trying to send them.
13147 13150 */
13148 13151 return;
13149 13152 }
13150 13153 ill = release_ill;
13151 13154 }
13152 13155 bzero(&ixas, sizeof (ixas));
13153 13156 ixas.ixa_zoneid = ALL_ZONES;
13154 13157 ixas.ixa_cred = kcred;
13155 13158 ixas.ixa_cpid = NOPID;
13156 13159 ixas.ixa_tsl = NULL;
13157 13160 /*
13158 13161 * Here we set ixa_ifindex. If IPMP it will be the lower ill which
13159 13162 * makes ip_select_route pick the IRE_MULTICAST for the cast_ill.
13160 13163 * That is necessary to handle IGMP/MLD snooping switches.
13161 13164 */
13162 13165 ixas.ixa_ifindex = ill->ill_phyint->phyint_ifindex;
13163 13166 ixas.ixa_ipst = ill->ill_ipst;
13164 13167
13165 13168 mutex_enter(&ill->ill_lock);
13166 13169 while ((mp = ill->ill_mcast_deferred) != NULL) {
13167 13170 ill->ill_mcast_deferred = mp->b_next;
13168 13171 mp->b_next = NULL;
13169 13172 if (!ill->ill_dl_up) {
13170 13173 /*
13171 13174 * Nobody there. Just drop the ip packets.
13172 13175 * IGMP/MLD will resend later, if this is a replumb.
13173 13176 */
13174 13177 freemsg(mp);
13175 13178 continue;
13176 13179 }
13177 13180 mutex_enter(&ill->ill_phyint->phyint_lock);
13178 13181 if (IS_UNDER_IPMP(ill) && !ipmp_ill_is_active(ill)) {
13179 13182 /*
13180 13183 * When the ill is getting deactivated, we only want to
13181 13184 * send the DLPI messages, so drop IGMP/MLD packets.
13182 13185 * DLPI messages are handled by ill_dlpi_send_queued()
13183 13186 */
13184 13187 mutex_exit(&ill->ill_phyint->phyint_lock);
13185 13188 freemsg(mp);
13186 13189 continue;
13187 13190 }
13188 13191 mutex_exit(&ill->ill_phyint->phyint_lock);
13189 13192 mutex_exit(&ill->ill_lock);
13190 13193
13191 13194 /* Check whether we are sending IPv4 or IPv6. */
13192 13195 if (ill->ill_isv6) {
13193 13196 ip6_t *ip6h = (ip6_t *)mp->b_rptr;
13194 13197
13195 13198 ixas.ixa_multicast_ttl = ip6h->ip6_hops;
13196 13199 ixas.ixa_flags = IXAF_BASIC_SIMPLE_V6;
13197 13200 } else {
13198 13201 ipha_t *ipha = (ipha_t *)mp->b_rptr;
13199 13202
13200 13203 ixas.ixa_multicast_ttl = ipha->ipha_ttl;
13201 13204 ixas.ixa_flags = IXAF_BASIC_SIMPLE_V4;
13202 13205 ixas.ixa_flags &= ~IXAF_SET_ULP_CKSUM;
13203 13206 }
13204 13207 ixas.ixa_flags &= ~IXAF_VERIFY_SOURCE;
13205 13208 ixas.ixa_flags |= IXAF_MULTICAST_LOOP | IXAF_SET_SOURCE;
13206 13209 (void) ip_output_simple(mp, &ixas);
13207 13210 ixa_cleanup(&ixas);
13208 13211
13209 13212 mutex_enter(&ill->ill_lock);
13210 13213 }
13211 13214 mutex_exit(&ill->ill_lock);
13212 13215
13213 13216 done:
13214 13217 if (release_ill != NULL)
13215 13218 ill_refrele(release_ill);
13216 13219 }
13217 13220
13218 13221 /*
13219 13222 * Take down a specific interface, but don't lose any information about it.
13220 13223 * (Always called as writer.)
13221 13224 * This function goes through the down sequence even if the interface is
13222 13225 * already down. There are 2 reasons.
13223 13226 * a. Currently we permit interface routes that depend on down interfaces
13224 13227 * to be added. This behaviour itself is questionable. However it appears
13225 13228 * that both Solaris and 4.3 BSD have exhibited this behaviour for a long
13226 13229 * time. We go thru the cleanup in order to remove these routes.
13227 13230 * b. The bringup of the interface could fail in ill_dl_up i.e. we get
13228 13231 * DL_ERROR_ACK in response to the DL_BIND request. The interface is
13229 13232 * down, but we need to cleanup i.e. do ill_dl_down and
13230 13233 * ip_rput_dlpi_writer (DL_ERROR_ACK) -> ipif_down.
13231 13234 *
13232 13235 * IP-MT notes:
13233 13236 *
13234 13237 * Model of reference to interfaces.
13235 13238 *
13236 13239 * The following members in ipif_t track references to the ipif.
13237 13240 * int ipif_refcnt; Active reference count
13238 13241 *
13239 13242 * The following members in ill_t track references to the ill.
13240 13243 * int ill_refcnt; active refcnt
13241 13244 * uint_t ill_ire_cnt; Number of ires referencing ill
13242 13245 * uint_t ill_ncec_cnt; Number of ncecs referencing ill
13243 13246 * uint_t ill_nce_cnt; Number of nces referencing ill
13244 13247 * uint_t ill_ilm_cnt; Number of ilms referencing ill
13245 13248 *
13246 13249 * Reference to an ipif or ill can be obtained in any of the following ways.
13247 13250 *
13248 13251 * Through the lookup functions ipif_lookup_* / ill_lookup_* functions
13249 13252 * Pointers to ipif / ill from other data structures viz ire and conn.
13250 13253 * Implicit reference to the ipif / ill by holding a reference to the ire.
13251 13254 *
13252 13255 * The ipif/ill lookup functions return a reference held ipif / ill.
13253 13256 * ipif_refcnt and ill_refcnt track the reference counts respectively.
13254 13257 * This is a purely dynamic reference count associated with threads holding
13255 13258 * references to the ipif / ill. Pointers from other structures do not
13256 13259 * count towards this reference count.
13257 13260 *
13258 13261 * ill_ire_cnt is the number of ire's associated with the
13259 13262 * ill. This is incremented whenever a new ire is created referencing the
13260 13263 * ill. This is done atomically inside ire_add_v[46] where the ire is
13261 13264 * actually added to the ire hash table. The count is decremented in
13262 13265 * ire_inactive where the ire is destroyed.
13263 13266 *
13264 13267 * ill_ncec_cnt is the number of ncec's referencing the ill thru ncec_ill.
13265 13268 * This is incremented atomically in
13266 13269 * ndp_add_v4()/ndp_add_v6() where the nce is actually added to the
13267 13270 * table. Similarly it is decremented in ncec_inactive() where the ncec
13268 13271 * is destroyed.
13269 13272 *
13270 13273 * ill_nce_cnt is the number of nce's referencing the ill thru nce_ill. This is
13271 13274 * incremented atomically in nce_add() where the nce is actually added to the
13272 13275 * ill_nce. Similarly it is decremented in nce_inactive() where the nce
13273 13276 * is destroyed.
13274 13277 *
13275 13278 * ill_ilm_cnt is the ilm's reference to the ill. It is incremented in
13276 13279 * ilm_add() and decremented before the ilm is freed in ilm_delete().
13277 13280 *
13278 13281 * Flow of ioctls involving interface down/up
13279 13282 *
13280 13283 * The following is the sequence of an attempt to set some critical flags on an
13281 13284 * up interface.
13282 13285 * ip_sioctl_flags
13283 13286 * ipif_down
13284 13287 * wait for ipif to be quiescent
13285 13288 * ipif_down_tail
13286 13289 * ip_sioctl_flags_tail
13287 13290 *
13288 13291 * All set ioctls that involve down/up sequence would have a skeleton similar
13289 13292 * to the above. All the *tail functions are called after the refcounts have
13290 13293 * dropped to the appropriate values.
13291 13294 *
13292 13295 * SIOC ioctls during the IPIF_CHANGING interval.
13293 13296 *
13294 13297 * Threads handling SIOC set ioctls serialize on the squeue, but this
13295 13298 * is not done for SIOC get ioctls. Since a set ioctl can cause several
13296 13299 * steps of internal changes to the state, some of which are visible in
13297 13300 * ipif_flags (such as IFF_UP being cleared and later set), and we want
13298 13301 * the set ioctl to be atomic related to the get ioctls, the SIOC get code
13299 13302 * will wait and restart ioctls if IPIF_CHANGING is set. The mblk is then
13300 13303 * enqueued in the ipsq and the operation is restarted by ipsq_exit() when
13301 13304 * the current exclusive operation completes. The IPIF_CHANGING check
13302 13305 * and enqueue is atomic using the ill_lock and ipsq_lock. The
13303 13306 * lookup is done holding the ill_lock. Hence the ill/ipif state flags can't
13304 13307 * change while the ill_lock is held. Before dropping the ill_lock we acquire
13305 13308 * the ipsq_lock and call ipsq_enq. This ensures that ipsq_exit can't finish
13306 13309 * until we release the ipsq_lock, even though the ill/ipif state flags
13307 13310 * can change after we drop the ill_lock.
13308 13311 */
13309 13312 int
13310 13313 ipif_down(ipif_t *ipif, queue_t *q, mblk_t *mp)
13311 13314 {
13312 13315 ill_t *ill = ipif->ipif_ill;
13313 13316 conn_t *connp;
13314 13317 boolean_t success;
13315 13318 boolean_t ipif_was_up = B_FALSE;
13316 13319 ip_stack_t *ipst = ill->ill_ipst;
13317 13320
13318 13321 ASSERT(IAM_WRITER_IPIF(ipif));
13319 13322
13320 13323 ip1dbg(("ipif_down(%s:%u)\n", ill->ill_name, ipif->ipif_id));
13321 13324
13322 13325 DTRACE_PROBE3(ipif__downup, char *, "ipif_down",
13323 13326 ill_t *, ill, ipif_t *, ipif);
13324 13327
13325 13328 if (ipif->ipif_flags & IPIF_UP) {
13326 13329 mutex_enter(&ill->ill_lock);
13327 13330 ipif->ipif_flags &= ~IPIF_UP;
13328 13331 ASSERT(ill->ill_ipif_up_count > 0);
13329 13332 --ill->ill_ipif_up_count;
13330 13333 mutex_exit(&ill->ill_lock);
13331 13334 ipif_was_up = B_TRUE;
13332 13335 /* Update status in SCTP's list */
13333 13336 sctp_update_ipif(ipif, SCTP_IPIF_DOWN);
13334 13337 ill_nic_event_dispatch(ipif->ipif_ill,
13335 13338 MAP_IPIF_ID(ipif->ipif_id), NE_LIF_DOWN, NULL, 0);
13336 13339 }
13337 13340
13338 13341 /*
13339 13342 * Removal of the last ipif from an ill may result in a DL_UNBIND
13340 13343 * being sent to the driver, and we must not send any data packets to
13341 13344 * the driver after the DL_UNBIND_REQ. To ensure this, all the
13342 13345 * ire and nce entries used in the data path will be cleaned
13343 13346 * up, and we also set the ILL_DOWN_IN_PROGRESS bit to make
13344 13347 * sure on new entries will be added until the ill is bound
13345 13348 * again. The ILL_DOWN_IN_PROGRESS bit is turned off upon
13346 13349 * receipt of a DL_BIND_ACK.
13347 13350 */
13348 13351 if (ill->ill_wq != NULL && !ill->ill_logical_down &&
13349 13352 ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
13350 13353 ill->ill_dl_up) {
13351 13354 ill->ill_state_flags |= ILL_DOWN_IN_PROGRESS;
13352 13355 }
13353 13356
13354 13357 /*
13355 13358 * Blow away memberships we established in ipif_multicast_up().
13356 13359 */
13357 13360 ipif_multicast_down(ipif);
13358 13361
13359 13362 /*
13360 13363 * Remove from the mapping for __sin6_src_id. We insert only
13361 13364 * when the address is not INADDR_ANY. As IPv4 addresses are
13362 13365 * stored as mapped addresses, we need to check for mapped
13363 13366 * INADDR_ANY also.
13364 13367 */
13365 13368 if (ipif_was_up && !IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) &&
13366 13369 !IN6_IS_ADDR_V4MAPPED_ANY(&ipif->ipif_v6lcl_addr) &&
13367 13370 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
13368 13371 int err;
13369 13372
13370 13373 err = ip_srcid_remove(&ipif->ipif_v6lcl_addr,
13371 13374 ipif->ipif_zoneid, ipst);
13372 13375 if (err != 0) {
13373 13376 ip0dbg(("ipif_down: srcid_remove %d\n", err));
13374 13377 }
13375 13378 }
13376 13379
13377 13380 if (ipif_was_up) {
13378 13381 /* only delete if we'd added ire's before */
13379 13382 if (ipif->ipif_isv6)
13380 13383 ipif_delete_ires_v6(ipif);
13381 13384 else
13382 13385 ipif_delete_ires_v4(ipif);
13383 13386 }
13384 13387
13385 13388 if (ipif_was_up && ill->ill_ipif_up_count == 0) {
13386 13389 /*
13387 13390 * Since the interface is now down, it may have just become
13388 13391 * inactive. Note that this needs to be done even for a
13389 13392 * lll_logical_down(), or ARP entries will not get correctly
13390 13393 * restored when the interface comes back up.
13391 13394 */
13392 13395 if (IS_UNDER_IPMP(ill))
13393 13396 ipmp_ill_refresh_active(ill);
13394 13397 }
13395 13398
13396 13399 /*
13397 13400 * neighbor-discovery or arp entries for this interface. The ipif
13398 13401 * has to be quiesced, so we walk all the nce's and delete those
13399 13402 * that point at the ipif->ipif_ill. At the same time, we also
13400 13403 * update IPMP so that ipifs for data addresses are unbound. We dont
13401 13404 * call ipif_arp_down to DL_UNBIND the arp stream itself here, but defer
13402 13405 * that for ipif_down_tail()
13403 13406 */
13404 13407 ipif_nce_down(ipif);
13405 13408
13406 13409 /*
13407 13410 * If this is the last ipif on the ill, we also need to remove
13408 13411 * any IREs with ire_ill set. Otherwise ipif_is_quiescent() will
13409 13412 * never succeed.
13410 13413 */
13411 13414 if (ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0)
13412 13415 ire_walk_ill(0, 0, ill_downi, ill, ill);
13413 13416
13414 13417 /*
13415 13418 * Walk all CONNs that can have a reference on an ire for this
13416 13419 * ipif (we actually walk all that now have stale references).
13417 13420 */
13418 13421 ipcl_walk(conn_ixa_cleanup, (void *)B_TRUE, ipst);
13419 13422
13420 13423 /*
13421 13424 * If mp is NULL the caller will wait for the appropriate refcnt.
13422 13425 * Eg. ip_sioctl_removeif -> ipif_free -> ipif_down
13423 13426 * and ill_delete -> ipif_free -> ipif_down
13424 13427 */
13425 13428 if (mp == NULL) {
13426 13429 ASSERT(q == NULL);
13427 13430 return (0);
13428 13431 }
13429 13432
13430 13433 if (CONN_Q(q)) {
13431 13434 connp = Q_TO_CONN(q);
13432 13435 mutex_enter(&connp->conn_lock);
13433 13436 } else {
13434 13437 connp = NULL;
13435 13438 }
13436 13439 mutex_enter(&ill->ill_lock);
13437 13440 /*
13438 13441 * Are there any ire's pointing to this ipif that are still active ?
13439 13442 * If this is the last ipif going down, are there any ire's pointing
13440 13443 * to this ill that are still active ?
13441 13444 */
13442 13445 if (ipif_is_quiescent(ipif)) {
13443 13446 mutex_exit(&ill->ill_lock);
13444 13447 if (connp != NULL)
13445 13448 mutex_exit(&connp->conn_lock);
13446 13449 return (0);
13447 13450 }
13448 13451
13449 13452 ip1dbg(("ipif_down: need to wait, adding pending mp %s ill %p",
13450 13453 ill->ill_name, (void *)ill));
13451 13454 /*
13452 13455 * Enqueue the mp atomically in ipsq_pending_mp. When the refcount
13453 13456 * drops down, the operation will be restarted by ipif_ill_refrele_tail
13454 13457 * which in turn is called by the last refrele on the ipif/ill/ire.
13455 13458 */
13456 13459 success = ipsq_pending_mp_add(connp, ipif, q, mp, IPIF_DOWN);
13457 13460 if (!success) {
13458 13461 /* The conn is closing. So just return */
13459 13462 ASSERT(connp != NULL);
13460 13463 mutex_exit(&ill->ill_lock);
13461 13464 mutex_exit(&connp->conn_lock);
13462 13465 return (EINTR);
13463 13466 }
13464 13467
13465 13468 mutex_exit(&ill->ill_lock);
13466 13469 if (connp != NULL)
13467 13470 mutex_exit(&connp->conn_lock);
13468 13471 return (EINPROGRESS);
13469 13472 }
13470 13473
13471 13474 int
13472 13475 ipif_down_tail(ipif_t *ipif)
13473 13476 {
13474 13477 ill_t *ill = ipif->ipif_ill;
13475 13478 int err = 0;
13476 13479
13477 13480 DTRACE_PROBE3(ipif__downup, char *, "ipif_down_tail",
13478 13481 ill_t *, ill, ipif_t *, ipif);
13479 13482
13480 13483 /*
13481 13484 * Skip any loopback interface (null wq).
13482 13485 * If this is the last logical interface on the ill
13483 13486 * have ill_dl_down tell the driver we are gone (unbind)
13484 13487 * Note that lun 0 can ipif_down even though
13485 13488 * there are other logical units that are up.
13486 13489 * This occurs e.g. when we change a "significant" IFF_ flag.
13487 13490 */
13488 13491 if (ill->ill_wq != NULL && !ill->ill_logical_down &&
13489 13492 ill->ill_ipif_up_count == 0 && ill->ill_ipif_dup_count == 0 &&
13490 13493 ill->ill_dl_up) {
13491 13494 ill_dl_down(ill);
13492 13495 }
13493 13496 if (!ipif->ipif_isv6)
13494 13497 err = ipif_arp_down(ipif);
13495 13498
13496 13499 ill->ill_logical_down = 0;
13497 13500
13498 13501 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
13499 13502 ip_rts_newaddrmsg(RTM_DELETE, 0, ipif, RTSQ_DEFAULT);
13500 13503 return (err);
13501 13504 }
13502 13505
13503 13506 /*
13504 13507 * Bring interface logically down without bringing the physical interface
13505 13508 * down e.g. when the netmask is changed. This avoids long lasting link
13506 13509 * negotiations between an ethernet interface and a certain switches.
13507 13510 */
13508 13511 static int
13509 13512 ipif_logical_down(ipif_t *ipif, queue_t *q, mblk_t *mp)
13510 13513 {
13511 13514 DTRACE_PROBE3(ipif__downup, char *, "ipif_logical_down",
13512 13515 ill_t *, ipif->ipif_ill, ipif_t *, ipif);
13513 13516
13514 13517 /*
13515 13518 * The ill_logical_down flag is a transient flag. It is set here
13516 13519 * and is cleared once the down has completed in ipif_down_tail.
13517 13520 * This flag does not indicate whether the ill stream is in the
13518 13521 * DL_BOUND state with the driver. Instead this flag is used by
13519 13522 * ipif_down_tail to determine whether to DL_UNBIND the stream with
13520 13523 * the driver. The state of the ill stream i.e. whether it is
13521 13524 * DL_BOUND with the driver or not is indicated by the ill_dl_up flag.
13522 13525 */
13523 13526 ipif->ipif_ill->ill_logical_down = 1;
13524 13527 return (ipif_down(ipif, q, mp));
13525 13528 }
13526 13529
13527 13530 /*
13528 13531 * Initiate deallocate of an IPIF. Always called as writer. Called by
13529 13532 * ill_delete or ip_sioctl_removeif.
13530 13533 */
13531 13534 static void
13532 13535 ipif_free(ipif_t *ipif)
13533 13536 {
13534 13537 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13535 13538
13536 13539 ASSERT(IAM_WRITER_IPIF(ipif));
13537 13540
13538 13541 if (ipif->ipif_recovery_id != 0)
13539 13542 (void) untimeout(ipif->ipif_recovery_id);
13540 13543 ipif->ipif_recovery_id = 0;
13541 13544
13542 13545 /*
13543 13546 * Take down the interface. We can be called either from ill_delete
13544 13547 * or from ip_sioctl_removeif.
13545 13548 */
13546 13549 (void) ipif_down(ipif, NULL, NULL);
13547 13550
13548 13551 /*
13549 13552 * Now that the interface is down, there's no chance it can still
13550 13553 * become a duplicate. Cancel any timer that may have been set while
13551 13554 * tearing down.
13552 13555 */
13553 13556 if (ipif->ipif_recovery_id != 0)
13554 13557 (void) untimeout(ipif->ipif_recovery_id);
13555 13558 ipif->ipif_recovery_id = 0;
13556 13559
13557 13560 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
13558 13561 /* Remove pointers to this ill in the multicast routing tables */
13559 13562 reset_mrt_vif_ipif(ipif);
13560 13563 /* If necessary, clear the cached source ipif rotor. */
13561 13564 if (ipif->ipif_ill->ill_src_ipif == ipif)
13562 13565 ipif->ipif_ill->ill_src_ipif = NULL;
13563 13566 rw_exit(&ipst->ips_ill_g_lock);
13564 13567 }
13565 13568
13566 13569 static void
13567 13570 ipif_free_tail(ipif_t *ipif)
13568 13571 {
13569 13572 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13570 13573
13571 13574 /*
13572 13575 * Need to hold both ill_g_lock and ill_lock while
13573 13576 * inserting or removing an ipif from the linked list
13574 13577 * of ipifs hanging off the ill.
13575 13578 */
13576 13579 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
13577 13580
13578 13581 #ifdef DEBUG
13579 13582 ipif_trace_cleanup(ipif);
13580 13583 #endif
13581 13584
13582 13585 /* Ask SCTP to take it out of it list */
13583 13586 sctp_update_ipif(ipif, SCTP_IPIF_REMOVE);
13584 13587 ip_rts_newaddrmsg(RTM_FREEADDR, 0, ipif, RTSQ_DEFAULT);
13585 13588
13586 13589 /* Get it out of the ILL interface list. */
13587 13590 ipif_remove(ipif);
13588 13591 rw_exit(&ipst->ips_ill_g_lock);
13589 13592
13590 13593 ASSERT(!(ipif->ipif_flags & (IPIF_UP | IPIF_DUPLICATE)));
13591 13594 ASSERT(ipif->ipif_recovery_id == 0);
13592 13595 ASSERT(ipif->ipif_ire_local == NULL);
13593 13596 ASSERT(ipif->ipif_ire_if == NULL);
13594 13597
13595 13598 /* Free the memory. */
13596 13599 mi_free(ipif);
13597 13600 }
13598 13601
13599 13602 /*
13600 13603 * Sets `buf' to an ipif name of the form "ill_name:id", or "ill_name" if "id"
13601 13604 * is zero.
13602 13605 */
13603 13606 void
13604 13607 ipif_get_name(const ipif_t *ipif, char *buf, int len)
13605 13608 {
13606 13609 char lbuf[LIFNAMSIZ];
13607 13610 char *name;
13608 13611 size_t name_len;
13609 13612
13610 13613 buf[0] = '\0';
13611 13614 name = ipif->ipif_ill->ill_name;
13612 13615 name_len = ipif->ipif_ill->ill_name_length;
13613 13616 if (ipif->ipif_id != 0) {
13614 13617 (void) sprintf(lbuf, "%s%c%d", name, IPIF_SEPARATOR_CHAR,
13615 13618 ipif->ipif_id);
13616 13619 name = lbuf;
13617 13620 name_len = mi_strlen(name) + 1;
13618 13621 }
13619 13622 len -= 1;
13620 13623 buf[len] = '\0';
13621 13624 len = MIN(len, name_len);
13622 13625 bcopy(name, buf, len);
13623 13626 }
13624 13627
13625 13628 /*
13626 13629 * Sets `buf' to an ill name.
13627 13630 */
13628 13631 void
13629 13632 ill_get_name(const ill_t *ill, char *buf, int len)
13630 13633 {
13631 13634 char *name;
13632 13635 size_t name_len;
13633 13636
13634 13637 name = ill->ill_name;
13635 13638 name_len = ill->ill_name_length;
13636 13639 len -= 1;
13637 13640 buf[len] = '\0';
13638 13641 len = MIN(len, name_len);
13639 13642 bcopy(name, buf, len);
13640 13643 }
13641 13644
13642 13645 /*
13643 13646 * Find an IPIF based on the name passed in. Names can be of the form <phys>
13644 13647 * (e.g., le0) or <phys>:<#> (e.g., le0:1). When there is no colon, the
13645 13648 * implied unit id is zero. <phys> must correspond to the name of an ILL.
13646 13649 * (May be called as writer.)
13647 13650 */
13648 13651 static ipif_t *
13649 13652 ipif_lookup_on_name(char *name, size_t namelen, boolean_t do_alloc,
13650 13653 boolean_t *exists, boolean_t isv6, zoneid_t zoneid, ip_stack_t *ipst)
13651 13654 {
13652 13655 char *cp;
13653 13656 char *endp;
13654 13657 long id;
13655 13658 ill_t *ill;
13656 13659 ipif_t *ipif;
13657 13660 uint_t ire_type;
13658 13661 boolean_t did_alloc = B_FALSE;
13659 13662 char last;
13660 13663
13661 13664 /*
13662 13665 * If the caller wants to us to create the ipif, make sure we have a
13663 13666 * valid zoneid
13664 13667 */
13665 13668 ASSERT(!do_alloc || zoneid != ALL_ZONES);
13666 13669
13667 13670 if (namelen == 0) {
13668 13671 return (NULL);
13669 13672 }
13670 13673
13671 13674 *exists = B_FALSE;
13672 13675 /* Look for a colon in the name. */
13673 13676 endp = &name[namelen];
13674 13677 for (cp = endp; --cp > name; ) {
13675 13678 if (*cp == IPIF_SEPARATOR_CHAR)
13676 13679 break;
13677 13680 }
13678 13681
13679 13682 if (*cp == IPIF_SEPARATOR_CHAR) {
13680 13683 /*
13681 13684 * Reject any non-decimal aliases for logical
13682 13685 * interfaces. Aliases with leading zeroes
13683 13686 * are also rejected as they introduce ambiguity
13684 13687 * in the naming of the interfaces.
13685 13688 * In order to confirm with existing semantics,
13686 13689 * and to not break any programs/script relying
13687 13690 * on that behaviour, if<0>:0 is considered to be
13688 13691 * a valid interface.
13689 13692 *
13690 13693 * If alias has two or more digits and the first
13691 13694 * is zero, fail.
13692 13695 */
13693 13696 if (&cp[2] < endp && cp[1] == '0') {
13694 13697 return (NULL);
13695 13698 }
13696 13699 }
13697 13700
13698 13701 if (cp <= name) {
13699 13702 cp = endp;
13700 13703 }
13701 13704 last = *cp;
13702 13705 *cp = '\0';
13703 13706
13704 13707 /*
13705 13708 * Look up the ILL, based on the portion of the name
13706 13709 * before the slash. ill_lookup_on_name returns a held ill.
13707 13710 * Temporary to check whether ill exists already. If so
13708 13711 * ill_lookup_on_name will clear it.
13709 13712 */
13710 13713 ill = ill_lookup_on_name(name, do_alloc, isv6,
13711 13714 &did_alloc, ipst);
13712 13715 *cp = last;
13713 13716 if (ill == NULL)
13714 13717 return (NULL);
13715 13718
13716 13719 /* Establish the unit number in the name. */
13717 13720 id = 0;
13718 13721 if (cp < endp && *endp == '\0') {
13719 13722 /* If there was a colon, the unit number follows. */
13720 13723 cp++;
13721 13724 if (ddi_strtol(cp, NULL, 0, &id) != 0) {
13722 13725 ill_refrele(ill);
13723 13726 return (NULL);
13724 13727 }
13725 13728 }
13726 13729
13727 13730 mutex_enter(&ill->ill_lock);
13728 13731 /* Now see if there is an IPIF with this unit number. */
13729 13732 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13730 13733 if (ipif->ipif_id == id) {
13731 13734 if (zoneid != ALL_ZONES &&
13732 13735 zoneid != ipif->ipif_zoneid &&
13733 13736 ipif->ipif_zoneid != ALL_ZONES) {
13734 13737 mutex_exit(&ill->ill_lock);
13735 13738 ill_refrele(ill);
13736 13739 return (NULL);
13737 13740 }
13738 13741 if (IPIF_CAN_LOOKUP(ipif)) {
13739 13742 ipif_refhold_locked(ipif);
13740 13743 mutex_exit(&ill->ill_lock);
13741 13744 if (!did_alloc)
13742 13745 *exists = B_TRUE;
13743 13746 /*
13744 13747 * Drop locks before calling ill_refrele
13745 13748 * since it can potentially call into
13746 13749 * ipif_ill_refrele_tail which can end up
13747 13750 * in trying to acquire any lock.
13748 13751 */
13749 13752 ill_refrele(ill);
13750 13753 return (ipif);
13751 13754 }
13752 13755 }
13753 13756 }
13754 13757
13755 13758 if (!do_alloc) {
13756 13759 mutex_exit(&ill->ill_lock);
13757 13760 ill_refrele(ill);
13758 13761 return (NULL);
13759 13762 }
13760 13763
13761 13764 /*
13762 13765 * If none found, atomically allocate and return a new one.
13763 13766 * Historically, we used IRE_LOOPBACK only for lun 0, and IRE_LOCAL
13764 13767 * to support "receive only" use of lo0:1 etc. as is still done
13765 13768 * below as an initial guess.
13766 13769 * However, this is now likely to be overriden later in ipif_up_done()
13767 13770 * when we know for sure what address has been configured on the
13768 13771 * interface, since we might have more than one loopback interface
13769 13772 * with a loopback address, e.g. in the case of zones, and all the
13770 13773 * interfaces with loopback addresses need to be marked IRE_LOOPBACK.
13771 13774 */
13772 13775 if (ill->ill_net_type == IRE_LOOPBACK && id == 0)
13773 13776 ire_type = IRE_LOOPBACK;
13774 13777 else
13775 13778 ire_type = IRE_LOCAL;
13776 13779 ipif = ipif_allocate(ill, id, ire_type, B_TRUE, B_TRUE, NULL);
13777 13780 if (ipif != NULL)
13778 13781 ipif_refhold_locked(ipif);
13779 13782 mutex_exit(&ill->ill_lock);
13780 13783 ill_refrele(ill);
13781 13784 return (ipif);
13782 13785 }
13783 13786
13784 13787 /*
13785 13788 * Variant of the above that queues the request on the ipsq when
13786 13789 * IPIF_CHANGING is set.
13787 13790 */
13788 13791 static ipif_t *
13789 13792 ipif_lookup_on_name_async(char *name, size_t namelen, boolean_t isv6,
13790 13793 zoneid_t zoneid, queue_t *q, mblk_t *mp, ipsq_func_t func, int *error,
13791 13794 ip_stack_t *ipst)
13792 13795 {
13793 13796 char *cp;
13794 13797 char *endp;
13795 13798 long id;
13796 13799 ill_t *ill;
13797 13800 ipif_t *ipif;
13798 13801 boolean_t did_alloc = B_FALSE;
13799 13802 ipsq_t *ipsq;
13800 13803
13801 13804 if (error != NULL)
13802 13805 *error = 0;
13803 13806
13804 13807 if (namelen == 0) {
13805 13808 if (error != NULL)
13806 13809 *error = ENXIO;
13807 13810 return (NULL);
13808 13811 }
13809 13812
13810 13813 /* Look for a colon in the name. */
13811 13814 endp = &name[namelen];
13812 13815 for (cp = endp; --cp > name; ) {
13813 13816 if (*cp == IPIF_SEPARATOR_CHAR)
13814 13817 break;
13815 13818 }
13816 13819
13817 13820 if (*cp == IPIF_SEPARATOR_CHAR) {
13818 13821 /*
13819 13822 * Reject any non-decimal aliases for logical
13820 13823 * interfaces. Aliases with leading zeroes
13821 13824 * are also rejected as they introduce ambiguity
13822 13825 * in the naming of the interfaces.
13823 13826 * In order to confirm with existing semantics,
13824 13827 * and to not break any programs/script relying
13825 13828 * on that behaviour, if<0>:0 is considered to be
13826 13829 * a valid interface.
13827 13830 *
13828 13831 * If alias has two or more digits and the first
13829 13832 * is zero, fail.
13830 13833 */
13831 13834 if (&cp[2] < endp && cp[1] == '0') {
13832 13835 if (error != NULL)
13833 13836 *error = EINVAL;
13834 13837 return (NULL);
13835 13838 }
13836 13839 }
13837 13840
13838 13841 if (cp <= name) {
13839 13842 cp = endp;
13840 13843 } else {
13841 13844 *cp = '\0';
13842 13845 }
13843 13846
13844 13847 /*
13845 13848 * Look up the ILL, based on the portion of the name
13846 13849 * before the slash. ill_lookup_on_name returns a held ill.
13847 13850 * Temporary to check whether ill exists already. If so
13848 13851 * ill_lookup_on_name will clear it.
13849 13852 */
13850 13853 ill = ill_lookup_on_name(name, B_FALSE, isv6, &did_alloc, ipst);
13851 13854 if (cp != endp)
13852 13855 *cp = IPIF_SEPARATOR_CHAR;
13853 13856 if (ill == NULL)
13854 13857 return (NULL);
13855 13858
13856 13859 /* Establish the unit number in the name. */
13857 13860 id = 0;
13858 13861 if (cp < endp && *endp == '\0') {
13859 13862 /* If there was a colon, the unit number follows. */
13860 13863 cp++;
13861 13864 if (ddi_strtol(cp, NULL, 0, &id) != 0) {
13862 13865 ill_refrele(ill);
13863 13866 if (error != NULL)
13864 13867 *error = ENXIO;
13865 13868 return (NULL);
13866 13869 }
13867 13870 }
13868 13871
13869 13872 GRAB_CONN_LOCK(q);
13870 13873 mutex_enter(&ill->ill_lock);
13871 13874 /* Now see if there is an IPIF with this unit number. */
13872 13875 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
13873 13876 if (ipif->ipif_id == id) {
13874 13877 if (zoneid != ALL_ZONES &&
13875 13878 zoneid != ipif->ipif_zoneid &&
13876 13879 ipif->ipif_zoneid != ALL_ZONES) {
13877 13880 mutex_exit(&ill->ill_lock);
13878 13881 RELEASE_CONN_LOCK(q);
13879 13882 ill_refrele(ill);
13880 13883 if (error != NULL)
13881 13884 *error = ENXIO;
13882 13885 return (NULL);
13883 13886 }
13884 13887
13885 13888 if (!(IPIF_IS_CHANGING(ipif) ||
13886 13889 IPIF_IS_CONDEMNED(ipif)) ||
13887 13890 IAM_WRITER_IPIF(ipif)) {
13888 13891 ipif_refhold_locked(ipif);
13889 13892 mutex_exit(&ill->ill_lock);
13890 13893 /*
13891 13894 * Drop locks before calling ill_refrele
13892 13895 * since it can potentially call into
13893 13896 * ipif_ill_refrele_tail which can end up
13894 13897 * in trying to acquire any lock.
13895 13898 */
13896 13899 RELEASE_CONN_LOCK(q);
13897 13900 ill_refrele(ill);
13898 13901 return (ipif);
13899 13902 } else if (q != NULL && !IPIF_IS_CONDEMNED(ipif)) {
13900 13903 ipsq = ill->ill_phyint->phyint_ipsq;
13901 13904 mutex_enter(&ipsq->ipsq_lock);
13902 13905 mutex_enter(&ipsq->ipsq_xop->ipx_lock);
13903 13906 mutex_exit(&ill->ill_lock);
13904 13907 ipsq_enq(ipsq, q, mp, func, NEW_OP, ill);
13905 13908 mutex_exit(&ipsq->ipsq_xop->ipx_lock);
13906 13909 mutex_exit(&ipsq->ipsq_lock);
13907 13910 RELEASE_CONN_LOCK(q);
13908 13911 ill_refrele(ill);
13909 13912 if (error != NULL)
13910 13913 *error = EINPROGRESS;
13911 13914 return (NULL);
13912 13915 }
13913 13916 }
13914 13917 }
13915 13918 RELEASE_CONN_LOCK(q);
13916 13919 mutex_exit(&ill->ill_lock);
13917 13920 ill_refrele(ill);
13918 13921 if (error != NULL)
13919 13922 *error = ENXIO;
13920 13923 return (NULL);
13921 13924 }
13922 13925
13923 13926 /*
13924 13927 * This routine is called whenever a new address comes up on an ipif. If
13925 13928 * we are configured to respond to address mask requests, then we are supposed
13926 13929 * to broadcast an address mask reply at this time. This routine is also
13927 13930 * called if we are already up, but a netmask change is made. This is legal
13928 13931 * but might not make the system manager very popular. (May be called
13929 13932 * as writer.)
13930 13933 */
13931 13934 void
13932 13935 ipif_mask_reply(ipif_t *ipif)
13933 13936 {
13934 13937 icmph_t *icmph;
13935 13938 ipha_t *ipha;
13936 13939 mblk_t *mp;
13937 13940 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
13938 13941 ip_xmit_attr_t ixas;
13939 13942
13940 13943 #define REPLY_LEN (sizeof (icmp_ipha) + sizeof (icmph_t) + IP_ADDR_LEN)
13941 13944
13942 13945 if (!ipst->ips_ip_respond_to_address_mask_broadcast)
13943 13946 return;
13944 13947
13945 13948 /* ICMP mask reply is IPv4 only */
13946 13949 ASSERT(!ipif->ipif_isv6);
13947 13950 /* ICMP mask reply is not for a loopback interface */
13948 13951 ASSERT(ipif->ipif_ill->ill_wq != NULL);
13949 13952
13950 13953 if (ipif->ipif_lcl_addr == INADDR_ANY)
13951 13954 return;
13952 13955
13953 13956 mp = allocb(REPLY_LEN, BPRI_HI);
13954 13957 if (mp == NULL)
13955 13958 return;
13956 13959 mp->b_wptr = mp->b_rptr + REPLY_LEN;
13957 13960
13958 13961 ipha = (ipha_t *)mp->b_rptr;
13959 13962 bzero(ipha, REPLY_LEN);
13960 13963 *ipha = icmp_ipha;
13961 13964 ipha->ipha_ttl = ipst->ips_ip_broadcast_ttl;
13962 13965 ipha->ipha_src = ipif->ipif_lcl_addr;
13963 13966 ipha->ipha_dst = ipif->ipif_brd_addr;
13964 13967 ipha->ipha_length = htons(REPLY_LEN);
13965 13968 ipha->ipha_ident = 0;
13966 13969
13967 13970 icmph = (icmph_t *)&ipha[1];
13968 13971 icmph->icmph_type = ICMP_ADDRESS_MASK_REPLY;
13969 13972 bcopy(&ipif->ipif_net_mask, &icmph[1], IP_ADDR_LEN);
13970 13973 icmph->icmph_checksum = IP_CSUM(mp, sizeof (ipha_t), 0);
13971 13974
13972 13975 bzero(&ixas, sizeof (ixas));
13973 13976 ixas.ixa_flags = IXAF_BASIC_SIMPLE_V4;
13974 13977 ixas.ixa_zoneid = ALL_ZONES;
13975 13978 ixas.ixa_ifindex = 0;
13976 13979 ixas.ixa_ipst = ipst;
13977 13980 ixas.ixa_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
13978 13981 (void) ip_output_simple(mp, &ixas);
13979 13982 ixa_cleanup(&ixas);
13980 13983 #undef REPLY_LEN
13981 13984 }
13982 13985
13983 13986 /*
13984 13987 * Join the ipif specific multicast groups.
13985 13988 * Must be called after a mapping has been set up in the resolver. (Always
13986 13989 * called as writer.)
13987 13990 */
13988 13991 void
13989 13992 ipif_multicast_up(ipif_t *ipif)
13990 13993 {
13991 13994 int err;
13992 13995 ill_t *ill;
13993 13996 ilm_t *ilm;
13994 13997
13995 13998 ASSERT(IAM_WRITER_IPIF(ipif));
13996 13999
13997 14000 ill = ipif->ipif_ill;
13998 14001
13999 14002 ip1dbg(("ipif_multicast_up\n"));
14000 14003 if (!(ill->ill_flags & ILLF_MULTICAST) ||
14001 14004 ipif->ipif_allhosts_ilm != NULL)
14002 14005 return;
14003 14006
14004 14007 if (ipif->ipif_isv6) {
14005 14008 in6_addr_t v6allmc = ipv6_all_hosts_mcast;
14006 14009 in6_addr_t v6solmc = ipv6_solicited_node_mcast;
14007 14010
14008 14011 v6solmc.s6_addr32[3] |= ipif->ipif_v6lcl_addr.s6_addr32[3];
14009 14012
14010 14013 if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr))
14011 14014 return;
14012 14015
14013 14016 ip1dbg(("ipif_multicast_up - addmulti\n"));
14014 14017
14015 14018 /*
14016 14019 * Join the all hosts multicast address. We skip this for
14017 14020 * underlying IPMP interfaces since they should be invisible.
14018 14021 */
14019 14022 if (!IS_UNDER_IPMP(ill)) {
14020 14023 ilm = ip_addmulti(&v6allmc, ill, ipif->ipif_zoneid,
14021 14024 &err);
14022 14025 if (ilm == NULL) {
14023 14026 ASSERT(err != 0);
14024 14027 ip0dbg(("ipif_multicast_up: "
14025 14028 "all_hosts_mcast failed %d\n", err));
14026 14029 return;
14027 14030 }
14028 14031 ipif->ipif_allhosts_ilm = ilm;
14029 14032 }
14030 14033
14031 14034 /*
14032 14035 * Enable multicast for the solicited node multicast address.
14033 14036 * If IPMP we need to put the membership on the upper ill.
14034 14037 */
14035 14038 if (!(ipif->ipif_flags & IPIF_NOLOCAL)) {
14036 14039 ill_t *mcast_ill = NULL;
14037 14040 boolean_t need_refrele;
14038 14041
14039 14042 if (IS_UNDER_IPMP(ill) &&
14040 14043 (mcast_ill = ipmp_ill_hold_ipmp_ill(ill)) != NULL) {
14041 14044 need_refrele = B_TRUE;
14042 14045 } else {
14043 14046 mcast_ill = ill;
14044 14047 need_refrele = B_FALSE;
14045 14048 }
14046 14049
14047 14050 ilm = ip_addmulti(&v6solmc, mcast_ill,
14048 14051 ipif->ipif_zoneid, &err);
14049 14052 if (need_refrele)
14050 14053 ill_refrele(mcast_ill);
14051 14054
14052 14055 if (ilm == NULL) {
14053 14056 ASSERT(err != 0);
14054 14057 ip0dbg(("ipif_multicast_up: solicited MC"
14055 14058 " failed %d\n", err));
14056 14059 if ((ilm = ipif->ipif_allhosts_ilm) != NULL) {
14057 14060 ipif->ipif_allhosts_ilm = NULL;
14058 14061 (void) ip_delmulti(ilm);
14059 14062 }
14060 14063 return;
14061 14064 }
14062 14065 ipif->ipif_solmulti_ilm = ilm;
14063 14066 }
14064 14067 } else {
14065 14068 in6_addr_t v6group;
14066 14069
14067 14070 if (ipif->ipif_lcl_addr == INADDR_ANY || IS_UNDER_IPMP(ill))
14068 14071 return;
14069 14072
14070 14073 /* Join the all hosts multicast address */
14071 14074 ip1dbg(("ipif_multicast_up - addmulti\n"));
14072 14075 IN6_IPADDR_TO_V4MAPPED(htonl(INADDR_ALLHOSTS_GROUP), &v6group);
14073 14076
14074 14077 ilm = ip_addmulti(&v6group, ill, ipif->ipif_zoneid, &err);
14075 14078 if (ilm == NULL) {
14076 14079 ASSERT(err != 0);
14077 14080 ip0dbg(("ipif_multicast_up: failed %d\n", err));
14078 14081 return;
14079 14082 }
14080 14083 ipif->ipif_allhosts_ilm = ilm;
14081 14084 }
14082 14085 }
14083 14086
14084 14087 /*
14085 14088 * Blow away any multicast groups that we joined in ipif_multicast_up().
14086 14089 * (ilms from explicit memberships are handled in conn_update_ill.)
14087 14090 */
14088 14091 void
14089 14092 ipif_multicast_down(ipif_t *ipif)
14090 14093 {
14091 14094 ASSERT(IAM_WRITER_IPIF(ipif));
14092 14095
14093 14096 ip1dbg(("ipif_multicast_down\n"));
14094 14097
14095 14098 if (ipif->ipif_allhosts_ilm != NULL) {
14096 14099 (void) ip_delmulti(ipif->ipif_allhosts_ilm);
14097 14100 ipif->ipif_allhosts_ilm = NULL;
14098 14101 }
14099 14102 if (ipif->ipif_solmulti_ilm != NULL) {
14100 14103 (void) ip_delmulti(ipif->ipif_solmulti_ilm);
14101 14104 ipif->ipif_solmulti_ilm = NULL;
14102 14105 }
14103 14106 }
14104 14107
14105 14108 /*
14106 14109 * Used when an interface comes up to recreate any extra routes on this
14107 14110 * interface.
14108 14111 */
14109 14112 int
14110 14113 ill_recover_saved_ire(ill_t *ill)
14111 14114 {
14112 14115 mblk_t *mp;
14113 14116 ip_stack_t *ipst = ill->ill_ipst;
14114 14117
14115 14118 ip1dbg(("ill_recover_saved_ire(%s)", ill->ill_name));
14116 14119
14117 14120 mutex_enter(&ill->ill_saved_ire_lock);
14118 14121 for (mp = ill->ill_saved_ire_mp; mp != NULL; mp = mp->b_cont) {
14119 14122 ire_t *ire, *nire;
14120 14123 ifrt_t *ifrt;
14121 14124
14122 14125 ifrt = (ifrt_t *)mp->b_rptr;
14123 14126 /*
14124 14127 * Create a copy of the IRE with the saved address and netmask.
14125 14128 */
14126 14129 if (ill->ill_isv6) {
14127 14130 ire = ire_create_v6(
14128 14131 &ifrt->ifrt_v6addr,
14129 14132 &ifrt->ifrt_v6mask,
14130 14133 &ifrt->ifrt_v6gateway_addr,
14131 14134 ifrt->ifrt_type,
14132 14135 ill,
14133 14136 ifrt->ifrt_zoneid,
14134 14137 ifrt->ifrt_flags,
14135 14138 NULL,
14136 14139 ipst);
14137 14140 } else {
14138 14141 ire = ire_create(
14139 14142 (uint8_t *)&ifrt->ifrt_addr,
14140 14143 (uint8_t *)&ifrt->ifrt_mask,
14141 14144 (uint8_t *)&ifrt->ifrt_gateway_addr,
14142 14145 ifrt->ifrt_type,
14143 14146 ill,
14144 14147 ifrt->ifrt_zoneid,
14145 14148 ifrt->ifrt_flags,
14146 14149 NULL,
14147 14150 ipst);
14148 14151 }
14149 14152 if (ire == NULL) {
14150 14153 mutex_exit(&ill->ill_saved_ire_lock);
14151 14154 return (ENOMEM);
14152 14155 }
14153 14156
14154 14157 if (ifrt->ifrt_flags & RTF_SETSRC) {
14155 14158 if (ill->ill_isv6) {
14156 14159 ire->ire_setsrc_addr_v6 =
14157 14160 ifrt->ifrt_v6setsrc_addr;
14158 14161 } else {
14159 14162 ire->ire_setsrc_addr = ifrt->ifrt_setsrc_addr;
14160 14163 }
14161 14164 }
14162 14165
14163 14166 /*
14164 14167 * Some software (for example, GateD and Sun Cluster) attempts
14165 14168 * to create (what amount to) IRE_PREFIX routes with the
14166 14169 * loopback address as the gateway. This is primarily done to
14167 14170 * set up prefixes with the RTF_REJECT flag set (for example,
14168 14171 * when generating aggregate routes.)
14169 14172 *
14170 14173 * If the IRE type (as defined by ill->ill_net_type) is
14171 14174 * IRE_LOOPBACK, then we map the request into a
14172 14175 * IRE_IF_NORESOLVER.
14173 14176 */
14174 14177 if (ill->ill_net_type == IRE_LOOPBACK)
14175 14178 ire->ire_type = IRE_IF_NORESOLVER;
14176 14179
14177 14180 /*
14178 14181 * ire held by ire_add, will be refreled' towards the
14179 14182 * the end of ipif_up_done
14180 14183 */
14181 14184 nire = ire_add(ire);
14182 14185 /*
14183 14186 * Check if it was a duplicate entry. This handles
14184 14187 * the case of two racing route adds for the same route
14185 14188 */
14186 14189 if (nire == NULL) {
14187 14190 ip1dbg(("ill_recover_saved_ire: FAILED\n"));
14188 14191 } else if (nire != ire) {
14189 14192 ip1dbg(("ill_recover_saved_ire: duplicate ire %p\n",
14190 14193 (void *)nire));
14191 14194 ire_delete(nire);
14192 14195 } else {
14193 14196 ip1dbg(("ill_recover_saved_ire: added ire %p\n",
14194 14197 (void *)nire));
14195 14198 }
14196 14199 if (nire != NULL)
14197 14200 ire_refrele(nire);
14198 14201 }
14199 14202 mutex_exit(&ill->ill_saved_ire_lock);
14200 14203 return (0);
14201 14204 }
14202 14205
14203 14206 /*
14204 14207 * Used to set the netmask and broadcast address to default values when the
14205 14208 * interface is brought up. (Always called as writer.)
14206 14209 */
14207 14210 static void
14208 14211 ipif_set_default(ipif_t *ipif)
14209 14212 {
14210 14213 ASSERT(MUTEX_HELD(&ipif->ipif_ill->ill_lock));
14211 14214
14212 14215 if (!ipif->ipif_isv6) {
14213 14216 /*
14214 14217 * Interface holds an IPv4 address. Default
14215 14218 * mask is the natural netmask.
14216 14219 */
14217 14220 if (!ipif->ipif_net_mask) {
14218 14221 ipaddr_t v4mask;
14219 14222
14220 14223 v4mask = ip_net_mask(ipif->ipif_lcl_addr);
14221 14224 V4MASK_TO_V6(v4mask, ipif->ipif_v6net_mask);
14222 14225 }
14223 14226 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14224 14227 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
14225 14228 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
14226 14229 } else {
14227 14230 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
14228 14231 ipif->ipif_v6net_mask, ipif->ipif_v6subnet);
14229 14232 }
14230 14233 /*
14231 14234 * NOTE: SunOS 4.X does this even if the broadcast address
14232 14235 * has been already set thus we do the same here.
14233 14236 */
14234 14237 if (ipif->ipif_flags & IPIF_BROADCAST) {
14235 14238 ipaddr_t v4addr;
14236 14239
14237 14240 v4addr = ipif->ipif_subnet | ~ipif->ipif_net_mask;
14238 14241 IN6_IPADDR_TO_V4MAPPED(v4addr, &ipif->ipif_v6brd_addr);
14239 14242 }
14240 14243 } else {
14241 14244 /*
14242 14245 * Interface holds an IPv6-only address. Default
14243 14246 * mask is all-ones.
14244 14247 */
14245 14248 if (IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6net_mask))
14246 14249 ipif->ipif_v6net_mask = ipv6_all_ones;
14247 14250 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14248 14251 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
14249 14252 ipif->ipif_v6subnet = ipif->ipif_v6pp_dst_addr;
14250 14253 } else {
14251 14254 V6_MASK_COPY(ipif->ipif_v6lcl_addr,
14252 14255 ipif->ipif_v6net_mask, ipif->ipif_v6subnet);
14253 14256 }
14254 14257 }
14255 14258 }
14256 14259
14257 14260 /*
14258 14261 * Return 0 if this address can be used as local address without causing
14259 14262 * duplicate address problems. Otherwise, return EADDRNOTAVAIL if the address
14260 14263 * is already up on a different ill, and EADDRINUSE if it's up on the same ill.
14261 14264 * Note that the same IPv6 link-local address is allowed as long as the ills
14262 14265 * are not on the same link.
14263 14266 */
14264 14267 int
14265 14268 ip_addr_availability_check(ipif_t *new_ipif)
14266 14269 {
14267 14270 in6_addr_t our_v6addr;
14268 14271 ill_t *ill;
14269 14272 ipif_t *ipif;
14270 14273 ill_walk_context_t ctx;
14271 14274 ip_stack_t *ipst = new_ipif->ipif_ill->ill_ipst;
14272 14275
14273 14276 ASSERT(IAM_WRITER_IPIF(new_ipif));
14274 14277 ASSERT(MUTEX_HELD(&ipst->ips_ip_addr_avail_lock));
14275 14278 ASSERT(RW_READ_HELD(&ipst->ips_ill_g_lock));
14276 14279
14277 14280 new_ipif->ipif_flags &= ~IPIF_UNNUMBERED;
14278 14281 if (IN6_IS_ADDR_UNSPECIFIED(&new_ipif->ipif_v6lcl_addr) ||
14279 14282 IN6_IS_ADDR_V4MAPPED_ANY(&new_ipif->ipif_v6lcl_addr))
14280 14283 return (0);
14281 14284
14282 14285 our_v6addr = new_ipif->ipif_v6lcl_addr;
14283 14286
14284 14287 if (new_ipif->ipif_isv6)
14285 14288 ill = ILL_START_WALK_V6(&ctx, ipst);
14286 14289 else
14287 14290 ill = ILL_START_WALK_V4(&ctx, ipst);
14288 14291
14289 14292 for (; ill != NULL; ill = ill_next(&ctx, ill)) {
14290 14293 for (ipif = ill->ill_ipif; ipif != NULL;
14291 14294 ipif = ipif->ipif_next) {
14292 14295 if ((ipif == new_ipif) ||
14293 14296 !(ipif->ipif_flags & IPIF_UP) ||
14294 14297 (ipif->ipif_flags & IPIF_UNNUMBERED) ||
14295 14298 !IN6_ARE_ADDR_EQUAL(&ipif->ipif_v6lcl_addr,
14296 14299 &our_v6addr))
14297 14300 continue;
14298 14301
14299 14302 if (new_ipif->ipif_flags & IPIF_POINTOPOINT)
14300 14303 new_ipif->ipif_flags |= IPIF_UNNUMBERED;
14301 14304 else if (ipif->ipif_flags & IPIF_POINTOPOINT)
14302 14305 ipif->ipif_flags |= IPIF_UNNUMBERED;
14303 14306 else if ((IN6_IS_ADDR_LINKLOCAL(&our_v6addr) ||
14304 14307 IN6_IS_ADDR_SITELOCAL(&our_v6addr)) &&
14305 14308 !IS_ON_SAME_LAN(ill, new_ipif->ipif_ill))
14306 14309 continue;
14307 14310 else if (new_ipif->ipif_zoneid != ipif->ipif_zoneid &&
14308 14311 ipif->ipif_zoneid != ALL_ZONES && IS_LOOPBACK(ill))
14309 14312 continue;
14310 14313 else if (new_ipif->ipif_ill == ill)
14311 14314 return (EADDRINUSE);
14312 14315 else
14313 14316 return (EADDRNOTAVAIL);
14314 14317 }
14315 14318 }
14316 14319
14317 14320 return (0);
14318 14321 }
14319 14322
14320 14323 /*
14321 14324 * Bring up an ipif: bring up arp/ndp, bring up the DLPI stream, and add
14322 14325 * IREs for the ipif.
14323 14326 * When the routine returns EINPROGRESS then mp has been consumed and
14324 14327 * the ioctl will be acked from ip_rput_dlpi.
14325 14328 */
14326 14329 int
14327 14330 ipif_up(ipif_t *ipif, queue_t *q, mblk_t *mp)
14328 14331 {
14329 14332 ill_t *ill = ipif->ipif_ill;
14330 14333 boolean_t isv6 = ipif->ipif_isv6;
14331 14334 int err = 0;
14332 14335 boolean_t success;
14333 14336 uint_t ipif_orig_id;
14334 14337 ip_stack_t *ipst = ill->ill_ipst;
14335 14338
14336 14339 ASSERT(IAM_WRITER_IPIF(ipif));
14337 14340
14338 14341 ip1dbg(("ipif_up(%s:%u)\n", ill->ill_name, ipif->ipif_id));
14339 14342 DTRACE_PROBE3(ipif__downup, char *, "ipif_up",
14340 14343 ill_t *, ill, ipif_t *, ipif);
14341 14344
14342 14345 /* Shouldn't get here if it is already up. */
14343 14346 if (ipif->ipif_flags & IPIF_UP)
14344 14347 return (EALREADY);
14345 14348
14346 14349 /*
14347 14350 * If this is a request to bring up a data address on an interface
14348 14351 * under IPMP, then move the address to its IPMP meta-interface and
14349 14352 * try to bring it up. One complication is that the zeroth ipif for
14350 14353 * an ill is special, in that every ill always has one, and that code
14351 14354 * throughout IP deferences ill->ill_ipif without holding any locks.
14352 14355 */
14353 14356 if (IS_UNDER_IPMP(ill) && ipmp_ipif_is_dataaddr(ipif) &&
14354 14357 (!ipif->ipif_isv6 || !V6_IPIF_LINKLOCAL(ipif))) {
14355 14358 ipif_t *stubipif = NULL, *moveipif = NULL;
14356 14359 ill_t *ipmp_ill = ipmp_illgrp_ipmp_ill(ill->ill_grp);
14357 14360
14358 14361 /*
14359 14362 * The ipif being brought up should be quiesced. If it's not,
14360 14363 * something has gone amiss and we need to bail out. (If it's
14361 14364 * quiesced, we know it will remain so via IPIF_CONDEMNED.)
14362 14365 */
14363 14366 mutex_enter(&ill->ill_lock);
14364 14367 if (!ipif_is_quiescent(ipif)) {
14365 14368 mutex_exit(&ill->ill_lock);
14366 14369 return (EINVAL);
14367 14370 }
14368 14371 mutex_exit(&ill->ill_lock);
14369 14372
14370 14373 /*
14371 14374 * If we're going to need to allocate ipifs, do it prior
14372 14375 * to starting the move (and grabbing locks).
14373 14376 */
14374 14377 if (ipif->ipif_id == 0) {
14375 14378 if ((moveipif = ipif_allocate(ill, 0, IRE_LOCAL, B_TRUE,
14376 14379 B_FALSE, &err)) == NULL) {
14377 14380 return (err);
14378 14381 }
14379 14382 if ((stubipif = ipif_allocate(ill, 0, IRE_LOCAL, B_TRUE,
14380 14383 B_FALSE, &err)) == NULL) {
14381 14384 mi_free(moveipif);
14382 14385 return (err);
14383 14386 }
14384 14387 }
14385 14388
14386 14389 /*
14387 14390 * Grab or transfer the ipif to move. During the move, keep
14388 14391 * ill_g_lock held to prevent any ill walker threads from
14389 14392 * seeing things in an inconsistent state.
14390 14393 */
14391 14394 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
14392 14395 if (ipif->ipif_id != 0) {
14393 14396 ipif_remove(ipif);
14394 14397 } else {
14395 14398 ipif_transfer(ipif, moveipif, stubipif);
14396 14399 ipif = moveipif;
14397 14400 }
14398 14401
14399 14402 /*
14400 14403 * Place the ipif on the IPMP ill. If the zeroth ipif on
14401 14404 * the IPMP ill is a stub (0.0.0.0 down address) then we
14402 14405 * replace that one. Otherwise, pick the next available slot.
14403 14406 */
14404 14407 ipif->ipif_ill = ipmp_ill;
14405 14408 ipif_orig_id = ipif->ipif_id;
14406 14409
14407 14410 if (ipmp_ipif_is_stubaddr(ipmp_ill->ill_ipif)) {
14408 14411 ipif_transfer(ipif, ipmp_ill->ill_ipif, NULL);
14409 14412 ipif = ipmp_ill->ill_ipif;
14410 14413 } else {
14411 14414 ipif->ipif_id = -1;
14412 14415 if ((err = ipif_insert(ipif, B_FALSE)) != 0) {
14413 14416 /*
14414 14417 * No more available ipif_id's -- put it back
14415 14418 * on the original ill and fail the operation.
14416 14419 * Since we're writer on the ill, we can be
14417 14420 * sure our old slot is still available.
14418 14421 */
14419 14422 ipif->ipif_id = ipif_orig_id;
14420 14423 ipif->ipif_ill = ill;
14421 14424 if (ipif_orig_id == 0) {
14422 14425 ipif_transfer(ipif, ill->ill_ipif,
14423 14426 NULL);
14424 14427 } else {
14425 14428 VERIFY(ipif_insert(ipif, B_FALSE) == 0);
14426 14429 }
14427 14430 rw_exit(&ipst->ips_ill_g_lock);
14428 14431 return (err);
14429 14432 }
14430 14433 }
14431 14434 rw_exit(&ipst->ips_ill_g_lock);
14432 14435
14433 14436 /*
14434 14437 * Tell SCTP that the ipif has moved. Note that even if we
14435 14438 * had to allocate a new ipif, the original sequence id was
14436 14439 * preserved and therefore SCTP won't know.
14437 14440 */
14438 14441 sctp_move_ipif(ipif, ill, ipmp_ill);
14439 14442
14440 14443 /*
14441 14444 * If the ipif being brought up was on slot zero, then we
14442 14445 * first need to bring up the placeholder we stuck there. In
14443 14446 * ip_rput_dlpi_writer(), arp_bringup_done(), or the recursive
14444 14447 * call to ipif_up() itself, if we successfully bring up the
14445 14448 * placeholder, we'll check ill_move_ipif and bring it up too.
14446 14449 */
14447 14450 if (ipif_orig_id == 0) {
14448 14451 ASSERT(ill->ill_move_ipif == NULL);
14449 14452 ill->ill_move_ipif = ipif;
14450 14453 if ((err = ipif_up(ill->ill_ipif, q, mp)) == 0)
14451 14454 ASSERT(ill->ill_move_ipif == NULL);
14452 14455 if (err != EINPROGRESS)
14453 14456 ill->ill_move_ipif = NULL;
14454 14457 return (err);
14455 14458 }
14456 14459
14457 14460 /*
14458 14461 * Bring it up on the IPMP ill.
14459 14462 */
14460 14463 return (ipif_up(ipif, q, mp));
14461 14464 }
14462 14465
14463 14466 /* Skip arp/ndp for any loopback interface. */
14464 14467 if (ill->ill_wq != NULL) {
14465 14468 conn_t *connp = CONN_Q(q) ? Q_TO_CONN(q) : NULL;
14466 14469 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
14467 14470
14468 14471 if (!ill->ill_dl_up) {
14469 14472 /*
14470 14473 * ill_dl_up is not yet set. i.e. we are yet to
14471 14474 * DL_BIND with the driver and this is the first
14472 14475 * logical interface on the ill to become "up".
14473 14476 * Tell the driver to get going (via DL_BIND_REQ).
14474 14477 * Note that changing "significant" IFF_ flags
14475 14478 * address/netmask etc cause a down/up dance, but
14476 14479 * does not cause an unbind (DL_UNBIND) with the driver
14477 14480 */
14478 14481 return (ill_dl_up(ill, ipif, mp, q));
14479 14482 }
14480 14483
14481 14484 /*
14482 14485 * ipif_resolver_up may end up needeing to bind/attach
14483 14486 * the ARP stream, which in turn necessitates a
14484 14487 * DLPI message exchange with the driver. ioctls are
14485 14488 * serialized and so we cannot send more than one
14486 14489 * interface up message at a time. If ipif_resolver_up
14487 14490 * does need to wait for the DLPI handshake for the ARP stream,
14488 14491 * we get EINPROGRESS and we will complete in arp_bringup_done.
14489 14492 */
14490 14493
14491 14494 ASSERT(connp != NULL || !CONN_Q(q));
14492 14495 if (connp != NULL)
14493 14496 mutex_enter(&connp->conn_lock);
14494 14497 mutex_enter(&ill->ill_lock);
14495 14498 success = ipsq_pending_mp_add(connp, ipif, q, mp, 0);
14496 14499 mutex_exit(&ill->ill_lock);
14497 14500 if (connp != NULL)
14498 14501 mutex_exit(&connp->conn_lock);
14499 14502 if (!success)
14500 14503 return (EINTR);
14501 14504
14502 14505 /*
14503 14506 * Crank up IPv6 neighbor discovery. Unlike ARP, this should
14504 14507 * complete when ipif_ndp_up returns.
14505 14508 */
14506 14509 err = ipif_resolver_up(ipif, Res_act_initial);
14507 14510 if (err == EINPROGRESS) {
14508 14511 /* We will complete it in arp_bringup_done() */
14509 14512 return (err);
14510 14513 }
14511 14514
14512 14515 if (isv6 && err == 0)
14513 14516 err = ipif_ndp_up(ipif, B_TRUE);
14514 14517
14515 14518 ASSERT(err != EINPROGRESS);
14516 14519 mp = ipsq_pending_mp_get(ipsq, &connp);
14517 14520 ASSERT(mp != NULL);
14518 14521 if (err != 0)
14519 14522 return (err);
14520 14523 } else {
14521 14524 /*
14522 14525 * Interfaces without underlying hardware don't do duplicate
14523 14526 * address detection.
14524 14527 */
14525 14528 ASSERT(!(ipif->ipif_flags & IPIF_DUPLICATE));
14526 14529 ipif->ipif_addr_ready = 1;
14527 14530 err = ill_add_ires(ill);
14528 14531 /* allocation failure? */
14529 14532 if (err != 0)
14530 14533 return (err);
14531 14534 }
14532 14535
14533 14536 err = (isv6 ? ipif_up_done_v6(ipif) : ipif_up_done(ipif));
14534 14537 if (err == 0 && ill->ill_move_ipif != NULL) {
14535 14538 ipif = ill->ill_move_ipif;
14536 14539 ill->ill_move_ipif = NULL;
14537 14540 return (ipif_up(ipif, q, mp));
14538 14541 }
14539 14542 return (err);
14540 14543 }
14541 14544
14542 14545 /*
14543 14546 * Add any IREs tied to the ill. For now this is just an IRE_MULTICAST.
14544 14547 * The identical set of IREs need to be removed in ill_delete_ires().
14545 14548 */
14546 14549 int
14547 14550 ill_add_ires(ill_t *ill)
14548 14551 {
14549 14552 ire_t *ire;
14550 14553 in6_addr_t dummy6 = {(uint32_t)V6_MCAST, 0, 0, 1};
14551 14554 in_addr_t dummy4 = htonl(INADDR_ALLHOSTS_GROUP);
14552 14555
14553 14556 if (ill->ill_ire_multicast != NULL)
14554 14557 return (0);
14555 14558
14556 14559 /*
14557 14560 * provide some dummy ire_addr for creating the ire.
14558 14561 */
14559 14562 if (ill->ill_isv6) {
14560 14563 ire = ire_create_v6(&dummy6, 0, 0, IRE_MULTICAST, ill,
14561 14564 ALL_ZONES, RTF_UP, NULL, ill->ill_ipst);
14562 14565 } else {
14563 14566 ire = ire_create((uchar_t *)&dummy4, 0, 0, IRE_MULTICAST, ill,
14564 14567 ALL_ZONES, RTF_UP, NULL, ill->ill_ipst);
14565 14568 }
14566 14569 if (ire == NULL)
14567 14570 return (ENOMEM);
14568 14571
14569 14572 ill->ill_ire_multicast = ire;
14570 14573 return (0);
14571 14574 }
14572 14575
14573 14576 void
14574 14577 ill_delete_ires(ill_t *ill)
14575 14578 {
14576 14579 if (ill->ill_ire_multicast != NULL) {
14577 14580 /*
14578 14581 * BIND/ATTACH completed; Release the ref for ill_ire_multicast
14579 14582 * which was taken without any th_tracing enabled.
14580 14583 * We also mark it as condemned (note that it was never added)
14581 14584 * so that caching conn's can move off of it.
14582 14585 */
14583 14586 ire_make_condemned(ill->ill_ire_multicast);
14584 14587 ire_refrele_notr(ill->ill_ire_multicast);
14585 14588 ill->ill_ire_multicast = NULL;
14586 14589 }
14587 14590 }
14588 14591
14589 14592 /*
14590 14593 * Perform a bind for the physical device.
14591 14594 * When the routine returns EINPROGRESS then mp has been consumed and
14592 14595 * the ioctl will be acked from ip_rput_dlpi.
14593 14596 * Allocate an unbind message and save it until ipif_down.
14594 14597 */
14595 14598 static int
14596 14599 ill_dl_up(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
14597 14600 {
14598 14601 mblk_t *bind_mp = NULL;
14599 14602 mblk_t *unbind_mp = NULL;
14600 14603 conn_t *connp;
14601 14604 boolean_t success;
14602 14605 int err;
14603 14606
14604 14607 DTRACE_PROBE2(ill__downup, char *, "ill_dl_up", ill_t *, ill);
14605 14608
14606 14609 ip1dbg(("ill_dl_up(%s)\n", ill->ill_name));
14607 14610 ASSERT(IAM_WRITER_ILL(ill));
14608 14611 ASSERT(mp != NULL);
14609 14612
14610 14613 /*
14611 14614 * Make sure we have an IRE_MULTICAST in case we immediately
14612 14615 * start receiving packets.
14613 14616 */
14614 14617 err = ill_add_ires(ill);
14615 14618 if (err != 0)
14616 14619 goto bad;
14617 14620
14618 14621 bind_mp = ip_dlpi_alloc(sizeof (dl_bind_req_t) + sizeof (long),
14619 14622 DL_BIND_REQ);
14620 14623 if (bind_mp == NULL)
14621 14624 goto bad;
14622 14625 ((dl_bind_req_t *)bind_mp->b_rptr)->dl_sap = ill->ill_sap;
14623 14626 ((dl_bind_req_t *)bind_mp->b_rptr)->dl_service_mode = DL_CLDLS;
14624 14627
14625 14628 /*
14626 14629 * ill_unbind_mp would be non-null if the following sequence had
14627 14630 * happened:
14628 14631 * - send DL_BIND_REQ to driver, wait for response
14629 14632 * - multiple ioctls that need to bring the ipif up are encountered,
14630 14633 * but they cannot enter the ipsq due to the outstanding DL_BIND_REQ.
14631 14634 * These ioctls will then be enqueued on the ipsq
14632 14635 * - a DL_ERROR_ACK is returned for the DL_BIND_REQ
14633 14636 * At this point, the pending ioctls in the ipsq will be drained, and
14634 14637 * since ill->ill_dl_up was not set, ill_dl_up would be invoked with
14635 14638 * a non-null ill->ill_unbind_mp
14636 14639 */
14637 14640 if (ill->ill_unbind_mp == NULL) {
14638 14641 unbind_mp = ip_dlpi_alloc(sizeof (dl_unbind_req_t),
14639 14642 DL_UNBIND_REQ);
14640 14643 if (unbind_mp == NULL)
14641 14644 goto bad;
14642 14645 }
14643 14646 /*
14644 14647 * Record state needed to complete this operation when the
14645 14648 * DL_BIND_ACK shows up. Also remember the pre-allocated mblks.
14646 14649 */
14647 14650 connp = CONN_Q(q) ? Q_TO_CONN(q) : NULL;
14648 14651 ASSERT(connp != NULL || !CONN_Q(q));
14649 14652 GRAB_CONN_LOCK(q);
14650 14653 mutex_enter(&ipif->ipif_ill->ill_lock);
14651 14654 success = ipsq_pending_mp_add(connp, ipif, q, mp, 0);
14652 14655 mutex_exit(&ipif->ipif_ill->ill_lock);
14653 14656 RELEASE_CONN_LOCK(q);
14654 14657 if (!success)
14655 14658 goto bad;
14656 14659
14657 14660 /*
14658 14661 * Save the unbind message for ill_dl_down(); it will be consumed when
14659 14662 * the interface goes down.
14660 14663 */
14661 14664 if (ill->ill_unbind_mp == NULL)
14662 14665 ill->ill_unbind_mp = unbind_mp;
14663 14666
14664 14667 ill_dlpi_send(ill, bind_mp);
14665 14668 /* Send down link-layer capabilities probe if not already done. */
14666 14669 ill_capability_probe(ill);
14667 14670
14668 14671 /*
14669 14672 * Sysid used to rely on the fact that netboots set domainname
14670 14673 * and the like. Now that miniroot boots aren't strictly netboots
14671 14674 * and miniroot network configuration is driven from userland
14672 14675 * these things still need to be set. This situation can be detected
14673 14676 * by comparing the interface being configured here to the one
14674 14677 * dhcifname was set to reference by the boot loader. Once sysid is
14675 14678 * converted to use dhcp_ipc_getinfo() this call can go away.
14676 14679 */
14677 14680 if ((ipif->ipif_flags & IPIF_DHCPRUNNING) &&
14678 14681 (strcmp(ill->ill_name, dhcifname) == 0) &&
14679 14682 (strlen(srpc_domain) == 0)) {
14680 14683 if (dhcpinit() != 0)
14681 14684 cmn_err(CE_WARN, "no cached dhcp response");
14682 14685 }
14683 14686
14684 14687 /*
14685 14688 * This operation will complete in ip_rput_dlpi with either
14686 14689 * a DL_BIND_ACK or DL_ERROR_ACK.
14687 14690 */
14688 14691 return (EINPROGRESS);
14689 14692 bad:
14690 14693 ip1dbg(("ill_dl_up(%s) FAILED\n", ill->ill_name));
14691 14694
14692 14695 freemsg(bind_mp);
14693 14696 freemsg(unbind_mp);
14694 14697 return (ENOMEM);
14695 14698 }
14696 14699
14697 14700 /* Add room for tcp+ip headers */
14698 14701 uint_t ip_loopback_mtuplus = IP_LOOPBACK_MTU + IP_SIMPLE_HDR_LENGTH + 20;
14699 14702
14700 14703 /*
14701 14704 * DLPI and ARP is up.
14702 14705 * Create all the IREs associated with an interface. Bring up multicast.
14703 14706 * Set the interface flag and finish other initialization
14704 14707 * that potentially had to be deferred to after DL_BIND_ACK.
14705 14708 */
14706 14709 int
14707 14710 ipif_up_done(ipif_t *ipif)
14708 14711 {
14709 14712 ill_t *ill = ipif->ipif_ill;
14710 14713 int err = 0;
14711 14714 boolean_t loopback = B_FALSE;
14712 14715 boolean_t update_src_selection = B_TRUE;
14713 14716 ipif_t *tmp_ipif;
14714 14717
14715 14718 ip1dbg(("ipif_up_done(%s:%u)\n",
14716 14719 ipif->ipif_ill->ill_name, ipif->ipif_id));
14717 14720 DTRACE_PROBE3(ipif__downup, char *, "ipif_up_done",
14718 14721 ill_t *, ill, ipif_t *, ipif);
14719 14722
14720 14723 /* Check if this is a loopback interface */
14721 14724 if (ipif->ipif_ill->ill_wq == NULL)
14722 14725 loopback = B_TRUE;
14723 14726
14724 14727 ASSERT(!MUTEX_HELD(&ipif->ipif_ill->ill_lock));
14725 14728
14726 14729 /*
14727 14730 * If all other interfaces for this ill are down or DEPRECATED,
14728 14731 * or otherwise unsuitable for source address selection,
14729 14732 * reset the src generation numbers to make sure source
14730 14733 * address selection gets to take this new ipif into account.
14731 14734 * No need to hold ill_lock while traversing the ipif list since
14732 14735 * we are writer
14733 14736 */
14734 14737 for (tmp_ipif = ill->ill_ipif; tmp_ipif;
14735 14738 tmp_ipif = tmp_ipif->ipif_next) {
14736 14739 if (((tmp_ipif->ipif_flags &
14737 14740 (IPIF_NOXMIT|IPIF_ANYCAST|IPIF_NOLOCAL|IPIF_DEPRECATED)) ||
14738 14741 !(tmp_ipif->ipif_flags & IPIF_UP)) ||
14739 14742 (tmp_ipif == ipif))
14740 14743 continue;
14741 14744 /* first useable pre-existing interface */
14742 14745 update_src_selection = B_FALSE;
14743 14746 break;
14744 14747 }
14745 14748 if (update_src_selection)
14746 14749 ip_update_source_selection(ill->ill_ipst);
14747 14750
14748 14751 if (IS_LOOPBACK(ill) || ill->ill_net_type == IRE_IF_NORESOLVER) {
14749 14752 nce_t *loop_nce = NULL;
14750 14753 uint16_t flags = (NCE_F_MYADDR | NCE_F_AUTHORITY | NCE_F_NONUD);
14751 14754
14752 14755 /*
14753 14756 * lo0:1 and subsequent ipifs were marked IRE_LOCAL in
14754 14757 * ipif_lookup_on_name(), but in the case of zones we can have
14755 14758 * several loopback addresses on lo0. So all the interfaces with
14756 14759 * loopback addresses need to be marked IRE_LOOPBACK.
14757 14760 */
14758 14761 if (V4_PART_OF_V6(ipif->ipif_v6lcl_addr) ==
14759 14762 htonl(INADDR_LOOPBACK))
14760 14763 ipif->ipif_ire_type = IRE_LOOPBACK;
14761 14764 else
14762 14765 ipif->ipif_ire_type = IRE_LOCAL;
14763 14766 if (ill->ill_net_type != IRE_LOOPBACK)
14764 14767 flags |= NCE_F_PUBLISH;
14765 14768
14766 14769 /* add unicast nce for the local addr */
14767 14770 err = nce_lookup_then_add_v4(ill, NULL,
14768 14771 ill->ill_phys_addr_length, &ipif->ipif_lcl_addr, flags,
14769 14772 ND_REACHABLE, &loop_nce);
14770 14773 /* A shared-IP zone sees EEXIST for lo0:N */
14771 14774 if (err == 0 || err == EEXIST) {
14772 14775 ipif->ipif_added_nce = 1;
14773 14776 loop_nce->nce_ipif_cnt++;
14774 14777 nce_refrele(loop_nce);
14775 14778 err = 0;
14776 14779 } else {
14777 14780 ASSERT(loop_nce == NULL);
14778 14781 return (err);
14779 14782 }
14780 14783 }
14781 14784
14782 14785 /* Create all the IREs associated with this interface */
14783 14786 err = ipif_add_ires_v4(ipif, loopback);
14784 14787 if (err != 0) {
14785 14788 /*
14786 14789 * see comments about return value from
14787 14790 * ip_addr_availability_check() in ipif_add_ires_v4().
14788 14791 */
14789 14792 if (err != EADDRINUSE) {
14790 14793 (void) ipif_arp_down(ipif);
14791 14794 } else {
14792 14795 /*
14793 14796 * Make IPMP aware of the deleted ipif so that
14794 14797 * the needed ipmp cleanup (e.g., of ipif_bound_ill)
14795 14798 * can be completed. Note that we do not want to
14796 14799 * destroy the nce that was created on the ipmp_ill
14797 14800 * for the active copy of the duplicate address in
14798 14801 * use.
14799 14802 */
14800 14803 if (IS_IPMP(ill))
14801 14804 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
14802 14805 err = EADDRNOTAVAIL;
14803 14806 }
14804 14807 return (err);
14805 14808 }
14806 14809
14807 14810 if (ill->ill_ipif_up_count == 1 && !loopback) {
14808 14811 /* Recover any additional IREs entries for this ill */
14809 14812 (void) ill_recover_saved_ire(ill);
14810 14813 }
14811 14814
14812 14815 if (ill->ill_need_recover_multicast) {
14813 14816 /*
14814 14817 * Need to recover all multicast memberships in the driver.
14815 14818 * This had to be deferred until we had attached. The same
14816 14819 * code exists in ipif_up_done_v6() to recover IPv6
14817 14820 * memberships.
14818 14821 *
14819 14822 * Note that it would be preferable to unconditionally do the
14820 14823 * ill_recover_multicast() in ill_dl_up(), but we cannot do
14821 14824 * that since ill_join_allmulti() depends on ill_dl_up being
14822 14825 * set, and it is not set until we receive a DL_BIND_ACK after
14823 14826 * having called ill_dl_up().
14824 14827 */
14825 14828 ill_recover_multicast(ill);
14826 14829 }
14827 14830
14828 14831 if (ill->ill_ipif_up_count == 1) {
14829 14832 /*
14830 14833 * Since the interface is now up, it may now be active.
14831 14834 */
14832 14835 if (IS_UNDER_IPMP(ill))
14833 14836 ipmp_ill_refresh_active(ill);
14834 14837
14835 14838 /*
14836 14839 * If this is an IPMP interface, we may now be able to
14837 14840 * establish ARP entries.
14838 14841 */
14839 14842 if (IS_IPMP(ill))
14840 14843 ipmp_illgrp_refresh_arpent(ill->ill_grp);
14841 14844 }
14842 14845
14843 14846 /* Join the allhosts multicast address */
14844 14847 ipif_multicast_up(ipif);
14845 14848
14846 14849 if (!loopback && !update_src_selection &&
14847 14850 !(ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST|IPIF_DEPRECATED)))
14848 14851 ip_update_source_selection(ill->ill_ipst);
14849 14852
14850 14853 if (!loopback && ipif->ipif_addr_ready) {
14851 14854 /* Broadcast an address mask reply. */
14852 14855 ipif_mask_reply(ipif);
14853 14856 }
14854 14857 /* Perhaps ilgs should use this ill */
14855 14858 update_conn_ill(NULL, ill->ill_ipst);
14856 14859
14857 14860 /*
14858 14861 * This had to be deferred until we had bound. Tell routing sockets and
14859 14862 * others that this interface is up if it looks like the address has
14860 14863 * been validated. Otherwise, if it isn't ready yet, wait for
14861 14864 * duplicate address detection to do its thing.
14862 14865 */
14863 14866 if (ipif->ipif_addr_ready)
14864 14867 ipif_up_notify(ipif);
14865 14868 return (0);
14866 14869 }
14867 14870
14868 14871 /*
14869 14872 * Add the IREs associated with the ipif.
14870 14873 * Those MUST be explicitly removed in ipif_delete_ires_v4.
14871 14874 */
14872 14875 static int
14873 14876 ipif_add_ires_v4(ipif_t *ipif, boolean_t loopback)
14874 14877 {
14875 14878 ill_t *ill = ipif->ipif_ill;
14876 14879 ip_stack_t *ipst = ill->ill_ipst;
14877 14880 ire_t *ire_array[20];
14878 14881 ire_t **irep = ire_array;
14879 14882 ire_t **irep1;
14880 14883 ipaddr_t net_mask = 0;
14881 14884 ipaddr_t subnet_mask, route_mask;
14882 14885 int err;
14883 14886 ire_t *ire_local = NULL; /* LOCAL or LOOPBACK */
14884 14887 ire_t *ire_if = NULL;
14885 14888 uchar_t *gw;
14886 14889
14887 14890 if ((ipif->ipif_lcl_addr != INADDR_ANY) &&
14888 14891 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
14889 14892 /*
14890 14893 * If we're on a labeled system then make sure that zone-
14891 14894 * private addresses have proper remote host database entries.
14892 14895 */
14893 14896 if (is_system_labeled() &&
14894 14897 ipif->ipif_ire_type != IRE_LOOPBACK &&
14895 14898 !tsol_check_interface_address(ipif))
14896 14899 return (EINVAL);
14897 14900
14898 14901 /* Register the source address for __sin6_src_id */
14899 14902 err = ip_srcid_insert(&ipif->ipif_v6lcl_addr,
14900 14903 ipif->ipif_zoneid, ipst);
14901 14904 if (err != 0) {
14902 14905 ip0dbg(("ipif_add_ires: srcid_insert %d\n", err));
14903 14906 return (err);
14904 14907 }
14905 14908
14906 14909 if (loopback)
14907 14910 gw = (uchar_t *)&ipif->ipif_lcl_addr;
14908 14911 else
14909 14912 gw = NULL;
14910 14913
14911 14914 /* If the interface address is set, create the local IRE. */
14912 14915 ire_local = ire_create(
14913 14916 (uchar_t *)&ipif->ipif_lcl_addr, /* dest address */
14914 14917 (uchar_t *)&ip_g_all_ones, /* mask */
14915 14918 gw, /* gateway */
14916 14919 ipif->ipif_ire_type, /* LOCAL or LOOPBACK */
14917 14920 ipif->ipif_ill,
14918 14921 ipif->ipif_zoneid,
14919 14922 ((ipif->ipif_flags & IPIF_PRIVATE) ?
14920 14923 RTF_PRIVATE : 0) | RTF_KERNEL,
14921 14924 NULL,
14922 14925 ipst);
14923 14926 ip1dbg(("ipif_add_ires: 0x%p creating IRE %p type 0x%x"
14924 14927 " for 0x%x\n", (void *)ipif, (void *)ire_local,
14925 14928 ipif->ipif_ire_type,
14926 14929 ntohl(ipif->ipif_lcl_addr)));
14927 14930 if (ire_local == NULL) {
14928 14931 ip1dbg(("ipif_up_done: NULL ire_local\n"));
14929 14932 err = ENOMEM;
14930 14933 goto bad;
14931 14934 }
14932 14935 } else {
14933 14936 ip1dbg((
14934 14937 "ipif_add_ires: not creating IRE %d for 0x%x: flags 0x%x\n",
14935 14938 ipif->ipif_ire_type,
14936 14939 ntohl(ipif->ipif_lcl_addr),
14937 14940 (uint_t)ipif->ipif_flags));
14938 14941 }
14939 14942 if ((ipif->ipif_lcl_addr != INADDR_ANY) &&
14940 14943 !(ipif->ipif_flags & IPIF_NOLOCAL)) {
14941 14944 net_mask = ip_net_mask(ipif->ipif_lcl_addr);
14942 14945 } else {
14943 14946 net_mask = htonl(IN_CLASSA_NET); /* fallback */
14944 14947 }
14945 14948
14946 14949 subnet_mask = ipif->ipif_net_mask;
14947 14950
14948 14951 /*
14949 14952 * If mask was not specified, use natural netmask of
14950 14953 * interface address. Also, store this mask back into the
14951 14954 * ipif struct.
14952 14955 */
14953 14956 if (subnet_mask == 0) {
14954 14957 subnet_mask = net_mask;
14955 14958 V4MASK_TO_V6(subnet_mask, ipif->ipif_v6net_mask);
14956 14959 V6_MASK_COPY(ipif->ipif_v6lcl_addr, ipif->ipif_v6net_mask,
14957 14960 ipif->ipif_v6subnet);
14958 14961 }
14959 14962
14960 14963 /* Set up the IRE_IF_RESOLVER or IRE_IF_NORESOLVER, as appropriate. */
14961 14964 if (!loopback && !(ipif->ipif_flags & IPIF_NOXMIT) &&
14962 14965 ipif->ipif_subnet != INADDR_ANY) {
14963 14966 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
14964 14967
14965 14968 if (ipif->ipif_flags & IPIF_POINTOPOINT) {
14966 14969 route_mask = IP_HOST_MASK;
14967 14970 } else {
14968 14971 route_mask = subnet_mask;
14969 14972 }
14970 14973
14971 14974 ip1dbg(("ipif_add_ires: ipif 0x%p ill 0x%p "
14972 14975 "creating if IRE ill_net_type 0x%x for 0x%x\n",
14973 14976 (void *)ipif, (void *)ill, ill->ill_net_type,
14974 14977 ntohl(ipif->ipif_subnet)));
14975 14978 ire_if = ire_create(
14976 14979 (uchar_t *)&ipif->ipif_subnet,
14977 14980 (uchar_t *)&route_mask,
14978 14981 (uchar_t *)&ipif->ipif_lcl_addr,
14979 14982 ill->ill_net_type,
14980 14983 ill,
14981 14984 ipif->ipif_zoneid,
14982 14985 ((ipif->ipif_flags & IPIF_PRIVATE) ?
14983 14986 RTF_PRIVATE: 0) | RTF_KERNEL,
14984 14987 NULL,
14985 14988 ipst);
14986 14989 if (ire_if == NULL) {
14987 14990 ip1dbg(("ipif_up_done: NULL ire_if\n"));
14988 14991 err = ENOMEM;
14989 14992 goto bad;
14990 14993 }
14991 14994 }
14992 14995
14993 14996 /*
14994 14997 * Create any necessary broadcast IREs.
14995 14998 */
14996 14999 if ((ipif->ipif_flags & IPIF_BROADCAST) &&
14997 15000 !(ipif->ipif_flags & IPIF_NOXMIT))
14998 15001 irep = ipif_create_bcast_ires(ipif, irep);
14999 15002
15000 15003 /* If an earlier ire_create failed, get out now */
15001 15004 for (irep1 = irep; irep1 > ire_array; ) {
15002 15005 irep1--;
15003 15006 if (*irep1 == NULL) {
15004 15007 ip1dbg(("ipif_up_done: NULL ire found in ire_array\n"));
15005 15008 err = ENOMEM;
15006 15009 goto bad;
15007 15010 }
15008 15011 }
15009 15012
15010 15013 /*
15011 15014 * Need to atomically check for IP address availability under
15012 15015 * ip_addr_avail_lock. ill_g_lock is held as reader to ensure no new
15013 15016 * ills or new ipifs can be added while we are checking availability.
15014 15017 */
15015 15018 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
15016 15019 mutex_enter(&ipst->ips_ip_addr_avail_lock);
15017 15020 /* Mark it up, and increment counters. */
15018 15021 ipif->ipif_flags |= IPIF_UP;
15019 15022 ill->ill_ipif_up_count++;
15020 15023 err = ip_addr_availability_check(ipif);
15021 15024 mutex_exit(&ipst->ips_ip_addr_avail_lock);
15022 15025 rw_exit(&ipst->ips_ill_g_lock);
15023 15026
15024 15027 if (err != 0) {
15025 15028 /*
15026 15029 * Our address may already be up on the same ill. In this case,
15027 15030 * the ARP entry for our ipif replaced the one for the other
15028 15031 * ipif. So we don't want to delete it (otherwise the other ipif
15029 15032 * would be unable to send packets).
15030 15033 * ip_addr_availability_check() identifies this case for us and
15031 15034 * returns EADDRINUSE; Caller should turn it into EADDRNOTAVAIL
15032 15035 * which is the expected error code.
15033 15036 */
15034 15037 ill->ill_ipif_up_count--;
15035 15038 ipif->ipif_flags &= ~IPIF_UP;
15036 15039 goto bad;
15037 15040 }
15038 15041
15039 15042 /*
15040 15043 * Add in all newly created IREs. ire_create_bcast() has
15041 15044 * already checked for duplicates of the IRE_BROADCAST type.
15042 15045 * We add the IRE_INTERFACE before the IRE_LOCAL to ensure
15043 15046 * that lookups find the IRE_LOCAL even if the IRE_INTERFACE is
15044 15047 * a /32 route.
15045 15048 */
15046 15049 if (ire_if != NULL) {
15047 15050 ire_if = ire_add(ire_if);
15048 15051 if (ire_if == NULL) {
15049 15052 err = ENOMEM;
15050 15053 goto bad2;
15051 15054 }
15052 15055 #ifdef DEBUG
15053 15056 ire_refhold_notr(ire_if);
15054 15057 ire_refrele(ire_if);
15055 15058 #endif
15056 15059 }
15057 15060 if (ire_local != NULL) {
15058 15061 ire_local = ire_add(ire_local);
15059 15062 if (ire_local == NULL) {
15060 15063 err = ENOMEM;
15061 15064 goto bad2;
15062 15065 }
15063 15066 #ifdef DEBUG
15064 15067 ire_refhold_notr(ire_local);
15065 15068 ire_refrele(ire_local);
15066 15069 #endif
15067 15070 }
15068 15071 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15069 15072 if (ire_local != NULL)
15070 15073 ipif->ipif_ire_local = ire_local;
15071 15074 if (ire_if != NULL)
15072 15075 ipif->ipif_ire_if = ire_if;
15073 15076 rw_exit(&ipst->ips_ill_g_lock);
15074 15077 ire_local = NULL;
15075 15078 ire_if = NULL;
15076 15079
15077 15080 /*
15078 15081 * We first add all of them, and if that succeeds we refrele the
15079 15082 * bunch. That enables us to delete all of them should any of the
15080 15083 * ire_adds fail.
15081 15084 */
15082 15085 for (irep1 = irep; irep1 > ire_array; ) {
15083 15086 irep1--;
15084 15087 ASSERT(!MUTEX_HELD(&((*irep1)->ire_ill->ill_lock)));
15085 15088 *irep1 = ire_add(*irep1);
15086 15089 if (*irep1 == NULL) {
15087 15090 err = ENOMEM;
15088 15091 goto bad2;
15089 15092 }
15090 15093 }
15091 15094
15092 15095 for (irep1 = irep; irep1 > ire_array; ) {
15093 15096 irep1--;
15094 15097 /* refheld by ire_add. */
15095 15098 if (*irep1 != NULL) {
15096 15099 ire_refrele(*irep1);
15097 15100 *irep1 = NULL;
15098 15101 }
15099 15102 }
15100 15103
15101 15104 if (!loopback) {
15102 15105 /*
15103 15106 * If the broadcast address has been set, make sure it makes
15104 15107 * sense based on the interface address.
15105 15108 * Only match on ill since we are sharing broadcast addresses.
15106 15109 */
15107 15110 if ((ipif->ipif_brd_addr != INADDR_ANY) &&
15108 15111 (ipif->ipif_flags & IPIF_BROADCAST)) {
15109 15112 ire_t *ire;
15110 15113
15111 15114 ire = ire_ftable_lookup_v4(ipif->ipif_brd_addr, 0, 0,
15112 15115 IRE_BROADCAST, ipif->ipif_ill, ALL_ZONES, NULL,
15113 15116 (MATCH_IRE_TYPE | MATCH_IRE_ILL), 0, ipst, NULL);
15114 15117
15115 15118 if (ire == NULL) {
15116 15119 /*
15117 15120 * If there isn't a matching broadcast IRE,
15118 15121 * revert to the default for this netmask.
15119 15122 */
15120 15123 ipif->ipif_v6brd_addr = ipv6_all_zeros;
15121 15124 mutex_enter(&ipif->ipif_ill->ill_lock);
15122 15125 ipif_set_default(ipif);
15123 15126 mutex_exit(&ipif->ipif_ill->ill_lock);
15124 15127 } else {
15125 15128 ire_refrele(ire);
15126 15129 }
15127 15130 }
15128 15131
15129 15132 }
15130 15133 return (0);
15131 15134
15132 15135 bad2:
15133 15136 ill->ill_ipif_up_count--;
15134 15137 ipif->ipif_flags &= ~IPIF_UP;
15135 15138
15136 15139 bad:
15137 15140 ip1dbg(("ipif_add_ires: FAILED \n"));
15138 15141 if (ire_local != NULL)
15139 15142 ire_delete(ire_local);
15140 15143 if (ire_if != NULL)
15141 15144 ire_delete(ire_if);
15142 15145
15143 15146 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15144 15147 ire_local = ipif->ipif_ire_local;
15145 15148 ipif->ipif_ire_local = NULL;
15146 15149 ire_if = ipif->ipif_ire_if;
15147 15150 ipif->ipif_ire_if = NULL;
15148 15151 rw_exit(&ipst->ips_ill_g_lock);
15149 15152 if (ire_local != NULL) {
15150 15153 ire_delete(ire_local);
15151 15154 ire_refrele_notr(ire_local);
15152 15155 }
15153 15156 if (ire_if != NULL) {
15154 15157 ire_delete(ire_if);
15155 15158 ire_refrele_notr(ire_if);
15156 15159 }
15157 15160
15158 15161 while (irep > ire_array) {
15159 15162 irep--;
15160 15163 if (*irep != NULL) {
15161 15164 ire_delete(*irep);
15162 15165 }
15163 15166 }
15164 15167 (void) ip_srcid_remove(&ipif->ipif_v6lcl_addr, ipif->ipif_zoneid, ipst);
15165 15168
15166 15169 return (err);
15167 15170 }
15168 15171
15169 15172 /* Remove all the IREs created by ipif_add_ires_v4 */
15170 15173 void
15171 15174 ipif_delete_ires_v4(ipif_t *ipif)
15172 15175 {
15173 15176 ill_t *ill = ipif->ipif_ill;
15174 15177 ip_stack_t *ipst = ill->ill_ipst;
15175 15178 ire_t *ire;
15176 15179
15177 15180 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15178 15181 ire = ipif->ipif_ire_local;
15179 15182 ipif->ipif_ire_local = NULL;
15180 15183 rw_exit(&ipst->ips_ill_g_lock);
15181 15184 if (ire != NULL) {
15182 15185 /*
15183 15186 * Move count to ipif so we don't loose the count due to
15184 15187 * a down/up dance.
15185 15188 */
15186 15189 atomic_add_32(&ipif->ipif_ib_pkt_count, ire->ire_ib_pkt_count);
15187 15190
15188 15191 ire_delete(ire);
15189 15192 ire_refrele_notr(ire);
15190 15193 }
15191 15194 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15192 15195 ire = ipif->ipif_ire_if;
15193 15196 ipif->ipif_ire_if = NULL;
15194 15197 rw_exit(&ipst->ips_ill_g_lock);
15195 15198 if (ire != NULL) {
15196 15199 ire_delete(ire);
15197 15200 ire_refrele_notr(ire);
15198 15201 }
15199 15202
15200 15203 /*
15201 15204 * Delete the broadcast IREs.
15202 15205 */
15203 15206 if ((ipif->ipif_flags & IPIF_BROADCAST) &&
15204 15207 !(ipif->ipif_flags & IPIF_NOXMIT))
15205 15208 ipif_delete_bcast_ires(ipif);
15206 15209 }
15207 15210
15208 15211 /*
15209 15212 * Checks for availbility of a usable source address (if there is one) when the
15210 15213 * destination ILL has the ill_usesrc_ifindex pointing to another ILL. Note
15211 15214 * this selection is done regardless of the destination.
15212 15215 */
15213 15216 boolean_t
15214 15217 ipif_zone_avail(uint_t ifindex, boolean_t isv6, zoneid_t zoneid,
15215 15218 ip_stack_t *ipst)
15216 15219 {
15217 15220 ipif_t *ipif = NULL;
15218 15221 ill_t *uill;
15219 15222
15220 15223 ASSERT(ifindex != 0);
15221 15224
15222 15225 uill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
15223 15226 if (uill == NULL)
15224 15227 return (B_FALSE);
15225 15228
15226 15229 mutex_enter(&uill->ill_lock);
15227 15230 for (ipif = uill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15228 15231 if (IPIF_IS_CONDEMNED(ipif))
15229 15232 continue;
15230 15233 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15231 15234 continue;
15232 15235 if (!(ipif->ipif_flags & IPIF_UP))
15233 15236 continue;
15234 15237 if (ipif->ipif_zoneid != zoneid)
15235 15238 continue;
15236 15239 if (isv6 ? IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) :
15237 15240 ipif->ipif_lcl_addr == INADDR_ANY)
15238 15241 continue;
15239 15242 mutex_exit(&uill->ill_lock);
15240 15243 ill_refrele(uill);
15241 15244 return (B_TRUE);
15242 15245 }
15243 15246 mutex_exit(&uill->ill_lock);
15244 15247 ill_refrele(uill);
15245 15248 return (B_FALSE);
15246 15249 }
15247 15250
15248 15251 /*
15249 15252 * Find an ipif with a good local address on the ill+zoneid.
15250 15253 */
15251 15254 ipif_t *
15252 15255 ipif_good_addr(ill_t *ill, zoneid_t zoneid)
15253 15256 {
15254 15257 ipif_t *ipif;
15255 15258
15256 15259 mutex_enter(&ill->ill_lock);
15257 15260 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
15258 15261 if (IPIF_IS_CONDEMNED(ipif))
15259 15262 continue;
15260 15263 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15261 15264 continue;
15262 15265 if (!(ipif->ipif_flags & IPIF_UP))
15263 15266 continue;
15264 15267 if (ipif->ipif_zoneid != zoneid &&
15265 15268 ipif->ipif_zoneid != ALL_ZONES && zoneid != ALL_ZONES)
15266 15269 continue;
15267 15270 if (ill->ill_isv6 ?
15268 15271 IN6_IS_ADDR_UNSPECIFIED(&ipif->ipif_v6lcl_addr) :
15269 15272 ipif->ipif_lcl_addr == INADDR_ANY)
15270 15273 continue;
15271 15274 ipif_refhold_locked(ipif);
15272 15275 mutex_exit(&ill->ill_lock);
15273 15276 return (ipif);
15274 15277 }
15275 15278 mutex_exit(&ill->ill_lock);
15276 15279 return (NULL);
15277 15280 }
15278 15281
15279 15282 /*
15280 15283 * IP source address type, sorted from worst to best. For a given type,
15281 15284 * always prefer IP addresses on the same subnet. All-zones addresses are
15282 15285 * suboptimal because they pose problems with unlabeled destinations.
15283 15286 */
15284 15287 typedef enum {
15285 15288 IPIF_NONE,
15286 15289 IPIF_DIFFNET_DEPRECATED, /* deprecated and different subnet */
15287 15290 IPIF_SAMENET_DEPRECATED, /* deprecated and same subnet */
15288 15291 IPIF_DIFFNET_ALLZONES, /* allzones and different subnet */
15289 15292 IPIF_SAMENET_ALLZONES, /* allzones and same subnet */
15290 15293 IPIF_DIFFNET, /* normal and different subnet */
15291 15294 IPIF_SAMENET, /* normal and same subnet */
15292 15295 IPIF_LOCALADDR /* local loopback */
15293 15296 } ipif_type_t;
15294 15297
15295 15298 /*
15296 15299 * Pick the optimal ipif on `ill' for sending to destination `dst' from zone
15297 15300 * `zoneid'. We rate usable ipifs from low -> high as per the ipif_type_t
15298 15301 * enumeration, and return the highest-rated ipif. If there's a tie, we pick
15299 15302 * the first one, unless IPMP is used in which case we round-robin among them;
15300 15303 * see below for more.
15301 15304 *
15302 15305 * Returns NULL if there is no suitable source address for the ill.
15303 15306 * This only occurs when there is no valid source address for the ill.
15304 15307 */
15305 15308 ipif_t *
15306 15309 ipif_select_source_v4(ill_t *ill, ipaddr_t dst, zoneid_t zoneid,
15307 15310 boolean_t allow_usesrc, boolean_t *notreadyp)
15308 15311 {
15309 15312 ill_t *usill = NULL;
15310 15313 ill_t *ipmp_ill = NULL;
15311 15314 ipif_t *start_ipif, *next_ipif, *ipif, *best_ipif;
15312 15315 ipif_type_t type, best_type;
15313 15316 tsol_tpc_t *src_rhtp, *dst_rhtp;
15314 15317 ip_stack_t *ipst = ill->ill_ipst;
15315 15318 boolean_t samenet;
15316 15319
15317 15320 if (ill->ill_usesrc_ifindex != 0 && allow_usesrc) {
15318 15321 usill = ill_lookup_on_ifindex(ill->ill_usesrc_ifindex,
15319 15322 B_FALSE, ipst);
15320 15323 if (usill != NULL)
15321 15324 ill = usill; /* Select source from usesrc ILL */
15322 15325 else
15323 15326 return (NULL);
15324 15327 }
15325 15328
15326 15329 /*
15327 15330 * Test addresses should never be used for source address selection,
15328 15331 * so if we were passed one, switch to the IPMP meta-interface.
15329 15332 */
15330 15333 if (IS_UNDER_IPMP(ill)) {
15331 15334 if ((ipmp_ill = ipmp_ill_hold_ipmp_ill(ill)) != NULL)
15332 15335 ill = ipmp_ill; /* Select source from IPMP ill */
15333 15336 else
15334 15337 return (NULL);
15335 15338 }
15336 15339
15337 15340 /*
15338 15341 * If we're dealing with an unlabeled destination on a labeled system,
15339 15342 * make sure that we ignore source addresses that are incompatible with
15340 15343 * the destination's default label. That destination's default label
15341 15344 * must dominate the minimum label on the source address.
15342 15345 */
15343 15346 dst_rhtp = NULL;
15344 15347 if (is_system_labeled()) {
15345 15348 dst_rhtp = find_tpc(&dst, IPV4_VERSION, B_FALSE);
15346 15349 if (dst_rhtp == NULL)
15347 15350 return (NULL);
15348 15351 if (dst_rhtp->tpc_tp.host_type != UNLABELED) {
15349 15352 TPC_RELE(dst_rhtp);
15350 15353 dst_rhtp = NULL;
15351 15354 }
15352 15355 }
15353 15356
15354 15357 /*
15355 15358 * Hold the ill_g_lock as reader. This makes sure that no ipif/ill
15356 15359 * can be deleted. But an ipif/ill can get CONDEMNED any time.
15357 15360 * After selecting the right ipif, under ill_lock make sure ipif is
15358 15361 * not condemned, and increment refcnt. If ipif is CONDEMNED,
15359 15362 * we retry. Inside the loop we still need to check for CONDEMNED,
15360 15363 * but not under a lock.
15361 15364 */
15362 15365 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
15363 15366 retry:
15364 15367 /*
15365 15368 * For source address selection, we treat the ipif list as circular
15366 15369 * and continue until we get back to where we started. This allows
15367 15370 * IPMP to vary source address selection (which improves inbound load
15368 15371 * spreading) by caching its last ending point and starting from
15369 15372 * there. NOTE: we don't have to worry about ill_src_ipif changing
15370 15373 * ills since that can't happen on the IPMP ill.
15371 15374 */
15372 15375 start_ipif = ill->ill_ipif;
15373 15376 if (IS_IPMP(ill) && ill->ill_src_ipif != NULL)
15374 15377 start_ipif = ill->ill_src_ipif;
15375 15378
15376 15379 ipif = start_ipif;
15377 15380 best_ipif = NULL;
15378 15381 best_type = IPIF_NONE;
15379 15382 do {
15380 15383 if ((next_ipif = ipif->ipif_next) == NULL)
15381 15384 next_ipif = ill->ill_ipif;
15382 15385
15383 15386 if (IPIF_IS_CONDEMNED(ipif))
15384 15387 continue;
15385 15388 /* Always skip NOLOCAL and ANYCAST interfaces */
15386 15389 if (ipif->ipif_flags & (IPIF_NOLOCAL|IPIF_ANYCAST))
15387 15390 continue;
15388 15391 /* Always skip NOACCEPT interfaces */
15389 15392 if (ipif->ipif_ill->ill_flags & ILLF_NOACCEPT)
15390 15393 continue;
15391 15394 if (!(ipif->ipif_flags & IPIF_UP))
15392 15395 continue;
15393 15396
15394 15397 if (!ipif->ipif_addr_ready) {
15395 15398 if (notreadyp != NULL)
15396 15399 *notreadyp = B_TRUE;
15397 15400 continue;
15398 15401 }
15399 15402
15400 15403 if (zoneid != ALL_ZONES &&
15401 15404 ipif->ipif_zoneid != zoneid &&
15402 15405 ipif->ipif_zoneid != ALL_ZONES)
15403 15406 continue;
15404 15407
15405 15408 /*
15406 15409 * Interfaces with 0.0.0.0 address are allowed to be UP, but
15407 15410 * are not valid as source addresses.
15408 15411 */
15409 15412 if (ipif->ipif_lcl_addr == INADDR_ANY)
15410 15413 continue;
15411 15414
15412 15415 /*
15413 15416 * Check compatibility of local address for destination's
15414 15417 * default label if we're on a labeled system. Incompatible
15415 15418 * addresses can't be used at all.
15416 15419 */
15417 15420 if (dst_rhtp != NULL) {
15418 15421 boolean_t incompat;
15419 15422
15420 15423 src_rhtp = find_tpc(&ipif->ipif_lcl_addr,
15421 15424 IPV4_VERSION, B_FALSE);
15422 15425 if (src_rhtp == NULL)
15423 15426 continue;
15424 15427 incompat = src_rhtp->tpc_tp.host_type != SUN_CIPSO ||
15425 15428 src_rhtp->tpc_tp.tp_doi !=
15426 15429 dst_rhtp->tpc_tp.tp_doi ||
15427 15430 (!_blinrange(&dst_rhtp->tpc_tp.tp_def_label,
15428 15431 &src_rhtp->tpc_tp.tp_sl_range_cipso) &&
15429 15432 !blinlset(&dst_rhtp->tpc_tp.tp_def_label,
15430 15433 src_rhtp->tpc_tp.tp_sl_set_cipso));
15431 15434 TPC_RELE(src_rhtp);
15432 15435 if (incompat)
15433 15436 continue;
15434 15437 }
15435 15438
15436 15439 samenet = ((ipif->ipif_net_mask & dst) == ipif->ipif_subnet);
15437 15440
15438 15441 if (ipif->ipif_lcl_addr == dst) {
15439 15442 type = IPIF_LOCALADDR;
15440 15443 } else if (ipif->ipif_flags & IPIF_DEPRECATED) {
15441 15444 type = samenet ? IPIF_SAMENET_DEPRECATED :
15442 15445 IPIF_DIFFNET_DEPRECATED;
15443 15446 } else if (ipif->ipif_zoneid == ALL_ZONES) {
15444 15447 type = samenet ? IPIF_SAMENET_ALLZONES :
15445 15448 IPIF_DIFFNET_ALLZONES;
15446 15449 } else {
15447 15450 type = samenet ? IPIF_SAMENET : IPIF_DIFFNET;
15448 15451 }
15449 15452
15450 15453 if (type > best_type) {
15451 15454 best_type = type;
15452 15455 best_ipif = ipif;
15453 15456 if (best_type == IPIF_LOCALADDR)
15454 15457 break; /* can't get better */
15455 15458 }
15456 15459 } while ((ipif = next_ipif) != start_ipif);
15457 15460
15458 15461 if ((ipif = best_ipif) != NULL) {
15459 15462 mutex_enter(&ipif->ipif_ill->ill_lock);
15460 15463 if (IPIF_IS_CONDEMNED(ipif)) {
15461 15464 mutex_exit(&ipif->ipif_ill->ill_lock);
15462 15465 goto retry;
15463 15466 }
15464 15467 ipif_refhold_locked(ipif);
15465 15468
15466 15469 /*
15467 15470 * For IPMP, update the source ipif rotor to the next ipif,
15468 15471 * provided we can look it up. (We must not use it if it's
15469 15472 * IPIF_CONDEMNED since we may have grabbed ill_g_lock after
15470 15473 * ipif_free() checked ill_src_ipif.)
15471 15474 */
15472 15475 if (IS_IPMP(ill) && ipif != NULL) {
15473 15476 next_ipif = ipif->ipif_next;
15474 15477 if (next_ipif != NULL && !IPIF_IS_CONDEMNED(next_ipif))
15475 15478 ill->ill_src_ipif = next_ipif;
15476 15479 else
15477 15480 ill->ill_src_ipif = NULL;
15478 15481 }
15479 15482 mutex_exit(&ipif->ipif_ill->ill_lock);
15480 15483 }
15481 15484
15482 15485 rw_exit(&ipst->ips_ill_g_lock);
15483 15486 if (usill != NULL)
15484 15487 ill_refrele(usill);
15485 15488 if (ipmp_ill != NULL)
15486 15489 ill_refrele(ipmp_ill);
15487 15490 if (dst_rhtp != NULL)
15488 15491 TPC_RELE(dst_rhtp);
15489 15492
15490 15493 #ifdef DEBUG
15491 15494 if (ipif == NULL) {
15492 15495 char buf1[INET6_ADDRSTRLEN];
15493 15496
15494 15497 ip1dbg(("ipif_select_source_v4(%s, %s) -> NULL\n",
15495 15498 ill->ill_name,
15496 15499 inet_ntop(AF_INET, &dst, buf1, sizeof (buf1))));
15497 15500 } else {
15498 15501 char buf1[INET6_ADDRSTRLEN];
15499 15502 char buf2[INET6_ADDRSTRLEN];
15500 15503
15501 15504 ip1dbg(("ipif_select_source_v4(%s, %s) -> %s\n",
15502 15505 ipif->ipif_ill->ill_name,
15503 15506 inet_ntop(AF_INET, &dst, buf1, sizeof (buf1)),
15504 15507 inet_ntop(AF_INET, &ipif->ipif_lcl_addr,
15505 15508 buf2, sizeof (buf2))));
15506 15509 }
15507 15510 #endif /* DEBUG */
15508 15511 return (ipif);
15509 15512 }
15510 15513
15511 15514 /*
15512 15515 * Pick a source address based on the destination ill and an optional setsrc
15513 15516 * address.
15514 15517 * The result is stored in srcp. If generation is set, then put the source
15515 15518 * generation number there before we look for the source address (to avoid
15516 15519 * missing changes in the set of source addresses.
15517 15520 * If flagsp is set, then us it to pass back ipif_flags.
15518 15521 *
15519 15522 * If the caller wants to cache the returned source address and detect when
15520 15523 * that might be stale, the caller should pass in a generation argument,
15521 15524 * which the caller can later compare against ips_src_generation
15522 15525 *
15523 15526 * The precedence order for selecting an IPv4 source address is:
15524 15527 * - RTF_SETSRC on the offlink ire always wins.
15525 15528 * - If usrsrc is set, swap the ill to be the usesrc one.
15526 15529 * - If IPMP is used on the ill, select a random address from the most
15527 15530 * preferred ones below:
15528 15531 * 1. If onlink destination, same subnet and not deprecated, not ALL_ZONES
15529 15532 * 2. Not deprecated, not ALL_ZONES
15530 15533 * 3. If onlink destination, same subnet and not deprecated, ALL_ZONES
15531 15534 * 4. Not deprecated, ALL_ZONES
15532 15535 * 5. If onlink destination, same subnet and deprecated
15533 15536 * 6. Deprecated.
15534 15537 *
15535 15538 * We have lower preference for ALL_ZONES IP addresses,
15536 15539 * as they pose problems with unlabeled destinations.
15537 15540 *
15538 15541 * Note that when multiple IP addresses match e.g., #1 we pick
15539 15542 * the first one if IPMP is not in use. With IPMP we randomize.
15540 15543 */
15541 15544 int
15542 15545 ip_select_source_v4(ill_t *ill, ipaddr_t setsrc, ipaddr_t dst,
15543 15546 ipaddr_t multicast_ifaddr,
15544 15547 zoneid_t zoneid, ip_stack_t *ipst, ipaddr_t *srcp,
15545 15548 uint32_t *generation, uint64_t *flagsp)
15546 15549 {
15547 15550 ipif_t *ipif;
15548 15551 boolean_t notready = B_FALSE; /* Set if !ipif_addr_ready found */
15549 15552
15550 15553 if (flagsp != NULL)
15551 15554 *flagsp = 0;
15552 15555
15553 15556 /*
15554 15557 * Need to grab the generation number before we check to
15555 15558 * avoid a race with a change to the set of local addresses.
15556 15559 * No lock needed since the thread which updates the set of local
15557 15560 * addresses use ipif/ill locks and exit those (hence a store memory
15558 15561 * barrier) before doing the atomic increase of ips_src_generation.
15559 15562 */
15560 15563 if (generation != NULL) {
15561 15564 *generation = ipst->ips_src_generation;
15562 15565 }
15563 15566
15564 15567 if (CLASSD(dst) && multicast_ifaddr != INADDR_ANY) {
15565 15568 *srcp = multicast_ifaddr;
15566 15569 return (0);
15567 15570 }
15568 15571
15569 15572 /* Was RTF_SETSRC set on the first IRE in the recursive lookup? */
15570 15573 if (setsrc != INADDR_ANY) {
15571 15574 *srcp = setsrc;
15572 15575 return (0);
15573 15576 }
15574 15577 ipif = ipif_select_source_v4(ill, dst, zoneid, B_TRUE, ¬ready);
15575 15578 if (ipif == NULL) {
15576 15579 if (notready)
15577 15580 return (ENETDOWN);
15578 15581 else
15579 15582 return (EADDRNOTAVAIL);
15580 15583 }
15581 15584 *srcp = ipif->ipif_lcl_addr;
15582 15585 if (flagsp != NULL)
15583 15586 *flagsp = ipif->ipif_flags;
15584 15587 ipif_refrele(ipif);
15585 15588 return (0);
15586 15589 }
15587 15590
15588 15591 /* ARGSUSED */
15589 15592 int
15590 15593 if_unitsel_restart(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15591 15594 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
15592 15595 {
15593 15596 /*
15594 15597 * ill_phyint_reinit merged the v4 and v6 into a single
15595 15598 * ipsq. We might not have been able to complete the
15596 15599 * operation in ipif_set_values, if we could not become
15597 15600 * exclusive. If so restart it here.
15598 15601 */
15599 15602 return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q));
15600 15603 }
15601 15604
15602 15605 /*
15603 15606 * Can operate on either a module or a driver queue.
15604 15607 * Returns an error if not a module queue.
15605 15608 */
15606 15609 /* ARGSUSED */
15607 15610 int
15608 15611 if_unitsel(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15609 15612 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
15610 15613 {
15611 15614 queue_t *q1 = q;
15612 15615 char *cp;
15613 15616 char interf_name[LIFNAMSIZ];
15614 15617 uint_t ppa = *(uint_t *)mp->b_cont->b_cont->b_rptr;
15615 15618
15616 15619 if (q->q_next == NULL) {
15617 15620 ip1dbg((
15618 15621 "if_unitsel: IF_UNITSEL: no q_next\n"));
15619 15622 return (EINVAL);
15620 15623 }
15621 15624
15622 15625 if (((ill_t *)(q->q_ptr))->ill_name[0] != '\0')
15623 15626 return (EALREADY);
15624 15627
15625 15628 do {
15626 15629 q1 = q1->q_next;
15627 15630 } while (q1->q_next);
15628 15631 cp = q1->q_qinfo->qi_minfo->mi_idname;
15629 15632 (void) sprintf(interf_name, "%s%d", cp, ppa);
15630 15633
15631 15634 /*
15632 15635 * Here we are not going to delay the ioack until after
15633 15636 * ACKs from DL_ATTACH_REQ/DL_BIND_REQ. So no need to save the
15634 15637 * original ioctl message before sending the requests.
15635 15638 */
15636 15639 return (ipif_set_values(q, mp, interf_name, &ppa));
15637 15640 }
15638 15641
15639 15642 /* ARGSUSED */
15640 15643 int
15641 15644 ip_sioctl_sifname(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
15642 15645 ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
15643 15646 {
15644 15647 return (ENXIO);
15645 15648 }
15646 15649
15647 15650 /*
15648 15651 * Create any IRE_BROADCAST entries for `ipif', and store those entries in
15649 15652 * `irep'. Returns a pointer to the next free `irep' entry
15650 15653 * A mirror exists in ipif_delete_bcast_ires().
15651 15654 *
15652 15655 * The management of any "extra" or seemingly duplicate IRE_BROADCASTs is
15653 15656 * done in ire_add.
15654 15657 */
15655 15658 static ire_t **
15656 15659 ipif_create_bcast_ires(ipif_t *ipif, ire_t **irep)
15657 15660 {
15658 15661 ipaddr_t addr;
15659 15662 ipaddr_t netmask = ip_net_mask(ipif->ipif_lcl_addr);
15660 15663 ipaddr_t subnetmask = ipif->ipif_net_mask;
15661 15664 ill_t *ill = ipif->ipif_ill;
15662 15665 zoneid_t zoneid = ipif->ipif_zoneid;
15663 15666
15664 15667 ip1dbg(("ipif_create_bcast_ires: creating broadcast IREs\n"));
15665 15668
15666 15669 ASSERT(ipif->ipif_flags & IPIF_BROADCAST);
15667 15670 ASSERT(!(ipif->ipif_flags & IPIF_NOXMIT));
15668 15671
15669 15672 if (ipif->ipif_lcl_addr == INADDR_ANY ||
15670 15673 (ipif->ipif_flags & IPIF_NOLOCAL))
15671 15674 netmask = htonl(IN_CLASSA_NET); /* fallback */
15672 15675
15673 15676 irep = ire_create_bcast(ill, 0, zoneid, irep);
15674 15677 irep = ire_create_bcast(ill, INADDR_BROADCAST, zoneid, irep);
15675 15678
15676 15679 /*
15677 15680 * For backward compatibility, we create net broadcast IREs based on
15678 15681 * the old "IP address class system", since some old machines only
15679 15682 * respond to these class derived net broadcast. However, we must not
15680 15683 * create these net broadcast IREs if the subnetmask is shorter than
15681 15684 * the IP address class based derived netmask. Otherwise, we may
15682 15685 * create a net broadcast address which is the same as an IP address
15683 15686 * on the subnet -- and then TCP will refuse to talk to that address.
15684 15687 */
15685 15688 if (netmask < subnetmask) {
15686 15689 addr = netmask & ipif->ipif_subnet;
15687 15690 irep = ire_create_bcast(ill, addr, zoneid, irep);
15688 15691 irep = ire_create_bcast(ill, ~netmask | addr, zoneid, irep);
15689 15692 }
15690 15693
15691 15694 /*
15692 15695 * Don't create IRE_BROADCAST IREs for the interface if the subnetmask
15693 15696 * is 0xFFFFFFFF, as an IRE_LOCAL for that interface is already
15694 15697 * created. Creating these broadcast IREs will only create confusion
15695 15698 * as `addr' will be the same as the IP address.
15696 15699 */
15697 15700 if (subnetmask != 0xFFFFFFFF) {
15698 15701 addr = ipif->ipif_subnet;
15699 15702 irep = ire_create_bcast(ill, addr, zoneid, irep);
15700 15703 irep = ire_create_bcast(ill, ~subnetmask | addr, zoneid, irep);
15701 15704 }
15702 15705
15703 15706 return (irep);
15704 15707 }
15705 15708
15706 15709 /*
15707 15710 * Mirror of ipif_create_bcast_ires()
15708 15711 */
15709 15712 static void
15710 15713 ipif_delete_bcast_ires(ipif_t *ipif)
15711 15714 {
15712 15715 ipaddr_t addr;
15713 15716 ipaddr_t netmask = ip_net_mask(ipif->ipif_lcl_addr);
15714 15717 ipaddr_t subnetmask = ipif->ipif_net_mask;
15715 15718 ill_t *ill = ipif->ipif_ill;
15716 15719 zoneid_t zoneid = ipif->ipif_zoneid;
15717 15720 ire_t *ire;
15718 15721
15719 15722 ASSERT(ipif->ipif_flags & IPIF_BROADCAST);
15720 15723 ASSERT(!(ipif->ipif_flags & IPIF_NOXMIT));
15721 15724
15722 15725 if (ipif->ipif_lcl_addr == INADDR_ANY ||
15723 15726 (ipif->ipif_flags & IPIF_NOLOCAL))
15724 15727 netmask = htonl(IN_CLASSA_NET); /* fallback */
15725 15728
15726 15729 ire = ire_lookup_bcast(ill, 0, zoneid);
15727 15730 ASSERT(ire != NULL);
15728 15731 ire_delete(ire); ire_refrele(ire);
15729 15732 ire = ire_lookup_bcast(ill, INADDR_BROADCAST, zoneid);
15730 15733 ASSERT(ire != NULL);
15731 15734 ire_delete(ire); ire_refrele(ire);
15732 15735
15733 15736 /*
15734 15737 * For backward compatibility, we create net broadcast IREs based on
15735 15738 * the old "IP address class system", since some old machines only
15736 15739 * respond to these class derived net broadcast. However, we must not
15737 15740 * create these net broadcast IREs if the subnetmask is shorter than
15738 15741 * the IP address class based derived netmask. Otherwise, we may
15739 15742 * create a net broadcast address which is the same as an IP address
15740 15743 * on the subnet -- and then TCP will refuse to talk to that address.
15741 15744 */
15742 15745 if (netmask < subnetmask) {
15743 15746 addr = netmask & ipif->ipif_subnet;
15744 15747 ire = ire_lookup_bcast(ill, addr, zoneid);
15745 15748 ASSERT(ire != NULL);
15746 15749 ire_delete(ire); ire_refrele(ire);
15747 15750 ire = ire_lookup_bcast(ill, ~netmask | addr, zoneid);
15748 15751 ASSERT(ire != NULL);
15749 15752 ire_delete(ire); ire_refrele(ire);
15750 15753 }
15751 15754
15752 15755 /*
15753 15756 * Don't create IRE_BROADCAST IREs for the interface if the subnetmask
15754 15757 * is 0xFFFFFFFF, as an IRE_LOCAL for that interface is already
15755 15758 * created. Creating these broadcast IREs will only create confusion
15756 15759 * as `addr' will be the same as the IP address.
15757 15760 */
15758 15761 if (subnetmask != 0xFFFFFFFF) {
15759 15762 addr = ipif->ipif_subnet;
15760 15763 ire = ire_lookup_bcast(ill, addr, zoneid);
15761 15764 ASSERT(ire != NULL);
15762 15765 ire_delete(ire); ire_refrele(ire);
15763 15766 ire = ire_lookup_bcast(ill, ~subnetmask | addr, zoneid);
15764 15767 ASSERT(ire != NULL);
15765 15768 ire_delete(ire); ire_refrele(ire);
15766 15769 }
15767 15770 }
15768 15771
15769 15772 /*
15770 15773 * Extract both the flags (including IFF_CANTCHANGE) such as IFF_IPV*
15771 15774 * from lifr_flags and the name from lifr_name.
15772 15775 * Set IFF_IPV* and ill_isv6 prior to doing the lookup
15773 15776 * since ipif_lookup_on_name uses the _isv6 flags when matching.
15774 15777 * Returns EINPROGRESS when mp has been consumed by queueing it on
15775 15778 * ipx_pending_mp and the ioctl will complete in ip_rput.
15776 15779 *
15777 15780 * Can operate on either a module or a driver queue.
15778 15781 * Returns an error if not a module queue.
15779 15782 */
15780 15783 /* ARGSUSED */
15781 15784 int
15782 15785 ip_sioctl_slifname(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15783 15786 ip_ioctl_cmd_t *ipip, void *if_req)
15784 15787 {
15785 15788 ill_t *ill = q->q_ptr;
15786 15789 phyint_t *phyi;
15787 15790 ip_stack_t *ipst;
15788 15791 struct lifreq *lifr = if_req;
15789 15792 uint64_t new_flags;
15790 15793
15791 15794 ASSERT(ipif != NULL);
15792 15795 ip1dbg(("ip_sioctl_slifname %s\n", lifr->lifr_name));
15793 15796
15794 15797 if (q->q_next == NULL) {
15795 15798 ip1dbg(("if_sioctl_slifname: SIOCSLIFNAME: no q_next\n"));
15796 15799 return (EINVAL);
15797 15800 }
15798 15801
15799 15802 /*
15800 15803 * If we are not writer on 'q' then this interface exists already
15801 15804 * and previous lookups (ip_extract_lifreq()) found this ipif --
15802 15805 * so return EALREADY.
15803 15806 */
15804 15807 if (ill != ipif->ipif_ill)
15805 15808 return (EALREADY);
15806 15809
15807 15810 if (ill->ill_name[0] != '\0')
15808 15811 return (EALREADY);
15809 15812
15810 15813 /*
15811 15814 * If there's another ill already with the requested name, ensure
15812 15815 * that it's of the same type. Otherwise, ill_phyint_reinit() will
15813 15816 * fuse together two unrelated ills, which will cause chaos.
15814 15817 */
15815 15818 ipst = ill->ill_ipst;
15816 15819 phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
15817 15820 lifr->lifr_name, NULL);
15818 15821 if (phyi != NULL) {
15819 15822 ill_t *ill_mate = phyi->phyint_illv4;
15820 15823
15821 15824 if (ill_mate == NULL)
15822 15825 ill_mate = phyi->phyint_illv6;
15823 15826 ASSERT(ill_mate != NULL);
15824 15827
15825 15828 if (ill_mate->ill_media->ip_m_mac_type !=
15826 15829 ill->ill_media->ip_m_mac_type) {
15827 15830 ip1dbg(("if_sioctl_slifname: SIOCSLIFNAME: attempt to "
15828 15831 "use the same ill name on differing media\n"));
15829 15832 return (EINVAL);
15830 15833 }
15831 15834 }
15832 15835
15833 15836 /*
15834 15837 * We start off as IFF_IPV4 in ipif_allocate and become
15835 15838 * IFF_IPV4 or IFF_IPV6 here depending on lifr_flags value.
15836 15839 * The only flags that we read from user space are IFF_IPV4,
15837 15840 * IFF_IPV6, and IFF_BROADCAST.
15838 15841 *
15839 15842 * This ill has not been inserted into the global list.
15840 15843 * So we are still single threaded and don't need any lock
15841 15844 *
15842 15845 * Saniy check the flags.
15843 15846 */
15844 15847
15845 15848 if ((lifr->lifr_flags & IFF_BROADCAST) &&
15846 15849 ((lifr->lifr_flags & IFF_IPV6) ||
15847 15850 (!ill->ill_needs_attach && ill->ill_bcast_addr_length == 0))) {
15848 15851 ip1dbg(("ip_sioctl_slifname: link not broadcast capable "
15849 15852 "or IPv6 i.e., no broadcast \n"));
15850 15853 return (EINVAL);
15851 15854 }
15852 15855
15853 15856 new_flags =
15854 15857 lifr->lifr_flags & (IFF_IPV6|IFF_IPV4|IFF_BROADCAST);
15855 15858
15856 15859 if ((new_flags ^ (IFF_IPV6|IFF_IPV4)) == 0) {
15857 15860 ip1dbg(("ip_sioctl_slifname: flags must be exactly one of "
15858 15861 "IFF_IPV4 or IFF_IPV6\n"));
15859 15862 return (EINVAL);
15860 15863 }
15861 15864
15862 15865 /*
15863 15866 * We always start off as IPv4, so only need to check for IPv6.
15864 15867 */
15865 15868 if ((new_flags & IFF_IPV6) != 0) {
15866 15869 ill->ill_flags |= ILLF_IPV6;
15867 15870 ill->ill_flags &= ~ILLF_IPV4;
15868 15871
15869 15872 if (lifr->lifr_flags & IFF_NOLINKLOCAL)
15870 15873 ill->ill_flags |= ILLF_NOLINKLOCAL;
15871 15874 }
15872 15875
15873 15876 if ((new_flags & IFF_BROADCAST) != 0)
15874 15877 ipif->ipif_flags |= IPIF_BROADCAST;
15875 15878 else
15876 15879 ipif->ipif_flags &= ~IPIF_BROADCAST;
15877 15880
15878 15881 /* We started off as V4. */
15879 15882 if (ill->ill_flags & ILLF_IPV6) {
15880 15883 ill->ill_phyint->phyint_illv6 = ill;
15881 15884 ill->ill_phyint->phyint_illv4 = NULL;
15882 15885 }
15883 15886
15884 15887 return (ipif_set_values(q, mp, lifr->lifr_name, &lifr->lifr_ppa));
15885 15888 }
15886 15889
15887 15890 /* ARGSUSED */
15888 15891 int
15889 15892 ip_sioctl_slifname_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15890 15893 ip_ioctl_cmd_t *ipip, void *if_req)
15891 15894 {
15892 15895 /*
15893 15896 * ill_phyint_reinit merged the v4 and v6 into a single
15894 15897 * ipsq. We might not have been able to complete the
15895 15898 * slifname in ipif_set_values, if we could not become
15896 15899 * exclusive. If so restart it here
15897 15900 */
15898 15901 return (ipif_set_values_tail(ipif->ipif_ill, ipif, mp, q));
15899 15902 }
15900 15903
15901 15904 /*
15902 15905 * Return a pointer to the ipif which matches the index, IP version type and
15903 15906 * zoneid.
15904 15907 */
15905 15908 ipif_t *
15906 15909 ipif_lookup_on_ifindex(uint_t index, boolean_t isv6, zoneid_t zoneid,
15907 15910 ip_stack_t *ipst)
15908 15911 {
15909 15912 ill_t *ill;
15910 15913 ipif_t *ipif = NULL;
15911 15914
15912 15915 ill = ill_lookup_on_ifindex(index, isv6, ipst);
15913 15916 if (ill != NULL) {
15914 15917 mutex_enter(&ill->ill_lock);
15915 15918 for (ipif = ill->ill_ipif; ipif != NULL;
15916 15919 ipif = ipif->ipif_next) {
15917 15920 if (!IPIF_IS_CONDEMNED(ipif) && (zoneid == ALL_ZONES ||
15918 15921 zoneid == ipif->ipif_zoneid ||
15919 15922 ipif->ipif_zoneid == ALL_ZONES)) {
15920 15923 ipif_refhold_locked(ipif);
15921 15924 break;
15922 15925 }
15923 15926 }
15924 15927 mutex_exit(&ill->ill_lock);
15925 15928 ill_refrele(ill);
15926 15929 }
15927 15930 return (ipif);
15928 15931 }
15929 15932
15930 15933 /*
15931 15934 * Change an existing physical interface's index. If the new index
15932 15935 * is acceptable we update the index and the phyint_list_avl_by_index tree.
15933 15936 * Finally, we update other systems which may have a dependence on the
15934 15937 * index value.
15935 15938 */
15936 15939 /* ARGSUSED */
15937 15940 int
15938 15941 ip_sioctl_slifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
15939 15942 ip_ioctl_cmd_t *ipip, void *ifreq)
15940 15943 {
15941 15944 ill_t *ill;
15942 15945 phyint_t *phyi;
15943 15946 struct ifreq *ifr = (struct ifreq *)ifreq;
15944 15947 struct lifreq *lifr = (struct lifreq *)ifreq;
15945 15948 uint_t old_index, index;
15946 15949 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
15947 15950 avl_index_t where;
15948 15951
15949 15952 if (ipip->ipi_cmd_type == IF_CMD)
15950 15953 index = ifr->ifr_index;
15951 15954 else
15952 15955 index = lifr->lifr_index;
15953 15956
15954 15957 /*
15955 15958 * Only allow on physical interface. Also, index zero is illegal.
15956 15959 */
15957 15960 ill = ipif->ipif_ill;
15958 15961 phyi = ill->ill_phyint;
15959 15962 if (ipif->ipif_id != 0 || index == 0 || index > IF_INDEX_MAX) {
15960 15963 return (EINVAL);
15961 15964 }
15962 15965
15963 15966 /* If the index is not changing, no work to do */
15964 15967 if (phyi->phyint_ifindex == index)
15965 15968 return (0);
15966 15969
15967 15970 /*
15968 15971 * Use phyint_exists() to determine if the new interface index
15969 15972 * is already in use. If the index is unused then we need to
15970 15973 * change the phyint's position in the phyint_list_avl_by_index
15971 15974 * tree. If we do not do this, subsequent lookups (using the new
15972 15975 * index value) will not find the phyint.
15973 15976 */
15974 15977 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
15975 15978 if (phyint_exists(index, ipst)) {
15976 15979 rw_exit(&ipst->ips_ill_g_lock);
15977 15980 return (EEXIST);
15978 15981 }
15979 15982
15980 15983 /*
15981 15984 * The new index is unused. Set it in the phyint. However we must not
15982 15985 * forget to trigger NE_IFINDEX_CHANGE event before the ifindex
15983 15986 * changes. The event must be bound to old ifindex value.
15984 15987 */
15985 15988 ill_nic_event_dispatch(ill, 0, NE_IFINDEX_CHANGE,
15986 15989 &index, sizeof (index));
15987 15990
15988 15991 old_index = phyi->phyint_ifindex;
15989 15992 phyi->phyint_ifindex = index;
15990 15993
15991 15994 avl_remove(&ipst->ips_phyint_g_list->phyint_list_avl_by_index, phyi);
15992 15995 (void) avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
15993 15996 &index, &where);
15994 15997 avl_insert(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
15995 15998 phyi, where);
15996 15999 rw_exit(&ipst->ips_ill_g_lock);
15997 16000
15998 16001 /* Update SCTP's ILL list */
15999 16002 sctp_ill_reindex(ill, old_index);
16000 16003
16001 16004 /* Send the routing sockets message */
16002 16005 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
16003 16006 if (ILL_OTHER(ill))
16004 16007 ip_rts_ifmsg(ILL_OTHER(ill)->ill_ipif, RTSQ_DEFAULT);
16005 16008
16006 16009 /* Perhaps ilgs should use this ill */
16007 16010 update_conn_ill(NULL, ill->ill_ipst);
16008 16011 return (0);
16009 16012 }
16010 16013
16011 16014 /* ARGSUSED */
16012 16015 int
16013 16016 ip_sioctl_get_lifindex(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16014 16017 ip_ioctl_cmd_t *ipip, void *ifreq)
16015 16018 {
16016 16019 struct ifreq *ifr = (struct ifreq *)ifreq;
16017 16020 struct lifreq *lifr = (struct lifreq *)ifreq;
16018 16021
16019 16022 ip1dbg(("ip_sioctl_get_lifindex(%s:%u %p)\n",
16020 16023 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16021 16024 /* Get the interface index */
16022 16025 if (ipip->ipi_cmd_type == IF_CMD) {
16023 16026 ifr->ifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex;
16024 16027 } else {
16025 16028 lifr->lifr_index = ipif->ipif_ill->ill_phyint->phyint_ifindex;
16026 16029 }
16027 16030 return (0);
16028 16031 }
16029 16032
16030 16033 /* ARGSUSED */
16031 16034 int
16032 16035 ip_sioctl_get_lifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16033 16036 ip_ioctl_cmd_t *ipip, void *ifreq)
16034 16037 {
16035 16038 struct lifreq *lifr = (struct lifreq *)ifreq;
16036 16039
16037 16040 ip1dbg(("ip_sioctl_get_lifzone(%s:%u %p)\n",
16038 16041 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16039 16042 /* Get the interface zone */
16040 16043 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
16041 16044 lifr->lifr_zoneid = ipif->ipif_zoneid;
16042 16045 return (0);
16043 16046 }
16044 16047
16045 16048 /*
16046 16049 * Set the zoneid of an interface.
16047 16050 */
16048 16051 /* ARGSUSED */
16049 16052 int
16050 16053 ip_sioctl_slifzone(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16051 16054 ip_ioctl_cmd_t *ipip, void *ifreq)
16052 16055 {
16053 16056 struct lifreq *lifr = (struct lifreq *)ifreq;
16054 16057 int err = 0;
16055 16058 boolean_t need_up = B_FALSE;
16056 16059 zone_t *zptr;
16057 16060 zone_status_t status;
16058 16061 zoneid_t zoneid;
16059 16062
16060 16063 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
16061 16064 if ((zoneid = lifr->lifr_zoneid) == ALL_ZONES) {
16062 16065 if (!is_system_labeled())
16063 16066 return (ENOTSUP);
16064 16067 zoneid = GLOBAL_ZONEID;
16065 16068 }
16066 16069
16067 16070 /* cannot assign instance zero to a non-global zone */
16068 16071 if (ipif->ipif_id == 0 && zoneid != GLOBAL_ZONEID)
16069 16072 return (ENOTSUP);
16070 16073
16071 16074 /*
16072 16075 * Cannot assign to a zone that doesn't exist or is shutting down. In
16073 16076 * the event of a race with the zone shutdown processing, since IP
16074 16077 * serializes this ioctl and SIOCGLIFCONF/SIOCLIFREMOVEIF, we know the
16075 16078 * interface will be cleaned up even if the zone is shut down
16076 16079 * immediately after the status check. If the interface can't be brought
16077 16080 * down right away, and the zone is shut down before the restart
16078 16081 * function is called, we resolve the possible races by rechecking the
16079 16082 * zone status in the restart function.
16080 16083 */
16081 16084 if ((zptr = zone_find_by_id(zoneid)) == NULL)
16082 16085 return (EINVAL);
16083 16086 status = zone_status_get(zptr);
16084 16087 zone_rele(zptr);
16085 16088
16086 16089 if (status != ZONE_IS_READY && status != ZONE_IS_RUNNING)
16087 16090 return (EINVAL);
16088 16091
16089 16092 if (ipif->ipif_flags & IPIF_UP) {
16090 16093 /*
16091 16094 * If the interface is already marked up,
16092 16095 * we call ipif_down which will take care
16093 16096 * of ditching any IREs that have been set
16094 16097 * up based on the old interface address.
16095 16098 */
16096 16099 err = ipif_logical_down(ipif, q, mp);
16097 16100 if (err == EINPROGRESS)
16098 16101 return (err);
16099 16102 (void) ipif_down_tail(ipif);
16100 16103 need_up = B_TRUE;
16101 16104 }
16102 16105
16103 16106 err = ip_sioctl_slifzone_tail(ipif, lifr->lifr_zoneid, q, mp, need_up);
16104 16107 return (err);
16105 16108 }
16106 16109
16107 16110 static int
16108 16111 ip_sioctl_slifzone_tail(ipif_t *ipif, zoneid_t zoneid,
16109 16112 queue_t *q, mblk_t *mp, boolean_t need_up)
16110 16113 {
16111 16114 int err = 0;
16112 16115 ip_stack_t *ipst;
16113 16116
16114 16117 ip1dbg(("ip_sioctl_zoneid_tail(%s:%u %p)\n",
16115 16118 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16116 16119
16117 16120 if (CONN_Q(q))
16118 16121 ipst = CONNQ_TO_IPST(q);
16119 16122 else
16120 16123 ipst = ILLQ_TO_IPST(q);
16121 16124
16122 16125 /*
16123 16126 * For exclusive stacks we don't allow a different zoneid than
16124 16127 * global.
16125 16128 */
16126 16129 if (ipst->ips_netstack->netstack_stackid != GLOBAL_NETSTACKID &&
16127 16130 zoneid != GLOBAL_ZONEID)
16128 16131 return (EINVAL);
16129 16132
16130 16133 /* Set the new zone id. */
16131 16134 ipif->ipif_zoneid = zoneid;
16132 16135
16133 16136 /* Update sctp list */
16134 16137 sctp_update_ipif(ipif, SCTP_IPIF_UPDATE);
16135 16138
16136 16139 /* The default multicast interface might have changed */
16137 16140 ire_increment_multicast_generation(ipst, ipif->ipif_ill->ill_isv6);
16138 16141
16139 16142 if (need_up) {
16140 16143 /*
16141 16144 * Now bring the interface back up. If this
16142 16145 * is the only IPIF for the ILL, ipif_up
16143 16146 * will have to re-bind to the device, so
16144 16147 * we may get back EINPROGRESS, in which
16145 16148 * case, this IOCTL will get completed in
16146 16149 * ip_rput_dlpi when we see the DL_BIND_ACK.
16147 16150 */
16148 16151 err = ipif_up(ipif, q, mp);
16149 16152 }
16150 16153 return (err);
16151 16154 }
16152 16155
16153 16156 /* ARGSUSED */
16154 16157 int
16155 16158 ip_sioctl_slifzone_restart(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16156 16159 ip_ioctl_cmd_t *ipip, void *if_req)
16157 16160 {
16158 16161 struct lifreq *lifr = (struct lifreq *)if_req;
16159 16162 zoneid_t zoneid;
16160 16163 zone_t *zptr;
16161 16164 zone_status_t status;
16162 16165
16163 16166 ASSERT(ipip->ipi_cmd_type == LIF_CMD);
16164 16167 if ((zoneid = lifr->lifr_zoneid) == ALL_ZONES)
16165 16168 zoneid = GLOBAL_ZONEID;
16166 16169
16167 16170 ip1dbg(("ip_sioctl_slifzone_restart(%s:%u %p)\n",
16168 16171 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16169 16172
16170 16173 /*
16171 16174 * We recheck the zone status to resolve the following race condition:
16172 16175 * 1) process sends SIOCSLIFZONE to put hme0:1 in zone "myzone";
16173 16176 * 2) hme0:1 is up and can't be brought down right away;
16174 16177 * ip_sioctl_slifzone() returns EINPROGRESS and the request is queued;
16175 16178 * 3) zone "myzone" is halted; the zone status switches to
16176 16179 * 'shutting_down' and the zones framework sends SIOCGLIFCONF to list
16177 16180 * the interfaces to remove - hme0:1 is not returned because it's not
16178 16181 * yet in "myzone", so it won't be removed;
16179 16182 * 4) the restart function for SIOCSLIFZONE is called; without the
16180 16183 * status check here, we would have hme0:1 in "myzone" after it's been
16181 16184 * destroyed.
16182 16185 * Note that if the status check fails, we need to bring the interface
16183 16186 * back to its state prior to ip_sioctl_slifzone(), hence the call to
16184 16187 * ipif_up_done[_v6]().
16185 16188 */
16186 16189 status = ZONE_IS_UNINITIALIZED;
16187 16190 if ((zptr = zone_find_by_id(zoneid)) != NULL) {
16188 16191 status = zone_status_get(zptr);
16189 16192 zone_rele(zptr);
16190 16193 }
16191 16194 if (status != ZONE_IS_READY && status != ZONE_IS_RUNNING) {
16192 16195 if (ipif->ipif_isv6) {
16193 16196 (void) ipif_up_done_v6(ipif);
16194 16197 } else {
16195 16198 (void) ipif_up_done(ipif);
16196 16199 }
16197 16200 return (EINVAL);
16198 16201 }
16199 16202
16200 16203 (void) ipif_down_tail(ipif);
16201 16204
16202 16205 return (ip_sioctl_slifzone_tail(ipif, lifr->lifr_zoneid, q, mp,
16203 16206 B_TRUE));
16204 16207 }
16205 16208
16206 16209 /*
16207 16210 * Return the number of addresses on `ill' with one or more of the values
16208 16211 * in `set' set and all of the values in `clear' clear.
16209 16212 */
16210 16213 static uint_t
16211 16214 ill_flagaddr_cnt(const ill_t *ill, uint64_t set, uint64_t clear)
16212 16215 {
16213 16216 ipif_t *ipif;
16214 16217 uint_t cnt = 0;
16215 16218
16216 16219 ASSERT(IAM_WRITER_ILL(ill));
16217 16220
16218 16221 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next)
16219 16222 if ((ipif->ipif_flags & set) && !(ipif->ipif_flags & clear))
16220 16223 cnt++;
16221 16224
16222 16225 return (cnt);
16223 16226 }
16224 16227
16225 16228 /*
16226 16229 * Return the number of migratable addresses on `ill' that are under
16227 16230 * application control.
16228 16231 */
16229 16232 uint_t
16230 16233 ill_appaddr_cnt(const ill_t *ill)
16231 16234 {
16232 16235 return (ill_flagaddr_cnt(ill, IPIF_DHCPRUNNING | IPIF_ADDRCONF,
16233 16236 IPIF_NOFAILOVER));
16234 16237 }
16235 16238
16236 16239 /*
16237 16240 * Return the number of point-to-point addresses on `ill'.
16238 16241 */
16239 16242 uint_t
16240 16243 ill_ptpaddr_cnt(const ill_t *ill)
16241 16244 {
16242 16245 return (ill_flagaddr_cnt(ill, IPIF_POINTOPOINT, 0));
16243 16246 }
16244 16247
16245 16248 /* ARGSUSED */
16246 16249 int
16247 16250 ip_sioctl_get_lifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16248 16251 ip_ioctl_cmd_t *ipip, void *ifreq)
16249 16252 {
16250 16253 struct lifreq *lifr = ifreq;
16251 16254
16252 16255 ASSERT(q->q_next == NULL);
16253 16256 ASSERT(CONN_Q(q));
16254 16257
16255 16258 ip1dbg(("ip_sioctl_get_lifusesrc(%s:%u %p)\n",
16256 16259 ipif->ipif_ill->ill_name, ipif->ipif_id, (void *)ipif));
16257 16260 lifr->lifr_index = ipif->ipif_ill->ill_usesrc_ifindex;
16258 16261 ip1dbg(("ip_sioctl_get_lifusesrc:lifr_index = %d\n", lifr->lifr_index));
16259 16262
16260 16263 return (0);
16261 16264 }
16262 16265
16263 16266 /* Find the previous ILL in this usesrc group */
16264 16267 static ill_t *
16265 16268 ill_prev_usesrc(ill_t *uill)
16266 16269 {
16267 16270 ill_t *ill;
16268 16271
16269 16272 for (ill = uill->ill_usesrc_grp_next;
16270 16273 ASSERT(ill), ill->ill_usesrc_grp_next != uill;
16271 16274 ill = ill->ill_usesrc_grp_next)
16272 16275 /* do nothing */;
16273 16276 return (ill);
16274 16277 }
16275 16278
16276 16279 /*
16277 16280 * Release all members of the usesrc group. This routine is called
16278 16281 * from ill_delete when the interface being unplumbed is the
16279 16282 * group head.
16280 16283 *
16281 16284 * This silently clears the usesrc that ifconfig setup.
16282 16285 * An alternative would be to keep that ifindex, and drop packets on the floor
16283 16286 * since no source address can be selected.
16284 16287 * Even if we keep the current semantics, don't need a lock and a linked list.
16285 16288 * Can walk all the ills checking if they have a ill_usesrc_ifindex matching
16286 16289 * the one that is being removed. Issue is how we return the usesrc users
16287 16290 * (SIOCGLIFSRCOF). We want to be able to find the ills which have an
16288 16291 * ill_usesrc_ifindex matching a target ill. We could also do that with an
16289 16292 * ill walk, but the walker would need to insert in the ioctl response.
16290 16293 */
16291 16294 static void
16292 16295 ill_disband_usesrc_group(ill_t *uill)
16293 16296 {
16294 16297 ill_t *next_ill, *tmp_ill;
16295 16298 ip_stack_t *ipst = uill->ill_ipst;
16296 16299
16297 16300 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_usesrc_lock));
16298 16301 next_ill = uill->ill_usesrc_grp_next;
16299 16302
16300 16303 do {
16301 16304 ASSERT(next_ill != NULL);
16302 16305 tmp_ill = next_ill->ill_usesrc_grp_next;
16303 16306 ASSERT(tmp_ill != NULL);
16304 16307 next_ill->ill_usesrc_grp_next = NULL;
16305 16308 next_ill->ill_usesrc_ifindex = 0;
16306 16309 next_ill = tmp_ill;
16307 16310 } while (next_ill->ill_usesrc_ifindex != 0);
16308 16311 uill->ill_usesrc_grp_next = NULL;
16309 16312 }
16310 16313
16311 16314 /*
16312 16315 * Remove the client usesrc ILL from the list and relink to a new list
16313 16316 */
16314 16317 int
16315 16318 ill_relink_usesrc_ills(ill_t *ucill, ill_t *uill, uint_t ifindex)
16316 16319 {
16317 16320 ill_t *ill, *tmp_ill;
16318 16321 ip_stack_t *ipst = ucill->ill_ipst;
16319 16322
16320 16323 ASSERT((ucill != NULL) && (ucill->ill_usesrc_grp_next != NULL) &&
16321 16324 (uill != NULL) && RW_WRITE_HELD(&ipst->ips_ill_g_usesrc_lock));
16322 16325
16323 16326 /*
16324 16327 * Check if the usesrc client ILL passed in is not already
16325 16328 * in use as a usesrc ILL i.e one whose source address is
16326 16329 * in use OR a usesrc ILL is not already in use as a usesrc
16327 16330 * client ILL
16328 16331 */
16329 16332 if ((ucill->ill_usesrc_ifindex == 0) ||
16330 16333 (uill->ill_usesrc_ifindex != 0)) {
16331 16334 return (-1);
16332 16335 }
16333 16336
16334 16337 ill = ill_prev_usesrc(ucill);
16335 16338 ASSERT(ill->ill_usesrc_grp_next != NULL);
16336 16339
16337 16340 /* Remove from the current list */
16338 16341 if (ill->ill_usesrc_grp_next->ill_usesrc_grp_next == ill) {
16339 16342 /* Only two elements in the list */
16340 16343 ASSERT(ill->ill_usesrc_ifindex == 0);
16341 16344 ill->ill_usesrc_grp_next = NULL;
16342 16345 } else {
16343 16346 ill->ill_usesrc_grp_next = ucill->ill_usesrc_grp_next;
16344 16347 }
16345 16348
16346 16349 if (ifindex == 0) {
16347 16350 ucill->ill_usesrc_ifindex = 0;
16348 16351 ucill->ill_usesrc_grp_next = NULL;
16349 16352 return (0);
16350 16353 }
16351 16354
16352 16355 ucill->ill_usesrc_ifindex = ifindex;
16353 16356 tmp_ill = uill->ill_usesrc_grp_next;
16354 16357 uill->ill_usesrc_grp_next = ucill;
16355 16358 ucill->ill_usesrc_grp_next =
16356 16359 (tmp_ill != NULL) ? tmp_ill : uill;
16357 16360 return (0);
16358 16361 }
16359 16362
16360 16363 /*
16361 16364 * Set the ill_usesrc and ill_usesrc_head fields. See synchronization notes in
16362 16365 * ip.c for locking details.
16363 16366 */
16364 16367 /* ARGSUSED */
16365 16368 int
16366 16369 ip_sioctl_slifusesrc(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16367 16370 ip_ioctl_cmd_t *ipip, void *ifreq)
16368 16371 {
16369 16372 struct lifreq *lifr = (struct lifreq *)ifreq;
16370 16373 boolean_t isv6 = B_FALSE, reset_flg = B_FALSE;
16371 16374 ill_t *usesrc_ill, *usesrc_cli_ill = ipif->ipif_ill;
16372 16375 int err = 0, ret;
16373 16376 uint_t ifindex;
16374 16377 ipsq_t *ipsq = NULL;
16375 16378 ip_stack_t *ipst = ipif->ipif_ill->ill_ipst;
16376 16379
16377 16380 ASSERT(IAM_WRITER_IPIF(ipif));
16378 16381 ASSERT(q->q_next == NULL);
16379 16382 ASSERT(CONN_Q(q));
16380 16383
16381 16384 isv6 = (Q_TO_CONN(q))->conn_family == AF_INET6;
16382 16385
16383 16386 ifindex = lifr->lifr_index;
16384 16387 if (ifindex == 0) {
16385 16388 if (usesrc_cli_ill->ill_usesrc_grp_next == NULL) {
16386 16389 /* non usesrc group interface, nothing to reset */
16387 16390 return (0);
16388 16391 }
16389 16392 ifindex = usesrc_cli_ill->ill_usesrc_ifindex;
16390 16393 /* valid reset request */
16391 16394 reset_flg = B_TRUE;
16392 16395 }
16393 16396
16394 16397 usesrc_ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
16395 16398 if (usesrc_ill == NULL)
16396 16399 return (ENXIO);
16397 16400 if (usesrc_ill == ipif->ipif_ill) {
16398 16401 ill_refrele(usesrc_ill);
16399 16402 return (EINVAL);
16400 16403 }
16401 16404
16402 16405 ipsq = ipsq_try_enter(NULL, usesrc_ill, q, mp, ip_process_ioctl,
16403 16406 NEW_OP, B_TRUE);
16404 16407 if (ipsq == NULL) {
16405 16408 err = EINPROGRESS;
16406 16409 /* Operation enqueued on the ipsq of the usesrc ILL */
16407 16410 goto done;
16408 16411 }
16409 16412
16410 16413 /* USESRC isn't currently supported with IPMP */
16411 16414 if (IS_IPMP(usesrc_ill) || IS_UNDER_IPMP(usesrc_ill)) {
16412 16415 err = ENOTSUP;
16413 16416 goto done;
16414 16417 }
16415 16418
16416 16419 /*
16417 16420 * USESRC isn't compatible with the STANDBY flag. (STANDBY is only
16418 16421 * used by IPMP underlying interfaces, but someone might think it's
16419 16422 * more general and try to use it independently with VNI.)
16420 16423 */
16421 16424 if (usesrc_ill->ill_phyint->phyint_flags & PHYI_STANDBY) {
16422 16425 err = ENOTSUP;
16423 16426 goto done;
16424 16427 }
16425 16428
16426 16429 /*
16427 16430 * If the client is already in use as a usesrc_ill or a usesrc_ill is
16428 16431 * already a client then return EINVAL
16429 16432 */
16430 16433 if (IS_USESRC_ILL(usesrc_cli_ill) || IS_USESRC_CLI_ILL(usesrc_ill)) {
16431 16434 err = EINVAL;
16432 16435 goto done;
16433 16436 }
16434 16437
16435 16438 /*
16436 16439 * If the ill_usesrc_ifindex field is already set to what it needs to
16437 16440 * be then this is a duplicate operation.
16438 16441 */
16439 16442 if (!reset_flg && usesrc_cli_ill->ill_usesrc_ifindex == ifindex) {
16440 16443 err = 0;
16441 16444 goto done;
16442 16445 }
16443 16446
16444 16447 ip1dbg(("ip_sioctl_slifusesrc: usesrc_cli_ill %s, usesrc_ill %s,"
16445 16448 " v6 = %d", usesrc_cli_ill->ill_name, usesrc_ill->ill_name,
16446 16449 usesrc_ill->ill_isv6));
16447 16450
16448 16451 /*
16449 16452 * ill_g_usesrc_lock global lock protects the ill_usesrc_grp_next
16450 16453 * and the ill_usesrc_ifindex fields
16451 16454 */
16452 16455 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_WRITER);
16453 16456
16454 16457 if (reset_flg) {
16455 16458 ret = ill_relink_usesrc_ills(usesrc_cli_ill, usesrc_ill, 0);
16456 16459 if (ret != 0) {
16457 16460 err = EINVAL;
16458 16461 }
16459 16462 rw_exit(&ipst->ips_ill_g_usesrc_lock);
16460 16463 goto done;
16461 16464 }
16462 16465
16463 16466 /*
16464 16467 * Four possibilities to consider:
16465 16468 * 1. Both usesrc_ill and usesrc_cli_ill are not part of any usesrc grp
16466 16469 * 2. usesrc_ill is part of a group but usesrc_cli_ill isn't
16467 16470 * 3. usesrc_cli_ill is part of a group but usesrc_ill isn't
16468 16471 * 4. Both are part of their respective usesrc groups
16469 16472 */
16470 16473 if ((usesrc_ill->ill_usesrc_grp_next == NULL) &&
16471 16474 (usesrc_cli_ill->ill_usesrc_grp_next == NULL)) {
16472 16475 ASSERT(usesrc_ill->ill_usesrc_ifindex == 0);
16473 16476 usesrc_cli_ill->ill_usesrc_ifindex = ifindex;
16474 16477 usesrc_ill->ill_usesrc_grp_next = usesrc_cli_ill;
16475 16478 usesrc_cli_ill->ill_usesrc_grp_next = usesrc_ill;
16476 16479 } else if ((usesrc_ill->ill_usesrc_grp_next != NULL) &&
16477 16480 (usesrc_cli_ill->ill_usesrc_grp_next == NULL)) {
16478 16481 usesrc_cli_ill->ill_usesrc_ifindex = ifindex;
16479 16482 /* Insert at head of list */
16480 16483 usesrc_cli_ill->ill_usesrc_grp_next =
16481 16484 usesrc_ill->ill_usesrc_grp_next;
16482 16485 usesrc_ill->ill_usesrc_grp_next = usesrc_cli_ill;
16483 16486 } else {
16484 16487 ret = ill_relink_usesrc_ills(usesrc_cli_ill, usesrc_ill,
16485 16488 ifindex);
16486 16489 if (ret != 0)
16487 16490 err = EINVAL;
16488 16491 }
16489 16492 rw_exit(&ipst->ips_ill_g_usesrc_lock);
16490 16493
16491 16494 done:
16492 16495 if (ipsq != NULL)
16493 16496 ipsq_exit(ipsq);
16494 16497 /* The refrele on the lifr_name ipif is done by ip_process_ioctl */
16495 16498 ill_refrele(usesrc_ill);
16496 16499
16497 16500 /* Let conn_ixa caching know that source address selection changed */
16498 16501 ip_update_source_selection(ipst);
16499 16502
16500 16503 return (err);
16501 16504 }
16502 16505
16503 16506 /* ARGSUSED */
16504 16507 int
16505 16508 ip_sioctl_get_dadstate(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
16506 16509 ip_ioctl_cmd_t *ipip, void *if_req)
16507 16510 {
16508 16511 struct lifreq *lifr = (struct lifreq *)if_req;
16509 16512 ill_t *ill = ipif->ipif_ill;
16510 16513
16511 16514 /*
16512 16515 * Need a lock since IFF_UP can be set even when there are
16513 16516 * references to the ipif.
16514 16517 */
16515 16518 mutex_enter(&ill->ill_lock);
16516 16519 if ((ipif->ipif_flags & IPIF_UP) && ipif->ipif_addr_ready == 0)
16517 16520 lifr->lifr_dadstate = DAD_IN_PROGRESS;
16518 16521 else
16519 16522 lifr->lifr_dadstate = DAD_DONE;
16520 16523 mutex_exit(&ill->ill_lock);
16521 16524 return (0);
16522 16525 }
16523 16526
16524 16527 /*
16525 16528 * comparison function used by avl.
16526 16529 */
16527 16530 static int
16528 16531 ill_phyint_compare_index(const void *index_ptr, const void *phyip)
16529 16532 {
16530 16533
16531 16534 uint_t index;
16532 16535
16533 16536 ASSERT(phyip != NULL && index_ptr != NULL);
16534 16537
16535 16538 index = *((uint_t *)index_ptr);
16536 16539 /*
16537 16540 * let the phyint with the lowest index be on top.
16538 16541 */
16539 16542 if (((phyint_t *)phyip)->phyint_ifindex < index)
16540 16543 return (1);
16541 16544 if (((phyint_t *)phyip)->phyint_ifindex > index)
16542 16545 return (-1);
16543 16546 return (0);
16544 16547 }
16545 16548
16546 16549 /*
16547 16550 * comparison function used by avl.
16548 16551 */
16549 16552 static int
16550 16553 ill_phyint_compare_name(const void *name_ptr, const void *phyip)
16551 16554 {
16552 16555 ill_t *ill;
16553 16556 int res = 0;
16554 16557
16555 16558 ASSERT(phyip != NULL && name_ptr != NULL);
16556 16559
16557 16560 if (((phyint_t *)phyip)->phyint_illv4)
16558 16561 ill = ((phyint_t *)phyip)->phyint_illv4;
16559 16562 else
16560 16563 ill = ((phyint_t *)phyip)->phyint_illv6;
16561 16564 ASSERT(ill != NULL);
16562 16565
16563 16566 res = strcmp(ill->ill_name, (char *)name_ptr);
16564 16567 if (res > 0)
16565 16568 return (1);
16566 16569 else if (res < 0)
16567 16570 return (-1);
16568 16571 return (0);
16569 16572 }
16570 16573
16571 16574 /*
16572 16575 * This function is called on the unplumb path via ill_glist_delete() when
16573 16576 * there are no ills left on the phyint and thus the phyint can be freed.
16574 16577 */
16575 16578 static void
16576 16579 phyint_free(phyint_t *phyi)
16577 16580 {
16578 16581 ip_stack_t *ipst = PHYINT_TO_IPST(phyi);
16579 16582
16580 16583 ASSERT(phyi->phyint_illv4 == NULL && phyi->phyint_illv6 == NULL);
16581 16584
16582 16585 /*
16583 16586 * If this phyint was an IPMP meta-interface, blow away the group.
16584 16587 * This is safe to do because all of the illgrps have already been
16585 16588 * removed by I_PUNLINK, and thus SIOCSLIFGROUPNAME cannot find us.
16586 16589 * If we're cleaning up as a result of failed initialization,
16587 16590 * phyint_grp may be NULL.
16588 16591 */
16589 16592 if ((phyi->phyint_flags & PHYI_IPMP) && (phyi->phyint_grp != NULL)) {
16590 16593 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
16591 16594 ipmp_grp_destroy(phyi->phyint_grp);
16592 16595 phyi->phyint_grp = NULL;
16593 16596 rw_exit(&ipst->ips_ipmp_lock);
16594 16597 }
16595 16598
16596 16599 /*
16597 16600 * If this interface was under IPMP, take it out of the group.
16598 16601 */
16599 16602 if (phyi->phyint_grp != NULL)
16600 16603 ipmp_phyint_leave_grp(phyi);
16601 16604
16602 16605 /*
16603 16606 * Delete the phyint and disassociate its ipsq. The ipsq itself
16604 16607 * will be freed in ipsq_exit().
16605 16608 */
16606 16609 phyi->phyint_ipsq->ipsq_phyint = NULL;
16607 16610 phyi->phyint_name[0] = '\0';
16608 16611
16609 16612 mi_free(phyi);
16610 16613 }
16611 16614
16612 16615 /*
16613 16616 * Attach the ill to the phyint structure which can be shared by both
16614 16617 * IPv4 and IPv6 ill. ill_init allocates a phyint to just hold flags. This
16615 16618 * function is called from ipif_set_values and ill_lookup_on_name (for
16616 16619 * loopback) where we know the name of the ill. We lookup the ill and if
16617 16620 * there is one present already with the name use that phyint. Otherwise
16618 16621 * reuse the one allocated by ill_init.
16619 16622 */
16620 16623 static void
16621 16624 ill_phyint_reinit(ill_t *ill)
16622 16625 {
16623 16626 boolean_t isv6 = ill->ill_isv6;
16624 16627 phyint_t *phyi_old;
16625 16628 phyint_t *phyi;
16626 16629 avl_index_t where = 0;
16627 16630 ill_t *ill_other = NULL;
16628 16631 ip_stack_t *ipst = ill->ill_ipst;
16629 16632
16630 16633 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock));
16631 16634
16632 16635 phyi_old = ill->ill_phyint;
16633 16636 ASSERT(isv6 || (phyi_old->phyint_illv4 == ill &&
16634 16637 phyi_old->phyint_illv6 == NULL));
16635 16638 ASSERT(!isv6 || (phyi_old->phyint_illv6 == ill &&
16636 16639 phyi_old->phyint_illv4 == NULL));
16637 16640 ASSERT(phyi_old->phyint_ifindex == 0);
16638 16641
16639 16642 /*
16640 16643 * Now that our ill has a name, set it in the phyint.
16641 16644 */
16642 16645 (void) strlcpy(ill->ill_phyint->phyint_name, ill->ill_name, LIFNAMSIZ);
16643 16646
16644 16647 phyi = avl_find(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
16645 16648 ill->ill_name, &where);
16646 16649
16647 16650 /*
16648 16651 * 1. We grabbed the ill_g_lock before inserting this ill into
16649 16652 * the global list of ills. So no other thread could have located
16650 16653 * this ill and hence the ipsq of this ill is guaranteed to be empty.
16651 16654 * 2. Now locate the other protocol instance of this ill.
16652 16655 * 3. Now grab both ill locks in the right order, and the phyint lock of
16653 16656 * the new ipsq. Holding ill locks + ill_g_lock ensures that the ipsq
16654 16657 * of neither ill can change.
16655 16658 * 4. Merge the phyint and thus the ipsq as well of this ill onto the
16656 16659 * other ill.
16657 16660 * 5. Release all locks.
16658 16661 */
16659 16662
16660 16663 /*
16661 16664 * Look for IPv4 if we are initializing IPv6 or look for IPv6 if
16662 16665 * we are initializing IPv4.
16663 16666 */
16664 16667 if (phyi != NULL) {
16665 16668 ill_other = (isv6) ? phyi->phyint_illv4 : phyi->phyint_illv6;
16666 16669 ASSERT(ill_other->ill_phyint != NULL);
16667 16670 ASSERT((isv6 && !ill_other->ill_isv6) ||
16668 16671 (!isv6 && ill_other->ill_isv6));
16669 16672 GRAB_ILL_LOCKS(ill, ill_other);
16670 16673 /*
16671 16674 * We are potentially throwing away phyint_flags which
16672 16675 * could be different from the one that we obtain from
16673 16676 * ill_other->ill_phyint. But it is okay as we are assuming
16674 16677 * that the state maintained within IP is correct.
16675 16678 */
16676 16679 mutex_enter(&phyi->phyint_lock);
16677 16680 if (isv6) {
16678 16681 ASSERT(phyi->phyint_illv6 == NULL);
16679 16682 phyi->phyint_illv6 = ill;
16680 16683 } else {
16681 16684 ASSERT(phyi->phyint_illv4 == NULL);
16682 16685 phyi->phyint_illv4 = ill;
16683 16686 }
16684 16687
16685 16688 /*
16686 16689 * Delete the old phyint and make its ipsq eligible
16687 16690 * to be freed in ipsq_exit().
16688 16691 */
16689 16692 phyi_old->phyint_illv4 = NULL;
16690 16693 phyi_old->phyint_illv6 = NULL;
16691 16694 phyi_old->phyint_ipsq->ipsq_phyint = NULL;
16692 16695 phyi_old->phyint_name[0] = '\0';
16693 16696 mi_free(phyi_old);
16694 16697 } else {
16695 16698 mutex_enter(&ill->ill_lock);
16696 16699 /*
16697 16700 * We don't need to acquire any lock, since
16698 16701 * the ill is not yet visible globally and we
16699 16702 * have not yet released the ill_g_lock.
16700 16703 */
16701 16704 phyi = phyi_old;
16702 16705 mutex_enter(&phyi->phyint_lock);
16703 16706 /* XXX We need a recovery strategy here. */
16704 16707 if (!phyint_assign_ifindex(phyi, ipst))
16705 16708 cmn_err(CE_PANIC, "phyint_assign_ifindex() failed");
16706 16709
16707 16710 avl_insert(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
16708 16711 (void *)phyi, where);
16709 16712
16710 16713 (void) avl_find(&ipst->ips_phyint_g_list->
16711 16714 phyint_list_avl_by_index,
16712 16715 &phyi->phyint_ifindex, &where);
16713 16716 avl_insert(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
16714 16717 (void *)phyi, where);
16715 16718 }
16716 16719
16717 16720 /*
16718 16721 * Reassigning ill_phyint automatically reassigns the ipsq also.
16719 16722 * pending mp is not affected because that is per ill basis.
16720 16723 */
16721 16724 ill->ill_phyint = phyi;
16722 16725
16723 16726 /*
16724 16727 * Now that the phyint's ifindex has been assigned, complete the
16725 16728 * remaining
16726 16729 */
16727 16730 ill->ill_ip_mib->ipIfStatsIfIndex = ill->ill_phyint->phyint_ifindex;
16728 16731 if (ill->ill_isv6) {
16729 16732 ill->ill_icmp6_mib->ipv6IfIcmpIfIndex =
16730 16733 ill->ill_phyint->phyint_ifindex;
16731 16734 ill->ill_mcast_type = ipst->ips_mld_max_version;
16732 16735 } else {
16733 16736 ill->ill_mcast_type = ipst->ips_igmp_max_version;
16734 16737 }
16735 16738
16736 16739 /*
16737 16740 * Generate an event within the hooks framework to indicate that
16738 16741 * a new interface has just been added to IP. For this event to
16739 16742 * be generated, the network interface must, at least, have an
16740 16743 * ifindex assigned to it. (We don't generate the event for
16741 16744 * loopback since ill_lookup_on_name() has its own NE_PLUMB event.)
16742 16745 *
16743 16746 * This needs to be run inside the ill_g_lock perimeter to ensure
16744 16747 * that the ordering of delivered events to listeners matches the
16745 16748 * order of them in the kernel.
16746 16749 */
16747 16750 if (!IS_LOOPBACK(ill)) {
16748 16751 ill_nic_event_dispatch(ill, 0, NE_PLUMB, ill->ill_name,
16749 16752 ill->ill_name_length);
16750 16753 }
16751 16754 RELEASE_ILL_LOCKS(ill, ill_other);
16752 16755 mutex_exit(&phyi->phyint_lock);
16753 16756 }
16754 16757
16755 16758 /*
16756 16759 * Notify any downstream modules of the name of this interface.
16757 16760 * An M_IOCTL is used even though we don't expect a successful reply.
16758 16761 * Any reply message from the driver (presumably an M_IOCNAK) will
16759 16762 * eventually get discarded somewhere upstream. The message format is
16760 16763 * simply an SIOCSLIFNAME ioctl just as might be sent from ifconfig
16761 16764 * to IP.
16762 16765 */
16763 16766 static void
16764 16767 ip_ifname_notify(ill_t *ill, queue_t *q)
16765 16768 {
16766 16769 mblk_t *mp1, *mp2;
16767 16770 struct iocblk *iocp;
16768 16771 struct lifreq *lifr;
16769 16772
16770 16773 mp1 = mkiocb(SIOCSLIFNAME);
16771 16774 if (mp1 == NULL)
16772 16775 return;
16773 16776 mp2 = allocb(sizeof (struct lifreq), BPRI_HI);
16774 16777 if (mp2 == NULL) {
16775 16778 freeb(mp1);
16776 16779 return;
16777 16780 }
16778 16781
16779 16782 mp1->b_cont = mp2;
16780 16783 iocp = (struct iocblk *)mp1->b_rptr;
16781 16784 iocp->ioc_count = sizeof (struct lifreq);
16782 16785
16783 16786 lifr = (struct lifreq *)mp2->b_rptr;
16784 16787 mp2->b_wptr += sizeof (struct lifreq);
16785 16788 bzero(lifr, sizeof (struct lifreq));
16786 16789
16787 16790 (void) strncpy(lifr->lifr_name, ill->ill_name, LIFNAMSIZ);
16788 16791 lifr->lifr_ppa = ill->ill_ppa;
16789 16792 lifr->lifr_flags = (ill->ill_flags & (ILLF_IPV4|ILLF_IPV6));
16790 16793
16791 16794 DTRACE_PROBE3(ill__dlpi, char *, "ip_ifname_notify",
16792 16795 char *, "SIOCSLIFNAME", ill_t *, ill);
16793 16796 putnext(q, mp1);
16794 16797 }
16795 16798
16796 16799 static int
16797 16800 ipif_set_values_tail(ill_t *ill, ipif_t *ipif, mblk_t *mp, queue_t *q)
16798 16801 {
16799 16802 int err;
16800 16803 ip_stack_t *ipst = ill->ill_ipst;
16801 16804 phyint_t *phyi = ill->ill_phyint;
16802 16805
16803 16806 /*
16804 16807 * Now that ill_name is set, the configuration for the IPMP
16805 16808 * meta-interface can be performed.
16806 16809 */
16807 16810 if (IS_IPMP(ill)) {
16808 16811 rw_enter(&ipst->ips_ipmp_lock, RW_WRITER);
16809 16812 /*
16810 16813 * If phyi->phyint_grp is NULL, then this is the first IPMP
16811 16814 * meta-interface and we need to create the IPMP group.
16812 16815 */
16813 16816 if (phyi->phyint_grp == NULL) {
16814 16817 /*
16815 16818 * If someone has renamed another IPMP group to have
16816 16819 * the same name as our interface, bail.
16817 16820 */
16818 16821 if (ipmp_grp_lookup(ill->ill_name, ipst) != NULL) {
16819 16822 rw_exit(&ipst->ips_ipmp_lock);
16820 16823 return (EEXIST);
16821 16824 }
16822 16825 phyi->phyint_grp = ipmp_grp_create(ill->ill_name, phyi);
16823 16826 if (phyi->phyint_grp == NULL) {
16824 16827 rw_exit(&ipst->ips_ipmp_lock);
16825 16828 return (ENOMEM);
16826 16829 }
16827 16830 }
16828 16831 rw_exit(&ipst->ips_ipmp_lock);
16829 16832 }
16830 16833
16831 16834 /* Tell downstream modules where they are. */
16832 16835 ip_ifname_notify(ill, q);
16833 16836
16834 16837 /*
16835 16838 * ill_dl_phys returns EINPROGRESS in the usual case.
16836 16839 * Error cases are ENOMEM ...
16837 16840 */
16838 16841 err = ill_dl_phys(ill, ipif, mp, q);
16839 16842
16840 16843 if (ill->ill_isv6) {
16841 16844 mutex_enter(&ipst->ips_mld_slowtimeout_lock);
16842 16845 if (ipst->ips_mld_slowtimeout_id == 0) {
16843 16846 ipst->ips_mld_slowtimeout_id = timeout(mld_slowtimo,
16844 16847 (void *)ipst,
16845 16848 MSEC_TO_TICK(MCAST_SLOWTIMO_INTERVAL));
16846 16849 }
16847 16850 mutex_exit(&ipst->ips_mld_slowtimeout_lock);
16848 16851 } else {
16849 16852 mutex_enter(&ipst->ips_igmp_slowtimeout_lock);
16850 16853 if (ipst->ips_igmp_slowtimeout_id == 0) {
16851 16854 ipst->ips_igmp_slowtimeout_id = timeout(igmp_slowtimo,
16852 16855 (void *)ipst,
16853 16856 MSEC_TO_TICK(MCAST_SLOWTIMO_INTERVAL));
16854 16857 }
16855 16858 mutex_exit(&ipst->ips_igmp_slowtimeout_lock);
16856 16859 }
16857 16860
16858 16861 return (err);
16859 16862 }
16860 16863
16861 16864 /*
16862 16865 * Common routine for ppa and ifname setting. Should be called exclusive.
16863 16866 *
16864 16867 * Returns EINPROGRESS when mp has been consumed by queueing it on
16865 16868 * ipx_pending_mp and the ioctl will complete in ip_rput.
16866 16869 *
16867 16870 * NOTE : If ppa is UNIT_MAX, we assign the next valid ppa and return
16868 16871 * the new name and new ppa in lifr_name and lifr_ppa respectively.
16869 16872 * For SLIFNAME, we pass these values back to the userland.
16870 16873 */
16871 16874 static int
16872 16875 ipif_set_values(queue_t *q, mblk_t *mp, char *interf_name, uint_t *new_ppa_ptr)
16873 16876 {
16874 16877 ill_t *ill;
16875 16878 ipif_t *ipif;
16876 16879 ipsq_t *ipsq;
16877 16880 char *ppa_ptr;
16878 16881 char *old_ptr;
16879 16882 char old_char;
16880 16883 int error;
16881 16884 ip_stack_t *ipst;
16882 16885
16883 16886 ip1dbg(("ipif_set_values: interface %s\n", interf_name));
16884 16887 ASSERT(q->q_next != NULL);
16885 16888 ASSERT(interf_name != NULL);
16886 16889
16887 16890 ill = (ill_t *)q->q_ptr;
16888 16891 ipst = ill->ill_ipst;
16889 16892
16890 16893 ASSERT(ill->ill_ipst != NULL);
16891 16894 ASSERT(ill->ill_name[0] == '\0');
16892 16895 ASSERT(IAM_WRITER_ILL(ill));
16893 16896 ASSERT((mi_strlen(interf_name) + 1) <= LIFNAMSIZ);
16894 16897 ASSERT(ill->ill_ppa == UINT_MAX);
16895 16898
16896 16899 ill->ill_defend_start = ill->ill_defend_count = 0;
16897 16900 /* The ppa is sent down by ifconfig or is chosen */
16898 16901 if ((ppa_ptr = ill_get_ppa_ptr(interf_name)) == NULL) {
16899 16902 return (EINVAL);
16900 16903 }
16901 16904
16902 16905 /*
16903 16906 * make sure ppa passed in is same as ppa in the name.
16904 16907 * This check is not made when ppa == UINT_MAX in that case ppa
16905 16908 * in the name could be anything. System will choose a ppa and
16906 16909 * update new_ppa_ptr and inter_name to contain the choosen ppa.
16907 16910 */
16908 16911 if (*new_ppa_ptr != UINT_MAX) {
16909 16912 /* stoi changes the pointer */
16910 16913 old_ptr = ppa_ptr;
16911 16914 /*
16912 16915 * ifconfig passed in 0 for the ppa for DLPI 1 style devices
16913 16916 * (they don't have an externally visible ppa). We assign one
16914 16917 * here so that we can manage the interface. Note that in
16915 16918 * the past this value was always 0 for DLPI 1 drivers.
16916 16919 */
16917 16920 if (*new_ppa_ptr == 0)
16918 16921 *new_ppa_ptr = stoi(&old_ptr);
16919 16922 else if (*new_ppa_ptr != (uint_t)stoi(&old_ptr))
16920 16923 return (EINVAL);
16921 16924 }
16922 16925 /*
16923 16926 * terminate string before ppa
16924 16927 * save char at that location.
16925 16928 */
16926 16929 old_char = ppa_ptr[0];
16927 16930 ppa_ptr[0] = '\0';
16928 16931
16929 16932 ill->ill_ppa = *new_ppa_ptr;
16930 16933 /*
16931 16934 * Finish as much work now as possible before calling ill_glist_insert
16932 16935 * which makes the ill globally visible and also merges it with the
16933 16936 * other protocol instance of this phyint. The remaining work is
16934 16937 * done after entering the ipsq which may happen sometime later.
16935 16938 */
16936 16939 ipif = ill->ill_ipif;
16937 16940
16938 16941 /* We didn't do this when we allocated ipif in ip_ll_subnet_defaults */
16939 16942 ipif_assign_seqid(ipif);
16940 16943
16941 16944 if (!(ill->ill_flags & (ILLF_IPV4|ILLF_IPV6)))
16942 16945 ill->ill_flags |= ILLF_IPV4;
16943 16946
16944 16947 ASSERT(ipif->ipif_next == NULL); /* Only one ipif on ill */
16945 16948 ASSERT((ipif->ipif_flags & IPIF_UP) == 0);
16946 16949
16947 16950 if (ill->ill_flags & ILLF_IPV6) {
16948 16951
16949 16952 ill->ill_isv6 = B_TRUE;
16950 16953 ill_set_inputfn(ill);
16951 16954 if (ill->ill_rq != NULL) {
16952 16955 ill->ill_rq->q_qinfo = &iprinitv6;
16953 16956 }
16954 16957
16955 16958 /* Keep the !IN6_IS_ADDR_V4MAPPED assertions happy */
16956 16959 ipif->ipif_v6lcl_addr = ipv6_all_zeros;
16957 16960 ipif->ipif_v6subnet = ipv6_all_zeros;
16958 16961 ipif->ipif_v6net_mask = ipv6_all_zeros;
16959 16962 ipif->ipif_v6brd_addr = ipv6_all_zeros;
16960 16963 ipif->ipif_v6pp_dst_addr = ipv6_all_zeros;
16961 16964 ill->ill_reachable_retrans_time = ND_RETRANS_TIMER;
16962 16965 /*
16963 16966 * point-to-point or Non-mulicast capable
16964 16967 * interfaces won't do NUD unless explicitly
16965 16968 * configured to do so.
16966 16969 */
16967 16970 if (ipif->ipif_flags & IPIF_POINTOPOINT ||
16968 16971 !(ill->ill_flags & ILLF_MULTICAST)) {
16969 16972 ill->ill_flags |= ILLF_NONUD;
16970 16973 }
16971 16974 /* Make sure IPv4 specific flag is not set on IPv6 if */
16972 16975 if (ill->ill_flags & ILLF_NOARP) {
16973 16976 /*
16974 16977 * Note: xresolv interfaces will eventually need
16975 16978 * NOARP set here as well, but that will require
16976 16979 * those external resolvers to have some
16977 16980 * knowledge of that flag and act appropriately.
16978 16981 * Not to be changed at present.
16979 16982 */
16980 16983 ill->ill_flags &= ~ILLF_NOARP;
16981 16984 }
16982 16985 /*
16983 16986 * Set the ILLF_ROUTER flag according to the global
16984 16987 * IPv6 forwarding policy.
16985 16988 */
16986 16989 if (ipst->ips_ipv6_forwarding != 0)
16987 16990 ill->ill_flags |= ILLF_ROUTER;
16988 16991 } else if (ill->ill_flags & ILLF_IPV4) {
16989 16992 ill->ill_isv6 = B_FALSE;
16990 16993 ill_set_inputfn(ill);
16991 16994 ill->ill_reachable_retrans_time = ARP_RETRANS_TIMER;
16992 16995 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6lcl_addr);
16993 16996 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6subnet);
16994 16997 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6net_mask);
16995 16998 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6brd_addr);
16996 16999 IN6_IPADDR_TO_V4MAPPED(INADDR_ANY, &ipif->ipif_v6pp_dst_addr);
16997 17000 /*
16998 17001 * Set the ILLF_ROUTER flag according to the global
16999 17002 * IPv4 forwarding policy.
17000 17003 */
17001 17004 if (ipst->ips_ip_forwarding != 0)
17002 17005 ill->ill_flags |= ILLF_ROUTER;
17003 17006 }
17004 17007
17005 17008 ASSERT(ill->ill_phyint != NULL);
17006 17009
17007 17010 /*
17008 17011 * The ipIfStatsIfindex and ipv6IfIcmpIfIndex assignments will
17009 17012 * be completed in ill_glist_insert -> ill_phyint_reinit
17010 17013 */
17011 17014 if (!ill_allocate_mibs(ill))
17012 17015 return (ENOMEM);
17013 17016
17014 17017 /*
17015 17018 * Pick a default sap until we get the DL_INFO_ACK back from
17016 17019 * the driver.
17017 17020 */
17018 17021 ill->ill_sap = (ill->ill_isv6) ? ill->ill_media->ip_m_ipv6sap :
17019 17022 ill->ill_media->ip_m_ipv4sap;
17020 17023
17021 17024 ill->ill_ifname_pending = 1;
17022 17025 ill->ill_ifname_pending_err = 0;
17023 17026
17024 17027 /*
17025 17028 * When the first ipif comes up in ipif_up_done(), multicast groups
17026 17029 * that were joined while this ill was not bound to the DLPI link need
17027 17030 * to be recovered by ill_recover_multicast().
17028 17031 */
17029 17032 ill->ill_need_recover_multicast = 1;
17030 17033
17031 17034 ill_refhold(ill);
17032 17035 rw_enter(&ipst->ips_ill_g_lock, RW_WRITER);
17033 17036 if ((error = ill_glist_insert(ill, interf_name,
17034 17037 (ill->ill_flags & ILLF_IPV6) == ILLF_IPV6)) > 0) {
17035 17038 ill->ill_ppa = UINT_MAX;
17036 17039 ill->ill_name[0] = '\0';
17037 17040 /*
17038 17041 * undo null termination done above.
17039 17042 */
17040 17043 ppa_ptr[0] = old_char;
17041 17044 rw_exit(&ipst->ips_ill_g_lock);
17042 17045 ill_refrele(ill);
17043 17046 return (error);
17044 17047 }
17045 17048
17046 17049 ASSERT(ill->ill_name_length <= LIFNAMSIZ);
17047 17050
17048 17051 /*
17049 17052 * When we return the buffer pointed to by interf_name should contain
17050 17053 * the same name as in ill_name.
17051 17054 * If a ppa was choosen by the system (ppa passed in was UINT_MAX)
17052 17055 * the buffer pointed to by new_ppa_ptr would not contain the right ppa
17053 17056 * so copy full name and update the ppa ptr.
17054 17057 * When ppa passed in != UINT_MAX all values are correct just undo
17055 17058 * null termination, this saves a bcopy.
17056 17059 */
17057 17060 if (*new_ppa_ptr == UINT_MAX) {
17058 17061 bcopy(ill->ill_name, interf_name, ill->ill_name_length);
17059 17062 *new_ppa_ptr = ill->ill_ppa;
17060 17063 } else {
17061 17064 /*
17062 17065 * undo null termination done above.
17063 17066 */
17064 17067 ppa_ptr[0] = old_char;
17065 17068 }
17066 17069
17067 17070 /* Let SCTP know about this ILL */
17068 17071 sctp_update_ill(ill, SCTP_ILL_INSERT);
17069 17072
17070 17073 /*
17071 17074 * ill_glist_insert has made the ill visible globally, and
17072 17075 * ill_phyint_reinit could have changed the ipsq. At this point,
17073 17076 * we need to hold the ips_ill_g_lock across the call to enter the
17074 17077 * ipsq to enforce atomicity and prevent reordering. In the event
17075 17078 * the ipsq has changed, and if the new ipsq is currently busy,
17076 17079 * we need to make sure that this half-completed ioctl is ahead of
17077 17080 * any subsequent ioctl. We achieve this by not dropping the
17078 17081 * ips_ill_g_lock which prevents any ill lookup itself thereby
17079 17082 * ensuring that new ioctls can't start.
17080 17083 */
17081 17084 ipsq = ipsq_try_enter_internal(ill, q, mp, ip_reprocess_ioctl, NEW_OP,
17082 17085 B_TRUE);
17083 17086
17084 17087 rw_exit(&ipst->ips_ill_g_lock);
17085 17088 ill_refrele(ill);
17086 17089 if (ipsq == NULL)
17087 17090 return (EINPROGRESS);
17088 17091
17089 17092 /*
17090 17093 * If ill_phyint_reinit() changed our ipsq, then start on the new ipsq.
17091 17094 */
17092 17095 if (ipsq->ipsq_xop->ipx_current_ipif == NULL)
17093 17096 ipsq_current_start(ipsq, ipif, SIOCSLIFNAME);
17094 17097 else
17095 17098 ASSERT(ipsq->ipsq_xop->ipx_current_ipif == ipif);
17096 17099
17097 17100 error = ipif_set_values_tail(ill, ipif, mp, q);
17098 17101 ipsq_exit(ipsq);
17099 17102 if (error != 0 && error != EINPROGRESS) {
17100 17103 /*
17101 17104 * restore previous values
17102 17105 */
17103 17106 ill->ill_isv6 = B_FALSE;
17104 17107 ill_set_inputfn(ill);
17105 17108 }
17106 17109 return (error);
17107 17110 }
17108 17111
17109 17112 void
17110 17113 ipif_init(ip_stack_t *ipst)
17111 17114 {
17112 17115 int i;
17113 17116
17114 17117 for (i = 0; i < MAX_G_HEADS; i++) {
17115 17118 ipst->ips_ill_g_heads[i].ill_g_list_head =
17116 17119 (ill_if_t *)&ipst->ips_ill_g_heads[i];
17117 17120 ipst->ips_ill_g_heads[i].ill_g_list_tail =
17118 17121 (ill_if_t *)&ipst->ips_ill_g_heads[i];
17119 17122 }
17120 17123
17121 17124 avl_create(&ipst->ips_phyint_g_list->phyint_list_avl_by_index,
17122 17125 ill_phyint_compare_index,
17123 17126 sizeof (phyint_t),
17124 17127 offsetof(struct phyint, phyint_avl_by_index));
17125 17128 avl_create(&ipst->ips_phyint_g_list->phyint_list_avl_by_name,
17126 17129 ill_phyint_compare_name,
17127 17130 sizeof (phyint_t),
17128 17131 offsetof(struct phyint, phyint_avl_by_name));
17129 17132 }
17130 17133
17131 17134 /*
17132 17135 * Save enough information so that we can recreate the IRE if
17133 17136 * the interface goes down and then up.
17134 17137 */
17135 17138 void
17136 17139 ill_save_ire(ill_t *ill, ire_t *ire)
17137 17140 {
17138 17141 mblk_t *save_mp;
17139 17142
17140 17143 save_mp = allocb(sizeof (ifrt_t), BPRI_MED);
17141 17144 if (save_mp != NULL) {
17142 17145 ifrt_t *ifrt;
17143 17146
17144 17147 save_mp->b_wptr += sizeof (ifrt_t);
17145 17148 ifrt = (ifrt_t *)save_mp->b_rptr;
17146 17149 bzero(ifrt, sizeof (ifrt_t));
17147 17150 ifrt->ifrt_type = ire->ire_type;
17148 17151 if (ire->ire_ipversion == IPV4_VERSION) {
17149 17152 ASSERT(!ill->ill_isv6);
17150 17153 ifrt->ifrt_addr = ire->ire_addr;
17151 17154 ifrt->ifrt_gateway_addr = ire->ire_gateway_addr;
17152 17155 ifrt->ifrt_setsrc_addr = ire->ire_setsrc_addr;
17153 17156 ifrt->ifrt_mask = ire->ire_mask;
17154 17157 } else {
17155 17158 ASSERT(ill->ill_isv6);
17156 17159 ifrt->ifrt_v6addr = ire->ire_addr_v6;
17157 17160 /* ire_gateway_addr_v6 can change due to RTM_CHANGE */
17158 17161 mutex_enter(&ire->ire_lock);
17159 17162 ifrt->ifrt_v6gateway_addr = ire->ire_gateway_addr_v6;
17160 17163 mutex_exit(&ire->ire_lock);
17161 17164 ifrt->ifrt_v6setsrc_addr = ire->ire_setsrc_addr_v6;
17162 17165 ifrt->ifrt_v6mask = ire->ire_mask_v6;
17163 17166 }
17164 17167 ifrt->ifrt_flags = ire->ire_flags;
17165 17168 ifrt->ifrt_zoneid = ire->ire_zoneid;
17166 17169 mutex_enter(&ill->ill_saved_ire_lock);
17167 17170 save_mp->b_cont = ill->ill_saved_ire_mp;
17168 17171 ill->ill_saved_ire_mp = save_mp;
17169 17172 ill->ill_saved_ire_cnt++;
17170 17173 mutex_exit(&ill->ill_saved_ire_lock);
17171 17174 }
17172 17175 }
17173 17176
17174 17177 /*
17175 17178 * Remove one entry from ill_saved_ire_mp.
17176 17179 */
17177 17180 void
17178 17181 ill_remove_saved_ire(ill_t *ill, ire_t *ire)
17179 17182 {
17180 17183 mblk_t **mpp;
17181 17184 mblk_t *mp;
17182 17185 ifrt_t *ifrt;
17183 17186
17184 17187 /* Remove from ill_saved_ire_mp list if it is there */
17185 17188 mutex_enter(&ill->ill_saved_ire_lock);
17186 17189 for (mpp = &ill->ill_saved_ire_mp; *mpp != NULL;
17187 17190 mpp = &(*mpp)->b_cont) {
17188 17191 in6_addr_t gw_addr_v6;
17189 17192
17190 17193 /*
17191 17194 * On a given ill, the tuple of address, gateway, mask,
17192 17195 * ire_type, and zoneid is unique for each saved IRE.
17193 17196 */
17194 17197 mp = *mpp;
17195 17198 ifrt = (ifrt_t *)mp->b_rptr;
17196 17199 /* ire_gateway_addr_v6 can change - need lock */
17197 17200 mutex_enter(&ire->ire_lock);
17198 17201 gw_addr_v6 = ire->ire_gateway_addr_v6;
17199 17202 mutex_exit(&ire->ire_lock);
17200 17203
17201 17204 if (ifrt->ifrt_zoneid != ire->ire_zoneid ||
17202 17205 ifrt->ifrt_type != ire->ire_type)
17203 17206 continue;
17204 17207
17205 17208 if (ill->ill_isv6 ?
17206 17209 (IN6_ARE_ADDR_EQUAL(&ifrt->ifrt_v6addr,
17207 17210 &ire->ire_addr_v6) &&
17208 17211 IN6_ARE_ADDR_EQUAL(&ifrt->ifrt_v6gateway_addr,
17209 17212 &gw_addr_v6) &&
17210 17213 IN6_ARE_ADDR_EQUAL(&ifrt->ifrt_v6mask,
17211 17214 &ire->ire_mask_v6)) :
17212 17215 (ifrt->ifrt_addr == ire->ire_addr &&
17213 17216 ifrt->ifrt_gateway_addr == ire->ire_gateway_addr &&
17214 17217 ifrt->ifrt_mask == ire->ire_mask)) {
17215 17218 *mpp = mp->b_cont;
17216 17219 ill->ill_saved_ire_cnt--;
17217 17220 freeb(mp);
17218 17221 break;
17219 17222 }
17220 17223 }
17221 17224 mutex_exit(&ill->ill_saved_ire_lock);
17222 17225 }
17223 17226
17224 17227 /*
17225 17228 * IP multirouting broadcast routes handling
17226 17229 * Append CGTP broadcast IREs to regular ones created
17227 17230 * at ifconfig time.
17228 17231 * The usage is a route add <cgtp_bc> <nic_bc> -multirt i.e., both
17229 17232 * the destination and the gateway are broadcast addresses.
17230 17233 * The caller has verified that the destination is an IRE_BROADCAST and that
17231 17234 * RTF_MULTIRT was set. Here if the gateway is a broadcast address, then
17232 17235 * we create a MULTIRT IRE_BROADCAST.
17233 17236 * Note that the IRE_HOST created by ire_rt_add doesn't get found by anything
17234 17237 * since the IRE_BROADCAST takes precedence; ire_add_v4 does head insertion.
17235 17238 */
17236 17239 static void
17237 17240 ip_cgtp_bcast_add(ire_t *ire, ip_stack_t *ipst)
17238 17241 {
17239 17242 ire_t *ire_prim;
17240 17243
17241 17244 ASSERT(ire != NULL);
17242 17245
17243 17246 ire_prim = ire_ftable_lookup_v4(ire->ire_gateway_addr, 0, 0,
17244 17247 IRE_BROADCAST, NULL, ALL_ZONES, NULL, MATCH_IRE_TYPE, 0, ipst,
17245 17248 NULL);
17246 17249 if (ire_prim != NULL) {
17247 17250 /*
17248 17251 * We are in the special case of broadcasts for
17249 17252 * CGTP. We add an IRE_BROADCAST that holds
17250 17253 * the RTF_MULTIRT flag, the destination
17251 17254 * address and the low level
17252 17255 * info of ire_prim. In other words, CGTP
17253 17256 * broadcast is added to the redundant ipif.
17254 17257 */
17255 17258 ill_t *ill_prim;
17256 17259 ire_t *bcast_ire;
17257 17260
17258 17261 ill_prim = ire_prim->ire_ill;
17259 17262
17260 17263 ip2dbg(("ip_cgtp_filter_bcast_add: ire_prim %p, ill_prim %p\n",
17261 17264 (void *)ire_prim, (void *)ill_prim));
17262 17265
17263 17266 bcast_ire = ire_create(
17264 17267 (uchar_t *)&ire->ire_addr,
17265 17268 (uchar_t *)&ip_g_all_ones,
17266 17269 (uchar_t *)&ire->ire_gateway_addr,
17267 17270 IRE_BROADCAST,
17268 17271 ill_prim,
17269 17272 GLOBAL_ZONEID, /* CGTP is only for the global zone */
17270 17273 ire->ire_flags | RTF_KERNEL,
17271 17274 NULL,
17272 17275 ipst);
17273 17276
17274 17277 /*
17275 17278 * Here we assume that ire_add does head insertion so that
17276 17279 * the added IRE_BROADCAST comes before the existing IRE_HOST.
17277 17280 */
17278 17281 if (bcast_ire != NULL) {
17279 17282 if (ire->ire_flags & RTF_SETSRC) {
17280 17283 bcast_ire->ire_setsrc_addr =
17281 17284 ire->ire_setsrc_addr;
17282 17285 }
17283 17286 bcast_ire = ire_add(bcast_ire);
17284 17287 if (bcast_ire != NULL) {
17285 17288 ip2dbg(("ip_cgtp_filter_bcast_add: "
17286 17289 "added bcast_ire %p\n",
17287 17290 (void *)bcast_ire));
17288 17291
17289 17292 ill_save_ire(ill_prim, bcast_ire);
17290 17293 ire_refrele(bcast_ire);
17291 17294 }
17292 17295 }
17293 17296 ire_refrele(ire_prim);
17294 17297 }
17295 17298 }
17296 17299
17297 17300 /*
17298 17301 * IP multirouting broadcast routes handling
17299 17302 * Remove the broadcast ire.
17300 17303 * The usage is a route delete <cgtp_bc> <nic_bc> -multirt i.e., both
17301 17304 * the destination and the gateway are broadcast addresses.
17302 17305 * The caller has only verified that RTF_MULTIRT was set. We check
17303 17306 * that the destination is broadcast and that the gateway is a broadcast
17304 17307 * address, and if so delete the IRE added by ip_cgtp_bcast_add().
17305 17308 */
17306 17309 static void
17307 17310 ip_cgtp_bcast_delete(ire_t *ire, ip_stack_t *ipst)
17308 17311 {
17309 17312 ASSERT(ire != NULL);
17310 17313
17311 17314 if (ip_type_v4(ire->ire_addr, ipst) == IRE_BROADCAST) {
17312 17315 ire_t *ire_prim;
17313 17316
17314 17317 ire_prim = ire_ftable_lookup_v4(ire->ire_gateway_addr, 0, 0,
17315 17318 IRE_BROADCAST, NULL, ALL_ZONES, NULL, MATCH_IRE_TYPE, 0,
17316 17319 ipst, NULL);
17317 17320 if (ire_prim != NULL) {
17318 17321 ill_t *ill_prim;
17319 17322 ire_t *bcast_ire;
17320 17323
17321 17324 ill_prim = ire_prim->ire_ill;
17322 17325
17323 17326 ip2dbg(("ip_cgtp_filter_bcast_delete: "
17324 17327 "ire_prim %p, ill_prim %p\n",
17325 17328 (void *)ire_prim, (void *)ill_prim));
17326 17329
17327 17330 bcast_ire = ire_ftable_lookup_v4(ire->ire_addr, 0,
17328 17331 ire->ire_gateway_addr, IRE_BROADCAST,
17329 17332 ill_prim, ALL_ZONES, NULL,
17330 17333 MATCH_IRE_TYPE | MATCH_IRE_GW | MATCH_IRE_ILL |
17331 17334 MATCH_IRE_MASK, 0, ipst, NULL);
17332 17335
17333 17336 if (bcast_ire != NULL) {
17334 17337 ip2dbg(("ip_cgtp_filter_bcast_delete: "
17335 17338 "looked up bcast_ire %p\n",
17336 17339 (void *)bcast_ire));
17337 17340 ill_remove_saved_ire(bcast_ire->ire_ill,
17338 17341 bcast_ire);
17339 17342 ire_delete(bcast_ire);
17340 17343 ire_refrele(bcast_ire);
17341 17344 }
17342 17345 ire_refrele(ire_prim);
17343 17346 }
17344 17347 }
17345 17348 }
17346 17349
17347 17350 /*
17348 17351 * Derive an interface id from the link layer address.
17349 17352 * Knows about IEEE 802 and IEEE EUI-64 mappings.
17350 17353 */
17351 17354 static void
17352 17355 ip_ether_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17353 17356 {
17354 17357 char *addr;
17355 17358
17356 17359 /*
17357 17360 * Note that some IPv6 interfaces get plumbed over links that claim to
17358 17361 * be DL_ETHER, but don't actually have Ethernet MAC addresses (e.g.
17359 17362 * PPP links). The ETHERADDRL check here ensures that we only set the
17360 17363 * interface ID on IPv6 interfaces above links that actually have real
17361 17364 * Ethernet addresses.
17362 17365 */
17363 17366 if (ill->ill_phys_addr_length == ETHERADDRL) {
17364 17367 /* Form EUI-64 like address */
17365 17368 addr = (char *)&v6addr->s6_addr32[2];
17366 17369 bcopy(ill->ill_phys_addr, addr, 3);
17367 17370 addr[0] ^= 0x2; /* Toggle Universal/Local bit */
17368 17371 addr[3] = (char)0xff;
17369 17372 addr[4] = (char)0xfe;
17370 17373 bcopy(ill->ill_phys_addr + 3, addr + 5, 3);
17371 17374 }
17372 17375 }
17373 17376
17374 17377 /* ARGSUSED */
17375 17378 static void
17376 17379 ip_nodef_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17377 17380 {
17378 17381 }
17379 17382
17380 17383 typedef struct ipmp_ifcookie {
17381 17384 uint32_t ic_hostid;
17382 17385 char ic_ifname[LIFNAMSIZ];
17383 17386 char ic_zonename[ZONENAME_MAX];
17384 17387 } ipmp_ifcookie_t;
17385 17388
17386 17389 /*
17387 17390 * Construct a pseudo-random interface ID for the IPMP interface that's both
17388 17391 * predictable and (almost) guaranteed to be unique.
17389 17392 */
17390 17393 static void
17391 17394 ip_ipmp_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17392 17395 {
17393 17396 zone_t *zp;
17394 17397 uint8_t *addr;
17395 17398 uchar_t hash[16];
17396 17399 ulong_t hostid;
17397 17400 MD5_CTX ctx;
17398 17401 ipmp_ifcookie_t ic = { 0 };
17399 17402
17400 17403 ASSERT(IS_IPMP(ill));
17401 17404
17402 17405 (void) ddi_strtoul(hw_serial, NULL, 10, &hostid);
17403 17406 ic.ic_hostid = htonl((uint32_t)hostid);
17404 17407
17405 17408 (void) strlcpy(ic.ic_ifname, ill->ill_name, LIFNAMSIZ);
17406 17409
17407 17410 if ((zp = zone_find_by_id(ill->ill_zoneid)) != NULL) {
17408 17411 (void) strlcpy(ic.ic_zonename, zp->zone_name, ZONENAME_MAX);
17409 17412 zone_rele(zp);
17410 17413 }
17411 17414
17412 17415 MD5Init(&ctx);
17413 17416 MD5Update(&ctx, &ic, sizeof (ic));
17414 17417 MD5Final(hash, &ctx);
17415 17418
17416 17419 /*
17417 17420 * Map the hash to an interface ID per the basic approach in RFC3041.
17418 17421 */
17419 17422 addr = &v6addr->s6_addr8[8];
17420 17423 bcopy(hash + 8, addr, sizeof (uint64_t));
17421 17424 addr[0] &= ~0x2; /* set local bit */
17422 17425 }
17423 17426
17424 17427 /*
17425 17428 * Map the multicast in6_addr_t in m_ip6addr to the physaddr for ethernet.
17426 17429 */
17427 17430 static void
17428 17431 ip_ether_v6_mapping(ill_t *ill, uchar_t *m_ip6addr, uchar_t *m_physaddr)
17429 17432 {
17430 17433 phyint_t *phyi = ill->ill_phyint;
17431 17434
17432 17435 /*
17433 17436 * Check PHYI_MULTI_BCAST and length of physical
17434 17437 * address to determine if we use the mapping or the
17435 17438 * broadcast address.
17436 17439 */
17437 17440 if ((phyi->phyint_flags & PHYI_MULTI_BCAST) != 0 ||
17438 17441 ill->ill_phys_addr_length != ETHERADDRL) {
17439 17442 ip_mbcast_mapping(ill, m_ip6addr, m_physaddr);
17440 17443 return;
17441 17444 }
17442 17445 m_physaddr[0] = 0x33;
17443 17446 m_physaddr[1] = 0x33;
17444 17447 m_physaddr[2] = m_ip6addr[12];
17445 17448 m_physaddr[3] = m_ip6addr[13];
17446 17449 m_physaddr[4] = m_ip6addr[14];
17447 17450 m_physaddr[5] = m_ip6addr[15];
17448 17451 }
17449 17452
17450 17453 /*
17451 17454 * Map the multicast ipaddr_t in m_ipaddr to the physaddr for ethernet.
17452 17455 */
17453 17456 static void
17454 17457 ip_ether_v4_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17455 17458 {
17456 17459 phyint_t *phyi = ill->ill_phyint;
17457 17460
17458 17461 /*
17459 17462 * Check PHYI_MULTI_BCAST and length of physical
17460 17463 * address to determine if we use the mapping or the
17461 17464 * broadcast address.
17462 17465 */
17463 17466 if ((phyi->phyint_flags & PHYI_MULTI_BCAST) != 0 ||
17464 17467 ill->ill_phys_addr_length != ETHERADDRL) {
17465 17468 ip_mbcast_mapping(ill, m_ipaddr, m_physaddr);
17466 17469 return;
17467 17470 }
17468 17471 m_physaddr[0] = 0x01;
17469 17472 m_physaddr[1] = 0x00;
17470 17473 m_physaddr[2] = 0x5e;
17471 17474 m_physaddr[3] = m_ipaddr[1] & 0x7f;
17472 17475 m_physaddr[4] = m_ipaddr[2];
17473 17476 m_physaddr[5] = m_ipaddr[3];
17474 17477 }
17475 17478
17476 17479 /* ARGSUSED */
17477 17480 static void
17478 17481 ip_mbcast_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17479 17482 {
17480 17483 /*
17481 17484 * for the MULTI_BCAST case and other cases when we want to
17482 17485 * use the link-layer broadcast address for multicast.
17483 17486 */
17484 17487 uint8_t *bphys_addr;
17485 17488 dl_unitdata_req_t *dlur;
17486 17489
17487 17490 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17488 17491 if (ill->ill_sap_length < 0) {
17489 17492 bphys_addr = (uchar_t *)dlur +
17490 17493 dlur->dl_dest_addr_offset;
17491 17494 } else {
17492 17495 bphys_addr = (uchar_t *)dlur +
17493 17496 dlur->dl_dest_addr_offset + ill->ill_sap_length;
17494 17497 }
17495 17498
17496 17499 bcopy(bphys_addr, m_physaddr, ill->ill_phys_addr_length);
17497 17500 }
17498 17501
17499 17502 /*
17500 17503 * Derive IPoIB interface id from the link layer address.
17501 17504 */
17502 17505 static void
17503 17506 ip_ib_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17504 17507 {
17505 17508 char *addr;
17506 17509
17507 17510 ASSERT(ill->ill_phys_addr_length == 20);
17508 17511 addr = (char *)&v6addr->s6_addr32[2];
17509 17512 bcopy(ill->ill_phys_addr + 12, addr, 8);
17510 17513 /*
17511 17514 * In IBA 1.1 timeframe, some vendors erroneously set the u/l bit
17512 17515 * in the globally assigned EUI-64 GUID to 1, in violation of IEEE
17513 17516 * rules. In these cases, the IBA considers these GUIDs to be in
17514 17517 * "Modified EUI-64" format, and thus toggling the u/l bit is not
17515 17518 * required; vendors are required not to assign global EUI-64's
17516 17519 * that differ only in u/l bit values, thus guaranteeing uniqueness
17517 17520 * of the interface identifier. Whether the GUID is in modified
17518 17521 * or proper EUI-64 format, the ipv6 identifier must have the u/l
17519 17522 * bit set to 1.
17520 17523 */
17521 17524 addr[0] |= 2; /* Set Universal/Local bit to 1 */
17522 17525 }
17523 17526
17524 17527 /*
17525 17528 * Map the multicast ipaddr_t in m_ipaddr to the physaddr for InfiniBand.
17526 17529 * Note on mapping from multicast IP addresses to IPoIB multicast link
17527 17530 * addresses. IPoIB multicast link addresses are based on IBA link addresses.
17528 17531 * The format of an IPoIB multicast address is:
17529 17532 *
17530 17533 * 4 byte QPN Scope Sign. Pkey
17531 17534 * +--------------------------------------------+
17532 17535 * | 00FFFFFF | FF | 1X | X01B | Pkey | GroupID |
17533 17536 * +--------------------------------------------+
17534 17537 *
17535 17538 * The Scope and Pkey components are properties of the IBA port and
17536 17539 * network interface. They can be ascertained from the broadcast address.
17537 17540 * The Sign. part is the signature, and is 401B for IPv4 and 601B for IPv6.
17538 17541 */
17539 17542 static void
17540 17543 ip_ib_v4_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17541 17544 {
17542 17545 static uint8_t ipv4_g_phys_ibmulti_addr[] = { 0x00, 0xff, 0xff, 0xff,
17543 17546 0xff, 0x10, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00,
17544 17547 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
17545 17548 uint8_t *bphys_addr;
17546 17549 dl_unitdata_req_t *dlur;
17547 17550
17548 17551 bcopy(ipv4_g_phys_ibmulti_addr, m_physaddr, ill->ill_phys_addr_length);
17549 17552
17550 17553 /*
17551 17554 * RFC 4391: IPv4 MGID is 28-bit long.
17552 17555 */
17553 17556 m_physaddr[16] = m_ipaddr[0] & 0x0f;
17554 17557 m_physaddr[17] = m_ipaddr[1];
17555 17558 m_physaddr[18] = m_ipaddr[2];
17556 17559 m_physaddr[19] = m_ipaddr[3];
17557 17560
17558 17561
17559 17562 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17560 17563 if (ill->ill_sap_length < 0) {
17561 17564 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset;
17562 17565 } else {
17563 17566 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset +
17564 17567 ill->ill_sap_length;
17565 17568 }
17566 17569 /*
17567 17570 * Now fill in the IBA scope/Pkey values from the broadcast address.
17568 17571 */
17569 17572 m_physaddr[5] = bphys_addr[5];
17570 17573 m_physaddr[8] = bphys_addr[8];
17571 17574 m_physaddr[9] = bphys_addr[9];
17572 17575 }
17573 17576
17574 17577 static void
17575 17578 ip_ib_v6_mapping(ill_t *ill, uchar_t *m_ipaddr, uchar_t *m_physaddr)
17576 17579 {
17577 17580 static uint8_t ipv4_g_phys_ibmulti_addr[] = { 0x00, 0xff, 0xff, 0xff,
17578 17581 0xff, 0x10, 0x60, 0x1b, 0x00, 0x00, 0x00, 0x00,
17579 17582 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
17580 17583 uint8_t *bphys_addr;
17581 17584 dl_unitdata_req_t *dlur;
17582 17585
17583 17586 bcopy(ipv4_g_phys_ibmulti_addr, m_physaddr, ill->ill_phys_addr_length);
17584 17587
17585 17588 /*
17586 17589 * RFC 4391: IPv4 MGID is 80-bit long.
17587 17590 */
17588 17591 bcopy(&m_ipaddr[6], &m_physaddr[10], 10);
17589 17592
17590 17593 dlur = (dl_unitdata_req_t *)ill->ill_bcast_mp->b_rptr;
17591 17594 if (ill->ill_sap_length < 0) {
17592 17595 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset;
17593 17596 } else {
17594 17597 bphys_addr = (uchar_t *)dlur + dlur->dl_dest_addr_offset +
17595 17598 ill->ill_sap_length;
17596 17599 }
17597 17600 /*
17598 17601 * Now fill in the IBA scope/Pkey values from the broadcast address.
17599 17602 */
17600 17603 m_physaddr[5] = bphys_addr[5];
17601 17604 m_physaddr[8] = bphys_addr[8];
17602 17605 m_physaddr[9] = bphys_addr[9];
17603 17606 }
17604 17607
17605 17608 /*
17606 17609 * Derive IPv6 interface id from an IPv4 link-layer address (e.g. from an IPv4
17607 17610 * tunnel). The IPv4 address simply get placed in the lower 4 bytes of the
17608 17611 * IPv6 interface id. This is a suggested mechanism described in section 3.7
17609 17612 * of RFC4213.
17610 17613 */
17611 17614 static void
17612 17615 ip_ipv4_genv6intfid(ill_t *ill, uint8_t *physaddr, in6_addr_t *v6addr)
17613 17616 {
17614 17617 ASSERT(ill->ill_phys_addr_length == sizeof (ipaddr_t));
17615 17618 v6addr->s6_addr32[2] = 0;
17616 17619 bcopy(physaddr, &v6addr->s6_addr32[3], sizeof (ipaddr_t));
17617 17620 }
17618 17621
17619 17622 /*
17620 17623 * Derive IPv6 interface id from an IPv6 link-layer address (e.g. from an IPv6
17621 17624 * tunnel). The lower 8 bytes of the IPv6 address simply become the interface
17622 17625 * id.
17623 17626 */
17624 17627 static void
17625 17628 ip_ipv6_genv6intfid(ill_t *ill, uint8_t *physaddr, in6_addr_t *v6addr)
17626 17629 {
17627 17630 in6_addr_t *v6lladdr = (in6_addr_t *)physaddr;
17628 17631
17629 17632 ASSERT(ill->ill_phys_addr_length == sizeof (in6_addr_t));
17630 17633 bcopy(&v6lladdr->s6_addr32[2], &v6addr->s6_addr32[2], 8);
17631 17634 }
17632 17635
17633 17636 static void
17634 17637 ip_ipv6_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17635 17638 {
17636 17639 ip_ipv6_genv6intfid(ill, ill->ill_phys_addr, v6addr);
17637 17640 }
17638 17641
17639 17642 static void
17640 17643 ip_ipv6_v6destintfid(ill_t *ill, in6_addr_t *v6addr)
17641 17644 {
17642 17645 ip_ipv6_genv6intfid(ill, ill->ill_dest_addr, v6addr);
17643 17646 }
17644 17647
17645 17648 static void
17646 17649 ip_ipv4_v6intfid(ill_t *ill, in6_addr_t *v6addr)
17647 17650 {
17648 17651 ip_ipv4_genv6intfid(ill, ill->ill_phys_addr, v6addr);
17649 17652 }
17650 17653
17651 17654 static void
17652 17655 ip_ipv4_v6destintfid(ill_t *ill, in6_addr_t *v6addr)
17653 17656 {
17654 17657 ip_ipv4_genv6intfid(ill, ill->ill_dest_addr, v6addr);
17655 17658 }
17656 17659
17657 17660 /*
17658 17661 * Lookup an ill and verify that the zoneid has an ipif on that ill.
17659 17662 * Returns an held ill, or NULL.
17660 17663 */
17661 17664 ill_t *
17662 17665 ill_lookup_on_ifindex_zoneid(uint_t index, zoneid_t zoneid, boolean_t isv6,
17663 17666 ip_stack_t *ipst)
17664 17667 {
17665 17668 ill_t *ill;
17666 17669 ipif_t *ipif;
17667 17670
17668 17671 ill = ill_lookup_on_ifindex(index, isv6, ipst);
17669 17672 if (ill == NULL)
17670 17673 return (NULL);
17671 17674
17672 17675 mutex_enter(&ill->ill_lock);
17673 17676 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17674 17677 if (IPIF_IS_CONDEMNED(ipif))
17675 17678 continue;
17676 17679 if (zoneid != ALL_ZONES && ipif->ipif_zoneid != zoneid &&
17677 17680 ipif->ipif_zoneid != ALL_ZONES)
17678 17681 continue;
17679 17682
17680 17683 mutex_exit(&ill->ill_lock);
17681 17684 return (ill);
17682 17685 }
17683 17686 mutex_exit(&ill->ill_lock);
17684 17687 ill_refrele(ill);
17685 17688 return (NULL);
17686 17689 }
17687 17690
17688 17691 /*
17689 17692 * Return a pointer to an ipif_t given a combination of (ill_idx,ipif_id)
17690 17693 * If a pointer to an ipif_t is returned then the caller will need to do
17691 17694 * an ill_refrele().
17692 17695 */
17693 17696 ipif_t *
17694 17697 ipif_getby_indexes(uint_t ifindex, uint_t lifidx, boolean_t isv6,
17695 17698 ip_stack_t *ipst)
17696 17699 {
17697 17700 ipif_t *ipif;
17698 17701 ill_t *ill;
17699 17702
17700 17703 ill = ill_lookup_on_ifindex(ifindex, isv6, ipst);
17701 17704 if (ill == NULL)
17702 17705 return (NULL);
17703 17706
17704 17707 mutex_enter(&ill->ill_lock);
17705 17708 if (ill->ill_state_flags & ILL_CONDEMNED) {
17706 17709 mutex_exit(&ill->ill_lock);
17707 17710 ill_refrele(ill);
17708 17711 return (NULL);
17709 17712 }
17710 17713
17711 17714 for (ipif = ill->ill_ipif; ipif != NULL; ipif = ipif->ipif_next) {
17712 17715 if (!IPIF_CAN_LOOKUP(ipif))
17713 17716 continue;
17714 17717 if (lifidx == ipif->ipif_id) {
17715 17718 ipif_refhold_locked(ipif);
17716 17719 break;
17717 17720 }
17718 17721 }
17719 17722
17720 17723 mutex_exit(&ill->ill_lock);
17721 17724 ill_refrele(ill);
17722 17725 return (ipif);
17723 17726 }
17724 17727
17725 17728 /*
17726 17729 * Set ill_inputfn based on the current know state.
17727 17730 * This needs to be called when any of the factors taken into
17728 17731 * account changes.
17729 17732 */
17730 17733 void
17731 17734 ill_set_inputfn(ill_t *ill)
17732 17735 {
17733 17736 ip_stack_t *ipst = ill->ill_ipst;
17734 17737
17735 17738 if (ill->ill_isv6) {
17736 17739 if (is_system_labeled())
17737 17740 ill->ill_inputfn = ill_input_full_v6;
17738 17741 else
17739 17742 ill->ill_inputfn = ill_input_short_v6;
17740 17743 } else {
17741 17744 if (is_system_labeled())
17742 17745 ill->ill_inputfn = ill_input_full_v4;
17743 17746 else if (ill->ill_dhcpinit != 0)
17744 17747 ill->ill_inputfn = ill_input_full_v4;
17745 17748 else if (ipst->ips_ipcl_proto_fanout_v4[IPPROTO_RSVP].connf_head
17746 17749 != NULL)
17747 17750 ill->ill_inputfn = ill_input_full_v4;
17748 17751 else if (ipst->ips_ip_cgtp_filter &&
17749 17752 ipst->ips_ip_cgtp_filter_ops != NULL)
17750 17753 ill->ill_inputfn = ill_input_full_v4;
17751 17754 else
17752 17755 ill->ill_inputfn = ill_input_short_v4;
17753 17756 }
17754 17757 }
17755 17758
17756 17759 /*
17757 17760 * Re-evaluate ill_inputfn for all the IPv4 ills.
17758 17761 * Used when RSVP and CGTP comes and goes.
17759 17762 */
17760 17763 void
17761 17764 ill_set_inputfn_all(ip_stack_t *ipst)
17762 17765 {
17763 17766 ill_walk_context_t ctx;
17764 17767 ill_t *ill;
17765 17768
17766 17769 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
17767 17770 ill = ILL_START_WALK_V4(&ctx, ipst);
17768 17771 for (; ill != NULL; ill = ill_next(&ctx, ill))
17769 17772 ill_set_inputfn(ill);
17770 17773
17771 17774 rw_exit(&ipst->ips_ill_g_lock);
17772 17775 }
17773 17776
17774 17777 /*
17775 17778 * Set the physical address information for `ill' to the contents of the
17776 17779 * dl_notify_ind_t pointed to by `mp'. Must be called as writer, and will be
17777 17780 * asynchronous if `ill' cannot immediately be quiesced -- in which case
17778 17781 * EINPROGRESS will be returned.
17779 17782 */
17780 17783 int
17781 17784 ill_set_phys_addr(ill_t *ill, mblk_t *mp)
17782 17785 {
17783 17786 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17784 17787 dl_notify_ind_t *dlindp = (dl_notify_ind_t *)mp->b_rptr;
17785 17788
17786 17789 ASSERT(IAM_WRITER_IPSQ(ipsq));
17787 17790
17788 17791 if (dlindp->dl_data != DL_IPV6_LINK_LAYER_ADDR &&
17789 17792 dlindp->dl_data != DL_CURR_DEST_ADDR &&
17790 17793 dlindp->dl_data != DL_CURR_PHYS_ADDR) {
17791 17794 /* Changing DL_IPV6_TOKEN is not yet supported */
17792 17795 return (0);
17793 17796 }
17794 17797
17795 17798 /*
17796 17799 * We need to store up to two copies of `mp' in `ill'. Due to the
17797 17800 * design of ipsq_pending_mp_add(), we can't pass them as separate
17798 17801 * arguments to ill_set_phys_addr_tail(). Instead, chain them
17799 17802 * together here, then pull 'em apart in ill_set_phys_addr_tail().
17800 17803 */
17801 17804 if ((mp = copyb(mp)) == NULL || (mp->b_cont = copyb(mp)) == NULL) {
17802 17805 freemsg(mp);
17803 17806 return (ENOMEM);
17804 17807 }
17805 17808
17806 17809 ipsq_current_start(ipsq, ill->ill_ipif, 0);
17807 17810
17808 17811 /*
17809 17812 * Since we'll only do a logical down, we can't rely on ipif_down
17810 17813 * to turn on ILL_DOWN_IN_PROGRESS, or for the DL_BIND_ACK to reset
17811 17814 * ILL_DOWN_IN_PROGRESS. We instead manage this separately for this
17812 17815 * case, to quiesce ire's and nce's for ill_is_quiescent.
17813 17816 */
17814 17817 mutex_enter(&ill->ill_lock);
17815 17818 ill->ill_state_flags |= ILL_DOWN_IN_PROGRESS;
17816 17819 /* no more ire/nce addition allowed */
17817 17820 mutex_exit(&ill->ill_lock);
17818 17821
17819 17822 /*
17820 17823 * If we can quiesce the ill, then set the address. If not, then
17821 17824 * ill_set_phys_addr_tail() will be called from ipif_ill_refrele_tail().
17822 17825 */
17823 17826 ill_down_ipifs(ill, B_TRUE);
17824 17827 mutex_enter(&ill->ill_lock);
17825 17828 if (!ill_is_quiescent(ill)) {
17826 17829 /* call cannot fail since `conn_t *' argument is NULL */
17827 17830 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
17828 17831 mp, ILL_DOWN);
17829 17832 mutex_exit(&ill->ill_lock);
17830 17833 return (EINPROGRESS);
17831 17834 }
17832 17835 mutex_exit(&ill->ill_lock);
17833 17836
17834 17837 ill_set_phys_addr_tail(ipsq, ill->ill_rq, mp, NULL);
17835 17838 return (0);
17836 17839 }
17837 17840
17838 17841 /*
17839 17842 * When the allowed-ips link property is set on the datalink, IP receives a
17840 17843 * DL_NOTE_ALLOWED_IPS notification that is processed in ill_set_allowed_ips()
17841 17844 * to initialize the ill_allowed_ips[] array in the ill_t. This array is then
17842 17845 * used to vet addresses passed to ip_sioctl_addr() and to ensure that the
17843 17846 * only IP addresses configured on the ill_t are those in the ill_allowed_ips[]
17844 17847 * array.
17845 17848 */
17846 17849 void
17847 17850 ill_set_allowed_ips(ill_t *ill, mblk_t *mp)
17848 17851 {
17849 17852 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17850 17853 dl_notify_ind_t *dlip = (dl_notify_ind_t *)mp->b_rptr;
17851 17854 mac_protect_t *mrp;
17852 17855 int i;
17853 17856
17854 17857 ASSERT(IAM_WRITER_IPSQ(ipsq));
17855 17858 mrp = (mac_protect_t *)&dlip[1];
17856 17859
17857 17860 if (mrp->mp_ipaddrcnt == 0) { /* reset allowed-ips */
17858 17861 kmem_free(ill->ill_allowed_ips,
17859 17862 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
17860 17863 ill->ill_allowed_ips_cnt = 0;
17861 17864 ill->ill_allowed_ips = NULL;
17862 17865 mutex_enter(&ill->ill_phyint->phyint_lock);
17863 17866 ill->ill_phyint->phyint_flags &= ~PHYI_L3PROTECT;
17864 17867 mutex_exit(&ill->ill_phyint->phyint_lock);
17865 17868 return;
17866 17869 }
17867 17870
17868 17871 if (ill->ill_allowed_ips != NULL) {
17869 17872 kmem_free(ill->ill_allowed_ips,
17870 17873 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t));
17871 17874 }
17872 17875 ill->ill_allowed_ips_cnt = mrp->mp_ipaddrcnt;
17873 17876 ill->ill_allowed_ips = kmem_alloc(
17874 17877 ill->ill_allowed_ips_cnt * sizeof (in6_addr_t), KM_SLEEP);
17875 17878 for (i = 0; i < mrp->mp_ipaddrcnt; i++)
17876 17879 ill->ill_allowed_ips[i] = mrp->mp_ipaddrs[i].ip_addr;
17877 17880
17878 17881 mutex_enter(&ill->ill_phyint->phyint_lock);
17879 17882 ill->ill_phyint->phyint_flags |= PHYI_L3PROTECT;
17880 17883 mutex_exit(&ill->ill_phyint->phyint_lock);
17881 17884 }
17882 17885
17883 17886 /*
17884 17887 * Once the ill associated with `q' has quiesced, set its physical address
17885 17888 * information to the values in `addrmp'. Note that two copies of `addrmp'
17886 17889 * are passed (linked by b_cont), since we sometimes need to save two distinct
17887 17890 * copies in the ill_t, and our context doesn't permit sleeping or allocation
17888 17891 * failure (we'll free the other copy if it's not needed). Since the ill_t
17889 17892 * is quiesced, we know any stale nce's with the old address information have
17890 17893 * already been removed, so we don't need to call nce_flush().
17891 17894 */
17892 17895 /* ARGSUSED */
17893 17896 static void
17894 17897 ill_set_phys_addr_tail(ipsq_t *ipsq, queue_t *q, mblk_t *addrmp, void *dummy)
17895 17898 {
17896 17899 ill_t *ill = q->q_ptr;
17897 17900 mblk_t *addrmp2 = unlinkb(addrmp);
17898 17901 dl_notify_ind_t *dlindp = (dl_notify_ind_t *)addrmp->b_rptr;
17899 17902 uint_t addrlen, addroff;
17900 17903 int status;
17901 17904
17902 17905 ASSERT(IAM_WRITER_IPSQ(ipsq));
17903 17906
17904 17907 addroff = dlindp->dl_addr_offset;
17905 17908 addrlen = dlindp->dl_addr_length - ABS(ill->ill_sap_length);
17906 17909
17907 17910 switch (dlindp->dl_data) {
17908 17911 case DL_IPV6_LINK_LAYER_ADDR:
17909 17912 ill_set_ndmp(ill, addrmp, addroff, addrlen);
17910 17913 freemsg(addrmp2);
17911 17914 break;
17912 17915
17913 17916 case DL_CURR_DEST_ADDR:
17914 17917 freemsg(ill->ill_dest_addr_mp);
17915 17918 ill->ill_dest_addr = addrmp->b_rptr + addroff;
17916 17919 ill->ill_dest_addr_mp = addrmp;
17917 17920 if (ill->ill_isv6) {
17918 17921 ill_setdesttoken(ill);
17919 17922 ipif_setdestlinklocal(ill->ill_ipif);
17920 17923 }
17921 17924 freemsg(addrmp2);
17922 17925 break;
17923 17926
17924 17927 case DL_CURR_PHYS_ADDR:
17925 17928 freemsg(ill->ill_phys_addr_mp);
17926 17929 ill->ill_phys_addr = addrmp->b_rptr + addroff;
17927 17930 ill->ill_phys_addr_mp = addrmp;
17928 17931 ill->ill_phys_addr_length = addrlen;
17929 17932 if (ill->ill_isv6)
17930 17933 ill_set_ndmp(ill, addrmp2, addroff, addrlen);
17931 17934 else
17932 17935 freemsg(addrmp2);
17933 17936 if (ill->ill_isv6) {
17934 17937 ill_setdefaulttoken(ill);
17935 17938 ipif_setlinklocal(ill->ill_ipif);
17936 17939 }
17937 17940 break;
17938 17941 default:
17939 17942 ASSERT(0);
17940 17943 }
17941 17944
17942 17945 /*
17943 17946 * reset ILL_DOWN_IN_PROGRESS so that we can successfully add ires
17944 17947 * as we bring the ipifs up again.
17945 17948 */
17946 17949 mutex_enter(&ill->ill_lock);
17947 17950 ill->ill_state_flags &= ~ILL_DOWN_IN_PROGRESS;
17948 17951 mutex_exit(&ill->ill_lock);
17949 17952 /*
17950 17953 * If there are ipifs to bring up, ill_up_ipifs() will return
17951 17954 * EINPROGRESS, and ipsq_current_finish() will be called by
17952 17955 * ip_rput_dlpi_writer() or arp_bringup_done() when the last ipif is
17953 17956 * brought up.
17954 17957 */
17955 17958 status = ill_up_ipifs(ill, q, addrmp);
17956 17959 if (status != EINPROGRESS)
17957 17960 ipsq_current_finish(ipsq);
17958 17961 }
17959 17962
17960 17963 /*
17961 17964 * Helper routine for setting the ill_nd_lla fields.
17962 17965 */
17963 17966 void
17964 17967 ill_set_ndmp(ill_t *ill, mblk_t *ndmp, uint_t addroff, uint_t addrlen)
17965 17968 {
17966 17969 freemsg(ill->ill_nd_lla_mp);
17967 17970 ill->ill_nd_lla = ndmp->b_rptr + addroff;
17968 17971 ill->ill_nd_lla_mp = ndmp;
17969 17972 ill->ill_nd_lla_len = addrlen;
17970 17973 }
17971 17974
17972 17975 /*
17973 17976 * Replumb the ill.
17974 17977 */
17975 17978 int
17976 17979 ill_replumb(ill_t *ill, mblk_t *mp)
17977 17980 {
17978 17981 ipsq_t *ipsq = ill->ill_phyint->phyint_ipsq;
17979 17982
17980 17983 ASSERT(IAM_WRITER_IPSQ(ipsq));
17981 17984
17982 17985 ipsq_current_start(ipsq, ill->ill_ipif, 0);
17983 17986
17984 17987 /*
17985 17988 * If we can quiesce the ill, then continue. If not, then
17986 17989 * ill_replumb_tail() will be called from ipif_ill_refrele_tail().
17987 17990 */
17988 17991 ill_down_ipifs(ill, B_FALSE);
17989 17992
17990 17993 mutex_enter(&ill->ill_lock);
17991 17994 if (!ill_is_quiescent(ill)) {
17992 17995 /* call cannot fail since `conn_t *' argument is NULL */
17993 17996 (void) ipsq_pending_mp_add(NULL, ill->ill_ipif, ill->ill_rq,
17994 17997 mp, ILL_DOWN);
17995 17998 mutex_exit(&ill->ill_lock);
17996 17999 return (EINPROGRESS);
17997 18000 }
17998 18001 mutex_exit(&ill->ill_lock);
17999 18002
18000 18003 ill_replumb_tail(ipsq, ill->ill_rq, mp, NULL);
18001 18004 return (0);
18002 18005 }
18003 18006
18004 18007 /* ARGSUSED */
18005 18008 static void
18006 18009 ill_replumb_tail(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy)
18007 18010 {
18008 18011 ill_t *ill = q->q_ptr;
18009 18012 int err;
18010 18013 conn_t *connp = NULL;
18011 18014
18012 18015 ASSERT(IAM_WRITER_IPSQ(ipsq));
18013 18016 freemsg(ill->ill_replumb_mp);
18014 18017 ill->ill_replumb_mp = copyb(mp);
18015 18018
18016 18019 if (ill->ill_replumb_mp == NULL) {
18017 18020 /* out of memory */
18018 18021 ipsq_current_finish(ipsq);
18019 18022 return;
18020 18023 }
18021 18024
18022 18025 mutex_enter(&ill->ill_lock);
18023 18026 ill->ill_up_ipifs = ipsq_pending_mp_add(NULL, ill->ill_ipif,
18024 18027 ill->ill_rq, ill->ill_replumb_mp, 0);
18025 18028 mutex_exit(&ill->ill_lock);
18026 18029
18027 18030 if (!ill->ill_up_ipifs) {
18028 18031 /* already closing */
18029 18032 ipsq_current_finish(ipsq);
18030 18033 return;
18031 18034 }
18032 18035 ill->ill_replumbing = 1;
18033 18036 err = ill_down_ipifs_tail(ill);
18034 18037
18035 18038 /*
18036 18039 * Successfully quiesced and brought down the interface, now we send
18037 18040 * the DL_NOTE_REPLUMB_DONE message down to the driver. Reuse the
18038 18041 * DL_NOTE_REPLUMB message.
18039 18042 */
18040 18043 mp = mexchange(NULL, mp, sizeof (dl_notify_conf_t), M_PROTO,
18041 18044 DL_NOTIFY_CONF);
18042 18045 ASSERT(mp != NULL);
18043 18046 ((dl_notify_conf_t *)mp->b_rptr)->dl_notification =
18044 18047 DL_NOTE_REPLUMB_DONE;
18045 18048 ill_dlpi_send(ill, mp);
18046 18049
18047 18050 /*
18048 18051 * For IPv4, we would usually get EINPROGRESS because the ETHERTYPE_ARP
18049 18052 * streams have to be unbound. When all the DLPI exchanges are done,
18050 18053 * ipsq_current_finish() will be called by arp_bringup_done(). The
18051 18054 * remainder of ipif bringup via ill_up_ipifs() will also be done in
18052 18055 * arp_bringup_done().
18053 18056 */
18054 18057 ASSERT(ill->ill_replumb_mp != NULL);
18055 18058 if (err == EINPROGRESS)
18056 18059 return;
18057 18060 else
18058 18061 ill->ill_replumb_mp = ipsq_pending_mp_get(ipsq, &connp);
18059 18062 ASSERT(connp == NULL);
18060 18063 if (err == 0 && ill->ill_replumb_mp != NULL &&
18061 18064 ill_up_ipifs(ill, q, ill->ill_replumb_mp) == EINPROGRESS) {
18062 18065 return;
18063 18066 }
18064 18067 ipsq_current_finish(ipsq);
18065 18068 }
18066 18069
18067 18070 /*
18068 18071 * Issue ioctl `cmd' on `lh'; caller provides the initial payload in `buf'
18069 18072 * which is `bufsize' bytes. On success, zero is returned and `buf' updated
18070 18073 * as per the ioctl. On failure, an errno is returned.
18071 18074 */
18072 18075 static int
18073 18076 ip_ioctl(ldi_handle_t lh, int cmd, void *buf, uint_t bufsize, cred_t *cr)
18074 18077 {
18075 18078 int rval;
18076 18079 struct strioctl iocb;
18077 18080
18078 18081 iocb.ic_cmd = cmd;
18079 18082 iocb.ic_timout = 15;
18080 18083 iocb.ic_len = bufsize;
18081 18084 iocb.ic_dp = buf;
18082 18085
18083 18086 return (ldi_ioctl(lh, I_STR, (intptr_t)&iocb, FKIOCTL, cr, &rval));
18084 18087 }
18085 18088
18086 18089 /*
18087 18090 * Issue an SIOCGLIFCONF for address family `af' and store the result into a
18088 18091 * dynamically-allocated `lifcp' that will be `bufsizep' bytes on success.
18089 18092 */
18090 18093 static int
18091 18094 ip_lifconf_ioctl(ldi_handle_t lh, int af, struct lifconf *lifcp,
18092 18095 uint_t *bufsizep, cred_t *cr)
18093 18096 {
18094 18097 int err;
18095 18098 struct lifnum lifn;
18096 18099
18097 18100 bzero(&lifn, sizeof (lifn));
18098 18101 lifn.lifn_family = af;
18099 18102 lifn.lifn_flags = LIFC_UNDER_IPMP;
18100 18103
18101 18104 if ((err = ip_ioctl(lh, SIOCGLIFNUM, &lifn, sizeof (lifn), cr)) != 0)
18102 18105 return (err);
18103 18106
18104 18107 /*
18105 18108 * Pad the interface count to account for additional interfaces that
18106 18109 * may have been configured between the SIOCGLIFNUM and SIOCGLIFCONF.
18107 18110 */
18108 18111 lifn.lifn_count += 4;
18109 18112 bzero(lifcp, sizeof (*lifcp));
18110 18113 lifcp->lifc_flags = LIFC_UNDER_IPMP;
18111 18114 lifcp->lifc_family = af;
18112 18115 lifcp->lifc_len = *bufsizep = lifn.lifn_count * sizeof (struct lifreq);
18113 18116 lifcp->lifc_buf = kmem_zalloc(*bufsizep, KM_SLEEP);
18114 18117
18115 18118 err = ip_ioctl(lh, SIOCGLIFCONF, lifcp, sizeof (*lifcp), cr);
18116 18119 if (err != 0) {
18117 18120 kmem_free(lifcp->lifc_buf, *bufsizep);
18118 18121 return (err);
18119 18122 }
18120 18123
18121 18124 return (0);
18122 18125 }
18123 18126
18124 18127 /*
18125 18128 * Helper for ip_interface_cleanup() that removes the loopback interface.
18126 18129 */
18127 18130 static void
18128 18131 ip_loopback_removeif(ldi_handle_t lh, boolean_t isv6, cred_t *cr)
18129 18132 {
18130 18133 int err;
18131 18134 struct lifreq lifr;
18132 18135
18133 18136 bzero(&lifr, sizeof (lifr));
18134 18137 (void) strcpy(lifr.lifr_name, ipif_loopback_name);
18135 18138
18136 18139 /*
18137 18140 * Attempt to remove the interface. It may legitimately not exist
18138 18141 * (e.g. the zone administrator unplumbed it), so ignore ENXIO.
18139 18142 */
18140 18143 err = ip_ioctl(lh, SIOCLIFREMOVEIF, &lifr, sizeof (lifr), cr);
18141 18144 if (err != 0 && err != ENXIO) {
18142 18145 ip0dbg(("ip_loopback_removeif: IP%s SIOCLIFREMOVEIF failed: "
18143 18146 "error %d\n", isv6 ? "v6" : "v4", err));
18144 18147 }
18145 18148 }
18146 18149
18147 18150 /*
18148 18151 * Helper for ip_interface_cleanup() that ensures no IP interfaces are in IPMP
18149 18152 * groups and that IPMP data addresses are down. These conditions must be met
18150 18153 * so that IPMP interfaces can be I_PUNLINK'd, as per ip_sioctl_plink_ipmp().
18151 18154 */
18152 18155 static void
18153 18156 ip_ipmp_cleanup(ldi_handle_t lh, boolean_t isv6, cred_t *cr)
18154 18157 {
18155 18158 int af = isv6 ? AF_INET6 : AF_INET;
18156 18159 int i, nifs;
18157 18160 int err;
18158 18161 uint_t bufsize;
18159 18162 uint_t lifrsize = sizeof (struct lifreq);
18160 18163 struct lifconf lifc;
18161 18164 struct lifreq *lifrp;
18162 18165
18163 18166 if ((err = ip_lifconf_ioctl(lh, af, &lifc, &bufsize, cr)) != 0) {
18164 18167 cmn_err(CE_WARN, "ip_ipmp_cleanup: cannot get interface list "
18165 18168 "(error %d); any IPMP interfaces cannot be shutdown", err);
18166 18169 return;
18167 18170 }
18168 18171
18169 18172 nifs = lifc.lifc_len / lifrsize;
18170 18173 for (lifrp = lifc.lifc_req, i = 0; i < nifs; i++, lifrp++) {
18171 18174 err = ip_ioctl(lh, SIOCGLIFFLAGS, lifrp, lifrsize, cr);
18172 18175 if (err != 0) {
18173 18176 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot get "
18174 18177 "flags: error %d", lifrp->lifr_name, err);
18175 18178 continue;
18176 18179 }
18177 18180
18178 18181 if (lifrp->lifr_flags & IFF_IPMP) {
18179 18182 if ((lifrp->lifr_flags & (IFF_UP|IFF_DUPLICATE)) == 0)
18180 18183 continue;
18181 18184
18182 18185 lifrp->lifr_flags &= ~IFF_UP;
18183 18186 err = ip_ioctl(lh, SIOCSLIFFLAGS, lifrp, lifrsize, cr);
18184 18187 if (err != 0) {
18185 18188 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot "
18186 18189 "bring down (error %d); IPMP interface may "
18187 18190 "not be shutdown", lifrp->lifr_name, err);
18188 18191 }
18189 18192
18190 18193 /*
18191 18194 * Check if IFF_DUPLICATE is still set -- and if so,
18192 18195 * reset the address to clear it.
18193 18196 */
18194 18197 err = ip_ioctl(lh, SIOCGLIFFLAGS, lifrp, lifrsize, cr);
18195 18198 if (err != 0 || !(lifrp->lifr_flags & IFF_DUPLICATE))
18196 18199 continue;
18197 18200
18198 18201 err = ip_ioctl(lh, SIOCGLIFADDR, lifrp, lifrsize, cr);
18199 18202 if (err != 0 || (err = ip_ioctl(lh, SIOCGLIFADDR,
18200 18203 lifrp, lifrsize, cr)) != 0) {
18201 18204 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot "
18202 18205 "reset DAD (error %d); IPMP interface may "
18203 18206 "not be shutdown", lifrp->lifr_name, err);
18204 18207 }
18205 18208 continue;
18206 18209 }
18207 18210
18208 18211 if (strchr(lifrp->lifr_name, IPIF_SEPARATOR_CHAR) == 0) {
18209 18212 lifrp->lifr_groupname[0] = '\0';
18210 18213 if ((err = ip_ioctl(lh, SIOCSLIFGROUPNAME, lifrp,
18211 18214 lifrsize, cr)) != 0) {
18212 18215 cmn_err(CE_WARN, "ip_ipmp_cleanup: %s: cannot "
18213 18216 "leave IPMP group (error %d); associated "
18214 18217 "IPMP interface may not be shutdown",
18215 18218 lifrp->lifr_name, err);
18216 18219 continue;
18217 18220 }
18218 18221 }
18219 18222 }
18220 18223
18221 18224 kmem_free(lifc.lifc_buf, bufsize);
18222 18225 }
18223 18226
18224 18227 #define UDPDEV "/devices/pseudo/udp@0:udp"
18225 18228 #define UDP6DEV "/devices/pseudo/udp6@0:udp6"
18226 18229
18227 18230 /*
18228 18231 * Remove the loopback interfaces and prep the IPMP interfaces to be torn down.
18229 18232 * Non-loopback interfaces are either I_LINK'd or I_PLINK'd; the former go away
18230 18233 * when the user-level processes in the zone are killed and the latter are
18231 18234 * cleaned up by str_stack_shutdown().
18232 18235 */
18233 18236 void
18234 18237 ip_interface_cleanup(ip_stack_t *ipst)
18235 18238 {
18236 18239 ldi_handle_t lh;
18237 18240 ldi_ident_t li;
18238 18241 cred_t *cr;
18239 18242 int err;
18240 18243 int i;
18241 18244 char *devs[] = { UDP6DEV, UDPDEV };
18242 18245 netstackid_t stackid = ipst->ips_netstack->netstack_stackid;
18243 18246
18244 18247 if ((err = ldi_ident_from_major(ddi_name_to_major("ip"), &li)) != 0) {
18245 18248 cmn_err(CE_WARN, "ip_interface_cleanup: cannot get ldi ident:"
18246 18249 " error %d", err);
18247 18250 return;
18248 18251 }
18249 18252
18250 18253 cr = zone_get_kcred(netstackid_to_zoneid(stackid));
18251 18254 ASSERT(cr != NULL);
18252 18255
18253 18256 /*
18254 18257 * NOTE: loop executes exactly twice and is hardcoded to know that the
18255 18258 * first iteration is IPv6. (Unrolling yields repetitious code, hence
18256 18259 * the loop.)
18257 18260 */
18258 18261 for (i = 0; i < 2; i++) {
18259 18262 err = ldi_open_by_name(devs[i], FREAD|FWRITE, cr, &lh, li);
18260 18263 if (err != 0) {
18261 18264 cmn_err(CE_WARN, "ip_interface_cleanup: cannot open %s:"
18262 18265 " error %d", devs[i], err);
18263 18266 continue;
18264 18267 }
18265 18268
18266 18269 ip_loopback_removeif(lh, i == 0, cr);
18267 18270 ip_ipmp_cleanup(lh, i == 0, cr);
18268 18271
18269 18272 (void) ldi_close(lh, FREAD|FWRITE, cr);
18270 18273 }
18271 18274
18272 18275 ldi_ident_release(li);
18273 18276 crfree(cr);
18274 18277 }
18275 18278
18276 18279 /*
18277 18280 * This needs to be in-sync with nic_event_t definition
18278 18281 */
18279 18282 static const char *
18280 18283 ill_hook_event2str(nic_event_t event)
18281 18284 {
18282 18285 switch (event) {
18283 18286 case NE_PLUMB:
18284 18287 return ("PLUMB");
18285 18288 case NE_UNPLUMB:
18286 18289 return ("UNPLUMB");
18287 18290 case NE_UP:
18288 18291 return ("UP");
18289 18292 case NE_DOWN:
18290 18293 return ("DOWN");
18291 18294 case NE_ADDRESS_CHANGE:
18292 18295 return ("ADDRESS_CHANGE");
18293 18296 case NE_LIF_UP:
18294 18297 return ("LIF_UP");
18295 18298 case NE_LIF_DOWN:
18296 18299 return ("LIF_DOWN");
18297 18300 case NE_IFINDEX_CHANGE:
18298 18301 return ("IFINDEX_CHANGE");
18299 18302 default:
18300 18303 return ("UNKNOWN");
18301 18304 }
18302 18305 }
18303 18306
18304 18307 void
18305 18308 ill_nic_event_dispatch(ill_t *ill, lif_if_t lif, nic_event_t event,
18306 18309 nic_event_data_t data, size_t datalen)
18307 18310 {
18308 18311 ip_stack_t *ipst = ill->ill_ipst;
18309 18312 hook_nic_event_int_t *info;
18310 18313 const char *str = NULL;
18311 18314
18312 18315 /* create a new nic event info */
18313 18316 if ((info = kmem_alloc(sizeof (*info), KM_NOSLEEP)) == NULL)
18314 18317 goto fail;
18315 18318
18316 18319 info->hnei_event.hne_nic = ill->ill_phyint->phyint_ifindex;
18317 18320 info->hnei_event.hne_lif = lif;
18318 18321 info->hnei_event.hne_event = event;
18319 18322 info->hnei_event.hne_protocol = ill->ill_isv6 ?
18320 18323 ipst->ips_ipv6_net_data : ipst->ips_ipv4_net_data;
18321 18324 info->hnei_event.hne_data = NULL;
18322 18325 info->hnei_event.hne_datalen = 0;
18323 18326 info->hnei_stackid = ipst->ips_netstack->netstack_stackid;
18324 18327
18325 18328 if (data != NULL && datalen != 0) {
18326 18329 info->hnei_event.hne_data = kmem_alloc(datalen, KM_NOSLEEP);
18327 18330 if (info->hnei_event.hne_data == NULL)
18328 18331 goto fail;
18329 18332 bcopy(data, info->hnei_event.hne_data, datalen);
18330 18333 info->hnei_event.hne_datalen = datalen;
18331 18334 }
18332 18335
18333 18336 if (ddi_taskq_dispatch(eventq_queue_nic, ip_ne_queue_func, info,
18334 18337 DDI_NOSLEEP) == DDI_SUCCESS)
18335 18338 return;
18336 18339
18337 18340 fail:
18338 18341 if (info != NULL) {
18339 18342 if (info->hnei_event.hne_data != NULL) {
18340 18343 kmem_free(info->hnei_event.hne_data,
18341 18344 info->hnei_event.hne_datalen);
18342 18345 }
18343 18346 kmem_free(info, sizeof (hook_nic_event_t));
18344 18347 }
18345 18348 str = ill_hook_event2str(event);
18346 18349 ip2dbg(("ill_nic_event_dispatch: could not dispatch %s nic event "
18347 18350 "information for %s (ENOMEM)\n", str, ill->ill_name));
18348 18351 }
18349 18352
18350 18353 static int
18351 18354 ipif_arp_up_done_tail(ipif_t *ipif, enum ip_resolver_action res_act)
18352 18355 {
18353 18356 int err = 0;
18354 18357 const in_addr_t *addr = NULL;
18355 18358 nce_t *nce = NULL;
18356 18359 ill_t *ill = ipif->ipif_ill;
18357 18360 ill_t *bound_ill;
18358 18361 boolean_t added_ipif = B_FALSE;
18359 18362 uint16_t state;
18360 18363 uint16_t flags;
18361 18364
18362 18365 DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_up_done_tail",
18363 18366 ill_t *, ill, ipif_t *, ipif);
18364 18367 if (ipif->ipif_lcl_addr != INADDR_ANY) {
18365 18368 addr = &ipif->ipif_lcl_addr;
18366 18369 }
18367 18370
18368 18371 if ((ipif->ipif_flags & IPIF_UNNUMBERED) || addr == NULL) {
18369 18372 if (res_act != Res_act_initial)
18370 18373 return (EINVAL);
18371 18374 }
18372 18375
18373 18376 if (addr != NULL) {
18374 18377 ipmp_illgrp_t *illg = ill->ill_grp;
18375 18378
18376 18379 /* add unicast nce for the local addr */
18377 18380
18378 18381 if (IS_IPMP(ill)) {
18379 18382 /*
18380 18383 * If we're here via ipif_up(), then the ipif
18381 18384 * won't be bound yet -- add it to the group,
18382 18385 * which will bind it if possible. (We would
18383 18386 * add it in ipif_up(), but deleting on failure
18384 18387 * there is gruesome.) If we're here via
18385 18388 * ipmp_ill_bind_ipif(), then the ipif has
18386 18389 * already been added to the group and we
18387 18390 * just need to use the binding.
18388 18391 */
18389 18392 if ((bound_ill = ipmp_ipif_bound_ill(ipif)) == NULL) {
18390 18393 bound_ill = ipmp_illgrp_add_ipif(illg, ipif);
18391 18394 if (bound_ill == NULL) {
18392 18395 /*
18393 18396 * We couldn't bind the ipif to an ill
18394 18397 * yet, so we have nothing to publish.
18395 18398 * Mark the address as ready and return.
18396 18399 */
18397 18400 ipif->ipif_addr_ready = 1;
18398 18401 return (0);
18399 18402 }
18400 18403 added_ipif = B_TRUE;
18401 18404 }
18402 18405 } else {
18403 18406 bound_ill = ill;
18404 18407 }
18405 18408
18406 18409 flags = (NCE_F_MYADDR | NCE_F_PUBLISH | NCE_F_AUTHORITY |
18407 18410 NCE_F_NONUD);
18408 18411 /*
18409 18412 * If this is an initial bring-up (or the ipif was never
18410 18413 * completely brought up), do DAD. Otherwise, we're here
18411 18414 * because IPMP has rebound an address to this ill: send
18412 18415 * unsolicited advertisements (ARP announcements) to
18413 18416 * inform others.
18414 18417 */
18415 18418 if (res_act == Res_act_initial || !ipif->ipif_addr_ready) {
18416 18419 state = ND_UNCHANGED; /* compute in nce_add_common() */
18417 18420 } else {
18418 18421 state = ND_REACHABLE;
18419 18422 flags |= NCE_F_UNSOL_ADV;
18420 18423 }
18421 18424
18422 18425 retry:
18423 18426 err = nce_lookup_then_add_v4(ill,
18424 18427 bound_ill->ill_phys_addr, bound_ill->ill_phys_addr_length,
18425 18428 addr, flags, state, &nce);
18426 18429
18427 18430 /*
18428 18431 * note that we may encounter EEXIST if we are moving
18429 18432 * the nce as a result of a rebind operation.
18430 18433 */
18431 18434 switch (err) {
18432 18435 case 0:
18433 18436 ipif->ipif_added_nce = 1;
18434 18437 nce->nce_ipif_cnt++;
18435 18438 break;
18436 18439 case EEXIST:
18437 18440 ip1dbg(("ipif_arp_up: NCE already exists for %s\n",
18438 18441 ill->ill_name));
18439 18442 if (!NCE_MYADDR(nce->nce_common)) {
18440 18443 /*
18441 18444 * A leftover nce from before this address
18442 18445 * existed
18443 18446 */
18444 18447 ncec_delete(nce->nce_common);
18445 18448 nce_refrele(nce);
18446 18449 nce = NULL;
18447 18450 goto retry;
18448 18451 }
18449 18452 if ((ipif->ipif_flags & IPIF_POINTOPOINT) == 0) {
18450 18453 nce_refrele(nce);
18451 18454 nce = NULL;
18452 18455 ip1dbg(("ipif_arp_up: NCE already exists "
18453 18456 "for %s:%u\n", ill->ill_name,
18454 18457 ipif->ipif_id));
18455 18458 goto arp_up_done;
18456 18459 }
18457 18460 /*
18458 18461 * Duplicate local addresses are permissible for
18459 18462 * IPIF_POINTOPOINT interfaces which will get marked
18460 18463 * IPIF_UNNUMBERED later in
18461 18464 * ip_addr_availability_check().
18462 18465 *
18463 18466 * The nce_ipif_cnt field tracks the number of
18464 18467 * ipifs that have nce_addr as their local address.
18465 18468 */
18466 18469 ipif->ipif_addr_ready = 1;
18467 18470 ipif->ipif_added_nce = 1;
18468 18471 nce->nce_ipif_cnt++;
18469 18472 err = 0;
18470 18473 break;
18471 18474 default:
18472 18475 ASSERT(nce == NULL);
18473 18476 goto arp_up_done;
18474 18477 }
18475 18478 if (arp_no_defense) {
18476 18479 if ((ipif->ipif_flags & IPIF_UP) &&
18477 18480 !ipif->ipif_addr_ready)
18478 18481 ipif_up_notify(ipif);
18479 18482 ipif->ipif_addr_ready = 1;
18480 18483 }
18481 18484 } else {
18482 18485 /* zero address. nothing to publish */
18483 18486 ipif->ipif_addr_ready = 1;
18484 18487 }
18485 18488 if (nce != NULL)
18486 18489 nce_refrele(nce);
18487 18490 arp_up_done:
18488 18491 if (added_ipif && err != 0)
18489 18492 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18490 18493 return (err);
18491 18494 }
18492 18495
18493 18496 int
18494 18497 ipif_arp_up(ipif_t *ipif, enum ip_resolver_action res_act, boolean_t was_dup)
18495 18498 {
18496 18499 int err = 0;
18497 18500 ill_t *ill = ipif->ipif_ill;
18498 18501 boolean_t first_interface, wait_for_dlpi = B_FALSE;
18499 18502
18500 18503 DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_up",
18501 18504 ill_t *, ill, ipif_t *, ipif);
18502 18505
18503 18506 /*
18504 18507 * need to bring up ARP or setup mcast mapping only
18505 18508 * when the first interface is coming UP.
18506 18509 */
18507 18510 first_interface = (ill->ill_ipif_up_count == 0 &&
18508 18511 ill->ill_ipif_dup_count == 0 && !was_dup);
18509 18512
18510 18513 if (res_act == Res_act_initial && first_interface) {
18511 18514 /*
18512 18515 * Send ATTACH + BIND
18513 18516 */
18514 18517 err = arp_ll_up(ill);
18515 18518 if (err != EINPROGRESS && err != 0)
18516 18519 return (err);
18517 18520
18518 18521 /*
18519 18522 * Add NCE for local address. Start DAD.
18520 18523 * we'll wait to hear that DAD has finished
18521 18524 * before using the interface.
18522 18525 */
18523 18526 if (err == EINPROGRESS)
18524 18527 wait_for_dlpi = B_TRUE;
18525 18528 }
18526 18529
18527 18530 if (!wait_for_dlpi)
18528 18531 (void) ipif_arp_up_done_tail(ipif, res_act);
18529 18532
18530 18533 return (!wait_for_dlpi ? 0 : EINPROGRESS);
18531 18534 }
18532 18535
18533 18536 /*
18534 18537 * Finish processing of "arp_up" after all the DLPI message
18535 18538 * exchanges have completed between arp and the driver.
18536 18539 */
18537 18540 void
18538 18541 arp_bringup_done(ill_t *ill, int err)
18539 18542 {
18540 18543 mblk_t *mp1;
18541 18544 ipif_t *ipif;
18542 18545 conn_t *connp = NULL;
18543 18546 ipsq_t *ipsq;
18544 18547 queue_t *q;
18545 18548
18546 18549 ip1dbg(("arp_bringup_done(%s)\n", ill->ill_name));
18547 18550
18548 18551 ASSERT(IAM_WRITER_ILL(ill));
18549 18552
18550 18553 ipsq = ill->ill_phyint->phyint_ipsq;
18551 18554 ipif = ipsq->ipsq_xop->ipx_pending_ipif;
18552 18555 mp1 = ipsq_pending_mp_get(ipsq, &connp);
18553 18556 ASSERT(!((mp1 != NULL) ^ (ipif != NULL)));
18554 18557 if (mp1 == NULL) /* bringup was aborted by the user */
18555 18558 return;
18556 18559
18557 18560 /*
18558 18561 * If an IOCTL is waiting on this (ipsq_current_ioctl != 0), then we
18559 18562 * must have an associated conn_t. Otherwise, we're bringing this
18560 18563 * interface back up as part of handling an asynchronous event (e.g.,
18561 18564 * physical address change).
18562 18565 */
18563 18566 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18564 18567 ASSERT(connp != NULL);
18565 18568 q = CONNP_TO_WQ(connp);
18566 18569 } else {
18567 18570 ASSERT(connp == NULL);
18568 18571 q = ill->ill_rq;
18569 18572 }
18570 18573 if (err == 0) {
18571 18574 if (ipif->ipif_isv6) {
18572 18575 if ((err = ipif_up_done_v6(ipif)) != 0)
18573 18576 ip0dbg(("arp_bringup_done: init failed\n"));
18574 18577 } else {
18575 18578 err = ipif_arp_up_done_tail(ipif, Res_act_initial);
18576 18579 if (err != 0 ||
18577 18580 (err = ipif_up_done(ipif)) != 0) {
18578 18581 ip0dbg(("arp_bringup_done: "
18579 18582 "init failed err %x\n", err));
18580 18583 (void) ipif_arp_down(ipif);
18581 18584 }
18582 18585
18583 18586 }
18584 18587 } else {
18585 18588 ip0dbg(("arp_bringup_done: DL_BIND_REQ failed\n"));
18586 18589 }
18587 18590
18588 18591 if ((err == 0) && (ill->ill_up_ipifs)) {
18589 18592 err = ill_up_ipifs(ill, q, mp1);
18590 18593 if (err == EINPROGRESS)
18591 18594 return;
18592 18595 }
18593 18596
18594 18597 /*
18595 18598 * If we have a moved ipif to bring up, and everything has succeeded
18596 18599 * to this point, bring it up on the IPMP ill. Otherwise, leave it
18597 18600 * down -- the admin can try to bring it up by hand if need be.
18598 18601 */
18599 18602 if (ill->ill_move_ipif != NULL) {
18600 18603 ipif = ill->ill_move_ipif;
18601 18604 ip1dbg(("bringing up ipif %p on ill %s\n", (void *)ipif,
18602 18605 ipif->ipif_ill->ill_name));
18603 18606 ill->ill_move_ipif = NULL;
18604 18607 if (err == 0) {
18605 18608 err = ipif_up(ipif, q, mp1);
18606 18609 if (err == EINPROGRESS)
18607 18610 return;
18608 18611 }
18609 18612 }
18610 18613
18611 18614 /*
18612 18615 * The operation must complete without EINPROGRESS since
18613 18616 * ipsq_pending_mp_get() has removed the mblk from ipsq_pending_mp.
18614 18617 * Otherwise, the operation will be stuck forever in the ipsq.
18615 18618 */
18616 18619 ASSERT(err != EINPROGRESS);
18617 18620 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18618 18621 DTRACE_PROBE4(ipif__ioctl, char *, "arp_bringup_done finish",
18619 18622 int, ipsq->ipsq_xop->ipx_current_ioctl,
18620 18623 ill_t *, ill, ipif_t *, ipif);
18621 18624 ip_ioctl_finish(q, mp1, err, NO_COPYOUT, ipsq);
18622 18625 } else {
18623 18626 ipsq_current_finish(ipsq);
18624 18627 }
18625 18628 }
18626 18629
18627 18630 /*
18628 18631 * Finish processing of arp replumb after all the DLPI message
18629 18632 * exchanges have completed between arp and the driver.
18630 18633 */
18631 18634 void
18632 18635 arp_replumb_done(ill_t *ill, int err)
18633 18636 {
18634 18637 mblk_t *mp1;
18635 18638 ipif_t *ipif;
18636 18639 conn_t *connp = NULL;
18637 18640 ipsq_t *ipsq;
18638 18641 queue_t *q;
18639 18642
18640 18643 ASSERT(IAM_WRITER_ILL(ill));
18641 18644
18642 18645 ipsq = ill->ill_phyint->phyint_ipsq;
18643 18646 ipif = ipsq->ipsq_xop->ipx_pending_ipif;
18644 18647 mp1 = ipsq_pending_mp_get(ipsq, &connp);
18645 18648 ASSERT(!((mp1 != NULL) ^ (ipif != NULL)));
18646 18649 if (mp1 == NULL) {
18647 18650 ip0dbg(("arp_replumb_done: bringup aborted ioctl %x\n",
18648 18651 ipsq->ipsq_xop->ipx_current_ioctl));
18649 18652 /* bringup was aborted by the user */
18650 18653 return;
18651 18654 }
18652 18655 /*
18653 18656 * If an IOCTL is waiting on this (ipsq_current_ioctl != 0), then we
18654 18657 * must have an associated conn_t. Otherwise, we're bringing this
18655 18658 * interface back up as part of handling an asynchronous event (e.g.,
18656 18659 * physical address change).
18657 18660 */
18658 18661 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18659 18662 ASSERT(connp != NULL);
18660 18663 q = CONNP_TO_WQ(connp);
18661 18664 } else {
18662 18665 ASSERT(connp == NULL);
18663 18666 q = ill->ill_rq;
18664 18667 }
18665 18668 if ((err == 0) && (ill->ill_up_ipifs)) {
18666 18669 err = ill_up_ipifs(ill, q, mp1);
18667 18670 if (err == EINPROGRESS)
18668 18671 return;
18669 18672 }
18670 18673 /*
18671 18674 * The operation must complete without EINPROGRESS since
18672 18675 * ipsq_pending_mp_get() has removed the mblk from ipsq_pending_mp.
18673 18676 * Otherwise, the operation will be stuck forever in the ipsq.
18674 18677 */
18675 18678 ASSERT(err != EINPROGRESS);
18676 18679 if (ipsq->ipsq_xop->ipx_current_ioctl != 0) {
18677 18680 DTRACE_PROBE4(ipif__ioctl, char *,
18678 18681 "arp_replumb_done finish",
18679 18682 int, ipsq->ipsq_xop->ipx_current_ioctl,
18680 18683 ill_t *, ill, ipif_t *, ipif);
18681 18684 ip_ioctl_finish(q, mp1, err, NO_COPYOUT, ipsq);
18682 18685 } else {
18683 18686 ipsq_current_finish(ipsq);
18684 18687 }
18685 18688 }
18686 18689
18687 18690 void
18688 18691 ipif_up_notify(ipif_t *ipif)
18689 18692 {
18690 18693 ip_rts_ifmsg(ipif, RTSQ_DEFAULT);
18691 18694 ip_rts_newaddrmsg(RTM_ADD, 0, ipif, RTSQ_DEFAULT);
18692 18695 sctp_update_ipif(ipif, SCTP_IPIF_UP);
18693 18696 ill_nic_event_dispatch(ipif->ipif_ill, MAP_IPIF_ID(ipif->ipif_id),
18694 18697 NE_LIF_UP, NULL, 0);
18695 18698 }
18696 18699
18697 18700 /*
18698 18701 * ILB ioctl uses cv_wait (such as deleting a rule or adding a server) and
18699 18702 * this assumes the context is cv_wait'able. Hence it shouldnt' be used on
18700 18703 * TPI end points with STREAMS modules pushed above. This is assured by not
18701 18704 * having the IPI_MODOK flag for the ioctl. And IP ensures the ILB ioctl
18702 18705 * never ends up on an ipsq, otherwise we may end up processing the ioctl
18703 18706 * while unwinding from the ispq and that could be a thread from the bottom.
18704 18707 */
18705 18708 /* ARGSUSED */
18706 18709 int
18707 18710 ip_sioctl_ilb_cmd(ipif_t *ipif, sin_t *sin, queue_t *q, mblk_t *mp,
18708 18711 ip_ioctl_cmd_t *ipip, void *arg)
18709 18712 {
18710 18713 mblk_t *cmd_mp = mp->b_cont->b_cont;
18711 18714 ilb_cmd_t command = *((ilb_cmd_t *)cmd_mp->b_rptr);
18712 18715 int ret = 0;
18713 18716 int i;
18714 18717 size_t size;
18715 18718 ip_stack_t *ipst;
18716 18719 zoneid_t zoneid;
18717 18720 ilb_stack_t *ilbs;
18718 18721
18719 18722 ipst = CONNQ_TO_IPST(q);
18720 18723 ilbs = ipst->ips_netstack->netstack_ilb;
18721 18724 zoneid = Q_TO_CONN(q)->conn_zoneid;
18722 18725
18723 18726 switch (command) {
18724 18727 case ILB_CREATE_RULE: {
18725 18728 ilb_rule_cmd_t *cmd = (ilb_rule_cmd_t *)cmd_mp->b_rptr;
18726 18729
18727 18730 if (MBLKL(cmd_mp) != sizeof (ilb_rule_cmd_t)) {
18728 18731 ret = EINVAL;
18729 18732 break;
18730 18733 }
18731 18734
18732 18735 ret = ilb_rule_add(ilbs, zoneid, cmd);
18733 18736 break;
18734 18737 }
18735 18738 case ILB_DESTROY_RULE:
18736 18739 case ILB_ENABLE_RULE:
18737 18740 case ILB_DISABLE_RULE: {
18738 18741 ilb_name_cmd_t *cmd = (ilb_name_cmd_t *)cmd_mp->b_rptr;
18739 18742
18740 18743 if (MBLKL(cmd_mp) != sizeof (ilb_name_cmd_t)) {
18741 18744 ret = EINVAL;
18742 18745 break;
18743 18746 }
18744 18747
18745 18748 if (cmd->flags & ILB_RULE_ALLRULES) {
18746 18749 if (command == ILB_DESTROY_RULE) {
18747 18750 ilb_rule_del_all(ilbs, zoneid);
18748 18751 break;
18749 18752 } else if (command == ILB_ENABLE_RULE) {
18750 18753 ilb_rule_enable_all(ilbs, zoneid);
18751 18754 break;
18752 18755 } else if (command == ILB_DISABLE_RULE) {
18753 18756 ilb_rule_disable_all(ilbs, zoneid);
18754 18757 break;
18755 18758 }
18756 18759 } else {
18757 18760 if (command == ILB_DESTROY_RULE) {
18758 18761 ret = ilb_rule_del(ilbs, zoneid, cmd->name);
18759 18762 } else if (command == ILB_ENABLE_RULE) {
18760 18763 ret = ilb_rule_enable(ilbs, zoneid, cmd->name,
18761 18764 NULL);
18762 18765 } else if (command == ILB_DISABLE_RULE) {
18763 18766 ret = ilb_rule_disable(ilbs, zoneid, cmd->name,
18764 18767 NULL);
18765 18768 }
18766 18769 }
18767 18770 break;
18768 18771 }
18769 18772 case ILB_NUM_RULES: {
18770 18773 ilb_num_rules_cmd_t *cmd;
18771 18774
18772 18775 if (MBLKL(cmd_mp) != sizeof (ilb_num_rules_cmd_t)) {
18773 18776 ret = EINVAL;
18774 18777 break;
18775 18778 }
18776 18779 cmd = (ilb_num_rules_cmd_t *)cmd_mp->b_rptr;
18777 18780 ilb_get_num_rules(ilbs, zoneid, &(cmd->num));
18778 18781 break;
18779 18782 }
18780 18783 case ILB_RULE_NAMES: {
18781 18784 ilb_rule_names_cmd_t *cmd;
18782 18785
18783 18786 cmd = (ilb_rule_names_cmd_t *)cmd_mp->b_rptr;
18784 18787 if (MBLKL(cmd_mp) < sizeof (ilb_rule_names_cmd_t) ||
18785 18788 cmd->num_names == 0) {
18786 18789 ret = EINVAL;
18787 18790 break;
18788 18791 }
18789 18792 size = cmd->num_names * ILB_RULE_NAMESZ;
18790 18793 if (cmd_mp->b_rptr + offsetof(ilb_rule_names_cmd_t, buf) +
18791 18794 size != cmd_mp->b_wptr) {
18792 18795 ret = EINVAL;
18793 18796 break;
18794 18797 }
18795 18798 ilb_get_rulenames(ilbs, zoneid, &cmd->num_names, cmd->buf);
18796 18799 break;
18797 18800 }
18798 18801 case ILB_NUM_SERVERS: {
18799 18802 ilb_num_servers_cmd_t *cmd;
18800 18803
18801 18804 if (MBLKL(cmd_mp) != sizeof (ilb_num_servers_cmd_t)) {
18802 18805 ret = EINVAL;
18803 18806 break;
18804 18807 }
18805 18808 cmd = (ilb_num_servers_cmd_t *)cmd_mp->b_rptr;
18806 18809 ret = ilb_get_num_servers(ilbs, zoneid, cmd->name,
18807 18810 &(cmd->num));
18808 18811 break;
18809 18812 }
18810 18813 case ILB_LIST_RULE: {
18811 18814 ilb_rule_cmd_t *cmd = (ilb_rule_cmd_t *)cmd_mp->b_rptr;
18812 18815
18813 18816 if (MBLKL(cmd_mp) != sizeof (ilb_rule_cmd_t)) {
18814 18817 ret = EINVAL;
18815 18818 break;
18816 18819 }
18817 18820 ret = ilb_rule_list(ilbs, zoneid, cmd);
18818 18821 break;
18819 18822 }
18820 18823 case ILB_LIST_SERVERS: {
18821 18824 ilb_servers_info_cmd_t *cmd;
18822 18825
18823 18826 cmd = (ilb_servers_info_cmd_t *)cmd_mp->b_rptr;
18824 18827 if (MBLKL(cmd_mp) < sizeof (ilb_servers_info_cmd_t) ||
18825 18828 cmd->num_servers == 0) {
18826 18829 ret = EINVAL;
18827 18830 break;
18828 18831 }
18829 18832 size = cmd->num_servers * sizeof (ilb_server_info_t);
18830 18833 if (cmd_mp->b_rptr + offsetof(ilb_servers_info_cmd_t, servers) +
18831 18834 size != cmd_mp->b_wptr) {
18832 18835 ret = EINVAL;
18833 18836 break;
18834 18837 }
18835 18838
18836 18839 ret = ilb_get_servers(ilbs, zoneid, cmd->name, cmd->servers,
18837 18840 &cmd->num_servers);
18838 18841 break;
18839 18842 }
18840 18843 case ILB_ADD_SERVERS: {
18841 18844 ilb_servers_info_cmd_t *cmd;
18842 18845 ilb_rule_t *rule;
18843 18846
18844 18847 cmd = (ilb_servers_info_cmd_t *)cmd_mp->b_rptr;
18845 18848 if (MBLKL(cmd_mp) < sizeof (ilb_servers_info_cmd_t)) {
18846 18849 ret = EINVAL;
18847 18850 break;
18848 18851 }
18849 18852 size = cmd->num_servers * sizeof (ilb_server_info_t);
18850 18853 if (cmd_mp->b_rptr + offsetof(ilb_servers_info_cmd_t, servers) +
18851 18854 size != cmd_mp->b_wptr) {
18852 18855 ret = EINVAL;
18853 18856 break;
18854 18857 }
18855 18858 rule = ilb_find_rule(ilbs, zoneid, cmd->name, &ret);
18856 18859 if (rule == NULL) {
18857 18860 ASSERT(ret != 0);
18858 18861 break;
18859 18862 }
18860 18863 for (i = 0; i < cmd->num_servers; i++) {
18861 18864 ilb_server_info_t *s;
18862 18865
18863 18866 s = &cmd->servers[i];
18864 18867 s->err = ilb_server_add(ilbs, rule, s);
18865 18868 }
18866 18869 ILB_RULE_REFRELE(rule);
18867 18870 break;
18868 18871 }
18869 18872 case ILB_DEL_SERVERS:
18870 18873 case ILB_ENABLE_SERVERS:
18871 18874 case ILB_DISABLE_SERVERS: {
18872 18875 ilb_servers_cmd_t *cmd;
18873 18876 ilb_rule_t *rule;
18874 18877 int (*f)();
18875 18878
18876 18879 cmd = (ilb_servers_cmd_t *)cmd_mp->b_rptr;
18877 18880 if (MBLKL(cmd_mp) < sizeof (ilb_servers_cmd_t)) {
18878 18881 ret = EINVAL;
18879 18882 break;
18880 18883 }
18881 18884 size = cmd->num_servers * sizeof (ilb_server_arg_t);
18882 18885 if (cmd_mp->b_rptr + offsetof(ilb_servers_cmd_t, servers) +
18883 18886 size != cmd_mp->b_wptr) {
18884 18887 ret = EINVAL;
18885 18888 break;
18886 18889 }
18887 18890
18888 18891 if (command == ILB_DEL_SERVERS)
18889 18892 f = ilb_server_del;
18890 18893 else if (command == ILB_ENABLE_SERVERS)
18891 18894 f = ilb_server_enable;
18892 18895 else if (command == ILB_DISABLE_SERVERS)
18893 18896 f = ilb_server_disable;
18894 18897
18895 18898 rule = ilb_find_rule(ilbs, zoneid, cmd->name, &ret);
18896 18899 if (rule == NULL) {
18897 18900 ASSERT(ret != 0);
18898 18901 break;
18899 18902 }
18900 18903
18901 18904 for (i = 0; i < cmd->num_servers; i++) {
18902 18905 ilb_server_arg_t *s;
18903 18906
18904 18907 s = &cmd->servers[i];
18905 18908 s->err = f(ilbs, zoneid, NULL, rule, &s->addr);
18906 18909 }
18907 18910 ILB_RULE_REFRELE(rule);
18908 18911 break;
18909 18912 }
18910 18913 case ILB_LIST_NAT_TABLE: {
18911 18914 ilb_list_nat_cmd_t *cmd;
18912 18915
18913 18916 cmd = (ilb_list_nat_cmd_t *)cmd_mp->b_rptr;
18914 18917 if (MBLKL(cmd_mp) < sizeof (ilb_list_nat_cmd_t)) {
18915 18918 ret = EINVAL;
18916 18919 break;
18917 18920 }
18918 18921 size = cmd->num_nat * sizeof (ilb_nat_entry_t);
18919 18922 if (cmd_mp->b_rptr + offsetof(ilb_list_nat_cmd_t, entries) +
18920 18923 size != cmd_mp->b_wptr) {
18921 18924 ret = EINVAL;
18922 18925 break;
18923 18926 }
18924 18927
18925 18928 ret = ilb_list_nat(ilbs, zoneid, cmd->entries, &cmd->num_nat,
18926 18929 &cmd->flags);
18927 18930 break;
18928 18931 }
18929 18932 case ILB_LIST_STICKY_TABLE: {
18930 18933 ilb_list_sticky_cmd_t *cmd;
18931 18934
18932 18935 cmd = (ilb_list_sticky_cmd_t *)cmd_mp->b_rptr;
18933 18936 if (MBLKL(cmd_mp) < sizeof (ilb_list_sticky_cmd_t)) {
18934 18937 ret = EINVAL;
18935 18938 break;
18936 18939 }
18937 18940 size = cmd->num_sticky * sizeof (ilb_sticky_entry_t);
18938 18941 if (cmd_mp->b_rptr + offsetof(ilb_list_sticky_cmd_t, entries) +
18939 18942 size != cmd_mp->b_wptr) {
18940 18943 ret = EINVAL;
18941 18944 break;
18942 18945 }
18943 18946
18944 18947 ret = ilb_list_sticky(ilbs, zoneid, cmd->entries,
18945 18948 &cmd->num_sticky, &cmd->flags);
18946 18949 break;
18947 18950 }
18948 18951 default:
18949 18952 ret = EINVAL;
18950 18953 break;
18951 18954 }
18952 18955 done:
18953 18956 return (ret);
18954 18957 }
18955 18958
18956 18959 /* Remove all cache entries for this logical interface */
18957 18960 void
18958 18961 ipif_nce_down(ipif_t *ipif)
18959 18962 {
18960 18963 ill_t *ill = ipif->ipif_ill;
18961 18964 nce_t *nce;
18962 18965
18963 18966 DTRACE_PROBE3(ipif__downup, char *, "ipif_nce_down",
18964 18967 ill_t *, ill, ipif_t *, ipif);
18965 18968 if (ipif->ipif_added_nce) {
18966 18969 if (ipif->ipif_isv6)
18967 18970 nce = nce_lookup_v6(ill, &ipif->ipif_v6lcl_addr);
18968 18971 else
18969 18972 nce = nce_lookup_v4(ill, &ipif->ipif_lcl_addr);
18970 18973 if (nce != NULL) {
18971 18974 if (--nce->nce_ipif_cnt == 0)
18972 18975 ncec_delete(nce->nce_common);
18973 18976 ipif->ipif_added_nce = 0;
18974 18977 nce_refrele(nce);
18975 18978 } else {
18976 18979 /*
18977 18980 * nce may already be NULL because it was already
18978 18981 * flushed, e.g., due to a call to nce_flush
18979 18982 */
18980 18983 ipif->ipif_added_nce = 0;
18981 18984 }
18982 18985 }
18983 18986 /*
18984 18987 * Make IPMP aware of the deleted data address.
18985 18988 */
18986 18989 if (IS_IPMP(ill))
18987 18990 ipmp_illgrp_del_ipif(ill->ill_grp, ipif);
18988 18991
18989 18992 /*
18990 18993 * Remove all other nces dependent on this ill when the last ipif
18991 18994 * is going away.
18992 18995 */
18993 18996 if (ill->ill_ipif_up_count == 0) {
18994 18997 ncec_walk(ill, (pfi_t)ncec_delete_per_ill,
18995 18998 (uchar_t *)ill, ill->ill_ipst);
18996 18999 if (IS_UNDER_IPMP(ill))
18997 19000 nce_flush(ill, B_TRUE);
18998 19001 }
18999 19002 }
19000 19003
19001 19004 /*
19002 19005 * find the first interface that uses usill for its source address.
19003 19006 */
19004 19007 ill_t *
19005 19008 ill_lookup_usesrc(ill_t *usill)
19006 19009 {
19007 19010 ip_stack_t *ipst = usill->ill_ipst;
19008 19011 ill_t *ill;
19009 19012
19010 19013 ASSERT(usill != NULL);
19011 19014
19012 19015 /* ill_g_usesrc_lock protects ill_usesrc_grp_next */
19013 19016 rw_enter(&ipst->ips_ill_g_usesrc_lock, RW_WRITER);
19014 19017 rw_enter(&ipst->ips_ill_g_lock, RW_READER);
19015 19018 for (ill = usill->ill_usesrc_grp_next; ill != NULL && ill != usill;
19016 19019 ill = ill->ill_usesrc_grp_next) {
19017 19020 if (!IS_UNDER_IPMP(ill) && (ill->ill_flags & ILLF_MULTICAST) &&
19018 19021 !ILL_IS_CONDEMNED(ill)) {
19019 19022 ill_refhold(ill);
19020 19023 break;
19021 19024 }
19022 19025 }
19023 19026 rw_exit(&ipst->ips_ill_g_lock);
19024 19027 rw_exit(&ipst->ips_ill_g_usesrc_lock);
19025 19028 return (ill);
19026 19029 }
19027 19030
19028 19031 /*
19029 19032 * This comment applies to both ip_sioctl_get_ifhwaddr and
19030 19033 * ip_sioctl_get_lifhwaddr as the basic function of these two functions
19031 19034 * is the same.
19032 19035 *
19033 19036 * The goal here is to find an IP interface that corresponds to the name
19034 19037 * provided by the caller in the ifreq/lifreq structure held in the mblk_t
19035 19038 * chain and to fill out a sockaddr/sockaddr_storage structure with the
19036 19039 * mac address.
19037 19040 *
19038 19041 * The SIOCGIFHWADDR/SIOCGLIFHWADDR ioctl may return an error for a number
19039 19042 * of different reasons:
19040 19043 * ENXIO - the device name is not known to IP.
19041 19044 * EADDRNOTAVAIL - the device has no hardware address. This is indicated
19042 19045 * by ill_phys_addr not pointing to an actual address.
19043 19046 * EPFNOSUPPORT - this will indicate that a request is being made for a
19044 19047 * mac address that will not fit in the data structure supplier (struct
19045 19048 * sockaddr).
19046 19049 *
19047 19050 */
19048 19051 /* ARGSUSED */
19049 19052 int
19050 19053 ip_sioctl_get_ifhwaddr(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
19051 19054 ip_ioctl_cmd_t *ipip, void *if_req)
19052 19055 {
19053 19056 struct sockaddr *sock;
19054 19057 struct ifreq *ifr;
19055 19058 mblk_t *mp1;
19056 19059 ill_t *ill;
19057 19060
19058 19061 ASSERT(ipif != NULL);
19059 19062 ill = ipif->ipif_ill;
19060 19063
19061 19064 if (ill->ill_phys_addr == NULL) {
19062 19065 return (EADDRNOTAVAIL);
19063 19066 }
19064 19067 if (ill->ill_phys_addr_length > sizeof (sock->sa_data)) {
19065 19068 return (EPFNOSUPPORT);
19066 19069 }
19067 19070
19068 19071 ip1dbg(("ip_sioctl_get_hwaddr(%s)\n", ill->ill_name));
19069 19072
19070 19073 /* Existence of mp1 has been checked in ip_wput_nondata */
19071 19074 mp1 = mp->b_cont->b_cont;
19072 19075 ifr = (struct ifreq *)mp1->b_rptr;
19073 19076
19074 19077 sock = &ifr->ifr_addr;
19075 19078 /*
19076 19079 * The "family" field in the returned structure is set to a value
19077 19080 * that represents the type of device to which the address belongs.
19078 19081 * The value returned may differ to that on Linux but it will still
19079 19082 * represent the correct symbol on Solaris.
19080 19083 */
19081 19084 sock->sa_family = arp_hw_type(ill->ill_mactype);
19082 19085 bcopy(ill->ill_phys_addr, &sock->sa_data, ill->ill_phys_addr_length);
19083 19086
19084 19087 return (0);
19085 19088 }
19086 19089
19087 19090 /*
19088 19091 * The expection of applications using SIOCGIFHWADDR is that data will
19089 19092 * be returned in the sa_data field of the sockaddr structure. With
19090 19093 * SIOCGLIFHWADDR, we're breaking new ground as there is no Linux
19091 19094 * equivalent. In light of this, struct sockaddr_dl is used as it
19092 19095 * offers more space for address storage in sll_data.
19093 19096 */
19094 19097 /* ARGSUSED */
19095 19098 int
19096 19099 ip_sioctl_get_lifhwaddr(ipif_t *ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
19097 19100 ip_ioctl_cmd_t *ipip, void *if_req)
19098 19101 {
19099 19102 struct sockaddr_dl *sock;
19100 19103 struct lifreq *lifr;
19101 19104 mblk_t *mp1;
19102 19105 ill_t *ill;
19103 19106
19104 19107 ASSERT(ipif != NULL);
19105 19108 ill = ipif->ipif_ill;
19106 19109
19107 19110 if (ill->ill_phys_addr == NULL) {
19108 19111 return (EADDRNOTAVAIL);
19109 19112 }
19110 19113 if (ill->ill_phys_addr_length > sizeof (sock->sdl_data)) {
19111 19114 return (EPFNOSUPPORT);
19112 19115 }
19113 19116
19114 19117 ip1dbg(("ip_sioctl_get_lifhwaddr(%s)\n", ill->ill_name));
19115 19118
19116 19119 /* Existence of mp1 has been checked in ip_wput_nondata */
19117 19120 mp1 = mp->b_cont->b_cont;
19118 19121 lifr = (struct lifreq *)mp1->b_rptr;
19119 19122
19120 19123 /*
19121 19124 * sockaddr_ll is used here because it is also the structure used in
19122 19125 * responding to the same ioctl in sockpfp. The only other choice is
19123 19126 * sockaddr_dl which contains fields that are not required here
19124 19127 * because its purpose is different.
19125 19128 */
19126 19129 lifr->lifr_type = ill->ill_type;
19127 19130 sock = (struct sockaddr_dl *)&lifr->lifr_addr;
19128 19131 sock->sdl_family = AF_LINK;
19129 19132 sock->sdl_index = ill->ill_phyint->phyint_ifindex;
19130 19133 sock->sdl_type = ill->ill_mactype;
19131 19134 sock->sdl_nlen = 0;
19132 19135 sock->sdl_slen = 0;
19133 19136 sock->sdl_alen = ill->ill_phys_addr_length;
19134 19137 bcopy(ill->ill_phys_addr, sock->sdl_data, ill->ill_phys_addr_length);
19135 19138
19136 19139 return (0);
19137 19140 }
|
↓ open down ↓ |
9935 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX