src/vpp-api/vom/interface.hpp

   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 #ifndef __VOM_INTERFACE_H__
  17 #define __VOM_INTERFACE_H__
  18
  19 #include "vom/enum_base.hpp"
  20 #include "vom/hw.hpp"
  21 #include "vom/inspect.hpp"
  22 #include "vom/object_base.hpp"
  23 #include "vom/om.hpp"
  24 #include "vom/prefix.hpp"
  25 #include "vom/route_domain.hpp"
  26 #include "vom/rpc_cmd.hpp"
  27 #include "vom/singular_db.hpp"
  28
  29 namespace VOM {
  30 /**
  31  * Forward declaration of the stats and events command
  32  */
  33 namespace interface_cmds {
  34 class stats_cmd;
  35 class events_cmd;
  36 };
  37
  38 /**
  39  * A representation of an interface in VPP
  40  */
  41 class interface : public object_base
  42 {
  43 public:
  44   /**
  45    * The key for interface's key
  46    */
  47   typedef std::string key_t;
  48
  49   /**
  50    * The iterator type
  51    */
  52   typedef singular_db<const std::string, interface>::const_iterator
  53     const_iterator_t;
  54
  55   /**
  56    * An interface type
  57    */
  58   struct type_t : enum_base<type_t>
  59   {
  60     /**
  61      * Unkown type
  62      */
  63     const static type_t UNKNOWN;
  64     /**
  65      * A brideged Virtual interface (aka SVI or IRB)
  66      */
  67     const static type_t BVI;
  68     /**
  69      * VXLAN interface
  70      */
  71     const static type_t VXLAN;
  72     /**
  73      * Ethernet interface type
  74      */
  75     const static type_t ETHERNET;
  76     /**
  77      * AF-Packet interface type
  78      */
  79     const static type_t AFPACKET;
  80     /**
  81      * loopback interface type
  82      */
  83     const static type_t LOOPBACK;
  84     /**
  85      * Local interface type (specific to VPP)
  86      */
  87     const static type_t LOCAL;
  88     /**
  89      * TAP interface type
  90      */
  91     const static type_t TAP;
  92
  93     /**
  94      * Convert VPP's name of the interface to a type
  95      */
  96     static type_t from_string(const std::string& str);
  97
  98   private:
  99     /**
 100      * Private constructor taking the value and the string name
 101      */
 102     type_t(int v, const std::string& s);
 103   };
 104
 105   /**
 106    * The admin state of the interface
 107    */
 108   struct admin_state_t : enum_base<admin_state_t>
 109   {
 110     /**
 111      * Admin DOWN state
 112      */
 113     const static admin_state_t DOWN;
 114     /**
 115      * Admin UP state
 116      */
 117     const static admin_state_t UP;
 118
 119     /**
 120      * Convert VPP's numerical value to enum type
 121      */
 122     static admin_state_t from_int(uint8_t val);
 123
 124   private:
 125     /**
 126      * Private constructor taking the value and the string name
 127      */
 128     admin_state_t(int v, const std::string& s);
 129   };
 130
 131   /**
 132    * The oper state of the interface
 133    */
 134   struct oper_state_t : enum_base<oper_state_t>
 135   {
 136     /**
 137      * Operational DOWN state
 138      */
 139     const static oper_state_t DOWN;
 140     /**
 141      * Operational UP state
 142      */
 143     const static oper_state_t UP;
 144
 145     /**
 146      * Convert VPP's numerical value to enum type
 147      */
 148     static oper_state_t from_int(uint8_t val);
 149
 150   private:
 151     /**
 152      * Private constructor taking the value and the string name
 153      */
 154     oper_state_t(int v, const std::string& s);
 155   };
 156
 157   /**
 158    * Construct a new object matching the desried state
 159    */
 160   interface(const std::string& name, type_t type, admin_state_t state);
 161   /**
 162    * Construct a new object matching the desried state mapped
 163    * to a specific route_domain
 164    */
 165   interface(const std::string& name,
 166             type_t type,
 167             admin_state_t state,
 168             const route_domain& rd);
 169   /**
 170    * Destructor
 171    */
 172   virtual ~interface();
 173
 174   /**
 175    * Copy Constructor
 176    */
 177   interface(const interface& o);
 178
 179   static const_iterator_t cbegin();
 180   static const_iterator_t cend();
 181
 182   /**
 183    * Return the matching'singular' of the interface
 184    */
 185   std::shared_ptr<interface> singular() const;
 186
 187   /**
 188    * convert to string format for debug purposes
 189    */
 190   virtual std::string to_string(void) const;
 191
 192   /**
 193    * Return VPP's handle to this object
 194    */
 195   const handle_t& handle() const;
 196
 197   /**
 198    * Return the interface type
 199    */
 200   const type_t& type() const;
 201
 202   /**
 203    * Return the interface type
 204    */
 205   const std::string& name() const;
 206
 207   /**
 208    * Return the interface type
 209    */
 210   const key_t& key() const;
 211
 212   /**
 213    * Return the L2 Address
 214    */
 215   const l2_address_t& l2_address() const;
 216
 217   /**
 218    * Set the L2 Address
 219    */
 220   void set(const l2_address_t& addr);
 221
 222   /**
 223    * Set the operational state of the interface, as reported by VPP
 224    */
 225   void set(const oper_state_t& state);
 226
 227   /**
 228    * Comparison operator - only used for UT
 229    */
 230   virtual bool operator==(const interface& i) const;
 231
 232   /**
 233    * A base class for interface Create commands
 234    */
 235   template <typename MSG>
 236   class create_cmd : public rpc_cmd<HW::item<handle_t>, HW::item<handle_t>, MSG>
 237   {
 238   public:
 239     create_cmd(HW::item<handle_t>& item, const std::string& name)
 240       : rpc_cmd<HW::item<handle_t>, HW::item<handle_t>, MSG>(item)
 241       , m_name(name)
 242     {
 243     }
 244
 245     /**
 246      * Destructor
 247      */
 248     virtual ~create_cmd() = default;
 249
 250     /**
 251      * Comparison operator - only used for UT
 252      */
 253     virtual bool operator==(const create_cmd& o) const
 254     {
 255       return (m_name == o.m_name);
 256     }
 257
 258     /**
 259      * Indicate the succeeded, when the HW Q is disabled.
 260      */
 261     void succeeded()
 262     {
 263       rpc_cmd<HW::item<handle_t>, HW::item<handle_t>, MSG>::succeeded();
 264       interface::add(m_name, this->item());
 265     }
 266
 267     /**
 268      * add the created interface to the DB
 269      */
 270     void insert_interface() { interface::add(m_name, this->item()); }
 271
 272     virtual vapi_error_e operator()(MSG& reply)
 273     {
 274       int sw_if_index = reply.get_response().get_payload().sw_if_index;
 275       int retval = reply.get_response().get_payload().retval;
 276
 277       VOM_LOG(log_level_t::DEBUG) << this->to_string() << " " << retval;
 278
 279       rc_t rc = rc_t::from_vpp_retval(retval);
 280       handle_t handle = handle_t::INVALID;
 281
 282       if (rc_t::OK == rc) {
 283         handle = sw_if_index;
 284       }
 285
 286       HW::item<handle_t> res(handle, rc);
 287
 288       this->fulfill(res);
 289
 290       return (VAPI_OK);
 291     }
 292
 293   protected:
 294     /**
 295      * The name of the interface to be created
 296      */
 297     const std::string& m_name;
 298   };
 299
 300   /**
 301    * Base class for intterface Delete commands
 302    */
 303   template <typename MSG>
 304   class delete_cmd : public rpc_cmd<HW::item<handle_t>, HW::item<handle_t>, MSG>
 305   {
 306   public:
 307     delete_cmd(HW::item<handle_t>& item, const std::string& name)
 308       : rpc_cmd<HW::item<handle_t>, HW::item<handle_t>, MSG>(item)
 309       , m_name(name)
 310     {
 311     }
 312
 313     delete_cmd(HW::item<handle_t>& item)
 314       : rpc_cmd<HW::item<handle_t>, HW::item<handle_t>, MSG>(item)
 315       , m_name()
 316     {
 317     }
 318
 319     /**
 320      * Destructor
 321      */
 322     virtual ~delete_cmd() = default;
 323
 324     /**
 325      * Comparison operator - only used for UT
 326      */
 327     virtual bool operator==(const delete_cmd& o) const
 328     {
 329       return (this->m_hw_item == o.m_hw_item);
 330     }
 331
 332     /**
 333      * Indicate the succeeded, when the HW Q is disabled.
 334      */
 335     void succeeded() {}
 336
 337     /**
 338      * add the created interface to the DB
 339      */
 340     void remove_interface() { interface::remove(this->item()); }
 341
 342   protected:
 343     /**
 344      * The name of the interface to be created
 345      */
 346     const std::string m_name;
 347   };
 348
 349   /**
 350    * A class that listens to interface Events
 351    */
 352   class event_listener
 353   {
 354   public:
 355     /**
 356      * Default Constructor
 357      */
 358     event_listener();
 359
 360     /**
 361      * Virtual function called on the listener when the command has data
 362      * ready to process
 363      */
 364     virtual void handle_interface_event(interface_cmds::events_cmd* cmd) = 0;
 365
 366     /**
 367      * Return the HW::item representing the status
 368      */
 369     HW::item<bool>& status();
 370
 371   protected:
 372     /**
 373      * The status of the subscription
 374      */
 375     HW::item<bool> m_status;
 376   };
 377
 378   /**
 379    * A class that listens to interface Stats
 380    */
 381   class stat_listener
 382   {
 383   public:
 384     /**
 385      * Default Constructor
 386      */
 387     stat_listener();
 388
 389     /**
 390      * Virtual function called on the listener when the command has data
 391      * ready to process
 392      */
 393     virtual void handle_interface_stat(interface_cmds::stats_cmd* cmd) = 0;
 394
 395     /**
 396      * Return the HW::item representing the status
 397      */
 398     HW::item<bool>& status();
 399
 400   protected:
 401     /**
 402      * The status of the subscription
 403      */
 404     HW::item<bool> m_status;
 405   };
 406
 407   /**
 408    * The the singular instance of the interface in the DB by handle
 409    */
 410   static std::shared_ptr<interface> find(const handle_t& h);
 411
 412   /**
 413    * The the singular instance of the interface in the DB by key
 414    */
 415   static std::shared_ptr<interface> find(const key_t& k);
 416
 417   /**
 418    * Dump all interfaces into the stream provided
 419    */
 420   static void dump(std::ostream& os);
 421
 422   /**
 423    * Enable stats for this interface
 424    */
 425   void enable_stats(stat_listener& el);
 426
 427 protected:
 428   /**
 429    * Construct an interface object with a handle and a HW address
 430    */
 431   interface(const handle_t& handle,
 432             const l2_address_t& l2_address,
 433             const std::string& name,
 434             type_t type,
 435             admin_state_t state);
 436   friend class interface_factory;
 437
 438   /**
 439    * The SW interface handle VPP has asigned to the interface
 440    */
 441   HW::item<handle_t> m_hdl;
 442
 443   /**
 444    * Return the matching 'singular' of the interface
 445    */
 446   virtual std::shared_ptr<interface> singular_i() const;
 447
 448   /**
 449    * release/remove an interface form the singular store
 450    */
 451   void release();
 452
 453   /**
 454    * Virtual functions to construct an interface create commands.
 455    * Overridden in derived classes like the sub_interface
 456    */
 457   virtual std::queue<cmd*>& mk_create_cmd(std::queue<cmd*>& cmds);
 458
 459   /**
 460    * Virtual functions to construct an interface delete commands.
 461    * Overridden in derived classes like the sub_interface
 462    */
 463   virtual std::queue<cmd*>& mk_delete_cmd(std::queue<cmd*>& cmds);
 464
 465   /**
 466    * Sweep/reap the object if still stale
 467    */
 468   virtual void sweep(void);
 469
 470   /**
 471    * A map of all interfaces key against the interface's name
 472    */
 473   static singular_db<key_t, interface> m_db;
 474
 475   /**
 476    * Add an interface to the DB keyed on handle
 477    */
 478   static void add(const key_t& name, const HW::item<handle_t>& item);
 479
 480   /**
 481    * remove an interface from the DB keyed on handle
 482    */
 483   static void remove(const HW::item<handle_t>& item);
 484
 485 private:
 486   /**
 487    * Class definition for listeners to OM events
 488    */
 489   class event_handler : public OM::listener, public inspect::command_handler
 490   {
 491   public:
 492     event_handler();
 493     virtual ~event_handler() = default;
 494
 495     /**
 496      * Handle a populate event
 497      */
 498     void handle_populate(const client_db::key_t& key);
 499
 500     /**
 501      * Handle a replay event
 502      */
 503     void handle_replay();
 504
 505     /**
 506      * Show the object in the Singular DB
 507      */
 508     void show(std::ostream& os);
 509
 510     /**
 511      * Get the sortable Id of the listener
 512      */
 513     dependency_t order() const;
 514   };
 515
 516   static event_handler m_evh;
 517
 518   /**
 519    * enable the interface stats in the singular instance
 520    */
 521   void enable_stats_i(stat_listener& el);
 522
 523   /**
 524    * Commit the acculmulated changes into VPP. i.e. to a 'HW" write.
 525    */
 526   void update(const interface& obj);
 527
 528   /*
 529    * return the interface's handle in the singular instance
 530    */
 531   const handle_t& handle_i() const;
 532
 533   /*
 534    * It's the OM class that calls singular()
 535    */
 536   friend class OM;
 537
 538   /**
 539    * It's the singular_db class that calls replay()
 540    */
 541   friend class singular_db<key_t, interface>;
 542
 543   /**
 544    * The interfaces name
 545    */
 546   const std::string m_name;
 547
 548   /**
 549    * The interface type. clearly this cannot be changed
 550    * once the interface has been created.
 551    */
 552   const type_t m_type;
 553
 554   /**
 555    * shared pointer to the routeDoamin the interface is in.
 556    * NULL is not mapped  - i.e. in the default table
 557    */
 558   std::shared_ptr<route_domain> m_rd;
 559
 560   /**
 561    * shared pointer to the stats object for this interface.
 562    */
 563   std::shared_ptr<interface_cmds::stats_cmd> m_stats;
 564
 565   /**
 566    * The state of the interface
 567    */
 568   HW::item<admin_state_t> m_state;
 569
 570   /**
 571    * HW state of the VPP table mapping
 572    */
 573   HW::item<route::table_id_t> m_table_id;
 574
 575   /**
 576    * HW state of the L2 address
 577    */
 578   HW::item<l2_address_t> m_l2_address;
 579
 580   /**
 581    * Operational state of the interface
 582    */
 583   oper_state_t m_oper;
 584
 585   /**
 586    * A map of all interfaces keyed against VPP's handle
 587    */
 588   static std::map<handle_t, std::weak_ptr<interface>> m_hdl_db;
 589
 590   /**
 591    * replay the object to create it in hardware
 592    */
 593   virtual void replay(void);
 594
 595   /**
 596    * Create commands are firends so they can add interfaces to the
 597    * handle store.
 598    */
 599   template <typename MSG>
 600   friend class create_cmd;
 601
 602   /**
 603    * Create commands are firends so they can remove interfaces from the
 604    * handle store.
 605    */
 606   template <typename MSG>
 607   friend class delete_cmd;
 608 };
 609 };
 610 /*
 611  * fd.io coding-style-patch-verification: ON
 612  *
 613  * Local Variables:
 614  * eval: (c-set-style "mozilla")
 615  * End:
 616  */
 617 #endif