[mirror_frr.git] / pimd / pim_oil.c

/*
 * PIM for Quagga
 * Copyright (C) 2008  Everton da Silva Marques
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "log.h"
#include "memory.h"
#include "linklist.h"
#include "if.h"
#include "hash.h"
#include "jhash.h"

#include "pimd.h"
#include "pim_oil.h"
#include "pim_str.h"
#include "pim_iface.h"
#include "pim_time.h"
#include "pim_vxlan.h"

static void pim_channel_update_mute(struct channel_oil *c_oil);

char *pim_channel_oil_dump(struct channel_oil *c_oil, char *buf, size_t size)
{
	char *out;
	struct interface *ifp;
	pim_sgaddr sg;
	int i;

	sg.src = *oil_origin(c_oil);
	sg.grp = *oil_mcastgrp(c_oil);
	ifp = pim_if_find_by_vif_index(c_oil->pim, *oil_parent(c_oil));
	snprintfrr(buf, size, "%pSG IIF: %s, OIFS: ", &sg,
		   ifp ? ifp->name : "(?)");

	out = buf + strlen(buf);
	for (i = 0; i < MAXVIFS; i++) {
		if (oil_if_has(c_oil, i) != 0) {
			ifp = pim_if_find_by_vif_index(c_oil->pim, i);
			snprintf(out, buf + size - out, "%s ",
				 ifp ? ifp->name : "(?)");
			out += strlen(out);
		}
	}

	return buf;
}

int pim_channel_oil_compare(const struct channel_oil *cc1,
			    const struct channel_oil *cc2)
{
	struct channel_oil *c1 = (struct channel_oil *)cc1;
	struct channel_oil *c2 = (struct channel_oil *)cc2;
	int rv;

	rv = pim_addr_cmp(*oil_mcastgrp(c1), *oil_mcastgrp(c2));
	if (rv)
		return rv;
	rv = pim_addr_cmp(*oil_origin(c1), *oil_origin(c2));
	if (rv)
		return rv;
	return 0;
}

void pim_oil_init(struct pim_instance *pim)
{
	rb_pim_oil_init(&pim->channel_oil_head);
}

void pim_oil_terminate(struct pim_instance *pim)
{
	struct channel_oil *c_oil;

	while ((c_oil = rb_pim_oil_pop(&pim->channel_oil_head)))
		pim_channel_oil_free(c_oil);

	rb_pim_oil_fini(&pim->channel_oil_head);
}

void pim_channel_oil_free(struct channel_oil *c_oil)
{
	XFREE(MTYPE_PIM_CHANNEL_OIL, c_oil);
}

struct channel_oil *pim_find_channel_oil(struct pim_instance *pim,
					 pim_sgaddr *sg)
{
	struct channel_oil *c_oil = NULL;
	struct channel_oil lookup;

	*oil_mcastgrp(&lookup) = sg->grp;
	*oil_origin(&lookup) = sg->src;

	c_oil = rb_pim_oil_find(&pim->channel_oil_head, &lookup);

	return c_oil;
}

struct channel_oil *pim_channel_oil_add(struct pim_instance *pim,
					pim_sgaddr *sg, const char *name)
{
	struct channel_oil *c_oil;

	c_oil = pim_find_channel_oil(pim, sg);
	if (c_oil) {
		++c_oil->oil_ref_count;

		if (!c_oil->up) {
			/* channel might be present prior to upstream */
			c_oil->up = pim_upstream_find(
					pim, sg);
			/* if the upstream entry is being anchored to an
			 * already existing channel OIL we need to re-evaluate
			 * the "Mute" state on AA OIFs
			 */
			pim_channel_update_mute(c_oil);
		}

		/* check if the IIF has changed
		 * XXX - is this really needed
		 */
		pim_upstream_mroute_iif_update(c_oil, __func__);

		if (PIM_DEBUG_MROUTE)
			zlog_debug(
				"%s(%s): Existing oil for %pSG Ref Count: %d (Post Increment)",
				__func__, name, sg, c_oil->oil_ref_count);
		return c_oil;
	}

	c_oil = XCALLOC(MTYPE_PIM_CHANNEL_OIL, sizeof(*c_oil));

	*oil_mcastgrp(c_oil) = sg->grp;
	*oil_origin(c_oil) = sg->src;

	*oil_parent(c_oil) = MAXVIFS;
	c_oil->oil_ref_count = 1;
	c_oil->installed = 0;
	c_oil->up = pim_upstream_find(pim, sg);
	c_oil->pim = pim;

	rb_pim_oil_add(&pim->channel_oil_head, c_oil);

	if (PIM_DEBUG_MROUTE)
		zlog_debug("%s(%s): c_oil %pSG add", __func__, name, sg);

	return c_oil;
}

struct channel_oil *pim_channel_oil_del(struct channel_oil *c_oil,
					const char *name)
{
	if (PIM_DEBUG_MROUTE) {
		pim_sgaddr sg = {.src = *oil_mcastgrp(c_oil),
				 .grp = *oil_origin(c_oil)};

		zlog_debug(
			"%s(%s): Del oil for %pSG, Ref Count: %d (Predecrement)",
			__func__, name, &sg, c_oil->oil_ref_count);
	}
	--c_oil->oil_ref_count;

	if (c_oil->oil_ref_count < 1) {
		/*
		 * notice that listnode_delete() can't be moved
		 * into pim_channel_oil_free() because the later is
		 * called by list_delete_all_node()
		 */
		c_oil->up = NULL;
		rb_pim_oil_del(&c_oil->pim->channel_oil_head, c_oil);

		pim_channel_oil_free(c_oil);
		return NULL;
	}

	return c_oil;
}

