extras/vom/vom/interface_cmds.cpp

   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
  19 DEFINE_VAPI_MSG_IDS_VPE_API_JSON;
  20 DEFINE_VAPI_MSG_IDS_INTERFACE_API_JSON;
  21 DEFINE_VAPI_MSG_IDS_AF_PACKET_API_JSON;
  22 DEFINE_VAPI_MSG_IDS_VHOST_USER_API_JSON;
  23 DEFINE_VAPI_MSG_IDS_STATS_API_JSON;
  24
  25 namespace VOM {
  26 namespace interface_cmds {
  27 loopback_create_cmd::loopback_create_cmd(HW::item<handle_t>& item,
  28                                          const std::string& name)
  29   : create_cmd(item, name)
  30 {
  31 }
  32
  33 rc_t
  34 loopback_create_cmd::issue(connection& con)
  35 {
  36   msg_t req(con.ctx(), std::ref(*this));
  37
  38   VAPI_CALL(req.execute());
  39
  40   wait();
  41
  42   if (m_hw_item.rc() == rc_t::OK) {
  43     insert_interface();
  44   }
  45
  46   return rc_t::OK;
  47 }
  48 std::string
  49 loopback_create_cmd::to_string() const
  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
  57 af_packet_create_cmd::af_packet_create_cmd(HW::item<handle_t>& item,
  58                                            const std::string& name)
  59   : create_cmd(item, name)
  60 {
  61 }
  62
  63 rc_t
  64 af_packet_create_cmd::issue(connection& con)
  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   wait();
  78
  79   if (m_hw_item.rc() == rc_t::OK) {
  80     insert_interface();
  81   }
  82
  83   return rc_t::OK;
  84 }
  85 std::string
  86 af_packet_create_cmd::to_string() const
  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
  94 vhost_create_cmd::vhost_create_cmd(HW::item<handle_t>& item,
  95                                    const std::string& name,
  96                                    const std::string& tag)
  97   : create_cmd(item, name)
  98   , m_tag(tag)
  99 {
 100 }
 101
 102 rc_t
 103 vhost_create_cmd::issue(connection& con)
 104 {
 105   msg_t req(con.ctx(), std::ref(*this));
 106
 107   auto& payload = req.get_request().get_payload();
 108   memset(payload.sock_filename, 0, sizeof(payload.sock_filename));
 109   memcpy(payload.sock_filename, m_name.c_str(),
 110          std::min(m_name.length(), sizeof(payload.sock_filename)));
 111   memset(payload.tag, 0, sizeof(payload.tag));
 112
 113   if (!m_tag.empty())
 114     memcpy(payload.tag, m_tag.c_str(),
 115            std::min(m_tag.length(), sizeof(payload.tag)));
 116
 117   payload.is_server = 0;
 118   payload.use_custom_mac = 0;
 119   payload.renumber = 0;
 120
 121   VAPI_CALL(req.execute());
 122
 123   wait();
 124
 125   if (m_hw_item.rc() == rc_t::OK) {
 126     insert_interface();
 127   }
 128
 129   return rc_t::OK;
 130 }
 131
 132 std::string
 133 vhost_create_cmd::to_string() const
 134 {
 135   std::ostringstream s;
 136   s << "vhost-intf-create: " << m_hw_item.to_string() << " name:" << m_name
 137     << " tag:" << m_tag;
 138
 139   return (s.str());
 140 }
 141
 142 loopback_delete_cmd::loopback_delete_cmd(HW::item<handle_t>& item)
 143   : delete_cmd(item)
 144 {
 145 }
 146
 147 rc_t
 148 loopback_delete_cmd::issue(connection& con)
 149 {
 150   msg_t req(con.ctx(), std::ref(*this));
 151
 152   auto& payload = req.get_request().get_payload();
 153   payload.sw_if_index = m_hw_item.data().value();
 154
 155   VAPI_CALL(req.execute());
 156
 157   wait();
 158   m_hw_item.set(rc_t::NOOP);
 159
 160   remove_interface();
 161   return rc_t::OK;
 162 }
 163
 164 std::string
 165 loopback_delete_cmd::to_string() const
 166 {
 167   std::ostringstream s;
 168   s << "loopback-itf-delete: " << m_hw_item.to_string();
 169
 170   return (s.str());
 171 }
 172
 173 af_packet_delete_cmd::af_packet_delete_cmd(HW::item<handle_t>& item,
 174                                            const std::string& name)
 175   : delete_cmd(item, name)
 176 {
 177 }
 178
 179 rc_t
 180 af_packet_delete_cmd::issue(connection& con)
 181 {
 182   msg_t req(con.ctx(), std::ref(*this));
 183
 184   auto& payload = req.get_request().get_payload();
 185   memset(payload.host_if_name, 0, sizeof(payload.host_if_name));
 186   memcpy(payload.host_if_name, m_name.c_str(),
 187          std::min(m_name.length(), sizeof(payload.host_if_name)));
 188
 189   VAPI_CALL(req.execute());
 190
 191   wait();
 192   m_hw_item.set(rc_t::NOOP);
 193
 194   remove_interface();
 195   return rc_t::OK;
 196 }
 197 std::string
 198 af_packet_delete_cmd::to_string() const
 199 {
 200   std::ostringstream s;
 201   s << "af_packet-itf-delete: " << m_hw_item.to_string();
 202
 203   return (s.str());
 204 }
 205
 206 vhost_delete_cmd::vhost_delete_cmd(HW::item<handle_t>& item,
 207                                    const std::string& name)
 208   : delete_cmd(item, name)
 209 {
 210 }
 211
 212 rc_t
 213 vhost_delete_cmd::issue(connection& con)
 214 {
 215   msg_t req(con.ctx(), std::ref(*this));
 216
 217   auto& payload = req.get_request().get_payload();
 218   payload.sw_if_index = m_hw_item.data().value();
 219
 220   VAPI_CALL(req.execute());
 221
 222   wait();
 223   remove_interface();
 224
 225   return rc_t::OK;
 226 }
 227 std::string
 228 vhost_delete_cmd::to_string() const
 229 {
 230   std::ostringstream s;
 231   s << "vhost-itf-delete: " << m_hw_item.to_string() << " name:" << m_name;
 232
 233   return (s.str());
 234 }
 235
 236 state_change_cmd::state_change_cmd(HW::item<interface::admin_state_t>& state,
 237                                    const HW::item<handle_t>& hdl)
 238   : rpc_cmd(state)
 239   , m_hdl(hdl)
 240 {
 241 }
 242
 243 bool
 244 state_change_cmd::operator==(const state_change_cmd& other) const
 245 {
 246   return ((m_hdl == other.m_hdl) && (m_hw_item == other.m_hw_item));
 247 }
 248
 249 rc_t
 250 state_change_cmd::issue(connection& con)
 251 {
 252   msg_t req(con.ctx(), std::ref(*this));
 253
 254   auto& payload = req.get_request().get_payload();
 255   payload.sw_if_index = m_hdl.data().value();
 256   payload.admin_up_down = m_hw_item.data().value();
 257
 258   VAPI_CALL(req.execute());
 259
 260   return (wait());
 261 }
 262
 263 std::string
 264 state_change_cmd::to_string() const
 265 {
 266   std::ostringstream s;
 267   s << "itf-state-change: " << m_hw_item.to_string()
 268     << " hdl:" << m_hdl.to_string();
 269   return (s.str());
 270 }
 271
 272 set_table_cmd::set_table_cmd(HW::item<route::table_id_t>& table,
 273                              const l3_proto_t& proto,
 274                              const HW::item<handle_t>& hdl)
 275   : rpc_cmd(table)
 276   , m_hdl(hdl)
 277   , m_proto(proto)
 278 {
 279 }
 280
 281 bool
 282 set_table_cmd::operator==(const set_table_cmd& other) const
 283 {
 284   return ((m_hdl == other.m_hdl) && (m_proto == other.m_proto) &&
 285           (m_hw_item == other.m_hw_item));
 286 }
 287
 288 rc_t
 289 set_table_cmd::issue(connection& con)
 290 {
 291   msg_t req(con.ctx(), std::ref(*this));
 292
 293   auto& payload = req.get_request().get_payload();
 294   payload.sw_if_index = m_hdl.data().value();
 295   payload.is_ipv6 = m_proto.is_ipv6();
 296   payload.vrf_id = m_hw_item.data();
 297
 298   VAPI_CALL(req.execute());
 299
 300   return (wait());
 301 }
 302
 303 std::string
 304 set_table_cmd::to_string() const
 305 {
 306   std::ostringstream s;
 307   s << "itf-set-table: " << m_hw_item.to_string()
 308     << " proto:" << m_proto.to_string() << " hdl:" << m_hdl.to_string();
 309   return (s.str());
 310 }
 311
 312 set_mac_cmd::set_mac_cmd(HW::item<l2_address_t>& mac,
 313                          const HW::item<handle_t>& hdl)
 314   : rpc_cmd(mac)
 315   , m_hdl(hdl)
 316 {
 317 }
 318
 319 bool
 320 set_mac_cmd::operator==(const set_mac_cmd& other) const
 321 {
 322   return ((m_hdl == other.m_hdl) && (m_hw_item == other.m_hw_item));
 323 }
 324
 325 rc_t
 326 set_mac_cmd::issue(connection& con)
 327 {
 328   msg_t req(con.ctx(), std::ref(*this));
 329
 330   auto& payload = req.get_request().get_payload();
 331   payload.sw_if_index = m_hdl.data().value();
 332   m_hw_item.data().to_mac().to_bytes(payload.mac_address,
 333                                      sizeof(payload.mac_address));
 334
 335   VAPI_CALL(req.execute());
 336
 337   return (wait());
 338 }
 339
 340 std::string
 341 set_mac_cmd::to_string() const
 342 {
 343   std::ostringstream s;
 344   s << "itf-set-mac: " << m_hw_item.to_string() << " hdl:" << m_hdl.to_string();
 345   return (s.str());
 346 }
 347
 348 collect_detail_stats_change_cmd::collect_detail_stats_change_cmd(
 349   HW::item<interface::stats_type_t>& item,
 350   const handle_t& hdl,
 351   bool enable)
 352   : rpc_cmd(item)
 353   , m_hdl(hdl)
 354   , m_enable(enable)
 355 {
 356 }
 357
 358 bool
 359 collect_detail_stats_change_cmd::operator==(
 360   const collect_detail_stats_change_cmd& other) const
 361 {
 362   return ((m_hdl == other.m_hdl) && (m_hw_item == other.m_hw_item) &&
 363           (m_enable == other.m_enable));
 364 }
 365
 366 rc_t
 367 collect_detail_stats_change_cmd::issue(connection& con)
 368 {
 369   msg_t req(con.ctx(), std::ref(*this));
 370
 371   auto& payload = req.get_request().get_payload();
 372   payload.sw_if_index = m_hdl.value();
 373   payload.enable_disable = m_enable;
 374
 375   VAPI_CALL(req.execute());
 376
 377   return (wait());
 378 }
 379
 380 std::string
 381 collect_detail_stats_change_cmd::to_string() const
 382 {
 383   std::ostringstream s;
 384   s << "itf-stats: " << m_hw_item.to_string() << " hdl:" << m_hdl.to_string();
 385   return (s.str());
 386 }
 387
 388 events_cmd::events_cmd(interface::event_listener& el)
 389   : event_cmd(el.status())
 390   , m_listener(el)
 391 {
 392 }
 393
 394 bool
 395 events_cmd::operator==(const events_cmd& other) const
 396 {
 397   return (true);
 398 }
 399
 400 rc_t
 401 events_cmd::issue(connection& con)
 402 {
 403   /*
 404    * First set the call back to handle the interface events
 405    */
 406   m_reg.reset(new reg_t(con.ctx(), std::ref(*(static_cast<event_cmd*>(this)))));
 407
 408   /*
 409    * then send the request to enable them
 410    */
 411   msg_t req(con.ctx(), std::ref(*(static_cast<rpc_cmd*>(this))));
 412
 413   auto& payload = req.get_request().get_payload();
 414   payload.enable_disable = 1;
 415   payload.pid = getpid();
 416
 417   VAPI_CALL(req.execute());
 418
 419   wait();
 420
 421   return (rc_t::OK);
 422 }
 423
 424 void
 425 events_cmd::retire(connection& con)
 426 {
 427   /*
 428    * disable interface events.
 429    */
 430   msg_t req(con.ctx(), std::ref(*(static_cast<rpc_cmd*>(this))));
 431
 432   auto& payload = req.get_request().get_payload();
 433   payload.enable_disable = 0;
 434   payload.pid = getpid();
 435
 436   VAPI_CALL(req.execute());
 437
 438   wait();
 439 }
 440
 441 void
 442 events_cmd::notify()
 443 {
 444   m_listener.handle_interface_event(this);
 445 }
 446
 447 std::string
 448 events_cmd::to_string() const
 449 {
 450   return ("itf-events");
 451 }
 452
 453 /**
 454  * Interface statistics
 455  */
 456 stats_enable_cmd::stats_enable_cmd(interface::stat_listener& el,
 457                                    const handle_t& handle)
 458   : event_cmd(el.status())
 459   , m_listener(el)
 460   , m_swifindex(handle)
 461 {
 462 }
 463
 464 bool
 465 stats_enable_cmd::operator==(const stats_enable_cmd& other) const
 466 {
 467   return (true);
 468 }
 469
 470 rc_t
 471 stats_enable_cmd::issue(connection& con)
 472 {
 473   /*
 474    * First set the call back to handle the interface stats
 475    */
 476   m_reg.reset(new reg_t(con.ctx(), std::ref(*(static_cast<event_cmd*>(this)))));
 477
 478   /*
 479    * then send the request to enable them
 480    */
 481   msg_t req(con.ctx(), 1, std::ref(*(static_cast<rpc_cmd*>(this))));
 482
 483   auto& payload = req.get_request().get_payload();
 484   payload.enable_disable = 1;
 485   payload.pid = getpid();
 486   payload.num = 1;
 487
 488   payload.sw_ifs[0] = m_swifindex.value();
 489
 490   VAPI_CALL(req.execute());
 491
 492   wait();
 493
 494   return (rc_t::OK);
 495 }
 496
 497 void
 498 stats_enable_cmd::retire(connection& con)
 499 {
 500   /*
 501    * disable interface stats.
 502    */
 503   msg_t req(con.ctx(), 1, std::ref(*(static_cast<rpc_cmd*>(this))));
 504
 505   auto& payload = req.get_request().get_payload();
 506   payload.enable_disable = 0;
 507   payload.pid = getpid();
 508   payload.num = 1;
 509   payload.sw_ifs[0] = m_swifindex.value();
 510
 511   VAPI_CALL(req.execute());
 512
 513   wait();
 514 }
 515
 516 interface::stat_listener&
 517 stats_enable_cmd::listener() const
 518 {
 519   return m_listener;
 520 }
 521
 522 void
 523 stats_enable_cmd::set(const rc_t& rc)
 524 {
 525   m_listener.status().set(rc);
 526 }
 527
 528 void
 529 stats_enable_cmd::notify()
 530 {
 531   m_listener.handle_interface_stat(this);
 532 }
 533
 534 std::string
 535 stats_enable_cmd::to_string() const
 536 {
 537   std::ostringstream s;
 538   s << "itf-stats-enable itf:" << m_swifindex.to_string();
 539   return (s.str());
 540 }
 541
 542 stats_disable_cmd::stats_disable_cmd(const handle_t& handle)
 543   : rpc_cmd(m_res)
 544   , m_swifindex(handle)
 545 {
 546 }
 547
 548 bool
 549 stats_disable_cmd::operator==(const stats_disable_cmd& other) const
 550 {
 551   return (true);
 552 }
 553
 554 rc_t
 555 stats_disable_cmd::issue(connection& con)
 556 {
 557   /*
 558    * then send the request to enable them
 559    */
 560   msg_t req(con.ctx(), 1, std::ref(*this));
 561
 562   auto& payload = req.get_request().get_payload();
 563   payload.enable_disable = 0;
 564   payload.pid = getpid();
 565   payload.num = 1;
 566
 567   payload.sw_ifs[0] = m_swifindex.value();
 568
 569   VAPI_CALL(req.execute());
 570
 571   wait();
 572
 573   return (rc_t::OK);
 574 }
 575
 576 std::string
 577 stats_disable_cmd::to_string() const
 578 {
 579   std::ostringstream s;
 580   s << "itf-stats-disable itf:" << m_swifindex.to_string();
 581   return (s.str());
 582 }
 583
 584 dump_cmd::dump_cmd()
 585 {
 586 }
 587
 588 bool
 589 dump_cmd::operator==(const dump_cmd& other) const
 590 {
 591   return (true);
 592 }
 593
 594 rc_t
 595 dump_cmd::issue(connection& con)
 596 {
 597   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 598
 599   auto& payload = m_dump->get_request().get_payload();
 600   payload.name_filter_valid = 0;
 601
 602   VAPI_CALL(m_dump->execute());
 603
 604   wait();
 605
 606   return rc_t::OK;
 607 }
 608
 609 std::string
 610 dump_cmd::to_string() const
 611 {
 612   return ("itf-dump");
 613 }
 614
 615 vhost_dump_cmd::vhost_dump_cmd()
 616 {
 617 }
 618
 619 bool
 620 vhost_dump_cmd::operator==(const vhost_dump_cmd& other) const
 621 {
 622   return (true);
 623 }
 624
 625 rc_t
 626 vhost_dump_cmd::issue(connection& con)
 627 {
 628   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 629
 630   VAPI_CALL(m_dump->execute());
 631
 632   wait();
 633
 634   return rc_t::OK;
 635 }
 636
 637 std::string
 638 vhost_dump_cmd::to_string() const
 639 {
 640   return ("vhost-itf-dump");
 641 }
 642
 643 bool
 644 af_packet_dump_cmd::operator==(const af_packet_dump_cmd& other) const
 645 {
 646   return (true);
 647 }
 648
 649 rc_t
 650 af_packet_dump_cmd::issue(connection& con)
 651 {
 652   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 653
 654   VAPI_CALL(m_dump->execute());
 655
 656   wait();
 657
 658   return rc_t::OK;
 659 }
 660
 661 std::string
 662 af_packet_dump_cmd::to_string() const
 663 {
 664   return ("af-packet-itf-dump");
 665 }
 666
 667 set_tag::set_tag(HW::item<handle_t>& item, const std::string& name)
 668   : rpc_cmd(item)
 669   , m_name(name)
 670 {
 671 }
 672
 673 rc_t
 674 set_tag::issue(connection& con)
 675 {
 676   msg_t req(con.ctx(), std::ref(*this));
 677
 678   auto& payload = req.get_request().get_payload();
 679   payload.is_add = 1;
 680   payload.sw_if_index = m_hw_item.data().value();
 681   memset(payload.tag, 0, sizeof(payload.tag));
 682   memcpy(payload.tag, m_name.c_str(), m_name.length());
 683
 684   VAPI_CALL(req.execute());
 685
 686   return (wait());
 687 }
 688 std::string
 689 set_tag::to_string() const
 690 {
 691   std::ostringstream s;
 692   s << "itf-set-tag: " << m_hw_item.to_string() << " name:" << m_name;
 693
 694   return (s.str());
 695 }
 696
 697 bool
 698 set_tag::operator==(const set_tag& o) const
 699 {
 700   return ((m_name == o.m_name) && (m_hw_item.data() == o.m_hw_item.data()));
 701 }
 702 }; // namespace interface_cmds
 703 }; // namespace VOM
 704
 705 /*
 706  * fd.io coding-style-patch-verification: ON
 707  *
 708  * Local Variables:
 709  * eval: (c-set-style "mozilla")
 710  * End:
 711  */