Subject: [Idr] Example of multiple-path route selection issue

From: Jeffrey Haas <[email-masked]>
Date: Thu, 31 Aug 2006 12:52:19 -0400

Neither proposed solution for the injectin of multiple bgp routes
makes use of a "used for forwarding" bit.  Looking at the case
of BGP route oscillation, proposed solutions involve injecting "enough"
additional BGP routes into the entire routing mesh to suppress the
oscillation.  The scope of "enough" is outside this example.

Consider the case where multiple instances of a route are injected
into a routing mesh without any delineation of its use in forwarding state.

This example is meant to illustrate a case where, when this happens,
that we may converge in a forwarding loop.

This example does not cover the oscillation case.  It is meant
to illustrate that one solution to the oscillation case may be an issue.

Please excuse the complexity of this example. It's what I have doodled on my
whiteboard and some of this may be extraneous.

 A-----B-----C------D
        \   /
	 \ /
	  E

Outgoing link metrics for IGP:
A->B 1
B->C 10
C->D 1
B->E 1
E->C 1
D->C 1
C->B 1
B->A 4
C->E 10
E->B 10

Presume ebgp confederation connections for all routers in the above set.
B and C prepend one extra AS to each other to keep the loop equally
preferable for AS_PATH length purposes.

C is configured to prefer routes from A.  (Insert your mechanism of choice here)

A and D both receive a destination, R.  We'll call this R(A) and R(D)
to distinguish ingress.  R is coming from outside the confederation.
R is otherwise equally preferable regardless of who it comes from.

If we're running stock BGP, we expect to see the following:

Allow R(A) to percolate through first:
A: R(A) local
B: R(A) via B->A
C: R(A) via C->B
D: R(A) via D->C
E: R(A) via E->C

Allow R(D) to be injected *without* policy on C:
A: R(A) local
B: R(D) via B->E
C: R(D) via C->D
E: R(D) via E->C

Now, consider what happens if we use policy on C:

Start with our original case of R(A) to percolate.  If C has policy,
we have a form of wedgie:

A: R(A) local
B: R(A) via B->A
C: R(A) via C->B (preferred by policy)
D: R(D) local
E: R(A) via E->C

Were we to let R(A) and R(D) to flow simultaneously, depending on
the order things happen, we'll converge differently.  Specifically,
if B selects R(D), R(A) will never percolate through the rest of the
network.  Either answer is *fine* because we converge.

Consider what happens if we're able to circulate both R(A) and R(D)
within the network without regards to which route is used for forwarding:

A: R(A) local
B: R(D) via B->E (lowest IGP metric)
C: R(A) via C->B (prefer A)
D: R(D) local
E: R(D) via E->C (lowest IGP metric)

We now have a forwarding loop: B->E->C->B.  This loop isn't contingent
on order the routes come in, only that R(A) and R(D) are available everywhere
without regard to forwarding state.

-- Jeff

_______________________________________________
Idr mailing list
[email-masked]
https://www1.ietf.org/mailman/listinfo/idr