void pim_channel_oil_upstream_deref(struct channel_oil *c_oil)
{
	/* The upstream entry associated with a channel_oil is abt to be
	 * deleted. If the channel_oil is kept around because of other
	 * references we need to remove upstream based states out of it.
	 */
	c_oil = pim_channel_oil_del(c_oil, __func__);
	if (c_oil) {
		/* note: here we assume that c_oil->up has already been
		 * cleared
		 */
		pim_channel_update_mute(c_oil);
	}
}

int pim_channel_del_oif(struct channel_oil *channel_oil, struct interface *oif,
			uint32_t proto_mask, const char *caller)
{
	struct pim_interface *pim_ifp;

	assert(channel_oil);
	assert(oif);

	pim_ifp = oif->info;

	assertf(pim_ifp->mroute_vif_index >= 0,
		"trying to del OIF %s with VIF (%d)", oif->name,
		pim_ifp->mroute_vif_index);

	/*
	 * Don't do anything if we've been asked to remove a source
	 * that is not actually on it.
	 */
	if (!(channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask)) {
		if (PIM_DEBUG_MROUTE) {
			zlog_debug(
				"%s %s: no existing protocol mask %u(%u) for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
				__FILE__, __func__, proto_mask,
				channel_oil
					->oif_flags[pim_ifp->mroute_vif_index],
				oif->name, pim_ifp->mroute_vif_index,
				oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
				oil_origin(channel_oil),
				oil_mcastgrp(channel_oil));
		}
		return 0;
	}

	channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~proto_mask;

	if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] &
			PIM_OIF_FLAG_PROTO_ANY) {
		if (PIM_DEBUG_MROUTE) {
			zlog_debug(
				"%s %s: other protocol masks remain for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
				__FILE__, __func__, oif->name,
				pim_ifp->mroute_vif_index,
				oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
				oil_origin(channel_oil),
				oil_mcastgrp(channel_oil));
		}
		return 0;
	}

	oil_if_set(channel_oil, pim_ifp->mroute_vif_index, false);
	/* clear mute; will be re-evaluated when the OIF becomes valid again */
	channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~PIM_OIF_FLAG_MUTE;

	if (pim_upstream_mroute_add(channel_oil, __func__)) {
		if (PIM_DEBUG_MROUTE) {
			zlog_debug(
				"%s %s: could not remove output interface %s (vif_index=%d) for channel (S,G)=(%pPAs,%pPAs)",
				__FILE__, __func__, oif->name,
				pim_ifp->mroute_vif_index,
				oil_origin(channel_oil),
				oil_mcastgrp(channel_oil));
		}
		return -1;
	}

	--channel_oil->oil_size;

	if (PIM_DEBUG_MROUTE) {
		zlog_debug(
			"%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u IIF:%d OIF=%s vif_index=%d",
			__func__, caller, oil_origin(channel_oil),
			oil_mcastgrp(channel_oil),
			proto_mask,
			*oil_parent(channel_oil), oif->name,
			pim_ifp->mroute_vif_index);
	}

	return 0;
}

void pim_channel_del_inherited_oif(struct channel_oil *c_oil,
		struct interface *oif, const char *caller)
{
	struct pim_upstream *up = c_oil->up;

	pim_channel_del_oif(c_oil, oif, PIM_OIF_FLAG_PROTO_STAR,
			caller);

	/* if an inherited OIF is being removed join-desired can change
	 * if the inherited OIL is now empty and KAT is running
	 */
	if (up && !pim_addr_is_any(up->sg.src) &&
	    pim_upstream_empty_inherited_olist(up))
		pim_upstream_update_join_desired(up->pim, up);
}

static bool pim_channel_eval_oif_mute(struct channel_oil *c_oil,
		struct pim_interface *pim_ifp)
{
	struct pim_interface *pim_reg_ifp;
	struct pim_interface *vxlan_ifp;
	bool do_mute = false;
	struct pim_instance *pim = c_oil->pim;

	if (!c_oil->up)
		return do_mute;

	pim_reg_ifp = pim->regiface->info;
	if (pim_ifp == pim_reg_ifp) {
		/* suppress pimreg in the OIL if the mroute is not supposed to
		 * trigger register encapsulated data
		 */
		if (PIM_UPSTREAM_FLAG_TEST_NO_PIMREG_DATA(c_oil->up->flags))
			do_mute = true;

		return do_mute;
	}

	vxlan_ifp = pim_vxlan_get_term_ifp(pim);
	if (pim_ifp == vxlan_ifp) {
		/* 1. vxlan termination device must never be added to the
		 * origination mroute (and that can actually happen because
		 * of XG inheritance from the termination mroute) otherwise
		 * traffic will end up looping.
		 * PS: This check has also been extended to non-orig mroutes
		 * that have a local SIP as such mroutes can move back and
		 * forth between orig<=>non-orig type.
		 * 2. vxlan termination device should be removed from the non-DF
		 * to prevent duplicates to the overlay rxer
		 */
		if (PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_ORIG(c_oil->up->flags) ||
			PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(c_oil->up->flags) ||
			pim_vxlan_is_local_sip(c_oil->up))
			do_mute = true;

		return do_mute;
	}

	if (PIM_I_am_DualActive(pim_ifp)) {
		struct pim_upstream *starup = c_oil->up->parent;
		if (PIM_UPSTREAM_FLAG_TEST_MLAG_INTERFACE(c_oil->up->flags)
		    && (PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(c_oil->up->flags)))
			do_mute = true;

		/* In case entry is (S,G), Negotiation happens at (*.G) */
		if (starup

		    && PIM_UPSTREAM_FLAG_TEST_MLAG_INTERFACE(starup->flags)
		    && (PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(starup->flags)))
			do_mute = true;
		return do_mute;
	}
	return do_mute;
}

