ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add worker-handoff node

Browse Source 
worker-handoff node is universal node which taakes packets
from the input node and hands them over to worker threads.
Currently it supports flow hashing based on ipv4, ipv6 and
mpls headers.

New cli:

set interface handoff <intrerface-name> workers <list>

e.g.

set interface handoff TenGigabitEthernet2/0/0 workers 3-6,9-10

Change-Id: Iaf0df83e69bb0e84969865e0e1cdb000b0864cf5
Signed-off-by: Damjan Marion <damarion@cisco.com>
This commit is contained in:
Damjan Marion
2016-06-08 01:37:11 +02:00
committed by Dave Barach
parent c424879b4c
commit 0247b46002
8 changed files with 835 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
vnet/Makefile.am
View File

@ -26,6 +26,7 @@ TESTS =
########################################
libvnet_la_SOURCES += \
vnet/config.c \
vnet/handoff.c \
vnet/interface.c \
vnet/interface_cli.c \
vnet/interface_format.c \
@ -39,6 +40,7 @@ nobase_include_HEADERS += \
vnet/buffer.h \
vnet/config.h \
vnet/global_funcs.h \
vnet/handoff.h \
vnet/interface.h \
vnet/interface_funcs.h \
vnet/l3_types.h \

3
vnet/vnet/api_errno.h
View File

