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