void pim_channel_update_oif_mute(struct channel_oil *c_oil,
		struct pim_interface *pim_ifp)
{
	bool old_mute;
	bool new_mute;

	/* If pim_ifp is not a part of the OIL there is nothing to do */
	if (!oil_if_has(c_oil, pim_ifp->mroute_vif_index))
		return;

	old_mute = !!(c_oil->oif_flags[pim_ifp->mroute_vif_index] &
			PIM_OIF_FLAG_MUTE);
	new_mute = pim_channel_eval_oif_mute(c_oil, pim_ifp);
	if (old_mute == new_mute)
		return;

	if (new_mute)
		c_oil->oif_flags[pim_ifp->mroute_vif_index] |=
			PIM_OIF_FLAG_MUTE;
	else
		c_oil->oif_flags[pim_ifp->mroute_vif_index] &=
			~PIM_OIF_FLAG_MUTE;

	pim_upstream_mroute_add(c_oil, __func__);
}

/* pim_upstream has been set or cleared on the c_oil. re-eval mute state
 * on all existing OIFs
 */
static void pim_channel_update_mute(struct channel_oil *c_oil)
{
	struct pim_interface *pim_reg_ifp;
	struct pim_interface *vxlan_ifp;

	if (c_oil->pim->regiface) {
		pim_reg_ifp = c_oil->pim->regiface->info;
		if (pim_reg_ifp)
			pim_channel_update_oif_mute(c_oil, pim_reg_ifp);
	}
	vxlan_ifp = pim_vxlan_get_term_ifp(c_oil->pim);
	if (vxlan_ifp)
		pim_channel_update_oif_mute(c_oil, vxlan_ifp);
}

int pim_channel_add_oif(struct channel_oil *channel_oil, struct interface *oif,
			uint32_t proto_mask, const char *caller)
{
	struct pim_interface *pim_ifp;
	int old_ttl;

	/*
	 * If we've gotten here we've gone bad, but let's
	 * not take down pim
	 */
	if (!channel_oil) {
		zlog_warn("Attempt to Add OIF for non-existent channel oil");
		return -1;
	}

	pim_ifp = oif->info;

	assertf(pim_ifp->mroute_vif_index >= 0,
		"trying to add OIF %s with VIF (%d)", oif->name,
		pim_ifp->mroute_vif_index);

	/* Prevent single protocol from subscribing same interface to
	   channel (S,G) multiple times */
	if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask) {
		if (PIM_DEBUG_MROUTE) {
			zlog_debug(
				"%s %s: existing protocol mask %u requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
				__FILE__, __func__, proto_mask, oif->name,
				pim_ifp->mroute_vif_index,
				oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
				oil_origin(channel_oil),
				oil_mcastgrp(channel_oil));
		}
		return -3;
	}

	/* Allow other protocol to request subscription of same interface to
	 * channel (S,G), we need to note this information
	 */
	if (channel_oil->oif_flags[pim_ifp->mroute_vif_index]
	    & PIM_OIF_FLAG_PROTO_ANY) {

		/* Updating time here is not required as this time has to
		 * indicate when the interface is added
		 */

		channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;
		/* Check the OIF really exists before returning, and only log
		   warning otherwise */
		if (oil_if_has(channel_oil, pim_ifp->mroute_vif_index) < 1) {
			zlog_warn(
				"%s %s: new protocol mask %u requested nonexistent OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
				__FILE__, __func__, proto_mask, oif->name,
				pim_ifp->mroute_vif_index,
				oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
				oil_origin(channel_oil),
				oil_mcastgrp(channel_oil));
		}

		if (PIM_DEBUG_MROUTE) {
			zlog_debug(
				"%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u OIF=%s vif_index=%d added to 0x%x",
				__func__, caller, oil_origin(channel_oil),
				oil_mcastgrp(channel_oil),
				proto_mask, oif->name,
				pim_ifp->mroute_vif_index,
				channel_oil
					->oif_flags[pim_ifp->mroute_vif_index]);
		}
		return 0;
	}

	old_ttl = oil_if_has(channel_oil, pim_ifp->mroute_vif_index);

	if (old_ttl > 0) {
		if (PIM_DEBUG_MROUTE) {
			zlog_debug(
				"%s %s: interface %s (vif_index=%d) is existing output for channel (S,G)=(%pPAs,%pPAs)",
				__FILE__, __func__, oif->name,
				pim_ifp->mroute_vif_index,
				oil_origin(channel_oil),
				oil_mcastgrp(channel_oil));
		}
		return -4;
	}

	oil_if_set(channel_oil, pim_ifp->mroute_vif_index, PIM_MROUTE_MIN_TTL);

	/* Some OIFs are held in a muted state i.e. the PIM state machine
	 * decided to include the OIF but additional status check such as
	 * MLAG DF role prevent it from being activated for traffic
	 * forwarding.
	 */
	if (pim_channel_eval_oif_mute(channel_oil, pim_ifp))
		channel_oil->oif_flags[pim_ifp->mroute_vif_index] |=
			PIM_OIF_FLAG_MUTE;
	else
		channel_oil->oif_flags[pim_ifp->mroute_vif_index] &=
			~PIM_OIF_FLAG_MUTE;

	/* channel_oil->oil.mfcc_parent != MAXVIFS indicate this entry is not
	 * valid to get installed in kernel.
	 */
	if (*oil_parent(channel_oil) != MAXVIFS) {
		if (pim_upstream_mroute_add(channel_oil, __func__)) {
			if (PIM_DEBUG_MROUTE) {
				zlog_debug(
					"%s %s: could not add output interface %s (vif_index=%d) for channel (S,G)=(%pPAs,%pPAs)",
					__FILE__, __func__, oif->name,
					pim_ifp->mroute_vif_index,
					oil_origin(channel_oil),
					oil_mcastgrp(channel_oil));
			}

			oil_if_set(channel_oil, pim_ifp->mroute_vif_index,
				   old_ttl);
			return -5;
		}
	}

	channel_oil->oif_creation[pim_ifp->mroute_vif_index] =
		pim_time_monotonic_sec();
	++channel_oil->oil_size;
	channel_oil->oif_flags[pim_ifp->mroute_vif_index] |= proto_mask;

	if (PIM_DEBUG_MROUTE) {
		zlog_debug(
			"%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u OIF=%s vif_index=%d: DONE",
			__func__, caller, oil_origin(channel_oil),
			oil_mcastgrp(channel_oil),
			proto_mask,
			oif->name, pim_ifp->mroute_vif_index);
	}

	return 0;
}

