extras/vom/vom/acl_l2_list.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/acl_l2_list.hpp"
  17 #include "vom/acl_list_cmds.hpp"
  18 #include "vom/api_types.hpp"
  19 #include "vom/logger.hpp"
  20 #include "vom/singular_db_funcs.hpp"
  21
  22 namespace VOM {
  23 namespace ACL {
  24
  25 /**
  26  * Definition of the static singular_db for ACL Lists
  27  */
  28 singular_db<l2_list::key_t, l2_list> l2_list::m_db;
  29
  30 /**
  31  * Definition of the static per-handle DB for ACL Lists
  32  */
  33 std::map<handle_t, std::weak_ptr<l2_list>> l2_list::m_hdl_db;
  34
  35 l2_list::event_handler l2_list::m_evh;
  36
  37 l2_list::event_handler::event_handler()
  38 {
  39   OM::register_listener(this);
  40   inspect::register_handler({ "l2-acl-list" }, "L2 ACL lists", this);
  41 }
  42
  43 l2_list::l2_list(const key_t& key)
  44   : m_hdl(handle_t::INVALID)
  45   , m_key(key)
  46 {}
  47
  48 l2_list::l2_list(const handle_t& hdl, const key_t& key)
  49   : m_hdl(hdl)
  50   , m_key(key)
  51 {}
  52
  53 l2_list::l2_list(const key_t& key, const rules_t& rules)
  54   : m_hdl(handle_t::INVALID)
  55   , m_key(key)
  56   , m_rules(rules)
  57 {}
  58
  59 l2_list::l2_list(const l2_list& o)
  60   : m_hdl(o.m_hdl)
  61   , m_key(o.m_key)
  62   , m_rules(o.m_rules)
  63 {}
  64
  65 l2_list::~l2_list()
  66 {
  67   sweep();
  68   m_db.release(m_key, this);
  69 }
  70
  71 std::shared_ptr<l2_list>
  72 l2_list::singular() const
  73 {
  74   return find_or_add(*this);
  75 }
  76
  77 /**
  78  * Dump all ACLs into the stream provided
  79  */
  80 void
  81 l2_list::dump(std::ostream& os)
  82 {
  83   db_dump(m_db, os);
  84 }
  85
  86 /**
  87  * convert to string format for debug purposes
  88  */
  89 std::string
  90 l2_list::to_string() const
  91 {
  92   std::ostringstream s;
  93   s << "acl-list:[" << m_key << " " << m_hdl.to_string() << " rules:[";
  94
  95   for (auto rule : m_rules) {
  96     s << rule.to_string() << " ";
  97   }
  98
  99   s << "]]";
 100
 101   return (s.str());
 102 }
 103
 104 void
 105 l2_list::insert(const l2_rule& rule)
 106 {
 107   m_rules.insert(rule);
 108 }
 109
 110 void
 111 l2_list::remove(const l2_rule& rule)
 112 {
 113   m_rules.erase(rule);
 114 }
 115
 116 const handle_t&
 117 l2_list::handle() const
 118 {
 119   return (singular()->handle_i());
 120 }
 121
 122 std::shared_ptr<l2_list>
 123 l2_list::find(const handle_t& handle)
 124 {
 125   return (m_hdl_db[handle].lock());
 126 }
 127
 128 std::shared_ptr<l2_list>
 129 l2_list::find(const key_t& key)
 130 {
 131   return (m_db.find(key));
 132 }
 133
 134 std::shared_ptr<l2_list>
 135 l2_list::find_or_add(const l2_list& temp)
 136 {
 137   return (m_db.find_or_add(temp.key(), temp));
 138 }
 139
 140 const handle_t&
 141 l2_list::handle_i() const
 142 {
 143   return (m_hdl.data());
 144 }
 145
 146 void
 147 l2_list::add(const key_t& key, const HW::item<handle_t>& item)
 148 {
 149   std::shared_ptr<l2_list> sp = find(key);
 150
 151   if (sp && item) {
 152     m_hdl_db[item.data()] = sp;
 153   }
 154 }
 155
 156 void
 157 l2_list::remove(const HW::item<handle_t>& item)
 158 {
 159   m_hdl_db.erase(item.data());
 160 }
 161
 162 const l2_list::key_t&
 163 l2_list::key() const
 164 {
 165   return m_key;
 166 }
 167
 168 const l2_list::rules_t&
 169 l2_list::rules() const
 170 {
 171   return m_rules;
 172 }
 173
 174 bool
 175 l2_list::operator==(const l2_list& l) const
 176 {
 177   return (key() == l.key() && rules() == l.rules());
 178 }
 179
 180 void
 181 l2_list::event_handler::handle_populate(const client_db::key_t& key)
 182 {
 183   /*
 184    * dump L2 ACLs
 185    */
 186   std::shared_ptr<list_cmds::l2_dump_cmd> cmd =
 187     std::make_shared<list_cmds::l2_dump_cmd>();
 188
 189   HW::enqueue(cmd);
 190   HW::write();
 191
 192   for (auto& record : *cmd) {
 193     auto& payload = record.get_payload();
 194
 195     const handle_t hdl(payload.acl_index);
 196     l2_list acl(hdl, std::string(reinterpret_cast<const char*>(payload.tag)));
 197
 198     for (unsigned int ii = 0; ii < payload.count; ii++) {
 199       const route::prefix_t pfx = from_api(payload.r[ii].src_prefix);
 200       l2_rule rule(ii,
 201                    action_t::from_int(payload.r[ii].is_permit),
 202                    pfx,
 203                    { payload.r[ii].src_mac },
 204                    { payload.r[ii].src_mac_mask });
 205
 206       acl.insert(rule);
 207     }
 208     VOM_LOG(log_level_t::DEBUG) << "dump: " << acl.to_string();
 209
 210     /*
 211      * Write each of the discovered ACLs into the OM,
 212      * but disable the HW Command q whilst we do, so that no
 213      * commands are sent to VPP
 214      */
 215     OM::commit(key, acl);
 216   }
 217 }
 218
 219 void
 220 l2_list::event_handler::show(std::ostream& os)
 221 {
 222   db_dump(m_db, os);
 223 }
 224
 225 dependency_t
 226 l2_list::event_handler::order() const
 227 {
 228   return (dependency_t::ACL);
 229 }
 230
 231 void
 232 l2_list::event_handler::handle_replay()
 233 {
 234   m_db.replay();
 235 }
 236
 237 void
 238 l2_list::update(const l2_list& obj)
 239 {
 240   /*
 241    * always update the instance with the latest rule set
 242    */
 243   if (rc_t::OK != m_hdl.rc() || obj.m_rules != m_rules) {
 244     HW::enqueue(new list_cmds::l2_update_cmd(m_hdl, m_key, m_rules));
 245   }
 246   /*
 247    * We don't, can't, read the priority from VPP,
 248    * so the is equals check above does not include the priorty.
 249    * but we save it now.
 250    */
 251   m_rules = obj.m_rules;
 252 }
 253
 254 void
 255 l2_list::sweep(void)
 256 {
 257   if (m_hdl) {
 258     HW::enqueue(new list_cmds::l2_delete_cmd(m_hdl));
 259   }
 260   HW::write();
 261 }
 262
 263 void
 264 l2_list::replay(void)
 265 {
 266   if (m_hdl) {
 267     m_hdl.data().reset();
 268     HW::enqueue(new list_cmds::l2_update_cmd(m_hdl, m_key, m_rules));
 269   }
 270 }
 271
 272 }; // namespace ACL
 273 }; // namespace VOM
 274
 275 /*
 276  * fd.io coding-style-patch-verification: ON
 277  *
 278  * Local Variables:
 279  * eval: (c-set-style "mozilla")
 280  * End:
 281  */