FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
receive_dpo.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /**
16  * @brief
17  * The data-path object representing receiveing the packet, i.e. it's for-us
18  */
19 #include <vlib/vlib.h>
20 #include <vnet/ip/ip.h>
21 #include <vnet/dpo/receive_dpo.h>
22 
23 /**
24  * @brief pool of all receive DPOs
25  */
27 
28 int
30 {
31  return (dpo->dpoi_type == DPO_RECEIVE);
32 }
33 
34 static receive_dpo_t *
36 {
37  receive_dpo_t *rd;
38 
39  pool_get_aligned(receive_dpo_pool, rd, CLIB_CACHE_LINE_BYTES);
40  clib_memset(rd, 0, sizeof(*rd));
41 
42  return (rd);
43 }
44 
45 static receive_dpo_t *
47 {
48  ASSERT(DPO_RECEIVE == dpo->dpoi_type);
49 
50  return (receive_dpo_get(dpo->dpoi_index));
51 }
52 
53 
54 /*
55  * receive_dpo_add_or_lock
56  *
57  * The next_hop address here is used for source address selection in the DP.
58  * The local adj is added to an interface's receive prefix, the next-hop
59  * passed here is the local prefix on the same interface.
60  */
61 void
64  const ip46_address_t *nh_addr,
65  dpo_id_t *dpo)
66 {
67  receive_dpo_t *rd;
68 
69  rd = receive_dpo_alloc();
70 
72  if (NULL != nh_addr)
73  {
74  rd->rd_addr = *nh_addr;
75  }
76 
77  dpo_set(dpo, DPO_RECEIVE, proto, (rd - receive_dpo_pool));
78 }
79 
80 static void
82 {
83  receive_dpo_t *rd;
84 
85  rd = receive_dpo_get_from_dpo(dpo);
86  rd->rd_locks++;
87 }
88 
89 static void
91 {
92  receive_dpo_t *rd;
93 
94  rd = receive_dpo_get_from_dpo(dpo);
95  rd->rd_locks--;
96 
97  if (0 == rd->rd_locks)
98  {
99  pool_put(receive_dpo_pool, rd);
100  }
101 }
102 
103 static u8*
104 format_receive_dpo (u8 *s, va_list *ap)
105 {
106  CLIB_UNUSED(index_t index) = va_arg(*ap, index_t);
107  CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
108  vnet_main_t * vnm = vnet_get_main();
109  receive_dpo_t *rd;
110 
111  if (pool_is_free_index(receive_dpo_pool, index))
112  {
113  return (format(s, "dpo-receive DELETED"));
114  }
115 
116  rd = receive_dpo_get(index);
117 
118  if (~0 != rd->rd_sw_if_index)
119  {
120  return (format(s, "dpo-receive: %U on %U",
124  }
125  else
126  {
127  return (format(s, "dpo-receive"));
128  }
129 }
130 
131 static void
133 {
134  fib_show_memory_usage("Receive",
135  pool_elts(receive_dpo_pool),
136  pool_len(receive_dpo_pool),
137  sizeof(receive_dpo_t));
138 }
139 
140 const static dpo_vft_t receive_vft = {
142  .dv_unlock = receive_dpo_unlock,
143  .dv_format = format_receive_dpo,
144  .dv_mem_show = receive_dpo_mem_show,
145 };
146 
147 /**
148  * @brief The per-protocol VLIB graph nodes that are assigned to a receive
149  * object.
150  *
151  * this means that these graph nodes are ones from which a receive is the
152  * parent object in the DPO-graph.
153  */
154 const static char* const receive_ip4_nodes[] =
155 {
156  "ip4-local",
157  NULL,
158 };
159 const static char* const receive_ip6_nodes[] =
160 {
161  "ip6-local",
162  NULL,
163 };
164 
165 const static char* const * const receive_nodes[DPO_PROTO_NUM] =
166 {
169  [DPO_PROTO_MPLS] = NULL,
170 };
171 
172 void
174 {
175  dpo_register(DPO_RECEIVE, &receive_vft, receive_nodes);
176 }
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:406
u8 proto
Definition: acl_types.api:47
void receive_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, const ip46_address_t *nh_addr, dpo_id_t *dpo)
Definition: receive_dpo.c:62
#define CLIB_UNUSED(x)
Definition: clib.h:82
A virtual function table regisitered for a DPO type.
Definition: dpo.h:401
static void receive_dpo_unlock(dpo_id_t *dpo)
Definition: receive_dpo.c:90
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static u8 * format_receive_dpo(u8 *s, va_list *ap)
Definition: receive_dpo.c:104
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
static const char *const receive_ip4_nodes[]
The per-protocol VLIB graph nodes that are assigned to a receive object.
Definition: receive_dpo.c:154
unsigned char u8
Definition: types.h:56
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
static receive_dpo_t * receive_dpo_get_from_dpo(const dpo_id_t *dpo)
Definition: receive_dpo.c:46
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:322
vl_api_interface_index_t sw_if_index
Definition: gre.api:59
void receive_dpo_module_init(void)
Definition: receive_dpo.c:173
void fib_show_memory_usage(const char *name, u32 in_use_elts, u32 allocd_elts, size_t size_elt)
Show the memory usage for a type.
Definition: fib_node.c:220
unsigned int u32
Definition: types.h:88
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
int dpo_is_receive(const dpo_id_t *dpo)
Definition: receive_dpo.c:29
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:170
format_function_t format_vnet_sw_interface_name
dpo_type_t dpoi_type
the type
Definition: dpo.h:174
static const char *const *const receive_nodes[DPO_PROTO_NUM]
Definition: receive_dpo.c:165
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:287
static void receive_dpo_lock(dpo_id_t *dpo)
Definition: receive_dpo.c:81
format_function_t format_ip46_address
Definition: ip46_address.h:50
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:231
static receive_dpo_t * receive_dpo_alloc(void)
Definition: receive_dpo.c:35
static const char *const receive_ip6_nodes[]
Definition: receive_dpo.c:159
static receive_dpo_t * receive_dpo_get(index_t index)
Definition: receive_dpo.h:65
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:284
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
Definition: dpo.c:186
#define ASSERT(truth)
u32 rd_sw_if_index
The Software interface index on which traffic is received.
Definition: receive_dpo.h:37
u8 nh_addr[16]
Definition: lisp_gpe.api:233
The data-path object representing receiveing the packet, i.e.
Definition: receive_dpo.h:26
#define DPO_PROTO_NUM
Definition: dpo.h:70
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
receive_dpo_t * receive_dpo_pool
The data-path object representing receiveing the packet, i.e.
Definition: receive_dpo.c:26
ip46_address_t rd_addr
The address on the receive interface.
Definition: receive_dpo.h:42
static void receive_dpo_mem_show(void)
Definition: receive_dpo.c:132
u16 rd_locks
number oflocks.
Definition: receive_dpo.h:47
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128