int pim_channel_oil_empty(struct channel_oil *c_oil)
{
#if PIM_IPV == 4
	static struct mfcctl null_oil;
#else
	static struct mf6cctl null_oil;
#endif

	if (!c_oil)
		return 1;


	/* exclude pimreg from the OIL when checking if the inherited_oil is
	 * non-NULL.
	 * pimreg device (in all vrfs) uses a vifi of
	 * 0 (PIM_OIF_PIM_REGISTER_VIF) so we simply mfcc_ttls[0] */
	if (oil_if_has(c_oil, 0)) {
#if PIM_IPV == 4
		null_oil.mfcc_ttls[0] = 1;
#else
		IF_SET(0, &null_oil.mf6cc_ifset);
#endif
	}

	return !oil_if_cmp(&c_oil->oil, &null_oil);
}
Commit	Line	Data
12e41d03	1	/*
896014f4 DL	2	* PIM for Quagga
	3	* Copyright (C) 2008 Everton da Silva Marques
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; see the file COPYING; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
12e41d03 DL	19
	20	#include <zebra.h>
	21
	22	#include "log.h"
	23	#include "memory.h"
	24	#include "linklist.h"
744d91b3	25	#include "if.h"
040d86ad DS	26	#include "hash.h"
040d86ad DS	27	#include "jhash.h"
12e41d03 DL	28
	29	#include "pimd.h"
	30	#include "pim_oil.h"
	31	#include "pim_str.h"
	32	#include "pim_iface.h"
37653d4f	33	#include "pim_time.h"
5923b739	34	#include "pim_vxlan.h"
12e41d03	35
a155fed5 AK	36	static void pim_channel_update_mute(struct channel_oil *c_oil);
a155fed5 AK	37
d62a17ae	38	char pim_channel_oil_dump(struct channel_oil c_oil, char *buf, size_t size)
781a1745	39	{
a2dc7057	40	char *out;
9bf5f19c	41	struct interface *ifp;
6fff2cc6	42	pim_sgaddr sg;
d62a17ae	43	int i;
d62a17ae	44
a9338fa4 DL	45	sg.src = *oil_origin(c_oil);
	46	sg.grp = *oil_mcastgrp(c_oil);
	47	ifp = pim_if_find_by_vif_index(c_oil->pim, *oil_parent(c_oil));
98a81d2b DL	48	snprintfrr(buf, size, "%pSG IIF: %s, OIFS: ", &sg,
98a81d2b DL	49	ifp ? ifp->name : "(?)");
d62a17ae	50
a2dc7057	51	out = buf + strlen(buf);
d62a17ae	52	for (i = 0; i < MAXVIFS; i++) {
a9338fa4	53	if (oil_if_has(c_oil, i) != 0) {
9bf5f19c DS	54	ifp = pim_if_find_by_vif_index(c_oil->pim, i);
	55	snprintf(out, buf + size - out, "%s ",
	56	ifp ? ifp->name : "(?)");
a2dc7057	57	out += strlen(out);
d62a17ae	58	}
	59	}
	60
	61	return buf;
781a1745 DS	62	}
781a1745 DS	63
a9338fa4 DL	64	int pim_channel_oil_compare(const struct channel_oil *cc1,
a9338fa4 DL	65	const struct channel_oil *cc2)
040d86ad	66	{
a9338fa4 DL	67	struct channel_oil c1 = (struct channel_oil )cc1;
	68	struct channel_oil c2 = (struct channel_oil )cc2;
	69	int rv;
	70
	71	rv = pim_addr_cmp(oil_mcastgrp(c1), oil_mcastgrp(c2));
	72	if (rv)
	73	return rv;
	74	rv = pim_addr_cmp(oil_origin(c1), oil_origin(c2));
	75	if (rv)
	76	return rv;
d62a17ae	77	return 0;
040d86ad DS	78	}
040d86ad DS	79
611925dc	80	void pim_oil_init(struct pim_instance *pim)
040d86ad	81	{
7315ecda	82	rb_pim_oil_init(&pim->channel_oil_head);
040d86ad DS	83	}
040d86ad DS	84
611925dc	85	void pim_oil_terminate(struct pim_instance *pim)
040d86ad	86	{
7315ecda DS	87	struct channel_oil *c_oil;
	88
	89	while ((c_oil = rb_pim_oil_pop(&pim->channel_oil_head)))
	90	pim_channel_oil_free(c_oil);
040d86ad	91
7315ecda	92	rb_pim_oil_fini(&pim->channel_oil_head);
040d86ad DS	93	}
040d86ad DS	94
12e41d03 DL	95	void pim_channel_oil_free(struct channel_oil *c_oil)
12e41d03 DL	96	{
d62a17ae	97	XFREE(MTYPE_PIM_CHANNEL_OIL, c_oil);
12e41d03 DL	98	}
12e41d03 DL	99
4d9ad5dc	100	struct channel_oil pim_find_channel_oil(struct pim_instance pim,
6fff2cc6	101	pim_sgaddr *sg)
12e41d03	102	{
d62a17ae	103	struct channel_oil *c_oil = NULL;
d62a17ae	104	struct channel_oil lookup;
d270b216	105
a9338fa4 DL	106	*oil_mcastgrp(&lookup) = sg->grp;
a9338fa4 DL	107	*oil_origin(&lookup) = sg->src;
d270b216	108
7315ecda	109	c_oil = rb_pim_oil_find(&pim->channel_oil_head, &lookup);
d270b216	110
d62a17ae	111	return c_oil;
12e41d03 DL	112	}
12e41d03 DL	113
611925dc	114	struct channel_oil pim_channel_oil_add(struct pim_instance pim,
6fff2cc6	115	pim_sgaddr sg, const char name)
12e41d03	116	{
d62a17ae	117	struct channel_oil *c_oil;
d62a17ae	118
611925dc	119	c_oil = pim_find_channel_oil(pim, sg);
d62a17ae	120	if (c_oil) {
d62a17ae	121	++c_oil->oil_ref_count;
a155fed5 AK	122
	123	if (!c_oil->up) {
	124	/* channel might be present prior to upstream */
	125	c_oil->up = pim_upstream_find(
	126	pim, sg);
	127	/* if the upstream entry is being anchored to an
	128	* already existing channel OIL we need to re-evaluate
	129	* the "Mute" state on AA OIFs
	130	*/
	131	pim_channel_update_mute(c_oil);
	132	}