@ -78,7 +78,8 @@ _(SR_POLICY_NAME_NOT_PRESENT, -84, "Segement routing policy name required") \
_(NOT_RUNNING_AS_ROOT, -85, "Not running as root") \
_(ALREADY_CONNECTED, -86, "Connection to the data plane already exists") \
_(UNSUPPORTED_JNI_VERSION, -87, "Unsupported JNI version") \
_(FAILED_TO_ATTACH_TO_JAVA_THREAD, -88, "Failed to attach to Java thread")
_(FAILED_TO_ATTACH_TO_JAVA_THREAD, -88, "Failed to attach to Java thread") \
_(INVALID_WORKER, -89, "Invalid worker thread")
typedef enum {
#define _(a,b,c) VNET_API_ERROR_##a = (b),

7
vnet/vnet/buffer.h
View File

@ -64,6 +64,9 @@
#define LOG2_BUFFER_OUTPUT_FEAT_DONE LOG2_VLIB_BUFFER_FLAG_USER(5)
#define BUFFER_OUTPUT_FEAT_DONE (1 << LOG2_BUFFER_OUTPUT_FEAT_DONE)
#define LOG2_BUFFER_HANDOFF_NEXT_VALID LOG2_VLIB_BUFFER_FLAG_USER(6)
#define BUFFER_HANDOFF_NEXT_VALID (1 << LOG2_BUFFER_HANDOFF_NEXT_VALID)
#define foreach_buffer_opaque_union_subtype \
_(ethernet) \
_(ip) \
@ -73,7 +76,7 @@ _(l2) \
_(l2t) \
_(gre) \
_(l2_classify) \
_(io_handoff) \
_(handoff) \
_(policer) \
_(output_features) \
_(map) \
@ -185,7 +188,7 @@ typedef struct {
/* IO - worker thread handoff */
struct {
u32 next_index;
} io_handoff;
} handoff;
/* vnet policer */
struct {

4
vnet/vnet/devices/dpdk/dpdk.h
View File

@ -495,10 +495,6 @@ void dpdk_set_flowcontrol_callback (vlib_main_t *vm,
u32 dpdk_interface_tx_vector (vlib_main_t * vm, u32 dev_instance);
vlib_frame_queue_elt_t * vlib_get_handoff_queue_elt (u32 vlib_worker_index);
u32 dpdk_get_handoff_node_index (void);
void set_efd_bitmap (u8 *bitmap, u32 value, u32 op);
struct rte_mbuf * dpdk_replicate_packet_mb (vlib_buffer_t * b);

487
vnet/vnet/devices/dpdk/node.c
View File

File diff suppressed because it is too large Load Diff

529
vnet/vnet/handoff.c Normal file
View File

File diff suppressed because it is too large Load Diff

228
vnet/vnet/handoff.h Normal file
View File

@ -0,0 +1,228 @@
/*
* Copyright (c) 2016 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef included_vnet_handoff_h
#define included_vnet_handoff_h
#include <vlib/vlib.h>
#include <vnet/ethernet/ethernet.h>
#include <vnet/ip/ip4_packet.h>
#include <vnet/ip/ip6_packet.h>
#include <vnet/mpls-gre/packet.h>
typedef enum {
HANDOFF_DISPATCH_NEXT_IP4_INPUT,
HANDOFF_DISPATCH_NEXT_IP6_INPUT,
HANDOFF_DISPATCH_NEXT_MPLS_INPUT,
HANDOFF_DISPATCH_NEXT_ETHERNET_INPUT,
HANDOFF_DISPATCH_NEXT_DROP,
HANDOFF_DISPATCH_N_NEXT,
} handoff_dispatch_next_t;
static inline
void vlib_put_handoff_queue_elt (vlib_frame_queue_elt_t * hf)
{
CLIB_MEMORY_BARRIER();
hf->valid = 1;
}
static inline vlib_frame_queue_elt_t *
vlib_get_handoff_queue_elt (u32 vlib_worker_index)
{
vlib_frame_queue_t *fq;
vlib_frame_queue_elt_t *elt;
u64 new_tail;
fq = vlib_frame_queues[vlib_worker_index];
ASSERT (fq);
new_tail = __sync_add_and_fetch (&fq->tail, 1);
/* Wait until a ring slot is available */
while (new_tail >= fq->head_hint + fq->nelts)
vlib_worker_thread_barrier_check ();
elt = fq->elts + (new_tail & (fq->nelts-1));
/* this would be very bad... */
while (elt->valid)
;
elt->msg_type = VLIB_FRAME_QUEUE_ELT_DISPATCH_FRAME;
elt->last_n_vectors = elt->n_vectors = 0;
return elt;
}
static inline vlib_frame_queue_t *
is_vlib_handoff_queue_congested (
u32 vlib_worker_index,
u32 queue_hi_thresh,
vlib_frame_queue_t ** handoff_queue_by_worker_index)
{
vlib_frame_queue_t *fq;
fq = handoff_queue_by_worker_index [vlib_worker_index];
if (fq != (vlib_frame_queue_t *)(~0))
return fq;
fq = vlib_frame_queues[vlib_worker_index];
ASSERT (fq);
if (PREDICT_FALSE(fq->tail >= (fq->head_hint + queue_hi_thresh))) {
/* a valid entry in the array will indicate the queue has reached
* the specified threshold and is congested
*/
handoff_queue_by_worker_index [vlib_worker_index] = fq;
fq->enqueue_full_events++;
return fq;
}
return NULL;
}
static inline vlib_frame_queue_elt_t *
dpdk_get_handoff_queue_elt (u32 vlib_worker_index,
vlib_frame_queue_elt_t **
handoff_queue_elt_by_worker_index)
{
vlib_frame_queue_elt_t *elt;
if (handoff_queue_elt_by_worker_index [vlib_worker_index])
return handoff_queue_elt_by_worker_index [vlib_worker_index];
elt = vlib_get_handoff_queue_elt (vlib_worker_index);
handoff_queue_elt_by_worker_index [vlib_worker_index] = elt;
return elt;
}
static inline u64 ipv4_get_key (ip4_header_t *ip)
{
u64 hash_key;
hash_key = *((u64*)(&ip->address_pair)) ^ ip->protocol;
return hash_key;
}
static inline u64 ipv6_get_key (ip6_header_t *ip)
{
u64 hash_key;
hash_key = ip->src_address.as_u64[0] ^
rotate_left(ip->src_address.as_u64[1],13) ^
rotate_left(ip->dst_address.as_u64[0],26) ^
rotate_left(ip->dst_address.as_u64[1],39) ^
ip->protocol;
return hash_key;
}
#define MPLS_BOTTOM_OF_STACK_BIT_MASK 0x00000100U
#define MPLS_LABEL_MASK 0xFFFFF000U
static inline u64 mpls_get_key (mpls_unicast_header_t *m)
{
u64 hash_key;
u8 ip_ver;
/* find the bottom of the MPLS label stack. */
if (PREDICT_TRUE(m->label_exp_s_ttl &
clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK))) {
goto bottom_lbl_found;
}
m++;
if (PREDICT_TRUE(m->label_exp_s_ttl &
clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK))) {
goto bottom_lbl_found;
}
m++;
if (m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK)) {
goto bottom_lbl_found;
}
m++;
if (m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK)) {
goto bottom_lbl_found;
}
m++;
if (m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_BOTTOM_OF_STACK_BIT_MASK)) {
goto bottom_lbl_found;
}
/* the bottom label was not found - use the last label */
hash_key = m->label_exp_s_ttl & clib_net_to_host_u32(MPLS_LABEL_MASK);
return hash_key;
bottom_lbl_found:
m++;
ip_ver = (*((u8 *)m) >> 4);
/* find out if it is IPV4 or IPV6 header */
if (PREDICT_TRUE(ip_ver == 4)) {
hash_key = ipv4_get_key((ip4_header_t *)m);
} else if (PREDICT_TRUE(ip_ver == 6)) {
hash_key = ipv6_get_key((ip6_header_t *)m);
} else {
/* use the bottom label */
hash_key = (m-1)->label_exp_s_ttl & clib_net_to_host_u32(MPLS_LABEL_MASK);
}
return hash_key;
}
static inline u64
eth_get_key (ethernet_header_t *h0)
{
u64 hash_key;
if (PREDICT_TRUE(h0->type) == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) {
hash_key = ipv4_get_key((ip4_header_t *)(h0+1));
} else if (h0->type == clib_host_to_net_u16(ETHERNET_TYPE_IP6)) {
hash_key = ipv6_get_key((ip6_header_t *)(h0+1));
} else if (h0->type == clib_host_to_net_u16(ETHERNET_TYPE_MPLS_UNICAST)) {
hash_key = mpls_get_key((mpls_unicast_header_t *)(h0+1));
} else if ((h0->type == clib_host_to_net_u16(ETHERNET_TYPE_VLAN)) ||
(h0->type == clib_host_to_net_u16(ETHERNET_TYPE_DOT1AD))) {
ethernet_vlan_header_t * outer = (ethernet_vlan_header_t *)(h0 + 1);
outer = (outer->type == clib_host_to_net_u16(ETHERNET_TYPE_VLAN)) ?
outer+1 : outer;
if (PREDICT_TRUE(outer->type) == clib_host_to_net_u16(ETHERNET_TYPE_IP4)) {
hash_key = ipv4_get_key((ip4_header_t *)(outer+1));
} else if (outer->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)) {
hash_key = ipv6_get_key((ip6_header_t *)(outer+1));
} else if (outer->type == clib_host_to_net_u16(ETHERNET_TYPE_MPLS_UNICAST)) {
hash_key = mpls_get_key((mpls_unicast_header_t *)(outer+1));
} else {
hash_key = outer->type;
}
} else {
hash_key = 0;
}
return hash_key;
}
#endif /* included_vnet_handoff_h */

20
vppinfra/vppinfra/bitmap.h
View File

@ -338,6 +338,26 @@ always_inline uword clib_bitmap_first_set (uword * ai)
return ~0;
}
/* Return highest numbered set bit in bitmap.
Return infinity (~0) if bitmap is zero. */
always_inline uword clib_bitmap_last_set (uword * ai)
{
uword i;
for (i = vec_len (ai) - 1; i >= 0 ; i--)
{
uword x = ai[i];
if (x != 0)
{
uword first_bit;
count_leading_zeros (first_bit, x);
return (i + 1) * BITS (ai[0]) - first_bit - 1;
}
}
return ~0;
}
/* Return lowest numbered clear bit in bitmap. */
always_inline uword
clib_bitmap_first_clear (uword * ai)