FD.io VPP  v18.01.2-1-g9b554f3
Vector Packet Processing
interface_cmds.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 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 #include "vom/interface_cmds.hpp"
17 #include "vom/cmd.hpp"
18 
24 
25 namespace VOM {
26 namespace interface_cmds {
28  const std::string& name)
29  : create_cmd(item, name)
30 {
31 }
32 
33 rc_t
35 {
36  msg_t req(con.ctx(), std::ref(*this));
37 
38  VAPI_CALL(req.execute());
39 
40  m_hw_item = wait();
41 
42  if (m_hw_item.rc() == rc_t::OK) {
44  }
45 
46  return rc_t::OK;
47 }
48 std::string
50 {
51  std::ostringstream s;
52  s << "loopback-itf-create: " << m_hw_item.to_string() << " name:" << m_name;
53 
54  return (s.str());
55 }
56 
58  const std::string& name)
59  : create_cmd(item, name)
60 {
61 }
62 
63 rc_t
65 {
66  msg_t req(con.ctx(), std::ref(*this));
67 
68  auto& payload = req.get_request().get_payload();
69 
70  payload.use_random_hw_addr = 1;
71  memset(payload.host_if_name, 0, sizeof(payload.host_if_name));
72  memcpy(payload.host_if_name, m_name.c_str(),
73  std::min(m_name.length(), sizeof(payload.host_if_name)));
74 
75  VAPI_CALL(req.execute());
76 
77  m_hw_item = wait();
78 
79  if (m_hw_item.rc() == rc_t::OK) {
81  }
82 
83  return rc_t::OK;
84 }
85 std::string
87 {
88  std::ostringstream s;
89  s << "af-packet-itf-create: " << m_hw_item.to_string() << " name:" << m_name;
90 
91  return (s.str());
92 }
93 
95  const std::string& name)
96  : create_cmd(item, name)
97 {
98 }
99 
100 rc_t
102 {
103  msg_t req(con.ctx(), std::ref(*this));
104 
105  auto& payload = req.get_request().get_payload();
106 
107  memset(payload.tap_name, 0, sizeof(payload.tap_name));
108  memcpy(payload.tap_name, m_name.c_str(),
109  std::min(m_name.length(), sizeof(payload.tap_name)));
110  payload.use_random_mac = 1;
111 
112  VAPI_CALL(req.execute());
113 
114  m_hw_item = wait();
115 
116  if (m_hw_item.rc() == rc_t::OK) {
118  }
119 
120  return rc_t::OK;
121 }
122 
123 std::string
125 {
126  std::ostringstream s;
127  s << "tap-intf-create: " << m_hw_item.to_string() << " name:" << m_name;
128 
129  return (s.str());
130 }
131 
133  : delete_cmd(item)
134 {
135 }
136 
137 rc_t
139 {
140  msg_t req(con.ctx(), std::ref(*this));
141 
142  auto& payload = req.get_request().get_payload();
143  payload.sw_if_index = m_hw_item.data().value();
144 
145  VAPI_CALL(req.execute());
146 
147  wait();
149 
151  return rc_t::OK;
152 }
153 
154 std::string
156 {
157  std::ostringstream s;
158  s << "loopback-itf-delete: " << m_hw_item.to_string();
159 
160  return (s.str());
161 }
162 
164  const std::string& name)
165  : delete_cmd(item, name)
166 {
167 }
168 
169 rc_t
171 {
172  msg_t req(con.ctx(), std::ref(*this));
173 
174  auto& payload = req.get_request().get_payload();
175  memset(payload.host_if_name, 0, sizeof(payload.host_if_name));
176  memcpy(payload.host_if_name, m_name.c_str(),
177  std::min(m_name.length(), sizeof(payload.host_if_name)));
178 
179  VAPI_CALL(req.execute());
180 
181  wait();
183 
185  return rc_t::OK;
186 }
187 std::string
189 {
190  std::ostringstream s;
191  s << "af_packet-itf-delete: " << m_hw_item.to_string();
192 
193  return (s.str());
194 }
195 
197  : delete_cmd(item)
198 {
199 }
200 
201 rc_t
203 {
204  // finally... call VPP
205 
207  return rc_t::OK;
208 }
209 std::string
211 {
212  std::ostringstream s;
213  s << "tap-itf-delete: " << m_hw_item.to_string();
214 
215  return (s.str());
216 }
217 
219  const HW::item<handle_t>& hdl)
220  : rpc_cmd(state)
221  , m_hdl(hdl)
222 {
223 }
224 
225 bool
227 {
228  return ((m_hdl == other.m_hdl) && (m_hw_item == other.m_hw_item));
229 }
230 
231 rc_t
233 {
234  msg_t req(con.ctx(), std::ref(*this));
235 
236  auto& payload = req.get_request().get_payload();
237  payload.sw_if_index = m_hdl.data().value();
238  payload.admin_up_down = m_hw_item.data().value();
239 
240  VAPI_CALL(req.execute());
241 
242  m_hw_item.set(wait());
243 
244  return rc_t::OK;
245 }
246 
247 std::string
249 {
250  std::ostringstream s;
251  s << "itf-state-change: " << m_hw_item.to_string()
252  << " hdl:" << m_hdl.to_string();
253  return (s.str());
254 }
255 
257  const l3_proto_t& proto,
258  const HW::item<handle_t>& hdl)
259  : rpc_cmd(table)
260  , m_hdl(hdl)
261  , m_proto(proto)
262 {
263 }
264 
265 bool
267 {
268  return ((m_hdl == other.m_hdl) && (m_proto == other.m_proto) &&
269  (m_hw_item == other.m_hw_item));
270 }
271 
272 rc_t
274 {
275  msg_t req(con.ctx(), std::ref(*this));
276 
277  auto& payload = req.get_request().get_payload();
278  payload.sw_if_index = m_hdl.data().value();
279  payload.is_ipv6 = m_proto.is_ipv6();
280  payload.vrf_id = m_hw_item.data();
281 
282  VAPI_CALL(req.execute());
283 
284  m_hw_item.set(wait());
285 
286  return (rc_t::OK);
287 }
288 
289 std::string
291 {
292  std::ostringstream s;
293  s << "itf-set-table: " << m_hw_item.to_string()
294  << " proto:" << m_proto.to_string() << " hdl:" << m_hdl.to_string();
295  return (s.str());
296 }
297 
299  const HW::item<handle_t>& hdl)
300  : rpc_cmd(mac)
301  , m_hdl(hdl)
302 {
303 }
304 
305 bool
307 {
308  return ((m_hdl == other.m_hdl) && (m_hw_item == other.m_hw_item));
309 }
310 
311 rc_t
313 {
314  msg_t req(con.ctx(), std::ref(*this));
315 
316  auto& payload = req.get_request().get_payload();
317  payload.sw_if_index = m_hdl.data().value();
318  m_hw_item.data().to_mac().to_bytes(payload.mac_address,
319  sizeof(payload.mac_address));
320 
321  VAPI_CALL(req.execute());
322 
323  m_hw_item.set(wait());
324 
325  return (rc_t::OK);
326 }
327 
328 std::string
330 {
331  std::ostringstream s;
332  s << "itf-set-mac: " << m_hw_item.to_string() << " hdl:" << m_hdl.to_string();
333  return (s.str());
334 }
335 
337  : event_cmd(el.status())
338  , m_listener(el)
339 {
340 }
341 
342 bool
344 {
345  return (true);
346 }
347 
348 rc_t
350 {
351  /*
352  * First set the call back to handle the interface events
353  */
354  m_reg.reset(new reg_t(con.ctx(), std::ref(*(static_cast<event_cmd*>(this)))));
355 
356  /*
357  * then send the request to enable them
358  */
359  msg_t req(con.ctx(), std::ref(*(static_cast<rpc_cmd*>(this))));
360 
361  auto& payload = req.get_request().get_payload();
362  payload.enable_disable = 1;
363  payload.pid = getpid();
364 
365  VAPI_CALL(req.execute());
366 
367  wait();
368 
369  return (rc_t::OK);
370 }
371 
372 void
374 {
375  /*
376  * disable interface events.
377  */
378  msg_t req(con.ctx(), std::ref(*(static_cast<rpc_cmd*>(this))));
379 
380  auto& payload = req.get_request().get_payload();
381  payload.enable_disable = 0;
382  payload.pid = getpid();
383 
384  VAPI_CALL(req.execute());
385 
386  wait();
387 }
388 
389 void
391 {
392  m_listener.handle_interface_event(this);
393 }
394 
395 std::string
397 {
398  return ("itf-events");
399 }
400 
401 /**
402  * Interface statistics
403  */
405  const handle_t& handle)
406  : event_cmd(el.status())
407  , m_listener(el)
408  , m_swifindex(handle)
409 {
410 }
411 
412 bool
414 {
415  return (true);
416 }
417 
418 rc_t
420 {
421  /*
422  * First set the call back to handle the interface stats
423  */
424  m_reg.reset(new reg_t(con.ctx(), std::ref(*(static_cast<event_cmd*>(this)))));
425 
426  /*
427  * then send the request to enable them
428  */
429  msg_t req(con.ctx(), 1, std::ref(*(static_cast<rpc_cmd*>(this))));
430 
431  auto& payload = req.get_request().get_payload();
432  payload.enable_disable = 1;
433  payload.pid = getpid();
434  payload.num = 1;
435 
436  payload.sw_ifs[0] = m_swifindex.value();
437 
438  VAPI_CALL(req.execute());
439 
440  wait();
441 
442  return (rc_t::OK);
443 }
444 
445 void
447 {
448  /*
449  * disable interface stats.
450  */
451  msg_t req(con.ctx(), 1, std::ref(*(static_cast<rpc_cmd*>(this))));
452 
453  auto& payload = req.get_request().get_payload();
454  payload.enable_disable = 0;
455  payload.pid = getpid();
456  payload.num = 1;
457  payload.sw_ifs[0] = m_swifindex.value();
458 
459  VAPI_CALL(req.execute());
460 
461  wait();
462 }
463 
464 void
466 {
467  m_listener.handle_interface_stat(this);
468 }
469 
470 std::string
472 {
473  std::ostringstream s;
474  s << "itf-stats-enable itf:" << m_swifindex.to_string();
475  return (s.str());
476 }
477 
479 {
480 }
481 
483  : rpc_cmd(m_res)
484  , m_swifindex(handle)
485 {
486 }
487 
488 bool
490 {
491  return (true);
492 }
493 
494 rc_t
496 {
497  /*
498  * then send the request to enable them
499  */
500  msg_t req(con.ctx(), 1, std::ref(*this));
501 
502  auto& payload = req.get_request().get_payload();
503  payload.enable_disable = 0;
504  payload.pid = getpid();
505  payload.num = 1;
506 
507  payload.sw_ifs[0] = m_swifindex.value();
508 
509  VAPI_CALL(req.execute());
510 
511  wait();
512 
513  return (rc_t::OK);
514 }
515 
516 std::string
518 {
519  std::ostringstream s;
520  s << "itf-stats-disable itf:" << m_swifindex.to_string();
521  return (s.str());
522 }
523 
524 bool
525 dump_cmd::operator==(const dump_cmd& other) const
526 {
527  return (true);
528 }
529 
530 rc_t
532 {
533  m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
534 
535  auto& payload = m_dump->get_request().get_payload();
536  payload.name_filter_valid = 0;
537 
538  VAPI_CALL(m_dump->execute());
539 
540  wait();
541 
542  return rc_t::OK;
543 }
544 
545 std::string
547 {
548  return ("itf-dump");
549 }
550 
551 set_tag::set_tag(HW::item<handle_t>& item, const std::string& name)
552  : rpc_cmd(item)
553  , m_name(name)
554 {
555 }
556 
557 rc_t
559 {
560  msg_t req(con.ctx(), std::ref(*this));
561 
562  auto& payload = req.get_request().get_payload();
563  payload.is_add = 1;
564  payload.sw_if_index = m_hw_item.data().value();
565  memcpy(payload.tag, m_name.c_str(), m_name.length());
566 
567  VAPI_CALL(req.execute());
568 
569  wait();
570 
571  return rc_t::OK;
572 }
573 std::string
575 {
576  std::ostringstream s;
577  s << "itf-set-tag: " << m_hw_item.to_string() << " name:" << m_name;
578 
579  return (s.str());
580 }
581 
582 bool
584 {
585  return ((m_name == o.m_name) && (m_hw_item.data() == o.m_hw_item.data()));
586 }
587 }; // namespace interface_cmds
588 }; // namespace VOM
589 
590 /*
591  * fd.io coding-style-patch-verification: ON
592  *
593  * Local Variables:
594  * eval: (c-set-style "mozilla")
595  * End:
596  */
bool operator==(const set_tag &i) const
Comparison operator - only used for UT.
std::string to_string() const
convert to string format for debug purposes
static const rc_t NOOP
The HW write/update action was/has not been attempted.
Definition: types.hpp:101
void retire(connection &con)
Retires the command - unsubscribe from the events.
delete_cmd(HW::item< handle_t > &item, const std::string &name)
Definition: interface.hpp:307
HW::item< handle_t > & m_hw_item
A reference to an object&#39;s HW::item that the command will update.
Definition: rpc_cmd.hpp:131
bool operator==(const set_mac_cmd &i) const
Comparison operator - only used for UT.
std::string to_string() const
convert to string format for debug purposes
A command class represents our desire to recieve interface stats.
rc_t issue(connection &con)
Issue the command to VPP/HW.
DEFINE_VAPI_MSG_IDS_AF_PACKET_API_JSON
int value() const
Return the value of the enum - same as integer conversion.
Definition: enum_base.hpp:67
void remove_interface()
add the created interface to the DB
Definition: interface.hpp:340
uint32_t value() const
get the value of the handle
Definition: types.cpp:92
set_tag(HW::item< handle_t > &item, const std::string &name)
Constructor taking the HW::item to update.
std::string to_string() const
convert to string format for debug purposes
bool operator==(const set_table_cmd &i) const
Comparison operator - only used for UT.
void notify()
Called when it&#39;s time to poke the listeners.
rc_t issue(connection &con)
Issue the command to VPP/HW.
stats_disable_cmd(const handle_t &handle)
Constructor taking the listner to notify.
A command class to set tag on interfaces.
Error codes that VPP will return during a HW write.
Definition: types.hpp:84
std::string to_string() const
convert to string format for debug purposes
std::string to_string() const
convert to string format for debug purposes
Types belonging to Routing.
Definition: prefix.hpp:32
set_mac_cmd(HW::item< l2_address_t > &item, const HW::item< handle_t > &h)
Constructor taking the HW::item to update and the handle of the interface.
create_cmd(HW::item< handle_t > &item, const std::string &name)
Definition: interface.hpp:239
virtual void handle_interface_event(interface_cmds::events_cmd *cmd)=0
Virtual function called on the listener when the command has data ready to process.
std::string to_string() const
convert to string format for debug purposes
std::string to_string() const
convert to string format for debug purposes
std::string to_string() const
convert to string format for debug purposes
Definition: hw.hpp:160
T & data()
Return the data read/written.
Definition: hw.hpp:108
rc_t issue(connection &con)
Issue the command to VPP/HW.
DEFINE_VAPI_MSG_IDS_VPE_API_JSON
std::string to_string() const
convert to string format for debug purposes
Definition: types.cpp:68
rc_t issue(connection &con)
Issue the command to VPP/HW.
std::string to_string() const
convert to string format for debug purposes
A command class that binds an interface to an L3 table.
const std::string & m_name
The name of the interface to be created.
Definition: interface.hpp:297
dump_cmd()
Default Constructor.
A representation of the connection to VPP.
Definition: connection.hpp:33
bool operator==(const events_cmd &i) const
Comparison operator - only used for UT.
set_table_cmd(HW::item< route::table_id_t > &item, const l3_proto_t &proto, const HW::item< handle_t > &h)
Constructor taking the HW::item to update and the name handle of the interface whose table is to chan...
A class that listens to interface Stats.
Definition: interface.hpp:381
std::string to_string() const
convert to string format for debug purposes
tap_create_cmd(HW::item< handle_t > &item, const std::string &name)
Constructor taking the HW::item to update and the name of the interface to create.
rc_t issue(connection &con)
Issue the command to VPP/HW.
std::string to_string() const
convert to string format for debug purposes
state_change_cmd(HW::item< interface::admin_state_t > &s, const HW::item< handle_t > &h)
Constructor taking the HW::item to update and the name handle of the interface whose state is to chan...
rc_t issue(connection &con)
Issue the command to VPP/HW.
rc_t issue(connection &con)
Issue the command to VPP/HW.
HW::item< handle_t > & item()
return the HW item the command updates
Definition: rpc_cmd.hpp:64
A class that listens to interface Events.
Definition: interface.hpp:352
A base class for all RPC commands to VPP.
Definition: rpc_cmd.hpp:38
af_packet_delete_cmd(HW::item< handle_t > &item, const std::string &name)
Constructor taking the HW::item to update and the name of the interface to delete.
bool operator==(const stats_enable_cmd &i) const
Comparison operator - only used for UT.
#define VAPI_CALL(_stmt)
Convenince wrapper macro for error handling in VAPI sends.
Definition: types.hpp:29
A cmd class that changes the admin state.
std::string to_string() const
convert to string format for debug purposes
std::string to_string() const
convert to string format for debug purposes
af_packet_create_cmd(HW::item< handle_t > &item, const std::string &name)
Constructor taking the HW::item to update and the name of the interface to create.
A command class that binds an interface to an L3 table.
bool operator==(const dump_cmd &i) const
Comparison operator - only used for UT.
A command class represents our desire to recieve interface events.
stats_enable_cmd(interface::stat_listener &el, const handle_t &handle)
Constructor taking the listner to notify.
DEFINE_VAPI_MSG_IDS_STATS_API_JSON
std::unique_ptr< vapi::Event_registration< vapi::Sw_interface_event > > m_reg
The VAPI event registration.
Definition: event_cmd.hpp:100
rc_t issue(connection &con)
Issue the command to VPP/HW.
A type declaration of an interface handle in VPP.
Definition: types.hpp:164
vapi::Event_registration< vapi::Sw_interface_event > reg_t
Definition: event_cmd.hpp:59
rc_t issue(connection &con)
Issue the command to VPP/HW.
static const rc_t OK
The HW write was successfull.
Definition: types.hpp:106
bool operator==(const state_change_cmd &i) const
Comparison operator - only used for UT.
void notify()
Called when it&#39;s time to poke the listeners.
DEFINE_VAPI_MSG_IDS_TAP_API_JSON
vhost_vring_state_t state
Definition: vhost-user.h:82
std::string to_string() const
convert to string format for debug purposes
const std::string m_name
The name of the interface to be created.
Definition: interface.hpp:346
loopback_delete_cmd(HW::item< handle_t > &item)
Constructor taking the HW::item to update.
A command class represents our desire to recieve interface stats.
vapi::Connection & ctx()
Retrun the VAPI context the commands will use.
Definition: connection.cpp:51
void to_bytes(uint8_t *array, uint8_t len) const
Convert to byte array.
Definition: types.cpp:133
rc_t issue(connection &con)
Issue the command to VPP/HW.
void insert_interface()
add the created interface to the DB
Definition: interface.hpp:270
The VPP Object Model (VOM) library.
Definition: acl_binding.cpp:19
DEFINE_VAPI_MSG_IDS_INTERFACE_API_JSON
rc_t issue(connection &con)
Issue the command to VPP/HW.
void set(const rc_t &rc)
Set the HW return code - should only be called from the family of Command objects.
Definition: hw.hpp:124
tap_delete_cmd(HW::item< handle_t > &item)
Constructor taking the HW::item to update.
virtual void handle_interface_stat(interface_cmds::stats_enable_cmd *cmd)=0
Virtual function called on the listener when the command has data ready to process.
An Event command base class.
Definition: event_cmd.hpp:39
rc_t issue(connection &con)
Issue the command to VPP/HW.
const std::string & to_string() const
convert to string format for debug purposes
Definition: enum_base.hpp:36
void retire(connection &con)
Retires the command - unsubscribe from the stats.
rc_t issue(connection &con)
Issue the command to VPP/HW.
events_cmd(interface::event_listener &el)
Constructor taking the listner to notify.
A cmd class that Dumps all the Vpp interfaces.
std::string to_string() const
convert to string format for debug purposes
mac_address_t to_mac() const
MAC address conversion.
Definition: types.cpp:209
loopback_create_cmd(HW::item< handle_t > &item, const std::string &name)
Constructor taking the HW::item to update and the name of the interface to create.
bool operator==(const stats_disable_cmd &i) const
Comparison operator - only used for UT.
HW::item< handle_t > wait()
Wait on the commands promise.
Definition: rpc_cmd.hpp:89
bool is_ipv6()
Definition: prefix.cpp:35
rc_t issue(connection &con)
Issue the command to VPP/HW.