8a3e7e9e	133
7984af18 AK	134	/* check if the IIF has changed
	135	* XXX - is this really needed
	136	*/
	137	pim_upstream_mroute_iif_update(c_oil, __func__);
	138
8a3e7e9e DS	139	if (PIM_DEBUG_MROUTE)
8a3e7e9e DS	140	zlog_debug(
6fff2cc6	141	"%s(%s): Existing oil for %pSG Ref Count: %d (Post Increment)",
15569c58	142	__func__, name, sg, c_oil->oil_ref_count);
d62a17ae	143	return c_oil;
	144	}
	145
d62a17ae	146	c_oil = XCALLOC(MTYPE_PIM_CHANNEL_OIL, sizeof(*c_oil));
d62a17ae	147
a9338fa4 DL	148	*oil_mcastgrp(c_oil) = sg->grp;
a9338fa4 DL	149	*oil_origin(c_oil) = sg->src;
d62a17ae	150
a9338fa4	151	*oil_parent(c_oil) = MAXVIFS;
d62a17ae	152	c_oil->oil_ref_count = 1;
d62a17ae	153	c_oil->installed = 0;
611925dc DS	154	c_oil->up = pim_upstream_find(pim, sg);
611925dc DS	155	c_oil->pim = pim;
d62a17ae	156
7315ecda	157	rb_pim_oil_add(&pim->channel_oil_head, c_oil);
d62a17ae	158
8a3e7e9e	159	if (PIM_DEBUG_MROUTE)
98a81d2b	160	zlog_debug("%s(%s): c_oil %pSG add", __func__, name, sg);
7984af18	161
d62a17ae	162	return c_oil;
12e41d03 DL	163	}
12e41d03 DL	164
a155fed5	165	struct channel_oil pim_channel_oil_del(struct channel_oil c_oil,
17823cdd	166	const char *name)
12e41d03	167	{
8a3e7e9e	168	if (PIM_DEBUG_MROUTE) {
a9338fa4 DL	169	pim_sgaddr sg = {.src = *oil_mcastgrp(c_oil),
a9338fa4 DL	170	.grp = *oil_origin(c_oil)};
8a3e7e9e DS	171
8a3e7e9e DS	172	zlog_debug(
6fff2cc6	173	"%s(%s): Del oil for %pSG, Ref Count: %d (Predecrement)",
15569c58	174	__func__, name, &sg, c_oil->oil_ref_count);
8a3e7e9e	175	}
d62a17ae	176	--c_oil->oil_ref_count;
	177
	178	if (c_oil->oil_ref_count < 1) {
	179	/*
	180	* notice that listnode_delete() can't be moved
	181	* into pim_channel_oil_free() because the later is
	182	* called by list_delete_all_node()
	183	*/
	184	c_oil->up = NULL;
7315ecda	185	rb_pim_oil_del(&c_oil->pim->channel_oil_head, c_oil);
d62a17ae	186
d62a17ae	187	pim_channel_oil_free(c_oil);
a155fed5 AK	188	return NULL;
	189	}
	190
	191	return c_oil;
	192	}
	193
	194	void pim_channel_oil_upstream_deref(struct channel_oil *c_oil)
	195	{
	196	/* The upstream entry associated with a channel_oil is abt to be
	197	* deleted. If the channel_oil is kept around because of other
	198	* references we need to remove upstream based states out of it.
	199	*/
	200	c_oil = pim_channel_oil_del(c_oil, __func__);
	201	if (c_oil) {
	202	/* note: here we assume that c_oil->up has already been
	203	* cleared
	204	*/
	205	pim_channel_update_mute(c_oil);
d62a17ae	206	}
12e41d03	207	}
1865a44a	208
d62a17ae	209	int pim_channel_del_oif(struct channel_oil channel_oil, struct interface oif,
1b249e70	210	uint32_t proto_mask, const char *caller)
887fa014	211	{
d62a17ae	212	struct pim_interface *pim_ifp;
d62a17ae	213
df5dfb77 DL	214	assert(channel_oil);
df5dfb77 DL	215	assert(oif);
d62a17ae	216
	217	pim_ifp = oif->info;
	218
d6890c49 DL	219	assertf(pim_ifp->mroute_vif_index >= 0,
	220	"trying to del OIF %s with VIF (%d)", oif->name,
	221	pim_ifp->mroute_vif_index);
	222
d62a17ae	223	/*
	224	* Don't do anything if we've been asked to remove a source
	225	* that is not actually on it.
	226	*/
	227	if (!(channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask)) {
	228	if (PIM_DEBUG_MROUTE) {
d62a17ae	229	zlog_debug(
a9338fa4	230	"%s %s: no existing protocol mask %u(%u) for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
15569c58	231	__FILE__, __func__, proto_mask,
d62a17ae	232	channel_oil
	233	->oif_flags[pim_ifp->mroute_vif_index],
	234	oif->name, pim_ifp->mroute_vif_index,
a9338fa4 DL	235	oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
	236	oil_origin(channel_oil),
	237	oil_mcastgrp(channel_oil));
d62a17ae	238	}
	239	return 0;
	240	}
	241
	242	channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~proto_mask;
	243
5923b739 AK	244	if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] &
5923b739 AK	245	PIM_OIF_FLAG_PROTO_ANY) {
d62a17ae	246	if (PIM_DEBUG_MROUTE) {
d62a17ae	247	zlog_debug(
a9338fa4	248	"%s %s: other protocol masks remain for requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
15569c58	249	__FILE__, __func__, oif->name,
d62a17ae	250	pim_ifp->mroute_vif_index,
a9338fa4 DL	251	oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
	252	oil_origin(channel_oil),
	253	oil_mcastgrp(channel_oil));
d62a17ae	254	}
	255	return 0;
	256	}
	257
