Line data Source code
1 : /*
2 : * Copyright (c) 2015 Juniper Networks, Inc. All rights reserved.
3 : */
4 :
5 : #include <uve/stats_manager.h>
6 : #include <uve/vn_uve_table.h>
7 : #include <uve/interface_uve_stats_table.h>
8 : #include <oper/vm_interface.h>
9 : #include <uve/agent_uve_stats.h>
10 :
11 1 : StatsManager::StatsManager(Agent* agent)
12 1 : : vrf_listener_id_(DBTableBase::kInvalidId),
13 1 : intf_listener_id_(DBTableBase::kInvalidId), agent_(agent),
14 1 : request_queue_(agent->task_scheduler()->GetTaskId("Agent::Uve"), 0,
15 : boost::bind(&StatsManager::RequestHandler, this, _1),
16 : DEFAULT_FUVE_REQUEST_QUEUE_SIZE),
17 1 : timer_(TimerManager::CreateTimer
18 1 : (*(agent->event_manager())->io_service(), "IntfFlowStatsUpdateTimer",
19 1 : TaskScheduler::GetInstance()->GetTaskId(kTaskFlowStatsUpdate), 1)) {
20 1 : request_queue_.SetBounded(true);
21 1 : AddNamelessVrfStatsEntry();
22 1 : }
23 :
24 2 : StatsManager::~StatsManager() {
25 2 : }
26 :
27 19 : void StatsManager::AddInterfaceStatsEntry(const Interface *intf) {
28 19 : InterfaceStatsTree::iterator it;
29 19 : it = if_stats_tree_.find(intf);
30 19 : if (it == if_stats_tree_.end()) {
31 19 : InterfaceStats stats;
32 19 : stats.name = intf->name();
33 19 : if_stats_tree_.insert(InterfaceStatsPair(intf, stats));
34 19 : }
35 19 : }
36 :
37 19 : void StatsManager::DelInterfaceStatsEntry(const Interface *intf) {
38 19 : InterfaceStatsTree::iterator it;
39 19 : it = if_stats_tree_.find(intf);
40 19 : if (it != if_stats_tree_.end()) {
41 19 : if_stats_tree_.erase(it);
42 : }
43 19 : }
44 :
45 1 : void StatsManager::AddNamelessVrfStatsEntry() {
46 1 : VrfStats stats;
47 1 : stats.name = GetNamelessVrf();
48 1 : vrf_stats_tree_.insert(VrfStatsPair(GetNamelessVrfId(), stats));
49 1 : }
50 :
51 14 : void StatsManager::AddUpdateVrfStatsEntry(const VrfEntry *vrf) {
52 14 : StatsManager::VrfIdToVrfStatsTree::iterator it;
53 14 : it = vrf_stats_tree_.find(vrf->vrf_id());
54 14 : if (it == vrf_stats_tree_.end()) {
55 3 : VrfStats stats;
56 3 : stats.name = vrf->GetName();
57 3 : vrf_stats_tree_.insert(VrfStatsPair(vrf->vrf_id(), stats));
58 3 : } else {
59 : /* Vrf could be deleted in agent oper DB but not in Kernel. To handle
60 : * this case we maintain vrfstats object in StatsManager even
61 : * when vrf is absent in agent oper DB. Since vrf could get deleted and
62 : * re-added we need to update the name in vrfstats object.
63 : */
64 11 : VrfStats *stats = &it->second;
65 11 : stats->name = vrf->GetName();
66 : }
67 14 : }
68 :
69 8 : void StatsManager::DelVrfStatsEntry(const VrfEntry *vrf) {
70 8 : StatsManager::VrfIdToVrfStatsTree::iterator it;
71 8 : it = vrf_stats_tree_.find(vrf->vrf_id());
72 8 : if (it != vrf_stats_tree_.end()) {
73 8 : VrfStats *stats = &it->second;
74 8 : stats->prev_discards = stats->k_discards;
75 8 : stats->prev_resolves = stats->k_resolves;
76 8 : stats->prev_receives = stats->k_receives;
77 8 : stats->prev_udp_mpls_tunnels = stats->k_udp_mpls_tunnels;
78 8 : stats->prev_udp_tunnels = stats->k_udp_tunnels;
79 8 : stats->prev_gre_mpls_tunnels = stats->k_gre_mpls_tunnels;
80 8 : stats->prev_fabric_composites = stats->k_fabric_composites;
81 8 : stats->prev_l2_mcast_composites = stats->k_l2_mcast_composites;
82 8 : stats->prev_ecmp_composites = stats->k_ecmp_composites;
83 8 : stats->prev_l2_encaps = stats->k_l2_encaps;
84 8 : stats->prev_encaps = stats->k_encaps;
85 8 : stats->prev_gros = stats->gros;
86 8 : stats->prev_diags = stats->diags;
87 8 : stats->prev_encap_composites = stats->encap_composites;
88 8 : stats->prev_evpn_composites = stats->evpn_composites;
89 8 : stats->prev_vrf_translates = stats->vrf_translates;
90 8 : stats->prev_vxlan_tunnels = stats->vxlan_tunnels;
91 8 : stats->prev_arp_virtual_proxy = stats->arp_virtual_proxy;
92 8 : stats->prev_arp_virtual_stitch = stats->arp_virtual_stitch;
93 8 : stats->prev_arp_virtual_flood = stats->arp_virtual_flood;
94 8 : stats->prev_arp_physical_stitch = stats->arp_physical_stitch;
95 8 : stats->prev_arp_tor_proxy = stats->arp_tor_proxy;
96 8 : stats->prev_arp_physical_flood = stats->arp_physical_flood;
97 8 : stats->prev_l2_receives = stats->l2_receives;
98 8 : stats->prev_uuc_floods = stats->uuc_floods;
99 : }
100 8 : }
101 :
102 0 : StatsManager::InterfaceStats *StatsManager::GetInterfaceStats
103 : (const Interface *intf) {
104 0 : StatsManager::InterfaceStatsTree::iterator it;
105 :
106 0 : it = if_stats_tree_.find(intf);
107 0 : if (it == if_stats_tree_.end()) {
108 0 : return NULL;
109 : }
110 :
111 0 : return &it->second;
112 : }
113 :
114 0 : StatsManager::VrfStats *StatsManager::GetVrfStats(int vrf_id) {
115 0 : StatsManager::VrfIdToVrfStatsTree::iterator it;
116 0 : it = vrf_stats_tree_.find(vrf_id);
117 0 : if (it == vrf_stats_tree_.end()) {
118 0 : return NULL;
119 : }
120 :
121 0 : return &it->second;
122 : }
123 :
124 82 : void StatsManager::InterfaceNotify(DBTablePartBase *part, DBEntryBase *e) {
125 82 : const Interface *intf = static_cast<const Interface *>(e);
126 82 : const VmInterface *vmi = NULL;
127 82 : bool set_state = false, reset_state = false;
128 :
129 : DBState *state = static_cast<DBState *>
130 82 : (e->GetState(part->parent(), intf_listener_id_));
131 82 : switch (intf->type()) {
132 67 : case Interface::VM_INTERFACE:
133 67 : vmi = static_cast<const VmInterface *>(intf);
134 67 : if (e->IsDeleted() || (vmi->IsUveActive() == false)) {
135 38 : if (state) {
136 15 : reset_state = true;
137 : }
138 : } else {
139 29 : if (!state) {
140 15 : set_state = true;
141 : }
142 : }
143 67 : break;
144 15 : default:
145 15 : if (e->IsDeleted()) {
146 4 : if (state) {
147 4 : reset_state = true;
148 : }
149 : } else {
150 11 : if (!state) {
151 4 : set_state = true;
152 : }
153 : }
154 : }
155 82 : if (set_state) {
156 19 : state = new DBState();
157 19 : e->SetState(part->parent(), intf_listener_id_, state);
158 19 : AddInterfaceStatsEntry(intf);
159 63 : } else if (reset_state) {
160 19 : DelInterfaceStatsEntry(intf);
161 19 : delete state;
162 19 : e->ClearState(part->parent(), intf_listener_id_);
163 : }
164 82 : return;
165 : }
166 :
167 79 : void StatsManager::VrfNotify(DBTablePartBase *part, DBEntryBase *e) {
168 79 : const VrfEntry *vrf = static_cast<const VrfEntry *>(e);
169 : DBState *state = static_cast<DBState *>
170 79 : (e->GetState(part->parent(), vrf_listener_id_));
171 79 : if (e->IsDeleted()) {
172 65 : if (state) {
173 8 : DelVrfStatsEntry(vrf);
174 8 : delete state;
175 8 : e->ClearState(part->parent(), vrf_listener_id_);
176 : }
177 : } else {
178 14 : if (!state) {
179 8 : state = new DBState();
180 8 : e->SetState(part->parent(), vrf_listener_id_, state);
181 : }
182 14 : AddUpdateVrfStatsEntry(vrf);
183 : }
184 79 : }
185 :
186 1 : void StatsManager::RegisterDBClients() {
187 1 : InterfaceTable *intf_table = agent_->interface_table();
188 1 : intf_listener_id_ = intf_table->Register
189 1 : (boost::bind(&StatsManager::InterfaceNotify, this, _1, _2));
190 :
191 1 : VrfTable *vrf_table = agent_->vrf_table();
192 1 : vrf_listener_id_ = vrf_table->Register
193 1 : (boost::bind(&StatsManager::VrfNotify, this, _1, _2));
194 1 : }
195 :
196 1 : void StatsManager::Shutdown(void) {
197 1 : agent_->vrf_table()->Unregister(vrf_listener_id_);
198 1 : agent_->interface_table()->Unregister(intf_listener_id_);
199 1 : request_queue_.Shutdown();
200 1 : if (timer_) {
201 1 : timer_->Cancel();
202 1 : TimerManager::DeleteTimer(timer_);
203 : }
204 1 : }
205 :
206 63 : StatsManager::InterfaceStats::InterfaceStats()
207 63 : : name(""), speed(0), duplexity(0), in_pkts(0), in_bytes(0),
208 63 : out_pkts(0), out_bytes(0), prev_in_bytes(0), prev_out_bytes(0)
209 63 : , prev_5min_in_bytes(0), prev_5min_out_bytes(0), stats_time(0), flow_info(),
210 63 : added(), deleted(), drop_stats_received(false) {
211 63 : }
212 :
213 0 : void StatsManager::InterfaceStats::UpdateStats
214 : (uint64_t in_b, uint64_t in_p, uint64_t out_b, uint64_t out_p) {
215 0 : in_bytes = in_b;
216 0 : in_pkts = in_p;
217 0 : out_bytes = out_b;
218 0 : out_pkts = out_p;
219 0 : }
220 :
221 0 : void StatsManager::InterfaceStats::UpdatePrevStats() {
222 0 : prev_in_bytes = in_bytes;
223 0 : prev_out_bytes = out_bytes;
224 0 : }
225 :
226 0 : void StatsManager::InterfaceStats::GetDiffStats(uint64_t *in_b,
227 : uint64_t *out_b) const {
228 0 : *in_b = in_bytes - prev_in_bytes;
229 0 : *out_b = out_bytes - prev_out_bytes;
230 0 : }
231 :
232 4 : StatsManager::VrfStats::VrfStats()
233 4 : : name(""), discards(0), resolves(0), receives(0), udp_tunnels(0),
234 4 : udp_mpls_tunnels(0), gre_mpls_tunnels(0), ecmp_composites(0),
235 4 : l2_mcast_composites(0), fabric_composites(0), encaps(0), l2_encaps(0),
236 4 : gros(0), diags(0), encap_composites(0), evpn_composites(0),
237 4 : vrf_translates(0), vxlan_tunnels(0), arp_virtual_proxy(0),
238 4 : arp_virtual_stitch(0), arp_virtual_flood(0), arp_physical_stitch(0),
239 4 : arp_tor_proxy(0), arp_physical_flood(0), l2_receives(0), uuc_floods(0),
240 4 : prev_discards(0), prev_resolves(0), prev_receives(0), prev_udp_tunnels(0),
241 4 : prev_udp_mpls_tunnels(0), prev_gre_mpls_tunnels(0), prev_ecmp_composites(0),
242 4 : prev_l2_mcast_composites(0), prev_fabric_composites(0), prev_encaps(0),
243 4 : prev_l2_encaps(0), prev_gros(0), prev_diags(0), prev_encap_composites(0),
244 4 : prev_evpn_composites(0), prev_vrf_translates(0), prev_vxlan_tunnels(0),
245 4 : prev_arp_virtual_proxy(0), prev_arp_virtual_stitch(0),
246 4 : prev_arp_virtual_flood(0), prev_arp_physical_stitch(0),
247 4 : prev_arp_tor_proxy(0), prev_arp_physical_flood(0), prev_l2_receives(0),
248 4 : prev_uuc_floods(0), k_discards(0), k_resolves(0), k_receives(0),
249 4 : k_udp_tunnels(0), k_udp_mpls_tunnels(0), k_gre_mpls_tunnels(0),
250 4 : k_ecmp_composites(0), k_l2_mcast_composites(0), k_fabric_composites(0),
251 4 : k_encaps(0), k_l2_encaps(0), k_gros(0), k_diags(0), k_encap_composites(0),
252 4 : k_evpn_composites(0), k_vrf_translates(0), k_vxlan_tunnels(0),
253 4 : k_arp_virtual_proxy(0), k_arp_virtual_stitch(0), k_arp_virtual_flood(0),
254 4 : k_arp_physical_stitch(0), k_arp_tor_proxy(0), k_arp_physical_flood(0),
255 4 : k_l2_receives(0), k_uuc_floods(0) {
256 4 : }
257 :
258 100 : void StatsManager::AddFlow(const FlowUveStatsRequest *req) {
259 100 : FlowAceTree::iterator it = flow_ace_tree_.find(req->uuid());
260 100 : AgentUveStats *uve = static_cast<AgentUveStats *>(agent_->uve());
261 : InterfaceUveStatsTable *itable = static_cast<InterfaceUveStatsTable *>
262 100 : (uve->interface_uve_table());
263 100 : VnUveTable *vtable = static_cast<VnUveTable *>(uve->vn_uve_table());
264 100 : FlowUveFwPolicyInfo fw_info = req->fw_policy_info();
265 100 : if (fw_info.is_valid_) {
266 71 : assert(fw_info.added_);
267 : }
268 100 : if (it == flow_ace_tree_.end()) {
269 44 : InterfaceStats stats;
270 44 : itable->IncrInterfaceAceStats(req);
271 44 : bool fw_valid = itable->IncrInterfaceEndpointHits(req->interface(),
272 : fw_info);
273 44 : fw_info.is_valid_ = fw_valid;
274 44 : vtable->IncrVnAceStats(req->vn_ace_info());
275 : FlowRuleMatchInfo info(req->interface(), req->sg_rule_uuid(), fw_info,
276 44 : req->vn_ace_info());
277 44 : flow_ace_tree_.insert(FlowAcePair(req->uuid(), info));
278 44 : } else {
279 56 : FlowRuleMatchInfo &info = it->second;
280 56 : bool intf_changed = false;
281 56 : const string old_itf = info.interface;
282 56 : if (req->interface() != info.interface) {
283 0 : info.interface = req->interface();
284 0 : intf_changed = true;
285 : }
286 56 : if (intf_changed || (req->sg_rule_uuid() != info.sg_rule_uuid)) {
287 24 : itable->IncrInterfaceAceStats(req);
288 24 : info.sg_rule_uuid = req->sg_rule_uuid();
289 : }
290 112 : if (intf_changed ||
291 56 : (fw_info.is_valid_ && !info.IsFwPolicyInfoEqual(fw_info))) {
292 : /* When there is change either in interface-name or key of
293 : * Endpoint record, treat it as delete for old key and add for new
294 : * key.
295 : * (a) Increment added counter for new interface and new key
296 : * (b) Increment deleted counter for old interface and old key
297 : * (c) Update flow to point to new key
298 : */
299 42 : if (itable->IncrInterfaceEndpointHits(req->interface(), fw_info)) {
300 : /* Increment deleted counter for old interface and old key */
301 0 : FlowUveFwPolicyInfo old_info = info.fw_policy_info;
302 0 : old_info.added_ = false;
303 0 : itable->IncrInterfaceEndpointHits(old_itf, old_info);
304 : /* Update the flow with new key of endpoint after delete
305 : * counter is incremented */
306 0 : info.fw_policy_info = fw_info;
307 0 : }
308 : }
309 56 : if (!info.IsVnAceInfoEqual(req->vn_ace_info())) {
310 10 : vtable->IncrVnAceStats(req->vn_ace_info());
311 10 : info.vn_ace_info = req->vn_ace_info();
312 : }
313 56 : }
314 100 : }
315 :
316 44 : void StatsManager::DeleteFlow(const FlowUveStatsRequest *req) {
317 44 : FlowAceTree::iterator it = flow_ace_tree_.find(req->uuid());
318 44 : if (it == flow_ace_tree_.end()) {
319 0 : return;
320 : }
321 44 : FlowRuleMatchInfo &old_fw_info = it->second;
322 44 : const FlowUveFwPolicyInfo &new_fw_info = req->fw_policy_info();
323 : /* Increment deleted counter only if add counter was incremented earlier
324 : * for this. This is determined by checking whether old and new keys are
325 : * equal */
326 44 : if (old_fw_info.IsFwPolicyInfoEqual(new_fw_info)) {
327 2 : AgentUveStats *uve = static_cast<AgentUveStats *>(agent_->uve());
328 : InterfaceUveStatsTable *itable = static_cast<InterfaceUveStatsTable *>
329 2 : (uve->interface_uve_table());
330 2 : itable->IncrInterfaceEndpointHits(req->interface(), new_fw_info);
331 : }
332 44 : flow_ace_tree_.erase(it);
333 : }
334 :
335 144 : void StatsManager::EnqueueEvent(const boost::shared_ptr<FlowUveStatsRequest>
336 : &req) {
337 144 : request_queue_.Enqueue(req);
338 144 : }
339 :
340 144 : bool StatsManager::RequestHandler(boost::shared_ptr<FlowUveStatsRequest> req) {
341 144 : switch (req->event()) {
342 100 : case FlowUveStatsRequest::ADD_FLOW:
343 100 : AddFlow(req.get());
344 100 : break;
345 44 : case FlowUveStatsRequest::DELETE_FLOW:
346 44 : DeleteFlow(req.get());
347 44 : break;
348 0 : default:
349 0 : assert(0);
350 : }
351 144 : return true;
352 : }
353 :
354 0 : bool StatsManager::BuildFlowRate(AgentStats::FlowCounters &created,
355 : AgentStats::FlowCounters &aged,
356 : FlowRateComputeInfo &flow_info,
357 : VrouterFlowRate &flow_rate) const {
358 0 : uint64_t max_add_rate = 0, min_add_rate = 0;
359 0 : uint64_t max_del_rate = 0, min_del_rate = 0;
360 0 : uint64_t cur_time = UTCTimestampUsec();
361 0 : if (flow_info.prev_time_) {
362 0 : uint64_t diff_time = cur_time - flow_info.prev_time_;
363 0 : uint64_t diff_secs = diff_time / 1000000;
364 0 : if (diff_secs) {
365 0 : uint64_t created_flows = created.prev_flow_count -
366 0 : flow_info.prev_flow_created_;
367 0 : uint64_t aged_flows = aged.prev_flow_count -
368 0 : flow_info.prev_flow_aged_;
369 : //Flow setup/delete rate are always sent
370 0 : if (created_flows) {
371 0 : max_add_rate = created.max_flows_per_second;
372 0 : min_add_rate = created.min_flows_per_second;
373 0 : if (max_add_rate == AgentStats::kInvalidFlowCount) {
374 0 : LOG(WARN, "Invalid max_flow_adds_per_second " << max_add_rate);
375 0 : max_add_rate = 0;
376 : }
377 0 : if (min_add_rate == AgentStats::kInvalidFlowCount) {
378 0 : LOG(WARN, "Invalid min_flow_adds_per_second " << min_add_rate);
379 0 : min_add_rate = 0;
380 : }
381 : }
382 0 : if (aged_flows) {
383 0 : max_del_rate = aged.max_flows_per_second;
384 0 : min_del_rate = aged.min_flows_per_second;
385 0 : if (max_del_rate == AgentStats::kInvalidFlowCount) {
386 0 : LOG(WARN, "Invalid max_flow_deletes_per_second " << max_del_rate);
387 0 : max_del_rate = 0;
388 : }
389 0 : if (min_del_rate == AgentStats::kInvalidFlowCount) {
390 0 : LOG(WARN, "Invalid min_flow_deletes_per_second " << min_del_rate);
391 0 : min_del_rate = 0;
392 : }
393 : }
394 :
395 0 : flow_rate.set_added_flows(created_flows);
396 0 : flow_rate.set_max_flow_adds_per_second(max_add_rate);
397 0 : flow_rate.set_min_flow_adds_per_second(min_add_rate);
398 0 : flow_rate.set_deleted_flows(aged_flows);
399 0 : flow_rate.set_max_flow_deletes_per_second(max_del_rate);
400 0 : flow_rate.set_min_flow_deletes_per_second(min_del_rate);
401 0 : agent_->stats()->ResetFlowMinMaxStats(created);
402 0 : agent_->stats()->ResetFlowMinMaxStats(aged);
403 0 : flow_info.prev_time_ = cur_time;
404 0 : flow_info.prev_flow_created_ = created.prev_flow_count;
405 0 : flow_info.prev_flow_aged_ = aged.prev_flow_count;
406 0 : flow_rate.set_hold_flows(agent_->stats()->hold_flow_count());
407 0 : return true;
408 : }
409 : } else {
410 0 : flow_info.prev_time_ = cur_time;
411 : }
412 0 : return false;
413 : }
414 :
415 0 : bool StatsManager::FlowStatsUpdate() {
416 0 : InterfaceStatsTree::iterator it;
417 0 : it = if_stats_tree_.begin();
418 0 : while (it != if_stats_tree_.end()) {
419 0 : InterfaceStats &s = it->second;
420 0 : uint64_t created = 0, aged = 0;
421 : uint32_t dummy; //not used
422 0 : agent_->pkt()->get_flow_proto()->InterfaceFlowCount(it->first, &created,
423 : &aged, &dummy);
424 0 : agent_->stats()->UpdateFlowMinMaxStats(created, s.added);
425 0 : agent_->stats()->UpdateFlowMinMaxStats(aged, s.deleted);
426 0 : ++it;
427 : }
428 0 : return true;
429 : }
430 :
431 1 : void StatsManager::InitDone() {
432 1 : timer_->Start(agent_->stats()->flow_stats_update_timeout(),
433 : boost::bind(&StatsManager::FlowStatsUpdate, this));
434 1 : }
435 :
436 0 : void StatsManager::BuildDropStats(const vr_drop_stats_req &req,
437 : AgentDropStats &ds) const {
438 0 : ds.set_ds_discard(req.get_vds_discard());
439 0 : uint64_t drop_pkts = ds.get_ds_discard();
440 :
441 0 : ds.set_ds_pull(req.get_vds_pull());
442 0 : drop_pkts += ds.get_ds_pull();
443 :
444 0 : ds.set_ds_invalid_if(req.get_vds_invalid_if());
445 0 : drop_pkts += ds.get_ds_invalid_if();
446 :
447 0 : ds.set_ds_invalid_arp(req.get_vds_invalid_arp());
448 0 : drop_pkts += ds.get_ds_invalid_arp();
449 :
450 0 : ds.set_ds_trap_no_if(req.get_vds_trap_no_if());
451 0 : drop_pkts += ds.get_ds_trap_no_if();
452 :
453 0 : ds.set_ds_nowhere_to_go(req.get_vds_nowhere_to_go());
454 0 : drop_pkts += ds.get_ds_nowhere_to_go();
455 :
456 0 : ds.set_ds_flow_queue_limit_exceeded(req.get_vds_flow_queue_limit_exceeded());
457 0 : drop_pkts += ds.get_ds_flow_queue_limit_exceeded();
458 :
459 0 : ds.set_ds_flow_no_memory(req.get_vds_flow_no_memory());
460 0 : drop_pkts += ds.get_ds_flow_no_memory();
461 :
462 0 : ds.set_ds_flow_invalid_protocol(req.get_vds_flow_invalid_protocol());
463 0 : drop_pkts += ds.get_ds_flow_invalid_protocol();
464 :
465 0 : ds.set_ds_flow_nat_no_rflow(req.get_vds_flow_nat_no_rflow());
466 0 : drop_pkts += ds.get_ds_flow_nat_no_rflow();
467 :
468 0 : ds.set_ds_flow_action_drop(req.get_vds_flow_action_drop());
469 0 : drop_pkts += ds.get_ds_flow_action_drop();
470 :
471 0 : ds.set_ds_flow_action_invalid(req.get_vds_flow_action_invalid());
472 0 : drop_pkts += ds.get_ds_flow_action_invalid();
473 :
474 0 : ds.set_ds_flow_unusable(req.get_vds_flow_unusable());
475 0 : drop_pkts += ds.get_ds_flow_unusable();
476 :
477 0 : ds.set_ds_flow_table_full(req.get_vds_flow_table_full());
478 0 : drop_pkts += ds.get_ds_flow_table_full();
479 :
480 0 : ds.set_ds_interface_tx_discard(req.get_vds_interface_tx_discard());
481 0 : drop_pkts += ds.get_ds_interface_tx_discard();
482 :
483 0 : ds.set_ds_interface_drop(req.get_vds_interface_drop());
484 0 : drop_pkts += ds.get_ds_interface_drop();
485 :
486 0 : ds.set_ds_duplicated(req.get_vds_duplicated());
487 0 : drop_pkts += ds.get_ds_duplicated();
488 :
489 0 : ds.set_ds_push(req.get_vds_push());
490 0 : drop_pkts += ds.get_ds_push();
491 :
492 0 : ds.set_ds_ttl_exceeded(req.get_vds_ttl_exceeded());
493 0 : drop_pkts += ds.get_ds_ttl_exceeded();
494 :
495 0 : ds.set_ds_invalid_nh(req.get_vds_invalid_nh());
496 0 : drop_pkts += ds.get_ds_invalid_nh();
497 :
498 0 : ds.set_ds_invalid_label(req.get_vds_invalid_label());
499 0 : drop_pkts += ds.get_ds_invalid_label();
500 :
501 0 : ds.set_ds_invalid_protocol(req.get_vds_invalid_protocol());
502 0 : drop_pkts += ds.get_ds_invalid_protocol();
503 :
504 0 : ds.set_ds_interface_rx_discard(req.get_vds_interface_rx_discard());
505 0 : drop_pkts += ds.get_ds_interface_rx_discard();
506 :
507 0 : ds.set_ds_invalid_mcast_source(req.get_vds_invalid_mcast_source());
508 0 : drop_pkts += ds.get_ds_invalid_mcast_source();
509 :
510 0 : ds.set_ds_head_alloc_fail(req.get_vds_head_alloc_fail());
511 0 : drop_pkts += ds.get_ds_head_alloc_fail();
512 :
513 0 : ds.set_ds_pcow_fail(req.get_vds_pcow_fail());
514 0 : drop_pkts += ds.get_ds_pcow_fail();
515 :
516 0 : ds.set_ds_mcast_clone_fail(req.get_vds_mcast_clone_fail());
517 0 : drop_pkts += ds.get_ds_mcast_clone_fail();
518 :
519 0 : ds.set_ds_mcast_df_bit(req.get_vds_mcast_df_bit());
520 0 : drop_pkts += ds.get_ds_mcast_df_bit();
521 :
522 0 : ds.set_ds_no_memory(req.get_vds_no_memory());
523 0 : drop_pkts += ds.get_ds_no_memory();
524 :
525 0 : ds.set_ds_rewrite_fail(req.get_vds_rewrite_fail());
526 0 : drop_pkts += ds.get_ds_rewrite_fail();
527 :
528 0 : ds.set_ds_misc(req.get_vds_misc());
529 0 : drop_pkts += ds.get_ds_misc();
530 :
531 0 : ds.set_ds_invalid_packet(req.get_vds_invalid_packet());
532 0 : drop_pkts += ds.get_ds_invalid_packet();
533 :
534 0 : ds.set_ds_cksum_err(req.get_vds_cksum_err());
535 0 : drop_pkts += ds.get_ds_cksum_err();
536 :
537 0 : ds.set_ds_no_fmd(req.get_vds_no_fmd());
538 0 : drop_pkts += ds.get_ds_no_fmd();
539 :
540 0 : ds.set_ds_invalid_vnid(req.get_vds_invalid_vnid());
541 0 : drop_pkts += ds.get_ds_invalid_vnid();
542 :
543 0 : ds.set_ds_frag_err(req.get_vds_frag_err());
544 0 : drop_pkts += ds.get_ds_frag_err();
545 :
546 0 : ds.set_ds_invalid_source(req.get_vds_invalid_source());
547 0 : drop_pkts += ds.get_ds_invalid_source();
548 :
549 0 : ds.set_ds_l2_no_route(req.get_vds_l2_no_route());
550 0 : drop_pkts += ds.get_ds_l2_no_route();
551 :
552 0 : ds.set_ds_fragment_queue_fail(req.get_vds_fragment_queue_fail());
553 0 : drop_pkts += ds.get_ds_fragment_queue_fail();
554 :
555 0 : ds.set_ds_vlan_fwd_tx(req.get_vds_vlan_fwd_tx());
556 0 : drop_pkts += ds.get_ds_vlan_fwd_tx();
557 :
558 0 : ds.set_ds_vlan_fwd_enq(req.get_vds_vlan_fwd_enq());
559 0 : drop_pkts += ds.get_ds_vlan_fwd_enq();
560 :
561 0 : ds.set_ds_drop_new_flow(req.get_vds_drop_new_flow());
562 0 : drop_pkts += ds.get_ds_drop_new_flow();
563 :
564 0 : ds.set_ds_flow_evict(req.get_vds_flow_evict());
565 0 : drop_pkts += ds.get_ds_flow_evict();
566 :
567 0 : ds.set_ds_trap_original(req.get_vds_trap_original());
568 0 : drop_pkts += ds.get_ds_trap_original();
569 :
570 0 : ds.set_ds_no_frag_entry(req.get_vds_no_frag_entry());
571 0 : drop_pkts += ds.get_ds_no_frag_entry();
572 :
573 0 : ds.set_ds_icmp_error(req.get_vds_icmp_error());
574 0 : drop_pkts += ds.get_ds_icmp_error();
575 :
576 0 : ds.set_ds_clone_fail(req.get_vds_clone_fail());
577 0 : drop_pkts += ds.get_ds_clone_fail();
578 :
579 0 : ds.set_ds_drop_pkts(drop_pkts);
580 0 : }
|
