ip_ire.c revision 2b24ab6b3865caeede9eeb9db6b83e1d89dcd1ea
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1990 Mentat Inc. */
/*
* This file contains routines that manipulate Internet Routing Entries (IREs).
*/
#include <inet/ip_ftable.h>
#include <inet/ipsec_info.h>
#include <inet/ipclassifier.h>
struct kmem_cache *rt_entry_cache;
/*
* Synchronization notes:
*
* The fields of the ire_t struct are protected in the following way :
*
*
* - bucket lock of the respective tables (cache or forwarding tables).
*
* ire_mp, ire_rfq, ire_stq, ire_u *except* ire_gateway_addr[v6], ire_mask,
* ire_type, ire_create_time, ire_masklen, ire_ipversion, ire_flags, ire_ipif,
* ire_ihandle, ire_phandle, ire_nce, ire_bucket, ire_in_ill, ire_in_src_addr
*
* - Set in ire_create_v4/v6 and never changes after that. Thus,
* we don't need a lock whenever these fields are accessed.
*
* - ire_bucket and ire_masklen (also set in ire_create) is set in
* ire_add_v4/ire_add_v6 before inserting in the bucket and never
* changes after that. Thus we don't need a lock whenever these
* fields are accessed.
*
* ire_gateway_addr_v4[v6]
*
* - ire_gateway_addr_v4[v6] is set during ire_create and later modified
* by rts_setgwr[v6]. As ire_gateway_addr is a uint32_t, updates to
* it assumed to be atomic and hence the other parts of the code
* does not use any locks. ire_gateway_addr_v6 updates are not atomic
*
* ire_ident, ire_refcnt
*
* - Updated atomically using atomic_add_32
*
* ire_ssthresh, ire_rtt_sd, ire_rtt, ire_ib_pkt_count, ire_ob_pkt_count
*
* - Assumes that 32 bit writes are atomic. No locks. ire_lock is
* used to serialize updates to ire_ssthresh, ire_rtt_sd, ire_rtt.
*
* ire_max_frag, ire_frag_flag
*
*
* ire_tire_mark
*
* - Set in ire_create and updated in ire_expire, which is called
* by only one function namely ip_trash_timer_expire. Thus only
* one function updates and examines the value.
*
* ire_marks
* - bucket lock protects this.
*
* ire_ll_hdr_length
*
* - Place holder for returning the information to the upper layers
* when IRE_DB_REQ comes down.
*
*
* ipv6_ire_default_count is protected by the bucket lock of
* ip_forwarding_table_v6[0][0].
*
* ipv6_ire_default_index is not protected as it is just a hint
* at which default gateway to use. There is nothing
* wrong in using the same gateway for two different connections.
*
* As we always hold the bucket locks in all the places while accessing
* the above values, it is natural to use them for protecting them.
*
* We have a separate cache table and forwarding table for IPv4 and IPv6.
* Cache table (ip_cache_table/ip_cache_table_v6) is a pointer to an
* array of irb_t structures. The IPv6 forwarding table
* (ip_forwarding_table_v6) is an array of pointers to arrays of irb_t
* structure. ip_forwarding_table_v6 is allocated dynamically in
* ire_add_v6. ire_ft_init_lock is used to serialize multiple threads
* initializing the same bucket. Once a bucket is initialized, it is never
* de-alloacted. This assumption enables us to access
* ip_forwarding_table_v6[i] without any locks.
*
* The forwarding table for IPv4 is a radix tree whose leaves
* are rt_entry structures containing the irb_t for the rt_dst. The irb_t
* for IPv4 is dynamically allocated and freed.
*
* Each irb_t - ire bucket structure has a lock to protect
* a bucket and the ires residing in the bucket have a back pointer to
* the bucket structure. It also has a reference count for the number
* of threads walking the bucket - irb_refcnt which is bumped up
* using the macro IRB_REFHOLD macro. The flags irb_flags can be
* set to IRE_MARK_CONDEMNED indicating that there are some ires
* in this bucket that are marked with IRE_MARK_CONDEMNED and the
* last thread to leave the bucket should delete the ires. Usually
* this is done by the IRB_REFRELE macro which is used to decrement
* the reference count on a bucket. See comments above irb_t structure
* definition in ip.h for further details.
*
* IRE_REFHOLD/IRE_REFRELE macros operate on the ire which increments/
* decrements the reference count, ire_refcnt, atomically on the ire.
* ire_refcnt is modified only using this macro. Operations on the IRE
* could be described as follows :
*
* CREATE an ire with reference count initialized to 1.
*
* ADDITION of an ire holds the bucket lock, checks for duplicates
* and then adds the ire. ire_add_v4/ire_add_v6 returns the ire after
* bumping up once more i.e the reference count is 2. This is to avoid
* an extra lookup in the functions calling ire_add which wants to
* work with the ire after adding.
*
* LOOKUP of an ire bumps up the reference count using IRE_REFHOLD
* macro. It is valid to bump up the referece count of the IRE,
* after the lookup has returned an ire. Following are the lookup
* functions that return an HELD ire :
*
* ire_lookup_local[_v6], ire_ctable_lookup[_v6], ire_ftable_lookup[_v6],
* ire_cache_lookup[_v6], ire_lookup_multi[_v6], ire_route_lookup[_v6],
* ipif_to_ire[_v6].
*
* DELETION of an ire holds the bucket lock, removes it from the list
* and then decrements the reference count for having removed from the list
* by using the IRE_REFRELE macro. If some other thread has looked up
* the ire, the reference count would have been bumped up and hence
* this ire will not be freed once deleted. It will be freed once the
* reference count drops to zero.
*
* Add and Delete acquires the bucket lock as RW_WRITER, while all the
* lookups acquire the bucket lock as RW_READER.
*
* NOTE : The only functions that does the IRE_REFRELE when an ire is
* passed as an argument are :
*
* 1) ip_wput_ire : This is because it IRE_REFHOLD/RELEs the
* broadcast ires it looks up internally within
* the function. Currently, for simplicity it does
* not differentiate the one that is passed in and
* the ones it looks up internally. It always
* IRE_REFRELEs.
* 2) ire_send
* ire_send_v6 : As ire_send calls ip_wput_ire and other functions
* that take ire as an argument, it has to selectively
* IRE_REFRELE the ire. To maintain symmetry,
* ire_send_v6 does the same.
*
* Otherwise, the general rule is to do the IRE_REFRELE in the function
* that is passing the ire as an argument.
*
* In trying to locate ires the following points are to be noted.
*
* IRE_MARK_CONDEMNED signifies that the ire has been logically deleted and is
* to be ignored when walking the ires using ire_next.
*
* Zones note:
* Walking IREs within a given zone also walks certain ires in other
* zones. This is done intentionally. IRE walks with a specified
* zoneid are used only when doing informational reports, and
* zone users want to see things that they can access. See block
* comment in ire_walk_ill_match().
*/
/*
* The minimum size of IRE cache table. It will be recalcuated in
* ip_ire_init().
*/
/*
* The size of the forwarding table. We will make sure that it is a
* power of 2 in ip_ire_init().
*/
struct kmem_cache *ire_cache;
/*
* The threshold number of IRE in a bucket when the IREs are
* cleaned up. This threshold is calculated later in ip_open()
* based on the speed of CPU and available memory. This default
* value is the maximum.
*
* We have two kinds of cached IRE, temporary and
* non-temporary. Temporary IREs are marked with
* IRE_MARK_TEMPORARY. They are IREs created for non
* TCP traffic and for forwarding purposes. All others
* are non-temporary IREs. We don't mark IRE created for
* TCP as temporary because TCP is stateful and there are
* info stored in the IRE which can be shared by other TCP
* connections to the same destination. For connected
* endpoint, we also don't want to mark the IRE used as
* temporary because the same IRE will be used frequently,
* otherwise, the app should not do a connect(). We change
* the marking at ip_bind_connected_*() if necessary.
*
* We want to keep the cache IRE hash bucket length reasonably
* short, otherwise IRE lookup functions will take "forever."
* We use the "crude" function that the IRE bucket
* length should be based on the CPU speed, which is 1 entry
* per x MHz, depending on the shift factor ip_ire_cpu_ratio
* (n). This means that with a 750MHz CPU, the max bucket
* length can be (750 >> n) entries.
*
* Note that this threshold is separate for temp and non-temp
* IREs. This means that the actual bucket length can be
* twice as that. And while we try to keep temporary IRE
* length at most at the threshold value, we do not attempt to
* make the length for non-temporary IREs fixed, for the
* reason stated above. Instead, we start trying to find
* "unused" non-temporary IREs when the bucket length reaches
* this threshold and clean them up.
*
* We also want to limit the amount of memory used by
* IREs. So if we are allowed to use ~3% of memory (M)
* for those IREs, each bucket should not have more than
*
* M / num of cache bucket / sizeof (ire_t)
*
* Again the above memory uses are separate for temp and
* non-temp cached IREs.
*
* We may also want the limit to be a function of the number
* of interfaces and number of CPUs. Doing the initialization
* in ip_open() means that every time an interface is plumbed,
* the max is re-calculated. Right now, we don't do anything
* different. In future, when we have more experience, we
* may want to change this behavior.
*/
/*
* The minimum of the temporary IRE bucket count. We do not want
* the length of each bucket to be too short. This may hurt
* performance of some apps as the temporary IREs are removed too
* often.
*/
/*
* The ratio of memory consumed by IRE used for temporary to available
* memory. This is a shift factor, so 6 means the ratio 1 to 64. This
*/
/* The shift factor for CPU speed to calculate the max IRE bucket length. */
typedef struct nce_clookup_s {
/*
* The maximum number of buckets in IRE cache table. In future, we may
* want to make it a dynamic hash table. For the moment, we fix the
* size and allocate the table in ip_ire_init() when IP is first loaded.
* We take into account the amount of memory a system has.
*/
#define IP_MAX_CACHE_TABLE_SIZE 4096
/* Zero iulp_t for initialization. */
const iulp_t ire_uinfo_null = { 0 };
#ifdef DEBUG
static void ire_trace_cleanup(const ire_t *);
#endif
/*
* To avoid bloating the code, we call this function instead of
* using the macro IRE_REFRELE. Use macro only in performance
* critical paths.
*
* Must not be called while holding any locks. Otherwise if this is
* the last reference to be released there is a chance of recursive mutex
* panic due to ire_refrele -> ipif_ill_refrele_tail -> qwriter_ip trying
* to restart an ioctl. The one exception is when the caller is sure that
* this is not the last reference to be released. Eg. if the caller is
* sure that the ire has not been deleted and won't be deleted.
*/
void
{
}
void
{
}
/*
* kmem_cache_alloc constructor for IRE in kma space.
* Note that when ire_mp is set the IRE is stored in that mblk and
* not in this cache.
*/
/* ARGSUSED */
static int
{
return (0);
}
/* ARGSUSED1 */
static void
{
}
/*
* This function is associated with the IP_IOC_IRE_ADVISE_NO_REPLY
* IOCTL. It is used by TCP (or other ULPs) to supply revised information
* for an existing CACHED IRE.
*/
/* ARGSUSED */
int
{
/*
* Check privilege using the ioctl credential; if it is NULL
* then this is a kernel message and therefor privileged.
*/
return (EPERM);
ipic->ipic_addr_length))) {
return (EINVAL);
}
return (EINVAL);
switch (ipic->ipic_addr_length) {
case IP_ADDR_LEN: {
/* Extract the destination address. */
/* Find the corresponding IRE. */
break;
}
case IPV6_ADDR_LEN: {
/* Extract the destination address. */
/* Find the corresponding IRE. */
break;
}
default:
return (EINVAL);
}
return (ENOENT);
/*
*
* We serialize multiple advises using ire_lock.
*/
/*
* If there is no old cached values, initialize them
* conservatively. Set them to be (1.5 * new value).
*/
} else {
}
} else {
}
}
if (ipic->ipic_max_frag)
if (ipic->ipic_ssthresh != 0) {
(ipic->ipic_ssthresh +
else
}
/*
* Don't need the ire_lock below this. ire_type does not change
* after initialization. ire_marks is protected by irb_lock.
*/
/*
* Only increment the temporary IRE count if the original
* IRE is not already marked temporary.
*/
irb->irb_tmp_ire_cnt++;
}
}
return (0);
}
/*
* This function is associated with the IP_IOC_IRE_DELETE[_NO_REPLY]
* IOCTL[s]. The NO_REPLY form is used by TCP to delete a route IRE
* for a host that is not responding. This will force an attempt to
* establish a new route, if available, and flush out the ARP entry so
* it will re-resolve. Management processes may want to use the
* version that generates a reply.
*
* This function does not support IPv6 since Neighbor Unreachability Detection
* means that negative advise like this is useless.
*/
/* ARGSUSED */
int
{
ipst = CONNQ_TO_IPST(q);
/*
* Check privilege using the ioctl credential; if it is NULL
* then this is a kernel message and therefor privileged.
*/
return (EPERM);
/* Only actions on IRE_CACHEs are acceptable at present. */
return (EINVAL);
return (EINVAL);
switch (ipid->ipid_addr_length) {
case IP_ADDR_LEN:
/* addr_ucp points at IP addr */
break;
case sizeof (sin_t): {
/*
* got complete (sockaddr) address - increment addr_ucp to point
* at the ip_addr field.
*/
break;
}
default:
return (EINVAL);
}
/* Extract the destination address. */
/* Try to find the CACHED IRE. */
/* Nail it. */
if (ire) {
/* Allow delete only on CACHE entries */
return (EINVAL);
}
/*
* Verify that the IRE has been around for a while.
* This is to protect against transport protocols
* that are too eager in sending delete messages.
*/
if (gethrestime_sec() <
return (EINVAL);
}
/*
* Now we have a potentially dead cache entry. We need
* to remove it.
* If this cache entry is generated from a
* default route (i.e., ire_cmask == 0),
* search the default list and mark it dead and some
* background process will try to activate it.
*/
/*
* Make sure that we pick a different
* IRE_DEFAULT next time.
*/
ipst);
ip3dbg(("ire_ftable_lookup() returned gire %p\n",
(void *)gire));
/*
* We grab it as writer just to serialize
* multiple threads trying to bump up
* irb_rr_origin
*/
goto done;
}
/* Skip past the potentially bad gateway */
if (ire->ire_gateway_addr ==
}
}
}
done:
/* report the bad route to routing sockets */
/*
* TCP is really telling us to start over completely, and it
* expects that we'll resend the ARP query. Tell ARP to
* discard the entry, if this is a local destination.
*
* But, if the ARP entry is permanent then it shouldn't be
* deleted, so we set ARED_F_PRESERVE_PERM.
*/
if (ire->ire_gateway_addr == 0 &&
}
}
/*
* Also look for an IRE_HOST type redirect ire and
* remove it if present.
*/
/* Nail it. */
if (!routing_sock_info) {
ire->ire_src_addr, 0, 0, 0,
(RTA_DST | RTA_GATEWAY |
RTA_NETMASK | RTA_IFA),
ipst);
}
}
}
return (0);
}
/*
* ip_ire_req is called by ip_wput when an IRE_DB_REQ_TYPE message is handed
* down from the Upper Level Protocol to request a copy of the IRE (to check
* its type or to extract information like round-trip time estimates or the
* MTU.)
* The address is assumed to be in the ire_addr field. If no IRE is found
* an IRE is returned with ire_type being zero.
* Note that the upper lavel protocol has to check for broadcast
* (IRE_BROADCAST) and multicast (CLASSD(addr)).
* If there is a b_cont the resulting IRE_DB_TYPE mblk is placed at the
* end of the returned message.
*
* TCP sends down a message of this type with a connection request packet
* chained on. UDP and ICMP send it down to verify that a route exists for
* the destination address when they get connected.
*/
void
{
return;
}
/*
* Got it, now take our best shot at an IRE.
*/
} else {
}
/*
* We prevent returning IRES with source address INADDR_ANY
* as these were temporarily created for sending packets
* from endpoints that have conn_unspec_src set.
*/
} else {
/* Copy the route metrics from the parent. */
sizeof (iulp_t));
}
/* Pass the latest setting of the ip_path_mtu_discovery */
inire->ire_frag_flag |=
}
/* Put the IRE_DB_TYPE mblk last in the chain */
}
}
/*
* Send a packet using the specified IRE.
* If ire_src_addr_v6 is all zero then discard the IRE after
* the packet has been sent.
*/
static void
{
if (is_secure) {
}
/* If the packet originated externally then */
/*
* Extract the ifindex from b_prev (set in ip_rput_noire).
* Look up interface to see if it still exists (it could have
* been unplumbed by the time the reply came back from ARP)
*/
return;
}
/*
* This packet has not gone through IPSEC processing
* and hence we should not have any IPSEC message
* prepended.
*/
/* Packets from multicast router */
/*
* We never get the IPSEC_OUT while forwarding the
* packet for multicast router.
*/
} else {
/* Locally originated packets */
/*
* If this IRE shouldn't be kept in the table (because its
* source address is unspecified), hold a reference to it so
* we can delete it even after e.g. ip_wput_ire() has dropped
* its reference.
*/
delete_ire = B_TRUE;
}
/*
* If we were resolving a router we can not use the
* routers IRE for sending the packet (since it would
* violate the uniqness of the IP idents) thus we
* make another pass through ip_wput to create the IRE_CACHE
* for the destination.
* When IRE_MARK_NOADD is set, ire_add() is not called.
* Thus ip_wput() will never find a ire and result in an
* infinite loop. Thus we check whether IRE_MARK_NOADD is
* is set. This also implies that IRE_MARK_NOADD can only be
* used to send packets to directly connected hosts.
*/
if (CONN_Q(q)) {
IRE_SEND);
} else {
}
} else {
if (is_secure) {
if (oi->ipsec_out_proc_begin) {
/*
* This is the case where
* ip_wput_ipsec_out could not find
* the IRE and recreated a new one.
* As ip_wput_ipsec_out does ire
* lookups, ire_refrele for the extra
* bump in ire_add.
*/
} else {
/*
* IRE_REFRELE will be done in
* ip_wput_ire.
*/
}
} else {
/*
* IRE_REFRELE will be done in ip_wput_ire.
*/
}
}
/*
* Special code to support sending a single packet with
* conn_unspec_src using an IRE which has no source address.
* The IRE is deleted here after sending the packet to avoid
* having other code trip on it. But before we delete the
* ire, somebody could have looked up this ire.
* by making checks to NULL source address in other places
* like e.g ip_ire_append, ip_ire_req and ip_bind_connected.
* Though this does not completely prevent other threads
* from using this ire, this should not cause any problems.
*/
if (delete_ire) {
ip1dbg(("ire_send: delete IRE\n"));
}
}
}
/*
* Send a packet using the specified IRE.
* If ire_src_addr_v6 is all zero then discard the IRE after
* the packet has been sent.
*/
static void
{
} else {
}
/* If the packet originated externally then */
/*
* Extract the ifindex from b_prev (set in ip_rput_data_v6).
* Look up interface to see if it still exists (it could have
* been unplumbed by the time the reply came back from the
* resolver).
*/
return;
}
/*
* This packet has not gone through IPSEC processing
* and hence we should not have any IPSEC message
* prepended.
*/
/* Packets from multicast router */
/*
* We never get the IPSEC_OUT while forwarding the
* packet for multicast router.
*/
/*
* XXX TODO IPv6.
*/
#ifdef XXX
#endif
} else {
if (secure) {
if (oi->ipsec_out_proc_begin) {
/*
* This is the case where
* ip_wput_ipsec_out could not find
* the IRE and recreated a new one.
*/
} else {
if (CONN_Q(q)) {
(void) ip_output_v6(Q_TO_CONN(q),
} else {
(void) ip_output_v6(
}
}
} else {
/*
* Send packets through ip_output_v6 so that any
* ip6_info header can be processed again.
*/
if (CONN_Q(q)) {
IRE_SEND);
} else {
}
}
/*
* Special code to support sending a single packet with
* conn_unspec_src using an IRE which has no source address.
* The IRE is deleted here after sending the packet to avoid
* having other code trip on it. But before we delete the
* ire, somebody could have looked up this ire.
* by making checks to NULL source address in other places
* like e.g ip_ire_append_v6, ip_ire_req and
* ip_bind_connected_v6. Though, this does not completely
* prevent other threads from using this ire, this should
* not cause any problems.
*/
ip1dbg(("ire_send_v6: delete IRE\n"));
}
}
}
/*
* Make sure that IRE bucket does not get too long.
* This can cause lock up because ire_cache_lookup()
* may take "forever" to finish.
*
* We only remove a maximum of cnt IREs each time. This
* should keep the bucket length approximately constant,
* depending on cnt. This should be enough to defend
* against DoS attack based on creating temporary IREs
* (for forwarding and non-TCP traffic).
*
* We also pass in the address of the newly created IRE
* as we do not want to remove this straight after adding
* it. New IREs are normally added at the tail of the
* bucket. This means that we are removing the "oldest"
* temporary IREs added. Only if there are IREs with
* the same ire_addr, do we not add it at the tail. Refer
* to ire_add_v*(). It should be OK for our purpose.
*
* For non-temporary cached IREs, we make sure that they
* have not been used for some time (defined below), they
* are non-local destinations, and there is no one using
* them at the moment (refcnt == 1).
*
* The above means that the IRE bucket length may become
* very long, consisting of mostly non-temporary IREs.
* This can happen when the hash function does a bad job
* so that most TCP connections cluster to a specific bucket.
* This "hopefully" should never happen. It can also
* happen if most TCP connections have very long lives.
* Even with the minimal hash table size of 256, there
* has to be a lot of such connections to make the bucket
* length unreasonably long. This should probably not
* happen either. The third can when this can happen is
* when the machine is under attack, such as SYN flooding.
* TCP should already have the proper mechanism to protect
* that. So we should be safe.
*
* This function is called by ire_add_then_send() after
* a new IRE is added and the packet is sent.
*
* The idle cutoff interval is set to 60s. It can be
*/
static void
{
int cnt = ip_ire_cleanup_cnt;
/*
* Try to remove cnt temporary IREs first.
*/
continue;
continue;
cnt--;
}
}
if (cnt == 0)
return;
/*
* If we didn't satisfy our removal target from temporary IREs
* we see how many non-temporary IREs are currently in the bucket.
* If this quantity is above the threshold then we see if there are any
* candidates for removal. We are still limited to removing a maximum
* of cnt IREs.
*/
continue;
continue;
continue;
cnt--;
}
}
}
}
/*
* ire_add_then_send is called when a new IRE has been created in order to
* route an outgoing packet. Typically, it is called from ip_wput when
* a response comes back down from a resolver. We add the IRE, and then
* possibly run the packet through ip_wput or ip_rput, as appropriate.
* However, we do not add the newly created IRE in the cache when
* IRE_MARK_NOADD is set in the IRE. IRE_MARK_NOADD is set at
* ip_newroute_ipif(). The ires with IRE_MARK_NOADD are ire_refrele'd by
* ip_wput_ire() and get deleted.
* Multirouting support: the packet is silently discarded when the new IRE
* holds the RTF_MULTIRT flag, but is not the first IRE to be added with the
* RTF_MULTIRT flag for the same destination address.
* In this case, we just want to register this additional ire without
* sending the packet, as it has already been replicated through
* existing multirt routes in ip_wput().
*/
void
{
int ire_limit;
/*
* We first have to retrieve the destination address carried
* by the packet.
* We can't rely on ire as it can be related to a gateway.
* The destination address will help in determining if
* other RTF_MULTIRT ires are already registered.
*
* We first need to know where we are going : v4 or V6.
* the ire version is enough, as there is no risk that
* we resolve an IPv6 address with an IPv4 ire
* or vice versa.
*/
} else {
}
/*
* At least one resolved multirt route
* already exists for the destination,
* don't sent this packet: either drop it
* or complete the pending resolution,
* depending on the ire.
*/
}
ip1dbg(("ire_add_then_send: dst_ire %p "
"[dst %08x, gw %08x], drop %d\n",
(void *)dst_ire,
drop));
}
}
/* Regular packets with cache bound ires are here. */
return;
}
return;
}
}
if (drop) {
/*
* If we're adding an RTF_MULTIRT ire, the resolution
* is over: we just drop the packet.
*/
} else {
/*
* Otherwise, we're adding the ire to a gateway
* for a multirt route.
* Invoke ip_newroute() to complete the resolution
* of the route. We will then come back here and
* finally drop this packet in the above code.
*/
/*
* TODO: in order for CGTP to work in non-global
* zones, ip_newroute() must create the IRE
* cache in the zone indicated by
* ire->ire_zoneid.
*/
} else {
/*
* If necessary, skip over the ip6i_t to find
* the header with the actual source address.
*/
ip1dbg(("ire_add_then_send: "
"cannot pullupmsg ip6i\n"));
if (mctl_present)
return;
}
sizeof (ip6i_t));
}
ipst);
}
}
return;
}
/*
* Need to remember ire_bucket here as ire_send*() may delete
* the ire so we cannot reference it after that.
*/
} else {
}
/*
* irb is NULL if the IRE was not added to the hash. This happens
* when IRE_MARK_NOADD is set and when IREs are returned from
* ire_update_srcif_v4().
*/
}
}
/*
* Initialize the ire that is specific to IPv4 part and call
* ire_init_common to finish it.
*/
ire_t *
{
/*
* Reject IRE security attribute creation/initialization
* if system is not running in Trusted mode.
*/
return (NULL);
}
}
/* ire_init_common will free the mblks upon encountering any failure */
return (NULL);
return (ire);
}
/*
* Similar to ire_create except that it is called only when
* we want to allocate ire as an mblk e.g. we have an external
* resolver ARP.
*/
ire_t *
{
ip1dbg(("ire_create_mp: alloc failed\n"));
return (NULL);
}
/*
* Allocate the new IRE. The ire created will hold a ref on
* an nce_t after ire_nce_init, and this ref must either be
* (a) transferred to the ire_cache entry created when ire_add_v4
* is called after successful arp resolution, or,
* (b) released, when arp resolution fails
* Case (b) is handled in ire_freemblk() which will be called
* when mp is freed as a result of failed arp.
*/
ip1dbg(("ire_create_mp: alloc failed\n"));
return (NULL);
}
/* Start clean. */
/* ire_freemblk needs these set */
return (NULL);
}
/*
* ire_max_frag is normally zero here and is atomically set
* under the irebucket lock in ire_add_v[46] except for the
* case of IRE_MARK_NOADD. In that event the the ire_max_frag
* is non-zero here.
*/
return (ire);
}
/*
* ire_create is called to allocate and initialize a new IRE.
*
* NOTE : This is called as writer sometimes though not required
* by this function.
*/
ire_t *
{
ip1dbg(("ire_create: alloc failed\n"));
return (NULL);
}
return (NULL);
}
return (ire);
}
/*
* Common to IPv4 and IPv6
*/
{
#ifdef DEBUG
else
}
#endif /* DEBUG */
/*
* Create/initialize IRE security attribute only in Trusted mode;
* has held a reference to it and will release it when this routine
* returns a failure, otherwise we own the reference. We do this
* prior to initializing the rest IRE fields.
*
* Don't allocate ire_gw_secattr for the resolver case to prevent
* memory leak (in case of external resolution failure). We'll
* allocate it after a successful external resolution, in ire_add().
* Note that ire->ire_mp != NULL here means this ire is headed
* to an external resolver.
*/
if (is_system_labeled()) {
IRE_INTERFACE)) != 0) {
/* release references on behalf of caller */
GC_REFRELE(gc);
return (B_FALSE);
}
}
/*
* If this IRE is an IRE_CACHE, inherit the handles from the
* parent IREs. For others in the forwarding table, assign appropriate
* new ones.
*
* The mutex protecting ire_handle is because ire_create is not always
* called as a writer.
*/
}
} else {
}
if (ipversion == IPV4_VERSION) {
/*
* IPv6 initializes the ire_nce in ire_add_v6, which expects
* to find the ire_nce to be null when it is called.
*/
/* some failure occurred. propagate error back */
return (B_FALSE);
}
}
return (B_TRUE);
}
/*
* This routine is called repeatedly by ipif_up to create broadcast IREs.
* It is passed a pointer to a slot in an IRE pointer array into which to
* place the pointer to the new IRE, if indeed we create one. If the
* IRE corresponding to the address passed in would be a duplicate of an
* existing one, we don't create the new one. irep is incremented before
* return only if we do create a new IRE. (Always called as writer.)
*
* Note that with the "match_flags" parameter, we can match on either
* a particular logical interface (MATCH_IRE_IPIF) or for all logical
* interfaces for a given physical interface (MATCH_IRE_ILL). Currently,
* we only create broadcast ire's on a per physical interface basis. If
* someone is going to be mucking with logical interfaces, it is important
* to call "ipif_check_bcast_ires()" to make sure that any change to a
* logical interface will not cause critical broadcast IRE's to be deleted.
*/
ire_t **
int match_flags)
{
/*
* No broadcast IREs for the LOOPBACK interface
* or others such as point to point and IPIF_NOXMIT.
*/
return (irep);
/*
* If this new IRE would be a duplicate, only prefer it if one of
* the following is true:
*
* 1. The existing one has IPIF_DEPRECATED|IPIF_LOCAL|IPIF_ANYCAST
* set and the new one has all of those clear.
*
* 2. The existing one corresponds to an underlying ILL in an IPMP
* group and the new one corresponds to an IPMP group interface.
*/
if (!prefer) {
return (irep);
}
/*
* Bcast ires exist in pairs. Both have to be deleted,
* Since we are exclusive we can make the above assertion.
* The 1st has to be refrele'd since it was ctable_lookup'd.
*/
}
}
/*
* This routine is called from ipif_check_bcast_ires and ire_check_bcast.
* It leaves all the verifying and deleting to those routines. So it always
* creates 2 bcast ires and chains them into the ire array passed in.
*/
ire_t **
{
/*
* Broadcast IREs for the IPMP meta-interface use the
* nominated broadcast interface to send and receive packets.
* If there's no nominated interface, send the packets down to
* the IPMP stub driver, which will discard them. If the
* nominated broadcast interface changes, ill_refresh_bcast()
* will refresh the broadcast IREs.
*/
}
*irep++ = ire_create(
NULL, /* no gateway */
NULL, /* no src nce */
ipif,
0,
0,
0,
0,
NULL,
NULL,
ipst);
*irep++ = ire_create(
NULL, /* no gateway */
&ip_loopback_mtu, /* max frag size */
NULL, /* no src_nce */
NULL, /* no send-to queue */
IRE_BROADCAST, /* Needed for fanout in wput */
ipif,
0,
0,
0,
0,
NULL,
NULL,
ipst);
return (irep);
}
/*
* ire_walk routine to delete or update any IRE_CACHE that might contain
* stale information.
* The flags state which entries to delete or update.
* Garbage collection is done separately using kmem alloc callbacks to
* ip_trash_ire_reclaim.
* Used for both IPv4 and IPv6. However, IPv6 only uses FLUSH_MTU_TIME
* since other stale information is cleaned up using NUD.
*/
void
{
if ((flush_flags & FLUSH_REDIRECT_TIME) &&
/* Make sure we delete the corresponding IRE_CACHE */
ip1dbg(("ire_expire: all redirects\n"));
return;
}
return;
if (flush_flags & FLUSH_ARP_TIME) {
/*
* Remove all IRE_CACHE except IPv4 multicast ires. These
* ires will be deleted by ip_trash_ire_reclaim_stack()
* when system runs low in memory.
* Verify that create time is more than ip_ire_arp_interval
* milliseconds ago.
*/
return;
}
}
/* Increase pmtu if it is less than the interface mtu */
/*
* If the ipif is a vni (whose mtu is 0, since it's virtual)
* get the mtu from the sending interfaces' ipif
*/
} else {
}
}
}
/*
* Return any local address. We use this to target ourselves
* when the src address was specified as 'default'.
* Preference for IRE_LOCAL entries.
*/
ire_t *
{
int i;
for (i = 0; i < ipst->ips_ip_cache_table_size; i++) {
continue;
continue;
case IRE_LOOPBACK:
}
break;
case IRE_LOCAL:
}
return (ire);
}
}
}
return (maybe);
}
/*
* If the specified IRE is associated with a particular ILL, return
* that ILL pointer (May be called as writer.).
*
* NOTE : This is not a generic function that can be used always.
* This function always returns the ill of the outgoing packets
* if this ire is used.
*/
ill_t *
{
/*
* 1) For an IRE_CACHE, ire_ipif is the one where it obtained
* the source address from. ire_stq is the one where the
* packets will be sent out on. We return that here.
*
* 2) IRE_BROADCAST normally has a loopback and a non-loopback
* copy and they always exist next to each other with loopback
* copy being the first one. If we are called on the non-loopback
* copy, return the one pointed by ire_stq. If it was called on
* a loopback copy, we still return the one pointed by the next
* ire's ire_stq pointer i.e the one pointed by the non-loopback
* copy. We don't want use ire_ipif as it might represent the
* source address (if we borrow source addresses for
* IRE_BROADCASTS in the future).
* However if an interface is currently coming up, the above
* condition may not hold during that period since the ires
* are added one at a time. Thus one of the pair could have been
* added and the other not yet added.
* 3) For many other IREs (e.g., IRE_LOCAL), ire_rfq indicates the ill.
* 4) For all others return the ones pointed by ire_ipif->ipif_ill.
* That handles IRE_LOOPBACK.
*/
} else {
}
}
}
return (ill);
}
/* Arrange to call the specified function for every IRE in the world. */
void
{
}
void
{
}
void
{
}
/*
* Walk a particular version. version == 0 means both v4 and v6.
*/
static void
{
if (vers != IPV6_VERSION) {
/*
* ip_forwarding_table variable doesn't matter for IPv4 since
* ire_walk_ill_tables uses ips_ip_ftable for IPv4.
*/
0, NULL,
}
if (vers != IPV4_VERSION) {
}
}
/*
* Arrange to call the specified function for every IRE that matches the ill.
*/
void
{
}
void
{
ill);
}
void
{
ill);
}
/*
* Walk a particular ill and version.
*/
static void
{
if (vers == IPV4_VERSION) {
} else if (vers == IPV6_VERSION) {
}
}
{
/*
* MATCH_IRE_ILL: We match both on ill pointed by ire_stq and
* ire_ipif. Only in the case of IRE_CACHEs can ire_stq and
* ire_ipif be pointing to different ills. But we want to keep
* this function generic enough for future use. So, we always
* try to match on both. The only caller of this function
* ire_walk_ill_tables, will call "func" after we return from
* this function. We expect "func" to do the right filtering
* of ires in this case.
*/
if (match_flags & MATCH_IRE_ILL) {
}
/*
* We're walking the IREs for a specific zone. The only relevant
* IREs are:
* - all IREs with a matching ire_zoneid
* - all IRE_OFFSUBNETs as they're shared across all zones
* - IRE_INTERFACE IREs for interfaces with a usable source addr
* with a matching zone
* - IRE_DEFAULTs with a gateway reachable from the zone
* We should really match on IRE_OFFSUBNETs and IRE_DEFAULTs
* using the same rule; but the above rules are consistent with
* the behavior of ire_ftable_lookup[_v6]() so that all the
* routes that can be matched during lookup are also matched
* here.
*/
/*
* Note, IRE_INTERFACE can have the stq as NULL. For
* example, if the default multicast route is tied to
* the loopback address.
*/
if (!ipif_usesrc_avail(ire_stq_ill,
zoneid))
/* No usable src addr in zone */
return (B_FALSE);
} else if (ire_stq_ill->ill_usesrc_ifindex
!= 0) {
/*
* For IPv6 use ipif_select_source_v6()
* so the right scope selection is done
*/
src_ipif =
zoneid);
} else {
return (B_FALSE);
}
} else {
return (B_FALSE);
}
return (B_FALSE);
}
}
/*
* Match all default routes from the global zone, irrespective
* of reachability. For a non-global zone only match those
* where ire_gateway_addr has a IRE_INTERFACE for the zoneid.
*/
int ire_match_flags = 0;
} else {
}
return (B_FALSE);
}
}
}
if (((!(match_flags & MATCH_IRE_TYPE)) ||
((!(match_flags & MATCH_IRE_ILL)) ||
return (B_TRUE);
}
return (B_FALSE);
}
int
{
if ((rtf->rt_match_flags != 0) ||
} else
if (ret)
}
return (0);
}
/*
* Walk the ftable and the ctable entries that match the ill.
*/
void
{
int i, j;
/*
* Optimize by not looking at the forwarding table if there
* is a MATCH_IRE_TYPE specified with no IRE_FORWARDTABLE
* specified in ire_type.
*/
if (!(match_flags & MATCH_IRE_TYPE) ||
((ire_type & IRE_FORWARDTABLE) != 0)) {
/* knobs such that routine is called only for v6 case */
for (i = (ftbl_sz - 1); i >= 0; i--) {
continue;
for (j = 0; j < htbl_sz; j++) {
continue;
if (match_flags == 0 &&
} else {
ret =
}
if (ret)
}
}
}
} else {
if (match_flags != 0) {
}
}
}
/*
* Optimize by not looking at the cache table if there
* is a MATCH_IRE_TYPE specified with no IRE_CACHETABLE
* specified in ire_type.
*/
if (!(match_flags & MATCH_IRE_TYPE) ||
((ire_type & IRE_CACHETABLE) != 0)) {
for (i = 0; i < ctbl_sz; i++) {
continue;
} else {
}
if (ret)
}
}
}
}
/*
* This function takes a mask and returns
* number of bits set in the mask. If no
* bit is set it returns 0.
* Assumes a contiguous mask.
*/
int
{
}
/*
* Convert length for a mask to the mask.
*/
{
}
void
{
}
/*
* ire_add_v[46] atomically make sure that the ipif or ill associated
* with the new ire being added is stable and not IPIF_CHANGING or ILL_CHANGING
* before adding the ire to the table. This ensures that we don't create
* new IRE_CACHEs with stale values for parameters that are passed to
* ire_create such as ire_max_frag. Note that ire_create() is passed a pointer
* to the ipif_mtu, and not the value. The actual value is derived from the
* parent ire or ipif under the bucket lock.
*/
int
{
int error = 0;
GRAB_CONN_LOCK(q);
/*
* While the IRE is in the process of being added, a user may have
* invoked the ifconfig usesrc option on the stq_ill to make it a
* usesrc client ILL. Check for this possibility here, if it is true
* then we fail adding the IRE_CACHE. Another check is to make sure
* that an ipif_ill of an IRE_CACHE being added is not part of a usesrc
* group. The ill_g_usesrc_lock is released in ire_atomic_end
*/
if (stq_ill->ill_usesrc_ifindex != 0) {
(ipif_ill->ill_usesrc_ifindex != 0)) {
goto done;
}
goto done;
}
}
/*
* Don't allow IRE's to be created on changing ill's. Also, since
* IPMP flags can be set on an ill without quiescing it, if we're not
* a writer on stq_ill, check that the flags still allow IRE creation.
*/
} else if (IS_UNDER_IPMP(stq_ill)) {
if (!ipmp_ill_is_active(stq_ill) &&
}
}
if (error != 0)
goto done;
}
goto done;
}
goto done;
}
done:
error = EINPROGRESS;
} else if (error != 0) {
}
return (error);
}
/*
* Add a fully initialized IRE to an appropriate table based on
* ire_type.
*
* allow_unresolved == B_FALSE indicates a legacy code-path call
* that has prohibited the addition of incomplete ire's. If this
* parameter is set, and we find an nce that is in a state other
* than ND_REACHABLE, we fail the add. Note that nce_state could be
* something other than ND_REACHABLE if the nce had just expired and
* the ire_create preceding the ire_add added a new ND_INITIAL nce.
*/
int
{
int error;
/* get ready for the day when original ire is not created as mblk */
/* Copy the ire to a kmem_alloc'ed area */
ip1dbg(("ire_add: alloc failed\n"));
return (ENOMEM);
}
ire1->ire_stq_ifindex = 0;
}
continue;
}
/*
* We need to make sure that the ipif is a valid one
* before adding the IRE_CACHE. This happens only
* with IRE_CACHE when there is an external resolver.
*
* We can unplumb a logical interface while the
* packet is waiting in ARP with the IRE. Then,
* later on when we feed the IRE back, the ipif
* has to be re-checked. This can't happen with
* NDP currently, as we never queue the IRE with
* the packet. We always try to recreate the IRE
* when the resolution is completed. But, we do
* it for IPv6 also here so that in future if
* we have external resolvers, it will work without
* any change.
*/
break;
}
}
&ipif->ipif_v6src_addr)) ||
return (EINVAL);
}
/*
* Since we didn't attach label security attributes to the
* ire for the resolver case, we need to add it now. (only
* for v4 resolver and v6 xresolv case).
*/
if (is_system_labeled() && ire_is_mblk) {
} else {
&ire->ire_gateway_addr_v6) ?
ire->ire_addr_v6 :
}
if (error != 0) {
}
return (error);
}
}
}
/*
* In case ire was changed
*/
else
return (error);
}
/*
* Add an initialized IRE to an appropriate table based on ire_type.
*
* The forward table contains IRE_PREFIX/IRE_HOST and
* IRE_IF_RESOLVER/IRE_IF_NORESOLVER and IRE_DEFAULT.
*
* The cache table contains IRE_BROADCAST/IRE_LOCAL/IRE_LOOPBACK
* and IRE_CACHE.
*
* NOTE : This function is called as writer though not required
* by this function.
*/
static int
{
int flags;
int error;
/*
* IREs with source addresses hosted on interfaces that are under IPMP
* should be hidden so that applications don't accidentally end up
* sending packets with test addresses as their source addresses, or
* sending out interfaces that are e.g. IFF_INACTIVE. Hide them here.
*/
/* Find the appropriate list head. */
case IRE_HOST:
ire->ire_src_addr = 0;
break;
case IRE_CACHE:
break;
case IRE_BROADCAST:
case IRE_LOCAL:
case IRE_LOOPBACK:
break;
case IRE_PREFIX:
case IRE_DEFAULT:
ire->ire_src_addr = 0;
break;
case IRE_IF_RESOLVER:
case IRE_IF_NORESOLVER:
break;
default:
ip0dbg(("ire_add_v4: ire %p has unrecognized IRE type (%d)\n",
return (EINVAL);
}
/* Make sure the address is properly masked. */
/*
* ip_newroute/ip_newroute_multi are unable to prevent the deletion
* of the interface route while adding an IRE_CACHE for an on-link
* destination in the IRE_IF_RESOLVER case, since the ire has to
* go to ARP and return. We can't do a REFHOLD on the
* associated interface ire for fear of ARP freeing the message.
* Here we look up the interface ire in the forwarding table and
* make sure that the interface route has not been deleted.
*/
/*
* The ihandle that we used in ip_newroute_multi
* comes from the interface route corresponding
* to ire_ipif. Lookup here to see if it exists
* still.
* If the ire has a source address assigned using
* RTF_SETSRC, ire_ipif is the logical interface holding
* this source address, so we can't use it to check for
* the existence of the interface route. Instead we rely
* on the brute force ihandle search in
* ire_ihandle_lookup_onlink() below.
*/
return (EINVAL);
return (EINVAL);
}
} else {
return (EINVAL);
}
}
/* Prevent pire from getting deleted */
/* Has it been removed already ? */
return (EINVAL);
}
} else {
}
/*
* We use MATCH_IRE_IPIF while adding IRE_CACHES only
* for historic reasons and to maintain symmetry with
* IPv6 code path. Historically this was used by
* multicast code to create multiple IRE_CACHES on
* a single ill with different ipifs. This was used
* so that multicast packets leaving the node had the
* right source address. This is no longer needed as
* ip_wput initializes the address correctly.
*/
flags |= MATCH_IRE_IPIF;
/*
* If we are creating a hidden IRE, make sure we search for
* hidden IREs when searching for duplicates below.
* Otherwise, we might find an IRE on some other interface
* that's not marked hidden.
*/
}
/*
* This assumes that the ire has not added
* a reference to the ipif.
*/
}
return (EINVAL);
}
} else {
}
/*
* Start the atomic add of the ire. Grab the ill locks,
* ill_g_usesrc_lock and the bucket lock. Check for condemned
*
* If ipif or ill is changing ire_atomic_start() may queue the
* request and return EINPROGRESS.
* To avoid lock order problems, get the ndp4->ndp_g_lock.
*/
if (error != 0) {
/*
* We don't know whether it is a valid ipif or not.
* So, set it to NULL. This assumes that the ire has not added
* a reference to the ipif.
*/
}
if (need_refrele)
return (error);
}
/*
* To avoid creating ires having stale values for the ire_max_frag
* we get the latest value atomically here. For more details
* see the block comment in ip_sioctl_mtu and in DL_NOTE_SDU_CHANGE
* in ip_rput_dlpi_writer
*/
else
} else {
}
/*
* Atomically check for duplicate and insert in the table.
*/
continue;
/*
* We do MATCH_IRE_ILL implicitly here for IREs
* with a non-null ire_ipif, including IRE_CACHEs.
* As ire_ipif and ire_stq could point to two
* different ills, we can't pass just ire_ipif to
* ire_match_args and get a match on both ills.
* This is just needed for duplicate checks here and
* so we don't add an extra argument to
* ire_match_args for this. Do it locally.
*
* NOTE : Currently there is no part of the code
* that asks for both MATH_IRE_IPIF and MATCH_IRE_ILL
* match for IRE_CACHEs. Thus we don't want to
* extend the arguments to ire_match_args.
*/
continue;
/*
* Multiroute IRE_CACHEs for a given destination can
* have the same ire_ipif, typically if their source
* address is forced using RTF_SETSRC, and the same
* send-to queue. We differentiate them using the parent
* handle.
*/
continue;
}
continue;
/*
* Return the old ire after doing a REFHOLD.
* As most of the callers continue to use the IRE
* after adding, we return a held ire. This will
* avoid a lookup in the caller again. If the callers
* don't want to use it, they need to do a REFRELE.
*/
ip1dbg(("found dup ire existing %p new %p\n",
/*
* Assert that it is not removed from the
* list yet.
*/
}
if (need_refrele)
return (0);
}
}
B_TRUE);
/*
* if the nce is NCE_F_CONDEMNED, or if it is not ND_REACHABLE
* and the caller has prohibited the addition of incomplete
* ire's, we fail the add. Note that nce_state could be
* something other than ND_REACHABLE if the nce had
* just expired and the ire_create preceding the
* ire_add added a new ND_INITIAL nce.
*/
(!allow_unresolved &&
}
}
if (need_refrele)
return (EINVAL);
} else {
/*
* We are associating this nce to the ire, so
* change the nce ref taken in ndp_lookup_v4() from
* NCE_REFHOLD to NCE_REFHOLD_NOTR
*/
}
}
/*
* Make it easy for ip_wput_ire() to hit multiple broadcast ires by
* grouping identical addresses together on the hash chain. We do
* this only for IRE_BROADCASTs as ip_wput_ire is currently interested
* in such groupings only for broadcasts.
*
* Find the first entry that matches ire_addr. *irep will be null
* if no match.
*
* Note: the loopback and non-loopback broadcast entries for an
* interface MUST be added before any MULTIRT entries.
*/
/*
* We found some ire (i.e *irep) with a matching addr. We
* want to group ires with same addr.
*/
for (;;) {
break;
}
/*
* The ire will be added before *irep, so
* if irep is a MULTIRT ire, just break to
* ire insertion code.
*/
goto insert_ire;
/*
* Either we have hit the end of the list or the address
* did not match.
*/
break;
break;
}
}
/*
* Find the last ire which matches ire_addr.
* Needed to do tail insertion among entries with the same
* ire_addr.
*/
break;
}
}
/* Insert at *irep */
/* Link the new one in. */
/*
* ire_walk routines de-reference ire_next without holding
* a lock. Before we point to the new ire, we want to make
* sure the store that sets the ire_next of the new ire
* reaches global visibility, so that ire_walk routines
* don't see a truncated list of ires i.e if the ire_next
* of the new ire gets set after we do "*irep = ire" due
* to re-ordering, the ire_walk thread will see a NULL
* once it accesses the ire_next of the new ire.
* membar_producer() makes sure that the following store
* happens *after* all of the above stores.
*/
/*
* We return a bumped up IRE above. Keep it symmetrical
* so that the callers will always have to release. This
* helps the callers of this function because they continue
* to use the IRE after adding and hence they don't have to
* lookup again after we return the IRE.
*
* NOTE : We don't have to use atomics as this is appearing
* in the list for the first time and no one else can bump
* up the reference count on this yet.
*/
irb_ptr->irb_ire_cnt++;
(char *), "ire", (void *), ire);
(char *), "ire", (void *), ire);
stq_ill->ill_ire_cnt++;
}
} else {
}
/* Assert that it is not removed from the list yet */
}
/*
* For ire's with host mask see if there is an entry
* in the cache. If there is one flush the whole cache as
* there might be multiple entries due to RTF_MULTIRT (CGTP).
* If no entry is found than there is no need to flush the
* cache.
*/
}
} else {
}
}
/*
* We had to delay the fast path probe until the ire is inserted
* in the list. Otherwise the fast path ack won't find the ire in
* the table.
*/
}
if (need_refrele) {
}
return (0);
}
/*
* IRB_REFRELE is the only caller of the function. ire_unlink calls to
* do the final cleanup for this ire.
*/
void
{
} else {
}
/*
* Now it's really out of the list. Before doing the
* REFRELE, set ire_next to NULL as ire_inactive asserts
* so.
*/
}
}
/*
* IRB_REFRELE is the only caller of the function. It calls to unlink
* all the CONDEMNED ires from this bucket.
*/
ire_t *
{
(irb->irb_refcnt == 0));
if (ire1)
/*
* IRE is out of the list. We need to adjust
* the accounting before the caller drops
* the lock.
*/
0);
}
}
/*
* We need to call ire_delete_v4 or ire_delete_v6
* to clean up the cache or the redirects pointing at
* the default gateway. We need to drop the lock
* as ire_flush_cache/ire_delete_host_redircts require
* so. But we can't drop the lock, as ire_unlink needs
* to atomically remove the ires from the list.
* So, create a temporary list of CONDEMNED ires
* for doing ire_delete_v4/ire_delete_v6 operations
* later on.
*/
}
}
return (ire_list);
}
/*
* Delete all the cache entries with this 'addr'. When IP gets a gratuitous
* ARP message on any of its interface queue, it scans the nce table and
* deletes and calls ndp_delete() for the appropriate nce. This action
* This function is called from ip_arp_news in ip.c and also for
* ARP ioctl processing in ip_if.c. ip_ire_clookup_and_delete returns
* true if it finds a nce entry which is used by ip_arp_news to determine if
* it needs to do an ire_walk_v4. The return value is also used for the
* same purpose by ARP IOCTL processing * in ip_if.c when deleting
* ARP entries. For SIOC*IFARP ioctls in addition to the address,
* ip_if->ipif_ill also needs to be matched.
*/
{
/*
* clean up the nce (and any relevant ire's) that matches
* on addr and ill.
*/
return (B_TRUE);
}
} else {
/*
* ill is wildcard. clean up all nce's and
* ire's that match on addr
*/
/*
* ncecl_found would be set by ip_nce_clookup_and_delete if
* we found a matching nce.
*/
return (cl.ncecl_found);
}
return (B_FALSE);
}
/* Delete the supplied nce if its nce_addr matches the supplied address */
static void
{
/* clean up the nce (and any relevant ire's) */
}
}
/*
* Clean up the radix node for this ire. Must be called by IRB_REFRELE
* when there are no ire's left in the bucket. Returns TRUE if the bucket
* is deleted and freed.
*/
{
struct radix_node *rn;
/* first remove it from the radix tree. */
/* irb_lock is freed */
return (B_TRUE);
}
return (B_FALSE);
}
/*
* Delete the specified IRE.
*/
void
{
/*
* It was never inserted in the list. Should call REFRELE
* to free this IRE.
*/
return;
}
}
/*
* In case of V4 we might still be waiting for fastpath ack.
*/
}
/*
* Some other thread has removed us from the list.
* It should have done the REFRELE for us.
*/
return;
}
irb->irb_ire_cnt--;
irb->irb_tmp_ire_cnt--;
}
}
if (irb->irb_refcnt != 0) {
/*
* The last thread to leave this bucket will
* delete this ire.
*/
return;
}
/*
* Normally to delete an ire, we walk the bucket. While we
* walk the bucket, we normally bump up irb_refcnt and hence
* we return from above where we mark CONDEMNED and the ire
* gets deleted from ire_unlink. This case is where somebody
* knows the ire e.g by doing a lookup, and wants to delete the
* IRE. irb_refcnt would be 0 in this case if nobody is walking
* the bucket.
*/
} else {
}
/*
* ip_wput/ip_wput_v6 checks this flag to see whether
* it should still use the cached ire or not.
*/
/*
* IRE is out of the list. We need to adjust the
* accounting before we drop the lock.
*/
}
}
} else {
}
/*
* We removed it from the list. Decrement the
* reference count.
*/
}
/*
* Delete the specified IRE.
* All calls should use ire_delete().
* Sometimes called as writer though not required by this function.
*
* NOTE : This function is called only if the ire was added
* in the list.
*/
static void
{
/*
* when a default gateway is going away
* delete all the host redirects pointing at that
* gateway.
*/
}
}
/*
* IRE_REFRELE/ire_refrele are the only caller of the function. It calls
* to free the ire when the reference count goes to zero.
*/
void
{
}
return;
}
}
goto end;
/* The ire was never inserted in the table. */
goto end;
}
/*
* ipif_ire_cnt on this ipif goes down by 1. If the ire_stq is
* non-null ill_ire_count also goes down by 1.
*
* The ipif that is associated with an ire is ire->ire_ipif and
* hence when the ire->ire_ipif->ipif_ire_cnt drops to zero we call
* ipif_ill_refrele_tail. Usually stq_ill is null or the same as
* ire->ire_ipif->ipif_ill. So nothing more needs to be done.
* However, for VNI or IPMP IRE entries, stq_ill can be different.
* If this is different from ire->ire_ipif->ipif_ill and if the
* ill_ire_cnt on the stq_ill also has dropped to zero, we call
* ipif_ill_refrele_tail on the stq_ill.
*/
/* Optimize the most common case */
(char *), "ire", (void *), ire);
ipif->ipif_ire_cnt--;
if (IPIF_DOWN_OK(ipif))
(char *), "ire", (void *), ire);
stq_ill->ill_ire_cnt--;
if (ILL_DOWN_OK(stq_ill))
}
if (need_wakeup) {
/* Drops the ill lock */
} else {
}
} else {
/*
* We can't grab all the ill locks at the same time.
* It can lead to recursive lock enter in the call to
* ipif_ill_refrele_tail and later. Instead do it 1 at
* a time.
*/
(char *), "ire", (void *), ire);
ipif->ipif_ire_cnt--;
if (IPIF_DOWN_OK(ipif)) {
/* Drops the lock */
} else {
}
(char *), "ire", (void *), ire);
stq_ill->ill_ire_cnt--;
if (ILL_DOWN_OK(stq_ill)) {
/* Drops the ill lock */
} else {
}
}
}
end:
/* This should be true for both V4 and V6 */
/*
* Instead of examining the conditions for freeing
* the radix node here, we do it by calling
* IRB_REFRELE which is a single point in the code
* that embeds that logic. Bump up the refcnt to
* be able to call IRB_REFRELE
*/
}
#ifdef DEBUG
#endif
} else {
}
/* Has been allocated out of the cache */
}
/*
* entries that have a given gateway address.
*/
void
{
return;
ip1dbg(("ire_delete_cache_gw: deleted 0x%x type %d to 0x%x\n",
}
}
/*
* Remove all IRE_CACHE entries that match the ire specified.
*
* The flag argument indicates if the flush request is due to addition
* of new route (IRE_FLUSH_ADD) or deletion of old route (IRE_FLUSH_DELETE).
*
* This routine takes only the IREs from the forwarding table and flushes
* the corresponding entries from the cache table.
*
* When flushing due to the deletion of an old route, it
* just checks the cache handles (ire_phandle and ire_ihandle) and
* deletes the ones that match.
*
* When flushing due to the creation of a new route, it checks
* if a cache entry's address matches the one in the IRE and
* that the cache entry's parent has a less specific mask than the
* one in IRE. The destination of such a cache entry could be the
* gateway for other cache entries, so we need to flush those as
* well by looking for gateway addresses matching the IRE's address.
*/
void
{
int i;
return;
/*
* If a default is just created, there is no point
* in going through the cache, as there will not be any
* cached ires.
*/
return;
if (flag == IRE_FLUSH_ADD) {
/*
* This selective flush is due to the addition of
* new IRE.
*/
for (i = 0; i < ipst->ips_ip_cache_table_size; i++) {
continue;
continue;
/*
* If 'cire' belongs to the same subnet
* as the new ire being added, and 'cire'
* is derived from a prefix that is less
* specific than the new ire being added,
* we need to flush 'cire'; for instance,
* when a new interface comes up.
*/
ire->ire_masklen)) {
continue;
}
/*
* This is the case when the ire_gateway_addr
* of 'cire' belongs to the same subnet as
* the new ire being added.
* Flushing such ires is sometimes required to
* avoid misrouting: say we have a machine with
* two interfaces (I1 and I2), a default router
* R on the I1 subnet, and a host route to an
* off-link destination D with a gateway G on
* the I2 subnet.
* Under normal operation, we will have an
* on-link cache entry for G and an off-link
* cache entry for D with G as ire_gateway_addr,
* traffic to D will reach its destination
* through gateway G.
* If the administrator does 'ifconfig I2 down',
* the cache entries for D and G will be
* flushed. However, G will now be resolved as
* an off-link destination using R (the default
* router) as gateway. Then D will also be
* resolved as an off-link destination using G
* as gateway - this behavior is due to
* compatibility reasons, see comment in
* ire_ihandle_lookup_offlink(). Traffic to D
* will go to the router R and probably won't
* reach the destination.
* The administrator then does 'ifconfig I2 up'.
* Since G is on the I2 subnet, this routine
* will flush its cache entry. It must also
* flush the cache entry for D, otherwise
* traffic will stay misrouted until the IRE
* times out.
*/
continue;
}
}
}
} else {
/*
* delete the cache entries based on
* handle in the IRE as this IRE is
*/
for (i = 0; i < ipst->ips_ip_cache_table_size; i++) {
continue;
continue;
if ((cire->ire_phandle == 0 ||
(cire->ire_ihandle == 0 ||
continue;
}
}
}
}
/*
* Matches the arguments passed with the values in the ire.
*
* Note: for match types that match using "ipif" passed in, ipif
* must be checked for non-NULL before calling this routine.
*/
{
/*
* If MATCH_IRE_MARK_TESTHIDDEN is set, then only return the IRE if it
* is in fact hidden, to ensure the caller gets the right one. One
* exception: if the caller passed MATCH_IRE_IHANDLE, then they
* already know the identity of the given IRE_INTERFACE entry and
* there's no point trying to hide it from them.
*/
if (match_flags & MATCH_IRE_IHANDLE)
if (!(match_flags & MATCH_IRE_MARK_TESTHIDDEN))
return (B_FALSE);
}
/*
* MATCH_IRE_MARK_PRIVATE_ADDR is set when IP_NEXTHOP option
* is used. In that case the routing table is bypassed and the
* packets are sent directly to the specified nexthop. The
* IRE_CACHE entry representing this route should be marked
* with IRE_MARK_PRIVATE_ADDR.
*/
if (!(match_flags & MATCH_IRE_MARK_PRIVATE_ADDR) &&
return (B_FALSE);
/*
* If MATCH_IRE_ZONEONLY has been set and the supplied zoneid is
* valid and does not match that of ire_zoneid, a failure to
* match is reported at this point. Otherwise, since some IREs
* that are available in the global zone can be used in local
* zones, additional checks need to be performed:
*
* IRE_BROADCAST, IRE_CACHE and IRE_LOOPBACK
* entries should never be matched in this situation.
*
* IRE entries that have an interface associated with them
* should in general not match unless they are an IRE_LOCAL
* or in the case when MATCH_IRE_DEFAULT has been set in
* the caller. In the case of the former, checking of the
* other fields supplied should take place.
*
* In the case where MATCH_IRE_DEFAULT has been set,
* all of the ipif's associated with the IRE's ill are
* checked to see if there is a matching zoneid. If any
* one ipif has a matching zoneid, this IRE is a
* potential candidate so checking of the other fields
* takes place.
*
* In the case where the IRE_INTERFACE has a usable source
* address (indicated by ill_usesrc_ifindex) in the
* correct zone then it's permitted to return this IRE
*/
if (match_flags & MATCH_IRE_ZONEONLY)
return (B_FALSE);
return (B_FALSE);
/*
* Note, IRE_INTERFACE can have the stq as NULL. For
* example, if the default multicast route is tied to
* the loopback address.
*/
/*
* If there is a usable source address in the
* zone, then it's ok to return an
* IRE_INTERFACE
*/
ip3dbg(("ire_match_args: dst_ill %p match %d\n",
(void *)dst_ill,
} else {
ip3dbg(("ire_match_args: src_ipif NULL"
" dst_ill %p\n", (void *)dst_ill));
return (B_FALSE);
}
}
if ((match_flags & MATCH_IRE_DEFAULT) == 0) {
return (B_FALSE);
}
if (IPIF_CAN_LOOKUP(tipif) &&
break;
}
return (B_FALSE);
}
}
}
/*
* For IRE_CACHE entries, MATCH_IRE_ILL means that somebody wants to
* send out ire_stq (ire_ipif for IRE_CACHE entries is just the means
* of getting a source address -- i.e., ire_src_addr ==
* ire->ire_ipif->ipif_src_addr). ire_to_ill() handles this.
*
* NOTE: For IPMP, MATCH_IRE_ILL usually matches any ill in the group.
* However, if MATCH_IRE_MARK_TESTHIDDEN is set (i.e., the IRE is for
* IPMP test traffic), then the ill must match exactly.
*/
if (match_flags & MATCH_IRE_ILL) {
}
((!(match_flags & MATCH_IRE_GW)) ||
((!(match_flags & MATCH_IRE_TYPE)) ||
((!(match_flags & MATCH_IRE_SRC)) ||
((!(match_flags & MATCH_IRE_IPIF)) ||
((!(match_flags & MATCH_IRE_MARK_TESTHIDDEN)) ||
((!(match_flags & MATCH_IRE_MARK_PRIVATE_ADDR)) ||
((!(match_flags & MATCH_IRE_WQ)) ||
((!(match_flags & MATCH_IRE_ILL)) ||
(!(match_flags & MATCH_IRE_MARK_TESTHIDDEN) &&
((!(match_flags & MATCH_IRE_IHANDLE)) ||
((!(match_flags & MATCH_IRE_MASK)) ||
((!(match_flags & MATCH_IRE_SECATTR)) ||
(!is_system_labeled()) ||
/* We found the matched IRE */
return (B_TRUE);
}
return (B_FALSE);
}
/*
* Lookup for a route in all the tables
*/
ire_t *
{
/*
* ire_match_args() will dereference ipif MATCH_IRE_SRC or
* MATCH_IRE_ILL is set.
*/
return (NULL);
/*
* might be asking for a cache lookup,
* This is not best way to lookup cache,
* user should call ire_cache_lookup directly.
*
* If MATCH_IRE_TYPE was set, first lookup in the cache table and then
* in the forwarding table, if the applicable type flags were set.
*/
return (ire);
}
}
return (ire);
}
/*
* Delete the IRE cache for the gateway and all IRE caches whose
* ire_gateway_addr points to this gateway, and allow them to
* be created on demand by ip_newroute.
*/
void
{
continue;
}
}
}
/*
* Looks up cache table for a route.
* specific lookup can be indicated by
* passing the MATCH_* flags and the
* necessary parameters.
*/
ire_t *
{
return (ip4_ctable_lookup_impl(&margs));
}
/*
* Check whether the IRE_LOCAL and the IRE potentially used to transmit
* (could be an IRE_CACHE, IRE_BROADCAST, or IRE_INTERFACE) are identical
* or part of the same illgrp. (In the IPMP case, usually the two IREs
* will both belong to the IPMP ill, but exceptions are possible -- e.g.
* if IPMP test addresses are on their own subnet.)
*/
{
}
/*
* Check if the IRE_LOCAL uses the same ill as another route would use.
* If there is no alternate route, or the alternate is a REJECT or BLACKHOLE,
* then we don't allow this IRE_LOCAL to be used.
*/
{
int flags;
} else {
}
return (B_FALSE);
return (B_FALSE);
}
return (rval);
}
/*
* Lookup cache
*
* In general the zoneid has to match (where ALL_ZONES match all of them).
* But for IRE_LOCAL we also need to handle the case where L2 should
* conceptually loop back the packet. This is necessary since neither
* Ethernet drivers nor Ethernet hardware loops back packets sent to their
* own MAC address. This loopback is needed when the normal
* routes (ignoring IREs with different zoneids) would send out the packet on
* the same ill as the ill with which this IRE_LOCAL is associated.
*
* Earlier versions of this code always matched an IRE_LOCAL independently of
* the zoneid. We preserve that earlier behavior when
* ip_restrict_interzone_loopback is turned off.
*/
ire_t *
{
continue;
}
/*
* Finally, check if the security policy has any
* restriction on using this route for the specified
* message.
*/
continue;
}
return (ire);
}
continue;
return (ire);
}
}
}
return (NULL);
}
ire_t *
{
/*
* Look for an ire in the cachetable whose
* ire_addr matches the destination.
* Since we are being called by forwarding fastpath
* no need to check for Trusted Solaris label.
*/
continue;
}
return (ire);
}
}
return (NULL);
}
/*
* Locate the interface ire that is tied to the cache ire 'cire' via
* cire->ire_ihandle.
*
* We are trying to create the cache ire for an offlink destn based
* on the cache ire of the gateway in 'cire'. 'pire' is the prefix ire
* as found by ip_newroute(). We are called from ip_newroute() in
* the IRE_CACHE case.
*/
ire_t *
{
int match_flags;
/*
* We don't need to specify the zoneid to ire_ftable_lookup() below
* because the ihandle refers to an ipif which can be in only one zone.
*/
/*
* We know that the mask of the interface ire equals cire->ire_cmask.
* (When ip_newroute() created 'cire' for the gateway it set its
* cmask from the interface ire's mask)
*/
return (ire);
/*
* If we didn't find an interface ire above, we can't declare failure.
* For backwards compatibility, we need to support prefix routes
* pointing to next hop gateways that are not on-link.
*
* Assume we are trying to ping some offlink destn, and we have the
* routing table below.
*
* Eg. default - gw1 <--- pire (line 1)
* gw1 - gw2 (line 2)
* gw2 - hme0 (line 3)
*
* If we already have a cache ire for gw1 in 'cire', the
* ire_ftable_lookup above would have failed, since there is no
* interface ire to reach gw1. We will fallthru below.
*
* Here we duplicate the steps that ire_ftable_lookup() did in
* getting 'cire' from 'pire', in the MATCH_IRE_RECURSIVE case.
* The differences are the following
* i. We want the interface ire only, so we call ire_ftable_lookup()
* instead of ire_route_lookup()
* ii. We look for only prefix routes in the 1st call below.
* ii. We want to match on the ihandle in the 2nd call below.
*/
return (NULL);
/*
* At this point 'ire' corresponds to the entry shown in line 2.
* gw_addr is 'gw2' in the example above.
*/
ipst);
return (ire);
}
/*
* Return the IRE_LOOPBACK, IRE_IF_RESOLVER or IRE_IF_NORESOLVER
* ire associated with the specified ipif.
*
* This might occasionally be called when IPIF_UP is not set since
* the IP_MULTICAST_IF as well as creating interface routes
* allows specifying a down ipif (ipif_lookup* match ipifs that are down).
*
* Note that if IPIF_NOLOCAL, IPIF_NOXMIT, or IPIF_DEPRECATED is set on
* the ipif, this routine might return NULL.
*/
ire_t *
{
/*
* IRE_INTERFACE entries for ills under IPMP are IRE_MARK_TESTHIDDEN
* so that they aren't accidentally returned. However, if the
* caller's ipif is on an ill under IPMP, there's no need to hide 'em.
*/
ipst);
/* In this case we need to lookup destination address. */
ipst);
} else {
}
return (ire);
}
/*
* ire_walk function.
* Count the number of IRE_CACHE entries in different categories.
*/
void
{
return;
icc->icc_onlink++;
return;
}
} else {
if (ire->ire_gateway_addr == 0) {
icc->icc_onlink++;
return;
}
}
icc->icc_offlink++;
else
icc->icc_unused++;
}
/*
* ire_walk function called by ip_trash_ire_reclaim().
* Free a fraction of the IRE_CACHE cache entries. The fractions are
* different for different categories of IRE_CACHE entries.
* A fraction of zero means to not free any in that category.
* Use the hash bucket id plus lbolt as a random number. Thus if the fraction
* is N then every Nth hash bucket chain will be freed.
*/
void
{
return;
if (icr->icr_onlink != 0 &&
return;
}
goto done;
}
} else {
if (ire->ire_gateway_addr == 0) {
if (icr->icr_onlink != 0 &&
return;
}
goto done;
}
}
/* Not onlink IRE */
/* Use ptmu fraction */
return;
}
ire->ire_ib_pkt_count) {
/* Use offlink fraction */
if (icr->icr_offlink != 0 &&
return;
}
} else {
/* Use unused fraction */
if (icr->icr_unused != 0 &&
return;
}
}
done:
/*
* Update tire_mark so that those that haven't been used since this
* reclaim will be considered unused next time we reclaim.
*/
}
static void
{
int i;
for (i = 1; i < 31; i++) {
if (*value <= (1 << i))
break;
}
*value = (1 << i);
}
/* Global init for all zones */
void
{
/*
* Create ire caches, ire_reclaim()
* will give IRE_CACHE back to system when needed.
* This needs to be done here before anything else, since
* ire_add() expects the cache to be created.
*/
sizeof (ire_t), 0, ip_ire_constructor,
/*
* Have radix code setup kmem caches etc.
*/
rn_init();
}
void
{
int i;
/*
* ip_ire_max_bucket_cnt is sized below based on the memory
* size and the cpu speed of the machine. This is upper
* bounded by the compile time value of ip_ire_max_bucket_cnt
* and is lower bounded by the compile time value of
* ip_ire_min_bucket_cnt. Similar logic applies to
* ip6_ire_max_bucket_cnt.
*
* We calculate this for each IP Instances in order to use
* the kmem_avail and ip_ire_{min,max}_bucket_cnt that are
* in effect when the zone is booted.
*/
mem_avail = kmem_avail();
ip_cache_table_size / sizeof (ire_t);
if (min_cnt < ip_ire_min_bucket_cnt)
if (ip_ire_max_bucket_cnt > min_cnt) {
}
ip6_cache_table_size / sizeof (ire_t);
if (min_cnt < ip6_ire_min_bucket_cnt)
if (ip6_ire_max_bucket_cnt > min_cnt) {
}
/* Calculate the IPv4 cache table size. */
/*
* Make sure that the table size is always a power of 2. The
* hash macro IRE_ADDR_HASH() depends on that.
*/
for (i = 0; i < ipst->ips_ip_cache_table_size; i++) {
RW_DEFAULT, NULL);
}
/* Calculate the IPv6 cache table size. */
/*
* Make sure that the table size is always a power of 2. The
* hash macro IRE_ADDR_HASH_V6() depends on that.
*/
for (i = 0; i < ipst->ips_ip6_cache_table_size; i++) {
RW_DEFAULT, NULL);
}
/*
* Make sure that the forwarding table size is a power of 2.
* The IRE*_ADDR_HASH() macroes depend on that.
*/
}
void
ip_ire_g_fini(void)
{
rn_fini();
}
void
{
int i;
/*
* been removed so what remains are just the ftable and IRE_CACHE.
*/
for (i = 0; i < ipst->ips_ip_cache_table_size; i++) {
}
for (i = 0; i < ipst->ips_ip6_cache_table_size; i++) {
}
for (i = 0; i < IP6_MASK_TABLE_SIZE; i++) {
int j;
continue;
for (j = 0; j < ipst->ips_ip6_ftable_hash_size; j++) {
}
}
}
/*
* Check if another multirt route resolution is needed.
* B_TRUE is returned is there remain a resolvable route,
* or if no route for that dst is resolved yet.
* B_FALSE is returned if all routes for that dst are resolved
* or if the remaining unresolved routes are actually not
* resolvable.
* This only works in the global zone.
*/
{
int unres_cnt = 0;
/* Retrieve the first IRE_HOST that matches the destination */
/* No route at all */
if (first_fire == NULL) {
return (B_TRUE);
}
/* Retrieve the first IRE_CACHE ire for that destination. */
/* No resolved route. */
if (first_cire == NULL) {
return (B_TRUE);
}
/*
* At least one route is resolved. Here we look through the forward
* and cache tables, to compare the number of declared routes
* with the number of resolved routes. The search for a resolvable
* route is performed only if at least one route remains
* unresolved.
*/
/* Count the number of routes to that dest that are declared. */
continue;
continue;
unres_cnt++;
}
/* Then subtract the number of routes to that dst that are resolved */
continue;
continue;
continue;
unres_cnt--;
}
/* At least one route is unresolved; search for a resolvable route. */
if (unres_cnt > 0)
if (first_fire != NULL)
if (first_cire != NULL)
return (resolvable);
}
/*
* Explore a forward_table bucket, starting from fire_arg.
* fire_arg MUST be an IRE_HOST entry.
*
* Return B_TRUE and update *ire_arg and *fire_arg
* if at least one resolvable route is found. *ire_arg
* is the IRE entry for *fire_arg's gateway.
*
* Return B_FALSE otherwise (all routes are resolved or
* the remaining unresolved routes are all unresolvable).
*
* The IRE selection relies on a priority mechanism
* driven by the flags passed in by the caller.
* The caller, such as ip_newroute_ipif(), can get the most
* relevant ire at each stage of a multiple route resolution.
*
* The rules are:
*
* - if MULTIRT_CACHEGW is specified in flags, IRE_CACHETABLE
* ires are preferred for the gateway. This gives the highest
* priority to routes that can be resolved without using
* a resolver.
*
* - if MULTIRT_CACHEGW is not specified, or if MULTIRT_CACHEGW
* is specified but no IRE_CACHETABLE ire entry for the gateway
* is found, the following rules apply.
*
* - if MULTIRT_USESTAMP is specified in flags, IRE_INTERFACE
* ires for the gateway, that have not been tried since
* a configurable amount of time, are preferred.
* This applies when a resolver must be invoked for
* a missing route, but we don't want to use the resolver
* upon each packet emission. If no such resolver is found,
* B_FALSE is returned.
* The MULTIRT_USESTAMP flag can be combined with
* MULTIRT_CACHEGW.
*
* - if MULTIRT_USESTAMP is not specified in flags, the first
* unresolved but resolvable route is selected.
*
* - Otherwise, there is no resolvable route, and
* B_FALSE is returned.
*
* At last, MULTIRT_SETSTAMP can be specified in flags to
* request the timestamp of unresolvable routes to
* be refreshed. This prevents the useless exploration
* of those routes for a while, when MULTIRT_USESTAMP is used.
*
* The argument already_resolved_count is an output variable to track number
* of already resolved multirt routes.
*
* This only works in the global zone.
*/
{
ip2dbg(("ire_multirt_lookup: *ire_arg %p, *fire_arg %p, flags %04x\n",
/* Not an IRE_HOST ire; give up. */
return (B_FALSE);
}
/* This is the first IRE_HOST ire for that destination. */
first_fire = *fire_arg;
/*
* Retrieve the first IRE_CACHE ire for that destination;
* if we don't find one, no route for that dest is
* resolved yet.
*/
if (first_cire != NULL) {
}
/*
* Search for a resolvable route, giving the top priority
* to routes that can be resolved without any call to the resolver.
*/
/*
* For all multiroute IRE_HOST ires for that destination,
* check if the route via the IRE_HOST's gateway is
* resolved yet.
*/
continue;
continue;
continue;
}
ip2dbg(("ire_multirt_lookup: fire %p, "
"ire_addr %08x, ire_gateway_addr %08x\n",
if (first_cire != NULL) {
/*
* For all IRE_CACHE ires for that
* destination.
*/
for (cire = first_cire;
continue;
continue;
continue;
tsl) != 0) {
continue;
}
/*
* Check if the IRE_CACHE's gateway
* matches the IRE_HOST's gateway.
*/
break;
}
}
}
/*
* This route is already resolved;
* proceed with next one.
*/
if (already_resolved) {
ip2dbg(("ire_multirt_lookup: found cire %p, "
"already resolved\n", (void *)cire));
if (already_resolved_count != NULL)
(*already_resolved_count)++;
continue;
}
/*
* The route is unresolved; is it actually
* resolvable, i.e. is there a cache or a resolver
* for the gateway?
*/
ip2dbg(("ire_multirt_lookup: looked up gw_ire %p\n",
(void *)gw_ire));
/*
* If gw_ire is typed IRE_CACHETABLE,
* this route can be resolved without any call to the
* resolver. If the MULTIRT_CACHEGW flag is set,
* give the top priority to this ire and exit the
* loop.
* This is typically the case when an ARP reply
* is processed through ip_wput_nondata().
*/
if ((flags & MULTIRT_CACHEGW) &&
/*
* Release the resolver associated to the
* previous candidate best ire, if any.
*/
}
ip2dbg(("ire_multirt_lookup: found top prio "
"best_fire %p, best_cire %p\n",
break;
}
/*
* Compute the time elapsed since our preceding
* attempt to resolve that route.
* If the MULTIRT_USESTAMP flag is set, we take that
* route into account only if this time interval
* exceeds ip_multirt_resolution_interval;
* this prevents us from attempting to resolve a
* broken route upon each sending of a packet.
*/
(!(flags & MULTIRT_USESTAMP)));
ip2dbg(("ire_multirt_lookup: fire %p, delta %lu, "
"res %d\n",
if (res) {
/*
* We are here if MULTIRT_USESTAMP flag is set
* and the resolver for fire's gateway
* has not been tried since
* ip_multirt_resolution_interval, or if
* MULTIRT_USESTAMP is not set but gw_ire did
* not fill the conditions for MULTIRT_CACHEGW,
* or if neither MULTIRT_USESTAMP nor
* MULTIRT_CACHEGW are set.
*/
ip2dbg(("ire_multirt_lookup:"
"found candidate "
"best_fire %p, "
"best_cire %p\n",
(void *)best_fire,
(void *)best_cire));
/*
* If MULTIRT_CACHEGW is not
* set, we ignore the top
* priority ires that can
* be resolved without any
* call to the resolver;
* In that case, there is
* actually no need
* to continue the loop.
*/
if (!(flags &
MULTIRT_CACHEGW)) {
break;
}
continue;
}
} else {
/*
* No resolver for the gateway: the
* route is not resolvable.
* If the MULTIRT_SETSTAMP flag is
* set, we stamp the IRE_HOST ire,
* so we will not select it again
* during this resolution interval.
*/
if (flags & MULTIRT_SETSTAMP)
}
}
}
} else { /* CLASSD(dst) */
for (fire = first_fire;
continue;
continue;
continue;
}
/* No resolver for the gateway; we skip this ire. */
continue;
}
if (first_cire != NULL) {
/*
* For all IRE_CACHE ires for that
* destination.
*/
for (cire = first_cire;
continue;
continue;
continue;
tsl) != 0) {
continue;
}
/*
* Cache entries are linked to the
* parent routes using the parent handle
* (ire_phandle). If no cache entry has
* the same handle as fire, fire is
* still unresolved.
*/
if (cire->ire_phandle ==
fire->ire_phandle) {
break;
}
}
}
/*
* This route is already resolved; proceed with
* next one.
*/
if (already_resolved) {
if (already_resolved_count != NULL)
(*already_resolved_count)++;
continue;
}
/*
* Compute the time elapsed since our preceding
* attempt to resolve that route.
* If the MULTIRT_USESTAMP flag is set, we take
* that route into account only if this time
* interval exceeds ip_multirt_resolution_interval;
* this prevents us from attempting to resolve a
* broken route upon each sending of a packet.
*/
(!(flags & MULTIRT_USESTAMP)));
ip3dbg(("ire_multirt_lookup: fire %p, delta %lx, "
"flags %04x, res %d\n",
if (res) {
/*
* Release the resolver associated
* to the preceding candidate best
* ire, if any.
*/
}
continue;
}
}
}
}
/* Release the first IRE_CACHE we initially looked up, if any. */
if (first_cire != NULL)
/* Found a resolvable route. */
/*
* Update the passed-in arguments with the
* resolvable multirt route we found.
*/
ip2dbg(("ire_multirt_lookup: returning B_TRUE, "
"*fire_arg %p, *ire_arg %p\n",
return (B_TRUE);
}
ip2dbg(("ire_multirt_lookup: returning B_FALSE, *fire_arg %p, "
"*ire_arg %p\n",
/* No resolvable route. */
return (B_FALSE);
}
/*
* IRE iterator for inbound and loopback broadcast processing.
* Given an IRE_BROADCAST ire, walk the ires with the same destination
* address, but skip over the passed-in ire. Returns the next ire without
* a hold - assumes that the caller holds a reference on the IRE bucket.
*/
ire_t *
{
break;
}
} else {
}
/*
* All the IREs to a given destination are contiguous;
* break out once the address doesn't match.
*/
break;
}
/* skip over the passed-in ire */
continue;
}
/*
* If the passed-in ire is loopback, skip over
* non-loopback ires and vice versa.
*/
continue;
}
/* skip over IREs going through a different interface */
continue;
}
/* skip over deleted IREs */
continue;
}
return (curr);
}
return (NULL);
}
#ifdef DEBUG
void
{
if (ire->ire_trace_disable) {
return;
}
} else {
}
}
void
{
if (!ire->ire_trace_disable)
}
static void
{
}
#endif /* DEBUG */
/*
* Generate a message chain with an arp request to resolve the in_ire.
* It is assumed that in_ire itself is currently in the ire cache table,
* so we create a fake_ire filled with enough information about ire_addr etc.
* to retrieve in_ire when the DL_UNITDATA response from the resolver
* comes back. The fake_ire itself is created by calling esballoc with
* the fr_rtnp (free routine) set to ire_freemblk. This routine will be
* invoked when the mblk containing fake_ire is freed.
*/
void
{
/*
* Construct message chain for the resolver
* of the form:
* ARP_REQ_MBLK-->IRE_MBLK
*
* NOTE : If the response does not
* come back, ARP frees the packet. For this reason,
* we can't REFHOLD the bucket of save_ire to prevent
* deletions. We may not be able to REFRELE the bucket
* if the response never comes back. Thus, before
* adding the ire, ire_add_v4 will make sure that the
* interface route does not get deleted. This is the
* only case unlike ip_newroute_v6, ip_newroute_ipif_v6
* where we can always prevent deletions because of
* the synchronous nature of adding IRES i.e
* ire_add_then_send is called after creating the IRE.
*/
/*
* We use esballoc to allocate the second part (IRE_MBLK)
* of the message chain depicted above. This mblk will be freed
* by arp when there is a timeout, and otherwise passed to IP
* and IP will free it after processing the ARP response.
*/
ip1dbg(("ire_arpresolve: alloc buffer failed\n"));
return;
}
ip1dbg(("ire_arpresolve: esballoc failed\n"));
return;
}
return;
}
/*
* keep enough info in the fake ire so that we can pull up
* the incomplete ire (in_ire) after result comes back from
* arp and make it complete.
*/
/*
* ire_freemblk will be called when ire_mp is freed, both for
* successful and failed arp resolution. IRE_MARK_UNCACHED will be set
* when the arp resolution failed.
*/
/*
* Fill in the source and dest addrs for the resolver.
* NOTE: this depends on memory layouts imposed by
* ill_init().
*/
} else {
}
/* Up to the resolver. */
} else {
}
}
/*
* Esballoc free function for AR_ENTRY_QUERY request to clean up any
*
* This function can be called by ARP via free routine for ire_mp or
* by IPv4(both host and forwarding path) via ire_delete
* in case ARP resolution fails.
* NOTE: Since IP is MT, ARP can call into IP but not vice versa
* (for IP to talk to ARP, it still has to send AR* messages).
*
*/
void
{
ip1dbg(("ire_freemblk(0x%p) ire_addr is NULL\n",
(void *)ire_mp));
goto cleanup;
}
goto cleanup; /* everything succeeded. just free and return */
}
/*
* the arp information corresponding to this ire_mp was not
* transferred to an ire_cache entry. Need
* to clean up incomplete ire's and nce, if necessary.
*/
goto cleanup;
/*
* Get any nce's corresponding to this ire_mp. We first have to
* make sure that the ill is still around.
*/
/*
* ill went away. no nce to clean up.
* Note that the ill_state_flags could be set to
* ILL_CONDEMNED after this point, but if we know
* that it is CONDEMNED now, we just bail out quickly.
*/
goto cleanup;
}
B_FALSE);
/*
* some incomplete nce was found.
*/
/*
* Send the icmp_unreachable messages for the queued mblks in
* ire->ire_nce->nce_qd_mp, since ARP resolution failed
* for this ire
*/
/*
* Delete the nce and clean up all ire's pointing at this nce
* in the cachetable
*/
}
/*
* Get rid of the ire buffer
* We call kmem_free here(instead of ire_delete()), since
* this is the freeb's callback.
*/
}
/*
* find, or create if needed, a neighbor cache entry nce_t for IRE_CACHE and
* non-loopback IRE_BROADCAST ire's.
*
* If a neighbor-cache entry has to be created (i.e., one does not already
* exist in the nce list) the nce_res_mp and nce_state of the neighbor cache
* entry are initialized in ndp_add_v4(). These values are picked from
* the src_nce, if one is passed in. Otherwise (if src_nce == NULL) the
* ire->ire_type and the outgoing interface (ire_to_ill(ire)) values
* determine the {nce_state, nce_res_mp} of the nce_t created. All
* IRE_BROADCAST entries have nce_state = ND_REACHABLE, and the nce_res_mp
* is set to the ill_bcast_mp of the outgoing inerface. For unicast ire
* entries,
* - if the outgoing interface is of type IRE_IF_RESOLVER, a newly created
* nce_t will have a null nce_res_mp, and will be in the ND_INITIAL state.
* - if the outgoing interface is a IRE_IF_NORESOLVER interface, no link
* layer resolution is necessary, so that the nce_t will be in the
* ND_REACHABLE state and the nce_res_mp will have a copy of the
* ill_resolver_mp of the outgoing interface.
*
* The link layer information needed for broadcast addresses, and for
* packets sent on IRE_IF_NORESOLVER interfaces is a constant mapping that
* never needs re-verification for the lifetime of the nce_t. These are
* therefore marked NCE_F_PERMANENT, and never allowed to expire via
* NCE_EXPIRED.
*
* IRE_CACHE ire's contain the information for the nexthop (ire_gateway_addr)
* in the case of indirect routes, and for the dst itself (ire_addr) in the
* case of direct routes, with the nce_res_mp containing a template
* DL_UNITDATA request.
*
* The actual association of the ire_nce to the nce created here is
* typically done in ire_add_v4 for IRE_CACHE entries. Exceptions
* to this rule are SO_DONTROUTE ire's (IRE_MARK_NO_ADD), for which
* the ire_nce assignment is done in ire_add_then_send.
*/
int
{
int err;
case IRE_CACHE:
else
break;
case IRE_BROADCAST:
break;
default:
return (0);
}
/*
* ire_ipif is picked based on RTF_SETSRC, usesrc etc.
* rules in ire_forward_src_ipif. We want the dlureq_mp
* for the outgoing interface, which we get from the ire_stq.
*/
/*
* IRE_IF_NORESOLVER entries never need re-verification and
* do not expire, so we mark them as NCE_F_PERMANENT.
*/
/*
* We looked up an expired nce.
* Go back and try to create one again.
*/
goto retry_nce;
}
ip1dbg(("ire 0x%p addr 0x%lx type 0x%x; found nce 0x%p err %d\n",
switch (err) {
case 0:
case EEXIST:
/*
* return a pointer to a newly created or existing nce_t;
* note that the ire-nce mapping is many-one, i.e.,
* multiple ire's could point to the same nce_t.
*/
break;
default:
return (EINVAL);
}
/*
* IRE_BROADCAST ire's must be linked to NCE_F_BCAST nce's and
* vice-versa (IRE_CACHE <-> unicast nce entries). We may have found an
* existing unicast (or bcast) nce when trying to add a BROADCAST (or
* progress, and the ipif_ndp_down() call to quiesce existing state
* because the ipif being affected was not the last one on the ill. We
* recover from the missed ndp_delete() now, by deleting the old nce and
* adding a new one with the correct NCE_F_BCAST state.
*/
/* IRE_BROADCAST needs NCE_F_BCAST */
goto retry_nce;
}
/*
* Two bcast ires are created for each interface;
* 1. loopback copy (which does not have an
* ire_stq, and therefore has no ire_nce), and,
* 2. the non-loopback copy, which has the nce_res_mp
* initialized to a copy of the ill_bcast_mp, and
* is marked as ND_REACHABLE at this point.
* This nce does not undergo any further state changes,
* and exists as long as the interface is plumbed.
* Note: the assignment of ire_nce here is a historical
* artifact of old code that used to inline ire_add().
*/
/*
* We are associating this nce to the ire,
* so change the nce ref taken in
* ndp_lookup_then_add_v4() from
* NCE_REFHOLD to NCE_REFHOLD_NOTR
*/
} else {
/* IRE_CACHE needs unicast nce */
goto retry_nce;
}
/*
* We are not using this nce_t just yet so release
* the ref taken in ndp_lookup_then_add_v4()
*/
}
return (0);
}
/*
* This is the implementation of the IPv4 IRE cache lookup procedure.
* Separating the interface from the implementation allows additional
* flexibility when specifying search criteria.
*/
static ire_t *
{
return (NULL);
}
continue;
return (ire);
}
}
return (NULL);
}
/*
* This function locates IRE_CACHE entries which were added by the
* ire_forward() path. We can fully specify the IRE we are looking for by
* providing the ipif (MATCH_IRE_IPIF) *and* the stq (MATCH_IRE_WQ).
*/
ire_t *
{
return (ip4_ctable_lookup_impl(&margs));
}