a9338fa4	258	oil_if_set(channel_oil, pim_ifp->mroute_vif_index, false);
5923b739 AK	259	/* clear mute; will be re-evaluated when the OIF becomes valid again */
5923b739 AK	260	channel_oil->oif_flags[pim_ifp->mroute_vif_index] &= ~PIM_OIF_FLAG_MUTE;
d62a17ae	261
15569c58	262	if (pim_upstream_mroute_add(channel_oil, __func__)) {
d62a17ae	263	if (PIM_DEBUG_MROUTE) {
d62a17ae	264	zlog_debug(
a9338fa4	265	"%s %s: could not remove output interface %s (vif_index=%d) for channel (S,G)=(%pPAs,%pPAs)",
15569c58	266	__FILE__, __func__, oif->name,
a9338fa4 DL	267	pim_ifp->mroute_vif_index,
	268	oil_origin(channel_oil),
	269	oil_mcastgrp(channel_oil));
d62a17ae	270	}
d62a17ae	271	return -1;
887fa014	272	}
d62a17ae	273
	274	--channel_oil->oil_size;
	275
	276	if (PIM_DEBUG_MROUTE) {
d62a17ae	277	zlog_debug(
a9338fa4 DL	278	"%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u IIF:%d OIF=%s vif_index=%d",
	279	__func__, caller, oil_origin(channel_oil),
	280	oil_mcastgrp(channel_oil),
	281	proto_mask,
	282	*oil_parent(channel_oil), oif->name,
d62a17ae	283	pim_ifp->mroute_vif_index);
887fa014	284	}
d62a17ae	285
d62a17ae	286	return 0;
887fa014 DS	287	}
887fa014 DS	288
1537a668 AK	289	void pim_channel_del_inherited_oif(struct channel_oil *c_oil,
	290	struct interface oif, const char caller)
	291	{
	292	struct pim_upstream *up = c_oil->up;
	293
	294	pim_channel_del_oif(c_oil, oif, PIM_OIF_FLAG_PROTO_STAR,
	295	caller);
	296
	297	/* if an inherited OIF is being removed join-desired can change
	298	* if the inherited OIL is now empty and KAT is running
	299	*/
2a27f13b DL	300	if (up && !pim_addr_is_any(up->sg.src) &&
2a27f13b DL	301	pim_upstream_empty_inherited_olist(up))
1537a668 AK	302	pim_upstream_update_join_desired(up->pim, up);
1537a668 AK	303	}
887fa014	304
5923b739 AK	305	static bool pim_channel_eval_oif_mute(struct channel_oil *c_oil,
	306	struct pim_interface *pim_ifp)
	307	{
	308	struct pim_interface *pim_reg_ifp;
	309	struct pim_interface *vxlan_ifp;
	310	bool do_mute = false;
	311	struct pim_instance *pim = c_oil->pim;
	312
	313	if (!c_oil->up)
	314	return do_mute;
	315
	316	pim_reg_ifp = pim->regiface->info;
	317	if (pim_ifp == pim_reg_ifp) {
	318	/* suppress pimreg in the OIL if the mroute is not supposed to
	319	* trigger register encapsulated data
	320	*/
	321	if (PIM_UPSTREAM_FLAG_TEST_NO_PIMREG_DATA(c_oil->up->flags))
	322	do_mute = true;
	323
	324	return do_mute;
	325	}
	326
	327	vxlan_ifp = pim_vxlan_get_term_ifp(pim);
	328	if (pim_ifp == vxlan_ifp) {
	329	/* 1. vxlan termination device must never be added to the
	330	* origination mroute (and that can actually happen because
	331	* of XG inheritance from the termination mroute) otherwise
	332	* traffic will end up looping.
	333	* PS: This check has also been extended to non-orig mroutes
	334	* that have a local SIP as such mroutes can move back and
	335	* forth between orig<=>non-orig type.
	336	* 2. vxlan termination device should be removed from the non-DF
	337	* to prevent duplicates to the overlay rxer
	338	*/
	339	if (PIM_UPSTREAM_FLAG_TEST_SRC_VXLAN_ORIG(c_oil->up->flags) \|\|
	340	PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(c_oil->up->flags) \|\|
	341	pim_vxlan_is_local_sip(c_oil->up))
	342	do_mute = true;
	343
	344	return do_mute;
	345	}
	346
df94b33a DS	347	if (PIM_I_am_DualActive(pim_ifp)) {
	348	struct pim_upstream *starup = c_oil->up->parent;
	349	if (PIM_UPSTREAM_FLAG_TEST_MLAG_INTERFACE(c_oil->up->flags)
	350	&& (PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(c_oil->up->flags)))
	351	do_mute = true;
	352
	353	/* In case entry is (S,G), Negotiation happens at (.G) /
	354	if (starup
	355
	356	&& PIM_UPSTREAM_FLAG_TEST_MLAG_INTERFACE(starup->flags)
	357	&& (PIM_UPSTREAM_FLAG_TEST_MLAG_NON_DF(starup->flags)))
	358	do_mute = true;
	359	return do_mute;
	360	}
5923b739 AK	361	return do_mute;
	362	}
	363
	364	void pim_channel_update_oif_mute(struct channel_oil *c_oil,
	365	struct pim_interface *pim_ifp)
	366	{
	367	bool old_mute;
	368	bool new_mute;
	369
	370	/* If pim_ifp is not a part of the OIL there is nothing to do */
a9338fa4	371	if (!oil_if_has(c_oil, pim_ifp->mroute_vif_index))
5923b739 AK	372	return;
	373
	374	old_mute = !!(c_oil->oif_flags[pim_ifp->mroute_vif_index] &
	375	PIM_OIF_FLAG_MUTE);
	376	new_mute = pim_channel_eval_oif_mute(c_oil, pim_ifp);
	377	if (old_mute == new_mute)
	378	return;
	379
	380	if (new_mute)
	381	c_oil->oif_flags[pim_ifp->mroute_vif_index] \|=
	382	PIM_OIF_FLAG_MUTE;
	383	else
	384	c_oil->oif_flags[pim_ifp->mroute_vif_index] &=
	385	~PIM_OIF_FLAG_MUTE;
	386
15569c58	387	pim_upstream_mroute_add(c_oil, __func__);
5923b739 AK	388	}
5923b739 AK	389
a155fed5 AK	390	/* pim_upstream has been set or cleared on the c_oil. re-eval mute state
	391	* on all existing OIFs
	392	*/
	393	static void pim_channel_update_mute(struct channel_oil *c_oil)
	394	{
	395	struct pim_interface *pim_reg_ifp;
	396	struct pim_interface *vxlan_ifp;
	397
8c70a46b DS	398	if (c_oil->pim->regiface) {
	399	pim_reg_ifp = c_oil->pim->regiface->info;
	400	if (pim_reg_ifp)
	401	pim_channel_update_oif_mute(c_oil, pim_reg_ifp);
	402	}
a155fed5 AK	403	vxlan_ifp = pim_vxlan_get_term_ifp(c_oil->pim);
	404	if (vxlan_ifp)
	405	pim_channel_update_oif_mute(c_oil, vxlan_ifp);
	406	}
	407
d62a17ae	408	int pim_channel_add_oif(struct channel_oil channel_oil, struct interface oif,
1b249e70	409	uint32_t proto_mask, const char *caller)
1865a44a	410	{
d62a17ae	411	struct pim_interface *pim_ifp;
	412	int old_ttl;
	413
	414	/*
	415	* If we've gotten here we've gone bad, but let's
	416	* not take down pim
	417	*/
	418	if (!channel_oil) {
	419	zlog_warn("Attempt to Add OIF for non-existent channel oil");
	420	return -1;
	421	}
1865a44a	422
d62a17ae	423	pim_ifp = oif->info;
1865a44a	424
d6890c49 DL	425	assertf(pim_ifp->mroute_vif_index >= 0,
	426	"trying to add OIF %s with VIF (%d)", oif->name,
	427	pim_ifp->mroute_vif_index);
	428
d62a17ae	429	/* Prevent single protocol from subscribing same interface to
	430	channel (S,G) multiple times */
	431	if (channel_oil->oif_flags[pim_ifp->mroute_vif_index] & proto_mask) {
	432	if (PIM_DEBUG_MROUTE) {
d62a17ae	433	zlog_debug(
a9338fa4	434	"%s %s: existing protocol mask %u requested OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
15569c58 DA	435	__FILE__, __func__, proto_mask, oif->name,
15569c58 DA	436	pim_ifp->mroute_vif_index,
a9338fa4 DL	437	oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
	438	oil_origin(channel_oil),
	439	oil_mcastgrp(channel_oil));
d62a17ae	440	}
	441	return -3;
	442	}
	443
	444	/* Allow other protocol to request subscription of same interface to
	445	* channel (S,G), we need to note this information
	446	*/
	447	if (channel_oil->oif_flags[pim_ifp->mroute_vif_index]
	448	& PIM_OIF_FLAG_PROTO_ANY) {
	449
d23756e9 SP	450	/* Updating time here is not required as this time has to
	451	* indicate when the interface is added
	452	*/
	453
d62a17ae	454	channel_oil->oif_flags[pim_ifp->mroute_vif_index] \|= proto_mask;
	455	/* Check the OIF really exists before returning, and only log
	456	warning otherwise */
a9338fa4	457	if (oil_if_has(channel_oil, pim_ifp->mroute_vif_index) < 1) {
dd4a4b56	458	zlog_warn(
a9338fa4	459	"%s %s: new protocol mask %u requested nonexistent OIF %s (vif_index=%d, min_ttl=%d) for channel (S,G)=(%pPAs,%pPAs)",
dd4a4b56 DS	460	__FILE__, __func__, proto_mask, oif->name,
dd4a4b56 DS	461	pim_ifp->mroute_vif_index,
a9338fa4 DL	462	oil_if_has(channel_oil, pim_ifp->mroute_vif_index),
	463	oil_origin(channel_oil),
	464	oil_mcastgrp(channel_oil));
d62a17ae	465	}
d62a17ae	466
b900ad16	467	if (PIM_DEBUG_MROUTE) {
b900ad16	468	zlog_debug(
a9338fa4 DL	469	"%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u OIF=%s vif_index=%d added to 0x%x",
	470	__func__, caller, oil_origin(channel_oil),
	471	oil_mcastgrp(channel_oil),
b900ad16 AK	472	proto_mask, oif->name,
	473	pim_ifp->mroute_vif_index,
	474	channel_oil
	475	->oif_flags[pim_ifp->mroute_vif_index]);
	476	}
d62a17ae	477	return 0;
	478	}
	479
a9338fa4	480	old_ttl = oil_if_has(channel_oil, pim_ifp->mroute_vif_index);
d62a17ae	481
	482	if (old_ttl > 0) {
	483	if (PIM_DEBUG_MROUTE) {
d62a17ae	484	zlog_debug(
a9338fa4	485	"%s %s: interface %s (vif_index=%d) is existing output for channel (S,G)=(%pPAs,%pPAs)",
15569c58	486	__FILE__, __func__, oif->name,
a9338fa4 DL	487	pim_ifp->mroute_vif_index,
	488	oil_origin(channel_oil),
	489	oil_mcastgrp(channel_oil));
d62a17ae	490	}
	491	return -4;
	492	}
	493
a9338fa4	494	oil_if_set(channel_oil, pim_ifp->mroute_vif_index, PIM_MROUTE_MIN_TTL);
d62a17ae	495
5923b739 AK	496	/* Some OIFs are held in a muted state i.e. the PIM state machine
	497	* decided to include the OIF but additional status check such as
	498	* MLAG DF role prevent it from being activated for traffic
	499	* forwarding.
	500	*/
	501	if (pim_channel_eval_oif_mute(channel_oil, pim_ifp))
	502	channel_oil->oif_flags[pim_ifp->mroute_vif_index] \|=
	503	PIM_OIF_FLAG_MUTE;
	504	else
	505	channel_oil->oif_flags[pim_ifp->mroute_vif_index] &=
	506	~PIM_OIF_FLAG_MUTE;
	507
47e3ce59 SP	508	/* channel_oil->oil.mfcc_parent != MAXVIFS indicate this entry is not
47e3ce59 SP	509	* valid to get installed in kernel.
c3156184	510	*/
a9338fa4	511	if (*oil_parent(channel_oil) != MAXVIFS) {
15569c58	512	if (pim_upstream_mroute_add(channel_oil, __func__)) {
c3156184	513	if (PIM_DEBUG_MROUTE) {
c3156184	514	zlog_debug(
a9338fa4	515	"%s %s: could not add output interface %s (vif_index=%d) for channel (S,G)=(%pPAs,%pPAs)",
15569c58	516	__FILE__, __func__, oif->name,
a9338fa4 DL	517	pim_ifp->mroute_vif_index,
	518	oil_origin(channel_oil),
	519	oil_mcastgrp(channel_oil));
c3156184	520	}
d62a17ae	521
a9338fa4 DL	522	oil_if_set(channel_oil, pim_ifp->mroute_vif_index,
a9338fa4 DL	523	old_ttl);
c3156184 SP	524	return -5;
c3156184 SP	525	}
d62a17ae	526	}
	527
	528	channel_oil->oif_creation[pim_ifp->mroute_vif_index] =
	529	pim_time_monotonic_sec();
	530	++channel_oil->oil_size;
	531	channel_oil->oif_flags[pim_ifp->mroute_vif_index] \|= proto_mask;
	532
	533	if (PIM_DEBUG_MROUTE) {
d62a17ae	534	zlog_debug(
a9338fa4 DL	535	"%s(%s): (S,G)=(%pPAs,%pPAs): proto_mask=%u OIF=%s vif_index=%d: DONE",
	536	__func__, caller, oil_origin(channel_oil),
	537	oil_mcastgrp(channel_oil),
	538	proto_mask,
15569c58	539	oif->name, pim_ifp->mroute_vif_index);
d62a17ae	540	}
	541
	542	return 0;
1865a44a	543	}
ce0ddb4e	544
d62a17ae	545	int pim_channel_oil_empty(struct channel_oil *c_oil)
ce0ddb4e	546	{
a5fa9822	547	#if PIM_IPV == 4
	548	static struct mfcctl null_oil;
	549	#else
	550	static struct mf6cctl null_oil;
	551	#endif
	552
d62a17ae	553	if (!c_oil)
d62a17ae	554	return 1;
d62a17ae	555
a5fa9822	556
9e558d9a AK	557	/* exclude pimreg from the OIL when checking if the inherited_oil is
	558	* non-NULL.
	559	* pimreg device (in all vrfs) uses a vifi of
	560	* 0 (PIM_OIF_PIM_REGISTER_VIF) so we simply mfcc_ttls[0] */
a5fa9822	561	if (oil_if_has(c_oil, 0)) {
a9338fa4	562	#if PIM_IPV == 4
a5fa9822	563	null_oil.mfcc_ttls[0] = 1;
a9338fa4	564	#else
a5fa9822	565	IF_SET(0, &null_oil.mf6cc_ifset);
a9338fa4	566	#endif
a5fa9822	567	}
	568
	569	return !oil_if_cmp(&c_oil->oil, &null_oil);
ce0ddb4e	570	}