| blob | 31a67639ed683964e788fac5fc7c590a7414cc7f |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /* Copyright (c) 1990 Mentat Inc. */
29 /*
30 * This file contains the interface control functions for IP.
31 */
33 #include <sys/types.h>
34 #include <sys/stream.h>
35 #include <sys/dlpi.h>
36 #include <sys/stropts.h>
37 #include <sys/strsun.h>
38 #include <sys/sysmacros.h>
39 #include <sys/strlog.h>
40 #include <sys/ddi.h>
41 #include <sys/sunddi.h>
42 #include <sys/cmn_err.h>
43 #include <sys/kstat.h>
44 #include <sys/debug.h>
45 #include <sys/zone.h>
46 #include <sys/sunldi.h>
47 #include <sys/file.h>
48 #include <sys/bitmap.h>
50 #include <sys/kmem.h>
51 #include <sys/systm.h>
52 #include <sys/param.h>
53 #include <sys/socket.h>
54 #include <sys/isa_defs.h>
55 #include <net/if.h>
56 #include <net/if_arp.h>
57 #include <net/if_types.h>
58 #include <net/if_dl.h>
59 #include <net/route.h>
60 #include <sys/sockio.h>
61 #include <netinet/in.h>
62 #include <netinet/ip6.h>
63 #include <netinet/icmp6.h>
64 #include <netinet/igmp_var.h>
65 #include <sys/strsun.h>
66 #include <sys/policy.h>
67 #include <sys/ethernet.h>
70 #include <inet/mi.h>
71 #include <inet/nd.h>
72 #include <inet/arp.h>
73 #include <inet/mib2.h>
74 #include <inet/ip.h>
75 #include <inet/ip6.h>
76 #include <inet/ip6_asp.h>
77 #include <inet/tcp.h>
78 #include <inet/ip_multi.h>
79 #include <inet/ip_ire.h>
80 #include <inet/ip_ftable.h>
81 #include <inet/ip_rts.h>
82 #include <inet/ip_ndp.h>
83 #include <inet/ip_if.h>
84 #include <inet/ip_impl.h>
85 #include <inet/tun.h>
86 #include <inet/sctp_ip.h>
87 #include <inet/ip_netinfo.h>
88 #include <inet/mib2.h>
90 #include <net/pfkeyv2.h>
91 #include <inet/ipsec_info.h>
92 #include <inet/sadb.h>
93 #include <inet/ipsec_impl.h>
94 #include <sys/iphada.h>
97 #include <netinet/igmp.h>
98 #include <inet/ip_listutils.h>
99 #include <inet/ipclassifier.h>
100 #include <sys/mac.h>
102 #include <sys/systeminfo.h>
103 #include <sys/bootconf.h>
105 #include <sys/tsol/tndb.h>
106 #include <sys/tsol/tnet.h>
108 /* The character which tells where the ill_name ends */
111 /* IP ioctl function table entry */
114 pfi_t ipft_pfi;
123 area_t ip_sock_area;
124 ared_t ip_sock_ared;
125 areq_t ip_sock_areq;
159 boolean_t initialize);
163 boolean_t isv6);
207 in6_addr_t *);
209 ipaddr_t *);
212 in6_addr_t *);
214 ipaddr_t *);
221 /*
222 * Per-ill IPsec capabilities management.
223 */
231 boolean_t);
240 dl_capability_sub_t *);
259 #ifdef DEBUG
262 #endif
264 /*
265 * if we go over the memory footprint limit more than once in this msec
266 * interval, we'll start pruning aggressively.
267 */
270 /*
271 * max # of IPsec algorithms supported. Limited to 1 byte by PF_KEY
272 * and the IPsec DOI
273 */
274 #define MAX_IPSEC_ALGS 256
276 #define BITSPERBYTE 8
277 #define BITS(type) (BITSPERBYTE * (long)sizeof (type))
279 #define IPSEC_ALG_ENABLE(algs, algid) \
280 ((algs)[(algid) / BITS(ipsec_capab_elem_t)] |= \
281 (1 << ((algid) % BITS(ipsec_capab_elem_t))))
283 #define IPSEC_ALG_IS_ENABLED(algid, algs) \
284 ((algs)[(algid) / BITS(ipsec_capab_elem_t)] & \
285 (1 << ((algid) % BITS(ipsec_capab_elem_t))))
289 /*
290 * Per-algorithm parameters. Note that at present, only encryption
291 * algorithms have variable keysize (IKE does not provide a way to negotiate
292 * auth algorithm keysize).
293 *
294 * All sizes here are in bits.
295 */
297 {
302 /*
303 * Per-ill capabilities.
304 */
309 /* algorithm key lengths */
313 };
315 /*
316 * The field values are larger than strictly necessary for simple
317 * AR_ENTRY_ADDs but the padding lets us accomodate the socket ioctls.
318 */
322 /* area_name_offset */
323 /* area_name_length temporarily holds this structure length */
329 /* area_proto_mask_offset */
332 /* area_hw_addr_offset */
333 /* Zero length hw_addr_length means 'use your idea of the address' */
335 };
337 /*
338 * AR_ENTRY_ADD/DELETE templates have been added for IPv6 external resolver
339 * support
340 */
344 /* area_name_offset */
345 /* area_name_length temporarily holds this structure length */
351 /* area_proto_mask_offset */
354 /* area_hw_addr_offset */
355 /* Zero length hw_addr_length means 'use your idea of the address' */
357 };
360 AR_ENTRY_DELETE,
363 IP_ARP_PROTO_TYPE,
365 IP_ADDR_LEN
366 };
369 AR_ENTRY_DELETE,
372 IP_ARP_PROTO_TYPE,
374 IPV6_ADDR_LEN
375 };
377 /*
378 * A template for an IPv6 AR_ENTRY_QUERY template has not been created, as
379 * as the areq doesn't include an IP address in ill_dl_up() (the only place a
380 * areq is used).
381 */
394 AR_EQ_DEFAULT_MAX_BUFFERED /* max # of requests to buffer */
395 /* anything else filled in by the code */
396 };
399 AR_INTERFACE_UP,
402 };
405 AR_INTERFACE_DOWN,
408 };
411 AR_INTERFACE_ON,
414 };
417 AR_INTERFACE_OFF,
420 };
424 AR_MAPPING_ADD,
426 /* Name offset */
428 IP_ARP_PROTO_TYPE,
437 };
442 IPFT_F_NO_REPLY },
444 IPFT_F_NO_REPLY },
447 };
449 /* Simple ICMP IP Header Template */
452 };
454 /* Flag descriptors for ip_ipif_report */
490 };
496 ip_ether_v6intfid },
498 ip_nodef_v6intfid },
500 ip_nodef_v6intfid },
502 ip_nodef_v6intfid },
504 ip_ether_v6intfid },
506 ip_ib_v6intfid },
509 ip_nodef_v6intfid }
510 };
519 /* When set search for unused ipif_seqid */
522 /*
523 * ppa arena is created after these many
524 * interfaces have been plumbed.
525 */
528 /*
529 * Enable soft rings if ip_squeue_soft_ring or ip_squeue_fanout
530 * is set and ip_soft_rings_cnt > 0. ip_squeue_soft_ring is
531 * set through platform specific code (Niagara/Ontario).
532 */
533 #define SOFT_RINGS_ENABLED() (ip_soft_rings_cnt ? \
534 (ip_squeue_soft_ring || ip_squeue_fanout) : B_FALSE)
536 #define ILL_CAPAB_DLS (ILL_CAPAB_SOFT_RING | ILL_CAPAB_POLL)
538 static uint_t
540 {
544 }
546 /*
547 * Allocate per-interface mibs.
548 * Returns true if ok. False otherwise.
549 * ipsq may not yet be allocated (loopback case ).
550 */
551 static boolean_t
553 {
554 /* Already allocated? */
559 }
562 KM_NOSLEEP);
565 }
567 /* Setup static information */
595 /*
596 * For a v4 ill, we are done at this point, because per ill
597 * icmp mibs are only used for v6.
598 */
600 }
603 KM_NOSLEEP);
608 }
609 /* static icmp info */
612 /*
613 * The ipIfStatsIfindex and ipv6IfIcmpIndex will be assigned later
614 * after the phyint merge occurs in ipif_set_values -> ill_glist_insert
615 * -> ill_phyint_reinit
616 */
618 }
620 /*
621 * Common code for preparation of ARP commands. Two points to remember:
622 * 1) The ill_name is tacked on at the end of the allocated space so
623 * the templates name_offset field must contain the total space
624 * to allocate less the name length.
625 *
626 * 2) The templates name_length field should contain the *template*
627 * length. We use it as a parameter to bcopy() and then write
628 * the real ill_name_length into the name_length field of the copy.
629 * (Always called as writer.)
630 */
631 mblk_t *
633 {
668 else
672 }
673 }
675 }
677 mblk_t *
679 {
682 }
684 mblk_t *
686 {
689 }
691 mblk_t *
693 {
696 }
698 /*
699 * Completely vaporize a lower level tap and all associated interfaces.
700 * ill_delete is called only out of ip_close when the device control
701 * stream is being closed.
702 */
703 void
705 {
710 /*
711 * ill_delete may be forcibly entering the ipsq. The previous
712 * ioctl may not have completed and may need to be aborted.
713 * ipsq_flush takes care of it. If we don't need to enter the
714 * the ipsq forcibly, the 2nd invocation of ipsq_flush in
715 * ill_delete_tail is sufficient.
716 */
719 /*
720 * Nuke all interfaces. ipif_free will take down the interface,
721 * remove it from the list, and free the data structure.
722 * Walk down the ipif list and remove the logical interfaces
723 * first before removing the main ipif. We can't unplumb
724 * zeroth interface first in the case of IPv6 as reset_conn_ill
725 * -> ip_ll_delmulti_v6 de-references ill_ipif for checking
726 * POINTOPOINT.
727 *
728 * If ill_ipif was not properly initialized (i.e low on memory),
729 * then no interfaces to clean up. In this case just clean up the
730 * ill.
731 */
735 /*
736 * Used only by ill_arp_on and ill_arp_off, which are writers.
737 * So nobody can be using this mp now. Free the mp allocated for
738 * honoring ILLF_NOARP
739 */
743 /* Clean up msgs on pending upcalls for mrouted */
746 /*
747 * ipif_free -> reset_conn_ipif will remove all multicast
748 * references for IPv4. For IPv6, we need to do it here as
749 * it points only at ills.
750 */
753 /*
754 * ill_down will arrange to blow off any IRE's dependent on this
755 * ILL, and shut down fragmentation reassembly.
756 */
759 /* Let SCTP know, so that it can remove this from its list. */
762 /*
763 * If an address on this ILL is being used as a source address then
764 * clear out the pointers in other ILLs that point to this ILL.
765 */
774 }
775 }
777 }
779 static void
781 {
788 }
790 }
792 /*
793 * ill_delete_tail is called from ip_modclose after all references
794 * to the closing ill are gone. The wait is done in ip_modclose
795 */
796 void
798 {
806 }
812 /*
813 * If polling capability is enabled (which signifies direct
814 * upcall into IP and driver has ill saved as a handle),
815 * we need to make sure that unbind has completed before we
816 * let the ill disappear and driver no longer has any reference
817 * to this ill.
818 */
824 /*
825 * Clean up polling and soft ring capabilities
826 */
833 /*
834 * We do an ipsq_flush once again now. New messages could have
835 * landed up from below (M_ERROR or M_HANGUP). Similarly ioctls
836 * could also have landed up if an ioctl thread had looked up
837 * the ill before we set the ILL_CONDEMNED flag, but not yet
838 * enqueued the ioctl when we did the ipsq_flush last time.
839 */
842 /*
843 * Free capabilities.
844 */
849 }
855 }
860 }
865 }
871 }
876 }
885 }
892 /*
893 * We have removed all references to ilm from conn and the ones joined
894 * within the kernel.
895 *
896 * We don't walk conns, mrts and ires because
897 *
898 * 1) reset_conn_ill and reset_mrt_ill cleans up conns and mrts.
899 * 2) ill_down ->ill_downi walks all the ires and cleans up
900 * ill references.
901 */
903 /*
904 * Take us out of the list of ILLs. ill_glist_delete -> ill_phyint_free
905 * could free the phyint. No more reference to the phyint after this
906 * point.
907 */
917 uint_t count;
921 }
925 }
928 /* Free all retained control messages. */
940 }
942 }
947 #ifdef DEBUG
949 #endif
951 /* Drop refcnt here */
954 }
956 static void
958 {
961 /*
962 * MIB statistics must not be lost, so when an interface
963 * goes away the counter values will be added to the global
964 * MIBs.
965 */
973 }
977 }
983 }
984 }
986 /*
987 * Concatenate together a physical address and a sap.
988 *
989 * Sap_lengths are interpreted as follows:
990 * sap_length == 0 ==> no sap
991 * sap_length > 0 ==> sap is at the head of the dlpi address
992 * sap_length < 0 ==> sap is at the tail of the dlpi address
993 */
994 static void
997 {
1003 else
1008 else
1015 else
1017 }
1018 }
1020 /*
1021 * Generate a dl_unitdata_req mblk for the device and address given.
1022 * addr_length is the length of the physical portion of the address.
1023 * If addr is NULL include an all zero address of the specified length.
1024 * TRUE? In any case, addr_length is taken to be the entire length of the
1025 * dlpi address, including the absolute value of sap_length.
1026 */
1027 mblk_t *
1029 t_scalar_t sap_length)
1030 {
1037 DL_UNITDATA_REQ);
1041 /* HACK: accomodate incompatible DLPI drivers */
1051 }
1053 /*
1054 * Add the 'mp' to the list of pending mp's headed by ill_pending_mp
1055 * Return an error if we already have 1 or more ioctls in progress.
1056 * This is used only for non-exclusive ioctls. Currently this is used
1057 * for SIOC*ARP and SIOCGTUNPARAM ioctls. Most set ioctls are exclusive
1058 * and thus need to use ipsq_pending_mp_add.
1059 */
1060 boolean_t
1062 {
1065 /*
1066 * M_IOCDATA from ioctls, M_IOCTL from tunnel ioctls.
1067 */
1072 /*
1073 * Return error if the conn has started closing. The conn
1074 * could have finished cleaning up the pending mp list,
1075 * If so we should not add another mp to the list negating
1076 * the cleanup.
1077 */
1080 /*
1081 * Add the pending mp to the head of the list, chained by b_next.
1082 * Note down the conn on which the ioctl request came, in b_prev.
1083 * This will be used to later get the conn, when we get a response
1084 * on the ill queue, from some other module (typically arp)
1085 */
1092 }
1094 /*
1095 * Retrieve the ill_pending_mp and return it. We have to walk the list
1096 * of mblks starting at ill_pending_mp, and match based on the ioc_id.
1097 */
1098 mblk_t *
1100 {
1103 uint_t id;
1106 /*
1107 * When the conn closes, conn_ioctl_cleanup needs to clean
1108 * up the pending mp, but it does not know the ioc_id and
1109 * passes in a zero for it.
1110 */
1115 /* Search the list for the appropriate ioctl based on ioc_id */
1120 /* Match based on the ioc_id or based on the conn */
1123 }
1126 /* Unlink the mblk from the pending mp list */
1132 }
1134 /*
1135 * conn refcnt must have been bumped up at the start of
1136 * the ioctl. So we can safely access the conn.
1137 */
1142 }
1147 }
1149 /*
1150 * Add the pending mp to the list. There can be only 1 pending mp
1151 * in the list. Any exclusive ioctl that needs to wait for a response
1152 * from another module or driver needs to use this function to set
1153 * the ipsq_pending_mp to the ioctl mblk and wait for the response from
1154 * the other module/driver. This is also used while waiting for the
1155 * ipif/ill/ire refcnts to drop to zero in bringing down an ipif.
1156 */
1157 boolean_t
1160 {
1167 /*
1168 * The caller may be using a different ipif than the one passed into
1169 * ipsq_current_start() (e.g., suppose an ioctl that came in on the V4
1170 * ill needs to wait for the V6 ill to quiesce). So we can't ASSERT
1171 * that `ipsq_current_ipif == ipif'.
1172 */
1175 /*
1176 * M_IOCDATA from ioctls, M_IOCTL from tunnel ioctls,
1177 * M_ERROR/M_HANGUP/M_PROTO/M_PCPROTO from the driver.
1178 */
1185 /*
1186 * Return error if the conn has started closing. The conn
1187 * could have finished cleaning up the pending mp list,
1188 * If so we should not add another mp to the list negating
1189 * the cleanup.
1190 */
1193 }
1196 /*
1197 * Note down the queue in b_queue. This will be returned by
1198 * ipsq_pending_mp_get. Caller will then use these values to restart
1199 * the processing
1200 */
1210 }
1212 /*
1213 * Retrieve the ipsq_pending_mp and return it. There can be only 1 mp
1214 * queued in the list.
1215 */
1216 mblk_t *
1218 {
1226 }
1228 /* There can be only 1 such excl message */
1237 /*
1238 * This mp did a refhold on the conn, at the start of the ioctl.
1239 * So we can safely return a pointer to the conn to the caller.
1240 */
1244 }
1248 }
1250 /*
1251 * Cleanup the ioctl mp queued in ipsq_pending_mp
1252 * - Called in the ill_delete path
1253 * - Called in the M_ERROR or M_HANGUP path on the ill.
1254 * - Called in the conn close path.
1255 */
1256 boolean_t
1258 {
1267 /*
1268 * If connp is null, unconditionally clean up the ipsq_pending_mp.
1269 * This happens in M_ERROR/M_HANGUP. We need to abort the current ioctl
1270 * even if it is meant for another ill, since we have to enqueue
1271 * a new mp now in ipsq_pending_mp to complete the ipif_down.
1272 * If connp is non-null we are called from the conn close path.
1273 */
1279 }
1280 /* Now remove from the ipsq_pending_mp */
1287 /* If MOVE was in progress, clear the move_in_progress fields also. */
1293 }
1310 }
1312 /*
1313 * IP-MT XXX In the case of TLI/XTI bind / optmgmt this can't
1314 * be just inet_freemsg. we have to restart it
1315 * otherwise the thread will be stuck.
1316 */
1318 }
1320 }
1322 /*
1323 * The ill is closing. Cleanup all the pending mps. Called exclusively
1324 * towards the end of ill_delete. The refcount has gone to 0. So nobody
1325 * knows this ill, and hence nobody can add an mp to this list
1326 */
1327 static void
1329 {
1336 /*
1337 * Every mp on the pending mp list originating from an ioctl
1338 * added 1 to the conn refcnt, at the start of the ioctl.
1339 * So bump it down now. See comments in ip_wput_nondata()
1340 */
1353 }
1357 }
1359 /*
1360 * Called in the conn close path and ill delete path
1361 */
1362 static void
1364 {
1375 else
1379 /*
1380 * Cleanup the ioctl mp's queued in ipsq_xopq_pending_mp if any.
1381 * In the case of ioctl from a conn, there can be only 1 mp
1382 * queued on the ipsq. If an ill is being unplumbed, only messages
1383 * related to this ill are flushed, like M_ERROR or M_HANGUP message.
1384 * ioctls meant for this ill form conn's are not flushed. They will
1385 * be processed during ipsq_exit and will not find the ill and will
1386 * return error.
1387 */
1393 /* Unlink the mblk from the pending mp list */
1399 }
1402 /*
1403 * Create a temporary list and release the ipsq lock
1404 * New elements are added to the head of the tmp_list
1405 */
1410 }
1411 }
1424 /*
1425 * IP-MT XXX In the case of TLI/XTI bind / optmgmt
1426 * this can't be just inet_freemsg. we have to
1427 * restart it otherwise the thread will be stuck.
1428 */
1430 }
1431 }
1432 }
1434 /*
1435 * This conn has started closing. Cleanup any pending ioctl from this conn.
1436 * STREAMS ensures that there can be at most 1 ioctl pending on a stream.
1437 */
1438 void
1440 {
1444 boolean_t refheld;
1446 /*
1447 * Is any exclusive ioctl pending ? If so clean it up. If the
1448 * ioctl has not yet started, the mp is pending in the list headed by
1449 * ipsq_xopq_head. If the ioctl has started the mp could be present in
1450 * ipsq_pending_mp. If the ioctl timed out in the streamhead but
1451 * is currently executing now the mp is not queued anywhere but
1452 * conn_oper_pending_ill is null. The conn close will wait
1453 * till the conn_ref drops to zero.
1454 */
1460 }
1468 }
1469 /*
1470 * We may not be able to refhold the ill if the ill/ipif
1471 * is changing. But we need to make sure that the ill will
1472 * not vanish. So we just bump up the ill_waiter count.
1473 */
1479 /*
1480 * Check whether this ioctl has started and is
1481 * pending now in ipsq_pending_mp. If it is not
1482 * found there then check whether this ioctl has
1483 * not even started and is in the ipsq_xopq list.
1484 */
1490 }
1491 }
1493 /*
1494 * The ill is also closing and we could not bump up the
1495 * ill_waiter_count or we could not enter the ipsq. Leave
1496 * the cleanup to ill_delete
1497 */
1504 }
1506 /*
1507 * ipcl_walk function for cleaning up conn_*_ill fields.
1508 */
1509 static void
1511 {
1517 /* Revert to late binding */
1520 }
1533 /*
1534 * ip_newroute creates IRE_CACHE with ire_stq coming from
1535 * interface X and ipif coming from interface Y, if interface
1536 * X and Y are part of the same IPMPgroup. Thus whenever
1537 * interface X goes down, remove all references to it by
1538 * checking both on ire_ipif and ire_stq.
1539 */
1547 }
1548 }
1551 }
1553 /* ARGSUSED */
1554 void
1556 {
1564 }
1567 }
1569 /*
1570 * ill_down_start is called when we want to down this ill and bring it up again
1571 * It is called when we receive an M_ERROR / M_HANGUP. In this case we shut down
1572 * all interfaces, but don't tear down any plumbing.
1573 */
1574 boolean_t
1576 {
1591 /*
1592 * Atomically test and add the pending mp if references are active.
1593 */
1596 /* call cannot fail since `conn_t *' argument is NULL */
1601 }
1604 }
1606 static void
1608 {
1611 /* Blow off any IREs dependent on this ILL. */
1614 /* Remove any conn_*_ill depending on this ill */
1619 }
1620 }
1622 /*
1623 * ire_walk routine used to delete every IRE that depends on queues
1624 * associated with 'ill'. (Always called as writer.)
1625 */
1626 static void
1628 {
1631 /*
1632 * ip_newroute creates IRE_CACHE with ire_stq coming from
1633 * interface X and ipif coming from interface Y, if interface
1634 * X and Y are part of the same IPMP group. Thus whenever interface
1635 * X goes down, remove all references to it by checking both
1636 * on ire_ipif and ire_stq.
1637 */
1641 }
1642 }
1644 /*
1645 * Remove ire/nce from the fastpath list.
1646 */
1647 void
1649 {
1651 }
1653 /* Consume an M_IOCACK of the fastpath probe. */
1654 void
1656 {
1659 /*
1660 * If this was the first attempt turn on the fastpath probing.
1661 */
1667 /* Free the M_IOCACK mblk, hold on to the data */
1673 /*
1674 * Update all IRE's or NCE's that are waiting for
1675 * fastpath update.
1676 */
1683 }
1686 }
1688 /*
1689 * Throw an M_IOCTL message downstream asking "do you know fastpath?"
1690 * The data portion of the request is a dl_unitdata_req_t template for
1691 * what we would send downstream in the absence of a fastpath confirmation.
1692 */
1693 int
1695 {
1705 /*
1706 * Driver NAKed the first fastpath ioctl - assume it doesn't
1707 * support it.
1708 */
1712 /* This is the first probe */
1717 }
1727 }
1734 }
1736 void
1738 {
1739 /*
1740 * Do so only if capabilities are still unknown.
1741 */
1748 }
1750 void
1752 {
1756 /*
1757 * Note here that we reset the state to UNKNOWN, and later send
1758 * down the DL_CAPABILITY_REQ without first setting the state to
1759 * INPROGRESS. We do this in order to distinguish the
1760 * DL_CAPABILITY_ACK response which may come back in response to
1761 * a "reset" apart from the "probe" DL_CAPABILITY_REQ. This would
1762 * also handle the case where the driver doesn't send us back
1763 * a DL_CAPABILITY_ACK in response, since the "probe" routine
1764 * requires the state to be in UNKNOWN anyway. In any case, all
1765 * features are turned off until the state reaches IDS_OK.
1766 */
1770 /*
1771 * Disable sub-capabilities and request a list of sub-capability
1772 * messages which will be sent down to the driver. Each handler
1773 * allocates the corresponding dl_capability_sub_t inside an
1774 * mblk, and links it to the existing sc_mp mblk, or return it
1775 * as sc_mp if it's the first sub-capability (the passed in
1776 * sc_mp is NULL). Upon returning from all capability handlers,
1777 * sc_mp will be pulled-up, before passing it downstream.
1778 */
1786 /* Nothing to send down in order to disable the capabilities? */
1796 }
1800 }
1802 /*
1803 * Request or set new-style hardware capabilities supported by DLS provider.
1804 */
1805 static void
1807 {
1820 }
1833 }
1837 }
1839 static void
1841 {
1849 /*
1850 * Note: range checks here are not absolutely sufficient to
1851 * make us robust against malformed messages sent by drivers;
1852 * this is in keeping with the rest of IP's dlpi handling.
1853 * (Remember, it's coming from something else in the kernel
1854 * address space)
1855 */
1862 }
1873 }
1877 "isn't as expected; pass-thru module(s) detected, "
1880 }
1882 /* Process the encapsulated sub-capability */
1884 }
1886 /*
1887 * Process Multidata Transmit capability negotiation ack received from a
1888 * DLS Provider. isub must point to the sub-capability (DL_CAPAB_MDT) of a
1889 * DL_CAPABILITY_ACK message.
1890 */
1891 static void
1893 {
1905 /*
1906 * Note: range checks here are not absolutely sufficient to
1907 * make us robust against malformed messages sent by drivers;
1908 * this is in keeping with the rest of IP's dlpi handling.
1909 * (Remember, it's coming from something else in the kernel
1910 * address space)
1911 */
1918 }
1927 }
1931 "capability isn't as expected; pass-thru module(s) "
1934 }
1940 KM_NOSLEEP);
1944 "could not enable MDT version %d "
1948 }
1949 }
1952 "MDT version %d (%d bytes leading, %d bytes trailing "
1960 /*
1961 * Round the following values to the nearest 32-bit; ULP
1962 * may further adjust them to accomodate for additional
1963 * protocol headers. We pass these values to ULP during
1964 * bind time.
1965 */
1975 uint_t size;
1986 }
1989 /* initialize dl_capability_req_t */
1996 /* initialize dl_capability_sub_t */
2000 /* initialize dl_capab_mdt_t */
2008 MDT_VERSION_2));
2010 /* set ENABLE flag */
2013 /* nmp points to a DL_CAPABILITY_REQ message to enable MDT */
2015 }
2016 }
2018 static void
2020 {
2030 /*
2031 * Clear the capability flag for MDT but retain the ill_mdt_capab
2032 * structure since it's possible that another thread is still
2033 * referring to it. The structure only gets deallocated when
2034 * we destroy the ill.
2035 */
2045 }
2061 else
2063 }
2065 /*
2066 * Send a DL_NOTIFY_REQ to the specified ill to enable
2067 * DL_NOTE_PROMISC_ON/OFF_PHYS notifications.
2068 * Invoked by ill_capability_ipsec_ack() before enabling IPsec hardware
2069 * acceleration.
2070 * Returns B_TRUE on success, B_FALSE if the message could not be sent.
2071 */
2072 static boolean_t
2074 {
2086 DL_NOTE_PROMISC_OFF_PHYS;
2091 }
2094 /*
2095 * Allocate an IPsec capability request which will be filled by our
2096 * caller to turn on support for one or more algorithms.
2097 */
2100 {
2108 /*
2109 * The first time around, we send a DL_NOTIFY_REQ to enable
2110 * PROMISC_ON/OFF notification from the provider. We need to
2111 * do this before enabling the algorithms to avoid leakage of
2112 * cleartext packets.
2113 */
2118 /*
2119 * Allocate new mblk which will contain a new capability
2120 * request to enable the capabilities.
2121 */
2130 /* initialize dl_capability_req_t */
2136 /* initialize dl_capability_sub_t */
2140 /* initialize dl_capab_ipsec_t */
2146 }
2148 /*
2149 * Process an IPsec capability negotiation ack received from a DLS Provider.
2150 * isub must point to the sub-capability (DL_CAPAB_IPSEC_AH or
2151 * DL_CAPAB_IPSEC_ESP) of a DL_CAPABILITY_ACK message.
2152 */
2153 static void
2155 {
2161 uint_t alg_len;
2162 boolean_t need_sadb_dump;
2167 boolean_t sadb_resync;
2178 }
2180 /*
2181 * If the ill capability structure exists, then this incoming
2182 * DL_CAPABILITY_ACK is a response to a "renegotiation" cycle.
2183 * If this is so, then we'd need to resynchronize the SADB
2184 * after re-enabling the offloaded ciphers.
2185 */
2188 /*
2189 * Note: range checks here are not absolutely sufficient to
2190 * make us robust against malformed messages sent by drivers;
2191 * this is in keeping with the rest of IP's dlpi handling.
2192 * (Remember, it's coming from something else in the kernel
2193 * address space)
2194 */
2201 }
2203 /*
2204 * There are two types of acks we process here:
2205 * 1. acks in reply to a (first form) generic capability req
2206 * (no ENABLE flag set)
2207 * 2. acks in reply to a ENABLE capability req.
2208 * (ENABLE flag set)
2209 *
2210 * We process the subcapability passed as argument as follows:
2211 * 1 do initializations
2212 * 1.1 initialize nmp = NULL
2213 * 1.2 set need_sadb_dump to B_FALSE
2214 * 2 for each cipher in subcapability:
2215 * 2.1 if ENABLE flag is set:
2216 * 2.1.1 update per-ill ipsec capabilities info
2217 * 2.1.2 set need_sadb_dump to B_TRUE
2218 * 2.2 if ENABLE flag is not set:
2219 * 2.2.1 if nmp is NULL:
2220 * 2.2.1.1 allocate and initialize nmp
2221 * 2.2.1.2 init current pos in nmp
2222 * 2.2.2 copy current cipher to current pos in nmp
2223 * 2.2.3 set ENABLE flag in nmp
2224 * 2.2.4 update current pos
2225 * 3 if nmp is not equal to NULL, send enable request
2226 * 3.1 send capability request
2227 * 4 if need_sadb_dump is B_TRUE
2228 * 4.1 enable promiscuous on/off notifications
2229 * 4.2 call ill_dlpi_send(isub->dlcap) to send all
2230 * AH or ESP SA's to interface.
2231 */
2246 }
2252 /*
2253 * TBD: when we provide a way to disable capabilities
2254 * from above, need to manage the request-pending state
2255 * and fail if we were not expecting this ACK.
2256 */
2260 /*
2261 * Update IPsec capabilities for this ill
2262 */
2272 "ill_capability_ipsec_ack: "
2273 "could not enable IPsec Hardware "
2277 }
2278 }
2285 "ill_capability_ipsec_ack: "
2289 }
2302 "ill_capability_ipsec_ack: "
2306 }
2311 }
2313 /*
2314 * indicate that a capability was enabled, which
2315 * will be used below to kick off a SADB dump
2316 * to the ill.
2317 */
2327 /*
2328 * Sending the PROMISC_ON/OFF
2329 * notification request failed.
2330 * We cannot enable the algorithms
2331 * since the Provider will not
2332 * notify IP of promiscous mode
2333 * changes, which could lead
2334 * to leakage of packets.
2335 */
2337 "ill_capability_ipsec_ack: "
2338 "could not enable IPsec Hardware "
2342 }
2343 /* ptr to current output alg specifier */
2345 }
2347 /*
2348 * Copy current alg specifier, set ENABLE
2349 * flag, and advance to next output alg.
2350 * For now we enable all IPsec capabilities.
2351 */
2357 }
2359 /* move to next input algorithm specifier */
2362 }
2365 /*
2366 * nmp points to a DL_CAPABILITY_REQ message to enable
2367 * IPsec hardware acceleration.
2368 */
2372 /*
2373 * An acknowledgement corresponding to a request to
2374 * enable acceleration was received, notify SADB.
2375 */
2377 }
2379 /*
2380 * Given an mblk with enough space in it, create sub-capability entries for
2381 * DL_CAPAB_IPSEC_{AH,ESP} types which consist of previously-advertised
2382 * offloaded ciphers (both AUTH and ENCR) with their enable flags cleared,
2383 * in preparation for the reset the DL_CAPABILITY_REQ message.
2384 */
2385 static void
2388 {
2399 /* dl_capability_sub_t for "stype" */
2405 /* dl_capab_ipsec_t for "stype" */
2411 /* create entries for "stype" AUTH ciphers */
2422 }
2423 }
2424 /* create entries for "stype" ENCR ciphers */
2435 }
2436 }
2437 }
2439 /*
2440 * Macro to count number of 1s in a byte (8-bit word). The total count is
2441 * accumulated into the passed-in argument (sum). We could use SPARCv9's
2442 * POPC instruction, but our macro is more flexible for an arbitrary length
2443 * of bytes, such as {auth,encr}_hw_algs. These variables are currently
2444 * 256-bits long (MAX_IPSEC_ALGS), so if we know for sure that the length
2445 * stays that way, we can reduce the number of iterations required.
2446 */
2447 #define COUNT_1S(val, sum) { \
2448 uint8_t x = val & 0xff; \
2449 x = (x & 0x55) + ((x >> 1) & 0x55); \
2450 x = (x & 0x33) + ((x >> 2) & 0x33); \
2451 sum += (x & 0xf) + ((x >> 4) & 0xf); \
2452 }
2454 /* ARGSUSED */
2455 static void
2457 {
2472 /* Find out the number of ciphers for AH */
2477 }
2481 /* dl_capab_ipsec_t contains one dl_capab_ipsec_alg_t */
2484 }
2485 }
2487 /* Find out the number of ciphers for ESP */
2492 }
2496 /* dl_capab_ipsec_t contains one dl_capab_ipsec_alg_t */
2499 }
2500 }
2506 }
2513 }
2515 /*
2516 * Clear the capability flags for IPsec HA but retain the ill
2517 * capability structures since it's possible that another thread
2518 * is still referring to them. The structures only get deallocated
2519 * when we destroy the ill.
2520 *
2521 * Various places check the flags to see if the ill is capable of
2522 * hardware acceleration, and by clearing them we ensure that new
2523 * outbound IPsec packets are sent down encrypted.
2524 */
2527 /* Fill in DL_CAPAB_IPSEC_AH sub-capability entries */
2532 }
2534 /* Fill in DL_CAPAB_IPSEC_ESP sub-capability entries */
2539 }
2541 /*
2542 * At this point we've composed a bunch of sub-capabilities to be
2543 * encapsulated in a DL_CAPABILITY_REQ and later sent downstream
2544 * by the caller. Upon receiving this reset message, the driver
2545 * must stop inbound decryption (by destroying all inbound SAs)
2546 * and let the corresponding packets come in encrypted.
2547 */
2551 else
2553 }
2555 static void
2557 boolean_t encapsulated)
2558 {
2561 /*
2562 * If this DL_CAPABILITY_ACK came in as a response to our "reset"
2563 * DL_CAPABILITY_REQ, ignore it during this cycle. We've just
2564 * instructed the driver to disable its advertised capabilities,
2565 * so there's no point in accepting any response at this moment.
2566 */
2570 /*
2571 * Note that only the following two sub-capabilities may be
2572 * considered as "legacy", since their original definitions
2573 * do not incorporate the dl_mid_t module ID token, and hence
2574 * may require the use of the wrapper sub-capability.
2575 */
2581 }
2583 /*
2584 * For legacy sub-capabilities which don't incorporate a queue_t
2585 * pointer in their structures, discard them if we detect that
2586 * there are intermediate modules in between IP and the driver.
2587 */
2593 }
2623 }
2624 }
2626 /*
2627 * As part of negotiating polling capability, the driver tells us
2628 * the default (or normal) blanking interval and packet threshold
2629 * (the receive timer fires if blanking interval is reached or
2630 * the packet threshold is reached).
2631 *
2632 * As part of manipulating the polling interval, we always use our
2633 * estimated interval (avg service time * number of packets queued
2634 * on the squeue) but we try to blank for a minimum of
2635 * rr_normal_blank_time * rr_max_blank_ratio. We disable the
2636 * packet threshold during this time. When we are not in polling mode
2637 * we set the blank interval typically lower, rr_normal_pkt_cnt *
2638 * rr_min_blank_ratio but up the packet cnt by a ratio of
2639 * rr_min_pkt_cnt_ratio so that we are still getting chains if
2640 * possible although for a shorter interval.
2641 */
2642 #define RR_MAX_BLANK_RATIO 20
2643 #define RR_MIN_BLANK_RATIO 10
2644 #define RR_MAX_PKT_CNT_RATIO 3
2645 #define RR_MIN_PKT_CNT_RATIO 3
2647 /*
2648 * These can be tuned via /etc/system.
2649 */
2655 static mac_resource_handle_t
2657 {
2666 }
2678 uint_t normal_pkt_cnt =
2704 }
2705 }
2707 /*
2708 * We ran out of ILL_MAX_RINGS worth rx_ring structures. If
2709 * we have devices which can overwhelm this limit, ILL_MAX_RING
2710 * should be made configurable. Meanwhile it cause no panic because
2711 * driver will pass ip_input a NULL handle which will make
2712 * IP allocate the default squeue and Polling mode will not
2713 * be used for this ring.
2714 */
2720 }
2722 static boolean_t
2724 {
2733 "soft_ring enabled for ill=%s (%p) but data "
2736 }
2741 "polling enabled for ill=%s (%p) but data "
2744 }
2746 }
2750 /* Soft_Ring or polling is being re-enabled */
2760 }
2776 }
2778 /* Allocate space to hold ring table */
2783 }
2785 /*
2786 * ill_capability_dls_disable: disable soft_ring and/or polling
2787 * capability. Since any of the rings might already be in use, need
2788 * to call ip_squeue_clean_all() which gets behind the squeue to disable
2789 * direct calls if necessary.
2790 */
2791 static void
2793 {
2803 }
2806 }
2808 static void
2811 {
2812 uint_t size;
2824 /* Copy locally to get the members aligned */
2828 /* Get the tx function and handle from dld */
2839 }
2849 }
2851 /* initialize dl_capability_req_t */
2858 /* initialize dl_capability_sub_t */
2865 /* initialize dl_capab_dls_t to be sent down */
2878 }
2882 /*
2883 * nmp points to a DL_CAPABILITY_REQ message to
2884 * enable either soft_ring or polling
2885 */
2887 }
2889 static void
2891 {
2909 }
2917 else
2923 else
2928 else
2930 }
2932 /*
2933 * Process a soft_ring/poll capability negotiation ack received
2934 * from a DLS Provider.isub must point to the sub-capability
2935 * (DL_CAPAB_SOFT_RING/DL_CAPAB_POLL) of a DL_CAPABILITY_ACK message.
2936 */
2937 static void
2939 {
2950 /*
2951 * Note: range checks here are not absolutely sufficient to
2952 * make us robust against malformed messages sent by drivers;
2953 * this is in keeping with the rest of IP's dlpi handling.
2954 * (Remember, it's coming from something else in the kernel
2955 * address space)
2956 */
2962 }
2964 /*
2965 * There are two types of acks we process here:
2966 * 1. acks in reply to a (first form) generic capability req
2967 * (dls_flag will be set to SOFT_RING_CAPABLE or POLL_CAPABLE)
2968 * 2. acks in reply to a SOFT_RING_ENABLE or POLL_ENABLE
2969 * capability req.
2970 */
2975 "capability isn't as expected; pass-thru "
2978 /*
2979 * This is a capability renegotitation case.
2980 * The interface better be unusable at this
2981 * point other wise bad things will happen
2982 * if we disable direct calls on a running
2983 * and up interface.
2984 */
2986 }
2988 }
2992 /* Disable if unknown flag */
2999 /*
3000 * If the capability was already enabled, its safe
3001 * to disable it first to get rid of stale information
3002 * and then start enabling it again.
3003 */
3014 }
3021 }
3024 }
3025 }
3027 /*
3028 * Process a hardware checksum offload capability negotiation ack received
3029 * from a DLS Provider.isub must point to the sub-capability (DL_CAPAB_HCKSUM)
3030 * of a DL_CAPABILITY_ACK message.
3031 */
3032 static void
3034 {
3046 /*
3047 * Note: range checks here are not absolutely sufficient to
3048 * make us robust against malformed messages sent by drivers;
3049 * this is in keeping with the rest of IP's dlpi handling.
3050 * (Remember, it's coming from something else in the kernel
3051 * address space)
3052 */
3058 }
3060 /*
3061 * There are two types of acks we process here:
3062 * 1. acks in reply to a (first form) generic capability req
3063 * (no ENABLE flag set)
3064 * 2. acks in reply to a ENABLE capability req.
3065 * (ENABLE flag set)
3066 */
3071 "unsupported hardware checksum "
3075 }
3079 "checksum capability isn't as expected; pass-thru "
3082 }
3084 #define CURR_HCKSUM_CAPAB \
3085 (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 | \
3086 HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM)
3090 /* do ENABLE processing */
3093 KM_NOSLEEP);
3097 "could not enable hcksum version %d "
3101 }
3102 }
3111 /*
3112 * Enabling hardware checksum offload
3113 * Currently IP supports {TCP,UDP}/IPv4
3114 * partial and full cksum offload and
3115 * IPv4 header checksum offload.
3116 * Allocate new mblk which will
3117 * contain a new capability request
3118 * to enable hardware checksum offload.
3119 */
3120 uint_t size;
3131 }
3134 /* initialize dl_capability_req_t */
3143 /* initialize dl_capability_sub_t */
3147 /* initialize dl_capab_hcksum_t */
3154 /* Set ENABLE flag */
3158 /*
3159 * nmp points to a DL_CAPABILITY_REQ message to enable
3160 * hardware checksum acceleration.
3161 */
3167 }
3168 }
3170 static void
3172 {
3182 /*
3183 * Clear the capability flag for hardware checksum offload but
3184 * retain the ill_hcksum_capab structure since it's possible that
3185 * another thread is still referring to it. The structure only
3186 * gets deallocated when we destroy the ill.
3187 */
3197 }
3211 else
3213 }
3215 static void
3217 {
3229 /*
3230 * Note: range checks here are not absolutely sufficient to
3231 * make us robust against malformed messages sent by drivers;
3232 * this is in keeping with the rest of IP's dlpi handling.
3233 * (Remember, it's coming from something else in the kernel
3234 * address space)
3235 */
3241 }
3246 "unsupported ZEROCOPY sub-capability (version %d, "
3248 ZEROCOPY_VERSION_1);
3250 }
3254 "capability isn't as expected; pass-thru module(s) "
3257 }
3263 KM_NOSLEEP);
3267 "could not enable Zero-copy version %d "
3271 }
3272 }
3276 ZEROCOPY_VERSION_1));
3285 uint_t size;
3297 }
3300 /* initialize dl_capability_req_t */
3307 /* initialize dl_capability_sub_t */
3311 /* initialize dl_capab_zerocopy_t */
3317 ZEROCOPY_VERSION_1));
3319 /* set VMSAFE_MEM flag */
3322 /* nmp points to a DL_CAPABILITY_REQ message to enable zcopy */
3324 }
3325 }
3327 static void
3329 {
3339 /*
3340 * Clear the capability flag for Zero-copy but retain the
3341 * ill_zerocopy_capab structure since it's possible that another
3342 * thread is still referring to it. The structure only gets
3343 * deallocated when we destroy the ill.
3344 */
3354 }
3369 else
3371 }
3373 /*
3374 * Process Large Segment Offload capability negotiation ack received from a
3375 * DLS Provider. isub must point to the sub-capability (DL_CAPAB_LSO) of a
3376 * DL_CAPABILITY_ACK message.
3377 */
3378 static void
3380 {
3392 /*
3393 * Note: range checks here are not absolutely sufficient to
3394 * make us robust against malformed messages sent by drivers;
3395 * this is in keeping with the rest of IP's dlpi handling.
3396 * (Remember, it's coming from something else in the kernel
3397 * address space)
3398 */
3404 }
3413 }
3417 "capability isn't as expected; pass-thru module(s) "
3420 }
3426 KM_NOSLEEP);
3430 "could not enable LSO version %d "
3434 }
3435 }
3445 uint_t size;
3456 }
3459 /* initialize dl_capability_req_t */
3466 /* initialize dl_capability_sub_t */
3470 /* initialize dl_capab_lso_t */
3477 /* set ENABLE flag */
3480 /* nmp points to a DL_CAPABILITY_REQ message to enable LSO */
3486 }
3487 }
3490 static void
3492 {
3502 /*
3503 * Clear the capability flag for LSO but retain the
3504 * ill_lso_capab structure since it's possible that another
3505 * thread is still referring to it. The structure only gets
3506 * deallocated when we destroy the ill.
3507 */
3517 }
3531 else
3533 }
3535 /*
3536 * Consume a new-style hardware capabilities negotiation ack.
3537 * Called from ip_rput_dlpi_writer().
3538 */
3539 void
3541 {
3551 /* no new-style capabilities */
3554 /* make sure the driver supplied correct dl_sub_length */
3559 }
3561 #define SC(base, offset) (dl_capability_sub_t *)(((uchar_t *)(base))+(offset))
3562 /*
3563 * There are sub-capabilities. Process the ones we know about.
3564 * Loop until we don't have room for another sub-cap header..
3565 */
3578 }
3579 }
3580 #undef SC
3581 }
3583 /*
3584 * This routine is called to scan the fragmentation reassembly table for
3585 * the specified ILL for any packets that are starting to smell.
3586 * dead_interval is the maximum time in seconds that will be tolerated. It
3587 * will either be the value specified in ip_g_frag_timeout, or zero if the
3588 * ILL is shutting down and it is time to blow everything off.
3589 *
3590 * It returns the number of seconds (as a time_t) that the next frag timer
3591 * should be scheduled for, 0 meaning that the timer doesn't need to be
3592 * re-started. Note that the method of calculating next_timeout isn't
3593 * entirely accurate since time will flow between the time we grab
3594 * current_time and the time we schedule the next timeout. This isn't a
3595 * big problem since this is the timer for sending an ICMP reassembly time
3596 * exceeded messages, and it doesn't have to be exactly accurate.
3597 *
3598 * This function is
3599 * sometimes called as writer, although this is not required.
3600 */
3601 time_t
3603 {
3614 zoneid_t zoneid;
3621 /* Walk the frag hash table. */
3631 /*
3632 * There are some outstanding fragments
3633 * that will timeout later. Make note of
3634 * the time so that we can reschedule the
3635 * next timeout appropriately.
3636 */
3641 }
3643 }
3644 /* Time's up. Get it out of here. */
3652 /* Extra points for neatness. */
3655 }
3662 /*
3663 * We do not send any icmp message from here because
3664 * we currently are holding the ipfb_lock for this
3665 * hash chain. If we try and send any icmp messages
3666 * from here we may end up via a put back into ip
3667 * trying to get the same lock, causing a recursive
3668 * mutex panic. Instead we build a list and send all
3669 * the icmp messages after we have dropped the lock.
3670 */
3677 }
3684 }
3685 }
3688 }
3690 /*
3691 * Now need to send any icmp messages that we delayed from
3692 * above.
3693 */
3702 else
3712 }
3713 }
3715 ipaddr_t dst;
3723 else
3732 ipst);
3733 }
3734 }
3735 }
3736 /*
3737 * A non-dying ILL will use the return value to decide whether to
3738 * restart the frag timer, and for how long.
3739 */
3741 }
3743 /*
3744 * This routine is called when the approximate count of mblk memory used
3745 * for the specified ILL has exceeded max_count.
3746 */
3747 void
3749 {
3754 /*
3755 * If we are here within ip_min_frag_prune_time msecs remove
3756 * ill_frag_free_num_pkts oldest packets from each bucket and increment
3757 * ill_frag_free_num_pkts.
3758 */
3768 }
3772 /*
3773 * free ill_frag_free_num_pkts oldest packets from each bucket.
3774 */
3784 }
3786 }
3787 }
3788 /*
3789 * While the reassembly list for this ILL is too big, prune a fragment
3790 * queue by age, oldest first. Note that the per ILL count is
3791 * approximate, while the per frag hash bucket counts are accurate.
3792 */
3806 }
3809 }
3810 /* Refresh the per ILL count */
3815 }
3822 }
3824 }
3825 }
3827 /*
3828 * free 'free_cnt' fragmented packets starting at ipf.
3829 */
3830 void
3832 {
3849 }
3857 }
3862 }
3866 "ifconfig(1M) to manipulate the forwarding status of an interface."
3868 /*
3869 * For obsolete per-interface forwarding configuration;
3870 * called in response to ND_GET.
3871 */
3872 /* ARGSUSED */
3873 static int
3875 {
3882 }
3884 /*
3885 * For obsolete per-interface forwarding configuration;
3886 * called in response to ND_SET.
3887 */
3888 /* ARGSUSED */
3889 static int
3892 {
3902 }
3908 }
3910 /*
3911 * Set an ill's ILLF_ROUTER flag appropriately. If the ill is part of an
3912 * IPMP group, make sure all ill's in the group adopt the new policy. Send
3913 * up RTS_IFINFO routing socket messages for each interface whose flags we
3914 * change.
3915 */
3916 int
3918 {
3931 /*
3932 * If the ill is in an IPMP group, set the forwarding policy on all
3933 * members of the group to the same value.
3934 */
3948 else
3953 /* Notify routing socket listeners of this change. */
3955 }
3963 else
3968 /* Notify routing socket listeners of this change. */
3970 }
3973 }
3975 /*
3976 * Based on the ILLF_ROUTER flag of an ill, make sure all local nce's for
3977 * addresses assigned to the ill have the NCE_F_ISROUTER flag appropriately
3978 * set or clear.
3979 */
3980 static void
3982 {
3992 else
3996 }
3997 }
3998 }
4000 /*
4001 * Given an ill with a _valid_ name, add the ip_forwarding ndd variable
4002 * for this ill. Make sure the v6/v4 question has been answered about this
4003 * ill. The creation of this ndd variable is only for backwards compatibility.
4004 * The preferred way to control per-interface IP forwarding is through the
4005 * ILLF_ROUTER interface flag.
4006 */
4007 static int
4009 {
4017 else
4022 /*
4023 * Copies over the '\0'.
4024 * Note that strlen(suffix) is always bounded.
4025 */
4029 /*
4030 * Use of the nd table requires holding the reader lock.
4031 * Modifying the nd table thru nd_load/nd_unload requires
4032 * the writer lock.
4033 */
4037 /*
4038 * If the nd_load failed, it only meant that it could not
4039 * allocate a new bunch of room for further NDD expansion.
4040 * Because of that, the ill_ndd_name will be set to 0, and
4041 * this interface is at the mercy of the global ip_forwarding
4042 * variable.
4043 */
4047 }
4050 }
4052 /*
4053 * Intializes the context structure and returns the first ill in the list
4054 * cuurently start_list and end_list can have values:
4055 * MAX_G_HEADS Traverse both IPV4 and IPV6 lists.
4056 * IP_V4_G_HEAD Traverse IPV4 list only.
4057 * IP_V6_G_HEAD Traverse IPV6 list only.
4058 */
4060 /*
4061 * We don't check for CONDEMNED ills here. Caller must do that if
4062 * necessary under the ill lock.
4063 */
4064 ill_t *
4067 {
4075 /*
4076 * setup the lists to search
4077 */
4084 }
4092 /*
4093 * ill is guaranteed to be non NULL or ifp should have
4094 * not existed.
4095 */
4098 }
4100 }
4103 }
4105 /*
4106 * returns the next ill in the list. ill_first() must have been called
4107 * before calling ill_next() or bad things will happen.
4108 */
4110 /*
4111 * We don't check for CONDEMNED ills here. Caller must do that if
4112 * necessary under the ill lock.
4113 */
4114 ill_t *
4116 {
4126 }
4128 /* goto next ill_ifp in the list. */
4131 /* make sure not at end of circular list */
4137 }
4140 }
4142 /*
4143 * Check interface name for correct format which is name+ppa.
4144 * name can contain characters and digits, the right most digits
4145 * make up the ppa number. use of octal is not allowed, name must contain
4146 * a ppa, return pointer to the start of ppa.
4147 * In case of error return NULL.
4148 */
4151 {
4158 name--;
4161 len--;
4162 }
4164 /* empty string, all digits, or no trailing digits */
4168 name++;
4169 /* check for attempted use of octal */
4173 }
4175 /*
4176 * use avl tree to locate the ill.
4177 */
4181 {
4184 uint_t ppa;
4193 /*
4194 * get ppa ptr
4195 */
4198 else
4205 }
4214 /*
4215 * match is done on len - 1 as the name is not null
4216 * terminated it contains ppa in addition to the interface
4217 * name.
4218 */
4224 }
4225 }
4229 /*
4230 * Even the interface type does not exist.
4231 */
4235 }
4239 /*
4240 * The block comment at the start of ipif_down
4241 * explains the use of the macros used below
4242 */
4260 }
4263 }
4267 }
4269 /*
4270 * comparison function for use with avl.
4271 */
4272 static int
4274 {
4275 uint_t ppa;
4276 uint_t ill_ppa;
4282 /*
4283 * We want the ill with the lowest ppa to be on the
4284 * top.
4285 */
4291 }
4293 /*
4294 * remove an interface type from the global list.
4295 */
4296 static void
4298 {
4309 }
4311 /* Defined in ip_netinfo.c */
4314 /*
4315 * remove ill from the global list.
4316 */
4317 static void
4319 {
4335 }
4339 }
4341 /*
4342 * If the ill was never inserted into the AVL tree
4343 * we skip the if branch.
4344 */
4346 /*
4347 * remove from AVL tree and free ppa number
4348 */
4354 }
4357 }
4359 /*
4360 * Indicate ill is no longer in the list.
4361 */
4366 }
4368 /*
4369 * Run the unplumb hook after the NIC has disappeared from being
4370 * visible so that attempts to revalidate its existance will fail.
4371 *
4372 * This needs to be run inside the ill_g_lock perimeter to ensure
4373 * that the ordering of delivered events to listeners matches the
4374 * order of them in the kernel.
4375 */
4394 }
4395 }
4396 }
4398 /* Generate NE_UNPLUMB event for ill_name. */
4413 }
4419 }
4421 /*
4422 * allocate a ppa, if the number of plumbed interfaces of this type are
4423 * less than ill_no_arena do a linear search to find a unused ppa.
4424 * When the number goes beyond ill_no_arena switch to using an arena.
4425 * Note: ppa value of zero cannot be allocated from vmem_arena as it
4426 * is the return value for an error condition, so allocation starts at one
4427 * and is decremented by one.
4428 */
4429 static int
4431 {
4438 /*
4439 * Create an arena.
4440 */
4444 /* allocate what has already been assigned */
4453 /* minaddr */
4455 /* maxaddr */
4464 }
4465 }
4466 }
4484 /*
4485 * Most likely the allocation failed because
4486 * the requested ppa was in use.
4487 */
4490 }
4492 }
4494 /*
4495 * No arena is in use and not enough (>ill_no_arena) interfaces have
4496 * been plumbed to create one. Do a linear search to get a unused ppa.
4497 */
4503 }
4510 else
4512 }
4514 }
4517 }
4519 /*
4520 * Insert ill into the list of configured ill's. Once this function completes,
4521 * the ill is globally visible and is available through lookups. More precisely
4522 * this happens after the caller drops the ill_g_lock.
4523 */
4524 static int
4526 {
4541 else
4545 /*
4546 * Search for interface type based on name
4547 */
4552 }
4554 }
4556 /*
4557 * Interface type not found, create one.
4558 */
4561 ill_g_head_t ghead;
4563 /*
4564 * allocate ill_if_t structure
4565 */
4570 }
4581 /*
4582 * link the structure in the back to maintain order
4583 * of configuration for ifconfig output.
4584 */
4588 }
4598 }
4600 /*
4601 * When the ppa is choosen by the system, check that there is
4602 * enough space to insert ppa. if a specific ppa was passed in this
4603 * check is not required as the interface name passed in will have
4604 * the right ppa in it.
4605 */
4607 /*
4608 * UINT_MAX - 1 should fit in 10 chars, alloc 12 chars.
4609 */
4612 /*
4613 * convert ppa to string to calculate the amount of space
4614 * required for it in the name.
4615 */
4618 /* Do we have enough space to insert ppa ? */
4621 /* Free ppa and interface type struct */
4625 }
4629 }
4632 }
4633 }
4645 }
4647 /* Initialize the per phyint (per IPMP group) ipsq used for serialization */
4648 static boolean_t
4650 {
4653 /* Init the ipsq and impicitly enter as writer */
4666 #ifdef DEBUG
4668 IPSQ_STACK_DEPTH);
4669 #endif
4672 }
4674 /*
4675 * ill_init is called by ip_open when a device control stream is opened.
4676 * It does a few initializations, and shoots a DL_INFO_REQ message down
4677 * to the driver. The response is later picked up in ip_rput_dlpi and
4678 * used to set up default mechanisms for talking to the driver. (Always
4679 * called as writer.)
4680 *
4681 * If this function returns error, ip_open will call ip_close which in
4682 * turn will call ill_delete to clean up any memory allocated here that
4683 * is not yet freed.
4684 */
4685 int
4687 {
4693 /*
4694 * The ill is initialized to zero by mi_alloc*(). In addition
4695 * some fields already contain valid values, initialized in
4696 * ip_open(), before we reach here.
4697 */
4704 BPRI_HI);
4708 /*
4709 * Allocate sufficient space to contain our fragment hash table and
4710 * the device name.
4711 */
4717 }
4726 }
4733 }
4736 /*
4737 * For now pretend this is a v4 ill. We need to set phyint_ill*
4738 * at this point because of the following reason. If we can't
4739 * enter the ipsq at some point and cv_wait, the writer that
4740 * wakes us up tries to locate us using the list of all phyints
4741 * in an ipsq and the ills from the phyint thru the phyint_ill*.
4742 * If we don't set it now, we risk a missed wakeup.
4743 */
4753 }
4758 /* Frag queue limit stuff */
4768 /*
4769 * Initialize IPv6 configuration variables. The IP module is always
4770 * opened as an IPv4 module. Instead tracking down the cases where
4771 * it switches to do ipv6, we'll just initialize the IPv6 configuration
4772 * here for convenience, this has no effect until the ill is set to do
4773 * IPv6.
4774 */
4781 /* Send down the Info Request to the driver. */
4793 }
4795 /*
4796 * ill_dls_info
4797 * creates datalink socket info from the device.
4798 */
4799 int
4801 {
4818 }
4820 /*
4821 * ill_xarp_info
4822 * creates xarp info from the device.
4823 */
4824 static int
4826 {
4835 }
4837 static int
4839 {
4841 netstackid_t stackid;
4862 }
4867 }
4870 /*
4871 * Has ifindex been plumbed already.
4872 * Compares both phyint_ifindex and phyint_group_ifindex.
4873 */
4874 static boolean_t
4876 {
4881 /*
4882 * Indexes are stored in the phyint - a common structure
4883 * to both IPv4 and IPv6.
4884 */
4892 }
4894 }
4896 /* Pick a unique ifindex */
4897 boolean_t
4899 {
4900 uint_t starting_index;
4905 /* Reached the uint_t limit Next time wrap */
4907 }
4909 }
4911 /*
4912 * Start reusing unused indexes. Note that we hold the ill_g_lock
4913 * at this point and don't want to call any function that attempts
4914 * to get the lock again.
4915 */
4920 /* found unused index - use it */
4923 }
4924 }
4926 /*
4927 * all interface indicies are inuse.
4928 */
4930 }
4932 /*
4933 * Assign a unique interface index for the phyint.
4934 */
4935 static boolean_t
4937 {
4940 }
4942 /*
4943 * Return a pointer to the ill which matches the supplied name. Note that
4944 * the ill name length includes the null termination character. (May be
4945 * called as writer.)
4946 * If do_alloc and the interface is "lo0" it will be automatically created.
4947 * Cannot bump up reference on condemned ills. So dup detect can't be done
4948 * using this func.
4949 */
4950 ill_t *
4954 {
4958 boolean_t isloopback;
4960 in6_addr_t ov6addr;
4970 /*
4971 * Couldn't find it. Does this happen to be a lookup for the
4972 * loopback device and are we allowed to allocate it?
4973 */
4983 }
4985 /* Create the loopback device on demand */
4995 /*
4996 * For exclusive stacks we set the zoneid to zero
4997 * to make IP operate as if in the global zone.
4998 */
5007 else
5011 /* Add room for tcp+ip headers */
5017 }
5021 /*
5022 * ipif_loopback_name can't be pointed at directly because its used
5023 * by both the ipv4 and ipv6 interfaces. When the ill is removed
5024 * from the glist, ill_glist_delete() sets the first character of
5025 * ill_name to '\0'.
5026 */
5030 /* Set ill_name_set for ill_phyint_reinit to work properly */
5038 /* No resolver here. */
5041 /* Initialize the ipsq */
5048 #ifdef DEBUG
5050 #endif
5058 /* Set up default loopback address and mask. */
5075 }
5077 /*
5078 * Chain us in at the end of the ill list. hold the ill
5079 * before we make it globally visible. 1 for the lookup.
5080 */
5093 /* Let SCTP know so that it can add this to its list */
5096 /*
5097 * We have already assigned ipif_v6lcl_addr above, but we need to
5098 * call sctp_update_ipif_addr() after SCTP_ILL_INSERT, which
5099 * requires to be after ill_glist_insert() since we need the
5100 * ill_index set. Pass on ipv6_loopback as the old address.
5101 */
5104 /*
5105 * If the ipsq was changed in ill_phyint_reinit free the old ipsq.
5106 */
5108 /* Loopback ills aren't in any IPMP group */
5111 }
5113 /*
5114 * Delay this till the ipif is allocated as ipif_allocate
5115 * de-references ill_phyint for getting the ifindex. We
5116 * can't do this before ipif_allocate because ill_phyint_reinit
5117 * -> phyint_assign_ifindex expects ipif to be present.
5118 */
5124 /* Export loopback interface statistics */
5131 loopback_kstat_update;
5137 netstack_stackid;
5139 }
5140 }
5147 done:
5156 }
5158 }
5163 }
5168 }
5170 /*
5171 * For IPP calls - use the ip_stack_t for global stack.
5172 */
5173 ill_t *
5176 {
5184 }
5189 }
5191 /*
5192 * Return a pointer to the ill which matches the index and IP version type.
5193 */
5194 ill_t *
5197 {
5208 /*
5209 * Indexes are stored in the phyint - a common structure
5210 * to both IPv4 and IPv6.
5211 */
5218 /*
5219 * The block comment at the start of ipif_down
5220 * explains the use of the macros used below
5221 */
5241 }
5244 }
5245 }
5250 }
5252 /*
5253 * Return the ifindex next in sequence after the passed in ifindex.
5254 * If there is no next ifindex for the given protocol, return 0.
5255 */
5256 uint_t
5258 {
5261 uint_t ifindex;
5272 }
5277 /*
5278 * If we're not returning the first interface in the tree
5279 * and we still haven't moved past the phyint_t that
5280 * corresponds to index, avl_walk needs to be called again
5281 */
5293 }
5294 }
5295 }
5301 else
5305 }
5308 /*
5309 * Return the ifindex for the named interface.
5310 * If there is no next ifindex for the interface, return 0.
5311 */
5312 uint_t
5314 {
5317 uint_t ifindex;
5325 }
5332 }
5335 /*
5336 * Obtain a reference to the ill. The ill_refcnt is a dynamic refcnt
5337 * that gives a running thread a reference to the ill. This reference must be
5338 * released by the thread when it is done accessing the ill and related
5339 * objects. ill_refcnt can not be used to account for static references
5340 * such as other structures pointing to an ill. Callers must generally
5341 * check whether an ill can be refheld by using ILL_CAN_LOOKUP macros
5342 * or be sure that the ill is not being deleted or changing state before
5343 * calling the refhold functions. A non-zero ill_refcnt ensures that the
5344 * ill won't change any of its critical state such as address, netmask etc.
5345 */
5346 void
5348 {
5353 }
5355 void
5357 {
5361 }
5363 int
5365 {
5371 }
5374 }
5376 /*
5377 * Must not be called while holding any locks. Otherwise if this is
5378 * the last reference to be released, there is a chance of recursive mutex
5379 * panic due to ill_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
5380 * to restart an ioctl.
5381 */
5382 void
5384 {
5390 /* Every ire pointing to the ill adds 1 to ill_refcnt */
5393 }
5395 /* Drops the ill_lock */
5397 }
5399 /*
5400 * Obtain a weak reference count on the ill. This reference ensures the
5401 * ill won't be freed, but the ill may change any of its critical state
5402 * such as netmask, address etc. Returns an error if the ill has started
5403 * closing.
5404 */
5405 boolean_t
5407 {
5412 }
5416 }
5418 void
5420 {
5426 }
5428 /*
5429 * Named Dispatch routine to produce a formatted report on all ILLs.
5430 * This report is accessed by using the ndd utility to "get" ND variable
5431 * "ip_ill_status".
5432 */
5433 /* ARGSUSED */
5434 int
5436 {
5438 ill_walk_context_t ctx;
5444 "ILL " MI_COL_HDRPAD_STR
5445 /* 01234567[89ABCDEF] */
5446 "rq " MI_COL_HDRPAD_STR
5447 /* 01234567[89ABCDEF] */
5448 "wq " MI_COL_HDRPAD_STR
5449 /* 01234567[89ABCDEF] */
5451 /* 12345 12345 123 xxxxxxxx */
5457 MI_COL_PTRFMT_STR MI_COL_PTRFMT_STR MI_COL_PTRFMT_STR
5462 }
5466 }
5468 /*
5469 * Named Dispatch routine to produce a formatted report on all IPIFs.
5470 * This report is accessed by using the ndd utility to "get" ND variable
5471 * "ip_ipif_status".
5472 */
5473 /* ARGSUSED */
5474 int
5476 {
5488 zoneid_t zoneid;
5489 ill_walk_context_t ctx;
5516 MI_COL_PTRFMT_STR
5523 buf,
5529 /* Tack on text strings for any flags. */
5535 }
5550 }
5551 }
5554 }
5556 /*
5557 * ip_ll_subnet_defaults is called when we get the DL_INFO_ACK back from the
5558 * driver. We construct best guess defaults for lower level information that
5559 * we need. If an interface is brought up without injection of any overriding
5560 * information from outside, we have to be ready to go with these defaults.
5561 * When we get the first DL_INFO_ACK (from ip_open() sending a DL_INFO_REQ)
5562 * we primarely want the dl_provider_style.
5563 * The subsequent DL_INFO_ACK is received after doing a DL_ATTACH and DL_BIND
5564 * at which point we assume the other part of the information is valid.
5565 */
5566 void
5568 {
5571 t_scalar_t sap_length;
5578 /*
5579 * Till the ill is fully up ILL_CHANGING will be set and
5580 * the ill is not globally visible. So no need for a lock.
5581 */
5589 }
5592 /*
5593 * When the new DLPI stuff is ready we'll pull lengths
5594 * from dlia.
5595 */
5599 brdcst_addr_length);
5602 }
5612 }
5626 /*
5627 * Allocate the first ipif on this ill. We don't delay it
5628 * further as ioctl handling assumes atleast one ipif to
5629 * be present.
5630 *
5631 * At this point we don't know whether the ill is v4 or v6.
5632 * We will know this whan the SIOCSLIFNAME happens and
5633 * the correct value for ill_isv6 will be assigned in
5634 * ipif_set_values(). We need to hold the ill lock and
5635 * clear the ILL_LL_SUBNET_PENDING flag and atomically do
5636 * the wakeup.
5637 */
5648 }
5650 /*
5651 * We know whether it is IPv4 or IPv6 now, as this is the
5652 * second DL_INFO_ACK we are recieving in response to the
5653 * DL_INFO_REQ sent in ipif_set_values.
5654 */
5657 else
5659 /*
5660 * Set ipif_mtu which is used to set the IRE's
5661 * ire_max_frag value. The driver could have sent
5662 * a different mtu from what it sent last time. No
5663 * need to call ipif_mtu_change because IREs have
5664 * not yet been created.
5665 */
5667 /*
5668 * Clear all the flags that were set based on ill_bcast_addr_length
5669 * and ill_phys_addr_length (in ipif_set_values) as these could have
5670 * changed now and we need to re-evaluate.
5671 */
5675 /*
5676 * Free ill_resolver_mp and ill_bcast_mp as things could have
5677 * changed now.
5678 */
5686 else
5695 /*
5696 * Note: xresolv interfaces will eventually need NOARP
5697 * set here as well, but that will require those
5698 * external resolvers to have some knowledge of
5699 * that flag and act appropriately. Not to be changed
5700 * at present.
5701 */
5703 else
5711 /* pt-pt supports multicast. */
5714 }
5715 }
5723 /*
5724 * Later detect lack of DLPI driver multicast
5725 * capability by catching DL_ENABMULTI errors in
5726 * ip_rput_dlpi.
5727 */
5731 }
5732 /* By default an interface does not support any CoS marking */
5735 /*
5736 * If we get QoS information in DL_INFO_ACK, the device supports
5737 * some form of CoS marking, set ILLF_COS_ENABLED.
5738 */
5743 }
5745 /* Clear any previous error indication. */
5748 }
5750 /*
5751 * Perform various checks to verify that an address would make sense as a
5752 * local, remote, or subnet interface address.
5753 */
5754 static boolean_t
5756 {
5757 ipaddr_t net_mask;
5759 /*
5760 * Don't allow all zeroes, all ones or experimental address, but allow
5761 * all ones netmask.
5762 */
5765 /* A given netmask overrides the "guess" netmask */
5771 }
5776 }
5778 #define V6_IPIF_LINKLOCAL(p) \
5779 IN6_IS_ADDR_LINKLOCAL(&(p)->ipif_v6lcl_addr)
5781 /*
5782 * Compare two given ipifs and check if the second one is better than
5783 * the first one using the order of preference (not taking deprecated
5784 * into acount) specified in ipif_lookup_multicast().
5785 */
5786 static boolean_t
5788 {
5789 /* Check the least preferred first. */
5791 /* If both ipifs are the same, use the first one. */
5794 else
5796 }
5798 /* For IPv6, check for link local address. */
5802 /* The second one is equal or less preferred. */
5806 }
5807 }
5809 /* Then check for point to point interface. */
5817 }
5818 }
5820 /* old_ipif is a normal interface, so no need to use the new one. */
5822 }
5824 /*
5825 * Find any non-virtual, not condemned, and up multicast capable interface
5826 * given an IP instance and zoneid. Order of preference is:
5827 *
5828 * 1. normal
5829 * 1.1 normal, but deprecated
5830 * 2. point to point
5831 * 2.1 point to point, but deprecated
5832 * 3. link local
5833 * 3.1 link local, but deprecated
5834 * 4. loopback.
5835 */
5836 ipif_t *
5838 {
5840 ill_walk_context_t ctx;
5848 else
5857 }
5864 }
5868 }
5870 /*
5871 * Found one candidate. If it is deprecated,
5872 * remember it in dep_ipif. If it is not deprecated,
5873 * remember it in saved_ipif.
5874 */
5879 isv6)) {
5880 /*
5881 * If the previous dep_ipif does not
5882 * belong to the same ill, we've done
5883 * a ipif_refhold() on it. So we need
5884 * to release it.
5885 */
5889 }
5891 }
5899 }
5900 }
5901 }
5902 /*
5903 * Before going to the next ill, do a ipif_refhold() on the
5904 * saved ones.
5905 */
5911 }
5914 /*
5915 * If we have only the saved_ipif, return it. But if we have both
5916 * saved_ipif and dep_ipif, check to see which one is better.
5917 */
5926 }
5927 }
5931 }
5932 }
5934 /*
5935 * This function is called when an application does not specify an interface
5936 * to be used for multicast traffic (joining a group/sending data). It
5937 * calls ire_lookup_multi() to look for an interface route for the
5938 * specified multicast group. Doing this allows the administrator to add
5939 * prefix routes for multicast to indicate which interface to be used for
5940 * multicast traffic in the above scenario. The route could be for all
5941 * multicast (224.0/4), for a single multicast group (a /32 route) or
5942 * anything in between. If there is no such multicast route, we just find
5943 * any multicast capable interface and return it. The returned ipif
5944 * is refhold'ed.
5945 */
5946 ipif_t *
5948 {
5958 }
5961 }
5963 /*
5964 * Look for an ipif with the specified interface address and destination.
5965 * The destination address is used only for matching point-to-point interfaces.
5966 */
5967 ipif_t *
5970 {
5973 ill_walk_context_t ctx;
5979 /*
5980 * First match all the point-to-point interfaces
5981 * before looking at non-point-to-point interfaces.
5982 * This is done to avoid returning non-point-to-point
5983 * ipif instead of unnumbered point-to-point ipif.
5984 */
5992 /* Allow the ipif to be down */
5996 /*
5997 * The block comment at the start of ipif_down
5998 * explains the use of the macros used below
5999 */
6012 ill);
6018 }
6019 }
6020 }
6023 }
6026 /* lookup the ipif based on interface address */
6028 ipst);
6031 }
6033 /*
6034 * Look for an ipif with the specified address. For point-point links
6035 * we look for matches on either the destination address and the local
6036 * address, but we ignore the check on the local address if IPIF_UNNUMBERED
6037 * is set.
6038 * Matches on a specific ill if match_ill is set.
6039 */
6040 ipif_t *
6043 {
6048 ill_walk_context_t ctx;
6054 /*
6055 * Repeat twice, first based on local addresses and
6056 * next time for pointopoint.
6057 */
6058 repeat:
6063 }
6072 /* Allow the ipif to be down */
6077 /*
6078 * The block comment at the start of ipif_down
6079 * explains the use of the macros used below
6080 */
6093 ill);
6099 }
6100 }
6101 }
6104 }
6106 /* If we already did the ptp case, then we are done */
6112 }
6115 }
6117 /*
6118 * Look for an ipif with the specified address. For point-point links
6119 * we look for matches on either the destination address and the local
6120 * address, but we ignore the check on the local address if IPIF_UNNUMBERED
6121 * is set.
6122 * Matches on a specific ill if match_ill is set.
6123 * Return the zoneid for the ipif which matches. ALL_ZONES if no match.
6124 */
6125 zoneid_t
6127 {
6128 zoneid_t zoneid;
6132 ill_walk_context_t ctx;
6135 /*
6136 * Repeat twice, first based on local addresses and
6137 * next time for pointopoint.
6138 */
6139 repeat:
6144 }
6148 /* Allow the ipif to be down */
6157 /*
6158 * If ipif_zoneid was ALL_ZONES then we have
6159 * a trusted extensions shared IP address.
6160 * In that case GLOBAL_ZONEID works to send.
6161 */
6165 }
6166 }
6168 }
6170 /* If we already did the ptp case, then we are done */
6174 }
6177 }
6179 /*
6180 * Look for an ipif that matches the specified remote address i.e. the
6181 * ipif that would receive the specified packet.
6182 * First look for directly connected interfaces and then do a recursive
6183 * IRE lookup and pick the first ipif corresponding to the source address in the
6184 * ire.
6185 * Returns: held ipif
6186 */
6187 ipif_t *
6189 {
6196 /*
6197 * Someone could be changing this ipif currently or change it
6198 * after we return this. Thus a few packets could use the old
6199 * old values. However structure updates/creates (ire, ilg, ilm etc)
6200 * will atomically be updated or cleaned up with the new value
6201 * Thus we don't need a lock to check the flags or other attrs below.
6202 */
6210 /* Allow the ipif to be down */
6218 }
6223 }
6224 }
6229 /*
6230 * The callers of this function wants to know the
6231 * interface on which they have to send the replies
6232 * back. For IRE_CACHES that have ire_stq and ire_ipif
6233 * derived from different ills, we really don't care
6234 * what we return here.
6235 */
6241 }
6243 }
6244 /* Pick the first interface */
6247 }
6249 /*
6250 * This func does not prevent refcnt from increasing. But if
6251 * the caller has taken steps to that effect, then this func
6252 * can be used to determine whether the ill has become quiescent
6253 */
6254 boolean_t
6256 {
6264 }
6265 }
6269 }
6271 }
6273 /*
6274 * This func does not prevent refcnt from increasing. But if
6275 * the caller has taken steps to that effect, then this func
6276 * can be used to determine whether the ipif has become quiescent
6277 */
6278 static boolean_t
6280 {
6287 }
6293 }
6295 /* This is the last ipif going down or being deleted on this ill */
6298 }
6301 }
6303 /*
6304 * This func does not prevent refcnt from increasing. But if
6305 * the caller has taken steps to that effect, then this func
6306 * can be used to determine whether the ipifs marked with IPIF_MOVING
6307 * have become quiescent and can be moved in a failover/failback.
6308 */
6311 {
6320 }
6321 }
6322 }
6324 }
6326 /*
6327 * The ipif/ill/ire has been refreled. Do the tail processing.
6328 * Determine if the ipif or ill in question has become quiescent and if so
6329 * wakeup close and/or restart any queued pending ioctl that is waiting
6330 * for the ipif_down (or ill_down)
6331 */
6332 void
6334 {
6345 /* ill_close may be waiting */
6347 }
6349 /* ipsq can't change because ill_lock is held */
6352 /* Not waiting for anything, just return. */
6355 }
6358 /*
6359 * ipif->ipif_refcnt must go down to zero for restarting REMOVEIF.
6360 * Last ipif going down needs to down the ill, so ill_ire_cnt must
6361 * be zero for restarting an ioctl that ends up downing the ill.
6362 */
6365 /* The ioctl is pending on some other ill. */
6368 }
6376 }
6381 /*
6382 * case ILL_FREE arises only for loopback. otherwise ill_delete
6383 * waits synchronously in ip_close, and no message is queued in
6384 * ipsq_pending_mp at all in this case
6385 */
6389 }
6397 }
6403 }
6405 /*
6406 * Incr refcnt for the qwriter_ip call below which
6407 * does a refrele
6408 */
6415 /*
6416 * NOTE: all of the qwriter_ip() calls below use CUR_OP since
6417 * we can only get here when the current operation decides it
6418 * it needs to quiesce via ipsq_pending_mp_add().
6419 */
6423 /*
6424 * For now, only DL_NOTIFY_IND messages can use this facility.
6425 */
6436 }
6442 B_TRUE);
6454 }
6455 }
6457 #ifdef DEBUG
6458 /* Reuse trace buffer from beginning (if reached the end) and record trace */
6459 static void
6461 {
6463 uint_t lastref;
6466 lastref++;
6473 }
6475 static void
6477 {
6482 }
6484 /*
6485 * Find or create the per-thread hash table used to track object references.
6486 * The ipst argument is NULL if we shouldn't allocate.
6487 *
6488 * Accesses per-thread data, so there's no need to lock here.
6489 */
6492 {
6505 /*
6506 * We use mod_hash_create_extended here rather than the more
6507 * obvious mod_hash_create_ptrhash because the latter has a
6508 * hard-coded KM_SLEEP, and we'd prefer to fail rather than
6509 * block.
6510 */
6520 }
6523 /*
6524 * We trace ills, ipifs, ires, and nces. All of these are
6525 * per-IP-stack, so the lock on the thread list is as well.
6526 */
6532 }
6534 }
6536 boolean_t
6538 {
6541 mod_hash_val_t val;
6546 /*
6547 * Attempt to locate the trace buffer for this obj and thread.
6548 * If it does not exist, then allocate a new trace buffer and
6549 * insert into the hash.
6550 */
6561 }
6564 }
6572 }
6574 /*
6575 * For the purpose of tracing a reference release, we assume that global
6576 * tracing is always on and that the same thread initiated the reference hold
6577 * is releasing.
6578 */
6579 void
6581 {
6585 mod_hash_val_t val;
6595 }
6597 /*
6598 * If tracing has been disabled, then we assume that the reference counts are
6599 * now useless, and we clear them out before destroying the entries.
6600 */
6601 void
6603 {
6606 mod_hash_val_t val;
6620 }
6621 }
6623 }
6625 void
6627 {
6636 }
6637 }
6639 void
6641 {
6646 }
6648 void
6650 {
6659 }
6660 }
6662 void
6664 {
6669 }
6671 /*
6672 * Called when ipif is unplumbed or when memory alloc fails. Note that on
6673 * failure, ipif_trace_disable is set.
6674 */
6675 static void
6677 {
6679 }
6681 /*
6682 * Called when ill is unplumbed or when memory alloc fails. Note that on
6683 * failure, ill_trace_disable is set.
6684 */
6685 static void
6687 {
6689 }
6692 void
6694 {
6698 }
6700 void
6702 {
6710 }
6712 /*
6713 * Must not be called while holding any locks. Otherwise if this is
6714 * the last reference to be released there is a chance of recursive mutex
6715 * panic due to ipif_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
6716 * to restart an ioctl.
6717 */
6718 void
6720 {
6732 }
6734 /* Drops the ill_lock */
6736 }
6738 ipif_t *
6740 {
6751 }
6754 }
6756 /*
6757 * TODO: make this table extendible at run time
6758 * Return a pointer to the mac type info for 'mac_type'
6759 */
6762 {
6769 }
6771 /*
6772 * ip_rt_add is called to add an IPv4 route to the forwarding table.
6773 * ipif_arg is passed in to associate it with the correct interface.
6774 * We may need to restart this operation if the ipif cannot be looked up
6775 * due to an exclusive operation that is currently in progress. The restart
6776 * entry point is specified by 'func'
6777 */
6778 int
6783 {
6788 uint_t type;
6800 /*
6801 * If this is the case of RTF_HOST being set, then we set the netmask
6802 * to all ones (regardless if one was supplied).
6803 */
6807 /*
6808 * Prevent routes with a zero gateway from being created (since
6809 * interfaces can currently be plumbed and brought up no assigned
6810 * address).
6811 */
6814 /*
6815 * Get the ipif, if any, corresponding to the gw_addr
6816 */
6818 ipst);
6823 }
6830 }
6837 }
6839 /*
6840 * GateD will attempt to create routes with a loopback interface
6841 * address as the gateway and with RTF_GATEWAY set. We allow
6842 * these routes to be added, but create them as interface routes
6843 * since the gateway is an interface address.
6844 */
6856 }
6867 NULL,
6871 ipif,
6878 NULL,
6879 NULL,
6880 ipst);
6886 }
6894 }
6895 }
6897 /*
6898 * Traditionally, interface routes are ones where RTF_GATEWAY isn't set
6899 * and the gateway address provided is one of the system's interface
6900 * addresses. By using the routing socket interface and supplying an
6901 * RTA_IFP sockaddr with an interface index, an alternate method of
6902 * specifying an interface route to be created is available which uses
6903 * the interface index that specifies the outgoing interface rather than
6904 * the address of an outgoing interface (which may not be able to
6905 * uniquely identify an interface). When coupled with the RTF_GATEWAY
6906 * flag, routes can be specified which not only specify the next-hop to
6907 * be used when routing to a certain prefix, but also which outgoing
6908 * interface should be used.
6909 *
6910 * Previously, interfaces would have unique addresses assigned to them
6911 * and so the address assigned to a particular interface could be used
6912 * to identify a particular interface. One exception to this was the
6913 * case of an unnumbered interface (where IPIF_UNNUMBERED was set).
6914 *
6915 * With the advent of IPv6 and its link-local addresses, this
6916 * restriction was relaxed and interfaces could share addresses between
6917 * themselves. In fact, typically all of the link-local interfaces on
6918 * an IPv6 node or router will have the same link-local address. In
6919 * order to differentiate between these interfaces, the use of an
6920 * interface index is necessary and this index can be carried inside a
6921 * RTA_IFP sockaddr (which is actually a sockaddr_dl). One restriction
6922 * of using the interface index, however, is that all of the ipif's that
6923 * are part of an ill have the same index and so the RTA_IFP sockaddr
6924 * cannot be used to differentiate between ipif's (or logical
6925 * interfaces) that belong to the same ill (physical interface).
6926 *
6927 * For example, in the following case involving IPv4 interfaces and
6928 * logical interfaces
6929 *
6930 * 192.0.2.32 255.255.255.224 192.0.2.33 U if0
6931 * 192.0.2.32 255.255.255.224 192.0.2.34 U if0:1
6932 * 192.0.2.32 255.255.255.224 192.0.2.35 U if0:2
6933 *
6934 * the ipif's corresponding to each of these interface routes can be
6935 * uniquely identified by the "gateway" (actually interface address).
6936 *
6937 * In this case involving multiple IPv6 default routes to a particular
6938 * link-local gateway, the use of RTA_IFP is necessary to specify which
6939 * default route is of interest:
6940 *
6941 * default fe80::123:4567:89ab:cdef U if0
6942 * default fe80::123:4567:89ab:cdef U if1
6943 */
6945 /* RTF_GATEWAY not set */
6955 }
6957 /*
6958 * As the interface index specified with the RTA_IFP sockaddr is
6959 * the same for all ipif's off of an ill, the matching logic
6960 * below uses MATCH_IRE_ILL if such an index was specified.
6961 * This means that routes sharing the same prefix when added
6962 * using a RTA_IFP sockaddr must have distinct interface
6963 * indices (namely, they must be on distinct ill's).
6964 *
6965 * On the other hand, since the gateway address will usually be
6966 * different for each ipif on the system, the matching logic
6967 * uses MATCH_IRE_IPIF in the case of a traditional interface
6968 * route. This means that interface routes for the same prefix
6969 * can be created if they belong to distinct ipif's and if a
6970 * RTA_IFP sockaddr is not present.
6971 */
6976 }
6980 /*
6981 * Check the ipif corresponding to the gw_addr
6982 */
6986 }
6989 /*
6990 * We check for an existing entry at this point.
6991 *
6992 * Since a netmask isn't passed in via the ioctl interface
6993 * (SIOCADDRT), we don't check for a matching netmask in that
6994 * case.
6995 */
7005 }
7010 /*
7011 * Create a copy of the IRE_LOOPBACK,
7012 * IRE_IF_NORESOLVER or IRE_IF_RESOLVER with
7013 * the modified address and netmask.
7014 */
7019 NULL,
7021 NULL,
7022 NULL,
7023 stq,
7025 ipif,
7029 flags,
7031 NULL,
7032 NULL,
7033 ipst);
7038 }
7040 /*
7041 * Some software (for example, GateD and Sun Cluster) attempts
7042 * to create (what amount to) IRE_PREFIX routes with the
7043 * loopback address as the gateway. This is primarily done to
7044 * set up prefixes with the RTF_REJECT flag set (for example,
7045 * when generating aggregate routes.)
7046 *
7047 * If the IRE type (as defined by ipif->ipif_net_type) is
7048 * IRE_LOOPBACK, then we map the request into a
7049 * IRE_IF_NORESOLVER.
7050 *
7051 * Needless to say, the real IRE_LOOPBACK is NOT created by this
7052 * routine, but rather using ire_create() directly.
7053 *
7054 */
7062 /*
7063 * In the result of failure, ire_add() will have already
7064 * deleted the ire in question, so there is no need to
7065 * do that here.
7066 */
7070 }
7074 }
7076 /*
7077 * Get an interface IRE for the specified gateway.
7078 * If we don't have an IRE_IF_NORESOLVER or IRE_IF_RESOLVER for the
7079 * gateway, it is currently unreachable and we fail the request
7080 * accordingly.
7081 */
7090 /*
7091 * We create one of three types of IREs as a result of this request
7092 * based on the netmask. A netmask of all ones (which is automatically
7093 * assumed when RTF_HOST is set) results in an IRE_HOST being created.
7094 * An all zeroes netmask implies a default route so an IRE_DEFAULT is
7095 * created. Otherwise, an IRE_PREFIX route is created for the
7096 * destination prefix.
7097 */
7102 else
7105 /* check for a duplicate entry */
7113 }
7115 /* Security attribute exists */
7117 tsol_gcgrp_addr_t ga;
7119 /* find or create the gateway credentials group */
7123 /* we hold reference to it upon success */
7128 }
7130 /*
7131 * Create and add the security attribute to the group; a
7132 * reference to the group is made upon allocating a new
7133 * entry successfully. If it finds an already-existing
7134 * entry for the security attribute in the group, it simply
7135 * returns it and no new reference is made to the group.
7136 */
7139 /* release reference held by gcgrp_lookup */
7143 }
7144 }
7146 /* Create the IRE. */
7150 /* src address assigned by the caller? */
7159 ipif_arg,
7163 flags,
7166 NULL,
7167 ipst);
7169 /*
7170 * The ire holds a reference to the 'gc' and the 'gc' holds a
7171 * reference to the 'gcgrp'. We can now release the extra reference
7172 * the 'gcgrp' acquired in the gcgrp_lookup, if it was not used.
7173 */
7181 }
7183 /*
7184 * POLICY: should we allow an RTF_HOST with address INADDR_ANY?
7185 * SUN/OS socket stuff does but do we really want to allow 0.0.0.0?
7186 */
7188 /* Add the new IRE. */
7191 /*
7192 * In the result of failure, ire_add() will have already
7193 * deleted the ire in question, so there is no need to
7194 * do that here.
7195 */
7198 }
7201 /*
7202 * Invoke the CGTP (multirouting) filtering module
7203 * to add the dst address in the filtering database.
7204 * Replicated inbound packets coming from that address
7205 * will be filtered to discard the duplicates.
7206 * It is not necessary to call the CGTP filter hook
7207 * when the dst address is a broadcast or multicast,
7208 * because an IP source address cannot be a broadcast
7209 * or a multicast.
7210 */
7217 }
7230 }
7231 }
7232 }
7234 /*
7235 * Now that the prefix IRE entry has been created, delete any
7236 * existing gateway IRE cache entries as well as any IRE caches
7237 * using the gateway, and force them to be created through
7238 * ip_newroute.
7239 */
7243 }
7245 save_ire:
7248 }
7250 /*
7251 * Save enough information so that we can recreate the IRE if
7252 * the interface goes down and then up. The metrics associated
7253 * with the route will be saved as well when rts_setmetrics() is
7254 * called after the IRE has been created. In the case where
7255 * memory cannot be allocated, none of this information will be
7256 * saved.
7257 */
7259 }
7263 /*
7264 * Store the ire that was successfully added into where ire_arg
7265 * points to so that callers don't have to look it up
7266 * themselves (but they are responsible for ire_refrele()ing
7267 * the ire when they are finished with it).
7268 */
7272 }
7276 }
7278 /*
7279 * ip_rt_delete is called to delete an IPv4 route.
7280 * ipif_arg is passed in to associate it with the correct interface.
7281 * We may need to restart this operation if the ipif cannot be looked up
7282 * due to an exclusive operation that is currently in progress. The restart
7283 * entry point is specified by 'func'
7284 */
7285 /* ARGSUSED4 */
7286 int
7290 {
7294 uint_t type;
7299 /*
7300 * If this is the case of RTF_HOST being set, then we set the netmask
7301 * to all ones. Otherwise, we use the netmask if one was supplied.
7302 */
7308 }
7310 /*
7311 * Note that RTF_GATEWAY is never set on a delete, therefore
7312 * we check if the gateway address is one of our interfaces first,
7313 * and fall back on RTF_GATEWAY routes.
7314 *
7315 * This makes it possible to delete an original
7316 * IRE_IF_NORESOLVER/IRE_IF_RESOLVER - consistent with SunOS 4.1.
7317 *
7318 * As the interface index specified with the RTA_IFP sockaddr is the
7319 * same for all ipif's off of an ill, the matching logic below uses
7320 * MATCH_IRE_ILL if such an index was specified. This means a route
7321 * sharing the same prefix and interface index as the the route
7322 * intended to be deleted might be deleted instead if a RTA_IFP sockaddr
7323 * is specified in the request.
7324 *
7325 * On the other hand, since the gateway address will usually be
7326 * different for each ipif on the system, the matching logic
7327 * uses MATCH_IRE_IPIF in the case of a traditional interface
7328 * route. This means that interface routes for the same prefix can be
7329 * uniquely identified if they belong to distinct ipif's and if a
7330 * RTA_IFP sockaddr is not present.
7331 *
7332 * For more detail on specifying routes by gateway address and by
7333 * interface index, see the comments in ip_rt_add().
7334 */
7336 ipst);
7341 else
7348 }
7353 }
7357 }
7362 }
7363 }
7366 /*
7367 * At this point, the gateway address is not one of our own
7368 * addresses or a matching interface route was not found. We
7369 * set the IRE type to lookup based on whether
7370 * this is a host route, a default route or just a prefix.
7371 *
7372 * If an ipif_arg was passed in, then the lookup is based on an
7373 * interface index so MATCH_IRE_ILL is added to match_flags.
7374 * In any case, MATCH_IRE_IPIF is cleared and MATCH_IRE_GW is
7375 * set as the route being looked up is not a traditional
7376 * interface route.
7377 */
7386 else
7390 }
7395 /* ipif is not refheld anymore */
7400 /*
7401 * Invoke the CGTP (multirouting) filtering module
7402 * to remove the dst address from the filtering database.
7403 * Packets coming from that address will no longer be
7404 * filtered to remove duplicates.
7405 */
7410 }
7412 }
7422 }
7424 /*
7425 * ip_siocaddrt is called to complete processing of an SIOCADDRT IOCTL.
7426 */
7427 /* ARGSUSED */
7428 int
7431 {
7432 ipaddr_t dst_addr;
7433 ipaddr_t gw_addr;
7434 ipaddr_t mask;
7445 /* Existence of mp1 verified in ip_wput_nondata */
7452 /*
7453 * If the RTF_HOST flag is on, this is a request to assign a gateway
7454 * to a particular host address. In this case, we set the netmask to
7455 * all ones for the particular destination address. Otherwise,
7456 * determine the netmask to be used based on dst_addr and the interfaces
7457 * in use.
7458 */
7462 /*
7463 * Note that ip_subnet_mask returns a zero mask in the case of
7464 * default (an all-zeroes address).
7465 */
7467 }
7474 }
7476 /*
7477 * ip_siocdelrt is called to complete processing of an SIOCDELRT IOCTL.
7478 */
7479 /* ARGSUSED */
7480 int
7483 {
7484 ipaddr_t dst_addr;
7485 ipaddr_t gw_addr;
7486 ipaddr_t mask;
7497 /* Existence of mp1 verified in ip_wput_nondata */
7504 /*
7505 * If the RTF_HOST flag is on, this is a request to delete a gateway
7506 * to a particular host address. In this case, we set the netmask to
7507 * all ones for the particular destination address. Otherwise,
7508 * determine the netmask to be used based on dst_addr and the interfaces
7509 * in use.
7510 */
7514 /*
7515 * Note that ip_subnet_mask returns a zero mask in the case of
7516 * default (an all-zeroes address).
7517 */
7519 }
7527 }
7529 /*
7530 * Enqueue the mp onto the ipsq, chained by b_next.
7531 * b_prev stores the function to be executed later, and b_queue the queue
7532 * where this mp originated.
7533 */
7534 void
7537 {
7555 }
7566 }
7571 }
7578 }
7579 }
7581 /*
7582 * Return the mp at the head of the ipsq. After emptying the ipsq
7583 * look at the next ioctl, if this ioctl is complete. Otherwise
7584 * return, we will resume when we complete the current ioctl.
7585 * The current ioctl will wait till it gets a response from the
7586 * driver below.
7587 */
7590 {
7602 }
7612 }
7614 }
7616 /*
7617 * Enter the ipsq corresponding to ill, by waiting synchronously till
7618 * we can enter the ipsq exclusively. Unless 'force' is used, the ipsq
7619 * will have to drain completely before ipsq_enter returns success.
7620 * ipsq_current_ipif will be set if some exclusive ioctl is in progress,
7621 * and the ipsq_exit logic will start the next enqueued ioctl after
7622 * completion of the current ioctl. If 'force' is used, we don't wait
7623 * for the enqueued ioctls. This is needed when a conn_close wants to
7624 * enter the ipsq and abort an ioctl that is somehow stuck. Unplumb
7625 * of an ill can also use this option. But we dont' use it currently.
7626 */
7627 #define ENTER_SQ_WAIT_TICKS 100
7628 boolean_t
7630 {
7634 /*
7635 * Holding the ill_lock prevents <ill-ipsq> assocs from changing.
7636 * Since the <ill-ipsq> assocs could change while we wait for the
7637 * writer, it is easier to wait on a fixed global rather than try to
7638 * cv_wait on a changing ipsq.
7639 */
7645 }
7665 }
7666 }
7667 }
7673 #ifdef DEBUG
7675 #endif
7679 }
7681 /*
7682 * The ipsq_t (ipsq) is the synchronization data structure used to serialize
7683 * certain critical operations like plumbing (i.e. most set ioctls),
7684 * multicast joins, igmp/mld timers, IPMP operations etc. On a non-IPMP
7685 * system there is 1 ipsq per phyint. On an IPMP system there is 1 ipsq per
7686 * IPMP group. The ipsq serializes exclusive ioctls issued by applications
7687 * on a per ipsq basis in ipsq_xopq_mphead. It also protects against multiple
7688 * threads executing in the ipsq. Responses from the driver pertain to the
7689 * current ioctl (say a DL_BIND_ACK in response to a DL_BIND_REQUEST initiated
7690 * as part of bringing up the interface) and are enqueued in ipsq_mphead.
7691 *
7692 * If a thread does not want to reenter the ipsq when it is already writer,
7693 * it must make sure that the specified reentry point to be called later
7694 * when the ipsq is empty, nor any code path starting from the specified reentry
7695 * point must never ever try to enter the ipsq again. Otherwise it can lead
7696 * to an infinite loop. The reentry point ip_rput_dlpi_writer is an example.
7697 * When the thread that is currently exclusive finishes, it (ipsq_exit)
7698 * dequeues the requests waiting to become exclusive in ipsq_mphead and calls
7699 * the reentry point. When the list at ipsq_mphead becomes empty ipsq_exit
7700 * proceeds to dequeue the next ioctl in ipsq_xopq_mphead and start the next
7701 * ioctl if the current ioctl has completed. If the current ioctl is still
7702 * in progress it simply returns. The current ioctl could be waiting for
7703 * a response from another module (arp_ or the driver or could be waiting for
7704 * the ipif/ill/ire refcnts to drop to zero. In such a case the ipsq_pending_mp
7705 * and ipsq_pending_ipif are set. ipsq_current_ipif is set throughout the
7706 * execution of the ioctl and ipsq_exit does not start the next ioctl unless
7707 * ipsq_current_ipif is clear which happens only on ioctl completion.
7708 */
7710 /*
7711 * Try to enter the ipsq exclusively, corresponding to ipif or ill. (only 1 of
7712 * ipif or ill can be specified). The caller ensures ipif or ill is valid by
7713 * ref-holding it if necessary. If the ipsq cannot be entered, the mp is queued
7714 * completion.
7715 */
7716 ipsq_t *
7719 {
7722 /* Only 1 of ipif or ill can be specified */
7727 /*
7728 * lock ordering ill_g_lock -> conn_lock -> ill_lock -> ipsq_lock
7729 * ipsq of an ill can't change when ill_lock is held.
7730 */
7736 /*
7737 * 1. Enter the ipsq if we are already writer and reentry is ok.
7738 * (Note: If the caller does not specify reentry_ok then neither
7739 * 'func' nor any of its callees must ever attempt to enter the ipsq
7740 * again. Otherwise it can lead to an infinite loop
7741 * 2. Enter the ipsq if there is no current writer and this attempted
7742 * entry is part of the current ioctl or operation
7743 * 3. Enter the ipsq if there is no current writer and this is a new
7744 * ioctl (or operation) and the ioctl (or operation) queue is
7745 * empty and there is no ioctl (or operation) currently in progress
7746 */
7751 /* Success. */
7757 #ifdef DEBUG
7759 IPSQ_STACK_DEPTH);
7760 #endif
7762 }
7770 }
7772 /*
7773 * Try to enter the IPSQ corresponding to `ill' as writer. The caller ensures
7774 * ill is valid by refholding it if necessary; we will refrele. If the IPSQ
7775 * cannot be entered, the mp is queued for completion.
7776 */
7777 void
7779 boolean_t reentry_ok)
7780 {
7785 /*
7786 * Drop the caller's refhold on the ill. This is safe since we either
7787 * entered the IPSQ (and thus are exclusive), or failed to enter the
7788 * IPSQ, in which case we return without accessing ill anymore. This
7789 * is needed because func needs to see the correct refcount.
7790 * e.g. removeif can work only then.
7791 */
7796 }
7797 }
7799 /*
7800 * If there are more than ILL_GRP_CNT ills in a group,
7801 * we use kmem alloc'd buffers, else use the stack
7802 */
7803 #define ILL_GRP_CNT 14
7804 /*
7805 * Drain the ipsq, if there are messages on it, and then leave the ipsq.
7806 * Called by a thread that is currently exclusive on this ipsq.
7807 */
7808 void
7810 {
7813 ipsq_func_t func;
7828 }
7832 again:
7839 /*
7840 * If 'q' is an conn queue, it is valid, since we did a
7841 * a refhold on the connp, at the start of the ioctl.
7842 * If 'q' is an ill queue, it is valid, since close of an
7843 * ill will clean up the 'ipsq'.
7844 */
7849 }
7853 /*
7854 * Need to grab the locks in the right order. Need to
7855 * atomically check (under ipsq_lock) that there are no
7856 * messages before relinquishing the ipsq. Also need to
7857 * atomically wakeup waiters on ill_cv while holding ill_lock.
7858 * Holding ill_g_lock ensures that ipsq list of ills is stable.
7859 * If we need to call ill_split_ipsq and change <ill-ipsq> we need
7860 * to grab ill_g_lock as writer.
7861 */
7865 /* ipsq_refs can't change while ill_g_lock is held as reader */
7867 /* At most 2 ills v4/v6 per phyint */
7870 /*
7871 * If memory allocation fails, we will do the split
7872 * the next time ipsq_exit is called for whatever reason.
7873 * As long as the ipsq_split flag is set the need to
7874 * split is remembered.
7875 */
7879 }
7883 /* oops, some message has landed up, we can't get out */
7893 }
7895 /*
7896 * Split only if no ioctl is pending and if memory alloc succeeded
7897 * above.
7898 */
7901 /*
7902 * No new ill can join this ipsq since we are holding the
7903 * ill_g_lock. Hence ill_split_ipsq can safely traverse the
7904 * ipsq. ill_split_ipsq may fail due to memory shortage.
7905 * If so we will retry on the next ipsq_exit.
7906 */
7908 }
7910 /*
7911 * We are holding the ipsq lock, hence no new messages can
7912 * land up on the ipsq, and there are no messages currently.
7913 * Now safe to get out. Wake up waiters and relinquish ipsq
7914 * atomically while holding ill locks.
7915 */
7919 #ifdef DEBUG
7921 #endif
7923 /*
7924 * For IPMP this should wake up all ills in this ipsq.
7925 * We need to hold the ill_lock while waking up waiters to
7926 * avoid missed wakeups. But there is no need to acquire all
7927 * the ill locks and then wakeup. If we have not acquired all
7928 * the locks (due to memory failure above) ill_signal_ipsq_ills
7929 * wakes up ills one at a time after getting the right ill_lock
7930 */
7941 /*
7942 * Free the ipsq. ipsq_refs can't increase because ipsq can't be
7943 * looked up. ipsq can be looked up only thru ill or phyint
7944 * and there are no ills/phyint on this ipsq.
7945 */
7947 }
7948 /*
7949 * Now start any igmp or mld timers that could not be started
7950 * while inside the ipsq. The timers can't be started while inside
7951 * the ipsq, since igmp_start_timers may need to call untimeout()
7952 * which can't be done while holding a lock i.e. the ipsq. Otherwise
7953 * there could be a deadlock since the timeout handlers
7954 * mld_timeout_handler / igmp_timeout_handler also synchronously
7955 * wait in ipsq_enter() trying to get the ipsq.
7956 *
7957 * However there is one exception to the above. If this thread is
7958 * itself the igmp/mld timeout handler thread, then we don't want
7959 * to start any new timer until the current handler is done. The
7960 * handler thread passes in B_FALSE for start_igmp/mld_timers, while
7961 * all others pass B_TRUE.
7962 */
7971 }
7981 }
7982 }
7984 /*
7985 * Start the current exclusive operation on `ipsq'; associate it with `ipif'
7986 * and `ioccmd'.
7987 */
7988 void
7990 {
7999 }
8001 /*
8002 * Finish the current exclusive operation on `ipsq'. Note that other
8003 * operations will not be able to proceed until an ipsq_exit() is done.
8004 */
8005 void
8007 {
8012 /*
8013 * For SIOCSLIFREMOVEIF, the ipif has been already been blown away
8014 * (but we're careful to never set IPIF_CHANGING in that case).
8015 */
8020 /* Send any queued event */
8023 }
8030 }
8032 /*
8033 * The ill is closing. Flush all messages on the ipsq that originated
8034 * from this ill. Usually there wont' be any messages on the ipsq_xopq_mphead
8035 * for this ill since ipsq_enter could not have entered until then.
8036 * New messages can't be queued since the CONDEMNED flag is set.
8037 */
8038 static void
8040 {
8049 /*
8050 * Flush any messages sent up by the driver.
8051 */
8057 /* Remove the mp from the ipsq */
8060 else
8065 }
8069 }
8070 }
8075 }
8077 /* ARGSUSED */
8078 int
8081 {
8084 boolean_t isv6;
8091 /*
8092 * Set original index.
8093 * Failover and failback move logical interfaces
8094 * from one physical interface to another. The
8095 * original index indicates the parent of a logical
8096 * interface, in other words, the physical interface
8097 * the logical interface will be moved back to on
8098 * failback.
8099 */
8101 /*
8102 * Don't allow the original index to be changed
8103 * for non-failover addresses, autoconfigured
8104 * addresses, or IPv6 link local addresses.
8105 */
8109 }
8110 /*
8111 * The new original index must be in use by some
8112 * physical interface.
8113 */
8121 /*
8122 * When this ipif gets failed back, don't
8123 * preserve the original id, as it is no
8124 * longer applicable.
8125 */
8127 /*
8128 * For IPv4, change the original index of any
8129 * multicast addresses associated with the
8130 * ipif to the new value.
8131 */
8140 }
8141 }
8143 }
8145 }
8147 /* ARGSUSED */
8148 int
8151 {
8154 /*
8155 * Get the original interface index i.e the one
8156 * before FAILOVER if it ever happened.
8157 */
8160 }
8162 /*
8163 * Parse an iftun_req structure coming down SIOC[GS]TUNPARAM ioctls,
8164 * refhold and return the associated ipif
8165 */
8166 /* ARGSUSED */
8167 int
8170 {
8171 boolean_t exists;
8175 boolean_t isv6;
8181 /* Existence verified in ip_wput_nondata */
8184 /*
8185 * Null terminate the string to protect against buffer
8186 * overrun. String was generated by user code and may not
8187 * be trusted.
8188 */
8195 /* Disallows implicit create */
8203 /*
8204 * We really don't want to set/get tunnel parameters
8205 * on virtual tunnel interfaces. Only allow the
8206 * base tunnel to do these.
8207 */
8210 }
8212 /*
8213 * Send down to tunnel mod for ioctl processing.
8214 * Will finish ioctl in ip_rput_other().
8215 */
8220 }
8225 }
8226 /*
8227 * Mark the ioctl as coming from an IPv6 interface for
8228 * tun's convenience.
8229 */
8234 }
8236 /*
8237 * Parse an ifreq or lifreq struct coming down ioctls and refhold
8238 * and return the associated ipif.
8239 * Return value:
8240 * Non zero: An error has occurred. ci may not be filled out.
8241 * zero : ci is filled out with the ioctl cmd in ci.ci_name, and
8242 * a held ipif in ci.ci_ipif.
8243 */
8244 int
8247 {
8256 boolean_t isv6;
8257 boolean_t exists;
8260 zoneid_t zoneid;
8275 /* global zone can access ipifs in all zones */
8277 }
8279 }
8281 /* Has been checked in ip_wput_nondata */
8285 /* This a old style SIOC[GS]IF* command */
8287 /*
8288 * Null terminate the string to protect against buffer
8289 * overrun. String was generated by user code and may not
8290 * be trusted.
8291 */
8299 /* This a new style SIOC[GS]LIF* command */
8302 /*
8303 * Null terminate the string to protect against buffer
8304 * overrun. String was generated by user code and may not
8305 * be trusted.
8306 */
8313 LIFNAMSIZ);
8314 }
8318 }
8321 /*
8322 * The ioctl will be failed if the ioctl comes down
8323 * an conn stream
8324 */
8326 /*
8327 * Not an ill queue, return EINVAL same as the
8328 * old error code.
8329 */
8331 }
8338 ipst);
8344 /*
8345 * Need to try both v4 and v6 since this
8346 * ioctl can come down either v4 or v6
8347 * socket. The lifreq.lifr_family passed
8348 * down by this ioctl is AF_UNSPEC.
8349 */
8356 }
8358 }
8359 }
8361 /*
8362 * Old style [GS]IFCMD does not admit IPv6 ipif
8363 */
8367 }
8371 /*
8372 * Handle a or a SIOC?IF* with a null name
8373 * during plumb (on the ill queue before the I_PLINK).
8374 */
8377 }
8382 /*
8383 * Allow only GET operations if this ipif has been created
8384 * temporarily due to a MOVE operation.
8385 */
8389 }
8393 }
8395 /*
8396 * Return the total number of ipifs.
8397 */
8398 static uint_t
8400 {
8403 ill_walk_context_t ctx;
8414 numifs++;
8415 }
8417 }
8420 }
8422 /*
8423 * Return the total number of ipifs.
8424 */
8425 static uint_t
8427 {
8431 ill_walk_context_t ctx;
8440 else
8454 IPIF_DEPRECATED)) ||
8466 numifs++;
8467 }
8468 }
8471 }
8473 uint_t
8475 {
8480 /*
8481 * ill_g_usesrc_lock protects ill_usesrc_grp_next, for example, some
8482 * other thread may be trying to relink the ILLs in this usesrc group
8483 * and adjusting the ill_usesrc_grp_next pointers
8484 */
8490 numifs++;
8491 }
8495 }
8497 /* Null values are passed in for ipif, sin, and ifreq */
8498 /* ARGSUSED */
8499 int
8502 {
8508 /* Existence of b_cont->b_cont checked in ip_wput_nondata */
8515 }
8517 /* Null values are passed in for ipif, sin, and ifreq */
8518 /* ARGSUSED */
8519 int
8522 {
8529 /* Existence checked in ip_wput_nondata */
8540 }
8546 }
8548 /* ARGSUSED */
8549 int
8552 {
8557 ill_walk_context_t ctx;
8562 zoneid_t zoneid;
8568 /* Existence verified in ip_wput_nondata */
8573 /*
8574 * The original SIOCGIFCONF passed in a struct ifconf which specified
8575 * the user buffer address and length into which the list of struct
8576 * ifreqs was to be copied. Since AT&T Streams does not seem to
8577 * allow M_COPYOUT to be used in conjunction with I_STR IOCTLS,
8578 * the SIOCGIFCONF operation was redefined to simply provide
8579 * a large output buffer into which we are supposed to jam the ifreq
8580 * array. The same ioctl command code was used, despite the fact that
8581 * both the applications and the kernel code had to change, thus making
8582 * it impossible to support both interfaces.
8583 *
8584 * For reasons not good enough to try to explain, the following
8585 * algorithm is used for deciding what to do with one of these:
8586 * If the IOCTL comes in as an I_STR, it is assumed to be of the new
8587 * form with the output buffer coming down as the continuation message.
8588 * If it arrives as a TRANSPARENT IOCTL, it is assumed to be old style,
8589 * and we have to copy in the ifconf structure to find out how big the
8590 * output buffer is and where to copy out to. Sure no problem...
8591 *
8592 */
8598 /*
8599 * Must be (better be!) continuation of a TRANSPARENT
8600 * IOCTL. We just copied in the ifconf structure.
8601 */
8605 /*
8606 * Allocate a buffer to hold requested information.
8607 *
8608 * If ifc_len is larger than what is needed, we only
8609 * allocate what we will use.
8610 *
8611 * If ifc_len is smaller than what is needed, return
8612 * EINVAL.
8613 *
8614 * XXX: the ill_t structure can hava 2 counters, for
8615 * v4 and v6 (not just ill_ipif_up_count) to store the
8616 * number of interfaces for a device, so we don't need
8617 * to count them here...
8618 */
8625 /* old behaviour */
8629 }
8630 }
8638 }
8640 /*
8641 * the SIOCGIFCONF ioctl only knows about
8642 * IPv4 addresses, so don't try to tell
8643 * it about interfaces with IPv6-only
8644 * addresses. (Last parm 'isv6' is B_FALSE)
8645 */
8659 /* old behaviour */
8664 }
8665 }
8672 ifr++;
8673 }
8674 }
8675 if_copydone:
8682 }
8684 }
8686 /*
8687 * Get the interfaces using the address hosted on the interface passed in,
8688 * as a source adddress
8689 */
8690 /* ARGSUSED */
8691 int
8694 {
8702 uint_t ifindex;
8703 zoneid_t zoneid;
8717 /* Existence verified in ip_wput_nondata */
8720 /*
8721 * Must be (better be!) continuation of a TRANSPARENT
8722 * IOCTL. We just copied in the lifsrcof structure.
8723 */
8736 ifindex));
8738 }
8741 /* Allocate a buffer to hold requested information */
8745 /* The actual size needed is always returned in lifs_len */
8748 /* If the amount we need is more than what is passed in, abort */
8752 }
8759 }
8769 /* ill_g_usesrc_lock protects ill_usesrc_grp_next */
8796 }
8797 lifr++;
8798 }
8806 }
8808 /* ARGSUSED */
8809 int
8812 {
8821 sa_family_t family;
8824 ill_walk_context_t ctx;
8827 zoneid_t zoneid;
8837 /* Existence verified in ip_wput_nondata */
8840 /*
8841 * An extended version of SIOCGIFCONF that takes an
8842 * additional address family and flags field.
8843 * AF_UNSPEC retrieve both IPv4 and IPv6.
8844 * Unless LIFC_NOXMIT is specified the IPIF_NOXMIT
8845 * interfaces are omitted.
8846 * Similarly, IPIF_TEMPORARY interfaces are omitted
8847 * unless LIFC_TEMPORARY is specified.
8848 * If LIFC_EXTERNAL_SOURCE is specified, IPIF_NOXMIT,
8849 * IPIF_NOLOCAL, PHYI_LOOPBACK, IPIF_DEPRECATED and
8850 * not IPIF_UP interfaces are omitted. LIFC_EXTERNAL_SOURCE
8851 * has priority over LIFC_NOXMIT.
8852 */
8858 /*
8859 * Must be (better be!) continuation of a TRANSPARENT
8860 * IOCTL. We just copied in the lifconf structure.
8861 */
8869 /*
8870 * walk all ILL's.
8871 */
8875 /*
8876 * walk only IPV4 ILL's.
8877 */
8881 /*
8882 * walk only IPV6 ILL's.
8883 */
8888 }
8890 /*
8891 * Allocate a buffer to hold requested information.
8892 *
8893 * If lifc_len is larger than what is needed, we only
8894 * allocate what we will use.
8895 *
8896 * If lifc_len is smaller than what is needed, return
8897 * EINVAL.
8898 */
8905 else
8907 }
8934 IPIF_DEPRECATED)) ||
8952 }
8953 }
8975 }
8976 lifr++;
8977 }
8978 }
8979 lif_copydone:
8986 }
8988 }
8990 /* ARGSUSED */
8991 int
8994 {
8999 else
9002 /* Existence of b_cont->b_cont checked in ip_wput_nondata */
9005 }
9007 static void
9009 {
9018 else
9021 /* These two ioctls are I_STR only */
9025 }
9029 /* The user passed us a NULL argument */
9033 /*
9034 * The user provided a table. The stream head
9035 * may have copied in the user data in chunks,
9036 * so make sure everything is pulled up
9037 * properly.
9038 */
9042 NULL) {
9045 }
9049 }
9052 }
9059 #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4
9067 /*
9068 * We need to do an in-place shrink of the array
9069 * to match the alignment attributes of the
9070 * 32-bit ABI looking at it.
9071 */
9072 /* LINTED: logical expression always true: op "||" */
9076 }
9077 #endif
9083 #if defined(_SYSCALL32_IMPL) && _LONG_LONG_ALIGNMENT_32 == 4
9084 /*
9085 * We pass in the datamodel here so that the ip6_asp_replace()
9086 * routine can handle converting from 32-bit to native formats
9087 * where necessary.
9088 *
9089 * A better way to handle this might be to convert the inbound
9090 * data structure here, and hang it off a new 'mp'; thus the
9091 * ip6_asp_replace() logic would always be dealing with native
9092 * format data structures..
9093 *
9094 * (An even simpler way to handle these ioctls is to just
9095 * add a 32-bit trailing 'pad' field to the ip6_asp_t structure
9096 * and just recompile everything that depends on it.)
9097 */
9098 #endif
9102 }
9106 }
9108 static void
9110 {
9115 ipaddr_t v4daddr;
9118 boolean_t isipv4;
9123 zoneid_t zoneid;
9129 /*
9130 * This ioctl is I_STR only, and must have a
9131 * data mblk following the M_IOCTL mblk.
9132 */
9137 }
9145 }
9149 }
9159 /*
9160 * ip_addr_scope_v6() and ip6_asp_lookup() handle
9161 * v4 mapped addresses; ire_ftable_lookup[_v6]()
9162 * and ipif_select_source[_v6]() do not.
9163 */
9175 }
9179 /* move on to next dst addr */
9181 }
9188 /*
9189 * We expect to get back an interface ire or a
9190 * gateway ire cache entry. For both types, the
9191 * output interface is ire_ipif->ipif_ill.
9192 */
9201 zoneid);
9202 }
9213 next_dst:
9215 }
9217 }
9220 /*
9221 * Check if this is an address assigned to this machine.
9222 * Skips interfaces that are down by using ire checks.
9223 * Translates mapped addresses to v4 addresses and then
9224 * treats them as such, returning true if the v4 address
9225 * associated with this mapped address is configured.
9226 * Note: Applications will have to be careful what they do
9227 * with the response; use of mapped addresses limits
9228 * what can be done with the socket, especially with
9229 * respect to socket options and ioctls - neither IPv4
9230 * options nor IPv6 sticky options/ancillary data options
9231 * may be used.
9232 */
9233 /* ARGSUSED */
9234 int
9237 {
9242 zoneid_t zoneid;
9251 /* Existence verified in ip_wput_nondata */
9260 ipaddr_t v4_addr;
9263 v4_addr);
9268 in6_addr_t v6addr;
9274 }
9276 }
9278 ipaddr_t v4addr;
9285 }
9288 }
9294 }
9296 }
9298 /*
9299 * Check if this is an address assigned on-link i.e. neighbor,
9300 * and makes sure it's reachable from the current zone.
9301 * Returns true for my addresses as well.
9302 * Translates mapped addresses to v4 addresses and then
9303 * treats them as such, returning true if the v4 address
9304 * associated with this mapped address is configured.
9305 * Note: Applications will have to be careful what they do
9306 * with the response; use of mapped addresses limits
9307 * what can be done with the socket, especially with
9308 * respect to socket options and ioctls - neither IPv4
9309 * options nor IPv6 sticky options/ancillary data options
9310 * may be used.
9311 */
9312 /* ARGSUSED */
9313 int
9316 {
9321 zoneid_t zoneid;
9330 /* Existence verified in ip_wput_nondata */
9335 /*
9336 * Match addresses with a zero gateway field to avoid
9337 * routes going through a router.
9338 * Exclude broadcast and multicast addresses.
9339 */
9345 ipaddr_t v4_addr;
9348 v4_addr);
9353 }
9355 in6_addr_t v6addr;
9356 in6_addr_t v6gw;
9364 }
9365 }
9367 }
9369 ipaddr_t v4addr;
9376 }
9378 }
9381 }
9387 }
9389 }
9391 }
9393 /*
9394 * TBD: implement when kernel maintaines a list of site prefixes.
9395 */
9396 /* ARGSUSED */
9397 int
9400 {
9402 }
9404 /* ARGSUSED */
9405 int
9408 {
9412 boolean_t success;
9416 /* ioctl comes down on an conn */
9422 /*
9423 * Send down a copy. (copymsg does not copy b_next/b_prev).
9424 * The original mp contains contaminated b_next values due to 'mi',
9425 * which is needed to do the mi_copy_done. Unfortunately if we
9426 * send down the original mblk itself and if we are popped due to an
9427 * an unplumb before the response comes back from tunnel,
9428 * the streamhead (which does a freemsg) will see this contaminated
9429 * message and the assertion in freemsg about non-null b_next/b_prev
9430 * will panic a DEBUG kernel.
9431 */
9444 }
9453 /* The conn has started closing */
9456 }
9457 }
9459 /*
9460 * ARP IOCTLs.
9461 * How does IP get in the business of fronting ARP configuration/queries?
9462 * Well it's like this, the Berkeley ARP IOCTLs (SIOCGARP, SIOCDARP, SIOCSARP)
9463 * are by tradition passed in through a datagram socket. That lands in IP.
9464 * As it happens, this is just as well since the interface is quite crude in
9465 * that it passes in no information about protocol or hardware types, or
9466 * interface association. After making the protocol assumption, IP is in
9467 * the position to look up the name of the ILL, which ARP will need, and
9468 * format a request that can be handled by ARP. The request is passed up
9469 * stream to ARP, and the original IOCTL is completed by IP when ARP passes
9470 * back a response. ARP supports its own set of more general IOCTLs, in
9471 * case anyone is interested.
9472 */
9473 /* ARGSUSED */
9474 int
9477 {
9481 ipaddr_t ipaddr;
9498 /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->XARPREQ_MBLK */
9505 /*
9506 * Validate against user's link layer address length
9507 * input and name and addr length limits.
9508 */
9515 }
9517 /* We have a chain - M_IOCTL-->MI_COPY_MBLK-->ARPREQ_MBLK */
9523 /*
9524 * Theoretically, the sa_family could tell us what link
9525 * layer type this operation is trying to deal with. By
9526 * common usage AF_UNSPEC means ethernet. We'll assume
9527 * any attempt to use the SIOC?ARP ioctls is for ethernet,
9528 * for now. Our new SIOC*XARP ioctls can be used more
9529 * generally.
9530 *
9531 * If the underlying media happens to have a non 6 byte
9532 * address, arp module will fail set/get, but the del
9533 * operation will succeed.
9534 */
9539 }
9540 }
9542 /*
9543 * We are going to pass up to ARP a packet chain that looks
9544 * like:
9545 *
9546 * M_IOCTL-->ARP_op_MBLK-->ORIG_M_IOCTL-->MI_COPY_MBLK-->[X]ARPREQ_MBLK
9547 *
9548 * Get a copy of the original IOCTL mblk to head the chain,
9549 * to be sent up (in mp1). Also get another copy to store
9550 * in the ill_pending_mp list, for matching the response
9551 * when it comes back from ARP.
9552 */
9561 }
9571 }
9572 /* Put together the chain. */
9580 /*
9581 * An M_IOCDATA's payload (struct copyresp) is mostly the same as an
9582 * M_IOCTL's payload (struct iocblk), but 'struct copyresp' has a
9583 * cp_private field (or cp_rval on 32-bit systems) in place of the
9584 * ioc_count field; set ioc_count to be correct.
9585 */
9588 /*
9589 * Set the proper command in the ARP message.
9590 * Convert the SIOC{G|S|D}ARP calls into our
9591 * AR_ENTRY_xxx calls.
9592 */
9597 /*
9598 * We defer deleting the corresponding IRE until
9599 * we return from arp.
9600 */
9611 /*
9612 * Delete the corresponding ire to make sure IP will
9613 * pick up any change from arp.
9614 */
9621 ipst);
9623 }
9624 }
9626 }
9629 /*
9630 * Fill in the rest of the ARP operation fields.
9631 */
9635 /* Translate the flags. */
9643 /*
9644 * Before sending 'mp' to ARP, we have to clear the b_next
9645 * and b_prev. Otherwise if STREAMS encounters such a message
9646 * in freemsg(), (because ARP can close any time) it can cause
9647 * a panic. But mi code needs the b_next and b_prev values of
9648 * mp->b_cont, to complete the ioctl. So we store it here
9649 * in pending_mp->bcont, and restore it in ip_sioctl_iocack()
9650 * when the response comes down from ARP.
9651 */
9659 /* conn has not yet started closing, hence this can't fail */
9664 /*
9665 * Up to ARP it goes. The response will come back in ip_wput() as an
9666 * M_IOCACK, and will be handed to ip_sioctl_iocack() for completion.
9667 */
9670 }
9672 /*
9673 * Parse an [x]arpreq structure coming down SIOC[GSD][X]ARP ioctls, identify
9674 * the associated sin and refhold and return the associated ipif via `ci'.
9675 */
9676 int
9679 {
9687 boolean_t exists;
9693 /* ioctl comes down on a conn */
9701 /* Verified in ip_wput_nondata */
9719 }
9731 }
9733 /*
9734 * Either an SIOC[DGS]ARP or an SIOC[DGS]XARP with sdl_nlen ==
9735 * 0: use the IP address to figure out the ill. In the IPMP
9736 * case, a simple forwarding table lookup will return the
9737 * IRE_IF_RESOLVER for the first interface in the group, which
9738 * might not be the interface on which the requested IP
9739 * address was resolved due to the ill selection algorithm
9740 * (see ip_newroute_get_dst_ill()). So we do a cache table
9741 * lookup first: if the IRE cache entry for the IP address is
9742 * still there, it will contain the ill pointer for the right
9743 * interface, so we use that. If the cache entry has been
9744 * flushed, we fall back to the forwarding table lookup. This
9745 * should be rare enough since IRE cache entries have a longer
9746 * life expectancy than ARP cache entries.
9747 */
9749 ipst);
9763 }
9764 }
9769 }
9773 }
9775 /*
9776 * Do I_PLINK/I_LINK or I_PUNLINK/I_UNLINK with consistency checks and also
9777 * atomically set/clear the muxids. Also complete the ioctl by acking or
9778 * naking it. Note that the code is structured such that the link type,
9779 * whether it's persistent or not, is treated equally. ifconfig(1M) and
9780 * its clones use the persistent link, while pppd(1M) and perhaps many
9781 * other daemons may use non-persistent link. When combined with some
9782 * ill_t states, linking and unlinking lower streams may be used as
9783 * indicators of dynamic re-plumbing events [see PSARC/1999/348].
9784 */
9785 /* ARGSUSED */
9786 void
9788 {
9796 boolean_t islink;
9801 else
9812 /*
9813 * ARP has added this special mblk, and the utility is asking us
9814 * to perform consistency checks, and also atomically set the
9815 * muxid. Ifconfig is an example. It achieves this by using
9816 * /dev/arp as the mux to plink the arp stream, and pushes arp on
9817 * to /dev/udp[6] stream for use as the mux when plinking the IP
9818 * stream. SIOCSLIFMUXID is not required. See ifconfig.c, arp.c
9819 * and other comments in this routine for more details.
9820 */
9823 /*
9824 * If I_{P}LINK/I_{P}UNLINK is issued by a utility other than
9825 * ifconfig which didn't push ARP on top of the dummy mux, we won't
9826 * get the special mblk above. For backward compatibility, we
9827 * request ip_sioctl_plink_ipmod() to skip the consistency checks.
9828 * The utility will use SIOCSLIFMUXID to store the muxids. This is
9829 * not atomic, and can leave the streams unplumbable if the utility
9830 * is interrupted before it does the SIOCSLIFMUXID.
9831 */
9837 }
9839 /*
9840 * This is an I_{P}LINK sent down by ifconfig through the ARP module;
9841 * ARP has appended this last mblk to tell us whether the lower stream
9842 * is an arp-dev stream or an IP module stream.
9843 */
9846 /*
9847 * The lower stream is the arp-dev stream.
9848 */
9856 }
9864 }
9866 }
9870 /*
9871 * To ensure consistency between IP and ARP, the following
9872 * LIFO scheme is used in plink/punlink. (IP first, ARP last).
9873 * This is because the muxid's are stored in the IP stream on
9874 * the ill.
9875 *
9876 * I_{P}LINK: ifconfig plinks the IP stream before plinking
9877 * the ARP stream. On an arp-dev stream, IP checks that it is
9878 * not yet plinked, and it also checks that the corresponding
9879 * IP stream is already plinked.
9880 *
9881 * I_{P}UNLINK: ifconfig punlinks the ARP stream before
9882 * punlinking the IP stream. IP does not allow punlink of the
9883 * IP stream unless the arp stream has been punlinked.
9884 */
9890 }
9893 /*
9894 * The lower stream is probably an IP module stream. Do
9895 * consistency checking.
9896 */
9900 }
9901 done:
9904 else
9907 /* Conn was refheld in ip_sioctl_copyin_setup */
9912 }
9914 /*
9915 * Process I_{P}LINK and I_{P}UNLINK requests named by `ioccmd' and pointed to
9916 * by `mp' and `li' for the IP module stream (if li->q_bot is in fact an IP
9917 * module stream). If `doconsist' is set, then do the extended consistency
9918 * checks requested by ifconfig(1M) and (atomically) set ill_ip_muxid here.
9919 * Returns zero on success, EINPROGRESS if the operation is still pending, or
9920 * an error code on failure.
9921 */
9922 static int
9925 {
9933 /*
9934 * Walk the lower stream to verify it's the IP module stream.
9935 * The IP module is identified by its name, wput function,
9936 * and non-NULL q_next. STREAMS ensures that the lower stream
9937 * (li->l_qbot) will not vanish until this ioctl completes.
9938 */
9945 }
9946 }
9948 /*
9949 * If this isn't an IP module stream, bail.
9950 */
9963 }
9967 /*
9968 * Consistency checking requires that I_{P}LINK occurs
9969 * prior to setting ill_ip_muxid, and that I_{P}UNLINK
9970 * occurs prior to clearing ill_arp_muxid.
9971 */
9977 }
9978 }
9980 /*
9981 * As part of I_{P}LINKing, stash the number of downstream modules and
9982 * the read queue of the module immediately below IP in the ill.
9983 * These are used during the capability negotiation below.
9984 */
9991 }
9996 /*
9997 * If there's at least one up ipif on this ill, then we're bound to
9998 * the underlying driver via DLPI. In that case, renegotiate
9999 * capabilities to account for any possible change in modules
10000 * interposed between IP and the driver.
10001 */
10005 else
10007 }
10013 }
10015 /*
10016 * Search the ioctl command in the ioctl tables and return a pointer
10017 * to the ioctl command information. The ioctl command tables are
10018 * static and fully populated at compile time.
10019 */
10020 ip_ioctl_cmd_t *
10022 {
10030 /*
10031 * Do a 2 step search. First search the indexed table
10032 * based on the least significant byte of the ioctl cmd.
10033 * If we don't find a match, then search the misc table
10034 * serially.
10035 */
10040 /* Found a match in the ndx table */
10042 }
10043 }
10045 /* Search the misc table */
10049 /* Found a match in the misc table */
10051 }
10054 }
10056 /*
10057 * Wrapper function for resuming deferred ioctl processing
10058 * Used for SIOCGDSTINFO, SIOCGIP6ADDRPOLICY, SIOCGMSFILTER,
10059 * SIOCSMSFILTER, SIOCGIPMSFILTER, and SIOCSIPMSFILTER currently.
10060 */
10061 /* ARGSUSED */
10062 void
10065 {
10067 }
10069 /*
10070 * ip_sioctl_copyin_setup is called by ip_wput with any M_IOCTL message
10071 * that arrives. Most of the IOCTLs are "socket" IOCTLs which we handle
10072 * in either I_STR or TRANSPARENT form, using the mi_copy facility.
10073 * We establish here the size of the block to be copied in. mi_copyin
10074 * arranges for this to happen, an processing continues in ip_wput with
10075 * an M_IOCDATA message.
10076 */
10077 void
10079 {
10088 else
10093 /*
10094 * The ioctl is not one we understand or own.
10095 * Pass it along to be processed down stream,
10096 * if this is a module instance of IP, else nak
10097 * the ioctl.
10098 */
10104 }
10105 }
10107 /*
10108 * If this is deferred, then we will do all the checks when we
10109 * come back.
10110 */
10115 }
10117 /*
10118 * Only allow a very small subset of IP ioctls on this stream if
10119 * IP is a module and not a driver. Allowing ioctls to be processed
10120 * in this case may cause assert failures or data corruption.
10121 * Typically G[L]IFFLAGS, SLIFNAME/IF_UNITSEL are the only few
10122 * ioctls allowed on an IP module stream, after which this stream
10123 * normally becomes a multiplexor (at which time the stream head
10124 * will fail all ioctls).
10125 */
10128 /*
10129 * Pass common Streams ioctls which the IP
10130 * module does not own or consume along to
10131 * be processed down stream.
10132 */
10137 }
10138 }
10140 /* Make sure we have ioctl data to process. */
10144 /*
10145 * Prefer dblk credential over ioctl credential; some synthesized
10146 * ioctls have kcred set because there's no way to crhold()
10147 * a credential in some contexts. (ioc_cr is not crfree() by
10148 * the framework; the caller of ioctl needs to hold the reference
10149 * for the duration of the call).
10150 */
10153 /* Make sure normal users don't send down privileged ioctls */
10156 /* We checked the privilege earlier but log it here */
10159 }
10161 /*
10162 * The ioctl command tables can only encode fixed length
10163 * ioctl data. If the length is variable, the table will
10164 * encode the length as zero. Such special cases are handled
10165 * below in the switch.
10166 */
10170 }
10175 /*
10176 * This IOCTL is hilarious. See comments in
10177 * ip_sioctl_get_ifconf for the story.
10178 */
10182 else
10215 /*
10216 * We treat non-persistent link similarly as the persistent
10217 * link case, in terms of plumbing/unplumbing, as well as
10218 * dynamic re-plumbing events indicator. See comments
10219 * in ip_sioctl_plink() for more.
10220 *
10221 * Request can be enqueued in the 'ipsq' while waiting
10222 * to become exclusive. So bump up the conn ref.
10223 */
10231 /*
10232 * Use of the nd table requires holding the reader lock.
10233 * Modifying the nd table thru nd_load/nd_unload requires
10234 * the writer lock.
10235 */
10245 }
10247 /*
10248 * We don't understand this subioctl of ND_GET / ND_SET.
10249 * Maybe intended for some driver / module below us
10250 */
10258 }
10266 }
10267 nak:
10271 }
10276 }
10278 /* ip_wput hands off ARP IOCTL responses to us */
10279 void
10281 {
10291 uint_t ioc_id;
10297 ipaddr_t addr;
10305 /*
10306 * We should get back from ARP a packet chain that looks like:
10307 * M_IOCACK-->ARP_op_MBLK-->ORIG_M_IOCTL-->MI_COPY_MBLK-->[X]ARPREQ_MBLK
10308 */
10315 }
10335 }
10339 /*
10340 * Pick out the originating queue based on the ioc_id.
10341 */
10348 }
10352 /* Uncouple the internally generated IOCTL from the original one */
10356 /*
10357 * Restore the b_next and b_prev used by mi code. This is needed
10358 * to complete the ioctl using mi* functions. We stored them in
10359 * the pending mp prior to sending the request to ARP.
10360 */
10365 /*
10366 * We're done if there was an error or if this is not an SIOCG{X}ARP
10367 * Catch the case where there is an IRE_CACHE by no entry in the
10368 * arp table.
10369 */
10379 /*
10380 * There's no need to lookup the ill, since
10381 * we've already done that when we started
10382 * processing the ioctl and sent the message
10383 * to ARP on that ill. So use the ill that
10384 * is stored in q->q_ptr.
10385 */
10395 }
10401 /*
10402 * Since the ire obtained from cachetable is used for
10403 * mac addr copying below, treat an incomplete ire as if
10404 * as if we never found it.
10405 */
10412 }
10428 }
10434 else
10438 /*
10439 * For SIOCGARP, MAC address length
10440 * validation has already been done
10441 * before the ioctl was issued to ARP to
10442 * allow it to progress only on 6 byte
10443 * addressable (ethernet like) media. Thus
10444 * the mac address copying can not overwrite
10445 * the sa_data area below.
10446 */
10448 }
10449 /* Ditch the internal IOCTL. */
10454 }
10455 }
10457 /*
10458 * Delete the coresponding IRE_CACHE if any.
10459 * Reset the error if there was one (in case there was no entry
10460 * in arp.)
10461 */
10466 /*
10467 * There's no need to lookup the ill, since
10468 * we've already done that when we started
10469 * processing the ioctl and sent the message
10470 * to ARP on that ill. So use the ill that
10471 * is stored in q->q_ptr.
10472 */
10474 }
10476 /*
10477 * The address in "addr" may be an entry for a
10478 * router. If that's true, then any off-net
10479 * IRE_CACHE entries that go through the router
10480 * with address "addr" must be clobbered. Use
10481 * ire_walk to achieve this goal.
10482 */
10486 else
10490 }
10491 }
10492 errack:
10498 }
10500 /*
10501 * Completion of an SIOCG{X}ARP. Translate the information from
10502 * the area_t into the struct {x}arpreq.
10503 */
10510 NULL);
10512 }
10513 }
10523 /*
10524 * For SIOCGARP, MAC address length validation has
10525 * already been done before the ioctl was issued to ARP
10526 * to allow it to progress only on 6 byte addressable
10527 * (ethernet like) media. Thus the mac address copying
10528 * can not overwrite the sa_data area below.
10529 */
10532 }
10534 /* Ditch the internal IOCTL. */
10536 /* Complete the original. */
10538 }
10540 /*
10541 * Create a new logical interface. If ipif_id is zero (i.e. not a logical
10542 * interface) create the next available logical interface for this
10543 * physical interface.
10544 * If ipif is NULL (i.e. the lookup didn't find one) attempt to create an
10545 * ipif with the specified name.
10546 *
10547 * If the address family is not AF_UNSPEC then set the address as well.
10548 *
10549 * If ip_sioctl_addr returns EINPROGRESS then the ioctl (the copyout)
10550 * is completed when the DL_BIND_ACK arrive in ip_rput_dlpi_writer.
10551 *
10552 * Executed as a writer on the ill or ill group.
10553 * So no lock is needed to traverse the ipif chain, or examine the
10554 * phyint flags.
10555 */
10556 /* ARGSUSED */
10557 int
10560 {
10563 boolean_t isv6;
10564 boolean_t exists;
10577 zoneid_t zoneid;
10583 /* Existence of mp1 has been checked in ip_wput_nondata */
10585 /*
10586 * Null terminate the string to protect against buffer
10587 * overrun. String was generated by user code and may not
10588 * be trusted.
10589 */
10604 /*
10605 * Allow creating lo0 using SIOCLIFADDIF.
10606 * can't be any other writer thread. So can pass null below
10607 * for the last 4 args to ipif_lookup_name.
10608 */
10611 /* Prevent any further action */
10615 /* We created the ipif now and as writer */
10622 }
10624 /* Look for a colon in the name. */
10629 /*
10630 * Reject any non-decimal aliases for plumbing
10631 * of logical interfaces. Aliases with leading
10632 * zeroes are also rejected as they introduce
10633 * ambiguity in the naming of the interfaces.
10634 * Comparing with "0" takes care of all such
10635 * cases.
10636 */
10643 }
10646 }
10647 }
10654 }
10657 B_TRUE);
10659 /*
10660 * Release the refhold due to the lookup, now that we are excl
10661 * or we are just returning
10662 */
10668 /*
10669 * If the interface is failed, inactive or offlined, look for a working
10670 * interface in the ill group and create the ipif there. If we can't
10671 * find a good interface, create the ipif anyway so that in.mpathd can
10672 * move it to the first repaired interface.
10673 */
10680 /*
10681 * We're looking for a working interface, but it doesn't matter
10682 * if it's up or down; so instead of following the group lists,
10683 * we look at each physical interface and compare the groupname.
10684 * We're only interested in interfaces with IPv4 (resp. IPv6)
10685 * plumbed when we're adding an IPv4 (resp. IPv6) ipif.
10686 * Otherwise we create the ipif on the failed interface.
10687 */
10690 phyint_list_avl_by_index);
10693 phyint_list_avl_by_index,
10704 }
10705 }
10712 }
10713 }
10715 /*
10716 * We are now exclusive on the ipsq, so an ill move will be serialized
10717 * before or after us.
10718 */
10723 /* Now see if there is an IPIF with this unit number. */
10729 }
10730 }
10731 }
10733 /*
10734 * We use IRE_LOCAL for lo0:1 etc. for "receive only" use
10735 * of lo0. We never come here when we plumb lo0:0. It
10736 * happens in ipif_lookup_on_name.
10737 * The specified unit number is ignored when we create the ipif on a
10738 * different interface. However, we save it in ipif_orig_ipifid below so
10739 * that the ipif fails back to the right position.
10740 */
10745 }
10747 /* Return created name with ioctl */
10752 /* Set address */
10757 }
10759 /* Set ifindex and unit number for failback */
10764 }
10765 }
10767 done:
10770 }
10772 /*
10773 * Remove an existing logical interface. If ipif_id is zero (i.e. not a logical
10774 * interface) delete it based on the IP address (on this physical interface).
10775 * Otherwise delete it based on the ipif_id.
10776 * Also, special handling to allow a removeif of lo0.
10777 */
10778 /* ARGSUSED */
10779 int
10782 {
10785 boolean_t success;
10796 /*
10797 * Special case for unplumbing lo0 (the loopback physical interface).
10798 * If unplumbing lo0, the incoming address structure has been
10799 * initialized to all zeros. When unplumbing lo0, all its logical
10800 * interfaces must be removed too.
10801 *
10802 * Note that this interface may be called to remove a specific
10803 * loopback logical interface (eg, lo0:1). But in that case
10804 * ipif->ipif_id != 0 so that the code path for that case is the
10805 * same as any other interface (meaning it skips the code directly
10806 * below).
10807 */
10811 /*
10812 * Mark it condemned. No new ref. will be made to ill.
10813 */
10819 }
10823 /* unplumb the loopback interface */
10829 /* Are any references to this ill active */
10836 }
10843 else
10845 }
10846 }
10848 /*
10849 * We are exclusive on the ipsq, so an ill move will be serialized
10850 * before or after us.
10851 */
10855 /* Find based on address */
10863 /* We are a writer, so we should be able to lookup */
10867 /*
10868 * Maybe the address in on another interface in
10869 * the same IPMP group? We check this below.
10870 */
10873 ipst);
10874 }
10876 ipaddr_t addr;
10882 /* We are a writer, so we should be able to lookup */
10886 /*
10887 * Maybe the address in on another interface in
10888 * the same IPMP group? We check this below.
10889 */
10892 }
10893 }
10896 }
10897 /*
10898 * When the address to be removed is hosted on a different
10899 * interface, we check if the interface is in the same IPMP
10900 * group as the specified one; if so we proceed with the
10901 * removal.
10902 * ill->ill_group is NULL when the ill is down, so we have to
10903 * compare the group names instead.
10904 */
10912 }
10914 /* This is a writer */
10916 }
10918 /*
10919 * Can not delete instance zero since it is tied to the ill.
10920 */
10933 /* Are any references to this ipif active */
10941 }
10943 IPIF_FREE);
10948 else
10950 }
10952 /*
10953 * Restart the removeif ioctl. The refcnt has gone down to 0.
10954 * The ipif is already condemned. So can't find it thru lookups.
10955 */
10956 /* ARGSUSED */
10957 int
10960 {
10974 }
10982 }
10984 /*
10985 * Set the local interface address.
10986 * Allow an address of all zero when the interface is down.
10987 */
10988 /* ARGSUSED */
10989 int
10992 {
10994 in6_addr_t v6addr;
11015 /*
11016 * Enforce that true multicast interfaces have a link-local
11017 * address for logical unit 0.
11018 */
11025 }
11027 /*
11028 * up interfaces shouldn't have the unspecified address
11029 * unless they also have the IPIF_NOLOCAL flags set and
11030 * have a subnet assigned.
11031 */
11037 }
11042 ipaddr_t addr;
11049 /* Allow 0 as the local address. */
11054 }
11057 /*
11058 * Even if there is no change we redo things just to rerun
11059 * ipif_set_default.
11060 */
11062 /*
11063 * Setting a new local address, make sure
11064 * we have net and subnet bcast ire's for
11065 * the old address if we need them.
11066 */
11069 /*
11070 * If the interface is already marked up,
11071 * we call ipif_down which will take care
11072 * of ditching any IREs that have been set
11073 * up based on the old interface address.
11074 */
11080 }
11084 }
11086 int
11088 boolean_t need_up)
11089 {
11090 in6_addr_t v6addr;
11091 in6_addr_t ov6addr;
11092 ipaddr_t addr;
11097 boolean_t need_dl_down;
11098 boolean_t need_arp_down;
11107 /* Must cancel any pending timer before taking the ill_lock */
11120 }
11129 }
11132 /*
11133 * If the interface was previously marked as a duplicate, then since
11134 * we've now got a "new" address, it should no longer be considered a
11135 * duplicate -- even if the "new" address is the same as the old one.
11136 * Note that if all ipifs are down, we may have a pending ARP down
11137 * event to handle. This is because we want to recover from duplicates
11138 * and thus delay tearing down ARP until the duplicates have been
11139 * removed or disabled.
11140 */
11148 }
11149 }
11155 /*
11156 * The local address of this interface is a 6to4 address,
11157 * check if this interface is in fact a 6to4 tunnel or just
11158 * an interface configured with a 6to4 address. We are only
11159 * interested in the former.
11160 */
11168 /* set for use in IP */
11171 }
11173 }
11174 }
11175 }
11179 /*
11180 * When publishing an interface address change event, we only notify
11181 * the event listeners of the new address. It is assumed that if they
11182 * actively care about the addresses assigned that they will have
11183 * already discovered the previous address assigned (if there was one.)
11184 *
11185 * Don't attach nic event message for SIOCLIFADDIF ioctl.
11186 */
11196 }
11214 "address information for ADDRESS_CHANGE nic"
11218 }
11221 "ADDRESS_CHANGE nic event information for %s "
11225 }
11230 /*
11231 * Now bring the interface back up. If this
11232 * is the only IPIF for the ILL, ipif_up
11233 * will have to re-bind to the device, so
11234 * we may get back EINPROGRESS, in which
11235 * case, this IOCTL will get completed in
11236 * ip_rput_dlpi when we see the DL_BIND_ACK.
11237 */
11239 }
11247 }
11250 /*
11251 * Restart entry point to restart the address set operation after the
11252 * refcounts have dropped to zero.
11253 */
11254 /* ARGSUSED */
11255 int
11258 {
11264 }
11266 /* ARGSUSED */
11267 int
11270 {
11276 /*
11277 * The net mask and address can't change since we have a
11278 * reference to the ipif. So no lock is necessary.
11279 */
11294 }
11295 }
11297 }
11299 /*
11300 * Set the destination address for a pt-pt interface.
11301 */
11302 /* ARGSUSED */
11303 int
11306 {
11308 in6_addr_t v6addr;
11327 ipaddr_t addr;
11337 }
11343 /*
11344 * If the interface is already marked up,
11345 * we call ipif_down which will take care
11346 * of ditching any IREs that have been set
11347 * up based on the old pp dst address.
11348 */
11354 }
11355 /*
11356 * could return EINPROGRESS. If so ioctl will complete in
11357 * ip_rput_dlpi_writer
11358 */
11361 }
11363 static int
11365 boolean_t need_up)
11366 {
11367 in6_addr_t v6addr;
11370 boolean_t need_dl_down;
11371 boolean_t need_arp_down;
11376 /* Must cancel any pending timer before taking the ill_lock */
11387 ipaddr_t addr;
11391 }
11393 /* Set point to point destination address. */
11395 /*
11396 * Allow this as a means of creating logical
11397 * pt-pt interfaces on top of e.g. an Ethernet.
11398 * XXX Undocumented HACK for testing.
11399 * pt-pt interfaces are created with NUD disabled.
11400 */
11405 }
11407 /*
11408 * If the interface was previously marked as a duplicate, then since
11409 * we've now got a "new" address, it should no longer be considered a
11410 * duplicate -- even if the "new" address is the same as the old one.
11411 * Note that if all ipifs are down, we may have a pending ARP down
11412 * event to handle.
11413 */
11421 }
11422 }
11424 /* Set the new address. */
11426 /* Make sure subnet tracks pp_dst */
11431 /*
11432 * Now bring the interface back up. If this
11433 * is the only IPIF for the ILL, ipif_up
11434 * will have to re-bind to the device, so
11435 * we may get back EINPROGRESS, in which
11436 * case, this IOCTL will get completed in
11437 * ip_rput_dlpi when we see the DL_BIND_ACK.
11438 */
11440 }
11448 }
11450 /*
11451 * Restart entry point to restart the dstaddress set operation after the
11452 * refcounts have dropped to zero.
11453 */
11454 /* ARGSUSED */
11455 int
11458 {
11463 }
11465 /* ARGSUSED */
11466 int
11469 {
11474 /*
11475 * Get point to point destination address. The addresses can't
11476 * change since we hold a reference to the ipif.
11477 */
11490 }
11492 }
11494 /*
11495 * part of ipmp, make this func return the active/inactive state and
11496 * caller can set once atomically instead of multiple mutex_enter/mutex_exit
11497 */
11498 /*
11499 * This function either sets or clears the IFF_INACTIVE flag.
11500 *
11501 * As long as there are some addresses or multicast memberships on the
11502 * IPv4 or IPv6 interface of the "phyi" that does not belong in here, we
11503 * will consider it to be ACTIVE (clear IFF_INACTIVE) i.e the interface
11504 * will be used for outbound packets.
11505 *
11506 * Caller needs to verify the validity of setting IFF_INACTIVE.
11507 */
11508 static void
11510 {
11519 /*
11520 * No need for a lock while traversing the list since iam
11521 * a writer
11522 */
11532 }
11533 }
11541 }
11542 }
11543 }
11553 }
11554 }
11562 }
11563 }
11564 }
11568 }
11570 /*
11571 * This function is called only when the phyint flags change. Currently
11572 * called from ip_sioctl_flags. We re-do the broadcast nomination so
11573 * that we can select a good ill.
11574 */
11575 static void
11577 {
11586 }
11587 }
11589 /*
11590 * Heuristic to check if ill is INACTIVE.
11591 * Checks if ill has an ipif with an usable ip address.
11592 *
11593 * Return values:
11594 * B_TRUE - ill is INACTIVE; has no usable ipif
11595 * B_FALSE - ill is not INACTIVE; ill has at least one usable ipif
11596 */
11597 static boolean_t
11599 {
11602 /* Check whether it is in an IPMP group */
11612 /*
11613 * This ipif is usable if it is IPIF_UP and not a
11614 * dedicated test address. A dedicated test address
11615 * is marked IPIF_NOFAILOVER *and* IPIF_DEPRECATED
11616 * (note in particular that V6 test addresses are
11617 * link-local data addresses and thus are marked
11618 * IPIF_NOFAILOVER but not IPIF_DEPRECATED).
11619 */
11624 }
11626 }
11628 /*
11629 * Set interface flags.
11630 * Need to do special action for IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT,
11631 * IPIF_NOLOCAL, ILLF_NONUD, ILLF_NOARP, IPIF_PRIVATE, IPIF_ANYCAST,
11632 * IPIF_PREFERRED, PHYI_STANDBY, PHYI_FAILED and PHYI_OFFLINE.
11633 *
11634 * NOTE : We really don't enforce that ipif_id zero should be used
11635 * for setting any flags other than IFF_LOGINT_FLAGS. This
11636 * is because applications generally does SICGLIFFLAGS and
11637 * ORs in the new flags (that affects the logical) and does a
11638 * SIOCSLIFFLAGS. Thus, "flags" below could contain bits other
11639 * than IFF_LOGINT_FLAGS. One could check whether "turn_on" - the
11640 * flags that will be turned on is correct with respect to
11641 * ipif_id 0. For backward compatibility reasons, it is not done.
11642 */
11643 /* ARGSUSED */
11644 int
11647 {
11678 }
11682 /*
11683 * Has the flags been set correctly till now ?
11684 */
11688 /*
11689 * Compare the new flags to the old, and partition
11690 * into those coming on and those going off.
11691 * For the 16 bit command keep the bits above bit 16 unchanged.
11692 */
11696 /*
11697 * First check which bits will change and then which will
11698 * go on and off
11699 */
11708 /*
11709 * Don't allow any bits belonging to the logical interface
11710 * to be set or cleared on the replacement ipif that was
11711 * created temporarily during a MOVE.
11712 */
11716 }
11718 /*
11719 * Only allow the IFF_XRESOLV and IFF_TEMPORARY flags to be set on
11720 * IPv6 interfaces.
11721 */
11725 /*
11726 * cannot turn off IFF_NOXMIT on VNI interfaces.
11727 */
11731 /*
11732 * Don't allow the IFF_ROUTER flag to be turned on on loopback
11733 * interfaces. It makes no sense in that context.
11734 */
11741 /*
11742 * For IPv6 ipif_id 0, don't allow the interface to be up without
11743 * a link local address if IFF_NOLOCAL or IFF_ANYCAST are not set.
11744 * If the link local address isn't set, and can be set, it will get
11745 * set later on in this function.
11746 */
11753 }
11755 /*
11756 * ILL cannot be part of a usesrc group and and IPMP group at the
11757 * same time. No need to grab ill_g_usesrc_lock here, see
11758 * synchronization notes in ip.c
11759 */
11763 }
11765 /*
11766 * If we modify physical interface flags, we'll potentially need to
11767 * send up two routing socket messages for the changes (one for the
11768 * IPv4 ill, and another for the IPv6 ill). Note that here.
11769 */
11773 /*
11774 * If we are setting or clearing FAILED or STANDBY or OFFLINE,
11775 * we need to flush the IRE_CACHES belonging to this ill.
11776 * We handle this case here without doing the DOWN/UP dance
11777 * like it is done for other flags. If some other flags are
11778 * being turned on/off with FAILED/STANDBY/OFFLINE, the code
11779 * below will handle it by bringing it down and then
11780 * bringing it UP.
11781 */
11788 /*
11789 * First set the INACTIVE flag if needed. Then delete the ires.
11790 * ire_add will atomically prevent creating new IRE_CACHEs
11791 * unless hidden flag is set.
11792 * PHYI_FAILED and PHYI_INACTIVE are exclusive
11793 */
11797 /* Reset PHYI_INACTIVE when PHYI_FAILED is being set */
11799 }
11805 }
11808 /*
11809 * We implicitly set INACTIVE only when STANDBY is set.
11810 * INACTIVE is also set on non-STANDBY phyint when user
11811 * disables FAILBACK using configuration file.
11812 * Do not allow STANDBY to be set on such INACTIVE
11813 * phyint
11814 */
11819 }
11822 /*
11823 * Reset PHYI_INACTIVE.
11824 */
11828 /*
11829 * Need to set INACTIVE, when user sets
11830 * STANDBY on a non-STANDBY phyint and
11831 * later resets STANDBY
11832 */
11834 }
11835 }
11836 /*
11837 * We should always send up a message so that the
11838 * daemons come to know of it. Note that the zeroth
11839 * interface can be down and the check below for IPIF_UP
11840 * will not make sense as we are actually setting
11841 * a phyint flag here. We assume that the ipif used
11842 * is always the zeroth ipif. (ip_rts_ifmsg does not
11843 * send up any message for non-zero ipifs).
11844 */
11852 }
11858 }
11859 }
11861 /*
11862 * If ILLF_ROUTER changes, we need to change the ip forwarding
11863 * status of the interface and, if the interface is part of an IPMP
11864 * group, all other interfaces that are part of the same IPMP
11865 * group.
11866 */
11870 /*
11871 * If the interface is not UP and we are not going to
11872 * bring it UP, record the flags and return. When the
11873 * interface comes UP later, the right actions will be
11874 * taken.
11875 */
11878 /* Record new flags in their respective places. */
11890 /*
11891 * We do the broadcast and nomination here rather
11892 * than waiting for a FAILOVER/FAILBACK to happen. In
11893 * the case of FAILBACK from INACTIVE standby to the
11894 * interface that has been repaired, PHYI_FAILED has not
11895 * been cleared yet. If there are only two interfaces in
11896 * that group, all we have is a FAILED and INACTIVE
11897 * interface. If we do the nomination soon after a failback,
11898 * the broadcast nomination code would select the
11899 * INACTIVE interface for receiving broadcasts as FAILED is
11900 * not yet cleared. As we don't want STANDBY/INACTIVE to
11901 * receive broadcast packets, we need to redo nomination
11902 * when the FAILED is cleared here. Thus, in general we
11903 * always do the nomination here for FAILED, STANDBY
11904 * and OFFLINE.
11905 */
11909 }
11913 ill_ipif);
11914 }
11917 ill_ipif);
11918 }
11919 }
11928 }
11930 /*
11931 * Disallow IPv6 interfaces coming up that have the unspecified address,
11932 * or point-to-point interfaces with an unspecified destination. We do
11933 * allow the address to be unspecified for IPIF_NOLOCAL interfaces that
11934 * have a subnet assigned, which is how in.ndpd currently manages its
11935 * onlink prefix list when no addresses are configured with those
11936 * prefixes.
11937 */
11945 }
11947 /*
11948 * Prevent IPv4 point-to-point interfaces with a 0.0.0.0 destination
11949 * from being brought up.
11950 */
11955 }
11957 /*
11958 * The only flag changes that we currently take specific action on
11959 * is IPIF_UP, IPIF_DEPRECATED, IPIF_NOXMIT, IPIF_NOLOCAL,
11960 * ILLF_NOARP, ILLF_NONUD, IPIF_PRIVATE, IPIF_ANYCAST, and
11961 * IPIF_PREFERRED. This is done by bring the ipif down, changing
11962 * the flags and bringing it back up again.
11963 */
11967 /*
11968 * Taking this ipif down, make sure we have
11969 * valid net and subnet bcast ire's for other
11970 * logical interfaces, if we need them.
11971 */
11981 }
11987 }
11989 }
11991 static int
11993 boolean_t need_up)
11994 {
12022 /*
12023 * Now we change the flags. Track current value of
12024 * other flags in their respective places.
12025 */
12037 }
12041 }
12053 else
12057 /*
12058 * XXX ipif_up really does not know whether a phyint flags
12059 * was modified or not. So, it sends up information on
12060 * only one routing sockets message. As we don't bring up
12061 * the interface and also set STANDBY/FAILED simultaneously
12062 * it should be okay.
12063 */
12066 /*
12067 * Make sure routing socket sees all changes to the flags.
12068 * ipif_up_done* handles this when we use ipif_up.
12069 */
12073 ill_ipif);
12074 }
12077 ill_ipif);
12078 }
12081 }
12082 /*
12083 * Update the flags in SCTP's IPIF list, ipif_up() will do
12084 * this in need_up case.
12085 */
12087 }
12089 }
12091 /*
12092 * Restart entry point to restart the flags restart operation after the
12093 * refcounts have dropped to zero.
12094 */
12095 /* ARGSUSED */
12096 int
12099 {
12109 /*
12110 * Since ip_sioctl_flags expects an int and ifr_flags
12111 * is a short we need to cast ifr_flags into an int
12112 * to avoid having sign extension cause bits to get
12113 * set that should not be.
12114 */
12121 }
12123 }
12125 /*
12126 * Can operate on either a module or a driver queue.
12127 */
12128 /* ARGSUSED */
12129 int
12132 {
12133 /*
12134 * Has the flags been set correctly till now ?
12135 */
12145 /*
12146 * Need a lock since some flags can be set even when there are
12147 * references to the ipif.
12148 */
12153 /* Get interface flags (low 16 only). */
12159 /* Get interface flags. */
12162 }
12165 }
12167 /* ARGSUSED */
12168 int
12171 {
12187 }
12191 else
12197 /*
12198 * Change the MTU size in all relevant ire's.
12199 * Mtu change Vs. new ire creation - protocol below.
12200 * First change ipif_mtu and the ire_max_frag of the
12201 * interface ire. Then do an ire walk and change the
12202 * ire_max_frag of all affected ires. During ire_add
12203 * under the bucket lock, set the ire_max_frag of the
12204 * new ire being created from the ipif/ire from which
12205 * it is being derived. If an mtu change happens after
12206 * the ire is added, the new ire will be cleaned up.
12207 * Conversely if the mtu change happens before the ire
12208 * is added, ire_add will see the new value of the mtu.
12209 */
12215 else
12220 }
12225 ipst);
12226 else
12228 ipst);
12229 }
12230 /* Update the MTU in SCTP's list */
12233 }
12235 /* Get interface MTU. */
12236 /* ARGSUSED */
12237 int
12240 {
12252 }
12254 }
12256 /* Set interface broadcast address. */
12257 /* ARGSUSED2 */
12258 int
12261 {
12262 ipaddr_t addr;
12280 /*
12281 * If we are already up, make sure the new
12282 * broadcast address makes sense. If it does,
12283 * there should be an IRE for it already.
12284 * Don't match on ipif, only on the ill
12285 * since we are sharing these now. Don't use
12286 * MATCH_IRE_ILL_GROUP as we are looking for
12287 * the broadcast ire on this ill and each ill
12288 * in the group has its own broadcast ire.
12289 */
12297 }
12298 }
12299 /*
12300 * Changing the broadcast addr for this ipif.
12301 * Make sure we have valid net and subnet bcast
12302 * ire's for other logical interfaces, if needed.
12303 */
12308 }
12310 /* Get interface broadcast address. */
12311 /* ARGSUSED */
12312 int
12315 {
12321 /* IPIF_BROADCAST not possible with IPv6 */
12327 }
12329 /*
12330 * This routine is called to handle the SIOCS*IFNETMASK IOCTL.
12331 */
12332 /* ARGSUSED */
12333 int
12336 {
12338 in6_addr_t v6mask;
12354 ipaddr_t mask;
12361 }
12363 /*
12364 * No big deal if the interface isn't already up, or the mask
12365 * isn't really changing, or this is pt-pt.
12366 */
12375 }
12377 }
12378 /*
12379 * Make sure we have valid net and subnet broadcast ire's
12380 * for the old netmask, if needed by other logical interfaces.
12381 */
12391 }
12393 static int
12395 {
12396 in6_addr_t v6mask;
12408 ipaddr_t mask;
12412 }
12418 }
12422 /*
12423 * The interface must be DL_BOUND if this packet has to
12424 * go out on the wire. Since we only go through a logical
12425 * down and are bound with the driver during an internal
12426 * down/up that is satisfied.
12427 */
12429 /* Potentially broadcast an address mask reply. */
12431 }
12432 }
12434 }
12436 /* ARGSUSED */
12437 int
12440 {
12445 }
12447 /* Get interface net mask. */
12448 /* ARGSUSED */
12449 int
12452 {
12459 /*
12460 * net mask can't change since we have a reference to the ipif.
12461 */
12476 }
12477 }
12479 }
12481 /* ARGSUSED */
12482 int
12485 {
12489 /*
12490 * Set interface metric. We don't use this for
12491 * anything but we keep track of it in case it is
12492 * important to routing applications or such.
12493 */
12504 }
12506 }
12509 /* ARGSUSED */
12510 int
12513 {
12515 /* Get interface metric. */
12528 }
12531 }
12533 /* ARGSUSED */
12534 int
12537 {
12541 /*
12542 * Set the muxid returned from I_PLINK.
12543 */
12554 }
12556 }
12558 /* ARGSUSED */
12559 int
12562 {
12566 /*
12567 * Get the muxid saved in ill for I_PUNLINK.
12568 */
12579 }
12581 }
12583 /*
12584 * Set the subnet prefix. Does not modify the broadcast address.
12585 */
12586 /* ARGSUSED */
12587 int
12590 {
12592 in6_addr_t v6addr;
12593 in6_addr_t v6mask;
12614 ipaddr_t addr;
12623 /* Add 96 bits */
12625 }
12630 /* Check if bits in the address is set past the mask */
12639 /*
12640 * If the interface is already marked up,
12641 * we call ipif_down which will take care
12642 * of ditching any IREs that have been set
12643 * up based on the old interface address.
12644 */
12650 }
12654 }
12656 static int
12659 {
12666 /* Set the new address. */
12672 }
12676 /*
12677 * Now bring the interface back up. If this
12678 * is the only IPIF for the ILL, ipif_up
12679 * will have to re-bind to the device, so
12680 * we may get back EINPROGRESS, in which
12681 * case, this IOCTL will get completed in
12682 * ip_rput_dlpi when we see the DL_BIND_ACK.
12683 */
12687 }
12689 }
12691 /* ARGSUSED */
12692 int
12695 {
12697 in6_addr_t v6addr;
12698 in6_addr_t v6mask;
12712 ipaddr_t addr;
12717 }
12721 }
12723 /* ARGSUSED */
12724 int
12727 {
12746 }
12748 }
12750 /*
12751 * Set the IPv6 address token.
12752 */
12753 /* ARGSUSED */
12754 int
12757 {
12760 in6_addr_t v6addr;
12761 in6_addr_t v6mask;
12773 /* Only allow for logical unit zero i.e. not on "le0:17" */
12785 /*
12786 * The length of the token is the length from the end. To get
12787 * the proper mask for this, compute the mask of the bits not
12788 * in the token; ie. the prefix, and then xor to get the mask.
12789 */
12794 }
12806 }
12809 }
12811 static int
12814 {
12815 in6_addr_t v6addr;
12816 in6_addr_t v6mask;
12824 /*
12825 * The length of the token is the length from the end. To get
12826 * the proper mask for this, compute the mask of the bits not
12827 * in the token; ie. the prefix, and then xor to get the mask.
12828 */
12839 /*
12840 * Now bring the interface back up. If this
12841 * is the only IPIF for the ILL, ipif_up
12842 * will have to re-bind to the device, so
12843 * we may get back EINPROGRESS, in which
12844 * case, this IOCTL will get completed in
12845 * ip_rput_dlpi when we see the DL_BIND_ACK.
12846 */
12850 }
12852 }
12854 /* ARGSUSED */
12855 int
12858 {
12878 }
12880 /*
12881 * Set (hardware) link specific information that might override
12882 * what was acquired through the DL_INFO_ACK.
12883 * The logic is as follows.
12884 *
12885 * become exclusive
12886 * set CHANGING flag
12887 * change mtu on affected IREs
12888 * clear CHANGING flag
12889 *
12890 * An ire add that occurs before the CHANGING flag is set will have its mtu
12891 * changed by the ip_sioctl_lnkinfo.
12892 *
12893 * During the time the CHANGING flag is set, no new ires will be added to the
12894 * bucket, and ire add will fail (due the CHANGING flag).
12895 *
12896 * An ire add that occurs after the CHANGING flag is set will have the right mtu
12897 * before it is added to the bucket.
12898 *
12899 * Obviously only 1 thread can set the CHANGING flag and we need to become
12900 * exclusive to set the flag.
12901 */
12902 /* ARGSUSED */
12903 int
12906 {
12920 /* Only allow for logical unit zero i.e. not on "le0:17" */
12924 /* Set interface MTU. */
12927 else
12930 /*
12931 * Verify values before we set anything. Allow zero to
12932 * mean unspecified.
12933 */
12950 }
12958 }
12971 /*
12972 * Set the MTU on all ipifs associated with this ill except
12973 * for those whose MTU was fixed via SIOCSLIFMTU.
12974 */
12987 else
12992 }
12996 ill);
13000 ill);
13001 }
13002 }
13003 }
13009 }
13014 }
13016 /* ARGSUSED */
13017 int
13020 {
13036 }
13038 /*
13039 * Return best guess as to the subnet mask for the specified address.
13040 * Based on the subnet masks for all the configured interfaces.
13041 *
13042 * We end up returning a zero mask in the case of default, multicast or
13043 * experimental.
13044 */
13045 static ipaddr_t
13047 {
13048 ipaddr_t net_mask;
13051 ill_walk_context_t ctx;
13058 }
13060 /* Let's check to see if this is maybe a local subnet route. */
13061 /* this function only applies to IPv4 interfaces */
13074 /*
13075 * Don't trust pt-pt interfaces if there are
13076 * other interfaces.
13077 */
13082 }
13084 }
13086 /*
13087 * Fine. Just assume the same net mask as the
13088 * directly attached subnet interface is using.
13089 */
13097 }
13098 }
13100 }
13106 }
13108 /*
13109 * ip_sioctl_copyin_setup calls ip_wput_ioctl to process the IP_IOCTL ioctl.
13110 */
13111 static void
13113 {
13114 IOCP iocp;
13131 }
13133 /*
13134 * These IOCTLs provide various control capabilities to
13135 * upstream agents such as ULPs and processes. There
13136 * are currently two such IOCTLs implemented. They
13137 * are used by TCP to provide update information for
13138 * existing IREs and to forcibly delete an IRE for a
13139 * host that is not responding, thereby forcing an
13140 * attempt at a new route.
13141 */
13150 }
13151 /*
13152 * prefer credential from mblk over ioctl;
13153 * see ip_sioctl_copyin_setup
13154 */
13157 /*
13158 * Refhold the conn in case the request gets queued up in some lookup
13159 */
13168 }
13170 /*
13171 * CONN_OPER_PENDING_DONE happens in the function called
13172 * through ipft_pfi above.
13173 */
13175 }
13181 }
13184 done:
13189 }
13191 /*
13192 * Lookup an ipif using the sequence id (ipif_seqid)
13193 */
13194 ipif_t *
13196 {
13204 }
13206 }
13208 /*
13209 * Assign a unique id for the ipif. This is used later when we send
13210 * IRES to ARP for resolution where we initialize ire_ipif_seqid
13211 * to the value pointed by ire_ipif->ipif_seqid. Later when the
13212 * IRE is added, we verify that ipif has not disappeared.
13213 */
13215 static void
13217 {
13221 }
13223 /*
13224 * Insert the ipif, so that the list of ipifs on the ill will be sorted
13225 * with respect to ipif_id. Note that an ipif with an ipif_id of -1 will
13226 * be inserted into the first space available in the list. The value of
13227 * ipif_id will then be set to the appropriate value for its position.
13228 */
13229 static int
13231 {
13245 /*
13246 * In the case of lo0:0 we already hold the ill_g_lock.
13247 * ill_lookup_on_name (acquires ill_g_lock) -> ipif_allocate ->
13248 * ipif_insert. Another such caller is ipif_move.
13249 */
13262 id++;
13264 }
13265 /* limit number of logical interfaces */
13272 }
13275 /* we have a real id; insert ipif in the right place */
13281 }
13288 }
13299 }
13301 static void
13303 {
13310 else
13318 }
13319 }
13323 }
13325 /*
13326 * Allocate and initialize a new interface control structure. (Always
13327 * called as writer.)
13328 * When ipif_allocate() is called from ip_ll_subnet_defaults, the ill
13329 * is not part of the global linked list of ills. ipif_seqid is unique
13330 * in the system and to preserve the uniqueness, it is assigned only
13331 * when ill becomes part of the global list. At that point ill will
13332 * have a name. If it doesn't get assigned here, it will get assigned
13333 * in ipif_set_values() as part of SIOCSLIFNAME processing.
13334 * Aditionally, if we come here from ip_ll_subnet_defaults, we don't set
13335 * the interface flags or any other information from the DL_INFO_ACK for
13336 * DL_STYLE2 drivers (initialize == B_FALSE), since we won't have them at
13337 * this point. The flags etc. will be set in ip_ll_subnet_defaults when the
13338 * second DL_INFO_ACK comes in from the driver.
13339 */
13342 {
13356 /*
13357 * Inherit the zoneid from the ill; for the shared stack instance
13358 * this is always the global zone
13359 */
13370 }
13371 /* -1 id should have been replaced by real id */
13378 /*
13379 * Keep a copy of original id in ipif_orig_ipifid. Failback
13380 * will attempt to restore the original id. The SIOCSLIFOINDEX
13381 * ioctl sets ipif_orig_ipifid to zero.
13382 */
13385 /*
13386 * We grab the ill_lock and phyint_lock to protect the flag changes.
13387 * The ipif is still not up and can't be looked up until the
13388 * ioctl completes and the IPIF_CHANGING flag is cleared.
13389 */
13392 /*
13393 * Set the running flag when logical interface zero is created.
13394 * For subsequent logical interfaces, a DLPI link down
13395 * notification message may have cleared the running flag to
13396 * indicate the link is down, so we shouldn't just blindly set it.
13397 */
13411 /* Keep the IN6_IS_ADDR_V4MAPPED assertions happy */
13424 }
13426 /*
13427 * Don't set the interface flags etc. now, will do it in
13428 * ip_ll_subnet_defaults.
13429 */
13434 }
13438 /*
13439 * Later detect lack of DLPI driver multicast
13440 * capability by catching DL_ENABMULTI errors in
13441 * ip_rput_dlpi.
13442 */
13449 /*
13450 * Note: xresolv interfaces will eventually need
13451 * NOARP set here as well, but that will require
13452 * those external resolvers to have some
13453 * knowledge of that flag and act appropriately.
13454 * Not to be changed at present.
13455 */
13457 else
13459 }
13466 /* pt-pt supports multicast. */
13473 }
13474 }
13475 }
13476 }
13480 }
13482 /*
13483 * If appropriate, send a message up to the resolver delete the entry
13484 * for the address of this interface which is going out of business.
13485 * (Always called as writer).
13486 *
13487 * NOTE : We need to check for NULL mps as some of the fields are
13488 * initialized only for some interface types. See ipif_resolver_up()
13489 * for details.
13490 */
13491 void
13493 {
13500 /* Delete the mapping for the local address */
13507 }
13509 /*
13510 * If this is the last ipif that is going down and there are no
13511 * duplicate addresses we may yet attempt to re-probe, then we need to
13512 * clean up ARP completely.
13513 */
13516 /* Send up AR_INTERFACE_DOWN message */
13524 }
13526 /* Tell ARP to delete the multicast mappings */
13534 }
13535 }
13536 }
13538 /*
13539 * This function sets up the multicast mappings in ARP. When ipif_resolver_up
13540 * calls this function, it passes a non-NULL arp_add_mapping_mp indicating
13541 * that it wants the add_mp allocated in this function to be returned
13542 * wihtout sending it to arp. When ip_rput_dlpi_writer calls this to
13543 * just re-do the multicast, it wants us to send the add_mp to ARP also.
13544 * ipif_resolver_up does not want us to do the "add" i.e sending to ARP,
13545 * as it does a ipif_arp_down after calling this function - which will
13546 * remove what we add here.
13547 *
13548 * Returns -1 on failures and 0 on success.
13549 */
13550 int
13552 {
13568 /*
13569 * Delete the existing mapping from ARP. Normally ipif_down
13570 * -> ipif_arp_down should send this up to ARP. The only
13571 * reason we would find this when we are switching from
13572 * Multicast to Broadcast where we did not do a down.
13573 */
13580 }
13585 /*
13586 * Check that the address is not to long for the constant
13587 * length reserved in the template arma_t.
13588 */
13592 /* Add mapping mblk */
13604 /*
13605 * Determine the broadcast address.
13606 */
13610 else
13613 /*
13614 * Check PHYI_MULTI_BCAST and length of physical
13615 * address to determine if we use the mapping or the
13616 * broadcast address.
13617 */
13625 /* Make sure this will not match the "exact" entry. */
13632 }
13636 /* Use link-layer broadcast address for MULTI_BCAST */
13644 }
13648 /* It is neither MULTICAST nor MULTI_BCAST */
13650 }
13655 /* The caller just wants the mblks allocated */
13658 /* The caller wants us to send it to arp */
13660 }
13662 }
13664 /*
13665 * Get the resolver set up for a new interface address.
13666 * (Always called as writer.)
13667 * Called both for IPv4 and IPv6 interfaces,
13668 * though it only sets up the resolver for v6
13669 * if it's an xresolv interface (one using an external resolver).
13670 * Honors ILLF_NOARP.
13671 * The enumerated value res_act is used to tune the behavior.
13672 * If set to Res_act_initial, then we set up all the resolver
13673 * structures for a new interface. If set to Res_act_move, then
13674 * we just send an AR_ENTRY_ADD message up to ARP for IPv4
13675 * interfaces; this is called by ip_rput_dlpi_writer() to handle
13676 * asynchronous hardware address change notification. If set to
13677 * Res_act_defend, then we tell ARP that it needs to send a single
13678 * gratuitous message in defense of the address.
13679 * Returns error on failure.
13680 */
13681 int
13683 {
13684 caddr_t addr;
13695 boolean_t was_dup;
13704 /*
13705 * We're bringing an interface up here. There's no way that we
13706 * should need to shut down ARP now.
13707 */
13713 }
13715 }
13722 }
13723 /* NDP will set the ipif_addr_ready flag when it's ready */
13728 /*
13729 * External resolver for IPv6
13730 */
13736 }
13738 /*
13739 * IPv4 arp case. If the ARP stream has already started
13740 * closing, fail this request for ARP bringup. Else
13741 * record the fact that an ARP bringup is pending.
13742 */
13753 }
13758 }
13759 }
13761 /*
13762 * Add an entry for the local address in ARP only if it
13763 * is not UNNUMBERED and the address is not INADDR_ANY.
13764 */
13768 /* Now ask ARP to publish our address. */
13774 /*
13775 * Copy the new hardware address and length into
13776 * arp_add_mp to be sent to ARP.
13777 */
13782 }
13785 ACE_F_MYADDR;
13789 /*
13790 * If we're just defending our address now, then
13791 * there's no need to set up ARP multicast mappings.
13792 * The publish command is enough.
13793 */
13795 }
13800 /*
13801 * Allocate an ARP deletion message so we know we can tell ARP
13802 * when the interface goes down.
13803 */
13811 }
13812 /*
13813 * Need to bring up ARP or setup multicast mapping only
13814 * when the first interface is coming UP.
13815 */
13817 was_dup) {
13819 }
13821 /*
13822 * Allocate an ARP down message (to be saved) and an ARP up
13823 * message.
13824 */
13836 arp_setup_multicast:
13837 /*
13838 * Setup the multicast mappings. This function initializes
13839 * ill_arp_del_mapping_mp also. This does not need to be done for
13840 * IPv6.
13841 */
13848 }
13850 done:
13854 }
13858 }
13862 }
13867 }
13871 /*
13872 * If it's an extended ARP implementation, then we'll wait to
13873 * hear that DAD has finished before using the interface.
13874 */
13880 }
13885 }
13891 else
13902 }
13906 failed:
13915 }
13917 /*
13918 * This routine restarts IPv4 duplicate address detection (DAD) when a link has
13919 * just gone back up.
13920 */
13921 static void
13923 {
13933 /*
13934 * If we can't contact ARP for some reason, that's not really a
13935 * problem. Just send out the routing socket notification that
13936 * DAD completion would have done, and continue.
13937 */
13944 }
13946 /* Setting the 'unverified' flag restarts DAD */
13949 ACE_F_UNVERIFIED;
13951 }
13953 static void
13955 {
13963 /*
13964 * If we can't restart DAD for some reason, that's not really a
13965 * problem. Just send out the routing socket notification that
13966 * DAD completion would have done, and continue.
13967 */
13972 }
13974 }
13976 /*
13977 * Restart duplicate address detection on all interfaces on the given ill.
13978 *
13979 * This is called when an interface transitions from down to up
13980 * (DL_NOTE_LINK_UP) or up to down (DL_NOTE_LINK_DOWN).
13981 *
13982 * Note that since the underlying physical link has transitioned, we must cause
13983 * at least one routing socket message to be sent here, either via DAD
13984 * completion or just by default on the first ipif. (If we don't do this, then
13985 * in.mpathd will see long delays when doing link-based failure recovery.)
13986 */
13987 void
13989 {
13995 /*
13996 * If layer two doesn't support duplicate address detection, then just
13997 * send the routing socket message now and be done with it.
13998 */
14003 }
14010 else
14014 /*
14015 * For IPv4, the ARP module itself will
14016 * automatically start the DAD process when it
14017 * sees DL_NOTE_LINK_UP. We respond to the
14018 * AR_CN_READY at the completion of that task.
14019 * For IPv6, we must kick off the bring-up
14020 * process now.
14021 */
14024 /*
14025 * Unfortunately, the first ipif is "special"
14026 * and represents the underlying ill in the
14027 * routing socket messages. Thus, when this
14028 * one ipif is down, we must still notify so
14029 * that the user knows the IFF_RUNNING status
14030 * change. (If the first ipif is up, then
14031 * we'll handle eventual routing socket
14032 * notification via DAD completion.)
14033 */
14036 }
14038 /*
14039 * After link down, we'll need to send a new routing
14040 * message when the link comes back, so clear
14041 * ipif_addr_ready.
14042 */
14044 }
14045 }
14047 /*
14048 * If we've torn down links, then notify the user right away.
14049 */
14052 }
14054 /*
14055 * Wakeup all threads waiting to enter the ipsq, and sleeping
14056 * on any of the ills in this ipsq. The ill_lock of the ill
14057 * must be held so that waiters don't miss wakeups
14058 */
14059 static void
14061 {
14073 }
14081 }
14083 }
14084 }
14088 {
14095 }
14099 else
14108 }
14110 /*
14111 * Return an ipsq correspoding to the groupname. If 'create' is true
14112 * allocate a new ipsq if one does not exist. Usually an ipsq is associated
14113 * uniquely with an IPMP group. However during IPMP groupname operations,
14114 * multiple IPMP groups may be associated with a single ipsq. But no
14115 * IPMP group can be associated with more than 1 ipsq at any time.
14116 * For example
14117 * Interfaces IPMP grpname ipsq ipsq_name ipsq_refs
14118 * hme1, hme2 mpk17-84 ipsq1 mpk17-84 2
14119 * hme3, hme4 mpk17-85 ipsq2 mpk17-85 2
14120 *
14121 * Now the command ifconfig hme3 group mpk17-84 results in the temporary
14122 * status shown below during the execution of the above command.
14123 * hme1, hme2, hme3, hme4 mpk17-84, mpk17-85 ipsq1 mpk17-84 4
14124 *
14125 * After the completion of the above groupname command we return to the stable
14126 * state shown below.
14127 * hme1, hme2, hme3 mpk17-84 ipsq1 mpk17-84 3
14128 * hme4 mpk17-85 ipsq2 mpk17-85 1
14129 *
14130 * Because of the above, we don't search based on the ipsq_name since that
14131 * would miss the correct ipsq during certain windows as shown above.
14132 * The ipsq_name is only used during split of an ipsq to return the ipsq to its
14133 * natural state.
14134 */
14138 {
14147 group_len++;
14152 /*
14153 * When an ipsq is being split, and ill_split_ipsq
14154 * calls this function, we exclude it from being considered.
14155 */
14159 /*
14160 * Compare against the ipsq_name. The groupname change happens
14161 * in 2 phases. The 1st phase merges the from group into
14162 * the to group's ipsq, by calling ill_merge_groups and restarts
14163 * the ioctl. The 2nd phase then locates the ipsq again thru
14164 * ipsq_name. At this point the phyint_groupname has not been
14165 * updated.
14166 */
14169 /*
14170 * Verify that an ipmp groupname is exactly
14171 * part of 1 ipsq and is not found in any other
14172 * ipsq.
14173 */
14175 NULL);
14177 }
14179 /*
14180 * Comparison against ipsq_name alone is not sufficient.
14181 * In the case when groups are currently being
14182 * merged, the ipsq could hold other IPMP groups temporarily.
14183 * so we walk the phyint list and compare against the
14184 * phyint_groupname as well.
14185 */
14191 /*
14192 * Verify that an ipmp groupname is exactly
14193 * part of 1 ipsq and is not found in any other
14194 * ipsq.
14195 */
14199 }
14201 }
14202 }
14206 }
14208 static void
14210 {
14215 /*
14216 * We don't hold the ipsq lock, but we are sure no new
14217 * messages can land up, since the ipsq_refs is zero.
14218 * i.e. this ipsq is unnamed and no phyint or phyint group
14219 * is associated with this ipsq. (Lookups are based on ill_name
14220 * or phyint_groupname)
14221 */
14226 /*
14227 * This is not the ipsq of an IPMP group.
14228 */
14232 }
14236 /*
14237 * Locate the ipsq before we can remove it from
14238 * the singly linked list of ipsq's.
14239 */
14244 }
14246 }
14250 /* unlink ipsq from the list */
14253 else
14258 }
14260 static void
14263 {
14276 /*
14277 * move from old ipsq to the new ipsq.
14278 */
14284 }
14286 void
14288 {
14301 }
14304 }
14311 }
14314 }
14315 }
14316 /*
14317 * This function is called when an ill has had a change in its group status
14318 * to bring up all the ipifs that were up before the change.
14319 */
14320 int
14322 {
14332 /*
14333 * Except for ipif_state_flags and ill_state_flags the other
14334 * fields of the ipif/ill that are modified below are protected
14335 * implicitly since we are a writer. We would have tried to down
14336 * even an ipif that was already down, in ill_down_ipifs. So we
14337 * just blindly clear the IPIF_CHANGING flag here on all ipifs.
14338 */
14354 /*
14355 * Can there be any other error ?
14356 */
14359 }
14360 }
14361 }
14377 PHYI_STANDBY) {
14379 }
14381 PHYI_STANDBY) {
14383 }
14384 }
14386 }
14387 }
14402 /*
14403 * Can there be any other error ?
14404 */
14407 }
14408 }
14409 }
14425 }
14428 }
14430 }
14431 }
14433 }
14435 /*
14436 * bring down all the approriate ipifs.
14437 */
14438 /* ARGSUSED */
14439 static void
14441 {
14446 /*
14447 * Except for ipif_state_flags the other fields of the ipif/ill that
14448 * are modified below are protected implicitly since we are a writer
14449 */
14454 /*
14455 * We go through the ipif_down logic even if the ipif
14456 * is already down, since routes can be added based
14457 * on down ipifs. Going through ipif_down once again
14458 * will delete any IREs created based on these routes.
14459 */
14462 /*
14463 * If called with chk_nofailover true ipif is moving.
14464 */
14471 }
14473 /*
14474 * Need to re-create net/subnet bcast ires if
14475 * they are dependent on ipif.
14476 */
14482 }
14483 }
14484 }
14486 #define IPSQ_INC_REF(ipsq, ipst) { \
14487 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock)); \
14488 (ipsq)->ipsq_refs++; \
14489 }
14491 #define IPSQ_DEC_REF(ipsq, ipst) { \
14492 ASSERT(RW_WRITE_HELD(&ipst->ips_ill_g_lock)); \
14493 (ipsq)->ipsq_refs--; \
14494 if ((ipsq)->ipsq_refs == 0) \
14496 }
14498 /*
14499 * Change the ipsq of all the ill's whose current ipsq is 'cur_ipsq' to
14500 * new_ipsq.
14501 */
14502 static void
14504 {
14508 /*
14509 * To change the ipsq of an ill, we need to hold the ill_g_lock as
14510 * writer and the ill_lock of the ill in question. Also the dest
14511 * ipsq can't vanish while we hold the ill_g_lock as writer.
14512 */
14525 }
14526 }
14528 #define SPLIT_SUCCESS 0
14529 #define SPLIT_NOT_NEEDED 1
14530 #define SPLIT_FAILED 2
14532 int
14535 {
14538 /*
14539 * Assertions denote pre-requisites for changing the ipsq of
14540 * a phyint
14541 */
14543 /*
14544 * <ill-phyint> assocs can't change while ill_g_lock
14545 * is held as writer. See ill_phyint_reinit()
14546 */
14556 /*
14557 * Once we fail in creating a new ipsq due to memory shortage,
14558 * don't attempt to create new ipsq again, based on another
14559 * phyint, since we want all phyints belonging to an IPMP group
14560 * to be in the same ipsq even in the event of mem alloc fails.
14561 */
14565 /* Memory allocation failure */
14568 /* ipsq_refs protected by ill_g_lock (writer) */
14575 }
14576 }
14578 }
14580 /*
14581 * The ill locks of the phyint and the ill_g_lock (writer) must be held
14582 * to do this split
14583 */
14584 static int
14586 {
14590 /*
14591 * <ill-phyint> assocs can't change while ill_g_lock
14592 * is held as writer. See ill_phyint_reinit()
14593 */
14602 /*
14603 * ipsq_init failed due to no memory
14604 * caller will use the same ipsq
14605 */
14607 }
14609 /* ipsq_ref is protected by ill_g_lock (writer) */
14612 /*
14613 * This is a new ipsq that is unknown to the world.
14614 * So we don't need to hold ipsq_lock,
14615 */
14620 #ifdef DEBUG
14622 #endif
14625 }
14627 /*
14628 * Change the ipsq of all the ill's whose current ipsq is 'cur_ipsq' to
14629 * ipsq's representing their individual groups or themselves. Return
14630 * whether split needs to be retried again later.
14631 */
14632 static boolean_t
14634 {
14645 /*
14646 * 'created' will tell us whether the callee actually
14647 * created an ipsq. Lack of memory may force the callee
14648 * to return without creating an ipsq.
14649 */
14655 }
14660 /* FALLTHRU */
14662 /*
14663 * Keep it on the list.
14664 */
14672 }
14675 }
14677 }
14679 /*
14680 * given an ipsq 'ipsq' lock all ills associated with this ipsq.
14681 * and return the ills in the list. This list will be
14682 * needed to unlock all the ills later on by the caller.
14683 * The <ill-ipsq> associations could change between the
14684 * lock and unlock. Hence the unlock can't traverse the
14685 * ipsq to get the list of ills.
14686 */
14687 static int
14689 {
14694 /*
14695 * The caller holds ill_g_lock to ensure that the ill memberships
14696 * of the ipsq don't change
14697 */
14705 }
14709 }
14711 }
14714 }
14716 void
14718 {
14722 boolean_t try_again;
14729 /* swap the elements */
14734 }
14735 }
14737 }
14743 else
14747 }
14748 }
14749 }
14751 void
14753 {
14761 }
14762 }
14763 }
14765 /*
14766 * Merge all the ills from 1 ipsq group into another ipsq group.
14767 * The source ipsq group is specified by the ipsq associated with
14768 * 'from_ill'. The destination ipsq group is specified by the ipsq
14769 * associated with 'to_ill' or 'groupname' respectively.
14770 * Note that ipsq itself does not have a reference count mechanism
14771 * and functions don't look up an ipsq and pass it around. Instead
14772 * functions pass around an ill or groupname, and the ipsq is looked
14773 * up from the ill or groupname and the required operation performed
14774 * atomically with the lookup on the ipsq.
14775 */
14776 static int
14779 {
14789 /* Exactly 1 of 'to_ill' and groupname can be specified. */
14792 /*
14793 * Need to hold ill_g_lock as writer and also the ill_lock to
14794 * change the <ill-ipsq> assoc of an ill. Need to hold the
14795 * ipsq_lock to prevent new messages from landing on an ipsq.
14796 */
14804 }
14808 /*
14809 * both groups are on the same ipsq.
14810 */
14814 }
14822 }
14825 /* Need ipsq lock to enque messages on new ipsq or to become writer */
14833 }
14835 /*
14836 * We are holding ill_g_lock as writer and all the ill locks of
14837 * the old ipsq. So the old_ipsq can't be looked up, and hence no new
14838 * message can land up on the old ipsq even though we don't hold the
14839 * ipsq_lock of the old_ipsq. Now move all messages to the newipsq.
14840 */
14843 /*
14844 * now change the ipsq of all ills in the 'old_ipsq' to 'new_ipsq'.
14845 * 'new_ipsq' has been looked up, and it can't change its <ill-ipsq>
14846 * assocs. till we release the ill_g_lock, and hence it can't vanish.
14847 */
14850 /*
14851 * Mark the new ipsq as needing a split since it is currently
14852 * being shared by more than 1 IPMP group. The split will
14853 * occur at the end of ipsq_exit
14854 */
14857 /* Now release all the locks */
14864 /*
14865 * If we succeeded in becoming writer on the new ipsq, then
14866 * drain the new ipsq and start processing all enqueued messages
14867 * including the current ioctl we are processing which is either
14868 * a set groupname or failover/failback.
14869 */
14873 /*
14874 * syncq has been changed and all the messages have been moved.
14875 */
14881 }
14883 /*
14884 * Delete and add the loopback copy and non-loopback copy of
14885 * the BROADCAST ire corresponding to ill and addr. Used to
14886 * group broadcast ires together when ill becomes part of
14887 * a group.
14888 *
14889 * This function is also called when ill is leaving the group
14890 * so that the ires belonging to the group gets re-grouped.
14891 */
14892 static void
14894 {
14899 /*
14900 * The loopback and non-loopback IREs are inserted in the order in which
14901 * they're found, on the basis that they are correctly ordered (loopback
14902 * first).
14903 */
14910 /*
14911 * we are passing in KM_SLEEP because it is not easy to
14912 * go back to a sane state in case of memory failure.
14913 */
14917 /*
14918 * Don't use ire_max_frag directly since we don't
14919 * hold on to 'ire' until we add the new ire 'nire' and
14920 * we don't want the new ire to have a dangling reference
14921 * to 'ire'. The ire_max_frag of a broadcast ire must
14922 * be in sync with the ipif_mtu of the associate ipif.
14923 * For eg. this happens as a result of SIOCSLIFNAME,
14924 * SIOCSLIFLNKINFO or a DL_NOTE_SDU_SIZE inititated by
14925 * the driver. A change in ire_max_frag triggered as
14926 * as a result of path mtu discovery, or due to an
14927 * IP_IOC_IRE_ADVISE_NOREPLY from the transport or due a
14928 * route change -mtu command does not apply to broadcast ires.
14929 *
14930 * XXX We need a recovery strategy here if ire_init fails
14931 */
14949 NULL,
14950 NULL,
14953 }
14957 /*
14958 * The newly created IREs are inserted at the tail of the list
14959 * starting with ire_head. As we've just allocated them no one
14960 * knows about them so it's safe.
14961 */
14964 }
14969 /* unlink the IRE from our list before calling ire_add() */
14973 /* ire_add adds the ire at the right place in the list */
14979 }
14980 }
14982 /*
14983 * This function is usually called when an ill is inserted in
14984 * a group and all the ipifs are already UP. As all the ipifs
14985 * are already UP, the broadcast ires have already been created
14986 * and been inserted. But, ire_add_v4 would not have grouped properly.
14987 * We need to re-group for the benefit of ip_wput_ire which
14988 * expects BROADCAST ires to be grouped properly to avoid sending
14989 * more than one copy of the broadcast packet per group.
14990 *
14991 * NOTE : We don't check for ill_ipif_up_count to be non-zero here
14992 * because when ipif_up_done ends up calling this, ires have
14993 * already been added before illgrp_insert i.e before ill_group
14994 * has been initialized.
14995 */
14996 static void
14998 {
15001 ipaddr_t addr;
15002 ipaddr_t net_mask;
15003 ipaddr_t subnet_netmask;
15007 /*
15008 * This function is called even when an ill is deleted from
15009 * the group. Hence, illgrp could be null.
15010 */
15014 /*
15015 * Delete all the BROADCAST ires matching this ill and add
15016 * them back. This time, ire_add_v4 should take care of
15017 * grouping them with others because ill is part of the
15018 * group.
15019 */
15030 }
15039 }
15040 }
15042 /*
15043 * This function is called from illgrp_delete when ill is being deleted
15044 * from the group.
15045 *
15046 * As ill is not there in the group anymore, any address belonging
15047 * to this ill should be cleared of IRE_MARK_NORECV.
15048 */
15049 static void
15051 {
15062 /*
15063 * IPMP and plumbing operations are serialized on the ipsq, so
15064 * no one will insert or delete a broadcast ire under our feet.
15065 */
15078 }
15080 }
15081 }
15083 /*
15084 * This function must be called only after the broadcast ires
15085 * have been grouped together. For a given address addr, nominate
15086 * only one of the ires whose interface is not FAILED or OFFLINE.
15087 *
15088 * This is also called when an ipif goes down, so that we can nominate
15089 * a different ire with the same address for receiving.
15090 */
15091 static void
15093 {
15109 uint_t max_frag;
15113 /*
15114 * We may not be able to find some ires if a previous
15115 * ire_create failed. This happens when an ipif goes
15116 * down and we are unable to create BROADCAST ires due
15117 * to memory failure. Thus, we have to check for NULL
15118 * below. This should handle the case for LOOPBACK,
15119 * POINTOPOINT and interfaces with some POINTOPOINT
15120 * logicals for which there are no BROADCAST ires.
15121 */
15124 /*
15125 * Currently IRE_BROADCASTS are deleted when an ipif
15126 * goes down which runs exclusively. Thus, setting
15127 * IRE_MARK_RCVD should not race with ire_delete marking
15128 * IRE_MARK_CONDEMNED. We grab the lock below just to
15129 * be consistent with other parts of the code that walks
15130 * a given bucket.
15131 */
15138 }
15144 }
15147 /*
15148 * Get to the first ire matching the address and the
15149 * group. If the address does not match we are done
15150 * as we could not find the IRE. If the address matches
15151 * we should get to the first one matching the group.
15152 */
15157 }
15159 }
15162 redo:
15165 /*
15166 * The first ire for any address within a group
15167 * should always be the one with IRE_MARK_NORECV cleared
15168 * so that ip_wput_ire can avoid searching for one.
15169 * Note down the insertion point which will be used
15170 * later.
15171 */
15174 /*
15175 * PHYI_FAILED is set when the interface fails.
15176 * This interface might have become good, but the
15177 * daemon has not yet detected. We should still
15178 * not receive on this. PHYI_OFFLINE should never
15179 * be picked as this has been offlined and soon
15180 * be removed.
15181 */
15187 }
15192 PHYI_INACTIVE) {
15194 }
15196 }
15198 /*
15199 * We will move this to the front of the list later
15200 * on.
15201 */
15206 }
15209 }
15210 /*
15211 * If we never nominated anybody, try nominating at least
15212 * an INACTIVE, if we found one. Do it only once though.
15213 */
15215 fallback) {
15220 }
15223 /*
15224 * irep non-NULL indicates that we entered the while loop
15225 * above. If clear_ire is at the insertion point, we don't
15226 * have to do anything. clear_ire will be NULL if all the
15227 * interfaces are failed.
15228 *
15229 * We cannot unlink and reinsert the ire at the right place
15230 * in the list since there can be other walkers of this bucket.
15231 * Instead we delete and recreate the ire
15232 */
15237 /* XXX We need a recovery strategy here. */
15254 NULL,
15255 NULL,
15268 /* XXX We need a recovery strategy here. */
15275 NULL,
15285 NULL,
15286 NULL,
15289 }
15290 }
15292 /*
15293 * Delete the ire. We can't call ire_delete() since
15294 * we are holding the bucket lock. We can't release the
15295 * bucket lock since we can't allow irep to change. So just
15296 * mark it CONDEMNED. The IRB_REFRELE will delete the
15297 * ire from the list and do the refrele.
15298 */
15305 }
15307 /*
15308 * Also take care of otherfields like ib/ob pkt count
15309 * etc. Need to dup them. ditto in ill_bcast_delete_and_add
15310 */
15312 /* Set the max_frag before adding the ire */
15317 /* Add the new ire's. Insert at *irep */
15323 /* Link the new one in. */
15333 /* Set the max_frag before adding the ire */
15340 /* Add the new ire. Insert at *irep */
15345 /* Link the new one in. */
15351 ire_stats_inserted);
15355 }
15356 }
15363 }
15365 /*
15366 * Whenever an ipif goes down we have to renominate a different
15367 * broadcast ire to receive. Whenever an ipif comes up, we need
15368 * to make sure that we have only one nominated to receive.
15369 */
15370 static void
15372 {
15374 ipaddr_t subnet_addr;
15375 ipaddr_t net_addr;
15377 ipaddr_t subnet_netmask;
15378 ipaddr_t addr;
15383 /*
15384 * If this is the last ipif going down, it might take
15385 * the ill out of the group. In that case ipif_down ->
15386 * illgrp_delete takes care of doing the nomination.
15387 * ipif_down does not call for this case.
15388 */
15391 /* There could not have been any ires associated with this */
15403 }
15416 }
15418 /*
15419 * Whenever we form or delete ill groups, we need to nominate one set of
15420 * BROADCAST ires for receiving in the group.
15421 *
15422 * 1) When ipif_up_done -> ilgrp_insert calls this function, BROADCAST ires
15423 * have been added, but ill_ipif_up_count is 0. Thus, we don't assert
15424 * for ill_ipif_up_count to be non-zero. This is the only case where
15425 * ill_ipif_up_count is zero and we would still find the ires.
15426 *
15427 * 2) ip_sioctl_group_name/ifgrp_insert calls this function, at least one
15428 * ipif is UP and we just have to do the nomination.
15429 *
15430 * 3) When ill_handoff_responsibility calls us, some ill has been removed
15431 * from the group. So, we have to do the nomination.
15432 *
15433 * Because of (3), there could be just one ill in the group. But we have
15434 * to nominate still as IRE_MARK_NORCV may have been marked on this.
15435 * Thus, this function does not optimize when there is only one ill as
15436 * it is not correct for (3).
15437 */
15438 static void
15440 {
15443 ipaddr_t subnet_addr;
15445 ipaddr_t net_addr;
15448 ipaddr_t subnet_netmask;
15449 ipaddr_t addr;
15452 /*
15453 * When the last memeber is leaving, there is nothing to
15454 * nominate.
15455 */
15459 }
15464 /*
15465 * We assume that ires with same address and belonging to the
15466 * same group, has been grouped together. Nominating a *single*
15467 * ill in the group for sending and receiving broadcast is done
15468 * by making sure that the first BROADCAST ire (which will be
15469 * the one returned by ire_ctable_lookup for ip_rput and the
15470 * one that will be used in ip_wput_ire) will be the one that
15471 * will not have IRE_MARK_NORECV set.
15472 *
15473 * 1) ip_rput checks and discards packets received on ires marked
15474 * with IRE_MARK_NORECV. Thus, we don't send up duplicate
15475 * broadcast packets. We need to clear IRE_MARK_NORECV on the
15476 * first ire in the group for every broadcast address in the group.
15477 * ip_rput will accept packets only on the first ire i.e only
15478 * one copy of the ill.
15479 *
15480 * 2) ip_wput_ire needs to send out just one copy of the broadcast
15481 * packet for the whole group. It needs to send out on the ill
15482 * whose ire has not been marked with IRE_MARK_NORECV. If it sends
15483 * on the one marked with IRE_MARK_NORECV, ip_rput will accept
15484 * the copy echoed back on other port where the ire is not marked
15485 * with IRE_MARK_NORECV.
15486 *
15487 * Note that we just need to have the first IRE either loopback or
15488 * non-loopback (either of them may not exist if ire_create failed
15489 * during ipif_down) with IRE_MARK_NORECV not set. ip_rput will
15490 * always hit the first one and hence will always accept one copy.
15491 *
15492 * We have a broadcast ire per ill for all the unique prefixes
15493 * hosted on that ill. As we don't have a way of knowing the
15494 * unique prefixes on a given ill and hence in the whole group,
15495 * we just call ill_mark_bcast on all the prefixes that exist
15496 * in the group. For the common case of one prefix, the code
15497 * below optimizes by remebering the last address used for
15498 * markng. In the case of multiple prefixes, this will still
15499 * optimize depending the order of prefixes.
15500 *
15501 * The only unique address across the whole group is 0.0.0.0 and
15502 * 255.255.255.255 and thus we call only once. ill_mark_bcast enables
15503 * the first ire in the bucket for receiving and disables the
15504 * others.
15505 */
15516 }
15522 }
15528 }
15538 }
15540 }
15541 }
15542 }
15544 /*
15545 * This function is called while forming ill groups.
15546 *
15547 * Currently, we handle only allmulti groups. We want to join
15548 * allmulti on only one of the ills in the groups. In future,
15549 * when we have link aggregation, we may have to join normal
15550 * multicast groups on multiple ills as switch does inbound load
15551 * balancing. Following are the functions that calls this
15552 * function :
15553 *
15554 * 1) ill_recover_multicast : Interface is coming back UP.
15555 * When the first ipif comes back UP, ipif_up_done/ipif_up_done_v6
15556 * will call ill_recover_multicast to recover all the multicast
15557 * groups. We need to make sure that only one member is joined
15558 * in the ill group.
15559 *
15560 * 2) ip_addmulti/ip_addmulti_v6 : ill groups has already been formed.
15561 * Somebody is joining allmulti. We need to make sure that only one
15562 * member is joined in the group.
15563 *
15564 * 3) illgrp_insert : If allmulti has already joined, we need to make
15565 * sure that only one member is joined in the group.
15566 *
15567 * 4) ip_delmulti/ip_delmulti_v6 : Somebody in the group is leaving
15568 * allmulti who we have nominated. We need to pick someother ill.
15569 *
15570 * 5) illgrp_delete : The ill we nominated is leaving the group,
15571 * we need to pick a new ill to join the group.
15572 *
15573 * For (1), (2), (5) - we just have to check whether there is
15574 * a good ill joined in the group. If we could not find any ills
15575 * joined the group, we should join.
15576 *
15577 * For (4), the one that was nominated to receive, left the group.
15578 * There could be nobody joined in the group when this function is
15579 * called.
15580 *
15581 * For (3) - we need to explicitly check whether there are multiple
15582 * ills joined in the group.
15583 *
15584 * For simplicity, we don't differentiate any of the above cases. We
15585 * just leave the group if it is joined on any of them and join on
15586 * the first good ill.
15587 */
15588 int
15590 {
15597 /*
15598 * Leave the allmulti on all the ills and start fresh.
15599 */
15604 }
15606 /*
15607 * Choose a good ill. Fallback to inactive or failed if
15608 * none available. We need to fallback to FAILED in the
15609 * case where we have 2 interfaces in a group - where
15610 * one of them is failed and another is a good one and
15611 * the good one (not marked inactive) is leaving the group.
15612 */
15616 /* Never pick an offline interface */
15623 }
15627 }
15631 /*
15632 * ip_join_allmulti can fail because of memory
15633 * failures. So, make sure we join at least
15634 * on one ill.
15635 */
15638 }
15639 }
15640 }
15642 /*
15643 * If we tried nominating above and failed to do so,
15644 * return error. We might have tried multiple times.
15645 * But, return the latest error.
15646 */
15648 }
15654 }
15655 }
15661 }
15662 }
15663 }
15665 }
15667 /*
15668 * This function is called from illgrp_delete after it is
15669 * deleted from the group to reschedule responsibilities
15670 * to a different ill.
15671 */
15672 static void
15674 {
15677 ipaddr_t subnet_addr;
15678 ipaddr_t net_addr;
15680 ipaddr_t subnet_netmask;
15681 ipaddr_t addr;
15685 /*
15686 * Broadcast Responsibility:
15687 *
15688 * 1. If this ill has been nominated for receiving broadcast
15689 * packets, we need to find a new one. Before we find a new
15690 * one, we need to re-group the ires that are part of this new
15691 * group (assumed by ill_nominate_bcast_rcv). We do this by
15692 * calling ill_group_bcast_for_xmit(ill) which will do the right
15693 * thing for us.
15694 *
15695 * 2. If this ill was not nominated for receiving broadcast
15696 * packets, we need to clear the IRE_MARK_NORECV flag
15697 * so that we continue to send up broadcast packets.
15698 */
15700 /*
15701 * Case 1 above : No optimization here. Just redo the
15702 * nomination.
15703 */
15707 /*
15708 * Case 2 above : Lookup and clear IRE_MARK_NORECV.
15709 */
15719 }
15725 }
15738 }
15739 }
15741 /*
15742 * Multicast Responsibility.
15743 *
15744 * If we have joined allmulti on this one, find a new member
15745 * in the group to join allmulti. As this ill is already part
15746 * of allmulti, we don't have to join on this one.
15747 *
15748 * If we have not joined allmulti on this one, there is no
15749 * responsibility to handoff. But we need to take new
15750 * responsibility i.e, join allmulti on this one if we need
15751 * to.
15752 */
15760 }
15761 }
15762 }
15764 /*
15765 * We intentionally do the flushing of IRE_CACHES only matching
15766 * on the ill and not on groups. Note that we are already deleted
15767 * from the group.
15768 *
15769 * This will make sure that all IRE_CACHES whose stq is pointing
15770 * at ill_wq or ire_ipif->ipif_ill pointing at this ill will get
15771 * deleted and IRE_CACHES that are not pointing at this ill will
15772 * be left alone.
15773 */
15780 }
15782 /*
15783 * Some conn may have cached one of the IREs deleted above. By removing
15784 * the ire reference, we clean up the extra reference to the ill held in
15785 * ire->ire_stq.
15786 */
15789 /*
15790 * Re-do source address selection for all the members in the
15791 * group, if they borrowed source address from one of the ipifs
15792 * in this ill.
15793 */
15799 }
15800 }
15801 }
15803 /*
15804 * Delete the ill from the group. The caller makes sure that it is
15805 * in a group and it okay to delete from the group. So, we always
15806 * delete here.
15807 */
15808 static void
15810 {
15816 /*
15817 * Reset illgrp_ill_schednext if it was pointing at us.
15818 * We need to do this before we set ill_group to NULL.
15819 */
15827 /* Delete the ill from illgrp. */
15835 }
15837 }
15845 /*
15846 * As this ill is leaving the group, we need to hand off
15847 * the responsibilities to the other ills in the group, if
15848 * this ill had some responsibilities.
15849 */
15866 }
15868 }
15877 }
15879 }
15880 }
15883 }
15886 /*
15887 * Even though the ill is out of the group its not necessary
15888 * to set ipsq_split as TRUE as the ipifs could be down temporarily
15889 * We will split the ipsq when phyint_groupname is set to NULL.
15890 */
15892 /*
15893 * Send a routing sockets message if we are deleting from
15894 * groups with names.
15895 */
15898 }
15900 /*
15901 * Re-do source address selection. This is normally called when
15902 * an ill joins the group or when a non-NOLOCAL/DEPRECATED/ANYCAST
15903 * ipif comes up.
15904 */
15905 void
15907 {
15920 else
15922 }
15923 }
15924 }
15926 /*
15927 * Insert ill in a group headed by illgrp_head. The caller can either
15928 * pass a groupname in which case we search for a group with the
15929 * same name to insert in or pass a group to insert in. This function
15930 * would only search groups with names.
15931 *
15932 * NOTE : The caller should make sure that there is at least one ipif
15933 * UP on this ill so that illgrp_scheduler can pick this ill
15934 * for outbound packets. If ill_ipif_up_count is zero, we have
15935 * already sent a DL_UNBIND to the driver and we don't want to
15936 * send anymore packets. We don't assert for ipif_up_count
15937 * to be greater than zero, because ipif_up_done wants to call
15938 * this function before bumping up the ipif_up_count. See
15939 * ipif_up_done() for details.
15940 */
15941 int
15944 {
15956 /*
15957 * Look for a group with a matching groupname to insert.
15958 */
15964 /*
15965 * If we have an ill_group_t in the list which has
15966 * no ill_t assigned then we must be in the process of
15967 * removing this group. We skip this as illgrp_delete()
15968 * will remove it from the list.
15969 */
15973 }
15977 /*
15978 * Look at groups which has names only.
15979 */
15982 /*
15983 * Names are stored in the phyint common to both
15984 * IPv4 and IPv6.
15985 */
15989 }
15990 }
15992 /*
15993 * If the caller passes in a NULL "grp_to_insert", we
15994 * allocate one below and insert this singleton.
15995 */
15997 }
16005 }
16011 /*
16012 * Used in illgrp_scheduler to protect multiple threads
16013 * from traversing the list.
16014 */
16021 /* Insert ill at tail of this group */
16028 /*
16029 * Inherit group properties. Currently only forwarding
16030 * is the property we try to keep the same with all the
16031 * ills. When there are more, we will abstract this into
16032 * a function.
16033 */
16036 }
16040 /*
16041 * 1) When ipif_up_done() calls this function, ipif_up_count
16042 * may be zero as it has not yet been bumped. But the ires
16043 * have already been added. So, we do the nomination here
16044 * itself. But, when ip_sioctl_groupname calls this, it checks
16045 * for ill_ipif_up_count != 0. Thus we don't check for
16046 * ill_ipif_up_count here while nominating broadcast ires for
16047 * receive.
16048 *
16049 * 2) Similarly, we need to call ill_group_bcast_for_xmit here
16050 * to group them properly as ire_add() has already happened
16051 * in the ipif_up_done() case. For ip_sioctl_groupname/ifgrp_insert
16052 * case, we need to do it here anyway.
16053 */
16057 }
16060 /*
16061 * When ipif_up_done() calls this function, the multicast
16062 * groups have not been joined yet. So, there is no point in
16063 * nomination. ip_join_allmulti will handle groups when
16064 * ill_recover_multicast is called from ipif_up_done() later.
16065 */
16067 /*
16068 * ipif_up_done calls ill_update_source_selection
16069 * anyway. Moreover, we don't want to re-create
16070 * interface routes while ipif_up_done() still has reference
16071 * to them. Refer to ipif_up_done() for more details.
16072 */
16074 }
16076 /*
16077 * Send a routing sockets message if we are inserting into
16078 * groups with names.
16079 */
16083 }
16085 /*
16086 * Return the first phyint matching the groupname. There could
16087 * be more than one when there are ill groups.
16088 *
16089 * If 'usable' is set, then we exclude ones that are marked with any of
16090 * (PHYI_FAILED|PHYI_OFFLINE|PHYI_INACTIVE).
16091 * Needs work: called only from ip_sioctl_groupname and from the ipmp/netinfo
16092 * emulation of ipmp.
16093 */
16094 phyint_t *
16096 {
16100 /*
16101 * Group names are stored in the phyint - a common structure
16102 * to both IPv4 and IPv6.
16103 */
16110 /*
16111 * Skip the ones that should not be used since the callers
16112 * sometime use this for sending packets.
16113 */
16121 }
16123 }
16126 /*
16127 * Return the first usable phyint matching the group index. By 'usable'
16128 * we exclude ones that are marked ununsable with any of
16129 * (PHYI_FAILED|PHYI_OFFLINE|PHYI_INACTIVE).
16130 *
16131 * Used only for the ipmp/netinfo emulation of ipmp.
16132 */
16133 phyint_t *
16135 {
16143 /*
16144 * Group indicies are stored in the phyint - a common structure
16145 * to both IPv4 and IPv6.
16146 */
16151 /* Ignore the ones that do not have a group */
16156 /*
16157 * Skip the ones that should not be used since the callers
16158 * sometime use this for sending packets.
16159 */
16165 }
16167 }
16170 /*
16171 * MT notes on creation and deletion of IPMP groups
16172 *
16173 * Creation and deletion of IPMP groups introduce the need to merge or
16174 * split the associated serialization objects i.e the ipsq's. Normally all
16175 * the ills in an IPMP group would map to a single ipsq. If IPMP is not enabled
16176 * an ill-pair(v4, v6) i.e. phyint would map to a single ipsq. However during
16177 * the execution of the SIOCSLIFGROUPNAME command the picture changes. There
16178 * is a need to change the <ill-ipsq> association and we have to operate on both
16179 * the source and destination IPMP groups. For eg. attempting to set the
16180 * groupname of hme0 to mpk17-85 when it already belongs to mpk17-84 has to
16181 * handle 2 IPMP groups and 2 ipsqs. All the ills belonging to either of the
16182 * source or destination IPMP group are mapped to a single ipsq for executing
16183 * the SIOCSLIFGROUPNAME command. This is termed as a merge of the ipsq's.
16184 * The <ill-ipsq> mapping is restored back to normal at a later point. This is
16185 * termed as a split of the ipsq. The converse of the merge i.e. a split of the
16186 * ipsq happens while unwinding from ipsq_exit. If at least 1 set groupname
16187 * occurred on the ipsq, then the ipsq_split flag is set. This indicates the
16188 * ipsq has to be examined for redoing the <ill-ipsq> associations.
16189 *
16190 * In the above example the ioctl handling code locates the current ipsq of hme0
16191 * which is ipsq(mpk17-84). It then enters the above ipsq immediately or
16192 * eventually (after queueing the ioctl in ipsq(mpk17-84)). Then it locates
16193 * the destination ipsq which is ipsq(mpk17-85) and merges the source ipsq into
16194 * the destination ipsq. If the destination ipsq is not busy, it also enters
16195 * the destination ipsq exclusively. Now the actual groupname setting operation
16196 * can proceed. If the destination ipsq is busy, the operation is enqueued
16197 * on the destination (merged) ipsq and will be handled in the unwind from
16198 * ipsq_exit.
16199 *
16200 * To prevent other threads accessing the ill while the group name change is
16201 * in progres, we bring down the ipifs which also removes the ill from the
16202 * group. The group is changed in phyint and when the first ipif on the ill
16203 * is brought up, the ill is inserted into the right IPMP group by
16204 * illgrp_insert.
16205 */
16206 /* ARGSUSED */
16207 int
16210 {
16227 /* Existance verified in ip_wput_nondata */
16243 ;
16246 /* no null termination */
16248 }
16250 /*
16251 * Calculate the namelen exclusive of the null
16252 * termination character.
16253 */
16259 /*
16260 * ILL cannot be part of a usesrc group and and IPMP group at the
16261 * same time. No need to grab the ill_g_usesrc_lock here, see
16262 * synchronization notes in ip.c
16263 */
16266 }
16268 /*
16269 * mark the ill as changing.
16270 * this should queue all new requests on the syncq.
16271 */
16281 /*
16282 * Null string means remove this interface from the
16283 * existing group.
16284 */
16286 /*
16287 * Never was in a group.
16288 */
16291 }
16293 /*
16294 * IPv4 or IPv6 may be temporarily out of the group when all
16295 * the ipifs are down. Thus, we need to check for ill_group to
16296 * be non-NULL.
16297 */
16302 /*
16303 * ipsq_pending_mp_add will not fail since
16304 * connp is NULL
16305 */
16311 }
16313 }
16324 }
16326 }
16336 /* Restore the ifindex used to be the per interface one */
16344 /*
16345 * set the split flag so that the ipsq can be split
16346 */
16354 /* Are we inserting in the same group ? */
16359 }
16360 }
16363 /*
16364 * Merge ipsq for the group's.
16365 * This check is here as multiple groups/ills might be
16366 * sharing the same ipsq.
16367 * If we have to merege than the operation is restarted
16368 * on the new ipsq.
16369 */
16375 }
16376 /*
16377 * Running exclusive on new ipsq.
16378 */
16383 /*
16384 * Check whether the ill_type and ill_net_type matches before
16385 * we allocate any memory so that the cleanup is easier.
16386 *
16387 * We can't group dissimilar ones as we can't load spread
16388 * packets across the group because of potential link-level
16389 * header differences.
16390 */
16404 }
16416 }
16417 }
16421 /*
16422 * bring down all v4 ipifs.
16423 */
16426 }
16428 /*
16429 * bring down all v6 ipifs.
16430 */
16433 }
16435 /*
16436 * make sure all ipifs are down and there are no active
16437 * references. Call to ipsq_pending_mp_add will not fail
16438 * since connp is NULL.
16439 */
16448 }
16450 }
16460 }
16462 }
16464 /*
16465 * allocate including space for null terminator
16466 * before we insert.
16467 */
16478 }
16480 /*
16481 * setup the new group name.
16482 */
16488 /*
16489 * If the group already exists we use the existing
16490 * group_ifindex, otherwise we pick a new index here.
16491 */
16496 /* XXX We need a recovery strategy here. */
16501 }
16502 }
16503 /*
16504 * Select whether the netinfo and hook use the per-interface
16505 * or per-group ifindex.
16506 */
16509 else
16514 /* First phyint in group - group PLUMB event */
16516 }
16522 }
16524 done:
16525 /*
16526 * normally ILL_CHANGING is cleared in ill_up_ipifs.
16527 */
16535 }
16537 }
16539 /* ARGSUSED */
16540 int
16543 {
16549 /* Existence verified in ip_wput_nondata */
16556 /*
16557 * ill_group may be null if all the interfaces
16558 * are down. But still, the phyint should always
16559 * hold the name.
16560 */
16564 }
16567 }
16576 /*
16577 * ipcl_walk function for moving conn_multicast_ill for a given ill.
16578 */
16579 static void
16581 {
16595 /* Change IP_BOUND_IF/IPV6_BOUND_IF associations. */
16597 /* All multicast fields protected by conn_lock */
16604 }
16606 /* Change IP_MULTICAST_IF/IPV6_MULTICAST_IF associations */
16611 }
16613 /* Change IP_XMIT_IF associations */
16617 }
16618 /*
16619 * Change the ilg_ill to point to the new one. This assumes
16620 * ilm_move_v6 has moved the ilms to new_ill and the driver
16621 * has been told to receive packets on this interface.
16622 * ilm_move_v6 FAILBACKS all the ilms successfully always.
16623 * But when doing a FAILOVER, it might fail with ENOMEM and so
16624 * some ilms may not have moved. We check to see whether
16625 * the ilms have moved to to_ill. We can't check on from_ill
16626 * as in the process of moving, we could have split an ilm
16627 * in to two - which has the same orig_ifindex and v6group.
16628 *
16629 * For IPv4, ilg_ipif moves implicitly. The code below really
16630 * does not do anything for IPv4 as ilg_ill is NULL for IPv4.
16631 */
16636 /* ifindex != 0 indicates failback */
16640 }
16648 }
16649 }
16651 }
16653 static void
16655 {
16656 conn_move_t connm;
16664 }
16666 /*
16667 * ilm has been moved from from_ill to to_ill.
16668 * Send DL_DISABMULTI_REQ to ill and DL_ENABMULTI_REQ on to_ill.
16669 * appropriately.
16670 *
16671 * NOTE : We can't reuse the code in ip_ll_addmulti/delmulti because
16672 * the code there de-references ipif_ill to get the ill to
16673 * send multicast requests. It does not work as ipif is on its
16674 * move and already moved when this function is called.
16675 * Thus, we need to use from_ill and to_ill send down multicast
16676 * requests.
16677 */
16678 static void
16680 {
16684 /*
16685 * See whether we need to send down DL_ENABMULTI_REQ on
16686 * to_ill as ilm has just been added.
16687 */
16696 /*
16697 * no locks held, ill/ipif cannot dissappear as long
16698 * as we are writer.
16699 */
16701 /*
16702 * No need to hold any lock as we are the writer and this
16703 * can only be changed by a writer.
16704 */
16712 }
16719 }
16723 else
16727 /*
16728 * Nobody there. All multicast addresses will be
16729 * re-joined when we get the DL_BIND_ACK bringing the
16730 * interface up.
16731 */
16735 }
16737 /*
16738 * For allmulti address, we want to join on only one interface.
16739 * Checking for ilm_numentries_v6 is not correct as you may
16740 * find an ilm with zero address on to_ill, but we may not
16741 * have nominated to_ill for receiving. Thus, if we have
16742 * nominated from_ill (ill_join_allmulti is set), nominate
16743 * only if to_ill is not already nominated (to_ill normally
16744 * should not have been nominated if "from_ill" has already
16745 * been nominated. As we don't prevent failovers from happening
16746 * across groups, we don't assert).
16747 */
16749 /*
16750 * There is no need to hold ill locks as we are
16751 * writer on both ills and when ill_join_allmulti
16752 * is changed the thread is always a writer.
16753 */
16757 }
16760 /*
16761 * This is a newly moved ilm so we need to tell the
16762 * driver about the new group. There can be more than
16763 * one ilm's for the same group in the list each with a
16764 * different orig_ifindex. We have to inform the driver
16765 * once. In ilm_move_v[4,6] we only set the flag
16766 * ilm_notify_driver for the first ilm.
16767 */
16771 }
16775 /*
16776 * See whether we need to send down DL_DISABMULTI_REQ on
16777 * from_ill as ilm has just been removed.
16778 */
16779 from:
16786 }
16792 }
16800 }
16801 }
16803 }
16805 /*
16806 * This function is called when all multicast memberships needs
16807 * to be moved from "from_ill" to "to_ill" for IPv6. This function is
16808 * called only once unlike the IPv4 counterpart where it is called after
16809 * every logical interface is moved. The reason is due to multicast
16810 * memberships are joined using an interface address in IPv4 while in
16811 * IPv6, interface index is used.
16812 */
16813 static void
16815 {
16830 /*
16831 * Form the solicited node mcast address which is used later.
16832 */
16839 }
16848 }
16854 /*
16855 * We are failing back multicast memberships.
16856 * If the same ilm exists in to_ill, it means somebody
16857 * has joined the same group there e.g. ff02::1
16858 * is joined within the kernel when the interfaces
16859 * came UP.
16860 */
16867 }
16869 /*
16870 * check if we can just move the ilm
16871 */
16873 /*
16874 * We have walkers we cannot move
16875 * the ilm, so allocate a new ilm,
16876 * this (old) ilm will be marked
16877 * ILM_DELETED at the end of the loop
16878 * and will be freed when the
16879 * last walker exits.
16880 */
16885 "FAILBACK of IPv6"
16886 " multicast address %s : "
16887 "from %s to"
16897 }
16899 /*
16900 * we don't want new_ilm linked to
16901 * ilm's filter list.
16902 */
16905 /*
16906 * No walkers we can move the ilm.
16907 * lets take it out of the list.
16908 */
16912 }
16914 /*
16915 * if this is the first ilm for the group
16916 * set ilm_notify_driver so that we notify the
16917 * driver in ilm_send_multicast_reqs.
16918 */
16924 /* Add to the to_ill's list */
16927 /*
16928 * set the flag so that mld_joingroup is
16929 * called in ilm_send_multicast_reqs().
16930 */
16932 }
16935 /*
16936 * If this is FAILBACK (ifindex != 0) and the ifindex
16937 * has not matched above, look at the next ilm.
16938 */
16941 }
16942 /*
16943 * If we are here, it means ifindex is 0. Failover
16944 * everything.
16945 *
16946 * We need to handle solicited node mcast address
16947 * and all_nodes mcast address differently as they
16948 * are joined witin the kenrel (ipif_multicast_up)
16949 * and potentially from the userland. We are called
16950 * after the ipifs of from_ill has been moved.
16951 * If we still find ilms on ill with solicited node
16952 * mcast address or all_nodes mcast address, it must
16953 * belong to the UP interface that has not moved e.g.
16954 * ipif_id 0 with the link local prefix does not move.
16955 * We join this on the new ill accounting for all the
16956 * userland memberships so that applications don't
16957 * see any failure.
16958 *
16959 * We need to make sure that we account only for the
16960 * solicited node and all node multicast addresses
16961 * that was brought UP on these. In the case of
16962 * a failover from A to B, we might have ilms belonging
16963 * to A (ilm_orig_ifindex pointing at A) on B accounting
16964 * for the membership from the userland. If we are failing
16965 * over from B to C now, we will find the ones belonging
16966 * to A on B. These don't account for the ill_ipif_up_count.
16967 * They just move from B to C. The check below on
16968 * ilm_orig_ifindex ensures that.
16969 */
16977 /*
16978 * For indentation reasons, we are not using a
16979 * "else" here.
16980 */
16984 }
16987 /*
16988 * Can find one with the same
16989 * ilm_orig_ifindex, if we are failing
16990 * over to a STANDBY. This happens
16991 * when somebody wants to join a group
16992 * on a STANDBY interface and we
16993 * internally join on a different one.
16994 * If we had joined on from_ill then, a
16995 * failover now will find a new ilm
16996 * with this index.
16997 */
17008 }
17013 " multicast address %s : from %s to"
17021 }
17028 /*
17029 * If the to_ill has not joined this
17030 * group we need to tell the driver in
17031 * ill_send_multicast_reqs.
17032 */
17038 /* Add to the to_ill's list */
17042 }
17049 }
17052 /*
17053 * ifindex = 0 means, move everything pointing at
17054 * from_ill. We are doing this becuase ill has
17055 * either FAILED or became INACTIVE.
17056 *
17057 * As we would like to move things later back to
17058 * from_ill, we want to retain the identity of this
17059 * ilm. Thus, we don't blindly increment the reference
17060 * count on the ilms matching the address alone. We
17061 * need to match on the ilm_orig_index also. new_ilm
17062 * was obtained by matching ilm_orig_index also.
17063 */
17065 /*
17066 * This is possible only if a previous restore
17067 * was incomplete i.e restore to
17068 * ilm_orig_ifindex left some ilms because
17069 * of some failures. Thus when we are failing
17070 * again, we might find our old friends there.
17071 */
17082 }
17089 "FAILOVER of IPv6"
17090 " multicast address %s : "
17091 "from %s to"
17101 }
17107 }
17108 /*
17109 * If the to_ill has not joined this
17110 * group we need to tell the driver in
17111 * ill_send_multicast_reqs.
17112 */
17117 /* Add to the to_ill's list */
17123 }
17125 }
17127 bottom:
17128 /*
17129 * Revert multicast filter state to (EXCLUDE, NULL).
17130 * new_ilm->ilm_is_new should already be set if needed.
17131 */
17134 /*
17135 * We allocated/got a new ilm, free the old one.
17136 */
17150 }
17151 }
17152 }
17153 }
17155 /*
17156 * Move all the multicast memberships to to_ill. Called when
17157 * an ipif moves from "from_ill" to "to_ill". This function is slightly
17158 * different from IPv6 counterpart as multicast memberships are associated
17159 * with ills in IPv6. This function is called after every ipif is moved
17160 * unlike IPv6, where it is moved only once.
17161 */
17162 static void
17164 {
17182 }
17189 }
17197 /*
17198 * We still need to deal with the from_ill.
17199 */
17204 }
17205 /*
17206 * If we could not find one e.g. ipif is
17207 * still down on to_ill, we add this ilm
17208 * on ill_new to preserve the reference
17209 * count.
17210 */
17211 }
17212 /*
17213 * When ipifs move, ilms always move with it
17214 * to the NEW ill. Thus we should never be
17215 * able to find ilm till we really move it here.
17216 */
17225 " multicast address %s : "
17226 "from %s to"
17236 }
17238 /* We don't want new_ilm linked to ilm's filter list */
17241 /* Remove from the list */
17244 }
17246 /*
17247 * If we have never joined this group on the to_ill
17248 * make sure we tell the driver.
17249 */
17254 /* Add to the to_ill's list */
17259 /*
17260 * Revert multicast filter state to (EXCLUDE, NULL)
17261 */
17265 /*
17266 * Delete only if we have allocated a new ilm.
17267 */
17269 delete_ilm:
17271 /* Remove from the list */
17283 }
17284 }
17285 }
17286 }
17288 static uint_t
17290 {
17291 uint_t unit;
17296 /*
17297 * During failback, we want to go back to the same id
17298 * instead of the smallest id so that the original
17299 * configuration is maintained. id is non-zero in that
17300 * case.
17301 */
17303 /*
17304 * While failing back, if we still have an ipif with
17305 * MAX_ADDRS_PER_IF, it means this will be replaced
17306 * as soon as we return from this function. It was
17307 * to set to MAX_ADDRS_PER_IF by the caller so that
17308 * we can choose the smallest id. Thus we return zero
17309 * in that case ignoring the hint.
17310 */
17318 }
17319 }
17320 /*
17321 * If somebody already plumbed another logical
17322 * with the same id, we won't be able to find it.
17323 */
17326 }
17334 }
17335 }
17338 }
17340 }
17342 /* ARGSUSED */
17343 static int
17346 {
17349 uint_t unit;
17353 boolean_t failback_cmd;
17354 boolean_t remove_ipif;
17372 /*
17373 * Don't move LINK LOCAL addresses as they are tied to
17374 * physical interface.
17375 */
17381 }
17383 /*
17384 * We set the ipif_id to maximum so that the search for
17385 * ipif_id will pick the lowest number i.e 0 in the
17386 * following 2 cases :
17387 *
17388 * 1) We have a replacement ipif at the head of to_ill.
17389 * We can't remove it yet as we can exceed ip_addrs_per_if
17390 * on to_ill and hence the MOVE might fail. We want to
17391 * remove it only if we could move the ipif. Thus, by
17392 * setting it to the MAX value, we make the search in
17393 * ipif_get_id return the zeroth id.
17394 *
17395 * 2) When DR pulls out the NIC and re-plumbs the interface,
17396 * we might just have a zero address plumbed on the ipif
17397 * with zero id in the case of IPv4. We remove that while
17398 * doing the failback. We want to remove it only if we
17399 * could move the ipif. Thus, by setting it to the MAX
17400 * value, we make the search in ipif_get_id return the
17401 * zeroth id.
17402 *
17403 * Both (1) and (2) are done only when when we are moving
17404 * an ipif (either due to failover/failback) which originally
17405 * belonged to this interface i.e the ipif_orig_ifindex is
17406 * the same as to_ill's ifindex. This is needed so that
17407 * FAILOVER from A -> B ( A failed) followed by FAILOVER
17408 * from B -> A (B is being removed from the group) and
17409 * FAILBACK from A -> B restores the original configuration.
17410 * Without the check for orig_ifindex, the second FAILOVER
17411 * could make the ipif belonging to B replace the A's zeroth
17412 * ipif and the subsequent failback re-creating the replacement
17413 * ipif again.
17414 *
17415 * NOTE : We created the replacement ipif when we did a
17416 * FAILOVER (See below). We could check for FAILBACK and
17417 * then look for replacement ipif to be removed. But we don't
17418 * want to do that because we wan't to allow the possibility
17419 * of a FAILOVER from A -> B (which creates the replacement ipif),
17420 * followed by a *FAILOVER* from B -> A instead of a FAILBACK
17421 * from B -> A.
17422 */
17430 }
17431 /*
17432 * Find the lowest logical unit number on the to_ill.
17433 * If we are failing back, try to get the original id
17434 * rather than the lowest one so that the original
17435 * configuration is maintained.
17436 *
17437 * XXX need a better scheme for this.
17438 */
17443 }
17445 /* Reset back to zero in case we fail below */
17453 }
17455 /*
17456 * ipif is ready to move from "from_ill" to "to_ill".
17457 *
17458 * 1) If we are moving ipif with id zero, create a
17459 * replacement ipif for this ipif on from_ill. If this fails
17460 * fail the MOVE operation.
17461 *
17462 * 2) Remove the replacement ipif on to_ill if any.
17463 * We could remove the replacement ipif when we are moving
17464 * the ipif with id zero. But what if somebody already
17465 * unplumbed it ? Thus we always remove it if it is present.
17466 * We want to do it only if we are sure we are going to
17467 * move the ipif to to_ill which is why there are no
17468 * returns due to error till ipif is linked to to_ill.
17469 * Note that the first ipif that we failback will always
17470 * be zero if it is present.
17471 */
17480 }
17482 /*
17483 * Before we put the ipif on the list, store the addresses
17484 * as mapped addresses as some of the ioctls e.g SIOCGIFADDR
17485 * assumes so. This logic is not any different from what
17486 * ipif_allocate does.
17487 */
17500 /*
17501 * We mark IPIF_NOFAILOVER so that this can never
17502 * move.
17503 */
17514 /* Insert at head */
17517 /*
17518 * We don't really care to let apps know about
17519 * this interface.
17520 */
17521 }
17524 /*
17525 * We set to a max value above for this case to get
17526 * id zero. ASSERT that we did get one.
17527 */
17532 /*
17533 * If some apps scanned and find this interface,
17534 * it is time to let them know, so that they can
17535 * delete it.
17536 */
17539 }
17541 /* Get it out of the ILL interface list. */
17544 /* Assign the new ill */
17547 /* id has already been checked */
17550 /* Let SCTP update its list */
17552 /*
17553 * Handle the failover and failback of ipif_t between
17554 * ill_t that have differing maximum mtu values.
17555 */
17558 /*
17559 * As this ipif_t is moving to an ill_t
17560 * that has a lower ill_max_mtu, its
17561 * ipif_mtu needs to be saved so it can
17562 * be restored during failback or during
17563 * failover to an ill_t which has a
17564 * higher ill_max_mtu.
17565 */
17569 /*
17570 * The ipif_t is, once again, moving to
17571 * an ill_t that has a lower maximum mtu
17572 * value.
17573 */
17575 }
17578 /*
17579 * The mtu of this ipif_t had to be reduced
17580 * during an earlier failover; this is an
17581 * opportunity for it to be increased (either as
17582 * part of another failover or a failback).
17583 */
17589 }
17590 }
17592 /*
17593 * We preserve all the other fields of the ipif including
17594 * ipif_saved_ire_mp. The routes that are saved here will
17595 * be recreated on the new interface and back on the old
17596 * interface when we move back.
17597 */
17601 }
17603 static int
17606 {
17611 /*
17612 * We don't really try to MOVE back things if some of the
17613 * operations fail. The daemon will take care of moving again
17614 * later on.
17615 */
17623 /*
17624 * When the MOVE fails, it is the job of the
17625 * application to take care of this properly
17626 * i.e try again if it is ENOMEM.
17627 */
17629 /*
17630 * ipif has moved.
17631 *
17632 * Move the multicast memberships associated
17633 * with this ipif to the new ill. For IPv6, we
17634 * do it once after all the ipifs are moved
17635 * (in ill_move) as they are not associated
17636 * with ipifs.
17637 *
17638 * We need to move the ilms as the ipif has
17639 * already been moved to a new ill even
17640 * in the case of errors. Neither
17641 * ilm_free(ipif) will find the ilm
17642 * when somebody unplumbs this ipif nor
17643 * ilm_delete(ilm) will be able to find the
17644 * ilm, if we don't move now.
17645 */
17648 }
17652 }
17653 }
17655 }
17657 static int
17659 {
17671 /*
17672 * Move everything pointing at from_ill to to_ill.
17673 * We acheive this by passing in 0 as ifindex.
17674 */
17677 /*
17678 * Move everything pointing at from_ill whose original
17679 * ifindex of connp, ipif, ilm points at to_ill->ill_index.
17680 * We acheive this by passing in ifindex rather than 0.
17681 * Multicast vifs, ilgs move implicitly because ipifs move.
17682 */
17685 }
17687 /*
17688 * Determine if there is at least one ipif that would move from
17689 * 'from_ill' to 'to_ill'. If so, it is possible that the replacement
17690 * ipif (if it exists) on the to_ill would be consumed as a result of
17691 * the move, in which case we need to quiesce the replacement ipif also.
17692 */
17700 }
17701 }
17712 }
17714 /* Check if the replacement ipif is quiescent to delete */
17724 }
17725 }
17733 /* ilm_move is done inside ipif_move for IPv4 */
17740 /*
17741 * send rts messages and multicast messages.
17742 */
17747 }
17750 #ifdef DEBUG
17752 #endif
17754 }
17759 }
17761 /*
17762 * Used to extract arguments for FAILOVER/FAILBACK ioctls.
17763 * Also checks for the validity of the arguments.
17764 * Note: We are already exclusive inside the from group.
17765 * It is upto the caller to release refcnt on the to_ill's.
17766 */
17767 static int
17770 {
17775 boolean_t exists;
17782 else
17795 /*
17796 * We operate on both IPv4 and IPv6. Thus, we don't allow IPv4/IPv6
17797 * specific operations.
17798 */
17802 /*
17803 * Get ipif with id 0. We are writer on the from ill. So we can pass
17804 * NULLs for the last 4 args and we know the lookup won't fail
17805 * with EINPROGRESS.
17806 */
17822 }
17826 }
17833 }
17837 }
17844 /*
17845 * There could be only v6.
17846 */
17850 }
17860 }
17862 }
17864 /*
17865 * If we have something to MOVE i.e "from" not NULL,
17866 * "to" should be non-NULL.
17867 */
17871 }
17873 done:
17879 }
17881 /*
17882 * FAILOVER and FAILBACK are modelled as MOVE operations.
17883 *
17884 * We don't check whether the MOVE is within the same group or
17885 * not, because this ioctl can be used as a generic mechanism
17886 * to failover from interface A to B, though things will function
17887 * only if they are really part of the same group. Moreover,
17888 * all ipifs may be down and hence temporarily out of the group.
17889 *
17890 * ipif's that need to be moved are first brought down; V4 ipifs are brought
17891 * down first and then V6. For each we wait for the ipif's to become quiescent.
17892 * Bringing down the ipifs ensures that all ires pointing to these ipifs's
17893 * have been deleted and there are no active references. Once quiescent the
17894 * ipif's are moved and brought up on the new ill.
17895 *
17896 * Normally the source ill and destination ill belong to the same IPMP group
17897 * and hence the same ipsq_t. In the event they don't belong to the same
17898 * same group the two ipsq's are first merged into one ipsq - that of the
17899 * to_ill. The multicast memberships on the source and destination ill cannot
17900 * change during the move operation since multicast joins/leaves also have to
17901 * execute on the same ipsq and are hence serialized.
17902 */
17903 /* ARGSUSED */
17904 int
17907 {
17914 /*
17915 * setup from and to ill's, we can get EINPROGRESS only for
17916 * to_ill's.
17917 */
17924 }
17926 /*
17927 * nothing to do.
17928 */
17931 }
17933 /*
17934 * nothing to do.
17935 */
17938 }
17940 /*
17941 * Mark the ill as changing.
17942 * ILL_CHANGING flag is cleared when the ipif's are brought up
17943 * in ill_up_ipifs in case of error they are cleared below.
17944 */
17953 /*
17954 * Make sure that both src and dst are
17955 * in the same syncq group. If not make it happen.
17956 * We are not holding any locks because we are the writer
17957 * on the from_ipsq and we will hold locks in ill_merge_groups
17958 * to protect to_ipsq against changing.
17959 */
17967 }
17977 }
17979 }
17981 /*
17982 * Now that the ipsq's have been merged and we are the writer
17983 * lets mark to_ill as changing as well.
17984 */
17993 /*
17994 * Its ok for us to proceed with the move even if
17995 * ill_pending_mp is non null on one of the from ill's as the reply
17996 * should not be looking at the ipif, it should only care about the
17997 * ill itself.
17998 */
18000 /*
18001 * lets move ipv4 first.
18002 */
18010 }
18012 /*
18013 * Now lets move ipv6.
18014 */
18022 }
18024 err_ret:
18025 /*
18026 * EINPROGRESS means we are waiting for the ipif's that need to be
18027 * moved to become quiescent.
18028 */
18031 }
18033 /*
18034 * if err is set ill_up_ipifs will not be called
18035 * lets clear the flags.
18036 */
18040 /*
18041 * Some of the clearing may be redundant. But it is simple
18042 * not making any extra checks.
18043 */
18048 }
18053 }
18058 }
18063 }
18065 /*
18066 * Check for setting INACTIVE, if STANDBY is set and FAILED is not set.
18067 * Do this always to maintain proper state i.e even in case of errors.
18068 * As phyint_inactive looks at both v4 and v6 interfaces,
18069 * we need not call on both v4 and v6 interfaces.
18070 */
18075 }
18080 }
18081 }
18086 }
18090 }
18091 }
18096 no_err:
18097 /*
18098 * lets bring the interfaces up on the to_ill.
18099 */
18103 }
18111 }
18112 done:
18116 }
18119 }
18122 }
18124 static void
18126 {
18127 /*
18128 * The ill is down; unbind but stay attached since we're still
18129 * associated with a PPA. If we have negotiated DLPI capabilites
18130 * with the data link service provider (IDS_OK) then reset them.
18131 * The interval between unbinding and rebinding is potentially
18132 * unbounded hence we cannot assume things will be the same.
18133 * The DLPI capabilities will be probed again when the data link
18134 * is brought up.
18135 */
18149 /*
18150 * Reset the capabilities if the negotiation is done or is
18151 * still in progress. Note that ill_capability_reset() will
18152 * set ill_dlpi_capab_state to IDS_UNKNOWN, so the subsequent
18153 * DL_CAPABILITY_ACK and DL_NOTE_CAPAB_RENEG will be ignored.
18154 *
18155 * Further, reset ill_capab_reneg to be B_FALSE so that the
18156 * subsequent DL_CAPABILITY_ACK can be ignored, to prevent
18157 * the capabilities renegotiation from happening.
18158 */
18164 }
18166 /*
18167 * Toss all of our multicast memberships. We could keep them, but
18168 * then we'd have to do bookkeeping of any joins and leaves performed
18169 * by the application while the the interface is down (we can't just
18170 * issue them because arp cannot currently process AR_ENTRY_SQUERY's
18171 * on a downed interface).
18172 */
18185 }
18205 }
18207 static void
18209 {
18211 t_uscalar_t prim;
18223 {
18227 }
18233 }
18235 /*
18236 * Except for the ACKs for the M_PCPROTO messages, all other ACKs
18237 * are dropped by ip_rput() if ILL_CONDEMNED is set. Therefore
18238 * we only wait for the ACK of the DL_UNBIND_REQ.
18239 */
18244 }
18248 }
18250 /*
18251 * Helper function for ill_dlpi_send().
18252 */
18253 /* ARGSUSED */
18254 static void
18256 {
18258 }
18260 /*
18261 * Send a DLPI control message to the driver but make sure there
18262 * is only one outstanding message. Uses ill_dlpi_pending to tell
18263 * when it must queue. ip_rput_dlpi_writer calls ill_dlpi_done()
18264 * when an ACK or a NAK is received to process the next queued message.
18265 */
18266 void
18268 {
18273 /*
18274 * To ensure that any DLPI requests for current exclusive operation
18275 * are always completely sent before any DLPI messages for other
18276 * operations, require writer access before enqueuing.
18277 */
18280 /* qwriter_ip() does the ill_refrele() */
18284 }
18288 /* Must queue message. Tail insertion */
18299 }
18302 }
18304 /*
18305 * Send all deferred DLPI messages without waiting for their ACKs.
18306 */
18307 void
18309 {
18312 /*
18313 * Clear ill_dlpi_pending so that the message is not queued in
18314 * ill_dlpi_send().
18315 */
18326 }
18327 }
18329 /*
18330 * Check if the DLPI primitive `prim' is pending; print a warning if not.
18331 */
18332 boolean_t
18334 {
18335 t_uscalar_t pending;
18341 }
18343 /*
18344 * During teardown, ill_dlpi_dispatch() will send DLPI requests
18345 * without waiting, so don't print any warnings in that case.
18346 */
18350 }
18362 }
18364 }
18366 /*
18367 * Called when an DLPI control message has been acked or nacked to
18368 * send down the next queued message (if any).
18369 */
18370 void
18372 {
18389 }
18396 }
18398 void
18400 {
18404 /*
18405 * Look at the cached ires on conns which has pointers to ipifs.
18406 * We just call ire_refrele which clears up the reference
18407 * to ire. Called when a conn closes. Also called from ipif_free
18408 * to cleanup indirect references to the stale ipif via the cached ire.
18409 */
18417 }
18420 }
18422 /*
18423 * Some operations (illgrp_delete(), ipif_down()) conditionally delete a number
18424 * of IREs. Those IREs may have been previously cached in the conn structure.
18425 * This ipcl_walk() walker function releases all references to such IREs based
18426 * on the condemned flag.
18427 */
18428 /* ARGSUSED */
18429 void
18431 {
18441 }
18443 }
18445 /*
18446 * Take down a specific interface, but don't lose any information about it.
18447 * Also delete interface from its interface group (ifgrp).
18448 * (Always called as writer.)
18449 * This function goes through the down sequence even if the interface is
18450 * already down. There are 2 reasons.
18451 * a. Currently we permit interface routes that depend on down interfaces
18452 * to be added. This behaviour itself is questionable. However it appears
18453 * that both Solaris and 4.3 BSD have exhibited this behaviour for a long
18454 * time. We go thru the cleanup in order to remove these routes.
18455 * b. The bringup of the interface could fail in ill_dl_up i.e. we get
18456 * DL_ERROR_ACK in response to the the DL_BIND request. The interface is
18457 * down, but we need to cleanup i.e. do ill_dl_down and
18458 * ip_rput_dlpi_writer (DL_ERROR_ACK) -> ipif_down.
18459 *
18460 * IP-MT notes:
18461 *
18462 * Model of reference to interfaces.
18463 *
18464 * The following members in ipif_t track references to the ipif.
18465 * int ipif_refcnt; Active reference count
18466 * uint_t ipif_ire_cnt; Number of ire's referencing this ipif
18467 * The following members in ill_t track references to the ill.
18468 * int ill_refcnt; active refcnt
18469 * uint_t ill_ire_cnt; Number of ires referencing ill
18470 * uint_t ill_nce_cnt; Number of nces referencing ill
18471 *
18472 * Reference to an ipif or ill can be obtained in any of the following ways.
18473 *
18474 * Through the lookup functions ipif_lookup_* / ill_lookup_* functions
18475 * Pointers to ipif / ill from other data structures viz ire and conn.
18476 * Implicit reference to the ipif / ill by holding a reference to the ire.
18477 *
18478 * The ipif/ill lookup functions return a reference held ipif / ill.
18479 * ipif_refcnt and ill_refcnt track the reference counts respectively.
18480 * This is a purely dynamic reference count associated with threads holding
18481 * references to the ipif / ill. Pointers from other structures do not
18482 * count towards this reference count.
18483 *
18484 * ipif_ire_cnt/ill_ire_cnt is the number of ire's associated with the
18485 * ipif/ill. This is incremented whenever a new ire is created referencing the
18486 * ipif/ill. This is done atomically inside ire_add_v[46] where the ire is
18487 * actually added to the ire hash table. The count is decremented in
18488 * ire_inactive where the ire is destroyed.
18489 *
18490 * nce's reference ill's thru nce_ill and the count of nce's associated with
18491 * an ill is recorded in ill_nce_cnt. This is incremented atomically in
18492 * ndp_add_v4()/ndp_add_v6() where the nce is actually added to the
18493 * table. Similarly it is decremented in ndp_inactive() where the nce
18494 * is destroyed.
18495 *
18496 * Flow of ioctls involving interface down/up
18497 *
18498 * The following is the sequence of an attempt to set some critical flags on an
18499 * up interface.
18500 * ip_sioctl_flags
18501 * ipif_down
18502 * wait for ipif to be quiescent
18503 * ipif_down_tail
18504 * ip_sioctl_flags_tail
18505 *
18506 * All set ioctls that involve down/up sequence would have a skeleton similar
18507 * to the above. All the *tail functions are called after the refcounts have
18508 * dropped to the appropriate values.
18509 *
18510 * The mechanism to quiesce an ipif is as follows.
18511 *
18512 * Mark the ipif as IPIF_CHANGING. No more lookups will be allowed
18513 * on the ipif. Callers either pass a flag requesting wait or the lookup
18514 * functions will return NULL.
18515 *
18516 * Delete all ires referencing this ipif
18517 *
18518 * Any thread attempting to do an ipif_refhold on an ipif that has been
18519 * obtained thru a cached pointer will first make sure that
18520 * the ipif can be refheld using the macro IPIF_CAN_LOOKUP and only then
18521 * increment the refcount.
18522 *
18523 * The above guarantees that the ipif refcount will eventually come down to
18524 * zero and the ipif will quiesce, once all threads that currently hold a
18525 * reference to the ipif refrelease the ipif. The ipif is quiescent after the
18526 * ipif_refcount has dropped to zero and all ire's associated with this ipif
18527 * have also been ire_inactive'd. i.e. when ipif_ire_cnt and ipif_refcnt both
18528 * drop to zero.
18529 *
18530 * Lookups during the IPIF_CHANGING/ILL_CHANGING interval.
18531 *
18532 * Threads trying to lookup an ipif or ill can pass a flag requesting
18533 * wait and restart if the ipif / ill cannot be looked up currently.
18534 * For eg. bind, and route operations (Eg. route add / delete) cannot return
18535 * failure if the ipif is currently undergoing an exclusive operation, and
18536 * hence pass the flag. The mblk is then enqueued in the ipsq and the operation
18537 * is restarted by ipsq_exit() when the currently exclusive ioctl completes.
18538 * The lookup and enqueue is atomic using the ill_lock and ipsq_lock. The
18539 * lookup is done holding the ill_lock. Hence the ill/ipif state flags can't
18540 * change while the ill_lock is held. Before dropping the ill_lock we acquire
18541 * the ipsq_lock and call ipsq_enq. This ensures that ipsq_exit can't finish
18542 * until we release the ipsq_lock, even though the the ill/ipif state flags
18543 * can change after we drop the ill_lock.
18544 *
18545 * An attempt to send out a packet using an ipif that is currently
18546 * IPIF_CHANGING will fail. No attempt is made in this case to enqueue this
18547 * operation and restart it later when the exclusive condition on the ipif ends.
18548 * This is an example of not passing the wait flag to the lookup functions. For
18549 * example an attempt to refhold and use conn->conn_multicast_ipif and send
18550 * out a multicast packet on that ipif will fail while the ipif is
18551 * IPIF_CHANGING. An attempt to create an IRE_CACHE using an ipif that is
18552 * currently IPIF_CHANGING will also fail.
18553 */
18554 int
18556 {
18560 boolean_t success;
18575 /* Update status in SCTP's list */
18577 }
18579 /*
18580 * Blow away memberships we established in ipif_multicast_up().
18581 */
18584 /*
18585 * Remove from the mapping for __sin6_src_id. We insert only
18586 * when the address is not INADDR_ANY. As IPv4 addresses are
18587 * stored as mapped addresses, we need to check for mapped
18588 * INADDR_ANY also.
18589 */
18599 }
18600 }
18602 /*
18603 * Before we delete the ill from the group (if any), we need
18604 * to make sure that we delete all the routes dependent on
18605 * this and also any ipifs dependent on this ipif for
18606 * source address. We need to do before we delete from
18607 * the group because
18608 *
18609 * 1) ipif_down_delete_ire de-references ill->ill_group.
18610 *
18611 * 2) ipif_update_other_ipifs needs to walk the whole group
18612 * for re-doing source address selection. Note that
18613 * ipif_select_source[_v6] called from
18614 * ipif_update_other_ipifs[_v6] will not pick this ipif
18615 * because we have already marked down here i.e cleared
18616 * IPIF_UP.
18617 */
18620 ipst);
18623 ipst);
18624 }
18626 /*
18627 * Cleaning up the conn_ire_cache or conns must be done only after the
18628 * ires have been deleted above. Otherwise a thread could end up
18629 * caching an ire in a conn after we have finished the cleanup of the
18630 * conn. The caching is done after making sure that the ire is not yet
18631 * condemned. Also documented in the block comment above ip_output
18632 */
18634 /* Also, delete the ires cached in SCTP */
18637 /*
18638 * Update any other ipifs which have used "our" local address as
18639 * a source address. This entails removing and recreating IRE_INTERFACE
18640 * entries for such ipifs.
18641 */
18644 else
18648 /*
18649 * Check whether it is last ipif to leave this group.
18650 * If this is the last ipif to leave, we should remove
18651 * this ill from the group as ipif_select_source will not
18652 * be able to find any useful ipifs if this ill is selected
18653 * for load balancing.
18654 *
18655 * For nameless groups, we should call ifgrp_delete if this
18656 * belongs to some group. As this ipif is going down, we may
18657 * need to reconstruct groups.
18658 */
18660 /*
18661 * If the phyint_groupname_len is 0, it may or may not
18662 * be in the nameless group. If the phyint_groupname_len is
18663 * not 0, then this ill should be part of some group.
18664 * As we always insert this ill in the group if
18665 * phyint_groupname_len is not zero when the first ipif
18666 * comes up (in ipif_up_done), it should be in a group
18667 * when the namelen is not 0.
18668 *
18669 * NOTE : When we delete the ill from the group,it will
18670 * blow away all the IRE_CACHES pointing either at this ipif or
18671 * ill_wq (illgrp_cache_delete does this). Thus, no IRES
18672 * should be pointing at this ill.
18673 */
18680 }
18682 /*
18683 * If we have deleted some of the broadcast ires associated
18684 * with this ipif, we need to re-nominate somebody else if
18685 * the ires that we deleted were the nominated ones.
18686 */
18689 }
18691 /*
18692 * neighbor-discovery or arp entries for this interface.
18693 */
18696 /*
18697 * If mp is NULL the caller will wait for the appropriate refcnt.
18698 * Eg. ip_sioctl_removeif -> ipif_free -> ipif_down
18699 * and ill_delete -> ipif_free -> ipif_down
18700 */
18704 }
18711 }
18713 /*
18714 * Are there any ire's pointing to this ipif that are still active ?
18715 * If this is the last ipif going down, are there any ire's pointing
18716 * to this ill that are still active ?
18717 */
18723 }
18727 /*
18728 * Enqueue the mp atomically in ipsq_pending_mp. When the refcount
18729 * drops down, the operation will be restarted by ipif_ill_refrele_tail
18730 * which in turn is called by the last refrele on the ipif/ill/ire.
18731 */
18734 /* The conn is closing. So just return */
18739 }
18745 }
18747 void
18749 {
18752 /*
18753 * Skip any loopback interface (null wq).
18754 * If this is the last logical interface on the ill
18755 * have ill_dl_down tell the driver we are gone (unbind)
18756 * Note that lun 0 can ipif_down even though
18757 * there are other logical units that are up.
18758 * This occurs e.g. when we change a "significant" IFF_ flag.
18759 */
18764 }
18767 /*
18768 * Have to be after removing the routes in ipif_down_delete_ire.
18769 */
18775 }
18779 }
18781 /*
18782 * Bring interface logically down without bringing the physical interface
18783 * down e.g. when the netmask is changed. This avoids long lasting link
18784 * negotiations between an ethernet interface and a certain switches.
18785 */
18786 static int
18788 {
18789 /*
18790 * The ill_logical_down flag is a transient flag. It is set here
18791 * and is cleared once the down has completed in ipif_down_tail.
18792 * This flag does not indicate whether the ill stream is in the
18793 * DL_BOUND state with the driver. Instead this flag is used by
18794 * ipif_down_tail to determine whether to DL_UNBIND the stream with
18795 * the driver. The state of the ill stream i.e. whether it is
18796 * DL_BOUND with the driver or not is indicated by the ill_dl_up flag.
18797 */
18800 }
18802 /*
18803 * This is called when the SIOCSLIFUSESRC ioctl is processed in IP.
18804 * If the usesrc client ILL is already part of a usesrc group or not,
18805 * in either case a ire_stq with the matching usesrc client ILL will
18806 * locate the IRE's that need to be deleted. We want IREs to be created
18807 * with the new source address.
18808 */
18809 static void
18811 {
18822 }
18824 /*
18825 * ire_walk routine to delete every IRE dependent on the interface
18826 * address that is going down. (Always called as writer.)
18827 * Works for both v4 and v6.
18828 * In addition for checking for ire_ipif matches it also checks for
18829 * IRE_CACHE entries which have the same source address as the
18830 * disappearing ipif since ipif_select_source might have picked
18831 * that source. Note that ipif_down/ipif_update_other_ipifs takes
18832 * care of any IRE_INTERFACE with the disappearing source address.
18833 */
18834 static void
18836 {
18845 /*
18846 * For IPv4, we derive source addresses for an IRE from ipif's
18847 * belonging to the same IPMP group as the IRE's outgoing
18848 * interface. If an IRE's outgoing interface isn't in the
18849 * same IPMP group as a particular ipif, then that ipif
18850 * couldn't have been used as a source address for this IRE.
18851 *
18852 * For IPv6, source addresses are only restricted to the IPMP group
18853 * if the IRE is for a link-local address or a multicast address.
18854 * Otherwise, source addresses for an IRE can be chosen from
18855 * interfaces other than the the outgoing interface for that IRE.
18856 *
18857 * For source address selection details, see ipif_select_source()
18858 * and ipif_select_source_v6().
18859 */
18868 }
18869 }
18873 /*
18874 * Look for a matching source address.
18875 */
18888 }
18891 }
18892 /*
18893 * ire_delete() will do an ire_flush_cache which will delete
18894 * all ire_ipif matches
18895 */
18897 }
18899 /*
18900 * ire_walk_ill function for deleting all IRE_CACHE entries for an ill when
18901 * 1) an ipif (on that ill) changes the IPIF_DEPRECATED flags, or
18902 * 2) when an interface is brought up or down (on that ill).
18903 * This ensures that the IRE_CACHE entries don't retain stale source
18904 * address selection results.
18905 */
18906 void
18908 {
18913 /*
18914 * We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4.
18915 * Hence this should be IRE_CACHE.
18916 */
18919 /*
18920 * We are called for IRE_CACHES whose ire_ipif matches ill.
18921 * We are only interested in IRE_CACHES that has borrowed
18922 * the source address from ill_arg e.g. ipif_up_done[_v6]
18923 * for which we need to look at ire_ipif->ipif_ill match
18924 * with ill.
18925 */
18931 }
18932 }
18934 /*
18935 * Delete all the ire whose stq references ill_arg.
18936 */
18937 static void
18939 {
18944 /*
18945 * We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4.
18946 * Hence this should be IRE_CACHE.
18947 */
18950 /*
18951 * We are called for IRE_CACHES whose ire_stq and ire_ipif
18952 * matches ill. We are only interested in IRE_CACHES that
18953 * has ire_stq->q_ptr pointing at ill_arg. Thus we do the
18954 * filtering here.
18955 */
18960 }
18962 /*
18963 * This is called when an ill leaves the group. We want to delete
18964 * all IRE_CACHES whose stq is pointing at ill_wq or ire_ipif is
18965 * pointing at ill.
18966 */
18967 static void
18969 {
18974 /*
18975 * We use MATCH_IRE_TYPE/IRE_CACHE while calling ire_walk_ill_v4.
18976 * Hence this should be IRE_CACHE.
18977 */
18979 /*
18980 * We are called for IRE_CACHES whose ire_stq and ire_ipif
18981 * matches ill. We are interested in both.
18982 */
18987 }
18989 /*
18990 * Initiate deallocate of an IPIF. Always called as writer. Called by
18991 * ill_delete or ip_sioctl_removeif.
18992 */
18993 static void
18995 {
19004 /* Remove conn references */
19007 /*
19008 * Make sure we have valid net and subnet broadcast ire's for the
19009 * other ipif's which share them with this ipif.
19010 */
19014 /*
19015 * Take down the interface. We can be called either from ill_delete
19016 * or from ip_sioctl_removeif.
19017 */
19020 /*
19021 * Now that the interface is down, there's no chance it can still
19022 * become a duplicate. Cancel any timer that may have been set while
19023 * tearing down.
19024 */
19030 /* Remove pointers to this ill in the multicast routing tables */
19033 }
19035 /*
19036 * Warning: this is not the only function that calls mi_free on an ipif_t. See
19037 * also ill_move().
19038 */
19039 static void
19041 {
19045 /*
19046 * Free state for addition IRE_IF_[NO]RESOLVER ire's.
19047 */
19054 /*
19055 * Need to hold both ill_g_lock and ill_lock while
19056 * inserting or removing an ipif from the linked list
19057 * of ipifs hanging off the ill.
19058 */
19060 /*
19061 * Remove all IPv4 multicast memberships on the interface now.
19062 * IPv6 is not handled here as the multicast memberships are
19063 * tied to the ill rather than the ipif.
19064 */
19067 /*
19068 * Since we held the ill_g_lock while doing the ilm_free above,
19069 * we can assert the ilms were really deleted and not just marked
19070 * ILM_DELETED.
19071 */
19074 #ifdef DEBUG
19076 #endif
19078 /* Ask SCTP to take it out of it list */
19081 /* Get it out of the ILL interface list. */
19090 /* Free the memory. */
19092 }
19094 /*
19095 * Sets `buf' to an ipif name of the form "ill_name:id", or "ill_name" if "id"
19096 * is zero.
19097 */
19098 void
19100 {
19113 }
19118 }
19120 /*
19121 * Find an IPIF based on the name passed in. Names can be of the
19122 * form <phys> (e.g., le0), <phys>:<#> (e.g., le0:1),
19123 * The <phys> string can have forms like <dev><#> (e.g., le0),
19124 * <dev><#>.<module> (e.g. le0.foo), or <dev>.<module><#> (e.g. ip.tun3).
19125 * When there is no colon, the implied unit id is zero. <phys> must
19126 * correspond to the name of an ILL. (May be called as writer.)
19127 */
19132 {
19138 uint_t ire_type;
19145 /*
19146 * If the caller wants to us to create the ipif, make sure we have a
19147 * valid zoneid
19148 */
19155 }
19158 /* Look for a colon in the name. */
19163 }
19166 /*
19167 * Reject any non-decimal aliases for logical
19168 * interfaces. Aliases with leading zeroes
19169 * are also rejected as they introduce ambiguity
19170 * in the naming of the interfaces.
19171 * In order to confirm with existing semantics,
19172 * and to not break any programs/script relying
19173 * on that behaviour, if<0>:0 is considered to be
19174 * a valid interface.
19175 *
19176 * If alias has two or more digits and the first
19177 * is zero, fail.
19178 */
19183 }
19184 }
19190 }
19192 /*
19193 * Look up the ILL, based on the portion of the name
19194 * before the slash. ill_lookup_on_name returns a held ill.
19195 * Temporary to check whether ill exists already. If so
19196 * ill_lookup_on_name will clear it.
19197 */
19205 /* Establish the unit number in the name. */
19208 /* If there was a colon, the unit number follows. */
19209 cp++;
19215 }
19216 }
19220 /* Now see if there is an IPIF with this unit number. */
19232 }
19233 /*
19234 * The block comment at the start of ipif_down
19235 * explains the use of the macros used below
19236 */
19242 /*
19243 * Drop locks before calling ill_refrele
19244 * since it can potentially call into
19245 * ipif_ill_refrele_tail which can end up
19246 * in trying to acquire any lock.
19247 */
19262 }
19263 }
19264 }
19273 }
19275 /*
19276 * If none found, atomically allocate and return a new one.
19277 * Historically, we used IRE_LOOPBACK only for lun 0, and IRE_LOCAL
19278 * to support "receive only" use of lo0:1 etc. as is still done
19279 * below as an initial guess.
19280 * However, this is now likely to be overriden later in ipif_up_done()
19281 * when we know for sure what address has been configured on the
19282 * interface, since we might have more than one loopback interface
19283 * with a loopback address, e.g. in the case of zones, and all the
19284 * interfaces with loopback addresses need to be marked IRE_LOOPBACK.
19285 */
19288 else
19298 }
19300 /*
19301 * This routine is called whenever a new address comes up on an ipif. If
19302 * we are configured to respond to address mask requests, then we are supposed
19303 * to broadcast an address mask reply at this time. This routine is also
19304 * called if we are already up, but a netmask change is made. This is legal
19305 * but might not make the system manager very popular. (May be called
19306 * as writer.)
19307 */
19308 void
19310 {
19316 #define REPLY_LEN (sizeof (icmp_ipha) + sizeof (icmph_t) + IP_ADDR_LEN)
19321 /* ICMP mask reply is IPv4 only */
19323 /* ICMP mask reply is not for a loopback interface */
19347 #undef REPLY_LEN
19348 }
19350 /*
19351 * When the mtu in the ipif changes, we call this routine through ire_walk
19352 * to update all the relevant IREs.
19353 * Skip IRE_LOCAL and "loopback" IRE_BROADCAST by checking ire_stq.
19354 */
19355 static void
19357 {
19363 }
19365 /*
19366 * When the mtu in the ill changes, we call this routine through ire_walk
19367 * to update all the relevant IREs.
19368 * Skip IRE_LOCAL and "loopback" IRE_BROADCAST by checking ire_stq.
19369 */
19370 void
19372 {
19378 }
19380 /*
19381 * Join the ipif specific multicast groups.
19382 * Must be called after a mapping has been set up in the resolver. (Always
19383 * called as writer.)
19384 */
19385 void
19387 {
19404 /* Join the all hosts multicast address */
19406 /*
19407 * Passing B_TRUE means we have to join the multicast
19408 * membership on this interface even though this is
19409 * FAILED. If we join on a different one in the group,
19410 * we will not be able to delete the membership later
19411 * as we currently don't track where we join when we
19412 * join within the kernel unlike applications where
19413 * we have ilg/ilg_orig_index. See ip_addmulti_v6
19414 * for more on this.
19415 */
19421 err));
19423 }
19424 /*
19425 * Enable multicast for the solicited node multicast address
19426 */
19435 NULL);
19443 }
19444 }
19449 /* Join the all hosts multicast address */
19456 }
19457 }
19459 }
19461 /*
19462 * Blow away any multicast groups that we joined in ipif_multicast_up().
19463 * (Explicit memberships are blown away in ill_leave_multicast() when the
19464 * ill is brought down.)
19465 */
19466 static void
19468 {
19481 B_TRUE);
19487 }
19489 /*
19490 * Leave the all hosts multicast address. Similar to ip_addmulti_v6,
19491 * we should look for ilms on this ill rather than the ones that have
19492 * been failed over here. They are here temporarily. As
19493 * ipif_multicast_up has joined on this ill, we should delete only
19494 * from this ill.
19495 */
19501 err));
19502 }
19503 /*
19504 * Disable multicast for the solicited node multicast address
19505 */
19518 err));
19519 }
19520 }
19523 }
19525 /*
19526 * Used when an interface comes up to recreate any extra routes on this
19527 * interface.
19528 */
19531 {
19546 }
19556 ushort_t type;
19558 /*
19559 * When the ire was initially created and then added in
19560 * ip_rt_add(), it was created either using ipif->ipif_net_type
19561 * in the case of a traditional interface route, or as one of
19562 * the IRE_OFFSUBNET types (with the exception of
19563 * IRE_HOST types ire which is created by icmp_redirect() and
19564 * which we don't need to save or recover). In the case where
19565 * ipif->ipif_net_type was IRE_LOOPBACK, ip_rt_add() will update
19566 * the ire_type to IRE_IF_NORESOLVER before calling ire_add()
19567 * to satisfy software like GateD and Sun Cluster which creates
19568 * routes using the the loopback interface's address as a
19569 * gateway.
19570 *
19571 * As ifrt->ifrt_type reflects the already updated ire_type,
19572 * ire_create() will be called in the same way here as
19573 * in ip_rt_add(), namely using ipif->ipif_net_type when
19574 * the route looks like a traditional interface route (where
19575 * ifrt->ifrt_type & IRE_INTERFACE is true) and otherwise using
19576 * the saved ifrt->ifrt_type. This means that in the case where
19577 * ipif->ipif_net_type is IRE_LOOPBACK, the ire created by
19578 * ire_create() will be an IRE_LOOPBACK, it will then be turned
19579 * into an IRE_IF_NORESOLVER and then added by ire_add().
19580 */
19593 /* Recover multiroute broadcast IRE. */
19608 }
19610 /*
19611 * Create a copy of the IRE with the saved address and netmask.
19612 */
19621 src_addr,
19622 gateway_addr,
19624 NULL,
19625 rfq,
19626 stq,
19627 type,
19628 ipif,
19634 NULL,
19635 NULL,
19636 ipst);
19643 }
19645 /*
19646 * Some software (for example, GateD and Sun Cluster) attempts
19647 * to create (what amount to) IRE_PREFIX routes with the
19648 * loopback address as the gateway. This is primarily done to
19649 * set up prefixes with the RTF_REJECT flag set (for example,
19650 * when generating aggregate routes.)
19651 *
19652 * If the IRE type (as defined by ipif->ipif_net_type) is
19653 * IRE_LOOPBACK, then we map the request into a
19654 * IRE_IF_NORESOLVER.
19655 */
19658 /*
19659 * ire held by ire_add, will be refreled' towards the
19660 * the end of ipif_up_done
19661 */
19664 irep++;
19666 }
19669 }
19671 /*
19672 * Used to set the netmask and broadcast address to default values when the
19673 * interface is brought up. (Always called as writer.)
19674 */
19675 static void
19677 {
19681 /*
19682 * Interface holds an IPv4 address. Default
19683 * mask is the natural netmask.
19684 */
19686 ipaddr_t v4mask;
19690 }
19692 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
19697 }
19698 /*
19699 * NOTE: SunOS 4.X does this even if the broadcast address
19700 * has been already set thus we do the same here.
19701 */
19703 ipaddr_t v4addr;
19707 }
19709 /*
19710 * Interface holds an IPv6-only address. Default
19711 * mask is all-ones.
19712 */
19716 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
19721 }
19722 }
19723 }
19725 /*
19726 * Return 0 if this address can be used as local address without causing
19727 * duplicate address problems. Otherwise, return EADDRNOTAVAIL if the address
19728 * is already up on a different ill, and EADDRINUSE if it's up on the same ill.
19729 * Special checks are needed to allow the same IPv6 link-local address
19730 * on different ills.
19731 * TODO: allowing the same site-local address on different ill's.
19732 */
19733 int
19735 {
19736 in6_addr_t our_v6addr;
19739 ill_walk_context_t ctx;
19755 else
19784 else
19786 }
19787 }
19788 }
19791 }
19793 /*
19794 * Bring up an ipif: bring up arp/ndp, bring up the DLPI stream, and add
19795 * IREs for the ipif.
19796 * When the routine returns EINPROGRESS then mp has been consumed and
19797 * the ioctl will be acked from ip_rput_dlpi.
19798 */
19799 static int
19801 {
19805 boolean_t success;
19811 /* Shouldn't get here if it is already up. */
19815 /* Skip arp/ndp for any loopback interface. */
19821 /*
19822 * ill_dl_up is not yet set. i.e. we are yet to
19823 * DL_BIND with the driver and this is the first
19824 * logical interface on the ill to become "up".
19825 * Tell the driver to get going (via DL_BIND_REQ).
19826 * Note that changing "significant" IFF_ flags
19827 * address/netmask etc cause a down/up dance, but
19828 * does not cause an unbind (DL_UNBIND) with the driver
19829 */
19831 }
19833 /*
19834 * ipif_resolver_up may end up sending an
19835 * AR_INTERFACE_UP message to ARP, which would, in
19836 * turn send a DLPI message to the driver. ioctls are
19837 * serialized and so we cannot send more than one
19838 * interface up message at a time. If ipif_resolver_up
19839 * does send an interface up message to ARP, we get
19840 * EINPROGRESS and we will complete in ip_arp_done.
19841 */
19855 /*
19856 * Crank up IPv6 neighbor discovery
19857 * Unlike ARP, this should complete when
19858 * ipif_ndp_up returns. However, for
19859 * ILLF_XRESOLV interfaces we also send a
19860 * AR_INTERFACE_UP to the external resolver.
19861 * That ioctl will complete in ip_rput.
19862 */
19869 }
19870 }
19871 /* Now, ARP */
19874 /* We will complete it in ip_arp_done */
19876 }
19882 /*
19883 * Interfaces without underlying hardware don't do duplicate
19884 * address detection.
19885 */
19888 }
19890 }
19892 /*
19893 * Perform a bind for the physical device.
19894 * When the routine returns EINPROGRESS then mp has been consumed and
19895 * the ioctl will be acked from ip_rput_dlpi.
19896 * Allocate an unbind message and save it until ipif_down.
19897 */
19898 static int
19900 {
19906 boolean_t success;
19913 /* Create a resolver cookie for ARP */
19924 }
19926 DL_BIND_REQ);
19936 /*
19937 * Record state needed to complete this operation when the
19938 * DL_BIND_ACK shows up. Also remember the pre-allocated mblks.
19939 */
19951 /*
19952 * Save the unbind message for ill_dl_down(); it will be consumed when
19953 * the interface goes down.
19954 */
19959 /* Send down link-layer capabilities probe if not already done. */
19962 /*
19963 * Sysid used to rely on the fact that netboots set domainname
19964 * and the like. Now that miniroot boots aren't strictly netboots
19965 * and miniroot network configuration is driven from userland
19966 * these things still need to be set. This situation can be detected
19967 * by comparing the interface being configured here to the one
19968 * dhcack was set to reference by the boot loader. Once sysid is
19969 * converted to use dhcp_ipc_getinfo() this call can go away.
19970 */
19976 }
19978 /*
19979 * This operation will complete in ip_rput_dlpi with either
19980 * a DL_BIND_ACK or DL_ERROR_ACK.
19981 */
19983 bad:
19985 /*
19986 * We don't have to check for possible removal from illgrp
19987 * as we have not yet inserted in illgrp. For groups
19988 * without names, this ipif is still not UP and hence
19989 * this could not have possibly had any influence in forming
19990 * groups.
19991 */
19996 }
20000 /*
20001 * DLPI and ARP is up.
20002 * Create all the IREs associated with an interface bring up multicast.
20003 * Set the interface flag and finish other initialization
20004 * that potentially had to be differed to after DL_BIND_ACK.
20005 */
20006 int
20008 {
20031 /* Check if this is a loopback interface */
20036 /*
20037 * If all other interfaces for this ill are down or DEPRECATED,
20038 * or otherwise unsuitable for source address selection, remove
20039 * any IRE_CACHE entries for this ill to make sure source
20040 * address selection gets to take this new ipif into account.
20041 * No need to hold ill_lock while traversing the ipif list since
20042 * we are writer
20043 */
20051 /* first useable pre-existing interface */
20054 }
20059 /*
20060 * Figure out which way the send-to queue should go. Only
20061 * IRE_IF_RESOLVER or IRE_IF_NORESOLVER or IRE_LOOPBACK
20062 * should show up here.
20063 */
20074 }
20077 /*
20078 * lo0:1 and subsequent ipifs were marked IRE_LOCAL in
20079 * ipif_lookup_on_name(), but in the case of zones we can have
20080 * several loopback addresses on lo0. So all the interfaces with
20081 * loopback addresses need to be marked IRE_LOOPBACK.
20082 */
20086 else
20088 }
20091 /*
20092 * Can't use our source address. Select a different
20093 * source address for the IRE_INTERFACE and IRE_LOCAL
20094 */
20099 else
20103 }
20105 /* Create all the IREs associated with this interface */
20109 /*
20110 * If we're on a labeled system then make sure that zone-
20111 * private addresses have proper remote host database entries.
20112 */
20118 /* Register the source address for __sin6_src_id */
20124 }
20126 /* If the interface address is set, create the local IRE. */
20137 NULL,
20141 ipif,
20148 NULL,
20149 NULL,
20150 ipst);
20157 }
20163 }
20167 /*
20168 * If mask was not specified, use natural netmask of
20169 * interface address. Also, store this mask back into the
20170 * ipif struct.
20171 */
20177 }
20179 /* Set up the IRE_IF_RESOLVER or IRE_IF_NORESOLVER, as appropriate. */
20182 /* ipif_subnet is ipif_pp_dst_addr for pt-pt */
20188 }
20201 NULL,
20205 ipif,
20211 NULL,
20212 NULL,
20213 ipst);
20214 }
20216 /*
20217 * Create any necessary broadcast IREs.
20218 */
20225 /* If an earlier ire_create failed, get out now */
20227 irep1--;
20232 }
20233 }
20235 /*
20236 * Need to atomically check for ip_addr_availablity_check
20237 * under ip_addr_avail_lock, and if it fails got bad, and remove
20238 * from group also.The ill_g_lock is grabbed as reader
20239 * just to make sure no new ills or new ipifs are being added
20240 * to the system while we are checking the uniqueness of addresses.
20241 */
20244 /* Mark it up, and increment counters. */
20252 /*
20253 * Our address may already be up on the same ill. In this case,
20254 * the ARP entry for our ipif replaced the one for the other
20255 * ipif. So we don't want to delete it (otherwise the other ipif
20256 * would be unable to send packets).
20257 * ip_addr_availability_check() identifies this case for us and
20258 * returns EADDRINUSE; we need to turn it into EADDRNOTAVAIL
20259 * which is the expected error code.
20260 */
20265 }
20269 }
20271 /*
20272 * Add in all newly created IREs. ire_create_bcast() has
20273 * already checked for duplicates of the IRE_BROADCAST type.
20274 * We want to add before we call ifgrp_insert which wants
20275 * to know whether IRE_IF_RESOLVER exists or not.
20276 *
20277 * NOTE : We refrele the ire though we may branch to "bad"
20278 * later on where we do ire_delete. This is okay
20279 * because nobody can delete it as we are running
20280 * exclusively.
20281 */
20283 irep1--;
20285 /*
20286 * refheld by ire_add. refele towards the end of the func
20287 */
20289 }
20291 /*
20292 * Form groups if possible.
20293 *
20294 * If we are supposed to be in a ill_group with a name, insert it
20295 * now as we know that at least one ipif is UP. Otherwise form
20296 * nameless groups.
20297 *
20298 * If ip_enable_group_ifs is set and ipif address is not 0, insert
20299 * this ipif into the appropriate interface group, or create a
20300 * new one. If this is already in a nameless group, we try to form
20301 * a bigger group looking at other ills potentially sharing this
20302 * ipif's prefix.
20303 */
20315 }
20316 }
20318 }
20320 /*
20321 * When this is part of group, we need to make sure that
20322 * any broadcast ires created because of this ipif coming
20323 * UP gets marked/cleared with IRE_MARK_NORECV appropriately
20324 * so that we don't receive duplicate broadcast packets.
20325 */
20329 /* Recover any additional IRE_IF_[NO]RESOLVER entries for this ipif */
20334 /*
20335 * If the broadcast address has been set, make sure it makes
20336 * sense based on the interface address.
20337 * Only match on ill since we are sharing broadcast addresses.
20338 */
20348 /*
20349 * If there isn't a matching broadcast IRE,
20350 * revert to the default for this netmask.
20351 */
20358 }
20359 }
20361 }
20363 /* This is the first interface on this ill */
20365 /*
20366 * Need to recover all multicast memberships in the driver.
20367 * This had to be deferred until we had attached.
20368 */
20370 }
20371 /* Join the allhosts multicast address */
20375 /*
20376 * See whether anybody else would benefit from the
20377 * new ipif that we added. We call this always rather
20378 * than while adding a non-IPIF_NOLOCAL/DEPRECATED/ANYCAST
20379 * ipif is for the benefit of illgrp_insert (done above)
20380 * which does not do source address selection as it does
20381 * not want to re-create interface routes that we are
20382 * having reference to it here.
20383 */
20385 }
20388 irep1--;
20390 /* was held in ire_add */
20392 }
20393 }
20398 /* was held in ire_add */
20400 }
20401 }
20404 /* Broadcast an address mask reply. */
20406 }
20410 }
20414 /*
20415 * This had to be deferred until we had bound. Tell routing sockets and
20416 * others that this interface is up if it looks like the address has
20417 * been validated. Otherwise, if it isn't ready yet, wait for
20418 * duplicate address detection to do its thing.
20419 */
20423 /* Let SCTP update the status for this ipif */
20425 }
20428 bad:
20430 /*
20431 * We don't have to bother removing from ill groups because
20432 *
20433 * 1) For groups with names, we insert only when the first ipif
20434 * comes up. In that case if it fails, it will not be in any
20435 * group. So, we need not try to remove for that case.
20436 *
20437 * 2) For groups without names, either we tried to insert ipif_ill
20438 * in a group as singleton or found some other group to become
20439 * a bigger group. For the former, if it fails we don't have
20440 * anything to do as ipif_ill is not in the group and for the
20441 * latter, there are no failures in illgrp_insert/illgrp_delete
20442 * (ENOMEM can't occur for this. Check ifgrp_insert).
20443 */
20445 irep--;
20450 }
20451 }
20457 }
20463 }
20465 /*
20466 * Turn off the ARP with the ILLF_NOARP flag.
20467 */
20468 static int
20470 {
20479 /*
20480 * If the on message is still around we've already done
20481 * an arp_off without doing an arp_on thus there is no
20482 * work needed.
20483 */
20487 /*
20488 * Allocate an ARP on message (to be saved) and an ARP off message
20489 */
20501 /* Send an AR_INTERFACE_OFF request */
20504 failed:
20509 }
20511 /*
20512 * Turn on ARP by turning off the ILLF_NOARP flag.
20513 */
20514 static int
20516 {
20524 /*
20525 * Send an AR_INTERFACE_ON request if we have already done
20526 * an arp_off (which allocated the message).
20527 */
20532 }
20534 }
20536 /*
20537 * Called after either deleting ill from the group or when setting
20538 * FAILED or STANDBY on the interface.
20539 */
20540 static void
20542 {
20547 /*
20548 * When called from illgrp_delete, ill_group will be non-NULL.
20549 * But when called from ip_sioctl_flags, it could be NULL if
20550 * somebody is setting FAILED/INACTIVE on some interface which
20551 * is not part of a group.
20552 */
20561 /*
20562 * Choose a good ill to be the next one for
20563 * outbound traffic. As the flags FAILED/STANDBY is
20564 * not yet marked when called from ip_sioctl_flags,
20565 * we check for ill separately.
20566 */
20574 }
20575 }
20576 }
20578 /*
20579 * Given an ill, find the next ill in the group to be scheduled.
20580 * (This should be called by ip_newroute() before ire_create().)
20581 * The passed in ill may be pulled out of the group, after we have picked
20582 * up a different outgoing ill from the same group. However ire add will
20583 * atomically check this.
20584 */
20585 ill_t *
20587 {
20595 /*
20596 * We don't use a lock to check for the ill_group. If this ill
20597 * is currently being inserted we may end up just returning this
20598 * ill itself. That is ok.
20599 */
20603 }
20605 /*
20606 * Grab the ill_g_lock as reader to make sure we are dealing with
20607 * a set of stable ills. No ill can be added or deleted or change
20608 * group while we hold the reader lock.
20609 */
20615 }
20624 /*
20625 * We do a circular search beginning at illgrp_ill_schednext
20626 * or illgrp_ill. We don't check the flags against the ill lock
20627 * since it can change anytime. The ire creation will be atomic
20628 * and will fail if the ill is FAILED or OFFLINE.
20629 */
20638 }
20642 }
20647 }
20649 /*
20650 * Checks for availbility of a usable source address (if there is one) when the
20651 * destination ILL has the ill_usesrc_ifindex pointing to another ILL. Note
20652 * this selection is done regardless of the destination.
20653 */
20654 boolean_t
20656 {
20657 uint_t ifindex;
20660 boolean_t isv6;
20690 }
20693 }
20695 }
20697 /*
20698 * Determine the best source address given a destination address and an ill.
20699 * Prefers non-deprecated over deprecated but will return a deprecated
20700 * address if there is no other choice. If there is a usable source address
20701 * on the interface pointed to by ill_usesrc_ifindex then that is given
20702 * first preference.
20703 *
20704 * Returns NULL if there is no suitable source address for the ill.
20705 * This only occurs when there is no valid source address for the ill.
20706 */
20707 ipif_t *
20709 {
20717 boolean_t specific_found;
20727 else
20729 }
20731 /*
20732 * If we're dealing with an unlabeled destination on a labeled system,
20733 * make sure that we ignore source addresses that are incompatible with
20734 * the destination's default label. That destination's default label
20735 * must dominate the minimum label on the source address.
20736 */
20745 }
20746 }
20748 /*
20749 * Holds the ill_g_lock as reader. This makes sure that no ipif/ill
20750 * can be deleted. But an ipif/ill can get CONDEMNED any time.
20751 * After selecting the right ipif, under ill_lock make sure ipif is
20752 * not condemned, and increment refcnt. If ipif is CONDEMNED,
20753 * we retry. Inside the loop we still need to check for CONDEMNED,
20754 * but not under a lock.
20755 */
20758 retry:
20765 /*
20766 * Choose one good source address from each ill across the group.
20767 * If possible choose a source address in the same subnet as
20768 * the destination address.
20769 *
20770 * We don't check for PHYI_FAILED or PHYI_INACTIVE or PHYI_OFFLINE
20771 * This is okay because of the following.
20772 *
20773 * If PHYI_FAILED is set and we still have non-deprecated
20774 * addresses, it means the addresses have not yet been
20775 * failed over to a different interface. We potentially
20776 * select them to create IRE_CACHES, which will be later
20777 * flushed when the addresses move over.
20778 *
20779 * If PHYI_INACTIVE is set and we still have non-deprecated
20780 * addresses, it means either the user has configured them
20781 * or PHYI_INACTIVE has not been cleared after the addresses
20782 * been moved over. For the former, in.mpathd does a failover
20783 * when the interface becomes INACTIVE and hence we should
20784 * not find them. Once INACTIVE is set, we don't allow them
20785 * to create logical interfaces anymore. For the latter, a
20786 * flush will happen when INACTIVE is cleared which will
20787 * flush the IRE_CACHES.
20788 *
20789 * If PHYI_OFFLINE is set, all the addresses will be failed
20790 * over soon. We potentially select them to create IRE_CACHEs,
20791 * which will be later flushed when the addresses move over.
20792 *
20793 * NOTE : As ipif_select_source is called to borrow source address
20794 * for an ipif that is part of a group, source address selection
20795 * will be re-done whenever the group changes i.e either an
20796 * insertion/deletion in the group.
20797 *
20798 * Fill ipif_arr[] with source addresses, using these rules:
20799 *
20800 * 1. At most one source address from a given ill ends up
20801 * in ipif_arr[] -- that is, at most one of the ipif's
20802 * associated with a given ill ends up in ipif_arr[].
20803 *
20804 * 2. If there is at least one non-deprecated ipif in the
20805 * IPMP group with a source address on the same subnet as
20806 * our destination, then fill ipif_arr[] only with
20807 * source addresses on the same subnet as our destination.
20808 * Note that because of (1), only the first
20809 * non-deprecated ipif found with a source address
20810 * matching the destination ends up in ipif_arr[].
20811 *
20812 * 3. Otherwise, fill ipif_arr[] with non-deprecated source
20813 * addresses not in the same subnet as our destination.
20814 * Again, because of (1), only the first off-subnet source
20815 * address will be chosen.
20816 *
20817 * 4. If there are no non-deprecated ipifs, then just use
20818 * the source address associated with the last deprecated
20819 * one we find that happens to be on the same subnet,
20820 * otherwise the first one not in the same subnet.
20821 */
20830 /* Always skip NOLOCAL and ANYCAST interfaces */
20839 /*
20840 * Interfaces with 0.0.0.0 address are allowed to be UP,
20841 * but are not valid as source addresses.
20842 */
20846 /*
20847 * Check compatibility of local address for
20848 * destination's default label if we're on a labeled
20849 * system. Incompatible addresses can't be used at
20850 * all.
20851 */
20853 boolean_t incompat;
20859 incompat =
20870 }
20872 /*
20873 * We prefer not to use all all-zones addresses, if we
20874 * can avoid it, as they pose problems with unlabeled
20875 * destinations.
20876 */
20885 }
20889 }
20896 }
20898 /* found a source address in the same subnet */
20902 }
20908 }
20913 }
20916 }
20917 }
20926 }
20933 }
20936 }
20944 #ifdef DEBUG
20960 }
20963 }
20966 /*
20967 * If old_ipif is not NULL, see if ipif was derived from old
20968 * ipif and if so, recreate the interface route by re-doing
20969 * source address selection. This happens when ipif_down ->
20970 * ipif_update_other_ipifs calls us.
20971 *
20972 * If old_ipif is NULL, just redo the source address selection
20973 * if needed. This happens when illgrp_insert or ipif_up_done
20974 * calls us.
20975 */
20976 static void
20978 {
20993 /*
20994 * Can't possibly have borrowed the source
20995 * from old_ipif.
20996 */
20998 }
21000 /*
21001 * Is there any work to be done? No work if the address
21002 * is INADDR_ANY, loopback or NOLOCAL or ANYCAST (
21003 * ipif_select_source() does not borrow addresses from
21004 * NOLOCAL and ANYCAST interfaces).
21005 */
21012 }
21014 /*
21015 * Perform the same checks as when creating the
21016 * IRE_INTERFACE in ipif_up_done.
21017 */
21029 /*
21030 * We know that ipif uses some other source for its
21031 * IRE_INTERFACE. Is it using the source of this
21032 * old_ipif?
21033 */
21038 }
21040 /* ip1dbg */
21043 }
21047 /*
21048 * Can't use our source address. Select a different
21049 * source address for the IRE_INTERFACE.
21050 */
21053 /* Last resort - all ipif's have IPIF_NOLOCAL */
21057 }
21069 ipif,
21075 NULL,
21076 NULL,
21077 ipst);
21083 /*
21084 * We don't need ipif_ire anymore. We need to delete
21085 * before we add so that ire_add does not detect
21086 * duplicates.
21087 */
21093 /* Held in ire_add */
21095 }
21096 /*
21097 * Either we are falling through from above or could not
21098 * allocate a replacement.
21099 */
21103 }
21105 /*
21106 * This old_ipif is going away.
21107 *
21108 * Determine if any other ipif's is using our address as
21109 * ipif_lcl_addr (due to those being IPIF_NOLOCAL, IPIF_ANYCAST, or
21110 * IPIF_DEPRECATED).
21111 * Find the IRE_INTERFACE for such ipifs and recreate them
21112 * to use an different source address following the rules in
21113 * ipif_up_done.
21114 *
21115 * This function takes an illgrp as an argument so that illgrp_delete
21116 * can call this to update source address even after deleting the
21117 * old_ipif->ipif_ill from the ill group.
21118 */
21119 static void
21121 {
21135 /*
21136 * If this part of a group, look at all ills as ipif_select_source
21137 * borrows source address across all the ills in the group.
21138 */
21150 }
21151 }
21152 }
21154 /* ARGSUSED */
21155 int
21158 {
21159 /*
21160 * ill_phyint_reinit merged the v4 and v6 into a single
21161 * ipsq. Could also have become part of a ipmp group in the
21162 * process, and we might not have been able to complete the
21163 * operation in ipif_set_values, if we could not become
21164 * exclusive. If so restart it here.
21165 */
21167 }
21170 /*
21171 * Can operate on either a module or a driver queue.
21172 * Returns an error if not a module queue.
21173 */
21174 /* ARGSUSED */
21175 int
21178 {
21188 }
21199 /*
21200 * Here we are not going to delay the ioack until after
21201 * ACKs from DL_ATTACH_REQ/DL_BIND_REQ. So no need to save the
21202 * original ioctl message before sending the requests.
21203 */
21205 }
21207 /* ARGSUSED */
21208 int
21211 {
21213 }
21215 /*
21216 * Create any IRE_BROADCAST entries for `ipif', and store those entries in
21217 * `irep'. Returns a pointer to the next free `irep' entry (just like
21218 * ire_check_and_create_bcast()).
21219 */
21222 {
21223 ipaddr_t addr;
21239 /*
21240 * For backward compatibility, we create net broadcast IREs based on
21241 * the old "IP address class system", since some old machines only
21242 * respond to these class derived net broadcast. However, we must not
21243 * create these net broadcast IREs if the subnetmask is shorter than
21244 * the IP address class based derived netmask. Otherwise, we may
21245 * create a net broadcast address which is the same as an IP address
21246 * on the subnet -- and then TCP will refuse to talk to that address.
21247 */
21252 flags);
21253 }
21255 /*
21256 * Don't create IRE_BROADCAST IREs for the interface if the subnetmask
21257 * is 0xFFFFFFFF, as an IRE_LOCAL for that interface is already
21258 * created. Creating these broadcast IREs will only create confusion
21259 * as `addr' will be the same as the IP address.
21260 */
21266 }
21269 }
21271 /*
21272 * Broadcast IRE info structure used in the functions below. Since we
21273 * allocate BCAST_COUNT of them on the stack, keep the bit layout compact.
21274 */
21287 /*
21288 * Check if `ipif' needs the dying broadcast IRE described by `bireinfop', and
21289 * return B_TRUE if it should immediately be used to recreate the IRE.
21290 */
21291 static boolean_t
21293 {
21294 ipaddr_t addr;
21308 }
21315 }
21317 }
21319 /*
21320 * Create the broadcast IREs described by `bireinfop' on `ipif', and return
21321 * them ala ire_check_and_create_bcast().
21322 */
21325 {
21342 }
21346 }
21348 /*
21349 * Walk through all of the ipifs on `ill' that will be affected by `test_ipif'
21350 * going away, and determine if any of the broadcast IREs (named by `bireinfop')
21351 * that are going away are still needed. If so, have ipif_create_bcast()
21352 * recreate them (except for the deprecated case, as explained below).
21353 */
21357 {
21363 /*
21364 * Skip this ipif if it's (a) the one being taken down, (b)
21365 * not in the same zone, or (c) has no valid local address.
21366 */
21374 /*
21375 * For each dying IRE that hasn't yet been replaced, see if
21376 * `ipif' needs it and whether the IRE should be recreated on
21377 * `ipif'. If `ipif' is deprecated, ipif_consider_bcast()
21378 * will return B_FALSE even if `ipif' needs the IRE on the
21379 * hopes that we'll later find a needy non-deprecated ipif.
21380 * However, the ipif is recorded in bi_backup for possible
21381 * subsequent use by ipif_check_bcast_ires().
21382 */
21389 }
21391 /*
21392 * If we've replaced all of the broadcast IREs that are going
21393 * to be taken down, we know we're done.
21394 */
21398 }
21401 }
21403 }
21405 /*
21406 * Check if `test_ipif' (which is going away) is associated with any existing
21407 * broadcast IREs, and whether any other ipifs (e.g., on the same ill) were
21408 * using those broadcast IREs. If so, recreate the broadcast IREs on one or
21409 * more of those other ipifs. (The old IREs will be deleted in ipif_down().)
21410 *
21411 * This is necessary because broadcast IREs are shared. In particular, a
21412 * given ill has one set of all-zeroes and all-ones broadcast IREs (for every
21413 * zone), plus one set of all-subnet-ones, all-subnet-zeroes, all-net-ones,
21414 * and all-net-zeroes for every net/subnet (and every zone) it has IPIF_UP
21415 * ipifs on. Thus, if there are two IPIF_UP ipifs on the same subnet with the
21416 * same zone, they will share the same set of broadcast IREs.
21417 *
21418 * Note: the upper bound of 12 IREs comes from the worst case of replacing all
21419 * six pairs (loopback and non-loopback) of broadcast IREs (all-zeroes,
21420 * all-ones, subnet-zeroes, subnet-ones, net-zeroes, and net-ones).
21421 */
21422 static void
21424 {
21435 /*
21436 * No broadcast IREs for the LOOPBACK interface
21437 * or others such as point to point and IPIF_NOXMIT.
21438 */
21458 /*
21459 * Figure out what (if any) broadcast IREs will die as a result of
21460 * `test_ipif' going away. If none will die, we're done.
21461 */
21467 willdie++;
21470 }
21471 }
21476 /*
21477 * Walk through all the ipifs that will be affected by the dying IREs,
21478 * and recreate the IREs as necessary.
21479 */
21482 /*
21483 * Scan through the set of broadcast IREs and see if there are any
21484 * that we need to replace that have not yet been replaced. If so,
21485 * replace them using the appropriate backup ipif.
21486 */
21491 }
21493 /*
21494 * If we can't create all of them, don't add any of them. (Code in
21495 * ip_wput_ire() and ire_to_ill() assumes that we always have a
21496 * non-loopback copy and loopback copy for a given address.)
21497 */
21499 irep1--;
21504 irep--;
21507 }
21509 }
21510 }
21513 irep1--;
21516 }
21517 }
21519 /*
21520 * Extract both the flags (including IFF_CANTCHANGE) such as IFF_IPV*
21521 * from lifr_flags and the name from lifr_name.
21522 * Set IFF_IPV* and ill_isv6 prior to doing the lookup
21523 * since ipif_lookup_on_name uses the _isv6 flags when matching.
21524 * Returns EINPROGRESS when mp has been consumed by queueing it on
21525 * ill_pending_mp and the ioctl will complete in ip_rput.
21526 *
21527 * Can operate on either a module or a driver queue.
21528 * Returns an error if not a module queue.
21529 */
21530 /* ARGSUSED */
21531 int
21534 {
21546 }
21549 /*
21550 * If we are not writer on 'q' then this interface exists already
21551 * and previous lookups (ipif_extract_lifreq()) found this ipif.
21552 * So return EALREADY
21553 */
21560 /*
21561 * Set all the flags. Allows all kinds of override. Provide some
21562 * sanity checking by not allowing IFF_BROADCAST and IFF_MULTICAST
21563 * unless there is either multicast/broadcast support in the driver
21564 * or it is a pt-pt link.
21565 */
21567 /* Meaningless to IP thus don't allow them to be set. */
21570 }
21571 /*
21572 * For a DL_STYLE2 driver (ill_needs_attach), we would not have the
21573 * ill_bcast_addr_length info.
21574 */
21579 /* Link not broadcast/pt-pt capable i.e. no multicast */
21582 }
21586 /* Link not broadcast capable or IPv6 i.e. no broadcast */
21589 }
21591 /* Can only be set with SIOCSLIFFLAGS */
21594 }
21599 }
21600 /*
21601 * Only allow the IFF_XRESOLV flag to be set on IPv6 interfaces.
21602 */
21608 }
21610 /*
21611 * The user has done SIOCGLIFFLAGS prior to this ioctl and hence
21612 * we have all the flags here. So, we assign rather than we OR.
21613 * We can't OR the flags here because we don't want to set
21614 * both IFF_IPV4 and IFF_IPV6. We start off as IFF_IPV4 in
21615 * ipif_allocate and become IFF_IPV4 or IFF_IPV6 here depending
21616 * on lifr_flags value here.
21617 */
21618 /*
21619 * This ill has not been inserted into the global list.
21620 * So we are still single threaded and don't need any lock
21621 */
21627 /* We started off as V4. */
21631 }
21634 }
21636 /* ARGSUSED */
21637 int
21640 {
21641 /*
21642 * ill_phyint_reinit merged the v4 and v6 into a single
21643 * ipsq. Could also have become part of a ipmp group in the
21644 * process, and we might not have been able to complete the
21645 * slifname in ipif_set_values, if we could not become
21646 * exclusive. If so restart it here
21647 */
21649 }
21651 /*
21652 * Return a pointer to the ipif which matches the index, IP version type and
21653 * zoneid.
21654 */
21655 ipif_t *
21658 {
21678 }
21679 }
21684 }
21686 }
21689 uint_t cc_old_ifindex;
21690 uint_t cc_new_ifindex;
21693 /*
21694 * ipcl_walk function for changing interface index.
21695 */
21696 static void
21698 {
21700 uint_t old_ifindex;
21701 uint_t new_ifindex;
21722 }
21723 }
21725 /*
21726 * Walk all the ipifs and ilms on this ill and change the orig_ifindex
21727 * to new_index if it matches the old_index.
21728 *
21729 * Failovers typically happen within a group of ills. But somebody
21730 * can remove an ill from the group after a failover happened. If
21731 * we are setting the ifindex after this, we potentially need to
21732 * look at all the ills rather than just the ones in the group.
21733 * We cut down the work by looking at matching ill_net_types
21734 * and ill_types as we could not possibly grouped them together.
21735 */
21736 static void
21738 {
21741 uint_t old_ifindex;
21742 uint_t new_ifindex;
21744 ill_walk_context_t ctx;
21756 }
21761 }
21765 }
21766 }
21768 }
21770 /*
21771 * We first need to ensure that the new index is unique, and
21772 * then carry the change across both v4 and v6 ill representation
21773 * of the physical interface.
21774 */
21775 /* ARGSUSED */
21776 int
21779 {
21784 conn_change_t connc;
21787 uint_t index;
21794 else
21797 /*
21798 * Only allow on physical interface. Also, index zero is illegal.
21799 *
21800 * Need to check for PHYI_FAILED and PHYI_INACTIVE
21801 *
21802 * 1) If PHYI_FAILED is set, a failover could have happened which
21803 * implies a possible failback might have to happen. As failback
21804 * depends on the old index, we should fail setting the index.
21805 *
21806 * 2) If PHYI_INACTIVE is set, in.mpathd does a failover so that
21807 * any addresses or multicast memberships are failed over to
21808 * a non-STANDBY interface. As failback depends on the old
21809 * index, we should fail setting the index for this case also.
21810 *
21811 * 3) If PHYI_OFFLINE is set, a possible failover has happened.
21812 * Be consistent with PHYI_FAILED and fail the ioctl.
21813 */
21819 }
21822 /* If the index is not changing, no work to do */
21826 /*
21827 * Use ill_lookup_on_ifindex to determine if the
21828 * new index is unused and if so allow the change.
21829 */
21831 ipst);
21833 ipst);
21840 }
21842 /*
21843 * The new index is unused. Set it in the phyint.
21844 * Locate the other ill so that we can send a routing
21845 * sockets message.
21846 */
21851 }
21855 /* Update SCTP's ILL list */
21863 /* Send the routing sockets message */
21869 }
21871 /* ARGSUSED */
21872 int
21875 {
21881 /* Get the interface index */
21886 }
21888 }
21890 /* ARGSUSED */
21891 int
21894 {
21899 /* Get the interface zone */
21903 }
21905 /*
21906 * Set the zoneid of an interface.
21907 */
21908 /* ARGSUSED */
21909 int
21912 {
21917 zone_status_t status;
21918 zoneid_t zoneid;
21925 }
21927 /* cannot assign instance zero to a non-global zone */
21931 /*
21932 * Cannot assign to a zone that doesn't exist or is shutting down. In
21933 * the event of a race with the zone shutdown processing, since IP
21934 * serializes this ioctl and SIOCGLIFCONF/SIOCLIFREMOVEIF, we know the
21935 * interface will be cleaned up even if the zone is shut down
21936 * immediately after the status check. If the interface can't be brought
21937 * down right away, and the zone is shut down before the restart
21938 * function is called, we resolve the possible races by rechecking the
21939 * zone status in the restart function.
21940 */
21950 /*
21951 * If the interface is already marked up,
21952 * we call ipif_down which will take care
21953 * of ditching any IREs that have been set
21954 * up based on the old interface address.
21955 */
21961 }
21965 }
21967 static int
21970 {
21979 else
21982 /*
21983 * For exclusive stacks we don't allow a different zoneid than
21984 * global.
21985 */
21990 /* Set the new zone id. */
21993 /* Update sctp list */
21997 /*
21998 * Now bring the interface back up. If this
21999 * is the only IPIF for the ILL, ipif_up
22000 * will have to re-bind to the device, so
22001 * we may get back EINPROGRESS, in which
22002 * case, this IOCTL will get completed in
22003 * ip_rput_dlpi when we see the DL_BIND_ACK.
22004 */
22006 }
22008 }
22010 /* ARGSUSED */
22011 int
22014 {
22016 zoneid_t zoneid;
22018 zone_status_t status;
22028 /*
22029 * We recheck the zone status to resolve the following race condition:
22030 * 1) process sends SIOCSLIFZONE to put hme0:1 in zone "myzone";
22031 * 2) hme0:1 is up and can't be brought down right away;
22032 * ip_sioctl_slifzone() returns EINPROGRESS and the request is queued;
22033 * 3) zone "myzone" is halted; the zone status switches to
22034 * 'shutting_down' and the zones framework sends SIOCGLIFCONF to list
22035 * the interfaces to remove - hme0:1 is not returned because it's not
22036 * yet in "myzone", so it won't be removed;
22037 * 4) the restart function for SIOCSLIFZONE is called; without the
22038 * status check here, we would have hme0:1 in "myzone" after it's been
22039 * destroyed.
22040 * Note that if the status check fails, we need to bring the interface
22041 * back to its state prior to ip_sioctl_slifzone(), hence the call to
22042 * ipif_up_done[_v6]().
22043 */
22048 }
22054 }
22056 }
22061 B_TRUE));
22062 }
22064 /* ARGSUSED */
22065 int
22068 {
22080 }
22083 /* Find the previous ILL in this usesrc group */
22086 {
22094 }
22096 /*
22097 * Release all members of the usesrc group. This routine is called
22098 * from ill_delete when the interface being unplumbed is the
22099 * group head.
22100 */
22101 static void
22103 {
22119 }
22121 /*
22122 * Remove the client usesrc ILL from the list and relink to a new list
22123 */
22124 int
22126 {
22133 /*
22134 * Check if the usesrc client ILL passed in is not already
22135 * in use as a usesrc ILL i.e one whose source address is
22136 * in use OR a usesrc ILL is not already in use as a usesrc
22137 * client ILL
22138 */
22142 }
22147 /* Remove from the current list */
22149 /* Only two elements in the list */
22154 }
22160 }
22168 }
22170 /*
22171 * Set the ill_usesrc and ill_usesrc_head fields. See synchronization notes in
22172 * ip.c for locking details.
22173 */
22174 /* ARGSUSED */
22175 int
22178 {
22184 uint_t ifindex;
22198 /*
22199 * If the client ILL is being used for IPMP, abort.
22200 * Note, this can be done before ipsq_try_enter since we are already
22201 * exclusive on this ILL
22202 */
22206 }
22211 /* non usesrc group interface, nothing to reset */
22213 }
22215 /* valid reset request */
22217 }
22224 }
22226 /*
22227 * The usesrc_cli_ill or the usesrc_ill cannot be part of an IPMP
22228 * group nor can either of the interfaces be used for standy. So
22229 * to guarantee mutual exclusion with ip_sioctl_flags (which sets
22230 * PHYI_STANDBY) and ip_sioctl_groupname (which sets the groupname)
22231 * we need to be exclusive on the ipsq belonging to the usesrc_ill.
22232 * We are already exlusive on this ipsq i.e ipsq corresponding to
22233 * the usesrc_cli_ill
22234 */
22239 /* Operation enqueued on the ipsq of the usesrc ILL */
22241 }
22243 /* Check if the usesrc_ill is used for IPMP */
22249 }
22251 /*
22252 * If the client is already in use as a usesrc_ill or a usesrc_ill is
22253 * already a client then return EINVAL
22254 */
22258 }
22260 /*
22261 * If the ill_usesrc_ifindex field is already set to what it needs to
22262 * be then this is a duplicate operation.
22263 */
22267 }
22273 /*
22274 * The next step ensures that no new ires will be created referencing
22275 * the client ill, until the ILL_CHANGING flag is cleared. Then
22276 * we go through an ire walk deleting all ire caches that reference
22277 * the client ill. New ires referencing the client ill that are added
22278 * to the ire table before the ILL_CHANGING flag is set, will be
22279 * cleaned up by the ire walk below. Attempt to add new ires referencing
22280 * the client ill while the ILL_CHANGING flag is set will be failed
22281 * during the ire_add in ire_atomic_start. ire_atomic_start atomically
22282 * checks (under the ill_g_usesrc_lock) that the ire being added
22283 * is not stale, i.e the ire_stq and ire_ipif are consistent and
22284 * belong to the same usesrc group.
22285 */
22294 else
22298 /*
22299 * ill_g_usesrc_lock global lock protects the ill_usesrc_grp_next
22300 * and the ill_usesrc_ifindex fields
22301 */
22308 }
22311 }
22313 /*
22314 * Four possibilities to consider:
22315 * 1. Both usesrc_ill and usesrc_cli_ill are not part of any usesrc grp
22316 * 2. usesrc_ill is part of a group but usesrc_cli_ill isn't
22317 * 3. usesrc_cli_ill is part of a group but usesrc_ill isn't
22318 * 4. Both are part of their respective usesrc groups
22319 */
22329 /* Insert at head of list */
22335 ifindex);
22338 }
22341 done:
22346 }
22349 /* The refrele on the lifr_name ipif is done by ip_process_ioctl */
22352 }
22354 /*
22355 * comparison function used by avl.
22356 */
22357 static int
22359 {
22361 uint_t index;
22366 /*
22367 * let the phyint with the lowest index be on top.
22368 */
22374 }
22376 /*
22377 * comparison function used by avl.
22378 */
22379 static int
22381 {
22389 else
22399 }
22400 /*
22401 * This function is called from ill_delete when the ill is being
22402 * unplumbed. We remove the reference from the phyint and we also
22403 * free the phyint when there are no more references to it.
22404 */
22405 static void
22407 {
22418 /*
22419 * ill_init allocates a phyint always to store the copy
22420 * of flags relevant to phyint. At that point in time, we could
22421 * not assign the name and hence phyint_illv4/v6 could not be
22422 * initialized. Later in ipif_set_values, we assign the name to
22423 * the ill, at which point in time we assign phyint_illv4/v6.
22424 * Thus we don't rely on phyint_illv6 to be initialized always.
22425 */
22430 }
22431 /*
22432 * ipif_down removes it from the group when the last ipif goes
22433 * down.
22434 */
22440 /*
22441 * Make sure this phyint was put in the list.
22442 */
22445 phyi);
22447 phyi);
22448 }
22449 /*
22450 * remove phyint from the ipsq list.
22451 */
22462 }
22464 }
22466 }
22472 }
22474 }
22476 /*
22477 * Attach the ill to the phyint structure which can be shared by both
22478 * IPv4 and IPv6 ill. ill_init allocates a phyint to just hold flags. This
22479 * function is called from ipif_set_values and ill_lookup_on_name (for
22480 * loopback) where we know the name of the ill. We lookup the ill and if
22481 * there is one present already with the name use that phyint. Otherwise
22482 * reuse the one allocated by ill_init.
22483 */
22484 static void
22486 {
22507 /*
22508 * 1. We grabbed the ill_g_lock before inserting this ill into
22509 * the global list of ills. So no other thread could have located
22510 * this ill and hence the ipsq of this ill is guaranteed to be empty.
22511 * 2. Now locate the other protocol instance of this ill.
22512 * 3. Now grab both ill locks in the right order, and the phyint lock of
22513 * the new ipsq. Holding ill locks + ill_g_lock ensures that the ipsq
22514 * of neither ill can change.
22515 * 4. Merge the phyint and thus the ipsq as well of this ill onto the
22516 * other ill.
22517 * 5. Release all locks.
22518 */
22520 /*
22521 * Look for IPv4 if we are initializing IPv6 or look for IPv6 if
22522 * we are initializing IPv4.
22523 */
22531 /*
22532 * We are potentially throwing away phyint_flags which
22533 * could be different from the one that we obtain from
22534 * ill_other->ill_phyint. But it is okay as we are assuming
22535 * that the state maintained within IP is correct.
22536 */
22544 }
22545 /*
22546 * This is a new ill, currently undergoing SLIFNAME
22547 * So we could not have joined an IPMP group until now.
22548 */
22552 /*
22553 * This phyi_old is going away. Decref ipsq_refs and
22554 * assert it is zero. The ipsq itself will be freed in
22555 * ipsq_exit
22556 */
22560 /* Get the singleton phyint out of the ipsq list */
22568 /*
22569 * We don't need to acquire any lock, since
22570 * the ill is not yet visible globally and we
22571 * have not yet released the ill_g_lock.
22572 */
22575 /* XXX We need a recovery strategy here. */
22579 /* No IPMP group yet, thus the hook uses the ifindex */
22586 phyint_list_avl_by_index,
22590 }
22592 /*
22593 * Reassigning ill_phyint automatically reassigns the ipsq also.
22594 * pending mp is not affected because that is per ill basis.
22595 */
22598 /*
22599 * Keep the index on ipif_orig_index to be used by FAILOVER.
22600 * We do this here as when the first ipif was allocated,
22601 * ipif_allocate does not know the right interface index.
22602 */
22605 /*
22606 * Now that the phyint's ifindex has been assigned, complete the
22607 * remaining
22608 */
22617 }
22619 /*
22620 * Generate an event within the hooks framework to indicate that
22621 * a new interface has just been added to IP. For this event to
22622 * be generated, the network interface must, at least, have an
22623 * ifindex assigned to it.
22624 *
22625 * This needs to be run inside the ill_g_lock perimeter to ensure
22626 * that the ordering of delivered events to listeners matches the
22627 * order of them in the kernel.
22628 *
22629 * This function could be called from ill_lookup_on_name. In that case
22630 * the interface is loopback "lo", which will not generate a NIC event.
22631 */
22634 /*
22635 * Generate nic plumb event for ill_name even if
22636 * ipmp_hook_emulation is set. That avoids generating events
22637 * for the ill_names should ipmp_hook_emulation be turned on
22638 * later.
22639 */
22641 }
22644 }
22646 /*
22647 * Allocate a NE_PLUMB nic info event and store in the ill.
22648 * If 'group' is set we do it for the group name, otherwise the ill name.
22649 * It will be sent when we leave the ipsq.
22650 */
22651 void
22653 {
22670 }
22678 }
22687 }
22701 "name information for PLUMB nic event "
22705 }
22707 }
22709 /*
22710 * Unhook the nic event message from the ill and enqueue it
22711 * into the nic event taskq.
22712 */
22713 void
22715 {
22728 }
22730 }
22731 }
22733 /*
22734 * Notify any downstream modules of the name of this interface.
22735 * An M_IOCTL is used even though we don't expect a successful reply.
22736 * Any reply message from the driver (presumably an M_IOCNAK) will
22737 * eventually get discarded somewhere upstream. The message format is
22738 * simply an SIOCSLIFNAME ioctl just as might be sent from ifconfig
22739 * to IP.
22740 */
22741 static void
22743 {
22755 }
22770 }
22772 static int
22774 {
22778 /* Set the obsolete NDD per-interface forwarding name. */
22782 err);
22783 }
22785 /* Tell downstream modules where they are. */
22788 /*
22789 * ill_dl_phys returns EINPROGRESS in the usual case.
22790 * Error cases are ENOMEM ...
22791 */
22794 /*
22795 * If there is no IRE expiration timer running, get one started.
22796 * igmp and mld timers will be triggered by the first multicast
22797 */
22799 /*
22800 * acquire the lock and check again.
22801 */
22807 }
22809 }
22817 }
22825 }
22827 }
22830 }
22832 /*
22833 * Common routine for ppa and ifname setting. Should be called exclusive.
22834 *
22835 * Returns EINPROGRESS when mp has been consumed by queueing it on
22836 * ill_pending_mp and the ioctl will complete in ip_rput.
22837 *
22838 * NOTE : If ppa is UNIT_MAX, we assign the next valid ppa and return
22839 * the new name and new ppa in lifr_name and lifr_ppa respectively.
22840 * For SLIFNAME, we pass these values back to the userland.
22841 */
22842 static int
22844 {
22867 /* The ppa is sent down by ifconfig or is chosen */
22870 }
22872 /*
22873 * make sure ppa passed in is same as ppa in the name.
22874 * This check is not made when ppa == UINT_MAX in that case ppa
22875 * in the name could be anything. System will choose a ppa and
22876 * update new_ppa_ptr and inter_name to contain the choosen ppa.
22877 */
22879 /* stoi changes the pointer */
22881 /*
22882 * ifconfig passed in 0 for the ppa for DLPI 1 style devices
22883 * (they don't have an externally visible ppa). We assign one
22884 * here so that we can manage the interface. Note that in
22885 * the past this value was always 0 for DLPI 1 drivers.
22886 */
22891 }
22892 /*
22893 * terminate string before ppa
22894 * save char at that location.
22895 */
22900 /*
22901 * Finish as much work now as possible before calling ill_glist_insert
22902 * which makes the ill globally visible and also merges it with the
22903 * other protocol instance of this phyint. The remaining work is
22904 * done after entering the ipsq which may happen sometime later.
22905 * ill_set_ndd_name occurs after the ill has been made globally visible.
22906 */
22909 /* We didn't do this when we allocated ipif in ip_ll_subnet_defaults */
22924 }
22926 /* Keep the !IN6_IS_ADDR_V4MAPPED assertions happy */
22933 /*
22934 * point-to-point or Non-mulicast capable
22935 * interfaces won't do NUD unless explicitly
22936 * configured to do so.
22937 */
22941 }
22942 /* Make sure IPv4 specific flag is not set on IPv6 if */
22944 /*
22945 * Note: xresolv interfaces will eventually need
22946 * NOARP set here as well, but that will require
22947 * those external resolvers to have some
22948 * knowledge of that flag and act appropriately.
22949 * Not to be changed at present.
22950 */
22952 }
22953 /*
22954 * Set the ILLF_ROUTER flag according to the global
22955 * IPv6 forwarding policy.
22956 */
22967 /*
22968 * Set the ILLF_ROUTER flag according to the global
22969 * IPv4 forwarding policy.
22970 */
22973 }
22977 /*
22978 * The ipIfStatsIfindex and ipv6IfIcmpIfIndex assignments will
22979 * be completed in ill_glist_insert -> ill_phyint_reinit
22980 */
22984 /*
22985 * Pick a default sap until we get the DL_INFO_ACK back from
22986 * the driver.
22987 */
22991 else
22993 }
23004 /*
23005 * undo null termination done above.
23006 */
23011 }
23015 /*
23016 * When we return the buffer pointed to by interf_name should contain
23017 * the same name as in ill_name.
23018 * If a ppa was choosen by the system (ppa passed in was UINT_MAX)
23019 * the buffer pointed to by new_ppa_ptr would not contain the right ppa
23020 * so copy full name and update the ppa ptr.
23021 * When ppa passed in != UINT_MAX all values are correct just undo
23022 * null termination, this saves a bcopy.
23023 */
23028 /*
23029 * undo null termination done above.
23030 */
23032 }
23034 /* Let SCTP know about this ILL */
23038 B_TRUE);
23045 /*
23046 * If ill_phyint_reinit() changed our ipsq, then start on the new ipsq.
23047 */
23050 else
23056 /*
23057 * restore previous values
23058 */
23060 }
23062 }
23065 void
23067 {
23068 hrtime_t hrt;
23071 /*
23072 * Can't call drv_getparm here as it is too early in the boot.
23073 * As we use ipif_src_random just for picking a different
23074 * source address everytime, this need not be really random.
23075 */
23085 }
23088 ill_phyint_compare_index,
23092 ill_phyint_compare_name,
23095 }
23097 /*
23098 * Lookup the ipif corresponding to the onlink destination address. For
23099 * point-to-point interfaces, it matches with remote endpoint destination
23100 * address. For point-to-multipoint interfaces it only tries to match the
23101 * destination with the interface's subnet address. The longest, most specific
23102 * match is found to take care of such rare network configurations like -
23103 * le0: 129.146.1.1/16
23104 * le1: 129.146.2.2/24
23105 * It is used only by SO_DONTROUTE at the moment.
23106 */
23107 ipif_t *
23109 {
23112 ill_walk_context_t ctx;
23128 /*
23129 * Point-to-point case. Look for exact match with
23130 * destination address.
23131 */
23140 }
23143 /*
23144 * Point-to-multipoint case. Looping through to
23145 * find the most specific match. If there are
23146 * multiple best match ipif's then prefer ipif's
23147 * that are UP. If there is only one best match
23148 * ipif and it is DOWN we must still return it.
23149 */
23164 RW_READER);
23166 }
23167 }
23168 }
23170 }
23173 }
23176 /*
23177 * Save enough information so that we can recreate the IRE if
23178 * the interface goes down and then up.
23179 */
23180 static void
23182 {
23204 }
23205 }
23208 static void
23210 {
23215 /* Remove from ipif_saved_ire_mp list if it is there */
23219 /*
23220 * On a given ipif, the triple of address, gateway and
23221 * mask is unique for each saved IRE (in the case of
23222 * ordinary interface routes, the gateway address is
23223 * all-zeroes).
23224 */
23234 }
23235 }
23237 }
23240 /*
23241 * IP multirouting broadcast routes handling
23242 * Append CGTP broadcast IREs to regular ones created
23243 * at ifconfig time.
23244 */
23245 static void
23247 {
23256 /*
23257 * We are in the special case of broadcasts for
23258 * CGTP. We add an IRE_BROADCAST that holds
23259 * the RTF_MULTIRT flag, the destination
23260 * address of ire_dst and the low level
23261 * info of ire_prim. In other words, CGTP
23262 * broadcast is added to the redundant ipif.
23263 */
23280 NULL,
23283 IRE_BROADCAST,
23284 ipif_prim,
23290 NULL,
23291 NULL,
23292 ipst);
23303 bcast_ire);
23305 }
23306 }
23308 }
23309 }
23312 /*
23313 * IP multirouting broadcast routes handling
23314 * Remove the broadcast ire
23315 */
23316 static void
23318 {
23342 IRE_BROADCAST,
23344 NULL,
23353 bcast_ire);
23355 }
23357 }
23359 }
23360 }
23362 /*
23363 * IPsec hardware acceleration capabilities related functions.
23364 */
23366 /*
23367 * Free a per-ill IPsec capabilities structure.
23368 */
23369 static void
23371 {
23379 }
23381 /*
23382 * Allocate a new per-ill IPsec capabilities structure. This structure
23383 * is specific to an IPsec protocol (AH or ESP). It is implemented as
23384 * an array which specifies, for each algorithm, whether this algorithm
23385 * is supported by the ill or not.
23386 */
23389 {
23391 uint_t nelems;
23397 /* we need one bit per algorithm */
23401 /* allocate memory to store algorithm flags */
23408 /*
23409 * Leave encr_algparm NULL for now since we won't need it half
23410 * the time
23411 */
23414 nomem:
23417 }
23419 /*
23420 * Resize capability array. Since we're exclusive, this is OK.
23421 */
23422 static boolean_t
23424 {
23434 }
23444 }
23450 }
23452 /*
23453 * Compare the capabilities of the specified ill with the protocol
23454 * and algorithms specified by the SA passed as argument.
23455 * If they match, returns B_TRUE, B_FALSE if they do not match.
23456 *
23457 * The ill can be passed as a pointer to it, or by specifying its index
23458 * and whether it is an IPv6 ill (ill_index and ill_isv6 arguments).
23459 *
23460 * Called by ipsec_out_is_accelerated() do decide whether an outbound
23461 * packet is eligible for hardware acceleration, and by
23462 * ill_ipsec_capab_send_all() to decide whether a SA must be sent down
23463 * to a particular ill.
23464 */
23465 boolean_t
23468 {
23469 boolean_t sa_isv6;
23470 uint_t algid;
23481 }
23483 }
23485 /*
23486 * Use the address length specified by the SA to determine
23487 * if it corresponds to a IPv6 address, and fail the matching
23488 * if the isv6 flag passed as argument does not match.
23489 * Note: this check is used for SADB capability checking before
23490 * sending SA information to an ill.
23491 */
23494 /* protocol mismatch */
23497 /*
23498 * Check if the ill supports the protocol, algorithm(s) and
23499 * key size(s) specified by the SA, and get the pointers to
23500 * the algorithms supported by the ill.
23501 */
23506 /* ill does not support ESP acceleration */
23521 }
23526 /* ill does not support AH acceleration */
23532 }
23537 done:
23541 }
23544 /*
23545 * Add a new ill to the list of IPsec capable ills.
23546 * Called from ill_capability_ipsec_ack() when an ACK was received
23547 * indicating that IPsec hardware processing was enabled for an ill.
23548 *
23549 * ill must point to the ill for which acceleration was enabled.
23550 * dl_cap must be set to DL_CAPAB_IPSEC_AH or DL_CAPAB_IPSEC_ESP.
23551 */
23552 static void
23554 {
23556 uint_t sa_type;
23557 uint_t ipproto;
23574 }
23578 /*
23579 * Add ill index to list of hardware accelerators. If
23580 * already in list, do nothing.
23581 */
23585 ;
23588 /* if this is a new entry for this ill */
23593 }
23600 /* not resync'ing SADB and an entry exists for this ill */
23603 }
23608 /*
23609 * IPsec module for protocol loaded, initiate dump
23610 * of the SADB to this ill.
23611 */
23613 }
23615 /*
23616 * Remove an ill from the list of IPsec capable ills.
23617 */
23618 static void
23620 {
23636 ;
23638 /* entry not found */
23641 }
23643 /* entry at front of list */
23647 }
23650 }
23652 /*
23653 * Called by SADB to send a DL_CONTROL_REQ message to every ill
23654 * supporting the specified IPsec protocol acceleration.
23655 * sa_type must be SADB_SATYPE_AH or SADB_SATYPE_ESP.
23656 * We free the mblk and, if sa is non-null, release the held referece.
23657 */
23658 void
23661 {
23676 /*
23677 * Handle the case where the ill goes away while the SADB is
23678 * attempting to send messages. If it's going away, it's
23679 * nuking its shadow SADB, so we don't care..
23680 */
23686 /*
23687 * Make sure capabilities match before
23688 * sending SA to ill.
23689 */
23694 }
23699 }
23701 /*
23702 * Copy template message, and add it to the front
23703 * of the mblk ship list. We want to avoid holding
23704 * the ipsec_capab_ills_lock while sending the
23705 * message to the ills.
23706 *
23707 * The b_next and b_prev are temporarily used
23708 * to build a list of mblks to be sent down, and to
23709 * save the ill to which they must be sent.
23710 */
23715 }
23720 }
23725 /* restore the mblk to a sane state */
23733 }
23738 }
23740 /*
23741 * Derive an interface id from the link layer address.
23742 * Knows about IEEE 802 and IEEE EUI-64 mappings.
23743 */
23744 static boolean_t
23746 {
23752 /* Form EUI-64 like address */
23760 }
23762 /* ARGSUSED */
23763 static boolean_t
23765 {
23767 }
23769 /* ARGSUSED */
23770 static boolean_t
23773 {
23774 /*
23775 * Multicast address mappings used over Ethernet/802.X.
23776 * This address is used as a base for mappings.
23777 */
23781 /*
23782 * Extract low order 32 bits from IPv6 multicast address.
23783 * Or that into the link layer address, starting from the
23784 * second byte.
23785 */
23793 }
23795 /*
23796 * Indicate by return value whether multicast is supported. If not,
23797 * this code should not touch/change any parameters.
23798 */
23799 /* ARGSUSED */
23800 static boolean_t
23803 {
23804 /*
23805 * Multicast address mappings used over Ethernet/802.X.
23806 * This address is used as a base for mappings.
23807 */
23818 }
23820 /*
23821 * Derive IPoIB interface id from the link layer address.
23822 */
23823 static boolean_t
23825 {
23832 /*
23833 * In IBA 1.1 timeframe, some vendors erroneously set the u/l bit
23834 * in the globally assigned EUI-64 GUID to 1, in violation of IEEE
23835 * rules. In these cases, the IBA considers these GUIDs to be in
23836 * "Modified EUI-64" format, and thus toggling the u/l bit is not
23837 * required; vendors are required not to assign global EUI-64's
23838 * that differ only in u/l bit values, thus guaranteeing uniqueness
23839 * of the interface identifier. Whether the GUID is in modified
23840 * or proper EUI-64 format, the ipv6 identifier must have the u/l
23841 * bit set to 1.
23842 */
23845 }
23847 /*
23848 * Note on mapping from multicast IP addresses to IPoIB multicast link
23849 * addresses. IPoIB multicast link addresses are based on IBA link addresses.
23850 * The format of an IPoIB multicast address is:
23851 *
23852 * 4 byte QPN Scope Sign. Pkey
23853 * +--------------------------------------------+
23854 * | 00FFFFFF | FF | 1X | X01B | Pkey | GroupID |
23855 * +--------------------------------------------+
23856 *
23857 * The Scope and Pkey components are properties of the IBA port and
23858 * network interface. They can be ascertained from the broadcast address.
23859 * The Sign. part is the signature, and is 401B for IPv4 and 601B for IPv6.
23860 */
23862 static boolean_t
23865 {
23866 /*
23867 * Base IPoIB IPv6 multicast address used for mappings.
23868 * Does not contain the IBA scope/Pkey values.
23869 */
23874 /*
23875 * Extract low order 80 bits from IPv6 multicast address.
23876 * Or that into the link layer address, starting from the
23877 * sixth byte.
23878 */
23882 /*
23883 * Now fill in the IBA scope/Pkey values from the broadcast address.
23884 */
23894 }
23896 static boolean_t
23899 {
23900 /*
23901 * Base IPoIB IPv4 multicast address used for mappings.
23902 * Does not contain the IBA scope/Pkey values.
23903 */
23911 /*
23912 * Extract low order 28 bits from IPv4 multicast address.
23913 * Or that into the link layer address, starting from the
23914 * sixteenth byte.
23915 */
23920 /*
23921 * Now fill in the IBA scope/Pkey values from the broadcast address.
23922 */
23927 }
23929 /*
23930 * Returns B_TRUE if an ipif is present in the given zone, matching some flags
23931 * (typically IPIF_UP). If ipifp is non-null, the held ipif is returned there.
23932 * This works for both IPv4 and IPv6; if the passed-in ill is v6, the ipif with
23933 * the link-local address is preferred.
23934 */
23935 boolean_t
23937 {
23947 }
23961 }
23968 }
23971 }
23976 }
23979 }
23981 /*
23982 * Same as ipif_lookup_zoneid() but looks at all the ills in the same group.
23983 */
23984 boolean_t
23986 {
23990 /*
23991 * We look at the passed-in ill first without grabbing ill_g_lock.
23992 */
23995 }
23998 /* ill not in a group */
24001 }
24003 /*
24004 * There's no ipif in the zone on ill, however ill is part of an IPMP
24005 * group. We need to look for an ipif in the zone on all the ills in the
24006 * group.
24007 */
24010 /*
24011 * We don't call ipif_lookup_zoneid() on ill as we already know
24012 * that it's not there.
24013 */
24017 }
24021 }
24023 /*
24024 * Check if this ill is only being used to send ICMP probes for IPMP
24025 */
24026 boolean_t
24028 {
24029 /*
24030 * Check if the interface is FAILED, or INACTIVE
24031 */
24036 }
24038 /*
24039 * Return a pointer to an ipif_t given a combination of (ill_idx,ipif_id)
24040 * If a pointer to an ipif_t is returned then the caller will need to do
24041 * an ill_refrele().
24042 *
24043 * If there is no real interface which matches the ifindex, then it looks
24044 * for a group that has a matching index. In the case of a group match the
24045 * lifidx must be zero. We don't need emulate the logical interfaces
24046 * since IP Filter's use of netinfo doesn't use that.
24047 */
24048 ipif_t *
24051 {
24056 ipst);
24059 /* Fallback to group names only if hook_emulation set */
24068 }
24075 }
24083 }
24084 }
24089 }
24091 /*
24092 * Flush the fastpath by deleting any nce's that are waiting for the fastpath,
24093 * There is one exceptions IRE_BROADCAST are difficult to recreate,
24094 * so instead we just nuke their nce_fp_mp's; see ndp_fastpath_flush()
24095 * for details.
24096 */
24097 void
24099 {
24105 }
24107 /*
24108 * Set the physical address information for `ill' to the contents of the
24109 * dl_notify_ind_t pointed to by `mp'. Must be called as writer, and will be
24110 * asynchronous if `ill' cannot immediately be quiesced -- in which case
24111 * EINPROGRESS will be returned.
24112 */
24113 int
24115 {
24123 /* Changing DL_IPV6_TOKEN is not yet supported */
24125 }
24127 /*
24128 * We need to store up to two copies of `mp' in `ill'. Due to the
24129 * design of ipsq_pending_mp_add(), we can't pass them as separate
24130 * arguments to ill_set_phys_addr_tail(). Instead, chain them
24131 * together here, then pull 'em apart in ill_set_phys_addr_tail().
24132 */
24136 }
24140 /*
24141 * If we can quiesce the ill, then set the address. If not, then
24142 * ill_set_phys_addr_tail() will be called from ipif_ill_refrele_tail().
24143 */
24147 /* call cannot fail since `conn_t *' argument is NULL */
24152 }
24157 }
24159 /*
24160 * Once the ill associated with `q' has quiesced, set its physical address
24161 * information to the values in `addrmp'. Note that two copies of `addrmp'
24162 * are passed (linked by b_cont), since we sometimes need to save two distinct
24163 * copies in the ill_t, and our context doesn't permit sleeping or allocation
24164 * failure (we'll free the other copy if it's not needed). Since the ill_t
24165 * is quiesced, we know any stale IREs with the old address information have
24166 * already been removed, so we don't need to call ill_fastpath_flush().
24167 */
24168 /* ARGSUSED */
24169 static void
24171 {
24196 else
24201 }
24203 /*
24204 * If there are ipifs to bring up, ill_up_ipifs() will return
24205 * EINPROGRESS, and ipsq_current_finish() will be called by
24206 * ip_rput_dlpi_writer() or ip_arp_done() when the last ipif is
24207 * brought up.
24208 */
24211 }
24213 /*
24214 * Helper routine for setting the ill_nd_lla fields.
24215 */
24216 void
24218 {
24223 }
24225 major_t IP_MAJ;
24231 /*
24232 * Issue REMOVEIF ioctls to have the loopback interfaces
24233 * go away. Other interfaces are either I_LINKed or I_PLINKed;
24234 * the former going away when the user-level processes in the zone
24235 * are killed * and the latter are cleaned up by the stream head
24236 * str_stack_shutdown callback that undoes all I_PLINKs.
24237 */
24238 void
24240 {
24251 #ifdef NS_DEBUG
24254 #endif
24261 #ifdef DEBUG
24263 error);
24264 #endif
24266 }
24273 #ifdef DEBUG
24275 error);
24276 #endif
24278 }
24285 /* LINTED - statement has no consequent */
24287 #ifdef NS_DEBUG
24290 #endif
24291 }
24297 #ifdef NS_DEBUG
24299 error);
24300 #endif
24302 }
24310 /* LINTED - statement has no consequent */
24312 #ifdef NS_DEBUG
24315 #endif
24316 }
24320 out:
24321 /* Close layered handles */
24328 }